@nodefony/orm-core 10.0.0-alpha.1

package/dist/index.js

@@ -0,0 +1,22 @@
+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 { assertOrderOption } from "./nodefony/src/readOptions.js";
+import { OrmRegistry, ormRegistry } from "./nodefony/src/OrmRegistry.js";
+import { EntityRegistry, entityRegistry } from "./nodefony/src/EntityRegistry.js";
+import { connectionMonitor } from "./nodefony/src/ConnectionMonitor.js";
+import { Orm } from "./nodefony/src/Orm.js";
+import { Entity } from "./nodefony/src/Entity.js";
+import { paginate } from "./nodefony/src/paginate.js";
+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 { reportOrmBootLines, resolveOrmFlowEnabled, wireOrmAdminPlane } from "./nodefony/src/ormWiring.js";
+import { isMigrationFailure } from "./nodefony/interfaces/IOrmMigrations.js";
+import { getEntityMeta, getRepositoryMeta, hasEntityMeta, hasRepositoryMeta } from "./nodefony/src/decorators/metadataStore.js";
+import { entity } from "./nodefony/src/decorators/entityDecorator.js";
+import { DEFAULT_CONNECTOR, entities } from "./nodefony/src/decorators/entitiesDecorator.js";
+import { repository } from "./nodefony/src/decorators/repositoryDecorator.js";
+import "./nodefony/src/decorators/index.js";
+import { defineEntity } from "./nodefony/src/defineEntity.js";
+export { AbstractCrudService, DEFAULT_CONNECTOR, Entity, EntityRegistry, InvalidOrderOption, LIKE_ESCAPE_CHAR, OPERATOR_KEYS, Orm, OrmRegistry, UPDATE_OPERATOR_KEYS, UnknownCriteriaField, assertOrderOption, buildConnectionHealth, buildOrmFlow, buildOrmGraph, buildOrmLeanHealth, connectionMonitor, createOrmAdminApi, defineEntity, entities, entity, entityRegistry, escapeLikeTerm, getEntityMeta, getRepositoryMeta, hasEntityMeta, hasRepositoryMeta, isFieldOperators, isMigrationFailure, isUpdateOperators, likePatternToRegExp, ormRegistry, paginate, queryFlowMonitor, registerOrmAdminApi, reportOrmBootLines, repository, resolveOrmFlowEnabled, searchCriteria, toDbml, toJsonSchema, wireOrmAdminPlane };

package/dist/nodefony/interfaces/IEntity.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/IOrm.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/IOrmFlow.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/IOrmGraph.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/IOrmMigrations.js

@@ -0,0 +1,12 @@
+//#region nodefony/interfaces/IOrmMigrations.ts
+/**
+* Y a-t-il un empêchement plutôt qu'un état ?
+*
+* @param reply - ce que l'ORM a rendu.
+* @returns `true` si c'est un empêchement.
+*/
+function isMigrationFailure(reply) {
+	return "error" in reply;
+}
+//#endregion
+export { isMigrationFailure };

package/dist/nodefony/interfaces/IOrmProbe.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/IPage.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/IRepository.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/ITransaction.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/index.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/src/AbstractCrudService.js

