@nodefony/orm-core 10.0.0-alpha.7 → 10.0.0-alpha.9

package/dist/index.js

@@ -1,8 +1,9 @@
 import { LIKE_ESCAPE_CHAR, OPERATOR_KEYS, UPDATE_OPERATOR_KEYS, escapeLikeTerm, isFieldOperators, isUpdateOperators, likePatternToRegExp, searchCriteria } from "./nodefony/src/criteria.js";
-import { InvalidOrderOption, UnknownCriteriaField } from "./nodefony/src/errors.js";
+import { InvalidOrderOption, ReferencedEntityError, SavepointNotSupportedError, UnknownCriteriaField } from "./nodefony/src/errors.js";
 import { assertOrderOption } from "./nodefony/src/readOptions.js";
 import { OrmRegistry, ormRegistry } from "./nodefony/src/OrmRegistry.js";
 import { EntityRegistry, entityRegistry } from "./nodefony/src/EntityRegistry.js";
+import { reportOrphanEntities } from "./nodefony/src/orphanEntities.js";
 import { connectionMonitor } from "./nodefony/src/ConnectionMonitor.js";
 import { Orm } from "./nodefony/src/Orm.js";
 import { Entity } from "./nodefony/src/Entity.js";
@@ -11,7 +12,7 @@ import { AbstractCrudService } from "./nodefony/src/AbstractCrudService.js";
 import { queryFlowMonitor } from "./nodefony/src/QueryFlowMonitor.js";
 import { buildConnectionHealth, buildOrmFlow, buildOrmGraph, createOrmAdminApi, registerOrmAdminApi, toDbml, toJsonSchema } from "./nodefony/src/OrmAdminApi.js";
 import { buildOrmLeanHealth } from "./nodefony/src/buildOrmLeanHealth.js";
-import { diagnoseConnectionFailure, parseConnectionTarget } from "./nodefony/src/connectionDiagnosis.js";
+import { REJECTED_MARKER, describeConnectFailure, diagnoseConnectionFailure, parseConnectionTarget } from "./nodefony/src/connectionDiagnosis.js";
 import { CONNECT_TIMEOUT_MS, withConnectDeadline } from "./nodefony/src/connectDeadline.js";
 import { reportOrmBootLines, resolveOrmFlowEnabled, wireOrmAdminPlane } from "./nodefony/src/ormWiring.js";
 import { isMigrationFailure } from "./nodefony/interfaces/IOrmMigrations.js";
@@ -21,4 +22,4 @@ import { DEFAULT_CONNECTOR, entities } from "./nodefony/src/decorators/entitiesD
 import { repository } from "./nodefony/src/decorators/repositoryDecorator.js";
 import "./nodefony/src/decorators/index.js";
 import { defineEntity } from "./nodefony/src/defineEntity.js";
-export { AbstractCrudService, CONNECT_TIMEOUT_MS, DEFAULT_CONNECTOR, Entity, EntityRegistry, InvalidOrderOption, LIKE_ESCAPE_CHAR, OPERATOR_KEYS, Orm, OrmRegistry, UPDATE_OPERATOR_KEYS, UnknownCriteriaField, assertOrderOption, buildConnectionHealth, buildOrmFlow, buildOrmGraph, buildOrmLeanHealth, connectionMonitor, createOrmAdminApi, defineEntity, diagnoseConnectionFailure, entities, entity, entityRegistry, escapeLikeTerm, getEntityMeta, getRepositoryMeta, hasEntityMeta, hasRepositoryMeta, isFieldOperators, isMigrationFailure, isUpdateOperators, likePatternToRegExp, ormRegistry, paginate, parseConnectionTarget, queryFlowMonitor, registerOrmAdminApi, reportOrmBootLines, repository, resolveOrmFlowEnabled, searchCriteria, toDbml, toJsonSchema, wireOrmAdminPlane, withConnectDeadline };
+export { AbstractCrudService, CONNECT_TIMEOUT_MS, DEFAULT_CONNECTOR, Entity, EntityRegistry, InvalidOrderOption, LIKE_ESCAPE_CHAR, OPERATOR_KEYS, Orm, OrmRegistry, REJECTED_MARKER, ReferencedEntityError, SavepointNotSupportedError, UPDATE_OPERATOR_KEYS, UnknownCriteriaField, assertOrderOption, buildConnectionHealth, buildOrmFlow, buildOrmGraph, buildOrmLeanHealth, connectionMonitor, createOrmAdminApi, defineEntity, describeConnectFailure, diagnoseConnectionFailure, entities, entity, entityRegistry, escapeLikeTerm, getEntityMeta, getRepositoryMeta, hasEntityMeta, hasRepositoryMeta, isFieldOperators, isMigrationFailure, isUpdateOperators, likePatternToRegExp, ormRegistry, paginate, parseConnectionTarget, queryFlowMonitor, registerOrmAdminApi, reportOrmBootLines, reportOrphanEntities, repository, resolveOrmFlowEnabled, searchCriteria, toDbml, toJsonSchema, wireOrmAdminPlane, withConnectDeadline };

package/dist/nodefony/src/ConnectionMonitor.js

@@ -1,6 +1,8 @@
 //#region nodefony/src/ConnectionMonitor.ts
 /** Taille max du ring d'erreurs récentes (borne mémoire). */
 const MAX_RECENT_ERRORS = 12;
+/** Taille max de la chronologie pertes/reprises (borne mémoire). */
+const MAX_EVENTS = 20;
 /** Taille de la fenêtre glissante de latence (min/moy/max). */
 const MAX_LATENCY_SAMPLES = 30;
 /** Fenêtre de latence vide. */