@@ -0,0 +1,199 @@
+import { paginate } from "./paginate.js";
+import { Service } from "nodefony";
+//#region nodefony/src/AbstractCrudService.ts
+/**
+* Service CRUD **générique** — socle réutilisable au-dessus d'un {@link IRepository}.
+*
+* Toute entité (User, Article, Room...) expose son CRUD « toujours de la même
+* manière » en étendant cette classe : `class UserService extends
+* AbstractCrudService<IUser, IUserRepository>`. Le service est la **source de
+* vérité métier**, transport-agnostique : les adaptateurs (REST controller, WS
+* RPC, resolver GraphQL, commande CLI) l'appellent sans dupliquer la logique.
+*
+* Étend {@link Service} (DI, Syslog, bus d'événements) → instancié **une seule
+* fois** (singleton DI). C'est légitime car la classe est **stateless** : son
+* état d'instance ne porte que des invariants partagés (le `repository` injecté).
+* L'état par requête (utilisateur courant, tenant, transaction) vit dans le
+* `Context`/ALS, **jamais** dans un champ du service.
+*
+* **Perf** : les lectures (`find`/`findOne`/`findById`/`count`) délèguent
+* directement au repository — aucun hook ni event sur le chemin chaud. Les
+* mutations (`create`/`update`/`delete`) passent par les hooks template-method et
+* émettent un événement de cycle de vie (`onCreated`/`onUpdated`/`onDeleted`)
+* consommable pour l'audit, le cache, ou Studio.
+*
+* @typeParam T - type de l'entité gérée.
+* @typeParam R - type concret du repository (conserve les finders métier dans la
+*   sous-classe, ex. `IUserRepository`). Défaut : `IRepository<T>`.
+*/
+var AbstractCrudService = class extends Service {
+	repository;
+	/**
+	* @param name - identifiant logique du service (msgid des logs, clé d'abonnement events).
+	* @param repository - source de persistance injectée (DI).
+	* @param wiring - câblage Service ({@link ServiceWiring} : `container?`,
+	*   `notificationsCenter?`, `options?`) — quasi toujours omis (fourni par le container DI).
+	*/
+	constructor(name, repository, ...wiring) {
+		super(name, ...wiring);
+		this.repository = repository;
+	}
+	/**
+	* Liste les entités correspondant au critère (toutes si omis).
+	*
+	* @param criteria - filtre typé optionnel.
+	* @param options - eager-load / pagination / tri portables.
+	*/
+	find(criteria, options) {
+		return this.repository.find(criteria, options);
+	}
+	/**
+	* Première entité correspondant au critère, ou `null`.
+	*
+	* @param criteria - filtre de sélection.
+	* @param options - eager-load portable.
+	*/
+	findOne(criteria, options) {
+		return this.repository.findOne(criteria, options);
+	}
+	/**
+	* Entité par clé primaire `id`, ou `null`.
+	*
+	* @remarks Suppose une PK nommée `id` (convention Nodefony : UUID `string`).
+	* Override dans la sous-classe si la PK diffère.
+	* @param id - identifiant primaire.
+	* @param options - eager-load portable.
+	*/
+	findById(id, options) {
+		return this.repository.findOne({ id }, options);
+	}
+	/**
+	* Compte les entités correspondant au critère (toutes si omis).
+	*
+	* @param criteria - filtre optionnel.
+	*/
+	count(criteria) {
+		return this.repository.count(criteria);
+	}
+	/**
+	* Liste **une page** d'entités — pagination **native** (jamais matérialiser
+	* toute la collection). C'est la primitive à utiliser pour toute liste admin /
+	* data plane : elle ne charge qu'une page en mémoire, quelle que soit la taille
+	* de la table.
+	*
+	* @param page - requête de page ({@link PageQuery} : `limit` obligatoire,
+	*   `offset`/`order`/`criteria`/`withTotal` optionnels).
+	* @returns une {@link Page} : au plus `limit` items, `hasNext`, et `total` si demandé.
+	* @throws `PageQueryError` (`400`) si un `?q=` est reçu alors que
+	*   {@link AbstractCrudService.searchableFields} est vide.
+	*/
+	findPage(page) {
+		return paginate(this.repository, page, { searchable: this.searchableFields });
+	}
+	/**
+	* Champs sur lesquels `?q=` cherche — **vide par défaut, donc `q` est refusé**.
+	*
+	* Un service CRUD générique ne peut pas deviner ce qui, dans une entité, se
+	* cherche : un titre oui, une clé étrangère ou un horodatage non. Le défaut
+	* vide n'est donc pas une lacune mais la seule réponse honnête — et il refuse
+	* plutôt qu'il n'ignore, sans quoi une recherche non honorée rendrait toute la
+	* table sous un `200`.
+	*
+	* L'activer tient en une ligne dans le service concret, et la recherche
+	* devient alors réelle de bout en bout (`?q=` → `LIKE` ancré, indexable) :
+	*
+	* ```ts
+	* protected override readonly searchableFields = ["title", "slug"] as const;
+	* ```
+	*
+	* ⚠️ Le déclarer ici ne suffit PAS à ouvrir la route : le contrat de page
+	* refuse `q` en amont tant que le point d'entrée HTTP ne passe pas
+	* `searchable: true` à `parsePageQuery`. Les deux se déclarent, pour la même
+	* raison — une capacité se constate à chaque étage qu'elle traverse.
+	*/
+	searchableFields = [];
+	/**
+	* Crée une entité : `beforeCreate` → persistance → `afterCreate` → `onCreated`.
+	*
+	* @param data - champs de l'entité à créer.
+	* @returns l'entité persistée. Émet `onCreated`.
+	*/
+	async create(data) {
+		const prepared = await this.beforeCreate(data);
+		const entity = await this.repository.create(prepared);
+		await this.afterCreate(entity);
+		this.fire("onCreated", entity);
+		return entity;
+	}
+	/**
+	* Met à jour **au plus une** entité : `beforeUpdate` → persistance atomique
+	* → `afterUpdate` → `onUpdated`.
+	*
+	* S'appuie sur {@link IRepository.updateOne} (atomique, `RETURNING` /
+	* `findOneAndUpdate`) : l'entité retournée reflète l'écriture, donc l'event
+	* `onUpdated` part de façon fiable même quand le critère porte sur un champ
+	* modifié (corrige le faux `null` de l'ancien `update` + relecture).
+	*
+	* `updateMany` (mise à jour en masse) n'est volontairement **pas** exposée
+	* ici : c'est une primitive de niveau repository (`IRepository.updateMany`) —
+	* on la remontera dans un service le jour où un usage métier la réclame.
+	*
+	* @param criteria - filtre de sélection (champ inconnu → `UnknownCriteriaField`).
+	* @param data - champs à modifier.
+	* @returns l'entité mise à jour, ou `null` si aucune ne correspond (pas d'event).
+	*/
+	async updateOne(criteria, data) {
+		const prepared = await this.beforeUpdate(criteria, data);
+		const updated = await this.repository.updateOne(criteria, prepared);
+		if (updated !== null) {
+			await this.afterUpdate(updated);
+			this.fire("onUpdated", updated);
+		}
+		return updated;
+	}
+	/**
+	* Supprime : `beforeDelete` → persistance → `afterDelete` → `onDeleted`.
+	*
+	* @param criteria - filtre de sélection.
+	* @returns le nombre d'entités supprimées. Émet `onDeleted` (criteria, count)
+	*   uniquement si au moins une ligne a été supprimée.
+	*/
+	async delete(criteria) {
+		await this.beforeDelete(criteria);
+		const removed = await this.repository.delete(criteria);
+		if (removed > 0) {
+			await this.afterDelete(criteria, removed);
+			this.fire("onDeleted", criteria, removed);
+		}
+		return removed;
+	}
+	/**
+	* Transforme/valide les données avant création (ex. hacher un mot de passe).
+	*
+	* @param data - données entrantes.
+	* @returns les données préparées à persister.
+	*/
+	beforeCreate(data) {
+		return data;
+	}
+	/** Effet de bord après création (ex. provisionner une ressource liée). */
+	afterCreate(_entity) {}
+	/**
+	* Transforme/valide les données avant mise à jour.
+	*
+	* @param criteria - cible de la mise à jour.
+	* @param data - données entrantes.
+	* @returns les données préparées à persister.
+	*/
+	beforeUpdate(_criteria, data) {
+		return data;
+	}
+	/** Effet de bord après mise à jour. */
+	afterUpdate(_entity) {}
+	/** Garde/validation avant suppression (ex. interdire la suppression du dernier admin). */
+	beforeDelete(_criteria) {}
+	/** Effet de bord après suppression (ex. nettoyer un cache). */
+	afterDelete(_criteria, _removed) {}
+};
+//#endregion
+export { AbstractCrudService };

package/dist/nodefony/src/ConnectionMonitor.js

@@ -0,0 +1,181 @@
+//#region nodefony/src/ConnectionMonitor.ts
+/** Taille max du ring d'erreurs récentes (borne mémoire). */
+const MAX_RECENT_ERRORS = 12;
+/** Taille de la fenêtre glissante de latence (min/moy/max). */
+const MAX_LATENCY_SAMPLES = 30;
+/** Fenêtre de latence vide. */
+const EMPTY_LATENCY = {
+	last: null,
+	min: null,
+	avg: null,
+	max: null,
+	samples: 0
+};
+/** Compteurs neutres d'un connecteur jamais observé. */
+const EMPTY_CORE = {
+	connectedSince: null,
+	uptimeMs: null,
+	connectCount: 0,
+	reconnectCount: 0,
+	lostCount: 0,
+	errorCount: 0,
+	lastConnectMs: null,
+	lastError: null,
+	recentErrors: [],
+	latency: EMPTY_LATENCY
+};
+/**
+* **ConnectionMonitor** — observabilité **per-instance** (process-local) du
+* cycle de vie des connexions ORM : connexions, **reconnexions**, **erreurs**
+* (connexion + ping).
+*
+* Alimenté par la template method {@link Orm.connect} (capture latence + erreur
+* de connexion) et par le ping live de l'endpoint `connection/health`. Lecture
+* via {@link snapshot} (data plane ORM / dashboard Studio).
+*
+* **Cloud-native** : l'état d'une connexion DB est local au process (pool par
+* pod) → le moniteur est volontairement per-instance. La vue multi-pod relève
+* de l'agrégation (Prometheus par pod / fan-out Redis P13), pas de cette classe.
+*
+* **Perf** : structure lazy (`Map` allouée au 1ᵉʳ enregistrement) ; ring
+* d'erreurs alloué seulement au 1ᵉʳ incident ; aucun coût tant qu'aucun ORM ne
+* se connecte ou n'échoue. Reset au restart (diagnostic, pas d'état durable).
+*/
+var ConnectionMonitor = class {
+	/** `null` tant qu'aucun connecteur n'a été observé (lazy). */
+	#stats = null;
+	/** Crée/retourne les stats mutables d'un connecteur (alloue à la demande). */
+	#ensure(name) {
+		if (this.#stats === null) this.#stats = /* @__PURE__ */ new Map();
+		let s = this.#stats.get(name);
+		if (s === void 0) {
+			s = {
+				connectedSince: null,
+				connectCount: 0,
+				reconnectCount: 0,
+				lostCount: 0,
+				errorCount: 0,
+				lastConnectMs: null,
+				lastError: null,
+				recentErrors: null,
+				latencies: null
+			};
+			this.#stats.set(name, s);
+		}
+		return s;
+	}
+	/**
+	* Enregistre une latence de ping live dans la fenêtre glissante (ring borné).
+	*
+	* @param name - clé du connecteur.
+	* @param ms - latence du ping (ms).
+	*/
+	recordPing(name, ms) {
+		const s = this.#ensure(name);
+		if (s.latencies === null) s.latencies = [];
+		s.latencies.push(ms);
+		if (s.latencies.length > MAX_LATENCY_SAMPLES) s.latencies.shift();
+	}
+	/**
+	* Enregistre une connexion réussie + sa latence.
+	*
+	* Ne compte PAS une reconnexion : une reprise du driver ne repasse jamais
+	* par `Orm.connect()`, elle se signale par {@link ConnectionMonitor.recordReconnect}.
+	*
+	* @param name - clé du connecteur.
+	* @param latencyMs - durée de l'établissement (ms).
+	*/
+	recordConnect(name, latencyMs) {
+		const s = this.#ensure(name);
+		s.connectCount += 1;
+		s.connectedSince = Date.now();
+		s.lastConnectMs = Math.round(latencyMs * 100) / 100;
+	}
+	/**
+	* Enregistre une **perte** de connexion constatée par l'adapter.
+	*
+	* `connectedSince` retombe à `null` : un uptime qui continue de croître
+	* pendant que le serveur est tombé est pire qu'absent — il se lit comme une
+	* preuve de bonne santé.
+	*
+	* @param name - clé du connecteur.
+	*/
+	recordLost(name) {
+		const s = this.#ensure(name);
+		s.lostCount += 1;
+		s.connectedSince = null;
+	}
+	/**
+	* Enregistre une **reprise** de connexion constatée par l'adapter.
+	*
+	* @param name - clé du connecteur.
+	*/
+	recordReconnect(name) {
+		const s = this.#ensure(name);
+		s.reconnectCount += 1;
+		s.connectedSince = Date.now();
+	}
+	/**
+	* Enregistre une erreur (connexion échouée ou ping en échec).
+	*
+	* @param name - clé du connecteur.
+	* @param message - message d'erreur (credential déjà retiré par l'appelant).
+	*/
+	recordError(name, message) {
+		const s = this.#ensure(name);
+		s.errorCount += 1;
+		const err = {
+			message,
+			ts: Date.now()
+		};
+		s.lastError = err;
+		if (s.recentErrors === null) s.recentErrors = [];
+		s.recentErrors.unshift(err);
+		if (s.recentErrors.length > MAX_RECENT_ERRORS) s.recentErrors.length = MAX_RECENT_ERRORS;
+	}
+	/**
+	* Vue figée des compteurs d'un connecteur (ou compteurs neutres si jamais
+	* observé).
+	*
+	* @param name - clé du connecteur.
+	*/
+	snapshot(name) {
+		const s = this.#stats?.get(name);
+		if (s === void 0) return EMPTY_CORE;
+		const lat = s.latencies;
+		let latency = EMPTY_LATENCY;
+		if (lat && lat.length) {
+			let min = lat[0];
+			let max = lat[0];
+			let sum = 0;
+			for (const v of lat) {
+				if (v < min) min = v;
+				if (v > max) max = v;
+				sum += v;
+			}
+			latency = {
+				last: lat[lat.length - 1],
+				min: Math.round(min * 100) / 100,
+				avg: Math.round(sum / lat.length * 100) / 100,
+				max: Math.round(max * 100) / 100,
+				samples: lat.length
+			};
+		}
+		return {
+			connectedSince: s.connectedSince,
+			uptimeMs: s.connectedSince === null ? null : Date.now() - s.connectedSince,
+			connectCount: s.connectCount,
+			reconnectCount: s.reconnectCount,
+			lostCount: s.lostCount,
+			errorCount: s.errorCount,
+			lastConnectMs: s.lastConnectMs,
+			lastError: s.lastError,
+			recentErrors: s.recentErrors ?? [],
+			latency
+		};
+	}
+};
+/** Singleton process-wide du moniteur de connexions. */
+const connectionMonitor = new ConnectionMonitor();
+//#endregion
+export { connectionMonitor };