@@ -18,6 +20,9 @@ const EMPTY_CORE = {
 	connectCount: 0,
 	reconnectCount: 0,
 	lostCount: 0,
+	lastLostAt: null,
+	lastRestoredAt: null,
+	events: [],
 	errorCount: 0,
 	lastConnectMs: null,
 	lastError: null,
@@ -54,6 +59,9 @@ var ConnectionMonitor = class {
 				connectCount: 0,
 				reconnectCount: 0,
 				lostCount: 0,
+				lastLostAt: null,
+				lastRestoredAt: null,
+				events: null,
 				errorCount: 0,
 				lastConnectMs: null,
 				lastError: null,
@@ -99,11 +107,19 @@ var ConnectionMonitor = class {
 	* preuve de bonne santé.
 	*
 	* @param name - clé du connecteur.
+	* @param reason - cause lisible (credential déjà retiré), si connue.
 	*/
-	recordLost(name) {
+	recordLost(name, reason) {
 		const s = this.#ensure(name);
+		const ts = Date.now();
 		s.lostCount += 1;
 		s.connectedSince = null;
+		s.lastLostAt = ts;
+		this.#pushEvent(s, {
+			kind: "lost",
+			ts,
+			reason
+		});
 	}
 	/**
 	* Enregistre une **reprise** de connexion constatée par l'adapter.
@@ -112,8 +128,20 @@ var ConnectionMonitor = class {
 	*/
 	recordReconnect(name) {
 		const s = this.#ensure(name);
+		const ts = Date.now();
 		s.reconnectCount += 1;
-		s.connectedSince = Date.now();
+		s.connectedSince = ts;
+		s.lastRestoredAt = ts;
+		this.#pushEvent(s, {
+			kind: "restored",
+			ts
+		});
+	}
+	/** Ajoute un événement en tête de la chronologie (allouée au 1ᵉʳ, bornée). */
+	#pushEvent(s, e) {
+		if (s.events === null) s.events = [];
+		s.events.unshift(e);
+		if (s.events.length > MAX_EVENTS) s.events.length = MAX_EVENTS;
 	}
 	/**
 	* Enregistre une erreur (connexion échouée ou ping en échec).
@@ -167,6 +195,9 @@ var ConnectionMonitor = class {
 			connectCount: s.connectCount,
 			reconnectCount: s.reconnectCount,
 			lostCount: s.lostCount,
+			lastLostAt: s.lastLostAt,
+			lastRestoredAt: s.lastRestoredAt,
+			events: s.events ?? [],
 			errorCount: s.errorCount,
 			lastConnectMs: s.lastConnectMs,
 			lastError: s.lastError,

package/dist/nodefony/src/Orm.js

@@ -126,7 +126,7 @@ var Orm = class extends Service {
 		if (!this.alive) return;
 		this.alive = false;
 		this.#lostPending = true;
-		connectionMonitor.recordLost(this.name);
+		connectionMonitor.recordLost(this.name, reason);
 		this.log(`connexion perdue : ${reason}`, "WARNING");
 		this.fire("onOrmLost", this, reason);
 	}
@@ -197,6 +197,22 @@ var Orm = class extends Service {
 		timer.unref?.();
 		this.#heartbeat = timer;
 	}
+	/**
+	* Décrit le mécanisme de résilience TEL QU'IL TOURNE — lecture pure, pour
+	* le data plane (`connection/health`) : période et montre du battement,
+	* battement actif ou non, perte en souffrance.
+	*
+	* @returns l'état du mécanisme dans ce process.
+	*/
+	describeResilience() {
+		return {
+			heartbeatMs: this.heartbeatMs,
+			heartbeatTimeoutMs: this.heartbeatTimeoutMs,
+			heartbeatActive: this.#heartbeat !== null,
+			pingable: typeof this.ping === "function",
+			lostPending: this.#lostPending
+		};
+	}
 	/** Arrête le battement et libère la minuterie. Idempotent. */
 	stopHeartbeat() {
 		if (this.#heartbeat !== null) {

package/dist/nodefony/src/OrmAdminApi.js

@@ -2,6 +2,7 @@ import { ormRegistry } from "./OrmRegistry.js";
 import { entityRegistry } from "./EntityRegistry.js";
 import { connectionMonitor } from "./ConnectionMonitor.js";
 import { queryFlowMonitor } from "./QueryFlowMonitor.js";
+import { Nodefony } from "nodefony";
 import { performance } from "node:perf_hooks";
 //#region nodefony/src/OrmAdminApi.ts
 /**
@@ -76,9 +77,38 @@ async function migrationCapability(request, capability, missingMessage) {
 	return fn.call(orm);
 }
 /** Résumé des ORM enregistrés (statut connexion + nombre d'entités). */
+/**
+* Connecteur qui porte les stores de l'application — le connecteur PAR DÉFAUT.
+*
+* « Défaut » est un RÔLE, pas un nom : sur une infra MongoDB les briques
+* durables vivent sur `nodefony` (Mongoose), et marquer `default` (Drizzle)
+* parce qu'il s'appelle ainsi désignait une base que personne n'utilise. Le
+* rôle se CONSTATE dans le registre des stores (#474) : le connecteur qui porte
+* le plus de briques durables, puis de briques tout court.
+*
+* @param resolutions - registre des stores du kernel (`storeResolutions`).
+* @param names - connecteurs enregistrés ; une brique sur un autre nom est ignorée.
+* @returns le nom du connecteur, ou `null` si aucune brique n'est portée par
+*   un ORM (le repli sur le nom `default` s'applique alors).
+*/
+function storeCarrier(resolutions, names) {
+	const score = /* @__PURE__ */ new Map();
+	for (const r of resolutions) {
+		if (!r.connector || !names.includes(r.connector)) continue;
+		score.set(r.connector, (score.get(r.connector) ?? 0) + (r.nature === "durable" ? 1e3 : 1));
+	}
+	let best = null;
+	for (const name of names) {
+		const s = score.get(name) ?? 0;
+		if (s > 0 && (best === null || s > (score.get(best) ?? 0))) best = name;
+	}
+	return best;
+}
 function buildOrmSummaries() {
 	const entities = entityRegistry.list();
-	return ormRegistry.list().map((name) => {
+	const names = ormRegistry.list();
+	const carrier = storeCarrier(Nodefony.getKernel()?.storeResolutions ?? [], names);
+	return names.map((name) => {
 		let connected = false;
 		let vendor = "";
 		let connection;
@@ -93,7 +123,7 @@ function buildOrmSummaries() {
 		return {
 			name,
 			vendor,
-			default: name === "default",
+			default: carrier === null ? name === "default" : name === carrier,
 			connected,
 			entityCount: entities.filter((e) => e.connector === name).length,
 			connection
@@ -162,8 +192,10 @@ async function buildConnectionHealth(filter) {
 		let storage;
 		let pool;
 		let extra;
+		let resilience;
 		try {
 			const inst = ormRegistry.get(name);
+			resilience = inst.describeResilience?.();
 			connected = inst.isConnected();
 			vendor = vendorOf(inst);
 			const c = inst.describeConnection?.();
@@ -211,6 +243,11 @@ async function buildConnectionHealth(filter) {
 			uptimeMs: core.uptimeMs,
 			connectCount: core.connectCount,
 			reconnectCount: core.reconnectCount,
+			lostCount: core.lostCount,
+			lastLostAt: core.lastLostAt,
+			lastRestoredAt: core.lastRestoredAt,
+			events: core.events,
+			resilience,
 			errorCount: core.errorCount,
 			lastError: core.lastError,
 			recentErrors: core.recentErrors,
@@ -409,16 +446,21 @@ function createOrmAdminApi() {
 		},
 		{
 			path: "counts",
-			summary: "Nombre de lignes par entité (COUNT(*)) — ?connector= pour filtrer. Lazy : 1 COUNT par table.",
+			summary: "Nombre de lignes par entité (COUNT(*)) — ?connector= pour filtrer. Lazy : 1 COUNT par table. Clé = nom de l'entité, qualifiée `connecteur:nom` quand plusieurs connecteurs portent ce nom.",
 			handler: async (request) => {
 				const connector = oneParam(request, "connector");
 				const counts = {};
 				const entities = entityRegistry.list().filter((e) => !connector || e.connector === connector);
-				for (const e of entities) try {
-					const inst = ormRegistry.get(e.connector);
-					counts[e.name] = inst.isConnected() ? await inst.getRepository(e.name).count() : -1;
-				} catch {
-					counts[e.name] = -1;
+				const homonyms = /* @__PURE__ */ new Map();
+				for (const e of entities) homonyms.set(e.name, (homonyms.get(e.name) ?? 0) + 1);
+				for (const e of entities) {
+					const key = (homonyms.get(e.name) ?? 0) > 1 ? `${e.connector}:${e.name}` : e.name;
+					try {
+						const inst = ormRegistry.get(e.connector);
+						counts[key] = inst.isConnected() ? await inst.getRepository(e.name).count() : -1;
+					} catch {
+						counts[key] = -1;
+					}
 				}
 				return counts;
 			}
@@ -488,4 +530,4 @@ function registerOrmAdminApi(registry) {
 	registry.register(createOrmAdminApi());
 }
 //#endregion
-export { buildConnectionHealth, buildOrmFlow, buildOrmGraph, createOrmAdminApi, registerOrmAdminApi, toDbml, toJsonSchema };
+export { buildConnectionHealth, buildOrmFlow, buildOrmGraph, createOrmAdminApi, registerOrmAdminApi, storeCarrier, toDbml, toJsonSchema };

package/dist/nodefony/src/connectionDiagnosis.js

@@ -31,15 +31,41 @@ const ANSWERED_CODES = /* @__PURE__ */ new Set([
 	"AuthenticationFailed",
 	"Unauthorized"
 ]);
+/**
+* Classes SQLSTATE (PostgreSQL) qui décrivent la CONNEXION elle-même, pas une
+* instruction : `08` exception de connexion, `57` intervention de l'opérateur
+* (arrêt, base qui démarre). Tout autre SQLSTATE est rendu par un serveur à qui
+* l'on parlait déjà.
+*/
+const CONNECTION_SQLSTATE_CLASSES = /* @__PURE__ */ new Set(["08", "57"]);
+/**
+* Refus MySQL/MariaDB émis PENDANT l'établissement : le serveur n'a encore
+* exécuté aucune instruction. Tout autre `ER_*` vient d'un serveur connecté.
+*/
+const MYSQL_CONNECTION_PHASE = /* @__PURE__ */ new Set([
+	"ER_CON_COUNT_ERROR",
+	"ER_TOO_MANY_USER_CONNECTIONS",
+	"ER_HOST_IS_BLOCKED",
+	"ER_SERVER_SHUTDOWN"
+]);
+/**
+* Le code prouve-t-il que la connexion avait ABOUTI quand le refus est tombé ?
+*
+* Ce n'est vrai que d'un code produit par le SERVEUR en réponse à une
+* instruction : un SQLSTATE PostgreSQL hors des classes de connexion, ou un
+* `ER_*` MySQL hors de la phase d'établissement. Les codes de refus connus
+* ({@link ANSWERED_CODES}) sont tranchés AVANT.
+*/
+function provesEstablished(code) {
+	if (/^[0-9A-Z]{5}$/.test(code) && /[0-9]/.test(code)) return !CONNECTION_SQLSTATE_CLASSES.has(code.slice(0, 2));
+	return code.startsWith("ER_") && !MYSQL_CONNECTION_PHASE.has(code);
+}
 /** Lit le code que le driver a posé sur l'erreur, sans rien supposer de sa forme. */
 function readCode(error) {
 	if (typeof error !== "object" || error === null) return null;
 	const carrier = error;
-	for (const raw of [carrier.code, carrier.codeName]) {
-		if (typeof raw === "string" && raw.length > 0) return raw;
-		if (typeof raw === "number") return String(raw);
-	}
-	return null;
+	for (const raw of [carrier.code, carrier.codeName]) if (typeof raw === "string" && raw.length > 0) return raw;
+	return typeof carrier.code === "number" ? String(carrier.code) : null;
 }
 /**
 * Extrait l'hôte et le port d'une URL de connexion, sans son secret.
@@ -102,11 +128,45 @@ function diagnoseConnectionFailure(error, target = {
 		code,
 		explanation: `un serveur a RÉPONDU sur ${where} puis a refusé (${code}) — donc quelque chose tient bien ce port. Ce peut être la base attendue avec de mauvais identifiants, mais aussi UN AUTRE SERVEUR (le conteneur d'un autre projet, par exemple) : le refus vient alors d'une base qui n'est pas la vôtre, et vérifier les identifiants ne mène nulle part.${target.port !== null ? ` Pour savoir qui tient ce port : « docker ps --filter publish=${target.port} », ou « ${whoHoldsPort(target.port, platform)} ».` : ""}`
 	};
+	if (code !== null && provesEstablished(code)) return {
+		verdict: "rejected",
+		code,
+		explanation: `la connexion à ${where} a ABOUTI, puis le serveur a refusé une instruction (${code}) — ce n'est ni l'adresse ni l'état de la base : c'est le schéma envoyé (une table, une contrainte, un type) qu'il faut corriger.`
+	};
 	return {
 		verdict: "unknown",
 		code,
 		explanation: `échec de connexion à ${where}${code ? ` (${code})` : ""} — vérifier que l'infrastructure déclarée (NF_DATABASE_URL / connectors) désigne bien la base attendue, et qu'elle est démarrée.`
 	};
 }
+/**
+* Marqueur de la phrase « connecté, puis refusé » — lu par `create app`
+* (`migrationFailureCause`, cœur) pour NE PAS conclure à une base injoignable.
+* Le cœur ne peut pas importer ce paquet : sa copie est éprouvée contre
+* celle-ci par un test de parité.
+*/
+const REJECTED_MARKER = "s'est connecté, mais le serveur a refusé une instruction — ";
+/**
+* Compose le message d'échec au démarrage d'un connecteur — UNE rédaction pour
+* tous les adapters.
+*
+* 🔴 Un refus d'instruction (verdict `rejected`) ne commence JAMAIS par « n'a
+* pas pu se connecter » : c'était faux, et la phrase envoyait vérifier
+* l'adresse et l'état d'une base qui répondait très bien. La cause du pilote
+* passe alors EN TÊTE — c'est elle qui nomme la table ou la contrainte.
+*
+* @param subject - sujet de la phrase (`Drizzle : le connecteur "x" (…)`).
+* @param diagnosis - verdict de {@link diagnoseConnectionFailure}.
+* @param cause - message brut du pilote.
+* @param advice - conseil propre à l'adapter, pour un échec de CONNEXION.
+* @returns le message complet.
+*/
+function describeConnectFailure(subject, diagnosis, cause, advice = "") {
+	if (diagnosis.verdict === "rejected") {
+		const explanation = diagnosis.explanation.charAt(0).toUpperCase() + diagnosis.explanation.slice(1);
+		return `${subject} ${REJECTED_MARKER}${cause}${diagnosis.code ? ` (${diagnosis.code})` : ""}. ${explanation}`;
+	}
+	return `${subject} n'a pas pu se connecter — ${diagnosis.explanation}${advice} Cause : ${cause}`;
+}
 //#endregion
-export { diagnoseConnectionFailure, parseConnectionTarget };
+export { REJECTED_MARKER, describeConnectFailure, diagnoseConnectionFailure, parseConnectionTarget };

package/dist/nodefony/src/errors.js

@@ -72,5 +72,63 @@ var InvalidOrderOption = class extends Error {
 		this.received = received;
 	}
 };
+/**
+* Levée quand une suppression viserait une entité encore RÉFÉRENCÉE par une
+* relation obligatoire d'une autre entité.
+*
+* C'est le pendant, pour un moteur sans clé étrangère (MongoDB), du `restrict`
+* que le SQL généré pose sur une colonne de référence obligatoire : le parent
+* ne part pas tant qu'un enfant le désigne. Sans cette garde, la suppression
+* passait et `?include=` rendait ensuite `null` à la place du parent — une
+* application passée du SQL à MongoDB perdait en silence une garantie qu'elle
+* croyait avoir.
+*
+* Erreur de DONNÉES : c'est la surface API qui la projette (le rendu d'erreur
+* HTTP la reconnaît par son `name` et répond 409).
+*/
+var ReferencedEntityError = class extends Error {
+	/** Entité dont la suppression est refusée (nom logique). */
+	entity;
+	/** Entité qui la référence encore (nom logique). */
+	referencedBy;
+	/** Champ de référence de {@link ReferencedEntityError.referencedBy}. */
+	field;
+	/**
+	* @param entity - entité dont la suppression est refusée.
+	* @param referencedBy - entité qui la référence encore.
+	* @param field - champ de référence obligatoire qui la désigne.
+	*/
+	constructor(entity, referencedBy, field) {
+		super(`Cannot delete "${entity}": still referenced by "${referencedBy}.${field}" (required reference). Delete or reassign the "${referencedBy}" entries first.`);
+		this.name = "ReferencedEntityError";
+		this.entity = entity;
+		this.referencedBy = referencedBy;
+		this.field = field;
+	}
+};
+/**
+* Levée par `ITransaction.savepoint()` / `rollbackTo()` sur un moteur qui ne porte
+* PAS de savepoints (MongoDB).
+*
+* Refuser vaut mieux que se taire : un `rollbackTo()` rendu en no-op laissait
+* l'appelant croire ses écritures annulées alors qu'elles restaient en base. Le
+* refus tombe dès `savepoint()`, pas au `rollbackTo()` : le chemin d'erreur, où
+* l'on annule, est celui qu'on teste le moins — la faute doit se voir au premier
+* essai. Pour annuler, terminer la transaction entière (`rollback()`, ou laisser
+* le callback de `IOrm.transaction()` lever).
+*/
+var SavepointNotSupportedError = class extends Error {
+	/** Moteur qui refuse (valeur de `describeConnection().driver`). */
+	driver;
+	/**
+	* @param driver - moteur qui ne porte pas de savepoints.
+	* @param operation - opération refusée (`savepoint` ou `rollbackTo`).
+	*/
+	constructor(driver, operation) {
+		super(`${operation}() is not supported by the "${driver}" driver: it has no savepoints. Roll back the whole transaction instead (rollback(), or throw from the transaction callback).`);
+		this.name = "SavepointNotSupportedError";
+		this.driver = driver;
+	}
+};
 //#endregion
-export { InvalidOrderOption, UnknownCriteriaField };
+export { InvalidOrderOption, ReferencedEntityError, SavepointNotSupportedError, UnknownCriteriaField };

package/dist/nodefony/src/orphanEntities.js

@@ -0,0 +1,63 @@
+import { ormRegistry } from "./OrmRegistry.js";
+import { entityRegistry } from "./EntityRegistry.js";
+//#region nodefony/src/orphanEntities.ts
+/**
+* Entités inscrites sur un connecteur qu'aucun ORM n'a ouvert.
+*
+* Une telle entité ne sera servie par rien : son dépôt lèvera au premier
+* appel, loin de sa cause. Vécu : sur une infra MongoDB, le `User` d'une
+* application restait écrit en table SQL sur `default` — un connecteur que
+* Drizzle n'ouvre pas sur cette infra — et le boot n'en disait RIEN.
+*
+* @param entities - entités inscrites (registre des entités).
+* @param connectors - connecteurs ouverts (registre des ORM).
+* @returns les orphelines, dans l'ordre d'inscription.
+*/
+function findOrphanEntities(entities, connectors) {
+	return entities.filter((e) => !connectors.includes(e.connector));
+}
+/**
+* La phrase qui NOMME les orphelines et le remède — `null` s'il n'y en a pas.
+*
+* @param orphans - entités sans connecteur ouvert.
+* @param connectors - connecteurs ouverts, cités pour situer la faute.
+* @param declared - connecteurs DÉCLARÉS par les modules ORM (leur configuration).
+*/
+function describeOrphanEntities(orphans, connectors, declared = []) {
+	if (orphans.length === 0) return null;
+	const name = (e) => `${e.name}${e.module ? `@${e.module}` : ""} → « ${e.connector} »`;
+	const open = `Connecteurs ouverts : ${connectors.length > 0 ? connectors.join(", ") : "aucun"}.`;
+	const skipped = orphans.filter((e) => declared.includes(e.connector));
+	const unknown = orphans.filter((e) => !declared.includes(e.connector));
+	const parts = [];
+	if (unknown.length > 0) parts.push(`${unknown.length} entité(s) inscrite(s) sur un connecteur qu'aucun ORM n'a ouvert — rien ne les servira, leur dépôt lèvera au premier appel : ${unknown.map(name).join(", ")}. ${open} Une entité doit suivre la base déclarée (NF_DATABASE_URL) : table SQL sur une infra SQL, document sur MongoDB. État réel : npx nodefony inspect entities.`);
+	if (skipped.length > 0) parts.push(`${skipped.length} entité(s) sur un connecteur DÉCLARÉ mais jamais ouvert : ${skipped.map(name).join(", ")}. Ce n'est pas leur déclaration qui est en cause : un connecteur a échoué au démarrage (voir l'erreur de connexion plus haut), et ceux qui le suivent n'ont pas été ouverts. ${open}`);
+	return parts.join(" ");
+}
+/** Les démarrages déjà rapportés — un Kernel ne le dit qu'une fois. */
+const reported = /* @__PURE__ */ new WeakSet();
+/**
+* Signale UNE fois par démarrage les entités orphelines, au moment où tous les
+* ORM sont ouverts.
+*
+* Appelée par chaque module ORM (Drizzle, Mongoose) à `onReady` : la règle vit
+* ici, une fois, et le premier appel la rend — le second se tait, sans quoi une
+* application qui charge les deux ORM lirait deux fois le même avertissement.
+* La garde porte sur le KERNEL et non sur le process : un process qui démarre
+* plusieurs noyaux (une suite de tests) doit être prévenu à chacun.
+*
+* @param log - journal du module appelant.
+* @param owner - le démarrage concerné (le Kernel), clé de la garde.
+* @param declared - connecteurs que l'appelant a DÉCLARÉS (sa configuration).
+* @returns le message rendu, ou `null` (rien à dire, ou déjà dit).
+*/
+function reportOrphanEntities(log, owner, declared = []) {
+	if (reported.has(owner)) return null;
+	reported.add(owner);
+	const connectors = ormRegistry.list();
+	const message = describeOrphanEntities(findOrphanEntities(entityRegistry.list(), connectors), connectors, declared);
+	if (message !== null) log(message, "WARNING");
+	return message;
+}
+//#endregion
+export { describeOrphanEntities, findOrphanEntities, reportOrphanEntities };

package/dist/types/index.d.ts

@@ -7,15 +7,16 @@
  * Module, pas d'enregistrement dans `@modules()`. Les drivers concrets sont les
  * Modules ; ils s'enregistrent eux-mêmes dans le `OrmRegistry` à leur boot.
  */
-export type { IOrm, IEntity, IEntityRelation, IRepository, OrmCriteria, Criteria, FieldCriteria, FieldOperators, UpdateData, UpdateOperators, RepositoryReadOptions, ITransaction, IPage, IPageQuery, PageQuery, } from "./nodefony/interfaces/index.js";
+export type { IOrm, IEntity, IEntityIndex, IEntityRelation, IRepository, OrmCriteria, Criteria, FieldCriteria, FieldOperators, UpdateData, UpdateOperators, RepositoryReadOptions, ITransaction, IPage, IPageQuery, PageQuery, } from "./nodefony/interfaces/index.js";
 export { OPERATOR_KEYS, isFieldOperators, searchCriteria, LIKE_ESCAPE_CHAR, escapeLikeTerm, likePatternToRegExp, } from "./nodefony/src/criteria.js";
 export type { OperatorKey } from "./nodefony/src/criteria.js";
 export { UPDATE_OPERATOR_KEYS, isUpdateOperators, } from "./nodefony/src/criteria.js";
 export type { UpdateOperatorKey } from "./nodefony/src/criteria.js";
-export { UnknownCriteriaField, InvalidOrderOption, } from "./nodefony/src/errors.js";
+export { UnknownCriteriaField, InvalidOrderOption, ReferencedEntityError, SavepointNotSupportedError, } from "./nodefony/src/errors.js";
 export { assertOrderOption } from "./nodefony/src/readOptions.js";
 export { OrmRegistry, ormRegistry } from "./nodefony/src/OrmRegistry.js";
 export { EntityRegistry, entityRegistry } from "./nodefony/src/EntityRegistry.js";
+export { reportOrphanEntities } from "./nodefony/src/orphanEntities.js";
 export { Orm } from "./nodefony/src/Orm.js";
 export { Entity } from "./nodefony/src/Entity.js";
 export { AbstractCrudService } from "./nodefony/src/AbstractCrudService.js";
@@ -25,12 +26,12 @@ export { buildOrmGraph, buildConnectionHealth, buildOrmFlow, toDbml, toJsonSchem
 export { queryFlowMonitor } from "./nodefony/src/QueryFlowMonitor.js";
 export { connectionMonitor } from "./nodefony/src/ConnectionMonitor.js";
 export { buildOrmLeanHealth } from "./nodefony/src/buildOrmLeanHealth.js";
-export { diagnoseConnectionFailure, parseConnectionTarget, } from "./nodefony/src/connectionDiagnosis.js";
+export { diagnoseConnectionFailure, describeConnectFailure, parseConnectionTarget, REJECTED_MARKER, } from "./nodefony/src/connectionDiagnosis.js";
 export type { ConnectionVerdict, IConnectionDiagnosis, IConnectionTarget, } from "./nodefony/src/connectionDiagnosis.js";
 export { CONNECT_TIMEOUT_MS, withConnectDeadline, } from "./nodefony/src/connectDeadline.js";
 export { wireOrmAdminPlane, resolveOrmFlowEnabled, reportOrmBootLines, } from "./nodefony/src/ormWiring.js";
 export type { ISlowQuery, IQueryFlow, IOrmFlowReport, } from "./nodefony/interfaces/IOrmFlow.js";
-export type { IColumnInfo, IConnectionInfo, IRelationInfo, IEntityGraphNode, IOrmSummary, IOrmGraph, IConnectionError, IConnectionHealth, } from "./nodefony/interfaces/IOrmGraph.js";
+export type { IColumnInfo, IConnectionInfo, IRelationInfo, IEntityGraphNode, IOrmSummary, IOrmGraph, IConnectionError, IConnectionEvent, IOrmResilience, IConnectionHealth, } from "./nodefony/interfaces/IOrmGraph.js";
 export type { ILatencyWindow, IOrmStorageProbe, IOrmPoolProbe, IOrmProbe, } from "./nodefony/interfaces/IOrmProbe.js";
 export type { IOrmMigrationAction, IOrmMigrationEntry, IOrmMigrationSource, IOrmMigrationStatus, IOrmMigrationFailure, IOrmMigrationReply, IOrmPendingMigration, IOrmMigrationPlan, IOrmMigrationPlanReply, IOrmMigrationApplied, IOrmMigrationApplyReply, } from "./nodefony/interfaces/IOrmMigrations.js";
 export { isMigrationFailure } from "./nodefony/interfaces/IOrmMigrations.js";

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

@@ -30,6 +30,19 @@ export interface IEntityRelation {
  * @typeParam S - type du schéma natif du driver.
  * @typeParam M - type du modèle compilé natif du driver.
  */
+/**
+ * Index COMPOSITE déclaré par une entité, pour l'adapter qui ne sait pas
+ * l'exprimer dans son schéma (Mongoose : un `SchemaDefinition` plat n'a d'index
+ * que par champ).
+ */
+export interface IEntityIndex {
+    /** Champs et sens, dans l'ORDRE de l'index (`1` croissant, `-1` décroissant). */
+    readonly fields: Readonly<Record<string, 1 | -1>>;
+    /** Contrainte d'unicité sur la combinaison. */
+    readonly unique?: boolean;
+    /** Nom de l'index en base (sinon celui que le driver dérive des champs). */
+    readonly name?: string;
+}
 export interface IEntity<S = unknown, M = unknown> {
     /** Nom logique de l'entité (clé de lookup, ex. `"User"`). */
     readonly name: string;
@@ -62,4 +75,10 @@ export interface IEntity<S = unknown, M = unknown> {
     readonly timestamps?: boolean;
     /** Relations déclarées vers d'autres entités (par nom logique). */
     readonly relations?: ReadonlyArray<IEntityRelation>;
+    /**
+     * Index composites, appliqués par l'adapter qui les exprime hors schéma
+     * (Mongoose `schema.index()`). Les ORM schema-as-code (Drizzle) les déclarent
+     * dans leur table → ce champ y est sans effet. **Optionnel**.
+     */
+    readonly indexes?: ReadonlyArray<IEntityIndex>;
 }

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

@@ -1,6 +1,6 @@
 import type { IRepository } from "./IRepository.js";
 import type { ITransaction } from "./ITransaction.js";
-import type { IColumnInfo, IConnectionInfo } from "./IOrmGraph.js";
+import type { IOrmResilience, IColumnInfo, IConnectionInfo } from "./IOrmGraph.js";
 import type { IOrmProbe } from "./IOrmProbe.js";
 import type { IOrmMigrationApplyReply, IOrmMigrationPlanReply, IOrmMigrationReply } from "./IOrmMigrations.js";
 /**
@@ -73,6 +73,15 @@ export interface IOrm {
      * @returns infos de connexion, ou `undefined` si non implémenté.
      */
     describeConnection?(): IConnectionInfo;
+    /**
+     * Décrit le mécanisme de résilience tel qu'il tourne (battement, perte en
+     * souffrance) pour le data plane. **Optionnel** : la classe `Orm` l'implémente
+     * pour tous ses adapters ; un ORM qui ne dérive pas d'elle laisse le
+     * diagnostic sans cette section.
+     *
+     * @returns l'état du mécanisme.
+     */
+    describeResilience?(): IOrmResilience;
     /**
      * Ping bas-coût de la connexion (round-trip réel vers la base) pour le
      * diagnostic du data plane. **Optionnel** : un adapter qui ne l'implémente pas

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

@@ -82,7 +82,11 @@ export interface IOrmSummary {
      * `IOrm.vendor` déclaré par chaque adapter (P7.1 industrialisation ORM).
      */
     vendor: string;
-    /** `true` si c'est le connecteur par défaut (`"default"`). */
+    /**
+     * `true` pour le connecteur par défaut : celui qui porte les stores de
+     * l'application (un RÔLE constaté, pas le nom `"default"` — repli sur ce nom
+     * seulement quand aucun store n'est porté par un ORM).
+     */
     default: boolean;
     /** État de la connexion. */
     connected: boolean;
@@ -98,6 +102,37 @@ export interface IConnectionError {
     /** Horodatage epoch ms. */
     ts: number;
 }
+/**
+ * Un événement de vie de la connexion : une PERTE ou une REPRISE, constatée
+ * par l'adapter (événement du driver) ou par le battement de cœur.
+ */
+export interface IConnectionEvent {
+    /** `lost` : la base a cessé de répondre ; `restored` : elle répond à nouveau. */
+    kind: "lost" | "restored";
+    /** Horodatage epoch ms. */
+    ts: number;
+    /** Cause de la perte (credential déjà retiré) — absente pour une reprise. */
+    reason?: string;
+}
+/**
+ * Le mécanisme de résilience d'un connecteur, TEL QU'IL TOURNE dans ce process.
+ *
+ * Rend lisible ce qui décide de « connecté / perdu / rétabli » : un pilote qui
+ * surveille ses serveurs (MongoDB) le sait seul ; les autres ne l'apprennent
+ * que par une requête, d'où le battement de cœur que porte la classe `Orm`.
+ */
+export interface IOrmResilience {
+    /** Période du battement (ms) ; `0` = désactivé (`NF_ORM_HEARTBEAT_MS=0`). */
+    heartbeatMs: number;
+    /** Délai au-delà duquel un battement sans réponse vaut une perte (ms). */
+    heartbeatTimeoutMs: number;
+    /** Le battement tourne-t-il en ce moment ? */
+    heartbeatActive: boolean;
+    /** L'adapter sait-il répondre à `ping()` (condition du battement) ? */
+    pingable: boolean;
+    /** Une perte est-elle constatée et PAS ENCORE réparée ? */
+    lostPending: boolean;
+}
 /**
  * Diagnostic d'un connecteur — réponse de `/nodefony/orm/api/connection/health`.
  * Combine l'état figé ({@link IConnectionInfo}), les compteurs de cycle de vie
@@ -131,8 +166,18 @@ export interface IConnectionHealth {
     uptimeMs: number | null;
     /** Nombre total de connexions réussies. */
     connectCount: number;
-    /** Reconnexions (connexions au-delà de la première). */
+    /** Reprises CONSTATÉES après une perte (jamais déduites des connexions). */
     reconnectCount: number;
+    /** Pertes constatées depuis le démarrage du process. */
+    lostCount: number;
+    /** Dernière perte (epoch ms), `null` si aucune. */
+    lastLostAt: number | null;
+    /** Dernière reprise (epoch ms), `null` si aucune. */
+    lastRestoredAt: number | null;
+    /** Pertes et reprises récentes (ring borné, plus récentes d'abord). */
+    events: IConnectionEvent[];
+    /** Mécanisme de détection et de reprise, si l'ORM le décrit. */
+    resilience?: IOrmResilience;
     /** Nombre total d'erreurs enregistrées (connexion + ping). */
     errorCount: number;
     /** Dernière erreur, `null` si aucune. */

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

@@ -3,7 +3,7 @@
  *
  * Obtenue dans le callback de `IOrm.transaction()`. Les transactions cross-ORM
  * (2PC) ne sont PAS garanties : une transaction porte sur un seul ORM/connexion.
- * La sémantique des savepoints dépend du driver (peut être un no-op).
+ * Un moteur sans savepoints (MongoDB) les REFUSE : `SavepointNotSupportedError`.
  */
 export interface ITransaction {
     /** Valide définitivement les opérations de la transaction. */
@@ -14,12 +14,14 @@ export interface ITransaction {
      * Crée un point de sauvegarde nommé pour un rollback partiel ultérieur.
      *
      * @param name - identifiant du savepoint.
+     * @throws SavepointNotSupportedError si le moteur n'en porte pas (MongoDB).
      */
     savepoint(name: string): Promise<void>;
     /**
      * Annule jusqu'à un savepoint sans terminer la transaction.
      *
      * @param name - savepoint cible.
+     * @throws SavepointNotSupportedError si le moteur n'en porte pas (MongoDB).
      */
     rollbackTo(name: string): Promise<void>;
     /**

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

@@ -1,7 +1,7 @@
 export type { IOrm } from "./IOrm.js";
-export type { IEntity, IEntityRelation } from "./IEntity.js";
+export type { IEntity, IEntityIndex, IEntityRelation } from "./IEntity.js";
 export type { IRepository, OrmCriteria, Criteria, FieldCriteria, FieldOperators, UpdateData, UpdateOperators, RepositoryReadOptions, } from "./IRepository.js";
 export type { ITransaction } from "./ITransaction.js";
 export type { IPage, IPageQuery, PageQuery } from "./IPage.js";
-export type { IColumnInfo, IConnectionInfo, IRelationInfo, IEntityGraphNode, IOrmSummary, IOrmGraph, IConnectionError, IConnectionHealth, } from "./IOrmGraph.js";
+export type { IColumnInfo, IConnectionInfo, IRelationInfo, IEntityGraphNode, IOrmSummary, IOrmGraph, IConnectionError, IConnectionEvent, IOrmResilience, IConnectionHealth, } from "./IOrmGraph.js";
 export type { ILatencyWindow, IOrmStorageProbe, IOrmPoolProbe, IOrmProbe, } from "./IOrmProbe.js";

package/dist/types/nodefony/src/ConnectionMonitor.d.ts

@@ -1,4 +1,4 @@
-import type { IConnectionError } from "../interfaces/IOrmGraph.js";
+import type { IConnectionError, IConnectionEvent } from "../interfaces/IOrmGraph.js";
 import type { ILatencyWindow } from "../interfaces/IOrmProbe.js";
 /** Vue figée des compteurs du moniteur pour un connecteur. */
 export interface IConnectionMonitorCore {
@@ -8,6 +8,12 @@ export interface IConnectionMonitorCore {
     reconnectCount: number;
     /** Pertes de connexion constatées depuis le démarrage du process. */
     lostCount: number;
+    /** Dernière perte (epoch ms), `null` si aucune. */
+    lastLostAt: number | null;
+    /** Dernière reprise (epoch ms), `null` si aucune. */
+    lastRestoredAt: number | null;
+    /** Pertes et reprises récentes, plus récentes d'abord. */
+    events: IConnectionEvent[];
     errorCount: number;
     lastConnectMs: number | null;
     lastError: IConnectionError | null;
@@ -58,8 +64,9 @@ declare class ConnectionMonitor {
      * preuve de bonne santé.
      *
      * @param name - clé du connecteur.
+     * @param reason - cause lisible (credential déjà retiré), si connue.
      */
-    recordLost(name: string): void;
+    recordLost(name: string, reason?: string): void;
     /**
      * Enregistre une **reprise** de connexion constatée par l'adapter.
      *

package/dist/types/nodefony/src/Orm.d.ts

@@ -1,6 +1,6 @@
 import { Service } from "nodefony";
 import type { Container, Event, DefaultOptionsService } from "nodefony";
-import type { IColumnInfo, IConnectionInfo, IOrm, IRepository, ITransaction } from "../interfaces/index.js";
+import type { IColumnInfo, IConnectionInfo, IOrm, IOrmResilience, IRepository, ITransaction } from "../interfaces/index.js";
 /**
  * Classe de base abstraite de tout ORM Nodefony — câble {@link Service} (DI,
  * Syslog, bus d'événements) et le contrat {@link IOrm}, et s'auto-enregistre
@@ -121,6 +121,14 @@ export declare abstract class Orm extends Service implements IOrm {
      * prochain battement pour rendre la main.
      */
     protected startHeartbeat(): void;
+    /**
+     * Décrit le mécanisme de résilience TEL QU'IL TOURNE — lecture pure, pour
+     * le data plane (`connection/health`) : période et montre du battement,
+     * battement actif ou non, perte en souffrance.
+     *
+     * @returns l'état du mécanisme dans ce process.
+     */
+    describeResilience(): IOrmResilience;
     /** Arrête le battement et libère la minuterie. Idempotent. */
     protected stopHeartbeat(): void;
     /**

package/dist/types/nodefony/src/OrmAdminApi.d.ts

@@ -1,6 +1,22 @@
-import type { IAdminApi, IAdminRegistry } from "nodefony";
+import type { IAdminApi, IAdminRegistry, IStoreResolution } from "nodefony";
 import type { IConnectionHealth, IOrmGraph } from "../interfaces/IOrmGraph.js";
 import type { IOrmFlowReport } from "../interfaces/IOrmFlow.js";
+/** Résumé des ORM enregistrés (statut connexion + nombre d'entités). */
+/**
+ * Connecteur qui porte les stores de l'application — le connecteur PAR DÉFAUT.
+ *
+ * « Défaut » est un RÔLE, pas un nom : sur une infra MongoDB les briques
+ * durables vivent sur `nodefony` (Mongoose), et marquer `default` (Drizzle)
+ * parce qu'il s'appelle ainsi désignait une base que personne n'utilise. Le
+ * rôle se CONSTATE dans le registre des stores (#474) : le connecteur qui porte
+ * le plus de briques durables, puis de briques tout court.
+ *
+ * @param resolutions - registre des stores du kernel (`storeResolutions`).
+ * @param names - connecteurs enregistrés ; une brique sur un autre nom est ignorée.
+ * @returns le nom du connecteur, ou `null` si aucune brique n'est portée par
+ *   un ORM (le repli sur le nom `default` s'applique alors).
+ */
+export declare function storeCarrier(resolutions: readonly IStoreResolution[], names: readonly string[]): string | null;
 /** Construit le graphe canonique complet (optionnellement filtré par connecteur). */
 export declare function buildOrmGraph(connectorFilter?: string): IOrmGraph;
 /**

package/dist/types/nodefony/src/connectionDiagnosis.d.ts

@@ -24,6 +24,12 @@ export type ConnectionVerdict =
 "unreachable"
 /** Un serveur a répondu, et il refuse — le port est bien tenu par quelqu'un. */
  | "answered"
+/**
+ * La connexion a ABOUTI, puis le serveur a refusé une INSTRUCTION — une
+ * table, une contrainte, un type. Ni l'adresse ni l'état de la base ne sont
+ * en cause : c'est le schéma envoyé qu'il faut corriger.
+ */
+ | "rejected"
 /** L'erreur ne permet de trancher ni dans un sens ni dans l'autre. */
  | "unknown";
 /** Diagnostic rendu à l'appelant, qui compose le message final. */
@@ -56,3 +62,26 @@ export declare function parseConnectionTarget(url?: string | null): IConnectionT
  * @returns le verdict, le code constaté et une explication déjà rédigée.
  */
 export declare function diagnoseConnectionFailure(error: unknown, target?: IConnectionTarget, platform?: string): IConnectionDiagnosis;
+/**
+ * Marqueur de la phrase « connecté, puis refusé » — lu par `create app`
+ * (`migrationFailureCause`, cœur) pour NE PAS conclure à une base injoignable.
+ * Le cœur ne peut pas importer ce paquet : sa copie est éprouvée contre
+ * celle-ci par un test de parité.
+ */
+export declare const REJECTED_MARKER = "s'est connect\u00E9, mais le serveur a refus\u00E9 une instruction \u2014 ";
+/**
+ * Compose le message d'échec au démarrage d'un connecteur — UNE rédaction pour
+ * tous les adapters.
+ *
+ * 🔴 Un refus d'instruction (verdict `rejected`) ne commence JAMAIS par « n'a
+ * pas pu se connecter » : c'était faux, et la phrase envoyait vérifier
+ * l'adresse et l'état d'une base qui répondait très bien. La cause du pilote
+ * passe alors EN TÊTE — c'est elle qui nomme la table ou la contrainte.
+ *
+ * @param subject - sujet de la phrase (`Drizzle : le connecteur "x" (…)`).
+ * @param diagnosis - verdict de {@link diagnoseConnectionFailure}.
+ * @param cause - message brut du pilote.
+ * @param advice - conseil propre à l'adapter, pour un échec de CONNEXION.
+ * @returns le message complet.
+ */
+export declare function describeConnectFailure(subject: string, diagnosis: IConnectionDiagnosis, cause: string, advice?: string): string;

package/dist/types/nodefony/src/errors.d.ts

@@ -60,3 +60,51 @@ export declare class InvalidOrderOption extends Error {
      */
     constructor(entity: string, received: string);
 }
+/**
+ * Levée quand une suppression viserait une entité encore RÉFÉRENCÉE par une
+ * relation obligatoire d'une autre entité.
+ *
+ * C'est le pendant, pour un moteur sans clé étrangère (MongoDB), du `restrict`
+ * que le SQL généré pose sur une colonne de référence obligatoire : le parent
+ * ne part pas tant qu'un enfant le désigne. Sans cette garde, la suppression
+ * passait et `?include=` rendait ensuite `null` à la place du parent — une
+ * application passée du SQL à MongoDB perdait en silence une garantie qu'elle
+ * croyait avoir.
+ *
+ * Erreur de DONNÉES : c'est la surface API qui la projette (le rendu d'erreur
+ * HTTP la reconnaît par son `name` et répond 409).
+ */
+export declare class ReferencedEntityError extends Error {
+    /** Entité dont la suppression est refusée (nom logique). */
+    readonly entity: string;
+    /** Entité qui la référence encore (nom logique). */
+    readonly referencedBy: string;
+    /** Champ de référence de {@link ReferencedEntityError.referencedBy}. */
+    readonly field: string;
+    /**
+     * @param entity - entité dont la suppression est refusée.
+     * @param referencedBy - entité qui la référence encore.
+     * @param field - champ de référence obligatoire qui la désigne.
+     */
+    constructor(entity: string, referencedBy: string, field: string);
+}
+/**
+ * Levée par `ITransaction.savepoint()` / `rollbackTo()` sur un moteur qui ne porte
+ * PAS de savepoints (MongoDB).
+ *
+ * Refuser vaut mieux que se taire : un `rollbackTo()` rendu en no-op laissait
+ * l'appelant croire ses écritures annulées alors qu'elles restaient en base. Le
+ * refus tombe dès `savepoint()`, pas au `rollbackTo()` : le chemin d'erreur, où
+ * l'on annule, est celui qu'on teste le moins — la faute doit se voir au premier
+ * essai. Pour annuler, terminer la transaction entière (`rollback()`, ou laisser
+ * le callback de `IOrm.transaction()` lever).
+ */
+export declare class SavepointNotSupportedError extends Error {
+    /** Moteur qui refuse (valeur de `describeConnection().driver`). */
+    readonly driver: string;
+    /**
+     * @param driver - moteur qui ne porte pas de savepoints.
+     * @param operation - opération refusée (`savepoint` ou `rollbackTo`).
+     */
+    constructor(driver: string, operation: "savepoint" | "rollbackTo");
+}

package/dist/types/nodefony/src/orphanEntities.d.ts

@@ -0,0 +1,38 @@
+import type { IEntity } from "../interfaces/IEntity.js";
+/**
+ * Entités inscrites sur un connecteur qu'aucun ORM n'a ouvert.
+ *
+ * Une telle entité ne sera servie par rien : son dépôt lèvera au premier
+ * appel, loin de sa cause. Vécu : sur une infra MongoDB, le `User` d'une
+ * application restait écrit en table SQL sur `default` — un connecteur que
+ * Drizzle n'ouvre pas sur cette infra — et le boot n'en disait RIEN.
+ *
+ * @param entities - entités inscrites (registre des entités).
+ * @param connectors - connecteurs ouverts (registre des ORM).
+ * @returns les orphelines, dans l'ordre d'inscription.
+ */
+export declare function findOrphanEntities(entities: readonly IEntity[], connectors: readonly string[]): IEntity[];
+/**
+ * La phrase qui NOMME les orphelines et le remède — `null` s'il n'y en a pas.
+ *
+ * @param orphans - entités sans connecteur ouvert.
+ * @param connectors - connecteurs ouverts, cités pour situer la faute.
+ * @param declared - connecteurs DÉCLARÉS par les modules ORM (leur configuration).
+ */
+export declare function describeOrphanEntities(orphans: readonly IEntity[], connectors: readonly string[], declared?: readonly string[]): string | null;
+/**
+ * Signale UNE fois par démarrage les entités orphelines, au moment où tous les
+ * ORM sont ouverts.
+ *
+ * Appelée par chaque module ORM (Drizzle, Mongoose) à `onReady` : la règle vit
+ * ici, une fois, et le premier appel la rend — le second se tait, sans quoi une
+ * application qui charge les deux ORM lirait deux fois le même avertissement.
+ * La garde porte sur le KERNEL et non sur le process : un process qui démarre
+ * plusieurs noyaux (une suite de tests) doit être prévenu à chacun.
+ *
+ * @param log - journal du module appelant.
+ * @param owner - le démarrage concerné (le Kernel), clé de la garde.
+ * @param declared - connecteurs que l'appelant a DÉCLARÉS (sa configuration).
+ * @returns le message rendu, ou `null` (rien à dire, ou déjà dit).
+ */
+export declare function reportOrphanEntities(log: (message: string, severity: "WARNING") => void, owner: object, declared?: readonly string[]): string | null;

package/docs/index.md

@@ -393,7 +393,7 @@ l'ordre des écouteurs, la table existe ou non. `entities()` s'accroche à `onRe
 (`entitiesDecorator.ts:66`), strictement antérieur — sûr par construction. C'est la différence de
 comportement avec `@controllers`, qui lui reste à `onBoot`.
 
-**`Orm.connect()`** (`Orm.ts:54`) est une **template method** : elle mesure la latence, alimente le
+**`Orm.connect()`** (`Orm.ts:118`) est une **template method** : elle mesure la latence, alimente le
 moniteur de connexion, puis émet `onOrmReady`. Un adapter surcharge `onConnect()` (`Orm.ts:74`), et
 **jamais** `connect()` — sinon l'événement et l'instrumentation disparaissent.
 
@@ -412,8 +412,8 @@ transaction (`IOrm.transaction()`, `IOrm.ts:41`) et expose la trappe native
 
 Quatre méthodes sont **optionnelles** — un adapter qui ne les implémente pas dégrade proprement au
 lieu d'échouer : `describeEntity()` (`IOrm.ts:78`, colonnes pour l'ERD), `describeConnection()`
-(`IOrm.ts:71`, driver et cible **sans credential**), `ping()` (`IOrm.ts:82`, aller-retour réel) et
-`probe()` (`IOrm.ts:92`, métriques driver, qui ne doit **jamais** lever).
+(`IOrm.ts:88`, driver et cible **sans credential**), `ping()` (`IOrm.ts:109`, aller-retour réel) et
+`probe()` (`IOrm.ts:119`, métriques driver, qui ne doit **jamais** lever).
 
 ### [`IRepository`](tutorial-entity.md) — les quinze verbes
 
@@ -422,16 +422,16 @@ verbes se choisissent sur **la garantie** qu'ils apportent, pas sur leur nom.
 
 | Verbe                 | Ce qu'il garantit                                                    | Ancre                        |
 | --------------------- | -------------------------------------------------------------------- | ---------------------------- |
-| `find` / `findOne`    | lecture filtrée + eager-load + tri + bornes                          | `IRepository.ts:213`         |
-| `count` / `exists`    | compter, ou juste savoir s'il y en a un (sans charger de colonne)    | `IRepository.ts:378`, `:335` |
+| `find` / `findOne`    | lecture filtrée + eager-load + tri + bornes                          | `IRepository.ts:230`         |
+| `count` / `exists`    | compter, ou juste savoir s'il y en a un (sans charger de colonne)    | `IRepository.ts:395`, `:335` |
 | `create`              | insertion d'une ligne, rend la version persistée (id, défauts)       | `IRepository.ts:240`         |
 | `createMany`          | N lignes en **une** requête — seed, import, ingestion par lots       | `IRepository.ts:252`         |
 | `updateOne`           | met à jour **au plus une** ligne, **atomiquement**, et la rend       | `IRepository.ts:269`         |
 | `updateMany`          | met à jour toutes les lignes du critère, rend le **nombre**          | `IRepository.ts:312`         |
 | `upsert`              | insère **ou** met à jour sur conflit de clé, en **une** instruction  | `IRepository.ts:296`         |
 | `increment`           | `SET f = f + ?` atomique — compteurs, quotas, rate-limit             | `IRepository.ts:287`         |
-| `delete`              | supprime tout ce qui matche, rend le nombre                          | `IRepository.ts:298`         |
-| `deleteOne`           | supprime **au plus une** ligne, rend un booléen                      | `IRepository.ts:328`         |
+| `delete`              | supprime tout ce qui matche, rend le nombre                          | `IRepository.ts:336`         |
+| `deleteOne`           | supprime **au plus une** ligne, rend un booléen                      | `IRepository.ts:345`         |
 | `findOneAndDelete`    | supprime **et rend** la ligne — file de jobs, outbox, `pop` atomique | `IRepository.ts:355`         |
 | `withTransaction(tx)` | une **vue** du repository liée à une transaction                     | `IRepository.ts:406`         |
 
@@ -440,7 +440,7 @@ verbes se choisissent sur **la garantie** qu'ils apportent, pas sur leur nom.
 > `findOneAndUpdate` en Mongo), jamais un `UPDATE` suivi d'une relecture. La différence n'est pas
 > cosmétique : la relecture rendrait `null` **à tort** dès que le critère porte sur un champ qu'on
 > vient de modifier — `updateOne({ status: "pending" }, { status: "done" })` ne retrouve plus rien
-> après coup (`IRepository.ts:221`).
+> après coup (`IRepository.ts:269`).
 
 Quelques usages, un par garantie :
 
@@ -472,11 +472,13 @@ atomique sur les quatre backends.
 
 ### [`IEntity`](tutorial-entity.md) — la description d'une table
 
-`IEntity` (`IEntity.ts:37`) porte un nom logique, un `connector` (le nom d'une **connexion**, jamais
+`IEntity` (`IEntity.ts:51`) porte un nom logique, un `connector` (le nom d'une **connexion**, jamais
 d'un moteur), un `schema` natif du driver, et des `relations` déclaratives (`IEntityRelation`,
 `IEntity.ts:4`). Deux champs facultatifs servent la lisibilité d'un gros modèle : `module` (qui
-apporte l'entité) et `domain` (`IEntity.ts:58`, la classification métier — l'axe qui rend navigable
-une base de plusieurs centaines de tables).
+apporte l'entité) et `domain` (`IEntity.ts:72`, la classification métier — l'axe qui rend navigable
+une base de plusieurs centaines de tables). Un troisième, `indexes` (`IEntityIndex`), déclare les
+index COMPOSITES qu'un adaptateur ne sait pas exprimer dans son schéma : Mongoose les applique
+(`schema.index()`), Drizzle les ignore, puisqu'il les déclare dans sa table.
 
 Dans une application, on ne construit pas un `IEntity` à la main : on écrit un `IEntityDefinition`
 (`defineEntity.ts:15`) — le même objet **sans** `connector`, justement parce que le connecteur est
@@ -555,7 +557,7 @@ Deux décisions le rendent utilisable sur une grosse table :
    `false`. C'est la distinction « Page » (avec total) et « Slice » (sans), reprise de Spring Data.
 
 Les bornes sont normalisées plutôt que propagées : un `limit` de `0` ou un `offset` négatif est
-ramené dans le domaine valide (`paginate.ts:28`) — un `find({ limit: 0 })` a un comportement qui
+ramené dans le domaine valide (`paginate.ts:56`) — un `find({ limit: 0 })` a un comportement qui
 dépend du dialecte, donc on ne le laisse pas sortir.
 
 Le contrat de page lui-même (`IPage`, `IPageQuery`) vit dans le **cœur**
@@ -588,7 +590,7 @@ export class ArticleService extends AbstractCrudService<ArticleRow> {
 - **Lectures** (`find`, `findOne`, `findById`, `count`, `findPage`) — **délégation pure**. Aucun
   hook, aucun événement : c'est le chemin chaud, il ne doit rien payer.
 - **Mutations** (`create`, `updateOne`, `delete`) — encadrées par des hooks _template method_
-  (`beforeCreate`, `AbstractCrudService.ts:185`, et ses six frères) puis un événement de cycle de vie
+  (`beforeCreate`, `AbstractCrudService.ts:212`, et ses six frères) puis un événement de cycle de vie
   `onCreated` / `onUpdated` / `onDeleted`, **émis seulement si la mutation a eu lieu**
   (`AbstractCrudService.ts:167`). L'audit, l'invalidation de cache ou une notification Studio s'y
   abonnent sans toucher au service.
@@ -606,18 +608,19 @@ d'administration : elle ne charge qu'une page, quelle que soit la taille de la t
 
 Deux drivers implémentent les contrats. Le contrat `IRepository` est tenu **en entier** par les
 deux : les quinze verbes existent des deux côtés — par exemple l'upsert, avec
-`DrizzleRepository.upsert()` (`DrizzleRepository.ts:868`) et `MongooseRepository.upsert()`
-(`MongooseRepository.ts:343`).
-
-| Capacité                               | `@nodefony/drizzle`                 | `@nodefony/mongoose`               |
-| -------------------------------------- | ----------------------------------- | ---------------------------------- |
-| Moteurs                                | SQLite, PostgreSQL, MySQL / MariaDB | MongoDB                            |
-| Contrat `IRepository` (15 verbes)      | complet                             | complet                            |
-| Eager-load `{ relations }`             | oui                                 | oui (`populate`)                   |
-| Transactions + savepoints              | oui                                 | oui (replica set requis par Mongo) |
-| Colonnes pour l'ERD (`describeEntity`) | oui (`DrizzleOrm.ts:1593`)          | oui (`MongooseOrm.ts:558`)         |
-| Sonde de flux (requêtes/s, lentes)     | oui — alimente `queryFlowMonitor`   | non câblée                         |
-| Sonde profonde (`probe`)               | oui (`DrizzleOrm.ts:1614`)          | oui (`MongooseOrm.ts:529`)         |
+`DrizzleRepository.upsert()` (`DrizzleRepository.ts:879`) et `MongooseRepository.upsert()`
+(`MongooseRepository.ts:405`).
+
+| Capacité                               | `@nodefony/drizzle`                 | `@nodefony/mongoose`                         |
+| -------------------------------------- | ----------------------------------- | -------------------------------------------- |
+| Moteurs                                | SQLite, PostgreSQL, MySQL / MariaDB | MongoDB                                      |
+| Contrat `IRepository` (15 verbes)      | complet                             | complet                                      |
+| Eager-load `{ relations }`             | oui                                 | oui (`populate`)                             |
+| Transactions                           | oui                                 | oui (replica set requis par Mongo)           |
+| Savepoints (rollback partiel)          | oui                                 | non — refusés (`SavepointNotSupportedError`) |
+| Colonnes pour l'ERD (`describeEntity`) | oui (`DrizzleOrm.ts:1933`)          | oui (`MongooseOrm.ts:649`)                   |
+| Sonde de flux (requêtes/s, lentes)     | oui — alimente `queryFlowMonitor`   | non câblée                                   |
+| Sonde profonde (`probe`)               | oui (`DrizzleOrm.ts:1835`)          | oui (`MongooseOrm.ts:617`)                   |
 
 **Les « stores » du framework, eux, ne sont pas alignés — et c'est un choix.** Un adapter déclare ce
 qu'il porte dans son `package.json`, clé `nodefony.stores` :
@@ -644,7 +647,7 @@ qu'il porte dans son `package.json`, clé `nodefony.stores` :
 
 Le contrat minimal tient en peu de choses, parce que `orm-core` fournit déjà la plomberie.
 
-1. **Étendre `Orm`** (`Orm.ts:29`) : implémenter `onConnect()`, `disconnect()`, `isConnected()`,
+1. **Étendre `Orm`** (`Orm.ts:46`) : implémenter `onConnect()`, `disconnect()`, `isConnected()`,
    `getRepository()`, `transaction()`, `getNativeConnection()`. L'enregistrement dans `ormRegistry`
    est fait par le constructeur de base — il n'y a rien à écrire. **Ne jamais surcharger
    `connect()`** : c'est la template method qui émet `onOrmReady` et instrumente la latence.
@@ -672,7 +675,7 @@ la santé ne doit pas coûter le débit, et observer le débit ne doit pas réve
 
 **`connectionMonitor`** (`ConnectionMonitor.ts:197`) suit le **cycle de vie** d'une connexion :
 première connexion, reconnexions, erreurs récentes, et une fenêtre de latence de ping
-(`ConnectionMonitor.recordPing()`, `ConnectionMonitor.ts:106`). Il est alimenté par `Orm.connect()`
+(`ConnectionMonitor.recordPing()`, `ConnectionMonitor.ts:136`). Il est alimenté par `Orm.connect()`
 sans que l'adapter ait à y penser.
 
 **`queryFlowMonitor`** (`QueryFlowMonitor.ts:146`) suit le **débit** : total de requêtes, latence
@@ -687,7 +690,7 @@ rendent sûr en production :
   observe, et le débit par seconde est **dérivé côté lecteur** (delta entre deux relevés), donc rien
   n'est muté à la lecture.
 
-Le data plane `/nodefony/orm/api/*` (`createOrmAdminApi()`, `OrmAdminApi.ts:421`) expose huit points
+Le data plane `/nodefony/orm/api/*` (`createOrmAdminApi()`, `OrmAdminApi.ts:541`) expose huit points
 d'entrée, tous filtrables par `?connector=` :
 
 | Point d'entrée      | Ce qu'il rend                                                     |
@@ -695,11 +698,11 @@ d'entrée, tous filtrables par `?connector=` :
 | `orms`              | les connecteurs, leur état, leur nombre d'entités                 |
 | `entities`          | le modèle complet : colonnes + relations                          |
 | `entity/{name}`     | une entité (404 si inconnue)                                      |
-| `graph`             | le graphe canonique (`buildOrmGraph()`, `OrmAdminApi.ts:184`)     |
+| `graph`             | le graphe canonique (`buildOrmGraph()`, `OrmAdminApi.ts:227`)     |
 | `counts`            | le nombre de lignes par entité — un `COUNT(*)` par table          |
 | `connection/health` | état, latence, erreurs, reconnexions, sondes                      |
-| `flow`              | débit et requêtes lentes (`buildOrmFlow()`, `OrmAdminApi.ts:310`) |
-| `export/{format}`   | `dbml` (`toDbml()`, `OrmAdminApi.ts:345`) ou `jsonschema`         |
+| `flow`              | débit et requêtes lentes (`buildOrmFlow()`, `OrmAdminApi.ts:360`) |
+| `export/{format}`   | `dbml` (`toDbml()`, `OrmAdminApi.ts:395`) ou `jsonschema`         |
 
 Ce graphe canonique est **la pièce maîtresse**, pas le diagramme : c'est une donnée sérialisable qui
 sert à la fois l'ERD de Studio, un export vers un outil tiers, et le contexte d'un agent IA
@@ -730,11 +733,11 @@ deux, et pas de course).
 | Symptôme                                                      | Cause                                                                                              | Correction                                                                                  |
 | ------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- |
 | « no entity registered under "X" » au premier appel           | l'entité n'a jamais été inscrite (fichier importé mais `defineEntity` est sans effet de bord)      | l'ajouter à `@entities([...])` sur le module (`entitiesDecorator.ts:56`)                    |
-| La table n'existe pas alors que l'entité est déclarée         | inscription faite à `onBoot` → course avec `connect()`                                             | inscrire à `onRegister` — c'est ce que fait `entities()` (`entitiesDecorator.ts:66`)        |
+| La table n'existe pas alors que l'entité est déclarée         | inscription faite à `onBoot` → course avec `connect()`                                             | inscrire à `onRegister` — c'est ce que fait `entities()` (`entitiesDecorator.ts:56`)        |
 | « entity "User" exists on multiple connectors … specify one » | la même entité vit sur plusieurs connecteurs                                                       | préciser le connecteur : `entityRegistry.get("User", "analytics")` (`EntityRegistry.ts:54`) |
 | Un filtre « champ vide » ne remonte jamais rien               | `colonne = NULL` est toujours faux en SQL                                                          | `{ champ: { $null: true } }` ou la valeur nue `{ champ: null }` (`IRepository.ts:65`)       |
 | `UnknownCriteriaField` sur un champ qui existe « pourtant »   | faute de frappe, ou champ calculé absent du schéma                                                 | lire les champs connus dans le message ; pour du natif, passer par `getNativeConnection()`  |
-| `updateOne` rend `null` alors que la ligne a bien changé      | ancien réflexe `UPDATE` + relecture (le critère porte sur le champ modifié)                        | utiliser `updateOne`, atomique par construction (`IRepository.ts:252`)                      |
+| `updateOne` rend `null` alors que la ligne a bien changé      | ancien réflexe `UPDATE` + relecture (le critère porte sur le champ modifié)                        | utiliser `updateOne`, atomique par construction (`IRepository.ts:269`)                      |
 | Un `upsert` écrase une valeur qui devait progresser           | le `DO UPDATE` est inconditionnel (contrainte MySQL)                                               | poser la condition **dans** la valeur : `{ seuil: { $max: v } }` (`IRepository.ts:94`)      |
 | Un objet de critère est pris pour une égalité (colonne JSON)  | comportement **voulu** : une valeur n'est un filtre que si **toutes** ses clés sont des opérateurs | c'est la protection ; pour filtrer dedans, passer au natif (`criteria.ts:42`)               |
 | `onOrmReady` ne part plus après un ajout dans l'adapter       | `connect()` a été surchargé                                                                        | surcharger `onConnect()` (`Orm.ts:74`), jamais `connect()`                                  |

package/docs/tutorial-entity.md

@@ -88,7 +88,7 @@ battre contre le cadre.
 
 **1. Le connecteur est une donnée de configuration, jamais de code.** C'est pourquoi le
 descripteur qu'on écrit (`IEntityDefinition`, `defineEntity.ts:15`) est un `IEntity`
-(`IEntity.ts:37`) **privé de son `connector`** : celui-ci est résolu au démarrage, avec `"default"`
+(`IEntity.ts:51`) **privé de son `connector`** : celui-ci est résolu au démarrage, avec `"default"`
 pour valeur de repli (`DEFAULT_CONNECTOR`, `entitiesDecorator.ts:12`). Figer la connexion dans le
 fichier d'entité interdirait de servir la même table depuis une base différente selon
 l'environnement.
@@ -303,7 +303,7 @@ Cette absence d'effet de bord est délibérée : elle permet d'importer une enti
 un script ou un autre module **sans** déclencher son inscription dans un singleton global.
 
 Les champs facultatifs qui servent tôt : `module` (qui apporte l'entité) et `domain`
-(`IEntity.ts:58`), l'axe de classification qui rend navigable une base de plusieurs centaines de
+(`IEntity.ts:72`), l'axe de classification qui rend navigable une base de plusieurs centaines de
 tables dans l'ERD Studio.
 
 ### Étape 4 — brancher l'entité au module
@@ -318,7 +318,7 @@ d'être connues :
    être instancié deux fois : tests, rechargement). Une vraie collision, elle, lève
    (`EntityRegistry.register()`, `EntityRegistry.ts:24`).
 3. **Connecteur commun** — `entities([...], { connector: "analytics" })` pose toute la liste sur
-   une autre base ; une entité qui porte son propre `connector` (`IEntity.ts:42`) garde le sien.
+   une autre base ; une entité qui porte son propre `connector` (`IEntity.ts:56`) garde le sien.
 
 ### Le raccourci — `nodefony create entity`
 
@@ -339,7 +339,8 @@ que l'import plus la ligne du décorateur.
 > [!WARNING]
 > La commande refuse de générer si aucun module ORM n'est déclaré dans l'application. C'est
 > volontaire : une entité sans driver produit du code mort qui ne compile même pas. Ajoute
-> `use("@nodefony/drizzle", …)` au manifeste `modules`, puis relance.
+> `"@nodefony/drizzle"` (SQL) ou `"@nodefony/mongoose"` (MongoDB) au manifeste `modules`, puis
+> relance. Sur MongoDB, la même commande écrit un schéma Mongoose au lieu d'une table.
 
 ## 🧰 Lire et écrire — le contrat complet
 
@@ -348,23 +349,23 @@ apportent, jamais sur leur nom.
 
 | Verbe                 | Ce qu'il garantit                                                  | Ancre                        |
 | --------------------- | ------------------------------------------------------------------ | ---------------------------- |
-| `find` / `findOne`    | lecture filtrée, avec tri, bornes et eager-load                    | `IRepository.ts:213`, `:192` |
+| `find` / `findOne`    | lecture filtrée, avec tri, bornes et eager-load                    | `IRepository.ts:230`, `:192` |
 | `create`              | insère une ligne et rend sa version persistée (id, défauts)        | `IRepository.ts:240`         |
 | `createMany`          | N lignes en **une** requête — seed, import, ingestion par lots     | `IRepository.ts:252`         |
 | `updateOne`           | modifie **au plus une** ligne, **atomiquement**, et la rend        | `IRepository.ts:269`         |
 | `updateMany`          | modifie toutes les lignes du critère, rend le **nombre**           | `IRepository.ts:312`         |
 | `upsert`              | insère **ou** met à jour sur conflit de clé, en une instruction    | `IRepository.ts:296`         |
 | `increment`           | `SET f = f + ?` atomique — compteurs, quotas, limitation de débit  | `IRepository.ts:287`         |
-| `delete`              | supprime tout ce qui matche, rend le nombre                        | `IRepository.ts:298`         |
-| `deleteOne`           | supprime **au plus une** ligne, rend un booléen                    | `IRepository.ts:328`         |
+| `delete`              | supprime tout ce qui matche, rend le nombre                        | `IRepository.ts:336`         |
+| `deleteOne`           | supprime **au plus une** ligne, rend un booléen                    | `IRepository.ts:345`         |
 | `findOneAndDelete`    | supprime **et rend** la ligne — file de jobs, `pop` atomique       | `IRepository.ts:355`         |
-| `count` / `exists`    | compter, ou juste savoir s'il y en a une (sans charger de colonne) | `IRepository.ts:378`, `:335` |
+| `count` / `exists`    | compter, ou juste savoir s'il y en a une (sans charger de colonne) | `IRepository.ts:395`, `:335` |
 | `withTransaction(tx)` | une **vue** du repository liée à une transaction                   | `IRepository.ts:406`         |
 
 > [!IMPORTANT]
 > **Il n'existe pas de méthode `update()`.** Le choix est explicite et il est intentionnel :
 > `IRepository.updateOne()` (`IRepository.ts:269`) pour une ligne — atomique, et elle **rend** la
-> ligne modifiée —, `IRepository.updateMany()` (`IRepository.ts:274`) pour un lot — qui rend le
+> ligne modifiée —, `IRepository.updateMany()` (`IRepository.ts:312`) pour un lot — qui rend le
 > **nombre** de lignes touchées. Un verbe unique masquerait cette différence de garantie, qui est
 > précisément ce qu'on veut choisir en connaissance de cause.
 
@@ -393,7 +394,7 @@ await orm.transaction(async (tx) => {
 ```
 
 Deux réflexes de performance, dès le premier jour : préférer `IRepository.exists()`
-(`IRepository.ts:335`) à `findOne(...) !== null` — aucune colonne n'est chargée —, et
+(`IRepository.ts:395`) à `findOne(...) !== null` — aucune colonne n'est chargée —, et
 `IRepository.increment()` (`IRepository.ts:325`) à une lecture suivie d'une écriture : une requête
 au lieu de deux, et pas de course.
 
@@ -471,7 +472,7 @@ champs connus — le diagnostic d'une faute de frappe est immédiat.
 
 ## 📄 Pager les résultats
 
-`find()` avec `limit`/`offset`/`order` (`RepositoryReadOptions`, `IRepository.ts:153`) suffit pour
+`find()` avec `limit`/`offset`/`order` (`RepositoryReadOptions`, `IRepository.ts:174`) suffit pour
 une tranche. Pour une vraie page — celle qui sait s'il y a une suite — utilise `paginate()`
 (`paginate.ts:47`) :
 
@@ -524,9 +525,9 @@ d'administration, la primitive est `AbstractCrudService.findPage()` (`AbstractCr
 
 | Symptôme                                                      | Cause                                                                                            | Correction                                                                                               |
 | ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `posts.update is not a function`                              | la méthode `update()` n'existe pas dans le contrat                                               | `updateOne` pour une ligne (`IRepository.ts:269`), `updateMany` pour un lot (`IRepository.ts:274`)       |
+| `posts.update is not a function`                              | la méthode `update()` n'existe pas dans le contrat                                               | `updateOne` pour une ligne (`IRepository.ts:269`), `updateMany` pour un lot (`IRepository.ts:312`)       |
 | « no entity registered under "Post" » au premier appel        | le fichier d'entité est importé, mais `defineEntity()` est **sans effet de bord**                | ajouter l'entité à `@entities([...])` sur le module (`entitiesDecorator.ts:56`)                          |
-| La table n'existe pas alors que l'entité est déclarée         | inscription faite à `onBoot` → course avec l'ouverture du connecteur                             | inscrire à `onRegister` — c'est ce que fait `entities()` (`entitiesDecorator.ts:66`)                     |
+| La table n'existe pas alors que l'entité est déclarée         | inscription faite à `onBoot` → course avec l'ouverture du connecteur                             | inscrire à `onRegister` — c'est ce que fait `entities()` (`entitiesDecorator.ts:56`)                     |
 | Une colonne ajoutée au schéma reste absente de la table       | le DDL du boot est un `CREATE TABLE IF NOT EXISTS` : aucun `ALTER` n'est émis                    | supprimer la base de développement et redémarrer, ou passer par une migration                            |
 | Un `DEFAULT` SQL ou un index déclaré n'apparaît pas           | le DDL dérivé ne les émet pas                                                                    | poser le défaut côté JavaScript (`$defaultFn`) ; créer l'index par migration                             |
 | Un filtre « champ vide » ne remonte jamais rien               | `colonne = NULL` est toujours faux en SQL                                                        | `{ champ: { $null: true } }` ou la valeur nue `{ champ: null }` (`IRepository.ts:65`)                    |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodefony/orm-core",
-  "version": "10.0.0-alpha.7",
+  "version": "10.0.0-alpha.9",
   "description": "Un contrat de dépôt de données pour Nodefony, plusieurs moteurs : interfaces, registre et classes de base pour le support multi-ORM",
   "contributors": [],
   "type": "module",
@@ -8,6 +8,7 @@
   "types": "./dist/types/index.d.ts",
   "exports": {
     ".": {
+      "nodefony-source": "./index.ts",
       "types": "./dist/types/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
@@ -15,9 +16,9 @@
   },
   "scripts": {
     "start": "node dist/index.js",
-    "build": "rimraf dist && rolldown -c rolldown.config.ts && tsgo -p tsconfig.declarations.json",
+    "build": "rolldown -c rolldown.config.ts && tsgo -p tsconfig.declarations.json",
     "dev": "rolldown -c rolldown.config.ts --watch",
-    "clean": "rimraf dist",
+    "clean": "node --eval \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
     "test": "vitest run",
     "coverage": "vitest run --coverage",
     "typecheck": "tsgo --noEmit -p tsconfig.json && tsgo --noEmit -p tsconfig.tests.json"
@@ -36,12 +37,11 @@
     "esm"
   ],
   "peerDependencies": {
-    "nodefony": "^10.0.0-alpha.7"
+    "nodefony": "^10.0.0-alpha.9"
   },
   "devDependencies": {
-    "@types/node": "26.6.1",
-    "nodefony": "^10.0.0-alpha.7",
-    "rimraf": "6.1.3",
+    "@types/node": "26.6.2",
+    "nodefony": "^10.0.0-alpha.9",
     "vitest": "5.0.1"
   },
   "repository": {