package/dist/nodefony/src/Entity.js

@@ -0,0 +1,42 @@
+import { entityRegistry } from "./EntityRegistry.js";
+//#region nodefony/src/Entity.ts
+/**
+* Classe de base abstraite d'une entité, indépendante du driver ORM.
+*
+* Porte le contrat {@link IEntity} : nom logique, connecteur cible, schéma natif
+* (calculé via {@link Entity.getSchema}), modèle compilé (post-connexion) et
+* relations déclaratives. {@link Entity.register} insère l'entité dans le
+* {@link entityRegistry} process-wide.
+*
+* **Pas d'auto-enregistrement dans le constructeur** : en TypeScript, le
+* constructeur de la classe de base s'exécute AVANT les initialiseurs de champs
+* de la sous-classe — `name`/`connector` seraient encore `undefined`. L'enregistrement
+* automatique est donc porté par le décorateur `@entity` (P5.3), qui lit les
+* métadonnées de classe ; en attendant, appeler explicitement
+* {@link Entity.register} après instanciation.
+*
+* @typeParam S - type du schéma natif du driver.
+* @typeParam M - type du modèle compilé natif du driver.
+*/
+var Entity = class {
+	/** Modèle compilé natif, renseigné après connexion de l'ORM. */
+	model;
+	/** Relations déclarées vers d'autres entités (par nom logique). */
+	relations;
+	/** Définition de schéma propre au driver (délègue à {@link Entity.getSchema}). */
+	get schema() {
+		return this.getSchema();
+	}
+	/**
+	* Enregistre cette entité dans le {@link entityRegistry} process-wide.
+	*
+	* @returns `this` (chaînable).
+	* @throws si l'entité est déjà enregistrée sur le même connecteur.
+	*/
+	register() {
+		entityRegistry.register(this);
+		return this;
+	}
+};
+//#endregion
+export { Entity };

package/dist/nodefony/src/EntityRegistry.js

@@ -0,0 +1,109 @@
+//#region nodefony/src/EntityRegistry.ts
+/**
+* Registre cross-ORM des entités, indexé par nom logique puis par connecteur.
+*
+* Une même entité logique (ex. `User`) peut exister sur plusieurs connexions :
+* l'index interne est `entities[entityName][connectorName] = IEntity`. Le lookup
+* {@link EntityRegistry.get} accepte un nom seul (résolu si l'entité n'existe
+* que sur un connecteur) ou un couple nom + connecteur pour lever l'ambiguïté.
+*
+* Structure pure (`Object.create(null)`) et lazy : rien n'est alloué tant
+* qu'aucune entité n'est enregistrée. Aucun coupling à `nodefony`.
+*/
+var EntityRegistry = class {
+	/** `entities[name][connector] = entity` — allouée au premier enregistrement. */
+	#entities = null;
+	/**
+	* Enregistre une entité pour son connecteur cible.
+	*
+	* @param entity - entité implémentant {@link IEntity} (utilise `name` + `connector`).
+	* @throws si cette entité est déjà enregistrée sur le même connecteur.
+	*/
+	register(entity) {
+		if (this.#entities === null) this.#entities = Object.create(null);
+		const store = this.#entities;
+		let bucket = store[entity.name];
+		if (bucket === void 0) {
+			bucket = Object.create(null);
+			store[entity.name] = bucket;
+		}
+		if (bucket[entity.connector] !== void 0) throw new Error(`EntityRegistry: entity "${entity.name}" already registered for connector "${entity.connector}".`);
+		bucket[entity.connector] = entity;
+	}
+	/**
+	* Résout une entité par nom (et connecteur si plusieurs candidats).
+	*
+	* @param name - nom logique de l'entité (ex. `"User"`).
+	* @param connector - connecteur cible ; obligatoire si l'entité existe sur plusieurs.
+	* @returns l'entité correspondante.
+	* @throws si l'entité est inconnue, absente du connecteur demandé, ou ambiguë
+	*   (plusieurs connecteurs) sans `connector` précisé.
+	*/
+	get(name, connector) {
+		const bucket = this.#entities?.[name];
+		if (bucket === void 0) throw new Error(`EntityRegistry: no entity registered under "${name}".`);
+		if (connector !== void 0) {
+			const entity = bucket[connector];
+			if (entity === void 0) throw new Error(`EntityRegistry: entity "${name}" is not registered for connector "${connector}".`);
+			return entity;
+		}
+		const connectors = Object.keys(bucket);
+		if (connectors.length > 1) throw new Error(`EntityRegistry: entity "${name}" exists on multiple connectors (${connectors.join(", ")}); specify one.`);
+		return bucket[connectors[0]];
+	}
+	/**
+	* Indique si une entité (optionnellement sur un connecteur précis) est enregistrée.
+	*
+	* @param name - nom logique de l'entité.
+	* @param connector - connecteur cible facultatif.
+	*/
+	has(name, connector) {
+		const bucket = this.#entities?.[name];
+		if (bucket === void 0) return false;
+		return connector === void 0 ? true : bucket[connector] !== void 0;
+	}
+	/**
+	* Liste toutes les entités enregistrées, tous connecteurs confondus.
+	*
+	* @returns tableau d'entités (vide si registre vide).
+	*/
+	list() {
+		if (this.#entities === null) return [];
+		const out = [];
+		for (const name in this.#entities) {
+			const bucket = this.#entities[name];
+			for (const connector in bucket) out.push(bucket[connector]);
+		}
+		return out;
+	}
+	/**
+	* Retire une entité du registre (teardown tests / hot-reload).
+	*
+	* @param name - nom logique de l'entité.
+	* @param connector - si fourni, retire seulement cette variante ; sinon toutes.
+	* @returns `true` si quelque chose a été retiré, `false` sinon.
+	*/
+	unregister(name, connector) {
+		const store = this.#entities;
+		if (store === null) return false;
+		const bucket = store[name];
+		if (bucket === void 0) return false;
+		if (connector === void 0) {
+			delete store[name];
+			return true;
+		}
+		if (bucket[connector] === void 0) return false;
+		delete bucket[connector];
+		if (Object.keys(bucket).length === 0) delete store[name];
+		return true;
+	}
+};
+/**
+* Singleton process-wide partagé. Les entités s'y enregistrent (via le
+* décorateur `entities([...])` posé sur le Module, ou {@link Entity.register}).
+* La classe {@link EntityRegistry} reste instanciable pour des registres isolés
+* (tests).
+*/
+const entityRegistry = new EntityRegistry();
+//#endregion
+export { EntityRegistry, entityRegistry };