@navette-js/panels 1.0.0-beta.1 → 1.0.0-beta.2

package/lib/index.js

@@ -1,10 +1,19 @@
-// @navette-js/panels — port de filament/panels : Panel, mises en page, pages, navigation, connexion, session.
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+// @navette-js/panels: Panel, layouts, pages, resources, navigation, authentication and session.
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { createHash, createHmac, timingSafeEqual } from 'node:crypto';
 import { checkVerificationUrl, consoleMailer, readToken, signToken, signVerificationUrl } from "./auth.js";
 export { consoleMailer, fileMailer, hashPassword, knexAuthProvider, knexTenantProvider, mailText, verifyPassword } from "./auth.js";
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import express from 'express';
 import { Action, useColorManager, ActionGroup } from '@navette-js/actions';
 import { Checkbox, Field, Select, TextInput, Wizard, richDocumentToHtml, richHtmlToDocument, fillSchema, fillSchemaFromRecord, getSchemaState, validateSchema, useColorManager as useFormsColorManager } from '@navette-js/forms';
@@ -28,7 +37,6 @@ views.namespace('filament-panels', dir('../views'));
 views.namespace('filament', fileURLToPath(new URL('../views', import.meta.resolve('@navette-js/support'))));
 views.share({ t, tc });
 export const ASSET_VERSION = '5.11.2.0';
-// ------------------------------------------------------------------ navigation
 export class NavigationItem {
     label;
     _url = '#';
@@ -45,12 +53,11 @@ export class NavigationItem {
     group(group) { this._group = group; return this; }
     sort(sort) { this._sort = sort; return this; }
     badge(badge, color = 'primary') { this._badge = badge; this._badgeColor = color; return this; }
-    /** Par défaut un élément est actif sur son URL exacte, comme une page Filament (les resources fourniront leur propre règle). */
+    /** By default an item is active on its exact URL; this overrides the rule. */
     isActiveWhen(fn) { this._isActive = fn; return this; }
     isActive(path) { return this._isActive ? this._isActive(path) : path === this._url; }
 }
 const slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
-// ------------------------------------------------------------------ panel
 export class Panel {
     _id = 'admin';
     _path = '';
@@ -79,31 +86,31 @@ export class Panel {
     brandLogo(url) { this._brandLogo = url; return this; }
     darkModeBrandLogo(url) { this._darkModeBrandLogo = url; return this; }
     brandLogoHeight(height) { this._brandLogoHeight = height; return this; }
-    /** Icône d'onglet du navigateur. */
+    /** Browser tab icon. */
     favicon(url) { this._favicon = url; return this; }
     getFavicon() { return this._favicon; }
     /**
-     * Feuille de thème compilée par l'application (Tailwind) : elle remplace la feuille par défaut de Filament.
-     * Équivalent de `->viteTheme()` : le thème importe `@navette-js/panels/theme.css` et déclare ses propres sources.
+     * Theme stylesheet compiled by the application (Tailwind); it replaces the default stylesheet.
+     * The theme imports `@navette-js/panels/theme.css` and declares its own sources.
      */
     theme(url) { this._theme = url; return this; }
     getTheme() { return this._theme; }
     /**
-     * Mouvement et indicateurs de chargement propres à Navette (ressorts, pastille d'activité, roue des zones différées).
-     * C'est un écart assumé avec Filament : `motion(false)` rend l'interface d'origine, sans rien d'ajouté.
+     * Navette's motion and loading indicators (springs, activity dot, spinner for deferred areas).
+     * `motion(false)` renders the plain interface without them.
      */
     motion(enabled = true) { this._motion = enabled; return this; }
     hasMotion() { return this._motion; }
-    /** Thèmes proposés à l'utilisateur ; le premier est le thème par défaut. */
+    /** Themes offered to the user; the first one is the default. */
     themes(themes) {
         for (const theme of themes)
             if (!/^[a-z0-9-]{1,40}$/.test(theme.id))
-                throw new Error(`Identifiant de thème invalide : ${theme.id}`);
+                throw new Error(`Invalid theme id: ${theme.id}`);
         this._themes = themes;
         return this;
     }
     getThemes() { return this._themes; }
-    /** Thème de la requête : celui du cookie s'il est déclaré, sinon le premier. Null si le panel n'a pas de thèmes. */
+    /** Theme for the request: the cookie's theme if declared, otherwise the first one. `null` if the panel has no themes. */
     resolveTheme(req) {
         if (!this._themes.length)
             return null;
@@ -111,17 +118,17 @@ export class Panel {
         return this._themes.find((theme) => theme.id === id) ?? this._themes[0];
     }
     rememberTheme(res, theme) { res.cookie(`navette_${this._id}_theme`, theme.id, { sameSite: 'lax', secure: res.req?.secure === true, maxAge: 1000 * 60 * 60 * 24 * 365 }); }
-    /** Exécute un rendu avec les couleurs du thème de la requête. */
+    /** Runs a render with the colors of the request's theme. */
     withTheme(req, fn) {
         const theme = this.resolveTheme(req);
-        // Les composants des autres paquets lisent un gestionnaire de couleurs partagé par tous les panels :
-        // les couleurs de ce panel (et de son thème) n'y valent que le temps de la requête.
+        // Components from other packages read a color manager shared by all panels:
+        // this panel's (and its theme's) colors only apply for the duration of the request.
         const withPanelColors = () => sharedColors.runWith(`${this._id}:${theme?.id ?? ''}`, this.colors.getColors(), fn);
-        // Les render hooks du panel ne valent que pour ses propres requêtes.
+        // A panel's render hooks only apply to its own requests.
         return runWithRenderHooks(this._renderHooks, () => (theme?.colors ? this.colors.runWith(theme.id, theme.colors, withPanelColors) : withPanelColors()));
     }
     setColors(colors) { this.colors.register(colors); return this; }
-    /** Police du panel. Sans URL : fournisseur Bunny Fonts, comme `->font('Albert Sans')` dans Filament. */
+    /** Panel font. Without a URL, it is loaded from Bunny Fonts. */
     font(family, url) {
         this._font = { family, url: url ?? `https://fonts.bunny.net/css?family=${slug(family)}:400,500,600,700&display=swap`, preconnect: url ? null : 'https://fonts.bunny.net' };
         return this;
@@ -130,7 +137,7 @@ export class Panel {
     auth(provider) { this._auth = provider; return this; }
     key(key) { this._key = key; return this; }
     pages(pages) { this._pages.push(...pages); return this; }
-    /** Enregistre des resources : leurs pages et leur élément de navigation. */
+    /** Registers resources: their pages and navigation items. */
     resources(resources) {
         for (const resource of resources) {
             resource.panel = this;
@@ -140,13 +147,13 @@ export class Panel {
         return this;
     }
     navigationItems(items) { this._navigationItems.push(...items); return this; }
-    /** Ordre des groupes de navigation. */
+    /** Order of navigation groups. */
     navigationGroups(groups) { this._navigationGroups = groups; return this; }
     _plugins = [];
-    /** Applique un plugin : un objet qui configure le panel (resources, pages, render hooks, thèmes…). */
+    /** Applies a plugin: an object that configures the panel (resources, pages, render hooks, themes…). */
     plugin(plugin) {
         if (this._plugins.some((p) => p.id === plugin.id))
-            throw new Error(`Plugin déjà enregistré : ${plugin.id}`);
+            throw new Error(`Plugin already registered: ${plugin.id}`);
         this._plugins.push(plugin);
         plugin.register(this);
         return this;
@@ -156,15 +163,15 @@ export class Panel {
     getPlugins() { return this._plugins; }
     _renderHooks = new RenderHookRegistry();
     /**
-     * Insère du HTML à un emplacement nommé de l'interface de ce panel (noms : `PanelsRenderHook`, `TablesRenderHook`, `ActionsRenderHook`, `WidgetsRenderHook`).
-     * `scopes` limite le hook à certaines pages ou resources (leur classe). Le HTML rendu est inséré tel quel : échappez toute donnée avec `e()`.
+     * Inserts HTML at a named location of this panel's UI (names: `PanelsRenderHook`, `TablesRenderHook`, `ActionsRenderHook`, `WidgetsRenderHook`).
+     * `scopes` limits the hook to some pages or resources (their class). The HTML is inserted as-is: escape any data with `e()`.
      */
     renderHook(name, render, scopes = null) { this._renderHooks.register(name, render, scopes); return this; }
     getRenderHooks() { return this._renderHooks; }
     _authorizer = null;
-    /** Branche votre propre système de permissions : consulté avant toute politique, pour chaque capacité, page et widget. */
+    /** Plugs in your own permission system: consulted before any policy, for every ability, page and widget. */
     authorizeUsing(authorizer) { this._authorizer = authorizer; return this; }
-    /** Décision d'autorisation : le crochet du panel d'abord, puis la règle fournie ; sans utilisateur, toujours non. */
+    /** Authorization decision: the panel hook first, then the given rule. Always `false` without a user. */
     async authorize(user, ability, subject = {}) {
         if (!user)
             return false;
@@ -173,7 +180,7 @@ export class Panel {
             return decided;
         return subject.rule ? Boolean(await subject.rule()) : true;
     }
-    /** Une page est-elle accessible à cet utilisateur ? Liste : `viewAny` ; création : `create` ; édition : vérifiée sur l'enregistrement ; page libre : `canAccess`. */
+    /** Whether the user can open a page. List: `viewAny`; create: `create`; edit: checked against the record; custom page: `canAccess`. */
     async canAccessPage(PageClass, user) {
         const resource = PageClass.resource;
         if (resource && PageClass.prototype instanceof EditRecord)
@@ -185,37 +192,37 @@ export class Panel {
         return this.authorize(user, 'access', { page: PageClass, rule: () => PageClass.canAccess(user) });
     }
     _widgets = [];
-    /** Widgets du panel (tableau de bord, pages libres) : enregistrés comme composants, à afficher par `getHeaderWidgets()` d'une page. */
+    /** Panel widgets (dashboard, custom pages): registered as components, displayed through a page's `getHeaderWidgets()`. */
     widgets(widgets) { this._widgets.push(...widgets); return this; }
     getWidgets() { return this._widgets; }
     maxContentWidth(width) { this._maxContentWidth = width; return this; }
     getId() { return this._id; }
     getBrandName() { return this._brandName; }
     getAuth() { if (!this._auth)
-        throw new Error('Aucun fournisseur d\'authentification : panel.auth(...).'); return this._auth; }
+        throw new Error('No auth provider: call panel.auth(...).'); return this._auth; }
     getLoginPage() { return this._login; }
     getPages() { return this._pages; }
     getResources() { return this._resources; }
-    // -------------------------------------------------------------- recherche globale
+    // -------------------------------------------------------------- global search
     _globalSearch = true;
     _globalSearchKeyBindings = [];
     _globalSearchDebounce = '500ms';
     _globalSearchSuffix = null;
-    /** `false` retire le champ de recherche globale. Il n'apparaît de toute façon que si une resource est cherchable. */
+    /** `false` removes the global search field. It only appears when at least one resource is searchable. */
     globalSearch(condition = true) { this._globalSearch = condition; return this; }
-    /** Raccourcis qui placent le curseur dans le champ : `['command+k', 'ctrl+k']`. */
+    /** Keyboard shortcuts that focus the field: `['command+k', 'ctrl+k']`. */
     globalSearchKeyBindings(keyBindings) { this._globalSearchKeyBindings = keyBindings.filter((binding) => /^[a-z0-9+]+$/.test(binding)); return this; }
     getGlobalSearchKeyBindings() { return this._globalSearchKeyBindings; }
-    /** Délai entre la frappe et la recherche (`500ms` par défaut). */
+    /** Delay between typing and searching (`500ms` by default). */
     globalSearchDebounce(debounce) { if (/^[0-9]+m?s$/.test(debounce))
         this._globalSearchDebounce = debounce; return this; }
     getGlobalSearchDebounce() { return this._globalSearchDebounce; }
     globalSearchFieldSuffix(suffix) { this._globalSearchSuffix = suffix; return this; }
-    /** Affiche le premier raccourci dans le champ, écrit selon la plateforme du navigateur (comme Filament : « META+K » hors Mac pour `command+k`). */
+    /** Shows the first shortcut in the field, written for the browser's platform (`command+k` shows as "META+K" outside macOS). */
     globalSearchFieldKeyBindingSuffix() { this._globalSearchSuffix = (userAgent) => keyBindingSuffix(this._globalSearchKeyBindings, userAgent); return this; }
     getGlobalSearchFieldSuffix(userAgent = '') { return typeof this._globalSearchSuffix === 'function' ? this._globalSearchSuffix(userAgent) : this._globalSearchSuffix; }
     hasGlobalSearch() { return this._globalSearch && this._resources.some((resource) => resource.canGloballySearch()); }
-    /** Résultats par resource, dans l'ordre d'enregistrement ; seules les resources que l'utilisateur peut lister sont interrogées. */
+    /** Results per resource, in registration order. Only resources the user can list are queried. */
     async getGlobalSearchResults(search, user) {
         const categories = [];
         if (!this._globalSearch)
@@ -230,38 +237,38 @@ export class Panel {
         }
         return categories;
     }
-    // -------------------------------------------------------------- notifications en base
+    // -------------------------------------------------------------- database notifications
     _databaseNotifications = null;
     _databaseNotificationsPolling = '30s';
-    /** Active la cloche des notifications enregistrées en base, lues et écrites par ce stockage (`knexNotificationStore(knex)`). */
+    /** Enables the database notifications bell, read from and written to this store (`knexNotificationStore(knex)`). */
     databaseNotifications(store) { this._databaseNotifications = store; return this; }
     getDatabaseNotifications() { return this._databaseNotifications; }
-    /** Intervalle de rafraîchissement (`30s` par défaut) ; `null` pour ne pas interroger le serveur. */
+    /** Polling interval (`30s` by default); `null` disables polling. */
     databaseNotificationsPolling(interval) { this._databaseNotificationsPolling = interval; return this; }
     getDatabaseNotificationsPollingInterval() { return this._databaseNotificationsPolling; }
-    // -------------------------------------------------------------- mise en page : barre du haut, navigation, sidebar
+    // -------------------------------------------------------------- layout: topbar, navigation, sidebar
     _topbar = true;
     _topNavigation = false;
     _navigation = true;
     _sidebarCollapsibleOnDesktop = false;
     _sidebarFullyCollapsibleOnDesktop = false;
     _positions = { userMenu: null, globalSearch: null, databaseNotifications: null };
-    /** Barre du haut (présente par défaut, comme dans Filament) : `topbar(false)` met logo, recherche, cloche et menu dans la sidebar. */
+    /** Topbar, shown by default. `topbar(false)` moves the logo, search, bell and user menu into the sidebar. */
     topbar(condition = true) { this._topbar = condition; return this; }
     hasTopbar() { return this._topbar; }
-    /** Navigation dans la barre du haut (menus déroulants par groupe) au lieu de la sidebar. */
+    /** Navigation in the topbar (one dropdown per group) instead of the sidebar. */
     topNavigation(condition = true) { this._topNavigation = condition; return this; }
     hasTopNavigation() { return this._topNavigation; }
-    /** `navigation(false)` retire toute navigation (ni sidebar ni menus). */
+    /** `navigation(false)` removes all navigation (no sidebar, no menus). */
     navigation(condition = true) { this._navigation = condition; return this; }
     hasNavigation() { return this._navigation; }
-    /** Sidebar repliable sur grand écran en une colonne d'icônes. */
+    /** On desktop, the sidebar can collapse to a column of icons. */
     sidebarCollapsibleOnDesktop(condition = true) { this._sidebarCollapsibleOnDesktop = condition; return this; }
     isSidebarCollapsibleOnDesktop() { return this._sidebarCollapsibleOnDesktop; }
-    /** Sidebar entièrement masquable sur grand écran. */
+    /** On desktop, the sidebar can be fully hidden. */
     sidebarFullyCollapsibleOnDesktop(condition = true) { this._sidebarFullyCollapsibleOnDesktop = condition; return this; }
     isSidebarFullyCollapsibleOnDesktop() { return this._sidebarFullyCollapsibleOnDesktop; }
-    /** Emplacement du menu utilisateur ; par défaut, la barre du haut si elle existe. */
+    /** Where the user menu goes; defaults to the topbar when there is one. */
     userMenuPosition(position) { this._positions.userMenu = position; return this; }
     getUserMenuPosition() { return this._positions.userMenu ?? (this._topbar ? 'topbar' : 'sidebar'); }
     globalSearchPosition(position) { this._positions.globalSearch = position; return this; }
@@ -269,37 +276,37 @@ export class Panel {
     databaseNotificationsPosition(position) { this._positions.databaseNotifications = position; return this; }
     getDatabaseNotificationsPosition() { return this._positions.databaseNotifications ?? (this._topbar ? 'topbar' : 'sidebar'); }
     _userMenuItems = {};
-    /** Éléments ajoutés au menu utilisateur (actions à adresse ou à modale). `sort()` négatif : au-dessus du choix du thème. Clés `profile` et `logout` : remplacent ceux par défaut. */
+    /** Items added to the user menu (URL or modal actions). A negative `sort()` places them above the theme switcher. Keys `profile` and `logout` replace the defaults. */
     userMenuItems(items) {
         for (const [key, item] of Array.isArray(items) ? items.map((item) => [item.getName(), item]) : Object.entries(items))
             this._userMenuItems[key] = item;
         return this;
     }
     getUserMenuItems() { return this._userMenuItems; }
-    // -------------------------------------------------------------- inscription, mot de passe oublié, vérification, profil
+    // -------------------------------------------------------------- registration, password reset, email verification, profile
     _registration = null;
     _passwordReset = null;
     _emailVerification = null;
     _profile = null;
     _mailer = consoleMailer;
-    /** Page d'inscription (`/register`). Le fournisseur d'utilisateurs doit savoir créer (`create`) et chercher par adresse (`findByEmail`). */
+    /** Registration page (`/register`). The auth provider must implement `create` and `findByEmail`. */
     registration(page = Register) { this._registration = page; return this; }
     hasRegistration() { return this._registration !== null; }
     getRegistrationPage() { return this._registration; }
-    /** Mot de passe oublié : demande (`/password-reset/request`) et réinitialisation par un lien signé envoyé par e-mail. */
+    /** Password reset: request page (`/password-reset/request`), then reset through a signed link sent by email. */
     passwordReset(request = RequestPasswordReset, reset = ResetPassword) { this._passwordReset = { request, reset }; return this; }
     hasPasswordReset() { return this._passwordReset !== null; }
     getPasswordResetPages() { return this._passwordReset; }
-    /** Vérification de l'adresse e-mail : un lien signé est envoyé à l'inscription ; tant qu'il n'est pas suivi, seule l'invitation à vérifier est accessible (`isRequired`). */
+    /** Email verification: a signed link is sent on registration. Until it is followed, only the verification prompt is accessible (`isRequired`). */
     emailVerification(prompt = EmailVerificationPrompt, isRequired = true) { this._emailVerification = { prompt, isRequired }; return this; }
     hasEmailVerification() { return this._emailVerification !== null; }
     isEmailVerificationRequired() { return this._emailVerification?.isRequired === true; }
     getEmailVerificationPrompt() { return this._emailVerification?.prompt ?? null; }
-    /** Page de profil (`/profile`) : nom, adresse, mot de passe. `isSimple` : mise en page simple (par défaut) ou complète. */
+    /** Profile page (`/profile`): name, email, password. `isSimple`: simple layout (default) or full panel layout. */
     profile(page = EditProfile, isSimple = true) { this._profile = { page, isSimple }; return this; }
     hasProfile() { return this._profile !== null; }
     getProfile() { return this._profile; }
-    /** Envoi des e-mails (réinitialisation, vérification). Par défaut : écrits dans la console. */
+    /** Mailer for password reset and verification emails. Defaults to the console. */
     mailer(mailer) { this._mailer = mailer; return this; }
     async sendMail(message) { await this._mailer.send(message); }
     getAuthKey() { return this._key; }
@@ -309,7 +316,7 @@ export class Panel {
         const token = signToken(this._key, `${this._id}.password-reset`, { uid: user.id, fp: fingerprint }, 60 * 60);
         return `${this.getBaseUrl('password-reset/reset')}?email=${encodeURIComponent(user.email)}&token=${encodeURIComponent(token)}`;
     }
-    /** Charge d'un jeton de réinitialisation valide pour ce panel, sinon `null`. */
+    /** Payload of a password reset token valid for this panel, otherwise `null`. */
     readResetPasswordToken(token) { return readToken(this._key, `${this._id}.password-reset`, token); }
     getVerifyEmailUrl(user) {
         const expires = Math.floor(Date.now() / 1000) + 60 * 60;
@@ -319,14 +326,14 @@ export class Panel {
     checkVerifyEmailUrl(id, hash, expires, signature) { return checkVerificationUrl(`${this._key}.${this._id}`, id, hash, expires, signature); }
     getEmailVerificationPromptUrl() { return this.getBaseUrl('email-verification/prompt'); }
     getProfileUrl() { return this._profile ? this.getBaseUrl('profile') : null; }
-    /** L'utilisateur doit-il encore vérifier son adresse avant d'utiliser le panel ? */
+    /** Whether the user must still verify their email before using the panel. */
     async mustVerifyEmail(user) {
         if (!user || !this.isEmailVerificationRequired())
             return false;
         const auth = this.getAuth();
         return auth.hasVerifiedEmail ? !(await auth.hasVerifiedEmail(user)) : false;
     }
-    // -------------------------------------------------------------- locataires (multi-tenancy)
+    // -------------------------------------------------------------- multi-tenancy
     _tenant = null;
     _tenantOwnershipColumn = null;
     _tenantRegistration = null;
@@ -335,18 +342,18 @@ export class Panel {
     _tenantMenuItems = {};
     _tenantScope = new AsyncLocalStorage();
     /**
-     * Rend le panel multi-locataire. `ownershipColumn` : colonne qui rattache un enregistrement à son locataire (`team_id`) ;
-     * les resources du panel ne lisent et n'écrivent alors que les enregistrements du locataire courant (voir `Resource.isScopedToTenant`).
+     * Makes the panel multi-tenant. `ownershipColumn` is the column linking a record to its tenant (`team_id`);
+     * the panel's resources then only read and write the current tenant's records (see `Resource.isScopedToTenant`).
      */
     tenant(provider, options = {}) { this._tenant = provider; this._tenantOwnershipColumn = options.ownershipColumn ?? null; return this; }
     hasTenancy() { return this._tenant !== null; }
     getTenantProvider() { if (!this._tenant)
-        throw new Error('Panel sans locataires : panel.tenant(...).'); return this._tenant; }
+        throw new Error('Panel has no tenancy: call panel.tenant(...).'); return this._tenant; }
     getTenantOwnershipColumn() { return this._tenantOwnershipColumn; }
-    /** Page de création d'un locataire (`/new`). */
+    /** Tenant registration page (`/new`). */
     tenantRegistration(page) { this._tenantRegistration = page; return this; }
     getTenantRegistrationPage() { return this._tenantRegistration; }
-    /** Page de profil du locataire (`/<locataire>/profile`). */
+    /** Tenant profile page (`/<tenant>/profile`). */
     tenantProfile(page) { this._tenantProfile = page; return this; }
     getTenantProfilePage() { return this._tenantProfile; }
     tenantMenu(condition = true) { this._tenantMenu = condition; return this; }
@@ -357,41 +364,41 @@ export class Panel {
         return this;
     }
     getTenantMenuItems() { return this._tenantMenuItems; }
-    /** Exécute `fn` pour un locataire : les adresses produites (`getUrl`) et les requêtes des resources lui sont rattachées. */
+    /** Runs `fn` for a tenant: generated URLs (`getUrl`) and resource queries are scoped to it. */
     withTenant(tenant, fn) { return this._tenantScope.run({ tenant }, fn); }
-    /** Locataire de la requête en cours (équivalent de `Filament::getTenant()`), ou `null`. */
+    /** Tenant of the current request, or `null`. */
     getTenant() { return (this._tenantScope.getStore()?.tenant ?? null); }
     getTenantUrlKey(tenant) { return this.getTenantProvider().getKey(tenant); }
     _subNavigationPosition = 'start';
-    /** Position par défaut de la sous-navigation des pages (`start`, comme Filament). */
+    /** Default position of page sub-navigation (`start`). */
     subNavigationPosition(position) { this._subNavigationPosition = position; return this; }
     getSubNavigationPosition() { return this._subNavigationPosition; }
     _appUrl = null;
-    /** Adresse publique de l'application (`https://exemple.fr`), utilisée dans les liens envoyés par e-mail. Sans elle, l'origine de la requête est reprise : à éviter en production (en-tête `Host` falsifiable). */
+    /** Public URL of the application (`https://example.com`), used in emailed links. Without it the request origin is used, which should be avoided in production (the `Host` header can be forged). */
     appUrl(url) { this._appUrl = url ? url.replace(/\/$/, '') : null; return this; }
     getAppUrl() { return this._appUrl; }
     getMaxContentWidth() { return this._maxContentWidth; }
-    /** Adresse dans le panel ; dans un panel à locataires, préfixée par le locataire courant (ou celui donné). */
+    /** URL inside the panel; in a multi-tenant panel, prefixed with the current (or given) tenant. */
     getUrl(sub = '', tenant = this.getTenant()) {
         if (this._tenant && tenant)
             return '/' + [this._path, encodeURIComponent(this.getTenantUrlKey(tenant)), sub.replace(/^\/|\/$/g, '')].filter(Boolean).join('/');
         return this.getBaseUrl(sub);
     }
-    /** Adresse hors locataire (connexion, inscription, profil, création d'un locataire). */
+    /** URL outside any tenant (login, registration, profile, tenant registration). */
     getBaseUrl(sub = '') { return '/' + [this._path, sub.replace(/^\/|\/$/g, '')].filter(Boolean).join('/'); }
     getLoginUrl() { return this.getBaseUrl('login'); }
     getLogoutUrl() { return this.getBaseUrl('logout'); }
-    /** Préfixe de l'endpoint Livewire de ce panel (`/livewire`, ou `/<chemin>/livewire`) : chaque panel a le sien. */
+    /** Prefix of this panel's Livewire endpoint (`/livewire` or `/<path>/livewire`): each panel has its own. */
     getLivewirePrefix() { return this._path ? `/${this._path}/livewire` : '/livewire'; }
     assetUrl(file) { return `/${file}?v=${ASSET_VERSION}`; }
     getBrand() { return { name: this._brandName, logo: this._brandLogo, darkLogo: this._darkModeBrandLogo, height: this._brandLogoHeight }; }
     getFont() { return this._font; }
-    /** Avatar par défaut : port de UiAvatarsProvider (service externe ui-avatars.com, initiales du nom). */
+    /** Default avatar: the name's initials from the external ui-avatars.com service. */
     getUserAvatarUrl(user) { return this.getAvatarUrlFor(user.name); }
-    /** Avatar d'un locataire : celui de son fournisseur (`getAvatarUrl`), sinon ses initiales. */
+    /** Tenant avatar: from the tenant provider (`getAvatarUrl`), otherwise its initials. */
     getTenantAvatarUrl(tenant) { return this.getTenantProvider().getAvatarUrl?.(tenant) ?? this.getAvatarUrlFor(this.getTenantProvider().getName(tenant)); }
     _spa = false;
-    /** Navigation sans rechargement (`wire:navigate`) entre les pages du panel, comme `->spa()`. */
+    /** SPA mode: navigate between panel pages without full reloads (`wire:navigate`). */
     spa(condition = true) { this._spa = condition; return this; }
     hasSpaMode() { return this._spa; }
     getAvatarUrlFor(name) {
@@ -399,8 +406,8 @@ export class Panel {
         const background = '#' + convertToRgb(this.colors.getColor('gray')[950]).map((n) => n.toString(16).padStart(2, '0')).join('');
         return `https://ui-avatars.com/api/?name=${encodeURIComponent(initials).replace(/%20/g, '+')}&format=svg&color=FFFFFF&background=${encodeURIComponent(background)}`;
     }
-    /** Groupes de navigation : pages enregistrées + éléments libres, triés, groupés dans l'ordre déclaré. */
-    /** Compteurs de navigation calculés (équivalent de getNavigationBadge()) : adresse de la page → valeur. */
+    /** Navigation groups: registered pages plus custom items, sorted, grouped in the declared order. */
+    /** Computed navigation badges: page URL → value. */
     async resolveNavigationBadges() {
         const badges = new Map();
         for (const page of this._pages)
@@ -408,7 +415,7 @@ export class Panel {
                 badges.set(page.slug, await page.getNavigationBadge());
         return badges;
     }
-    /** Adresses des pages du menu que cet utilisateur ne peut pas ouvrir. */
+    /** URLs of menu pages this user cannot open. */
     async resolveInaccessiblePages(user) {
         const hidden = new Set();
         for (const page of this._pages)
@@ -431,7 +438,7 @@ export class Panel {
             return { label, itemsId: label ? `fi-sidebar-group-items-${slug(label)}-${createHash('md5').update(label).digest('hex').slice(0, 8)}` : '', isActive: own.some((i) => i.isActive), items: own };
         }).filter((g) => g.items.length);
     }
-    // --- session : cookie signé (identifiant d'utilisateur), suffisant pour le jalon 2
+    // --- session: an HMAC-signed cookie holding the user id
     sign(value) { return createHmac('sha256', this._key).update(value).digest('base64url'); }
     logIn(res, user, remember) {
         const value = Buffer.from(JSON.stringify({ uid: user.id })).toString('base64url');
@@ -454,11 +461,8 @@ export class Panel {
         }
     }
 }
-// ------------------------------------------------------------------ render hooks
 /**
- * Emplacements de render hook d'un panel — mêmes noms que `Filament\View\PanelsRenderHook`.
- * Ceux d'une brique pas encore portée (barre du haut, recherche globale, menu de locataire, sous-navigation, inscription,
- * réinitialisation du mot de passe, enregistrements liés) sont déclarés mais ne sont rendus nulle part pour l'instant : voir `UNPLACED_RENDER_HOOKS`.
+ * Render hook locations of a panel. A few are declared but not rendered anywhere yet: see `UNPLACED_RENDER_HOOKS`.
  */
 export const PanelsRenderHook = {
     AUTH_LOGIN_FORM_AFTER: 'panels::auth.login.form.after',
@@ -498,7 +502,7 @@ export const PanelsRenderHook = {
     PAGE_HEADER_WIDGETS_END: 'panels::page.header-widgets.end',
     PAGE_HEADER_WIDGETS_START: 'panels::page.header-widgets.start',
     PAGE_START: 'panels::page.start',
-    /** Le nom contient « module-menu » dans Filament : conservé tel quel. */
+    /** The hook name says "module-menu", not "mobile-menu": kept for compatibility. */
     PAGE_SUB_NAVIGATION_MOBILE_MENU_AFTER: 'panels::page.sub-navigation.module-menu.after',
     PAGE_SUB_NAVIGATION_MOBILE_MENU_BEFORE: 'panels::page.sub-navigation.module-menu.before',
     PAGE_SUB_NAVIGATION_SIDEBAR_AFTER: 'panels::page.sub-navigation.sidebar.after',
@@ -546,23 +550,21 @@ export const PanelsRenderHook = {
     USER_MENU_PROFILE_AFTER: 'panels::user-menu.profile.after',
     USER_MENU_PROFILE_BEFORE: 'panels::user-menu.profile.before',
 };
-/** Emplacements de render hook des widgets — mêmes noms que `Filament\Widgets\View\WidgetsRenderHook`. Rendus par `TableWidget`. */
+/** Widget render hook locations, rendered by `TableWidget`. */
 export const WidgetsRenderHook = {
     TABLE_WIDGET_END: 'widgets::table-widget.end',
     TABLE_WIDGET_START: 'widgets::table-widget.start',
 };
 /**
- * Emplacements déclarés mais rendus nulle part pour l'instant, avec la brique qui leur manque.
- * Les quatre « tabs » ne sont rendus par aucune vue de Filament 5.11.2 non plus.
+ * Hook locations that are declared but not rendered anywhere yet, with the reason.
  */
 export const UNPLACED_RENDER_HOOKS = {
-    ...Object.fromEntries(['RESOURCE_PAGES_MANAGE_RELATED_RECORDS_TABLE_AFTER', 'RESOURCE_PAGES_MANAGE_RELATED_RECORDS_TABLE_BEFORE'].map((k) => [PanelsRenderHook[k], 'page ManageRelatedRecords'])),
-    ...Object.fromEntries(['RESOURCE_PAGES_LIST_RECORDS_TABS_END', 'RESOURCE_PAGES_LIST_RECORDS_TABS_START', 'RESOURCE_TABS_END', 'RESOURCE_TABS_START'].map((k) => [PanelsRenderHook[k], 'non rendu par Filament 5.11.2'])),
+    ...Object.fromEntries(['RESOURCE_PAGES_MANAGE_RELATED_RECORDS_TABLE_AFTER', 'RESOURCE_PAGES_MANAGE_RELATED_RECORDS_TABLE_BEFORE'].map((k) => [PanelsRenderHook[k], 'ManageRelatedRecords page not implemented'])),
+    ...Object.fromEntries(['RESOURCE_PAGES_LIST_RECORDS_TABS_END', 'RESOURCE_PAGES_LIST_RECORDS_TABS_START', 'RESOURCE_TABS_END', 'RESOURCE_TABS_START'].map((k) => [PanelsRenderHook[k], 'reserved, no view renders it'])),
 };
-// ------------------------------------------------------------------ pages
-/** Portée Alpine d'un composant de schéma sans clé (cellule de grille anonyme). */
+/** Alpine scope of a schema component without a key (anonymous grid cell). */
 const ANONYMOUS_SCHEMA_COMPONENT = `x-data="filamentSchemaComponent(${e(js({ key: null, exposedMethods: [], path: '', containerPath: '' }))})"`;
-/** Base commune : composant à état hébergeant des schémas (`<nom>Schema(schema)`). */
+/** Common base: a stateful component hosting schemas (`<name>Schema(schema)`). */
 class BasePage extends Component {
     get panel() { return this._ctx.panel; }
     getSchema(name) {
@@ -572,15 +574,15 @@ class BasePage extends Component {
         return this[`${name}Schema`](schema);
     }
     contentSchema(schema) { return schema.components([]); }
-    /** Portées des render hooks de cette page : sa classe (et sa resource pour une page de resource), comme `getRenderHookScopes()` dans Filament. */
+    /** Render hook scopes of this page: its class (and its resource, for a resource page). */
     getRenderHookScopes() {
         const resource = this.constructor.resource;
         return resource ? [this.constructor, resource] : [this.constructor];
     }
 }
-/** Page d'un panel, dans la mise en page complète (sidebar, en-tête). */
+/** A panel page, in the full layout (sidebar, header). */
 export class Page extends BasePage {
-    /** Méthodes que le navigateur peut appeler. Une sous-classe ajoute les siennes : `static callable = ['approve']`. */
+    /** Methods the browser may call. A subclass adds its own: `static callable = ['approve']`. */
     static callable = ['mountAction', 'unmountAction', 'callMountedAction', 'callSchemaComponentMethod'];
     static slug = '';
     static title = null;
@@ -591,23 +593,23 @@ export class Page extends BasePage {
     static navigationBadge = null;
     static navigationBadgeColor = 'primary';
     static shouldRegisterNavigation = true;
-    /** Page réservée à certains utilisateurs : rendre `false` la retire du menu et la refuse (403). */
+    /** Restricts the page to some users: returning `false` hides it from the menu and denies it (403). */
     static canAccess(_user) { return true; }
     static getTitle() { return this.title ?? this.name.replace(/([a-z])([A-Z])/g, '$1 $2'); }
     static getNavigationLabel() { return this.navigationLabel ?? this.getTitle(); }
-    /** Chaque requête, y compris les mises à jour envoyées par le navigateur, exige un utilisateur authentifié : un snapshot conservé après déconnexion ne suffit pas. */
+    /** Every request, including browser updates, requires an authenticated user: a snapshot kept after logout is not enough. */
     async boot() {
         const ctx = this._ctx;
         if (!ctx?.user)
-            throw new WireError(401, 'Non authentifié.');
-        // Dans un panel à locataires, toute page vit chez un locataire dont l'utilisateur est membre (vérifié par le routeur).
+            throw new WireError(401, 'Unauthenticated.');
+        // In a multi-tenant panel, every page belongs to a tenant the user is a member of (checked by the router).
         if (ctx.panel.hasTenancy() && !ctx.tenant)
-            throw new WireError(404, 'Locataire introuvable.');
+            throw new WireError(404, 'Tenant not found.');
         if (await ctx.panel.mustVerifyEmail(ctx.user))
-            throw new WireError(403, 'Adresse e-mail à vérifier.');
-        // Vérifié à chaque requête, pas seulement à l'affichage : une requête forgée vers une page interdite est refusée.
+            throw new WireError(403, 'Email address not verified.');
+        // Checked on every request, not only on display: a forged request to a forbidden page is denied.
         if (!(await this.isAccessAuthorized(ctx)))
-            throw new WireError(403, 'Accès refusé.');
+            throw new WireError(403, 'Forbidden.');
     }
     isAccessAuthorized(ctx) { return ctx.panel.canAccessPage(this.constructor, ctx.user); }
     getTitle() { return this.constructor.getTitle(); }
@@ -615,19 +617,19 @@ export class Page extends BasePage {
     getBreadcrumbs() { return []; }
     getHeaderActions() { return []; }
     getPageClasses() { return []; }
-    /** Sous-navigation de la page : vide par défaut. */
+    /** Page sub-navigation; empty by default. */
     getSubNavigation() { return []; }
-    /** Position de la sous-navigation : `start` (colonne avant le contenu), `end` (après) ou `top` (onglets). Par défaut : celle de la resource, sinon du panel. */
+    /** Sub-navigation position: `start` (column before the content), `end` (after) or `top` (tabs). Defaults to the resource's, then the panel's. */
     static subNavigationPosition = null;
     getSubNavigationPosition() {
         const own = this.constructor.subNavigationPosition;
-        const resource = this.constructor.resource ?? this.constructor.related?.parentResource;
+        const resource = this.constructor.resource ?? this.constructor.parentResource;
         return own ?? resource?.subNavigationPosition ?? this.panel.getSubNavigationPosition();
     }
-    /** Widgets affichés sous le contenu de la page (port de getFooterWidgets). */
+    /** Widgets shown below the page content. */
     getFooterWidgets() { return []; }
     getFooterWidgetsColumns() { return 2; }
-    /** Port de filament-widgets::components.widgets, dans le schéma `footerWidgets` de la page. */
+    /** Footer widget grid, in the page's `footerWidgets` schema. */
     async renderFooterWidgets() {
         const widgets = await this.filterVisibleWidgets(this.getFooterWidgets());
         if (!widgets.length)
@@ -635,11 +637,11 @@ export class Page extends BasePage {
         const liberate = (hook) => `<div class="fi-sc-liberated" wire:key="" ${ANONYMOUS_SCHEMA_COMPONENT}>${renderHook(hook, this.getRenderHookScopes())}</div>`;
         return `<div x-data="filamentSchema({ livewireId: ${e(js(this.id))}, schemaKey: 'footerWidgets' })" x-on:form-validation-error.window="handleFormValidationError" x-on:reset-schema-component-state.window="handleClientSideStateReset" class="fi-grid fi-sc fi-sc-has-gap" style="--cols-default: repeat(1, minmax(0, 1fr));">${liberate(PanelsRenderHook.PAGE_FOOTER_WIDGETS_START)}${await this.renderWidgetsGrid(widgets, this.getFooterWidgetsColumns(), 'footerWidgets')}${liberate(PanelsRenderHook.PAGE_FOOTER_WIDGETS_END)}</div>`;
     }
-    /** Widgets affichés au-dessus du contenu de la page, et données passées à chacun (propriétés du widget). */
+    /** Widgets shown above the page content, with the data passed to each (widget properties). */
     getHeaderWidgets() { return []; }
     getHeaderWidgetsColumns() { return 2; }
     getWidgetData() { return {}; }
-    /** Port de filament-widgets::components.widgets, dans le schéma `headerWidgets` de la page. */
+    /** Header widget grid, in the page's `headerWidgets` schema. */
     async renderHeaderWidgets() {
         const widgets = await this.filterVisibleWidgets(this.getHeaderWidgets());
         if (!widgets.length)
@@ -647,7 +649,7 @@ export class Page extends BasePage {
         const liberate = (hook) => `<div class="fi-sc-liberated" wire:key="" ${ANONYMOUS_SCHEMA_COMPONENT}>${renderHook(hook, this.getRenderHookScopes())}</div>`;
         return `<div x-data="filamentSchema({ livewireId: ${e(js(this.id))}, schemaKey: 'headerWidgets' })" x-on:form-validation-error.window="handleFormValidationError" x-on:reset-schema-component-state.window="handleClientSideStateReset" class="fi-grid fi-sc fi-sc-has-gap" style="--cols-default: repeat(1, minmax(0, 1fr));">${liberate(PanelsRenderHook.PAGE_HEADER_WIDGETS_START)}${await this.renderWidgetsGrid(widgets, this.getHeaderWidgetsColumns(), 'headerWidgets')}${liberate(PanelsRenderHook.PAGE_HEADER_WIDGETS_END)}</div>`;
     }
-    /** Widgets que l'utilisateur courant a le droit de voir (port de filterVisibleWidgets). */
+    /** Widgets the current user is allowed to see. */
     async filterVisibleWidgets(candidates) {
         const viewer = this._ctx.user;
         const widgets = [];
@@ -656,50 +658,51 @@ export class Page extends BasePage {
                 widgets.push(widget);
         return widgets;
     }
-    /** Grille de widgets d'un schéma (port de Grid + getWidgetsSchemaComponents) : chaque widget est un composant enfant, « lazy » par défaut. */
+    /** Widget grid of a schema: each widget is a child component, lazy-loaded by default. */
     async renderWidgetsGrid(widgets, columns, schemaKey) {
         const items = [];
         for (const [index, widget] of widgets.entries()) {
-            const key = `${schemaKey}.${widget.componentName}-${index}`;
-            const child = await this.mountChild(widget.componentName, this.getWidgetData(), `${this.id}.${key}`, { lazy: widget.isLazy });
+            const componentName = this._runtime.nameOf(widget);
+            const key = `${schemaKey}.${componentName}-${index}`;
+            const child = await this.mountChild(componentName, this.getWidgetData(), `${this.id}.${key}`, { lazy: widget.isLazy });
             items.push(`<div class="fi-sc-liberated" wire:key="${e(`${this.id}.${key}`)}" x-data="filamentSchemaComponent(${e(js({ key, exposedMethods: [], path: '', containerPath: '' }))})">${child}</div>`);
         }
         const grid = new Attributes().grid(typeof columns === 'number' ? { lg: columns } : columns).class(['fi-sc', 'fi-sc-has-gap']);
         return `<div ${ANONYMOUS_SCHEMA_COMPONENT} class="fi-grid-col" style="--col-span-default: span 1 / span 1;"><div class="fi-sc-component"><div><div ${grid.toHtml()}>${items.join('')}</div></div></div></div>`;
     }
-    /** Contenu de la page : par défaut son schéma `content`. */
+    /** Page content: its `content` schema by default. */
     async renderContent() { return (await this.getSchema('content')).toHtml(); }
-    // --- actions montées (port de InteractsWithActions) : la pile vit dans l'état du composant, les modales sont rendues côté serveur
+    // --- mounted actions: the stack lives in the component state, modals are rendered server-side
     mountedActions = [];
     getActionMountContext() { return {}; }
     getActionRecord() { return null; }
-    /** Enregistrement visé par une action montée dans un contexte donné (ligne de table…). */
+    /** Record targeted by an action mounted in a given context (table row…). */
     async resolveActionRecord(_context) { return this.getActionRecord(); }
-    /** Actions pouvant être montées dans un contexte donné (en-tête de page par défaut). */
+    /** Actions that can be mounted in a given context (page header by default). */
     getMountableActions(context) {
         return typeof context.schemaComponent === 'string' ? this.getSchemaComponentActions(context.schemaComponent) : this.getHeaderActions();
     }
     /**
-     * Actions portées par un composant de schéma (Repeater : ajouter, supprimer, déplacer ; Section : actions d'en-tête).
-     * La clé vient du navigateur : elle doit désigner un composant réel du schéma, ou le schéma lui-même.
+     * Actions owned by a schema component (Repeater: add, delete, move; Section: header actions).
+     * The key comes from the browser: it must match a real component of the schema, or the schema itself.
      */
     async getSchemaComponentActions(key) {
         const name = key.split('.')[0];
-        // Le composant peut appartenir au formulaire d'une action déjà montée (éditeur riche dans une modale).
+        // The component may belong to the form of an already mounted action (rich editor in a modal).
         const mountedIndex = /^mountedActionSchema(\d+)$/.exec(name);
         if (!mountedIndex && (!/^[A-Za-z]+$/.test(name) || typeof this[`${name}Schema`] !== 'function'))
             return [];
         const schema = mountedIndex ? await this.getMountedActionSchema(Number(mountedIndex[1])) : this.getSchema(name);
         if (!schema)
             return [];
-        // Seuls les composants visibles exposent leurs actions : un composant masqué (section, callout…) n'en monte aucune.
+        // Only visible components expose their actions: a hidden component (section, callout…) mounts none.
         const components = (await schema.getVisibleFlatComponents());
         const exact = components.find((c) => c.getKey() === key && typeof c.getActions === 'function');
         if (exact)
             return exact.getActions();
         return key === schema.getKey() ? components.filter((c) => !c.hasStatePath() && typeof c.getActions === 'function').flatMap((c) => c.getActions()) : [];
     }
-    /** Contexte retenu pour une action montée : celui du serveur, jamais celui du navigateur tel quel. */
+    /** Context kept for a mounted action: the server's, never the browser's as-is. */
     resolveMountContext(clientContext) {
         const component = clientContext?.schemaComponent;
         return typeof component === 'string' && component.length <= 200 ? { ...this.getActionMountContext(), schemaComponent: component } : this.getActionMountContext();
@@ -707,11 +710,11 @@ export class Page extends BasePage {
     async findMountableAction(name, context = this.getActionMountContext()) {
         const action = (await this.getMountableActions(context)).find((a) => a.getName() === name && a.isMountable());
         if (!action)
-            throw new WireError(404, `Action introuvable : ${String(name)}`);
+            throw new WireError(404, `Action not found: ${String(name)}`);
         return action;
     }
     async actionContext(mounted) { return { livewire: this, record: await this.resolveActionRecord(mounted.context), arguments: mounted.arguments, data: emptyToNull(mounted.data ?? {}) }; }
-    /** Schéma du formulaire d'une action montée : clé `mountedActionSchema<n>`, état sous `mountedActions.<n>.data` (comme Filament). */
+    /** Form schema of a mounted action: key `mountedActionSchema<n>`, state under `mountedActions.<n>.data`. */
     async getMountedActionSchema(index) {
         const mounted = this.mountedActions[index];
         if (!mounted)
@@ -723,7 +726,7 @@ export class Page extends BasePage {
         const mounted = this.mountedActions[index];
         return (await this.findMountableAction(mounted.name, mounted.context)).toModalHtml(await this.actionContext(mounted), index, (await (await this.getMountedActionSchema(index))?.toHtml()) ?? null);
     }
-    /** Annule un rendu partiel de modale préparé par un champ réactif, quand la même requête exécute ensuite une action. */
+    /** Cancels a partial modal render prepared by a live field when the same request then runs an action. */
     cancelModalPartialRender() {
         for (const name of Object.keys(this._effects.partials ?? {}))
             if (name.startsWith('action-modals.')) {
@@ -731,7 +734,7 @@ export class Page extends BasePage {
                 this._skipRender = false;
             }
     }
-    /** Champ réactif du formulaire d'une action montée : exécute `afterStateUpdated`, puis ne renvoie que la modale concernée (comme Filament). */
+    /** Live field in a mounted action's form: runs `afterStateUpdated`, then only returns the affected modal. */
     async updatedMountedActions(_value, key) {
         const m = /^(\d+)\.data\.(.+)$/.exec(key ?? '');
         if (!m)
@@ -745,7 +748,7 @@ export class Page extends BasePage {
         await field.callAfterStateUpdated((name, value) => { data[name] = value; });
         this.renderPartial(`action-modals.${index}`, await this.renderActionModal(index));
     }
-    /** Appel, depuis le JavaScript d'un champ, d'une méthode que ce champ expose (ex. recherche d'un Select). Sans rendu. */
+    /** Calls a method exposed by a field, from that field's JavaScript (e.g. Select search). Does not re-render. */
     async callSchemaComponentMethod(componentKey, method, args = []) {
         if (typeof componentKey !== 'string' || typeof method !== 'string') {
             this.skipRender();
@@ -754,34 +757,34 @@ export class Page extends BasePage {
         const name = componentKey.split('.')[0];
         const mountedIndex = /^mountedActionSchema(\d+)$/.exec(name);
         const schema = mountedIndex ? await this.getMountedActionSchema(Number(mountedIndex[1])) : typeof this[`${name}Schema`] === 'function' ? await this.getSchema(name) : null;
-        // Un composant masqué n'expose aucune méthode, même si le navigateur en forge l'appel.
+        // A hidden component exposes no method, even if the browser forges the call.
         const component = schema ? (await schema.getVisibleFlatComponents()).find((c) => c.getKey() === componentKey) : undefined;
-        // Seules les méthodes que le composant déclare exposées sont appelables depuis le navigateur.
+        // Only methods the component declares as exposed can be called from the browser.
         if (!component || !component.getExposedMethods().includes(method) || typeof component[method] !== 'function') {
             this.skipRender();
             return null;
         }
         if (component.isRenderlessMethod(method))
             this.skipRender();
-        // Arguments nommés (objet), comme les envoie le JavaScript de Filament : passés dans l'ordre de leurs clés.
+        // Named arguments (an object), as sent by the front-end JavaScript: passed in key order.
         return component[method](...(Array.isArray(args) ? args : args && typeof args === 'object' ? Object.values(args) : []));
     }
-    /** Une action masquée ne peut être ni montée ni exécutée, même par un appel forgé depuis le navigateur. */
+    /** A hidden action can be neither mounted nor run, even through a call forged by the browser. */
     async assertActionVisible(action, context = {}) {
         const record = await this.resolveActionRecord(context);
         if (context.recordKey !== undefined && record === null)
-            throw new WireError(404, 'Enregistrement introuvable');
+            throw new WireError(404, 'Record not found.');
         const ctx = { livewire: this, component: null, operation: null, record, get: () => undefined, state: undefined };
         if (!(await action.isVisible(ctx)) || (await action.isDisabled(ctx)))
-            throw new WireError(403, `Action indisponible : ${action.getName()}`);
-        // Une action qui mène à une adresse pour cet enregistrement est un lien : elle ne se monte pas.
+            throw new WireError(403, `Action unavailable: ${action.getName()}`);
+        // An action with a URL for this record is a link: it cannot be mounted.
         if (action.resolveUrl(ctx) !== null)
-            throw new WireError(404, `Action introuvable : ${action.getName()}`);
+            throw new WireError(404, `Action not found: ${action.getName()}`);
     }
     syncActionModals() {
         this.dispatch('sync-action-modals', { id: this.id, newActionNestingIndex: this.mountedActions.length ? this.mountedActions.length - 1 : null, shouldOverlayParentActions: false });
     }
-    /** Faux pour un composant à table : ses modales sont rendues dans la table (comme Filament). */
+    /** False for a table component: its modals are rendered inside the table. */
     rendersActionModalsInPage() { return true; }
     async renderActionModals() {
         const modals = [];
@@ -791,7 +794,7 @@ export class Page extends BasePage {
                     livewireId: ${js(this.id)},
                 })" style="height: 0">${modals.join('')}</div>`;
     }
-    /** Monte une action : sans modale elle s'exécute tout de suite ; avec modale, seul le fragment des modales est renvoyé. */
+    /** Mounts an action: without a modal it runs immediately; with one, only the modals fragment is returned. */
     async mountAction(name, args = {}, _context = {}) {
         this.cancelModalPartialRender();
         const context = this.resolveMountContext(_context);
@@ -805,7 +808,7 @@ export class Page extends BasePage {
         this.mountedActions.push(mounted);
         const schema = await this.getMountedActionSchema(this.mountedActions.length - 1);
         if (schema) {
-            // État initial : valeurs par défaut des champs, puis `fillForm()`.
+            // Initial state: field defaults, then `fillForm()`.
             const data = {};
             mounted.data = data;
             fillSchema(schema, data);
@@ -841,7 +844,7 @@ export class Page extends BasePage {
         if (schema)
             callContext.data = await getSchemaState(schema);
         await action.call(callContext);
-        // « … & create another » : la modale reste ouverte sur un formulaire remis à zéro.
+        // "… & create another": the modal stays open with a reset form.
         if (schema && _args && typeof _args === 'object' && _args.another === true) {
             const data = {};
             mounted.data = data;
@@ -866,25 +869,25 @@ export class Page extends BasePage {
     }
 }
 /**
- * Tableau de bord (port de Filament\Pages\Dashboard) : une grille de widgets, précédée d'un formulaire de filtres
- * quand la page définit `filtersFormSchema(schema)` (port de HasFiltersForm). Les filtres sont passés aux widgets sous `pageFilters`.
+ * Dashboard: a widget grid, preceded by a filters form when the page defines `filtersFormSchema(schema)`.
+ * The filters are passed to widgets as `pageFilters`.
  */
 export class Dashboard extends Page {
     static slug = '';
     static title = 'Dashboard';
     static navigationIcon = 'o-home';
     static navigationSort = -2;
-    /** État du formulaire de filtres. Reste `null` tant que la page n'a pas de filtres. */
+    /** Filters form state. Stays `null` while the page has no filters. */
     filters = null;
-    /** Widgets du tableau de bord. Par défaut : ceux du panel (`panel.widgets([...])`). */
+    /** Dashboard widgets. Defaults to the panel's (`panel.widgets([...])`). */
     getWidgets() { return this.panel.getWidgets(); }
-    /** Colonnes de la grille : un nombre (au point de rupture `lg`), ou un nombre par point de rupture. */
+    /** Grid columns: a number (at the `lg` breakpoint), or one number per breakpoint. */
     getColumns() { return 2; }
     hasFiltersForm() { return typeof this.filtersFormSchema === 'function'; }
     getSchema(name) {
         if (name !== 'filtersForm')
             return super.getSchema(name);
-        // Comme getFiltersForm() : grille 2 / 3 / 4 colonnes, état sous `filters`, champs « live ».
+        // 2 / 3 / 4 column grid, state under `filters`, live fields.
         const schema = this.filtersFormSchema(Schema.make(this).key('filtersForm').columns({ md: 2, xl: 3, '2xl': 4 }).statePath('filters').partialName('table-filters-form'));
         for (const component of schema.getFlatComponents())
             if (component instanceof Field && typeof component.live === 'function')
@@ -904,13 +907,13 @@ export class Dashboard extends Page {
         return `<div x-data="filamentSchema({ livewireId: ${e(js(this.id))}, schemaKey: 'content' })" x-on:form-validation-error.window="handleFormValidationError" x-on:reset-schema-component-state.window="handleClientSideStateReset" class="fi-grid fi-sc fi-sc-has-gap" style="--cols-default: repeat(1, minmax(0, 1fr));">${filters}${widgets}</div>`;
     }
 }
-/** Limiteur de tentatives en mémoire : `max` essais par fenêtre, par clé. Suffisant pour une instance ; à remplacer par un magasin partagé si le panel tourne sur plusieurs. */
+/** In-memory rate limiter: `max` attempts per window, per key. Fine for a single instance; use a shared store when running several. */
 export class Throttle {
     hits = new Map();
     max;
     windowMs;
     constructor(max = 5, windowMs = 60_000) { this.max = max; this.windowMs = windowMs; }
-    /** Enregistre un essai ; rend 0 s'il est permis, sinon le nombre de secondes à attendre. */
+    /** Records an attempt; returns 0 if allowed, otherwise the number of seconds to wait. */
     hit(key, now = Date.now()) {
         const recent = (this.hits.get(key) ?? []).filter((at) => at > now - this.windowMs);
         if (recent.length >= this.max) {
@@ -919,7 +922,7 @@ export class Throttle {
         }
         recent.push(now);
         this.hits.set(key, recent);
-        // Le magasin ne grossit pas indéfiniment.
+        // Keep the store from growing forever.
         if (this.hits.size > 10_000)
             for (const [k, v] of this.hits)
                 if (!v.some((at) => at > now - this.windowMs))
@@ -929,35 +932,35 @@ export class Throttle {
     clear(key) { this.hits.delete(key); }
 }
 const loginThrottle = new Throttle();
-/** Page à mise en page « simple » (connexion, inscription…). */
+/** Page with the simple layout (login, registration…). */
 export class SimplePage extends BasePage {
     getHeading() { return this.getTitle(); }
-    /** Sous-titre, en HTML de confiance (composé par la page, données échappées). */
+    /** Subheading, as trusted HTML (built by the page, with data escaped). */
     getSubheading() { return null; }
     hasLogo() { return true; }
     async render() {
         return views.render('filament-panels::pages.simple', { brand: this.panel.getBrand(), heading: this.getHeading(), subheading: this.getSubheading(), hasLogo: this.hasLogo(), content: await this.getSchema('content').toHtml(), livewireId: this.id, renderHookScopes: this.getRenderHookScopes() });
     }
 }
-/** Gestionnaire de couleurs lu par les autres paquets, partagé par tous les panels ; chaque requête y pose les couleurs de son panel (`Panel.withTheme`). */
+/** Color manager read by the other packages and shared by all panels; each request sets its panel's colors on it (`Panel.withTheme`). */
 const sharedColors = new ColorManager();
-/** Lien « fi-link » d'une page d'authentification (port de `Action::make()->link()`). */
+/** `fi-link` link of an authentication page. */
 function authLink(url, label, options = {}) {
     const classes = ['fi-ac-link-action', 'fi-link', `fi-size-${options.size ?? 'md'}`, ...sharedColors.getComponentClasses('link', 'primary')];
     return `<a href="${e(url)}" class="${classes.join(' ')}" >${options.iconName ? icon(options.iconName) : ''}<span class="fi-link-label"> ${e(label)} </span></a>`;
 }
-/** Adresse absolue pour un e-mail : celle déclarée par `panel.appUrl()`, sinon l'origine de la requête. */
+/** Absolute URL for an email: based on `panel.appUrl()`, otherwise the request origin. */
 function absoluteUrl(panel, req, path) { return `${panel.getAppUrl() ?? `${req.protocol}://${req.get('host')}`}${path}`; }
 const registerThrottle = new Throttle(2);
 const passwordResetThrottle = new Throttle(2);
 const verificationThrottle = new Throttle(2);
 const throttled = (group, wait) => Notification.make().danger().title(t(`${group}.notifications.throttled.title`, { seconds: wait, minutes: Math.ceil(wait / 60) })).body(t(`${group}.notifications.throttled.body`, { seconds: wait, minutes: Math.ceil(wait / 60) })).send();
-/** Règles de mot de passe de Laravel (`Password::default()` : 8 caractères au moins) et de confirmation (`same`). */
+/** Password rules (at least 8 characters) and confirmation rule (`same`). */
 const passwordRules = (confirmationField, confirmationLabel) => [
     { name: 'min', passes: (value) => String(value).length >= 8, message: (attribute) => `The ${attribute} field must be at least 8 characters.` },
     { name: 'same', passes: (value, ctx) => value === ctx.get(confirmationField), message: (attribute) => `The ${attribute} field must match ${confirmationLabel}.` },
 ];
-/** E-mail de vérification de l'adresse (texte de la notification `VerifyEmail` de Laravel). */
+/** Email verification message. */
 async function sendVerificationEmail(panel, req, user) {
     await panel.sendMail({
         to: user.email, subject: 'Verify Email Address',
@@ -972,7 +975,7 @@ const formContent = (submit, actions, options = {}) => [
         .footer([Actions.make(actions).alignment(options.alignment ?? null).fullWidth(options.fullWidth ?? true).key('form-actions')]),
     ...(options.after ? [RenderHook.make(options.after)] : []),
 ];
-/** Inscription (port de Filament\Auth\Pages\Register) : nom, adresse, mot de passe confirmé ; l'utilisateur est connecté, puis invité à vérifier son adresse si le panel l'exige. */
+/** Registration page: name, email, confirmed password. The user is logged in, then asked to verify their email if the panel requires it. */
 export class Register extends SimplePage {
     static callable = ['register', 'callSchemaComponentMethod'];
     data = {};
@@ -1003,9 +1006,9 @@ export class Register extends SimplePage {
     contentSchema(schema) {
         return schema.components(formContent('register', [Action.make('register').label(t('filament-panels::auth/pages/register.form.actions.register.label')).submit('register')], { before: PanelsRenderHook.AUTH_REGISTER_FORM_BEFORE, after: PanelsRenderHook.AUTH_REGISTER_FORM_AFTER }));
     }
-    /** Données validées, juste avant la création (ajouter une valeur, normaliser l'adresse…). */
+    /** Validated data, just before creation (add a value, normalize the email…). */
     mutateFormDataBeforeRegister(data) { return data; }
-    /** Création de l'utilisateur : par défaut `create()` du fournisseur d'utilisateurs. */
+    /** Creates the user; defaults to the auth provider's `create()`. */
     handleRegistration(data) {
         return this.panel.getAuth().create({ name: String(data.name), email: String(data.email), password: String(data.password) });
     }
@@ -1029,7 +1032,7 @@ export class Register extends SimplePage {
         this.redirect(panel.getUrl());
     }
 }
-/** Demande de réinitialisation du mot de passe (port de RequestPasswordReset) : un lien signé, valable 60 minutes, part par e-mail. */
+/** Password reset request page: a signed link, valid for 60 minutes, is sent by email. */
 export class RequestPasswordReset extends SimplePage {
     static callable = ['request', 'callSchemaComponentMethod'];
     data = {};
@@ -1074,14 +1077,14 @@ export class RequestPasswordReset extends SimplePage {
                 outro: ['This password reset link will expire in 60 minutes.', 'If you did not request a password reset, no further action is required.'],
             });
         }
-        // Écart de sécurité assumé : Filament (via Laravel) répond « adresse inconnue » quand aucun compte n'existe, ce qui
-        // révèle quelles adresses sont inscrites. Navette répond toujours de la même façon.
+        // Security: always answer the same way, whether or not an account exists, so the response
+        // does not reveal which email addresses are registered.
         Notification.make().success().title('We have emailed your password reset link.').body(t('filament-panels::auth/pages/password-reset/request-password-reset.notifications.sent.body')).send();
         this.data = {};
         fillSchema(form, this.data);
     }
 }
-/** Nouveau mot de passe, depuis le lien reçu par e-mail (port de ResetPassword). Le lien ne sert qu'une fois : il meurt avec l'ancien mot de passe. */
+/** Sets a new password from the emailed link. The link works once: it dies with the old password. */
 export class ResetPassword extends SimplePage {
     static callable = ['resetPassword', 'callSchemaComponentMethod'];
     static locked = ['email', 'token'];
@@ -1097,7 +1100,7 @@ export class ResetPassword extends SimplePage {
         this.token = typeof params.token === 'string' ? params.token : null;
         this.email = typeof params.email === 'string' ? params.email : null;
     }
-    /** Comme Filament : le formulaire n'a pas de chemin d'état, ses champs sont des propriétés de la page. */
+    /** The form has no state path: its fields are page properties. */
     getSchema(name) { return name === 'form' ? this.formSchema(Schema.make(this).key('form')) : super.getSchema(name); }
     getTitle() { return t('filament-panels::auth/pages/password-reset/reset-password.title'); }
     getHeading() { return t('filament-panels::auth/pages/password-reset/reset-password.heading'); }
@@ -1126,7 +1129,7 @@ export class ResetPassword extends SimplePage {
         const auth = panel.getAuth();
         const payload = panel.readResetPasswordToken(this.token);
         const user = payload ? await auth.find(payload.uid) : null;
-        // Le jeton désigne l'utilisateur ; l'adresse de l'URL doit être la sienne et son mot de passe ne doit pas avoir changé depuis l'envoi.
+        // The token identifies the user; the URL's email must be theirs and their password must not have changed since the link was sent.
         if (!payload || !user || user.email !== this.email || (await auth.getPasswordFingerprint(user)) !== payload.fp) {
             Notification.make().danger().title('This password reset token is invalid.').send();
             return;
@@ -1136,7 +1139,7 @@ export class ResetPassword extends SimplePage {
         this.redirect(panel.getLoginUrl());
     }
 }
-/** Invitation à vérifier son adresse (port de EmailVerificationPrompt), avec le lien « Resend it. ». */
+/** Email verification prompt, with a "Resend it." link. */
 export class EmailVerificationPrompt extends SimplePage {
     static callable = ['mountAction'];
     async mount() {
@@ -1156,11 +1159,11 @@ export class EmailVerificationPrompt extends SimplePage {
             text(`${e(t('filament-panels::auth/pages/email-verification/email-verification-prompt.messages.notification_not_received'))} ${link}`),
         ]);
     }
-    /** Seule action de la page : renvoyer l'e-mail (deux fois par minute au plus). */
+    /** The page's only action: resend the email (at most twice per minute). */
     async mountAction(name) {
         const { req, panel, user } = this._ctx;
         if (name !== 'resendNotification' || !user)
-            throw new WireError(404, 'Action introuvable.');
+            throw new WireError(404, 'Action not found.');
         this.skipRender();
         const wait = verificationThrottle.hit(`${panel.getId()}:verify:${user.id}`);
         if (wait > 0) {
@@ -1172,7 +1175,7 @@ export class EmailVerificationPrompt extends SimplePage {
         Notification.make().success().title(t('filament-panels::auth/pages/email-verification/email-verification-prompt.notifications.notification_resent.title')).send();
     }
 }
-/** Profil de l'utilisateur (port de EditProfile) : nom, adresse, nouveau mot de passe ; le mot de passe actuel est exigé pour changer l'adresse ou le mot de passe. */
+/** User profile page: name, email, new password. The current password is required to change the email or password. */
 export class EditProfile extends SimplePage {
     static callable = ['save', 'callSchemaComponentMethod'];
     static slug = 'profile';
@@ -1181,11 +1184,11 @@ export class EditProfile extends SimplePage {
     async mount() {
         const { user } = this._ctx;
         if (!user)
-            throw new WireError(401, 'Non authentifié.');
+            throw new WireError(401, 'Unauthenticated.');
         this.data = { name: user.name, email: user.email, password: null, passwordConfirmation: null, currentPassword: null };
     }
     async boot() { if (!this._ctx?.user)
-        throw new WireError(401, 'Non authentifié.'); }
+        throw new WireError(401, 'Unauthenticated.'); }
     getTitle() { return this.constructor.getLabel(); }
     hasLogo() { return false; }
     formSchema(schema) {
@@ -1213,7 +1216,7 @@ export class EditProfile extends SimplePage {
     async save() {
         const { panel, user } = this._ctx;
         if (!user)
-            throw new WireError(401, 'Non authentifié.');
+            throw new WireError(401, 'Unauthenticated.');
         const form = this.getSchema('form');
         this._errors = await validateSchema(form);
         if (Object.keys(this._errors).length) {
@@ -1227,18 +1230,18 @@ export class EditProfile extends SimplePage {
     }
 }
 const blankValue = (value) => value === null || value === undefined || value === '';
-/** Création d'un locataire (port de RegisterTenant) : la sous-classe donne son libellé et son formulaire (`formSchema`). */
+/** Tenant registration page: the subclass provides its label and form (`formSchema`). */
 export class RegisterTenant extends SimplePage {
     static callable = ['register', 'callSchemaComponentMethod'];
     static slug = 'new';
     data = {};
     static getLabel() { return 'Register tenant'; }
-    /** Le panel accepte-t-il la création ? Par défaut : si le fournisseur de locataires sait créer. */
+    /** Whether tenants can be created; by default, if the tenant provider implements `create`. */
     static canView(panel, _user) { return typeof panel.getTenantProvider().create === 'function'; }
     async boot() {
         const ctx = this._ctx;
         if (!ctx?.user)
-            throw new WireError(401, 'Non authentifié.');
+            throw new WireError(401, 'Unauthenticated.');
         if (!(await this.constructor.canView(ctx.panel, ctx.user)))
             throw new WireError(404, 'Not Found');
     }
@@ -1266,7 +1269,7 @@ export class RegisterTenant extends SimplePage {
         this.redirect(panel.getUrl('', tenant));
     }
 }
-/** Profil du locataire courant (port de EditTenantProfile), dans la mise en page complète. */
+/** Current tenant's profile page, in the full layout. */
 export class EditTenantProfile extends Page {
     static callable = [...Page.callable, 'save'];
     static slug = 'profile';
@@ -1319,7 +1322,7 @@ export class Login extends SimplePage {
             RenderHook.make(PanelsRenderHook.AUTH_LOGIN_FORM_BEFORE),
             Form.make([EmbeddedSchema.make('form')]).id('form').livewireSubmitHandler('authenticate')
                 .footer([Actions.make([Action.make('authenticate').label(t('filament-panels::auth/pages/login.form.actions.authenticate.label')).submit('authenticate')]).fullWidth().key('form-actions')]),
-            // Formulaire de défi multi-facteur : masqué tant que la MFA n'est pas portée (jalon 7).
+            // Multi-factor challenge form: hidden until MFA is implemented.
             Form.make([]).id('multiFactorChallengeForm').hidden(),
             RenderHook.make(PanelsRenderHook.AUTH_LOGIN_FORM_AFTER),
         ]);
@@ -1331,7 +1334,7 @@ export class Login extends SimplePage {
             return;
         }
         const { req, res, panel } = this._ctx;
-        // Comme Filament : cinq tentatives par minute et par adresse IP, puis attente.
+        // Five attempts per minute per IP address, then wait.
         const wait = loginThrottle.hit(`${panel.getId()}:${req.ip ?? ''}`);
         if (wait > 0) {
             Notification.make().danger().title(t('filament-actions::notifications.throttled.title', { seconds: wait, minutes: Math.ceil(wait / 60) })).body(t('filament-actions::notifications.throttled.body', { seconds: wait, minutes: Math.ceil(wait / 60) })).send();
@@ -1347,16 +1350,15 @@ export class Login extends SimplePage {
         this.redirect(panel.getUrl());
     }
 }
-/** L'utilisateur du composant hôte a-t-il cette capacité sur la resource (ou le relation manager) du composant ? À utiliser dans `authorize()` de vos actions. */
+/** Whether the host component's user has this ability on the component's resource (or relation manager). Use it in your actions' `authorize()`. */
 export const can = (livewire, ability, record = null) => canOn(livewire, ability, record);
 function canOn(livewire, ability, record = null) {
     const resource = livewire?.resource;
     return typeof resource?.can === 'function' ? resource.can(ability, livewire._ctx?.user ?? null, record) : true;
 }
-// ------------------------------------------------------------------ resources
 const plural = (s) => (/[^aeiou]y$/.test(s) ? s.slice(0, -1) + 'ies' : /(s|x|z|ch|sh)$/.test(s) ? s + 'es' : s + 's');
 const ucfirst = (s) => s.replace(/^./, (c) => c.toUpperCase());
-/** Resource : un modèle, ses pages, sa table et sa navigation (port partiel de Filament\Resources\Resource). */
+/** Resource: a model with its pages, table and navigation. */
 export class Resource {
     static panel;
     static slug = '';
@@ -1367,33 +1369,33 @@ export class Resource {
     static navigationSort = 0;
     static navigationBadge = null;
     static adapter;
-    /** Dans un panel à locataires : les enregistrements sont-ils propres à chaque locataire ? (vrai par défaut, comme Filament) */
+    /** In a multi-tenant panel, whether records belong to each tenant (`true` by default). */
     static isScopedToTenant = true;
-    /** Colonne du locataire pour cette resource (par défaut celle du panel : `panel.tenant(provider, { ownershipColumn })`). */
+    /** Tenant column for this resource (defaults to the panel's: `panel.tenant(provider, { ownershipColumn })`). */
     static tenantOwnershipColumn = null;
     /**
-     * Pages de la resource, à remplacer par vos sous-classes pour en changer le comportement :
+     * Resource pages; replace them with your subclasses to change their behavior:
      * `static pages = { index: MyList, create: MyCreate, edit: MyEdit }`.
      */
     static pages = {};
-    /** Page de consultation (`ViewRecord`) : vrai pour l'ajouter aux pages de la resource ; la ligne d'une table y mène alors, comme dans Filament. */
+    /** `true` adds a view page (`ViewRecord`) to the resource; table rows then link to it. */
     static hasViewPage = false;
-    /** Qui peut faire quoi sur cette resource. Sans politique, tout utilisateur connecté peut tout. */
+    /** Who can do what on this resource. Without a policy, any signed-in user can do everything. */
     static policy = null;
-    /** L'utilisateur a-t-il cette capacité (sur cet enregistrement, s'il y en a un) ? */
+    /** Whether the user has this ability (on this record, if any). */
     static can(ability, user, record = null) {
         const rule = this.policy?.[ability];
         return this.panel.authorize(user, ability, { resource: this, record, rule: rule ? () => rule(user, record) : null });
     }
-    /** Widgets de la resource (équivalent de getWidgets()) : enregistrés comme composants. */
+    /** Resource widgets, registered as components. */
     static widgets = [];
-    /** Widgets affichés au-dessus de la table de la page de liste (équivalent de ListRecords::getHeaderWidgets()). */
+    /** Widgets shown above the table on the list page. */
     static headerWidgets = [];
-    /** Relation managers affichés sous le formulaire d'édition (équivalent de getRelations()). */
+    /** Relation managers shown below the edit form. */
     static relations = [];
-    /** Onglets de la page de liste (équivalent de ListRecords::getTabs()). */
+    /** Tabs of the list page. */
     static tabs() { return {}; }
-    /** Resource « simple » (équivalent de ManageRecords) : une seule page, création et édition en modales. */
+    /** Simple resource: a single page, with create and edit in modals. */
     static isSimple = false;
     static getPluralModelLabel() { return this.pluralModelLabel ?? plural(this.modelLabel); }
     static getTitleCasePluralModelLabel() { return this.getPluralModelLabel().split(' ').map(ucfirst).join(' '); }
@@ -1403,11 +1405,11 @@ export class Resource {
             return `${base}/${record}/${page}`;
         return page === 'index' ? base : page === 'create' ? `${base}/create` : page === 'view' ? `${base}/${record}` : `${base}/${record}/edit`;
     }
-    /** Pages d'enregistrements liés (port de ManageRelatedRecords) : `{ comments: ManagePostComments }` répond sous `<slug>/{record}/comments`. */
+    /** Related records pages: `{ comments: ManagePostComments }` is served at `<slug>/{record}/comments`. */
     static relatedPages = {};
-    /** Pages proposées dans la sous-navigation d'un enregistrement, dans l'ordre : `['view', 'edit', 'comments']`. Vide : pas de sous-navigation. */
+    /** Pages listed in a record's sub-navigation, in order: `['view', 'edit', 'comments']`. Empty: no sub-navigation. */
     static recordSubNavigation = [];
-    /** Port de getRecordSubNavigation() + generateNavigationItems() : un onglet par page déclarée, celui de la page courante actif. */
+    /** Record sub-navigation: one tab per declared page, the current page's tab active. */
     static getRecordSubNavigation(page) {
         const pages = this.getPages();
         const key = page.getRecordKey() ?? '';
@@ -1422,25 +1424,25 @@ export class Resource {
         });
     }
     static _registered = new WeakMap();
-    /** Classe de page réellement enregistrée pour un nom (les pages sont générées une seule fois par resource). */
+    /** Page class actually registered under a name (pages are generated once per resource). */
     static getRegisteredPage(name) { return this.getPages()[name]; }
     static table(table) { return table; }
     static form(schema) { return schema; }
-    /** Schéma de la page de consultation (équivalent de `infolist()`). */
+    /** Schema of the view page. */
     static infolist(schema) { return schema; }
-    // -------------------------------------------------------------- recherche globale
-    /** Colonnes interrogées par la recherche globale ; par défaut, l'attribut de titre. Tableau vide : resource non cherchable. */
+    // -------------------------------------------------------------- global search
+    /** Columns searched by global search; defaults to the title attribute. Empty array: the resource is not searchable. */
     static globallySearchableAttributes = null;
     static getGloballySearchableAttributes() { return this.globallySearchableAttributes ?? (this.recordTitleAttribute ? [this.recordTitleAttribute] : []); }
     static canGloballySearch() { return this.getGloballySearchableAttributes().length > 0; }
-    /** Rang du groupe de cette resource dans les résultats (`$globalSearchSort`) ; sans rang : après les autres, dans l'ordre d'enregistrement. */
+    /** Position of this resource's group in the results; without one, after the others in registration order. */
     static globalSearchSort = null;
-    /** Nombre de résultats rendus par resource (50, comme Filament). */
+    /** Maximum results rendered per resource. */
     static globalSearchResultsLimit = 50;
     static getGlobalSearchResultTitle(record) { return this.getRecordTitle(record); }
-    /** Précisions affichées sous le titre : `{ Author: 'Jane' }`. Les valeurs vides sont écartées. */
+    /** Details shown under the title: `{ Author: 'Jane' }`. Empty values are skipped. */
     static getGlobalSearchResultDetails(_record) { return {}; }
-    /** Adresse d'un résultat : page « View », sinon édition ; pour une resource simple, la liste avec l'action ouverte. Nul si l'utilisateur n'a aucun accès. */
+    /** URL of a result: the view page, otherwise the edit page; for a simple resource, the list with the action open. `null` if the user has no access. */
     static async getGlobalSearchResultUrl(record, user) {
         const key = this.adapter.getKey(record);
         const canView = await this.can('view', user, record);
@@ -1467,11 +1469,11 @@ export class Resource {
         }
         return results;
     }
-    /** Attribut affiché comme titre d'un enregistrement (`$recordTitleAttribute`). */
+    /** Attribute used as a record's title. */
     static recordTitleAttribute = null;
-    /** Sans attribut de titre : le libellé du modèle, en capitales initiales (« Leave Request »), comme Filament. */
+    /** Without a title attribute: the model label in title case ("Leave Request"). */
     static getRecordTitle(record) { return this.recordTitleAttribute ? String(record?.[this.recordTitleAttribute] ?? '') : this.modelLabel.split(' ').map(ucfirst).join(' '); }
-    /** Pages de la resource, générées : liste, création, édition. */
+    /** Generated resource pages: list, create, edit. */
     static getPages() {
         const known = Resource._registered.get(this);
         if (known)
@@ -1522,90 +1524,90 @@ export class Resource {
         return { index: List, create: Create, edit: Edit, view: View, ...related };
     }
 }
-/** Widget : composant affiché dans une grille de page (port de Filament\Widgets\Widget). */
+/** Widget: a component displayed in a page's widget grid. */
 export class Widget extends Component {
     static componentName;
-    /** Largeur dans la grille de widgets : un nombre de colonnes, ou `'full'`. */
+    /** Width in the widget grid: a number of columns, or `'full'`. */
     static columnSpan = 1;
-    /** Chargé quand il devient visible (comme `$isLazy`). */
+    /** Loaded when it becomes visible. */
     static isLazy = true;
     get panel() { return this._ctx.panel; }
-    /** Widget réservé à certains utilisateurs : rendre `false` le retire de la page et refuse son chargement. */
+    /** Restricts the widget to some users: returning `false` removes it from the page and refuses to load it. */
     static canView(_user) { return true; }
     async boot() {
         const ctx = this._ctx;
         if (!ctx?.user)
-            throw new WireError(401, 'Non authentifié.');
+            throw new WireError(401, 'Unauthenticated.');
         const WidgetClass = this.constructor;
         if (!(await ctx.panel.authorize(ctx.user, 'view', { widget: WidgetClass, rule: () => WidgetClass.canView(ctx.user) })))
-            throw new WireError(403, 'Accès refusé.');
+            throw new WireError(403, 'Forbidden.');
     }
-    /** Classes et style de colonne de grille, au point de rupture `lg` comme Filament. */
+    /** Grid column classes and style, at the `lg` breakpoint. */
     gridColumn() {
         const span = this.constructor.columnSpan;
-        // Comme Filament : la portée est toujours écrite, même pour une seule colonne.
+        // The span is always written, even for a single column.
         return { classes: ['fi-grid-col', 'lg:fi-grid-col-span'], style: `--col-span-lg: ${span === 'full' ? '1 / -1' : `span ${Math.floor(span)} / span ${Math.floor(span)}`};` };
     }
     placeholder() {
         const column = this.gridColumn();
         return `<div role="status" aria-busy="true" style="height: 8rem; ${column.style}" class="${cls(['fi-section', 'fi-loading-section', ...column.classes])}"><span class="fi-sr-only">${e(t('filament::components/loading-section.label'))}</span></div>`;
     }
-    /** Enveloppe commune (port de filament-widgets::components.widget). */
+    /** Common widget wrapper. */
     wrap(content, classes = []) {
         const column = this.gridColumn();
         return `<div${column.style ? ` style="${column.style}"` : ''} class="${cls(['fi-wi-widget', ...column.classes, ...classes])}">${content}</div>`;
     }
 }
 /**
- * Calendrier (propre à Navette) : vues mois, semaine et liste, navigation rendue par le serveur, sans bibliothèque JavaScript.
+ * Calendar widget: month, week and list views, server-rendered navigation, no JavaScript library.
  *
- * Le minimum : étendre la classe et rendre les événements de la période affichée.
+ * Minimal use: extend the class and return the events of the displayed period.
  *
  *     class LeaveCalendar extends CalendarWidget {
  *         static heading = 'Leave';
  *         async getEvents({ start, end }) { return [{ id: 1, title: 'Ada — vacation', start: '2026-11-12', end: '2026-11-14', color: 'success' }]; }
  *     }
  *
- * Tout le reste se redéfinit méthode par méthode : vues proposées, premier jour de la semaine, langue, libellés, nombre
- * d'événements par case, réaction au clic sur un jour (`onDateClick`) ou sur un événement (`onEventClick`), rendu d'un
- * événement (`renderEvent`), pied de case (`renderDayFooter`), boutons de la barre d'outils (`renderToolbarEnd`), et
- * l'apparence par les variables CSS de `.nv-cal` (`getExtraClasses`, `getStyle`).
+ * Everything else can be overridden method by method: available views, first day of the week, locale, labels, events
+ * per cell, day clicks (`onDateClick`) and event clicks (`onEventClick`), event rendering (`renderEvent`), cell footer
+ * (`renderDayFooter`), toolbar buttons (`renderToolbarEnd`), and appearance through the `.nv-cal` CSS variables
+ * (`getExtraClasses`, `getStyle`).
  */
 export class CalendarWidget extends Widget {
     static columnSpan = 'full';
-    /** Titre affiché avant la période (« Leave — November 2026 »). */
+    /** Heading shown before the period ("Leave — November 2026"). */
     static heading = null;
     static callable = ['previousPeriod', 'nextPeriod', 'goToToday', 'setView', 'selectDate', 'selectEvent', 'showDay'];
-    /** La vue et la date ne changent que par les méthodes ci-dessous, qui les valident. */
+    /** View and date only change through the methods below, which validate them. */
     static locked = ['view', 'date'];
     view = 'month';
-    /** Date d'ancrage (`YYYY-MM-DD`) : le mois ou la semaine affichés la contiennent. Vide : aujourd'hui. */
+    /** Anchor date (`YYYY-MM-DD`): the displayed month or week contains it. Empty: today. */
     date = '';
-    /** Vues proposées, la première étant celle d'arrivée. Une seule vue : le sélecteur disparaît. */
+    /** Available views; the first is the initial one. With a single view, the switcher is hidden. */
     getViews() { return ['month', 'week', 'list']; }
-    /** 0 = dimanche, 1 = lundi… */
+    /** 0 = Sunday, 1 = Monday… */
     getFirstDayOfWeek() { return 1; }
-    /** Langue des noms de mois et de jours (`Intl`). */
+    /** Locale for month and day names (`Intl`). */
     getLocale() { return 'en-US'; }
     getLabels() { return CALENDAR_LABELS; }
-    /** En vue mois, au-delà de ce nombre, la case affiche « +N more » (qui ouvre la liste sur ce jour). */
+    /** In month view, beyond this number the cell shows "+N more" (which opens the list on that day). */
     getMaxEventsPerDay() { return 3; }
     getHeading() { return this.constructor.heading; }
-    /** Date du jour, `YYYY-MM-DD` (UTC par défaut ; à redéfinir pour un autre fuseau). */
+    /** Today's date, `YYYY-MM-DD` (UTC by default; override for another time zone). */
     getToday() { return new Date().toISOString().slice(0, 10); }
-    /** Clic sur un numéro de jour. Redéfinir cette méthode rend les jours cliquables : ouvrir une page (`this.redirect`), notifier, changer de vue… */
+    /** Click on a day number. Overriding this makes days clickable: open a page (`this.redirect`), notify, switch view… */
     onDateClick(_date) { }
-    /** Clic sur un événement sans adresse. L'événement est relu côté serveur : `event.extra` est disponible. */
+    /** Click on an event without a URL. The event is reloaded server-side, so `event.extra` is available. */
     onEventClick(_event) { }
-    /** HTML d'un événement (déjà échappé), ou `null` pour le rendu par défaut (`renderCalendarEvent`). */
+    /** Already-escaped HTML for an event, or `null` for the default rendering (`renderCalendarEvent`). */
     renderEvent(_event, _context) { return null; }
-    /** HTML ajouté au bas de chaque case (déjà échappé). */
+    /** Already-escaped HTML appended to the bottom of each cell. */
     renderDayFooter(_day, _events) { return ''; }
-    /** HTML placé à droite de la barre d'outils (déjà échappé) : un lien « New », un filtre… */
+    /** Already-escaped HTML at the end of the toolbar: a "New" link, a filter… */
     renderToolbarEnd() { return ''; }
-    /** Classes ajoutées au calendrier, pour y accrocher vos styles ou redéfinir ses variables CSS. */
+    /** Extra classes on the calendar, to hook your styles or override its CSS variables. */
     getExtraClasses() { return []; }
-    /** Variables CSS posées sur le calendrier : `{ '--nv-cal-day-min-height': '9rem' }`. */
+    /** CSS variables set on the calendar: `{ '--nv-cal-day-min-height': '9rem' }`. */
     getStyle() { return {}; }
     // ---------------------------------------------------------- navigation
     anchor() { return isDate(this.date) ? this.date : this.getToday(); }
@@ -1616,7 +1618,7 @@ export class CalendarWidget extends Widget {
     goToToday() { this.date = this.getToday(); }
     setView(view) { if (typeof view === 'string' && this.getViews().includes(view) && CALENDAR_VIEWS.includes(view))
         this.view = view; }
-    /** « +N more » : la liste, ancrée sur ce jour (ou la semaine si la liste n'est pas proposée). */
+    /** "+N more": the list view anchored on that day (or the week view if list is not available). */
     showDay(date) {
         if (!isDate(date))
             return;
@@ -1628,7 +1630,7 @@ export class CalendarWidget extends Widget {
     eventsClickable() { return this.onEventClick !== CalendarWidget.prototype.onEventClick; }
     async selectDate(date) { if (isDate(date) && this.datesClickable())
         await this.onDateClick(date); }
-    /** L'identifiant vient du navigateur : l'événement est recherché parmi ceux de la période affichée, jamais cru sur parole. */
+    /** The id comes from the browser: the event is looked up among those of the displayed period, never trusted as-is. */
     async selectEvent(id) {
         if ((typeof id !== 'string' && typeof id !== 'number') || !this.eventsClickable())
             return;
@@ -1655,20 +1657,20 @@ export class CalendarWidget extends Widget {
     }
 }
 /**
- * Page calendrier (propre à Navette) : le même calendrier que `CalendarWidget`, sur une page entière, avec les actions de
- * Filament — donc des modales, des formulaires, des confirmations, des panneaux latéraux.
+ * Calendar page: the same calendar as `CalendarWidget`, on a full page, with actions — so modals, forms,
+ * confirmations and slide-overs.
  *
  *     class Planning extends CalendarPage {
  *         static slug = 'planning';
  *         async getEvents({ start, end }) { return db('shifts').where('day', '>=', start).where('day', '<=', end)… }
- *         // Clic sur un jour : une modale avec un formulaire, prérempli avec la date.
+ *         // Day click: a modal with a form, prefilled with the date.
  *         dateAction() {
  *             return Action.make('createShift').modalHeading('New shift')
  *                 .schema([Select.make('employee_id').options(…).required(), DatePicker.make('day').required()])
  *                 .fillForm(({ arguments: args }) => ({ day: CalendarPage.dateOf(args) }))
  *                 .action(async ({ data }) => { await db('shifts').insert(data); Notification.make().success().title('Saved').send(); });
  *         }
- *         // Clic sur un événement : une autre action ; l'événement est relu côté serveur.
+ *         // Event click: another action; the event is reloaded server-side.
  *         eventAction() {
  *             return Action.make('editShift').schema([…])
  *                 .fillForm(async ({ livewire, arguments: args }) => (await livewire.findEvent(args.event))?.extra ?? {})
@@ -1676,10 +1678,10 @@ export class CalendarWidget extends Widget {
  *         }
  *     }
  *
- * Trois façons de réagir à un clic, au choix : une **adresse** sur l'événement (`url` : page dédiée), une **action** (modale),
- * ou du **code libre** en redéfinissant `onDateClick()` / `onEventClick()` (rediriger, notifier, écrire en base, monter l'action
- * de son choix avec `this.mountAction(nom, arguments)`). `getHeaderActions()` ajoute des boutons en tête de page, et
- * `getCalendarActions()` déclare d'autres actions montables depuis votre propre rendu (`renderEvent`, `renderToolbarEnd`).
+ * Three ways to handle a click: a **URL** on the event (`url`: dedicated page), an **action** (modal),
+ * or **custom code** by overriding `onDateClick()` / `onEventClick()` (redirect, notify, write to the database, mount any
+ * action with `this.mountAction(name, arguments)`). `getHeaderActions()` adds buttons to the page header, and
+ * `getCalendarActions()` declares other actions mountable from your own rendering (`renderEvent`, `renderToolbarEnd`).
  */
 export class CalendarPage extends Page {
     static callable = ['mountAction', 'unmountAction', 'callMountedAction', 'callSchemaComponentMethod', 'previousPeriod', 'nextPeriod', 'goToToday', 'setView', 'selectDate', 'selectEvent', 'showDay'];
@@ -1698,21 +1700,21 @@ export class CalendarPage extends Page {
     renderToolbarEnd() { return ''; }
     getExtraClasses() { return []; }
     getStyle() { return {}; }
-    /** Action ouverte au clic sur un jour ; elle reçoit `arguments.date`. Nul : les jours ne sont pas cliquables (sauf `onDateClick` redéfini). */
+    /** Action opened on day click; it receives `arguments.date`. `null`: days are not clickable (unless `onDateClick` is overridden). */
     dateAction() { return null; }
-    /** Action ouverte au clic sur un événement sans adresse ; elle reçoit `arguments.event` (identifiant, à relire avec `findEvent`). */
+    /** Action opened on click on an event without a URL; it receives `arguments.event` (an id, to resolve with `findEvent`). */
     eventAction() { return null; }
-    /** Autres actions montables depuis votre propre HTML : `wire:click="mountAction('nom', { … })"`. */
+    /** Other actions mountable from your own HTML: `wire:click="mountAction('name', { … })"`. */
     getCalendarActions() { return []; }
-    /** Par défaut : ouvre `dateAction()`. À redéfinir pour faire autre chose (rediriger vers une page de création, par exemple). */
+    /** Opens `dateAction()` by default. Override to do something else (e.g. redirect to a create page). */
     async onDateClick(date) { const action = this.dateAction(); if (action)
         await this.mountAction(action.getName(), { date }); }
-    /** Par défaut : ouvre `eventAction()`. L'événement a été retrouvé côté serveur avant l'appel. */
+    /** Opens `eventAction()` by default. The event has been resolved server-side before the call. */
     async onEventClick(event) { const action = this.eventAction(); if (action)
         await this.mountAction(action.getName(), { event: String(event.id) }); }
-    /** Date d'un clic, relue dans les arguments d'une action : ils viennent du navigateur, seule une vraie date est rendue. */
+    /** Clicked date, read from an action's arguments. They come from the browser: only a valid date is returned. */
     static dateOf(args) { return isDate(args?.date) ? args.date : null; }
-    /** Événement de la période affichée portant cet identifiant, ou nul : ne jamais agir sur un identifiant reçu sans passer par ici. */
+    /** Event of the displayed period with this id, or `null`. Never act on a received id without going through this. */
     async findEvent(id) {
         if (typeof id !== 'string' && typeof id !== 'number')
             return null;
@@ -1765,11 +1767,11 @@ export class CalendarPage extends Page {
         return widgetSection(calendar.replace('<div class="nv-cal ', `<div${style ? ` style="${e(style)}"` : ''} class="nv-cal ${extra.length ? `${extra.join(' ')} ` : ''}`));
     }
 }
-/** Section sans en-tête des widgets fournis (port de `<x-filament::section>`). */
+/** Header-less section used by the built-in widgets. */
 const widgetSection = (content) => `<section x-data="{
         isCollapsed:  false ,
     }" class="fi-section"><div class="fi-section-content-ctn"><div class="fi-section-content">${content}</div></div></section>`;
-/** Compte de l'utilisateur connecté : avatar, nom, déconnexion (port de Filament\Widgets\AccountWidget). */
+/** Signed-in user's account: avatar, name, logout. */
 export class AccountWidget extends Widget {
     static isLazy = false;
     render() {
@@ -1779,7 +1781,7 @@ export class AccountWidget extends Widget {
         return this.wrap(widgetSection(`<img alt="${e(t('filament-panels::layout.avatar.alt', { name: user.name }))}" class="fi-avatar fi-circular fi-size-lg fi-user-avatar" src="${e(panel.getUserAvatarUrl(user))}" loading="lazy" /><div class="fi-account-widget-main"><h2 class="fi-account-widget-heading">${e(t('filament-panels::widgets/account-widget.welcome'))}</h2><p class="fi-account-widget-user-name">${e(user.name)}</p></div><form action="${e(panel.getLogoutUrl())}" method="post" class="fi-account-widget-logout-form"><input type="hidden" name="_token" value="${e(csrfToken(req, res))}" autocomplete="off"><button class="fi-icon-btn fi-size-md" title="${e(logout)}" aria-label="${e(logout)}" type="submit" ${loading}>${icon('m-arrow-left-end-on-rectangle')}</button><button class="fi-btn fi-size-md fi-labeled-from-sm" type="submit" ${loading}>${icon('m-arrow-left-end-on-rectangle')}${e(logout)}</button></form>`), ['fi-account-widget']);
     }
 }
-/** Version de Navette et liens utiles (pendant de Filament\Widgets\FilamentInfoWidget, dont il reprend le balisage et les classes). */
+/** Navette version and useful links. */
 export class NavetteInfoWidget extends Widget {
     static isLazy = false;
     static homeUrl = 'https://github.com/NavetteJS';
@@ -1793,9 +1795,9 @@ export class NavetteInfoWidget extends Widget {
         return this.wrap(widgetSection(`<div class="fi-filament-info-widget-main"><a href="${e(WidgetClass.homeUrl)}" rel="noopener noreferrer" target="_blank"><svg aria-label="Navette" fill="currentColor" role="img" viewBox="0 0 96 24" xmlns="http://www.w3.org/2000/svg" class="fi-filament-info-widget-logo"><text x="0" y="19" font-size="22" font-weight="700" letter-spacing="-0.5">Navette</text></svg></a><p class="fi-filament-info-widget-version">v${e(WidgetClass.version)}</p></div><div class="fi-filament-info-widget-links">${link(WidgetClass.documentationUrl, icon('m-book-open'), t('filament-panels::widgets/filament-info-widget.actions.open_documentation.label'))}${link(WidgetClass.githubUrl, github, t('filament-panels::widgets/filament-info-widget.actions.open_github.label'))}</div>`), ['fi-filament-info-widget']);
     }
 }
-/** Propriétés de table qu'une page de liste expose à ses widgets (port de InteractsWithPageTable / ExposesTableToWidgets). */
+/** Table properties a list page exposes to its widgets. */
 const PAGE_TABLE_PROPERTIES = ['activeTab', 'paginators', 'tableColumnSearches', 'tableFilters', 'tableRecordsPerPage', 'tableSearch', 'tableSort'];
-/** Une statistique d'un StatsOverviewWidget (port de Stat). */
+/** One stat of a StatsOverviewWidget. */
 export class Stat {
     _description = null;
     _descriptionIcon = null;
@@ -1810,10 +1812,10 @@ export class Stat {
     static make(label, value) { return new Stat(label, value); }
     description(text) { this._description = text; return this; }
     descriptionIcon(name, position = 'after') { this._descriptionIcon = name; this._descriptionIconPosition = position; return this; }
-    /** Couleur de la description et de la courbe. */
+    /** Color of the description and chart. */
     color(color) { this._color = color; return this; }
     icon(name) { this._icon = name; return this; }
-    /** Courbe de tendance : une liste de valeurs, ou des valeurs par libellé. */
+    /** Trend chart: a list of values, or values keyed by label. */
     chart(values) { this._chart = values; return this; }
     url(url) { this._url = url; return this; }
     hasChart() { return this._chart !== null; }
@@ -1835,18 +1837,18 @@ export class Stat {
         return `<${tag}${this._url ? ` href="${e(this._url)}"` : ''} class="fi-wi-stats-overview-stat"><div class="fi-wi-stats-overview-stat-content"><div class="fi-wi-stats-overview-stat-label-ctn">${this._icon ? icon(this._icon) : ''}<span class="fi-wi-stats-overview-stat-label">${e(this.label)}</span></div>${filled ? `<div class="fi-wi-stats-overview-stat-value">${e(String(this.value))}</div>` : '<div class="fi-wi-stats-overview-stat-placeholder"></div>'}${description}</div>${chart}</${tag}>`;
     }
 }
-/** Rangée de statistiques (port de StatsOverviewWidget). */
+/** A row of stats. */
 export class StatsOverviewWidget extends Widget {
     static columnSpan = 'full';
-    /** Intervalle de rafraîchissement (`'5s'` dans Filament par défaut), ou null pour ne pas rafraîchir. */
+    /** Polling interval, or `null` to disable polling. */
     static pollingInterval = '5s';
-    /** Colonnes de la rangée : comme Filament, trois, ou quatre quand le nombre de statistiques s'y prête. */
+    /** Row columns: three, or four when the number of stats fits better. */
     getColumns(count) { return count < 3 ? 3 : count % 3 !== 1 ? 3 : 4; }
     async render() {
         const stats = await this.getStats();
         const columns = this.getColumns(stats.length);
         const anonymous = `x-data="filamentSchemaComponent(${e(js({ key: null, exposedMethods: [], path: '', containerPath: '' }))})"`;
-        // Comme Filament : une statistique à courbe reçoit un identifiant (`stats-overview-stat-<n>`), donc une clé de composant ; les autres restent anonymes.
+        // A stat with a chart gets an id (`stats-overview-stat-<n>`), hence a component key; the others stay anonymous.
         const cells = stats.map((stat, index) => {
             if (!stat.hasChart())
                 return `<div ${anonymous} class="fi-grid-col" style="--col-span-default: span 1 / span 1;"><div class="fi-sc-component">${stat.toHtml(this.panel, `${this.id}.stats.${index}`)}</div></div>`;
@@ -1861,41 +1863,41 @@ export class StatsOverviewWidget extends Widget {
     }
 }
 /**
- * Graphique Chart.js (port de Filament\Widgets\ChartWidget). Une sous-classe donne `getType()` (`'line'`, `'bar'`, `'pie'`,
- * `'doughnut'`, `'radar'`, `'polarArea'`, `'scatter'`, `'bubble'`) et `getData()`. Le rendu est fait dans le navigateur par le
- * composant `chart.js` de Filament ; le serveur n'envoie de nouvelles données que si elles ont changé (somme de contrôle).
+ * Chart.js chart. A subclass provides `getType()` (`'line'`, `'bar'`, `'pie'`, `'doughnut'`, `'radar'`, `'polarArea'`,
+ * `'scatter'`, `'bubble'`) and `getData()`. Rendering happens in the browser; the server only sends new data when it
+ * has changed (checksum).
  */
 export class ChartWidget extends Widget {
     static callable = ['updateChartData'];
     static locked = ['dataChecksum'];
-    /** Intervalle de rafraîchissement (`'5s'` par défaut dans Filament), ou null pour ne pas rafraîchir. */
+    /** Polling interval, or `null` to disable polling. */
     static pollingInterval = '5s';
     static heading = null;
     static description = null;
-    /** Couleur des séries qui n'en précisent pas. */
+    /** Color of datasets that do not set one. */
     static color = 'primary';
-    /** Hauteur maximale du graphique (`'300px'`). */
+    /** Maximum chart height (`'300px'`). */
     static maxHeight = null;
     static isCollapsible = false;
     dataChecksum = null;
-    /** Filtre choisi, parmi `getFilters()`. */
+    /** Selected filter, one of `getFilters()`. */
     filter = null;
     _cachedData = null;
     getData() { return {}; }
-    /** Options de Chart.js. */
+    /** Chart.js options. */
     getOptions() { return null; }
-    /** Filtres proposés dans l'en-tête : valeur vers libellé. */
+    /** Filters offered in the header: value → label. */
     getFilters() { return null; }
     getHeading() { return this.constructor.heading; }
     getDescription() { return this.constructor.description; }
     getColor() { return this.constructor.color; }
     getMaxHeight() { return this.constructor.maxHeight; }
-    /** Texte lu par les lecteurs d'écran à la place du graphique. */
+    /** Text read by screen readers instead of the chart. */
     getChartAssistiveContent() { return null; }
     async getCachedData() { return (this._cachedData ??= await this.getData()); }
     async generateDataChecksum() { return createHash('md5').update(JSON.stringify(await this.getCachedData())).digest('hex'); }
     async mount() { this.dataChecksum = await this.generateDataChecksum(); }
-    /** Appelé par le rafraîchissement périodique et avant chaque rendu : n'émet les données que si elles ont changé. */
+    /** Called by polling and before each render: only emits data when it has changed. */
     async updateChartData() {
         const checksum = await this.generateDataChecksum();
         if (checksum === this.dataChecksum)
@@ -1940,13 +1942,13 @@ export class ChartWidget extends Widget {
     }
 }
 /**
- * Table dans un widget (port de Filament\Widgets\TableWidget) : recherche, tri, pagination simple (précédent / suivant).
- * Une sous-classe donne `table(table)` et `getDataAdapterForTable()`. Pas d'actions ni de filtres pour l'instant.
+ * Table in a widget: search, sort, simple pagination (previous / next).
+ * A subclass provides `table(table)` and `getDataAdapterForTable()`. No actions or filters yet.
  */
 export class TableWidget extends Widget {
     static columnSpan = 'full';
     static callable = ['sortTable', 'gotoPage', 'nextPage', 'previousPage', 'applyTableColumnManager', 'resetTableColumnManager'];
-    /** Titre de la table ; par défaut tiré du nom de la classe (`FlaggedOrders` : « Flagged Orders »). */
+    /** Table heading; derived from the class name by default (`FlaggedOrders` → "Flagged Orders"). */
     static heading = null;
     tableSearch = '';
     tableSort = null;
@@ -1984,14 +1986,14 @@ export class TableWidget extends Widget {
                 })" style="height: 0"></div>` })}${renderHook(WidgetsRenderHook.TABLE_WIDGET_END, scopes)}`, ['fi-wi-table']);
     }
 }
-/** Widgets qui reçoivent les filtres du tableau de bord (port de InteractsWithPageFilters) : `static reactive = PAGE_FILTERS` et une propriété `pageFilters`. */
+/** For widgets that receive the dashboard filters: `static reactive = PAGE_FILTERS` plus a `pageFilters` property. */
 export const PAGE_FILTERS = ['pageFilters'];
 /**
- * Widget de statistiques lié à la table d'une page de liste (port de InteractsWithPageTable) : il reçoit l'état de la table
- * (recherche, filtres, onglet…) et peut agréger exactement les enregistrements qu'elle affiche.
+ * Stats widget bound to a list page's table: it receives the table state (search, filters, tab…)
+ * and can aggregate exactly the records the table displays.
  */
 export class PageTableStatsWidget extends StatsOverviewWidget {
-    /** Page de liste dont la table est observée (équivalent de getTablePage()). */
+    /** List page whose table is observed. */
     static tablePage;
     static reactive = PAGE_TABLE_PROPERTIES;
     activeTab = null;
@@ -2001,19 +2003,19 @@ export class PageTableStatsWidget extends StatsOverviewWidget {
     tableRecordsPerPage = 10;
     tableSearch = '';
     tableSort = null;
-    /** Agrégats sur la requête courante de la table. L'état reçu passe par la même validation que sur la page. */
+    /** Aggregates over the table's current query. The received state goes through the same validation as on the page. */
     async aggregatePageTable(columns = {}, modify = null) {
         const PageClass = this.constructor.tablePage();
         const page = new PageClass();
         for (const property of PAGE_TABLE_PROPERTIES)
             page[property] = this[property];
         const query = getTableQuery(page.getTable(), page);
-        // Restriction supplémentaire propre à une statistique (« parmi les lignes affichées, celles qui… »).
+        // Extra restriction for one stat ("among the displayed rows, those that…").
         if (modify)
             (query.modifiers ??= []).push(modify);
         return PageClass.resource.adapter.aggregate(query, columns);
     }
-    /** Tendance mensuelle sur la requête courante de la table (voir `ObjectionAdapter.trendPerMonth`). */
+    /** Monthly trend over the table's current query (see `ObjectionAdapter.trendPerMonth`). */
     async trendPageTable(options) {
         const PageClass = this.constructor.tablePage();
         const page = new PageClass();
@@ -2022,12 +2024,12 @@ export class PageTableStatsWidget extends StatsOverviewWidget {
         return PageClass.resource.adapter.trendPerMonth(getTableQuery(page.getTable(), page), options);
     }
 }
-/** Composant de schéma qui intègre la table du composant hôte (port de EmbeddedTable). */
+/** Schema component that embeds the host component's table. */
 export class EmbeddedTable extends SchemaComponent {
     static make() { return new EmbeddedTable(); }
     async toHtml() { return this.livewire.renderTable(); }
 }
-/** Onglets des relation managers d'une page d'édition : seul le manager de l'onglet actif est monté, en composant enfant « lazy » (port de RelationManagers + Tabs). */
+/** Relation manager tabs of an edit page: only the active tab's manager is mounted, as a lazy child component. */
 class RelationManagerTabs extends SchemaComponent {
     constructor() { super(); this._keyName = 'relationManagerTabs'; }
     getExposedMethods() { return ['getLazyLoadedTabBadges', 'getDeferredTabBadges']; }
@@ -2045,8 +2047,9 @@ class RelationManagerTabs extends SchemaComponent {
         for (const [index, manager] of managers.entries()) {
             let content = '';
             if (index === active) {
-                const childKey = `${key}.${index}.${manager.componentName}`;
-                const child = await page.mountChild(manager.componentName, { ownerRecord: page.recordKey }, `${id}.${childKey}`, { lazy: true });
+                const componentName = page._runtime.nameOf(manager);
+                const childKey = `${key}.${index}.${componentName}`;
+                const child = await page.mountChild(componentName, { ownerRecord: page.recordKey }, `${id}.${childKey}`, { lazy: true });
                 content = `<div class="fi-grid fi-sc fi-sc-has-gap" style="--cols-default: repeat(1, minmax(0, 1fr));"><div wire:partial="schema-component::${e(childKey)}" x-data="filamentSchemaComponent(${e(js({ key: childKey, exposedMethods: [], path: '', containerPath: '' }))})" wire:key="${e(`${id}.${childKey}`)}" class="fi-grid-col" style="--col-span-default: span 1 / span 1;"><div class="fi-sc-component">${child}</div></div></div>`;
             }
             panels.push(`<div aria-labelledby="${tabId(index)}" id="${key}.${index}" role="tabpanel" tabindex="0" wire:key="${id}.${key}.${index}.container" x-show="true" x-bind:class="{ 'fi-active': isTabSelected('${index}') }" x-on:expand="revealTab('${index}')" x-data="filamentSchemaComponent(${e(js({ key: `${key}.${index}`, exposedMethods: [], path: '', containerPath: '' }))})" class="fi-sc-tabs-tab">${content}</div>`);
@@ -2062,7 +2065,7 @@ class RelationManagerTabs extends SchemaComponent {
  })" x-load x-load-src="${e(page.panel.assetUrl('js/filament/schemas/components/tabs.js'))}" wire:ignore.self id="${key}" wire:key="${id}.${key}.container" class="fi-sc-tabs"><input type="hidden" x-ref="tabsData" data-active-tab="${active}" /><div x-ref="tabsHeader" class="fi-tabs"><div x-ref="tablist" role="tablist" x-bind:role="hasVisibleTabHeaders ? 'tablist' : 'group'" aria-label="${e(t('filament::components/tabs.label'))}" x-on:keydown="handleKeydown($event)" data-prevent-disabled-clicks wire:loading.attr="aria-disabled" wire:loading.class="fi-disabled" wire:target="activeRelationManager" class="fi-sc-tabs-tablist">${tabs.join('')}</div></div>${panels.join('')}</div>`;
     }
 }
-/** Onglet d'une page de liste : restreint la requête de la table et peut afficher un compteur (port de Tab). */
+/** List page tab: restricts the table query and can show a badge. */
 export class Tab {
     _label;
     _badge = null;
@@ -2071,7 +2074,7 @@ export class Tab {
     _query = null;
     constructor(label = null) { this._label = label; }
     static make(label = null) { return new Tab(label); }
-    /** Compteur, calculé après l'affichage de la page (comme `lazyLoadedBadge()`). */
+    /** Badge computed after the page is displayed. */
     badge(resolver) { this._badge = resolver; return this; }
     badgeColor(color) { this._badgeColor = color; this._hasBadgeColor = true; return this; }
     query(modifier) { this._query = modifier; return this; }
@@ -2079,16 +2082,16 @@ export class Tab {
     hasBadge() { return this._badge !== null; }
     async getBadge() { return this._badge ? this._badge() : null; }
     getBadgeColor() { return this._badgeColor; }
-    /** Faux tant que `badgeColor()` n'a pas été appelé : un badge chargé après coup ne reçoit alors aucune classe de couleur, comme dans Filament. */
+    /** False until `badgeColor()` is called: a lazy-loaded badge then gets no color class. */
     hasBadgeColor() { return this._hasBadgeColor; }
     getQuery() { return this._query; }
 }
-/** Onglets de la page de liste (port de ResourceTabs) : masqués quand la page n'en déclare pas. */
+/** List page tabs: hidden when the page declares none. */
 class ResourceTabs extends SchemaComponent {
     constructor() { super(); this._keyName = 'resourceTabs'; this._hidden = ({ livewire }) => Object.keys(livewire.getTabs()).length === 0; }
     getExposedMethods() { return ['getLazyLoadedTabBadges', 'getDeferredTabBadges']; }
     getDeferredTabBadges() { return {}; }
-    /** Compteurs des onglets, demandés par le navigateur une fois la page affichée. */
+    /** Tab badges, requested by the browser once the page is displayed. */
     async getLazyLoadedTabBadges() {
         const page = this.livewire;
         const badges = {};
@@ -2153,7 +2156,7 @@ class ResourceTabs extends SchemaComponent {
  }" x-ref="tabsHeader" class="fi-tabs"><div x-ref="tablist" role="group" aria-label="${e(t('filament-panels::resources/pages/list-records.tabs.label'))}" x-on:keydown="handleKeydown($event)" data-prevent-disabled-clicks wire:loading.attr="aria-disabled" wire:loading.class="fi-disabled" wire:target="activeTab" class="fi-sc-tabs-tablist">${buttons.join('')}</div></div></div>`;
     }
 }
-/** Page de liste d'une resource : état de table et méthodes appelées par le navigateur (port de ListRecords + InteractsWithTable). */
+/** Resource list page: table state and methods called by the browser. */
 export class ListRecords extends Page {
     static callable = ['updateTableColumnState', 'sortTable', 'gotoPage', 'nextPage', 'previousPage', 'applyTableFilters', 'resetTableFiltersForm', 'removeTableFilters', 'removeTableFilter', 'applyTableColumnManager', 'resetTableColumnManager', 'toggleTableReordering', 'reorderTable'];
     static resource;
@@ -2162,24 +2165,24 @@ export class ListRecords extends Page {
     tableColumnSearches = {};
     tableRecordsPerPage = 10;
     paginators = { page: 1 };
-    // Sélection : tenue par le navigateur, envoyée avec l'appel de l'action groupée (port de CanSelectRecords).
+    // Selection: kept by the browser, sent along with the bulk action call.
     selectedTableRecords = [];
     deselectedTableRecords = [];
     isTrackingDeselectedTableRecords = false;
-    // Filtres : `tableDeferredFilters` est l'état du formulaire, `tableFilters` l'état appliqué (filtres différés, comme Filament par défaut).
+    // Filters: `tableDeferredFilters` is the form state, `tableFilters` the applied state (deferred filters by default).
     tableFilters = {};
     tableDeferredFilters = {};
     tableColumns = [];
     isTableReordering = false;
-    /** Regroupement courant de la table (`identifiant:direction`), choisi dans la barre d'outils. */
+    /** Current table grouping (`id:direction`), chosen in the toolbar. */
     tableGrouping = null;
     updatedTableGrouping() { this.paginators.page = 1; }
-    /** Entre dans le mode « tri manuel » ou en sort (port de toggleTableReordering). */
+    /** Toggles manual reordering mode. */
     async toggleTableReordering() { if (this.getTable().getReorderColumn() !== null && (await canOn(this, 'reorder'))) {
         this.isTableReordering = !this.isTableReordering;
         this.deselectAllTableRecords();
     } }
-    /** Enregistre le nouvel ordre : seules les clés de la table sont retenues, chacune reçoit son rang (port de reorderTable). */
+    /** Saves the new order: only keys belonging to the table are kept, each gets its position. */
     async reorderTable(order, _draggedRecordKey = null) {
         const column = this.getTable().getReorderColumn();
         if (column === null || !this.isTableReordering || !Array.isArray(order) || order.length > REORDER_LIMIT || !(await canOn(this, 'reorder')))
@@ -2196,9 +2199,9 @@ export class ListRecords extends Page {
         this.tableFilters = table.getDefaultFilterState();
         this.tableDeferredFilters = table.getDefaultFilterState();
         this.tableColumns = table.getDefaultColumnState();
-        // Groupe par défaut présélectionné, comme Filament.
+        // Preselect the default group.
         initializeTableGrouping(table, this);
-        // `?tableAction=view&tableActionRecord=12` (lien d'un résultat de recherche globale) : l'action de ligne s'ouvre à l'arrivée, avec les contrôles habituels.
+        // `?tableAction=view&tableActionRecord=12` (global search result link): the row action opens on arrival, with the usual checks.
         const query = (this._ctx?.req?.query ?? {});
         if (typeof query.tableAction === 'string' && /^[A-Za-z0-9_-]{1,64}$/.test(query.tableAction) && typeof query.tableActionRecord === 'string' && query.tableActionRecord.length <= 64) {
             try {
@@ -2210,13 +2213,13 @@ export class ListRecords extends Page {
             }
         }
     }
-    /** Formulaire des filtres : un groupe par filtre, lié à `tableDeferredFilters.<filtre>`. */
+    /** Filters form: one group per filter, bound to `tableDeferredFilters.<filter>`. */
     tableFiltersFormSchema(schema) {
         const table = this.getTable();
-        // Au-dessus du contenu, les filtres se répartissent sur plusieurs colonnes (comme Filament) ; dans le menu déroulant, sur une seule.
+        // Above the content, filters spread over several columns; in the dropdown, a single one.
         const columns = table.getFiltersLayout() === 'above-content-collapsible' ? { sm: 2, lg: 3, xl: 4, '2xl': 5 } : 1;
         return schema.statePath('tableDeferredFilters').columns(columns).partiallyRendered().components(table.getFilters().map((filter) => {
-            // Un filtre peut fournir son propre formulaire (constructeur de requêtes) ; sinon c'est un sélecteur.
+            // A filter may provide its own form (query builder); otherwise it is a select.
             const custom = filter.getFormComponents?.();
             if (custom)
                 return StatefulGroup.make(filter.name, custom).columnSpan(filter.getColumnSpan?.() ?? { default: 1, lg: 1 });
@@ -2225,7 +2228,7 @@ export class ListRecords extends Page {
         }));
     }
     applyTableFilters() {
-        // Seuls les filtres déclarés par la table passent dans l'état appliqué : chacun nettoie son état, ou à défaut seules ses clés connues sont reprises.
+        // Only filters declared by the table reach the applied state: each sanitizes its own state, or else only its known keys are kept.
         this.tableFilters = Object.fromEntries(this.getTable().getFilters().map((filter) => {
             const deferred = this.tableDeferredFilters?.[filter.name];
             if (filter.sanitizeState)
@@ -2234,7 +2237,7 @@ export class ListRecords extends Page {
         }));
         this.paginators.page = 1;
     }
-    /** Retrait d'un indicateur de filtre actif : le champ visé est effacé de l'état appliqué et du formulaire. */
+    /** Removes an active filter indicator: the field is cleared from both the applied state and the form. */
     removeTableFilter(filterName, field = null) {
         const filter = this.getTable().getFilters().find((candidate) => candidate.name === filterName);
         if (!filter)
@@ -2245,7 +2248,7 @@ export class ListRecords extends Page {
         this.tableDeferredFilters = { ...this.tableDeferredFilters, [filter.name]: JSON.parse(JSON.stringify(next)) };
         this.paginators.page = 1;
     }
-    /** Champ réactif du formulaire des filtres (changement d'opérateur d'une règle) : exécute son `afterStateUpdated`. */
+    /** Live field in the filters form (e.g. a rule's operator changed): runs its `afterStateUpdated`. */
     async updatedTableDeferredFilters(_value, key) {
         if (!key)
             return;
@@ -2274,10 +2277,10 @@ export class ListRecords extends Page {
     applyTableColumnManager(state = null, _wasReordered = false) { if (state)
         this.tableColumns = sanitizeColumnState(this.getTable(), state); }
     resetTableColumnManager() { this.tableColumns = this.getTable().getDefaultColumnState(); }
-    // --- onglets de liste : la clé vide est l'onglet par défaut (`null` côté navigateur)
+    // --- list tabs: the empty key is the default tab (`null` in the browser)
     activeTab = null;
     getTabs() { return this.resource.tabs?.() ?? {}; }
-    /** Onglet actif, ramené à une clé déclarée (une valeur inconnue envoyée par le navigateur vaut l'onglet par défaut). */
+    /** Active tab, coerced to a declared key (an unknown value from the browser means the default tab). */
     getActiveTabKey() {
         const tabs = this.getTabs();
         const key = this.activeTab ?? '';
@@ -2292,11 +2295,11 @@ export class ListRecords extends Page {
     }
     get resource() { return this.constructor.resource; }
     getHeaderWidgets() { return this.resource.headerWidgets ?? []; }
-    /** Port de ExposesTableToWidgets : l'état de la table est passé aux widgets, qui peuvent refaire la même requête. */
+    /** The table state is passed to widgets, which can rerun the same query. */
     getWidgetData() { return Object.fromEntries(PAGE_TABLE_PROPERTIES.map((property) => [property, this[property]])); }
     rendersActionModalsInPage() { return false; }
     getBulkActions() { return this.getTable().getBulkActions() ?? [DeleteBulkAction.make()]; }
-    /** Actions de ligne déclarées par la table, groupes dépliés. */
+    /** Row actions declared by the table, with groups flattened. */
     getRecordActions() { return this.getTable().getRecordActions().flatMap((a) => (a instanceof ActionGroup ? a.getActions() : [a])); }
     getMountableActions(context) {
         if (typeof context.schemaComponent === 'string')
@@ -2309,7 +2312,7 @@ export class ListRecords extends Page {
             return this.getTable().getHeaderActions();
         return this.getHeaderActions();
     }
-    /** Seules les formes de contexte connues sont retenues ; la clé d'enregistrement est revérifiée en base au montage. */
+    /** Only known context shapes are kept; the record key is checked again in the database on mount. */
     resolveMountContext(clientContext) {
         const c = clientContext && typeof clientContext === 'object' ? clientContext : {};
         if (typeof c.schemaComponent === 'string' && c.schemaComponent.length <= 200)
@@ -2326,17 +2329,17 @@ export class ListRecords extends Page {
         return typeof context.recordKey === 'string' ? ((await this.resource.adapter.find(context.recordKey)) ?? null) : null;
     }
     /**
-     * Écriture d'une cellule modifiable (port de `updateTableColumnState`). Tout vient du navigateur : la colonne doit exister, être
-     * modifiable et visible, l'enregistrement être dans la portée de la table et modifiable par l'utilisateur, la valeur être valide.
+     * Writes an editable cell. Everything comes from the browser: the column must exist and be editable and visible, the record
+     * must be in the table's scope and editable by the user, and the value must be valid.
      */
     async updateTableColumnState(columnName, recordKey, input) {
-        // Toutes les vérifications (colonne visible et modifiable, portée, désactivation, autorisation, validation, crochets) sont dans le paquet tables.
+        // All checks (visible and editable column, scope, disabled state, authorization, validation, hooks) live in the tables package.
         return updateEditableColumnState(this.getTable(), this, this.getDataAdapterForTable(), columnName, recordKey, input, { authorize: (record) => canOn(this, 'update', record) });
     }
-    /** Clés sélectionnées : la liste envoyée, ou — en mode « tout sélectionner » — tous les enregistrements de la requête courante sauf ceux désélectionnés. */
+    /** Selected keys: the sent list, or, in "select all" mode, every record of the current query except deselected ones. */
     async getSelectedRecordKeys() {
         const clean = (list) => (Array.isArray(list) ? list.filter((k) => typeof k === 'string' || typeof k === 'number').map(String) : []);
-        // La sélection vient du navigateur : elle est ramenée aux enregistrements que cette table peut réellement afficher.
+        // The selection comes from the browser: it is narrowed to records this table can actually display.
         if (!this.isTrackingDeselectedTableRecords)
             return this.resource.adapter.keysInScope(clean(this.selectedTableRecords));
         const excluded = new Set(clean(this.deselectedTableRecords));
@@ -2351,7 +2354,7 @@ export class ListRecords extends Page {
     getTable() {
         const resource = this.resource;
         const table = new Table().pluralModelLabel(resource.getPluralModelLabel());
-        // Resource simple : la ligne ouvre l'édition en modale ; sinon elle mène à la page d'édition.
+        // Simple resource: the row opens the edit modal; otherwise it links to the edit page.
         return resource.table(resource.isSimple ? table.recordAction('edit') : table.recordUrl((record) => resource.getUrl(resource.hasViewPage ? 'view' : 'edit', resource.adapter.getKey(record))));
     }
     async renderTable() {
@@ -2382,7 +2385,7 @@ export class ListRecords extends Page {
             rowActions: async (record) => resource.isSimple || table.getRecordActions().length || !(await canOn(this, 'update', record)) ? [] : [{ label: t('filament-actions::edit.single.label'), url: resource.getUrl('edit', resource.adapter.getKey(record)), icon: 'c-pencil-square', key: `edit.${createHash('md5').update(resource.adapter.getKey(record)).digest('hex')}` }],
         });
     }
-    /** Actions affichées dans l'en-tête de la table (aucune pour une page de liste : elles sont dans l'en-tête de page). */
+    /** Table header actions (none on a list page: they go in the page header). */
     async renderTableHeaderActions(ctx) {
         const html = [];
         for (const action of this.getTable().getHeaderActions())
@@ -2406,7 +2409,7 @@ export class ListRecords extends Page {
         return [{ label: this.resource.getTitleCasePluralModelLabel(), url: this.resource.getUrl() }, { label: t('filament-panels::resources/pages/list-records.breadcrumb'), url: null }];
     }
     getHeaderActions() {
-        // Resource simple : création en modale ; sinon lien vers la page de création.
+        // Simple resource: create in a modal; otherwise link to the create page.
         if (this.resource.isSimple)
             return [CreateAction.make(this.resource)];
         return [...(this.resource.listHeaderActions?.() ?? []), Action.make('create').label(t('filament-actions::create.single.label', { label: this.resource.modelLabel })).url(this.resource.getUrl('create')).authorize(({ livewire }) => canOn(livewire, 'create'))];
@@ -2417,27 +2420,27 @@ export class ListRecords extends Page {
     }
 }
 /**
- * Table des enregistrements liés à un autre (port de RelationManager) : composant enfant de la page d'édition, chargé quand il devient visible.
- * Les sous-classes déclarent `relationship`, `adapterFor()`, `table()` et `form()`.
+ * Table of records related to another one: a child component of the edit page, loaded when it becomes visible.
+ * Subclasses declare `relationship`, `adapterFor()`, `table()` and `form()`.
  */
 export class RelationManager extends ListRecords {
     static relationship = '';
     static modelLabel = 'record';
     static pluralModelLabel = null;
     static recordTitleAttribute = null;
-    /** Adaptateur limité aux enregistrements liés au propriétaire donné. */
-    static adapterFor(_ownerKey) { throw new Error('RelationManager.adapterFor() doit être défini.'); }
-    /** Politique des enregistrements liés (mêmes capacités que celle d'une resource). */
+    /** Data adapter limited to records related to the given owner. */
+    static adapterFor(_ownerKey) { throw new Error('RelationManager.adapterFor() must be defined.'); }
+    /** Policy for related records (same abilities as a resource policy). */
     static policy = null;
     isAccessAuthorized(ctx) { return this.resource.can('viewAny', ctx.user); }
     static table(table) { return table; }
     static form(schema) { return schema; }
     static getTitle() { return this.title ?? ucfirst(this.relationship.replace(/([a-z])([A-Z])/g, '$1 $2').replace(/[_-]+/g, ' ').toLowerCase()); }
-    /** Clé de l'enregistrement propriétaire : fixée au montage par la page, jamais modifiable depuis le navigateur. */
+    /** Owner record key: set on mount by the page, never writable from the browser. */
     ownerRecord = '';
     static locked = ['ownerRecord'];
     _facade = null;
-    /** Ce que ListRecords attend d'une resource, fourni ici par le relation manager. */
+    /** What ListRecords expects from a resource, provided here by the relation manager. */
     get resource() {
         const manager = this.constructor;
         return (this._facade ??= {
@@ -2452,24 +2455,24 @@ export class RelationManager extends ListRecords {
     getTable() {
         const manager = this.constructor;
         const table = manager.table(new Table().pluralModelLabel(this.resource.getPluralModelLabel()).heading(manager.getTitle()));
-        // Comme Filament : s'il existe une action de ligne « edit », cliquer la ligne l'ouvre.
+        // If there is an "edit" row action, clicking the row opens it.
         const hasEdit = table.getRecordActions().flatMap((a) => (a instanceof ActionGroup ? a.getActions() : [a])).some((a) => a.getName() === 'edit');
         return hasEdit ? table.recordAction('edit') : table;
     }
-    // --- relations plusieurs-à-plusieurs : à définir par le manager qui propose Attach / Detach
-    /** Rattache un enregistrement existant au propriétaire. */
-    static attach(_ownerKey, _recordKey) { throw new Error('RelationManager.attach() doit être défini.'); }
-    /** Détache des enregistrements du propriétaire, sans les supprimer. */
-    static detach(_ownerKey, _recordKeys) { throw new Error('RelationManager.detach() doit être défini.'); }
-    /** Enregistrements rattachables correspondant à la recherche : [clé, libellé]. */
-    static searchAttachable(_ownerKey, _search) { throw new Error('RelationManager.searchAttachable() doit être défini.'); }
-    /** Libellé d'un enregistrement rattachable, ou null s'il ne l'est pas (sert aussi de validation). */
-    static attachableLabel(_ownerKey, _recordKey) { throw new Error('RelationManager.attachableLabel() doit être défini.'); }
+    // --- many-to-many: to be defined by managers offering Attach / Detach
+    /** Attaches an existing record to the owner. */
+    static attach(_ownerKey, _recordKey) { throw new Error('RelationManager.attach() must be defined.'); }
+    /** Detaches records from the owner without deleting them. */
+    static detach(_ownerKey, _recordKeys) { throw new Error('RelationManager.detach() must be defined.'); }
+    /** Attachable records matching the search: [key, label]. */
+    static searchAttachable(_ownerKey, _search) { throw new Error('RelationManager.searchAttachable() must be defined.'); }
+    /** Label of an attachable record, or `null` if it is not attachable (also used as validation). */
+    static attachableLabel(_ownerKey, _recordKey) { throw new Error('RelationManager.attachableLabel() must be defined.'); }
     getHeaderActions() { return []; }
     placeholder() {
         return `<div role="status" aria-busy="true" style="height: 8rem; ;" class="fi-section fi-loading-section fi-grid-col"><span class="fi-sr-only">${e(t('filament::components/loading-section.label'))}</span></div>`;
     }
-    /** Comme Filament : un relation manager a ses propres emplacements, pas ceux de la page de liste. */
+    /** A relation manager has its own render hook locations, not the list page's. */
     contentSchema(schema) {
         return schema.components([new ResourceTabs(), RenderHook.make(PanelsRenderHook.RESOURCE_RELATION_MANAGER_BEFORE), EmbeddedTable.make(), RenderHook.make(PanelsRenderHook.RESOURCE_RELATION_MANAGER_AFTER)]);
     }
@@ -2478,25 +2481,25 @@ export class RelationManager extends ListRecords {
     }
 }
 /**
- * Page des enregistrements liés à un enregistrement (port de ManageRelatedRecords) : une table, avec création, consultation et
- * édition en modales. Déclarée par `static relatedPages` de la resource propriétaire, elle répond sous `<slug>/{record}/<nom>`.
+ * Page listing records related to a record: a table, with create, view and edit in modals.
+ * Declared in the owner resource's `static relatedPages`, it is served at `<slug>/{record}/<name>`.
  */
 export class ManageRelatedRecords extends ListRecords {
-    /** Resource propriétaire : fixée à l'enregistrement de la page. */
+    /** Owner resource: set when the page is registered. */
     static parentResource;
     static relationship = '';
     static modelLabel = 'record';
     static pluralModelLabel = null;
     static recordTitleAttribute = null;
     static policy = null;
-    /** Adaptateur limité aux enregistrements liés au propriétaire donné. */
-    static adapterFor(_ownerKey) { throw new Error('ManageRelatedRecords.adapterFor() doit être défini.'); }
+    /** Data adapter limited to records related to the given owner. */
+    static adapterFor(_ownerKey) { throw new Error('ManageRelatedRecords.adapterFor() must be defined.'); }
     static table(table) { return table; }
     static form(schema) { return schema; }
     static infolist(schema) { return schema; }
     static getTitle() { return this.title ?? ucfirst(this.relationship.replace(/([a-z])([A-Z])/g, '$1 $2').replace(/[_-]+/g, ' ').toLowerCase()); }
     static getNavigationLabel() { return this.navigationLabel ?? this.getTitle(); }
-    /** Clé de l'enregistrement propriétaire : tirée de l'adresse au montage, jamais modifiable depuis le navigateur. */
+    /** Owner record key: read from the URL on mount, never writable from the browser. */
     recordKey = '';
     static locked = ['recordKey'];
     _owner = null;
@@ -2507,18 +2510,18 @@ export class ManageRelatedRecords extends ListRecords {
         await this.hydrate();
         await ListRecords.prototype.mount?.call(this, params);
     }
-    /** Le propriétaire est relu et son accès vérifié à chaque requête. */
+    /** The owner is reloaded and access to it checked on every request. */
     async hydrate() {
         const parent = this.related.parentResource;
         this._owner = await parent.adapter.find(this.recordKey);
         if (!this._owner)
-            throw new WireError(404, 'Enregistrement introuvable.');
+            throw new WireError(404, 'Record not found.');
         if (!(await parent.can('view', this._ctx?.user ?? null, this._owner)))
-            throw new WireError(403, 'Accès refusé.');
+            throw new WireError(403, 'Forbidden.');
         await ListRecords.prototype.hydrate?.call(this);
     }
     getRecordKey() { return this.recordKey; }
-    /** Ce que ListRecords attend d'une resource, fourni ici par la page. */
+    /** What ListRecords expects from a resource, provided here by the page. */
     get resource() {
         const page = this.related;
         return (this._facade ??= {
@@ -2532,7 +2535,7 @@ export class ManageRelatedRecords extends ListRecords {
     }
     getTable() { return this.related.table(new Table().pluralModelLabel(this.resource.getPluralModelLabel())); }
     getHeaderActions() { return []; }
-    /** Comme Filament : le contenu de la page est un groupe (onglets éventuels, puis la table). */
+    /** The page content is a group (tabs, if any, then the table). */
     contentSchema(schema) {
         return schema.components([Group.make([new ResourceTabs(), RenderHook.make(PanelsRenderHook.RESOURCE_RELATION_MANAGER_BEFORE), EmbeddedTable.make(), RenderHook.make(PanelsRenderHook.RESOURCE_RELATION_MANAGER_AFTER)]), new RelationManagerTabs().key(null).hidden()]);
     }
@@ -2548,7 +2551,7 @@ export class ManageRelatedRecords extends ListRecords {
     }
     getPageClasses() { return ['fi-resource-manage-related-records-page', `fi-resource-${this.related.parentResource.slug.replace(/\//g, '-')}`, `fi-resource-record-${this.recordKey}`]; }
 }
-/** Adresse de la page précédente si elle appartient à ce site, sinon la racine du site (sans barre finale, comme Laravel). */
+/** Previous page URL if it belongs to this site, otherwise the site root (without a trailing slash). */
 function previousUrlOf(req) {
     if (!req)
         return '';
@@ -2558,27 +2561,27 @@ function previousUrlOf(req) {
         if (referer.origin === origin)
             return `${origin}${referer.pathname === '/' ? '' : referer.pathname}${referer.search}`;
     }
-    catch { /* pas de Referer exploitable */ }
+    catch { /* no usable Referer */ }
     return origin;
 }
-/** Couleur représentative d'un thème (nuance 500 de sa couleur primaire), pour la pastille du menu. */
+/** A theme's representative color (shade 500 of its primary color), for the menu swatch. */
 function swatchOf(theme, panel) {
     const primary = theme.colors?.primary;
     return (typeof primary === 'string' ? primary : primary?.[500]) ?? panel.colors.getColor('primary')?.[500] ?? 'currentColor';
 }
-/** Police d'un thème : sans adresse, elle est servie par Bunny Fonts comme celle du panel. */
+/** A theme's font: without a URL, it is served by Bunny Fonts like the panel font. */
 function fontOf(font) {
     return font.url ? { family: font.family, url: font.url } : { family: font.family, url: `https://fonts.bunny.net/css?family=${encodeURIComponent(font.family.toLowerCase().replace(/ /g, '-'))}:400,500,600,700&display=swap`, preconnect: 'https://fonts.bunny.net' };
 }
 function emptyToNull(data) { return Object.fromEntries(Object.entries(data).map(([k, v]) => [k, v === '' ? null : v])); }
-/** Base des pages à formulaire d'une resource. */
+/** Base class for a resource's form pages. */
 class ResourceFormPage extends Page {
-    /** Champ réactif du formulaire (`live()` + `afterStateUpdated()`) : `set(nom, valeur)` écrit à côté du champ modifié. */
+    /** Live form field (`live()` + `afterStateUpdated()`): `set(name, value)` writes next to the updated field. */
     async updatedData(_value, key) {
         if (!key)
             return;
         const path = `data.${key}`;
-        // Le champ modifié d'abord, puis ses champs parents (un Repeater recalcule un total quand une de ses lignes change), comme Filament.
+        // The updated field first, then its parent fields (a Repeater recomputes a total when one of its rows changes).
         const fields = this.getSchema('form').getFlatComponents().filter((c) => c instanceof Field && c.hasAfterStateUpdated() && (c.getStatePath() === path || path.startsWith(`${c.getStatePath()}.`)))
             .sort((a, b) => b.getStatePath().length - a.getStatePath().length);
         for (const field of fields) {
@@ -2600,21 +2603,21 @@ class ResourceFormPage extends Page {
     getDataAdapter() { return this.resource.adapter; }
     getRecordKey() { return null; }
     getRecord() { return null; }
-    /** Deux colonnes par défaut à partir de `lg`, comme `defaultForm()` de Filament ; la resource peut en décider autrement. */
+    /** Two columns from `lg` by default; the resource may decide otherwise. */
     formSchema(schema) {
         const form = this.resource.form(schema.columns(2).operation(this.getOperation()).record(this.getRecord()));
         const steps = this.getSteps();
-        // Assistant : les étapes remplacent les composants du formulaire de la resource (comme le trait HasWizard).
+        // Wizard: the steps replace the resource form's components.
         return steps === null ? form : form.columns(null).components([this.getWizardComponent(steps)]);
     }
     /**
-     * Étapes d'un assistant (équivalent du trait HasWizard de Filament) : dès que la méthode en retourne, la page présente son formulaire
-     * étape par étape, avec « Back » / « Next » et le bouton d'enregistrement sur la dernière étape.
+     * Wizard steps: as soon as this method returns some, the page shows its form step by step,
+     * with "Back" / "Next" and the submit button on the last step.
      */
     getSteps() { return null; }
-    /** Vrai : les étapes sont accessibles dans n'importe quel ordre, sans validation au passage. */
+    /** `true`: steps can be visited in any order, without validation along the way. */
     hasSkippableSteps() { return false; }
-    /** Étape affichée à l'ouverture (à partir de 1). */
+    /** Step shown on open (1-based). */
     getStartStep() { return 1; }
     getWizardComponent(steps) {
         const [submit] = this.getFormActions();
@@ -2623,7 +2626,7 @@ class ResourceFormPage extends Page {
             .alpineSubmitHandler(`$wire.${this.getSubmitMethod()}()`).skippable(this.hasSkippableSteps()).contained(false);
     }
     contentSchema(schema) {
-        // Assistant : pas de balise <form> autour, chaque étape a la sienne et l'assistant porte les actions.
+        // Wizard: no surrounding <form>; each step has its own and the wizard holds the actions.
         if (this.getSteps() !== null)
             return schema.components([EmbeddedSchema.make('form')]);
         return schema.components([
@@ -2631,13 +2634,13 @@ class ResourceFormPage extends Page {
                 .footer([Actions.make(this.getFormActions()).alignment('start').key('form-actions')]),
         ]);
     }
-    /** Destination de « Cancel » quand le navigateur n'a pas d'historique : la liste, sauf si la page en décide autrement. */
+    /** Where "Cancel" goes when the browser has no history: the list page, unless the page decides otherwise. */
     getCancelUrl() { return this.resource.getUrl(); }
     cancelAction() {
         return Action.make('cancel').label(t(`filament-panels::resources/pages/${this.getOperation()}-record.form.actions.cancel.label`)).color('gray')
             .alpineClickHandler(`document.referrer ? window.history.back() : Livewire.navigate(${js(this.getCancelUrl())})`);
     }
-    /** Valide le formulaire ; en cas d'erreur, les pose sur le composant et prévient le navigateur. */
+    /** Validates the form; on error, sets the errors on the component and notifies the browser. */
     async validateForm() {
         this._errors = await validateSchema(this.getSchema('form'));
         if (!Object.keys(this._errors).length)
@@ -2646,7 +2649,7 @@ class ResourceFormPage extends Page {
         return false;
     }
 }
-/** Page de création d'un enregistrement (port de CreateRecord). */
+/** Record creation page. */
 export class CreateRecord extends ResourceFormPage {
     static callable = ['create', 'createAnother'];
     mount() { fillSchema(this.getSchema('form'), this.data); }
@@ -2664,18 +2667,18 @@ export class CreateRecord extends ResourceFormPage {
             this.cancelAction(),
         ];
     }
-    // --- crochets de cycle de vie, à surcharger dans une sous-classe (aucun n'est appelable depuis le navigateur)
-    /** Transforme les données validées avant la création (ajouter l'auteur, calculer un champ…). */
+    // --- lifecycle hooks, to override in a subclass (none can be called from the browser)
+    /** Transforms validated data before creation (add the author, compute a field…). */
     mutateFormDataBeforeCreate(data) { return data; }
-    /** Juste avant la création ; lever une erreur l'annule. */
+    /** Right before creation; throwing cancels it. */
     beforeCreate(_data) { }
-    /** La création elle-même : par défaut, l'adaptateur de la resource. */
+    /** The creation itself; defaults to the resource's data adapter. */
     handleRecordCreation(data) { return this.getDataAdapter().create(data); }
-    /** Après la création (journal, envoi d'un message…). */
+    /** After creation (logging, sending a message…). */
     afterCreate(_record) { }
-    /** Où aller ensuite : par défaut, la page d'édition du nouvel enregistrement. */
+    /** Where to go next; defaults to the new record's edit page. */
     getRedirectUrl(record) { return this.resource.getUrl('edit', this.getDataAdapter().getKey(record)); }
-    /** Titre de la notification de succès ; `null` pour ne rien afficher. */
+    /** Success notification title; `null` to show nothing. */
     getCreatedNotificationTitle() { return t('filament-panels::resources/pages/create-record.notifications.created.title'); }
     async create(another = false) {
         if (!(await this.validateForm()))
@@ -2696,14 +2699,14 @@ export class CreateRecord extends ResourceFormPage {
     }
     createAnother() { return this.create(true); }
 }
-/** Action de suppression d'un enregistrement, avec confirmation (port de Filament\Actions\DeleteAction dans une page de resource). */
+/** Delete action with confirmation. */
 export class DeleteAction {
-    /** Sur une page d'édition : supprime l'enregistrement de la page puis revient à la liste. Sur une ligne de table : supprime la ligne. */
+    /** On an edit page, deletes the page's record and returns to the list. On a table row, deletes the row. */
     static make() {
         return Action.make('delete').authorize(({ livewire, record }) => canOn(livewire, 'delete', record))
             .label(t('filament-actions::delete.single.label')).color('danger').keyBindings(['mod+d']).tableIcon('c-trash').groupedIcon('m-trash')
             .requiresConfirmation().modalIcon('o-trash')
-            // Masquée pour un enregistrement déjà supprimé (suppression douce).
+            // Hidden for an already soft-deleted record.
             .hidden(({ livewire, record }) => { const target = record ?? livewire._record; return target ? livewire.getDataAdapter().isTrashed(target) : false; })
             .modalHeading(({ livewire, record }) => t('filament-actions::delete.single.modal.heading', { label: livewire.resource.getRecordTitle(record ?? livewire._record) }))
             .modalSubmitActionLabel(t('filament-actions::delete.single.modal.actions.delete.label'))
@@ -2717,7 +2720,7 @@ export class DeleteAction {
         });
     }
 }
-/** Duplication d'une ligne de table (port de ReplicateAction) : la copie reprend les attributs de l'enregistrement, sauf sa clé, ses dates et ceux exclus. */
+/** Duplicates a table row: the copy takes the record's attributes, except its key, timestamps and excluded ones. */
 export class ReplicateAction {
     static make() {
         let excluded = [];
@@ -2728,7 +2731,7 @@ export class ReplicateAction {
             .action(async ({ livewire, record }) => {
             const adapter = livewire.getDataAdapter();
             const source = typeof record?.toJSON === 'function' ? record.toJSON() : { ...record };
-            // Comme Model::replicate() : ni clé primaire ni dates de création et de modification.
+            // No primary key, no created/updated timestamps.
             for (const attribute of ['id', 'created_at', 'updated_at', ...excluded])
                 delete source[attribute];
             await adapter.create(source);
@@ -2738,9 +2741,9 @@ export class ReplicateAction {
         return action;
     }
 }
-/** Création en modale avec le formulaire de la resource (port de CreateAction). */
+/** Create in a modal with the resource form. */
 export class CreateAction {
-    /** Sans argument, la resource (ou le relation manager) est celle du composant hôte. */
+    /** Without an argument, the resource (or relation manager) is the host component's. */
     static make(resource = null) {
         const of = (livewire) => resource ?? livewire.resource;
         return Action.make('create').authorize(({ livewire, record }) => canOn(livewire, 'create', record))
@@ -2755,9 +2758,9 @@ export class CreateAction {
         });
     }
 }
-/** Édition en modale d'une ligne de table, avec le formulaire de la resource (port de EditAction). */
+/** Edit a table row in a modal, with the resource form. */
 export class EditAction {
-    /** Sans argument, la resource (ou le relation manager) est celle du composant hôte. */
+    /** Without an argument, the resource (or relation manager) is the host component's. */
     static make(resource = null) {
         const of = (livewire) => resource ?? livewire.resource;
         return Action.make('edit').authorize(({ livewire, record }) => canOn(livewire, 'update', record))
@@ -2773,13 +2776,13 @@ export class EditAction {
         });
     }
 }
-/** Lien vers la page de consultation de l'enregistrement (port de ViewAction, quand la resource a une page « View »). */
+/** Link to the record's view page (when the resource has one). */
 export class ViewAction {
     static make(resource = null) {
         const of = (livewire) => resource ?? livewire.resource;
         return Action.make('view').authorize(({ livewire, record }) => canOn(livewire, 'view', record))
             .label(t('filament-actions::view.single.label')).color('gray').tableIcon('c-eye').groupedIcon('m-eye')
-            // Sans page « View » (resource simple, enregistrements liés) : l'infolist s'ouvre en modale, comme Filament.
+            // Without a view page (simple resource, related records): the infolist opens in a modal.
             .url(({ livewire, record }) => (record && of(livewire).hasViewPage ? of(livewire).getUrl('view', of(livewire).adapter.getKey(record)) : null))
             .modalHeading(({ livewire, record }) => t('filament-actions::view.single.modal.heading', { label: of(livewire).getRecordTitle(record) }))
             .modalSubmitAction(false).modalCancelActionLabel(t('filament-actions::view.single.modal.actions.close.label'))
@@ -2787,7 +2790,7 @@ export class ViewAction {
     }
 }
 const managerOf = (livewire) => livewire.constructor;
-/** Rattache un enregistrement existant au propriétaire d'un relation manager (port de AttachAction). */
+/** Attaches an existing record to a relation manager's owner. */
 export class AttachAction {
     static make() {
         return Action.make('attach')
@@ -2807,7 +2810,7 @@ export class AttachAction {
         });
     }
 }
-/** Détache une ligne du propriétaire sans la supprimer (port de DetachAction). */
+/** Detaches a row from the owner without deleting it. */
 export class DetachAction {
     static make() {
         return Action.make('detach')
@@ -2821,7 +2824,7 @@ export class DetachAction {
         });
     }
 }
-/** Détache les lignes sélectionnées (port de DetachBulkAction). */
+/** Detaches the selected rows. */
 export class DetachBulkAction {
     static make() {
         return Action.make('detach')
@@ -2830,14 +2833,14 @@ export class DetachBulkAction {
             .modalHeading(({ livewire }) => t('filament-actions::detach.multiple.modal.heading', { label: livewire.resource.getPluralModelLabel() }))
             .modalSubmitActionLabel(t('filament-actions::detach.multiple.modal.actions.detach.label'))
             .action(async ({ livewire }) => {
-            // Les clés sélectionnées sont celles de la requête courante du manager : elles appartiennent donc au propriétaire.
+            // Selected keys come from the manager's current query, so they belong to the owner.
             await managerOf(livewire).detach(livewire.ownerRecord, await livewire.getSelectedRecordKeys());
             Notification.make().success().title(t('filament-actions::detach.multiple.notifications.detached.title')).send();
             livewire.deselectAllTableRecords();
         });
     }
 }
-/** Restauration d'un enregistrement supprimé (port de RestoreAction). Visible seulement s'il est supprimé. */
+/** Restores a soft-deleted record. Only visible when the record is deleted. */
 export class RestoreAction {
     static make() {
         return Action.make('restore').authorize(({ livewire, record }) => canOn(livewire, 'restore', record))
@@ -2853,7 +2856,7 @@ export class RestoreAction {
         });
     }
 }
-/** Suppression définitive d'un enregistrement supprimé (port de ForceDeleteAction). Visible seulement s'il est supprimé. */
+/** Permanently deletes a soft-deleted record. Only visible when the record is deleted. */
 export class ForceDeleteAction {
     static make() {
         return Action.make('forceDelete').authorize(({ livewire, record }) => canOn(livewire, 'forceDelete', record))
@@ -2869,7 +2872,7 @@ export class ForceDeleteAction {
         });
     }
 }
-/** Suppression groupée des enregistrements sélectionnés dans une table (port de DeleteBulkAction). */
+/** Deletes the records selected in a table. */
 export class DeleteBulkAction {
     static make() {
         return Action.make('delete').authorize(({ livewire, record }) => canOn(livewire, 'deleteAny', record))
@@ -2884,21 +2887,21 @@ export class DeleteBulkAction {
         });
     }
 }
-/** Page d'édition d'un enregistrement (port de EditRecord). */
+/** Record edit page. */
 export class EditRecord extends ResourceFormPage {
     static callable = ['save'];
     recordKey = '';
-    /** Onglet de relation manager actif (indice dans `Resource.relations`). */
+    /** Active relation manager tab (index in `Resource.relations`). */
     activeRelationManager = '0';
     /**
-     * Page précédente (équivalent de `url()->previous()`), retenue au premier affichage. Elle vient de l'en-tête Referer :
-     * seule une adresse de ce même site est acceptée, et elle n'est plus modifiable ensuite.
+     * Previous page, captured on first display from the Referer header: only a same-site URL is accepted,
+     * and it cannot be changed afterwards.
      */
     previousUrl = '';
     getCancelUrl() { return this.previousUrl; }
     contentSchema(schema) {
         const content = super.contentSchema(schema);
-        // Toujours présent, comme dans Filament : masqué (colonne vide) quand la resource n'a pas de relation manager.
+        // Always present: hidden (empty column) when the resource has no relation manager.
         return content.components([...content.getComponents(), this.resource.relations.length ? new RelationManagerTabs() : new RelationManagerTabs().key(null).hidden()]);
     }
     static locked = ['recordKey', 'previousUrl'];
@@ -2907,25 +2910,24 @@ export class EditRecord extends ResourceFormPage {
         this.recordKey = String(params.record ?? '');
         this.previousUrl = previousUrlOf(this._ctx?.req);
         await this.hydrate();
-        // Remplit le formulaire avec les valeurs de l'enregistrement pour chaque champ déclaré.
         fillSchemaFromRecord(this.getSchema('form'), this.data, await this.mutateFormDataBeforeFill({ ...this._record }));
     }
-    /** L'enregistrement est relu à chaque requête, comme dans Filament (pas de liaison de route). */
+    /** The record is reloaded on every request (no route model binding). */
     async hydrate() {
         this._record = await this.getDataAdapter().find(this.recordKey);
         if (!this._record)
-            throw new WireError(404, 'Enregistrement introuvable.');
+            throw new WireError(404, 'Record not found.');
         if (!(await canOn(this, 'update', this._record)))
-            throw new WireError(403, 'Accès refusé.');
+            throw new WireError(403, 'Forbidden.');
     }
     getRecord() { return this._record; }
     getRecordKey() { return this.recordKey; }
     getActionMountContext() { return { recordKey: this.recordKey }; }
     getActionRecord() { return this._record; }
-    /** Comme une page générée par Filament : suppression, plus restauration et suppression définitive si le modèle a la suppression douce. */
+    /** Delete, plus restore and force-delete when the model uses soft deletes. */
     getHeaderActions() {
         const defaults = this.getDataAdapter().supportsSoftDeletes() ? [DeleteAction.make(), RestoreAction.make(), ForceDeleteAction.make()] : [DeleteAction.make()];
-        // Actions propres à la resource, placées avant les actions par défaut.
+        // Resource-specific actions come before the default ones.
         return [...(this.resource.editHeaderActions?.() ?? []), ...defaults];
     }
     getOperation() { return 'edit'; }
@@ -2934,7 +2936,7 @@ export class EditRecord extends ResourceFormPage {
     getBreadcrumbs() {
         return [
             { label: this.resource.getTitleCasePluralModelLabel(), url: this.resource.getUrl() },
-            // Le titre de l'enregistrement n'apparaît que si la resource déclare `recordTitleAttribute` ; il mène à la page « View » quand elle existe.
+            // The record title only appears if the resource declares `recordTitleAttribute`; it links to the view page when there is one.
             ...(this.resource.recordTitleAttribute ? [{ label: this.resource.getRecordTitle(this._record), url: this.resource.getUrl(this.resource.hasViewPage ? 'view' : 'edit', this.recordKey) }] : []),
             { label: t('filament-panels::resources/pages/edit-record.breadcrumb'), url: null },
         ];
@@ -2944,20 +2946,20 @@ export class EditRecord extends ResourceFormPage {
     getFormActions() {
         return [Action.make('save').label(t('filament-panels::resources/pages/edit-record.form.actions.save.label')).submit('save').keyBindings(['mod+s']), this.cancelAction()];
     }
-    // --- crochets de cycle de vie, à surcharger dans une sous-classe (aucun n'est appelable depuis le navigateur)
-    /** Transforme les valeurs de l'enregistrement avant de remplir le formulaire. */
+    // --- lifecycle hooks, to override in a subclass (none can be called from the browser)
+    /** Transforms the record's values before filling the form. */
     mutateFormDataBeforeFill(data) { return data; }
-    /** Transforme les données validées avant l'enregistrement. */
+    /** Transforms validated data before saving. */
     mutateFormDataBeforeSave(data) { return data; }
-    /** Juste avant l'enregistrement ; lever une erreur l'annule. */
+    /** Right before saving; throwing cancels it. */
     beforeSave(_data) { }
-    /** L'enregistrement lui-même : par défaut, l'adaptateur de la resource. */
+    /** The save itself; defaults to the resource's data adapter. */
     handleRecordUpdate(record, data) { return this.getDataAdapter().update(this.getDataAdapter().getKey(record), data); }
-    /** Après l'enregistrement. */
+    /** After saving. */
     afterSave(_record) { }
-    /** Adresse où aller après l'enregistrement ; `null` (défaut) : rester sur la page. */
+    /** URL to go to after saving; `null` (default) stays on the page. */
     getRedirectUrl(_record) { return null; }
-    /** Titre de la notification de succès ; `null` pour ne rien afficher. */
+    /** Success notification title; `null` to show nothing. */
     getSavedNotificationTitle() { return t('filament-panels::resources/pages/edit-record.notifications.saved.title'); }
     async save() {
         if (!(await this.validateForm()))
@@ -2974,12 +2976,12 @@ export class EditRecord extends ResourceFormPage {
             this.redirect(url, true);
     }
 }
-/** Page de consultation d'un enregistrement (port de ViewRecord) : le schéma `infolist()` de la resource, en lecture seule. */
+/** Record view page: the resource's read-only `infolist()` schema. */
 export class ViewRecord extends Page {
     static resource;
     static locked = ['recordKey'];
     recordKey = '';
-    /** Onglet de relation manager actif (indice dans `Resource.relations`). */
+    /** Active relation manager tab (index in `Resource.relations`). */
     activeRelationManager = '0';
     _record = null;
     get resource() { return this.constructor.resource; }
@@ -2988,13 +2990,13 @@ export class ViewRecord extends Page {
         this.recordKey = String(params.record ?? '');
         await this.hydrate();
     }
-    /** L'enregistrement est relu à chaque requête, comme sur la page d'édition. */
+    /** The record is reloaded on every request, as on the edit page. */
     async hydrate() {
         this._record = await this.getDataAdapter().find(this.recordKey);
         if (!this._record)
-            throw new WireError(404, 'Enregistrement introuvable.');
+            throw new WireError(404, 'Record not found.');
         if (!(await canOn(this, 'view', this._record)))
-            throw new WireError(403, 'Accès refusé.');
+            throw new WireError(403, 'Forbidden.');
     }
     getRecordKey() { return this.recordKey; }
     getActionMountContext() { return { recordKey: this.recordKey }; }
@@ -3002,10 +3004,10 @@ export class ViewRecord extends Page {
     infolistSchema(schema) { return this.resource.infolist(schema.columns(2).operation('view').record(this._record)); }
     contentSchema(schema) {
         const content = schema.components([EmbeddedSchema.make('infolist')]);
-        // Toujours présent, comme dans Filament : masqué (colonne vide) quand la resource n'a pas de relation manager.
+        // Always present: hidden (empty column) when the resource has no relation manager.
         return content.components([...content.getComponents(), this.resource.relations.length ? new RelationManagerTabs() : new RelationManagerTabs().key(null).hidden()]);
     }
-    /** Par défaut : le lien vers la page d'édition (EditAction d'une page « View »). */
+    /** Defaults to a link to the edit page. */
     getHeaderActions() { return [this.editAction()]; }
     editAction() {
         return Action.make('edit').authorize(({ livewire, record }) => canOn(livewire, 'update', record)).label(t('filament-actions::edit.single.label')).url(() => this.resource.getUrl('edit', this.recordKey));
@@ -3014,7 +3016,7 @@ export class ViewRecord extends Page {
     getBreadcrumbs() {
         return [
             { label: this.resource.getTitleCasePluralModelLabel(), url: this.resource.getUrl() },
-            // Le titre de l'enregistrement n'apparaît que si la resource déclare `recordTitleAttribute`.
+            // The record title only appears if the resource declares `recordTitleAttribute`.
             ...(this.resource.recordTitleAttribute ? [{ label: this.resource.getRecordTitle(this._record), url: this.resource.getUrl('view', this.recordKey) }] : []),
             { label: t('filament-panels::resources/pages/view-record.breadcrumb'), url: null },
         ];
@@ -3022,10 +3024,9 @@ export class ViewRecord extends Page {
     getSubNavigation() { return this.resource.getRecordSubNavigation(this); }
     getPageClasses() { return ['fi-resource-view-record-page', `fi-resource-${this.resource.slug.replace(/\//g, '-')}`, `fi-resource-record-${this.recordKey}`]; }
 }
-// ------------------------------------------------------------------ composants de mise en page
-/** Contexte d'évaluation des actions d'un menu du panel (pas d'enregistrement). */
+/** Evaluation context for panel menu actions (no record). */
 const menuContext = (livewire) => ({ livewire: livewire, component: null, operation: null, record: null, get: () => undefined, state: undefined });
-/** Menu utilisateur (port de HasUserMenu et de la vue user-menu) : profil, éléments du panel, thèmes, déconnexion. */
+/** User menu: profile, panel items, themes, logout. */
 async function renderUserMenu(component, position) {
     const { req, res, panel, user } = component._ctx;
     const ctx = menuContext(component);
@@ -3048,7 +3049,7 @@ async function renderUserMenu(component, position) {
         themes: panel.getThemes().map((theme) => ({ id: theme.id, label: theme.label, swatch: swatchOf(theme, panel) })), activeTheme: panel.resolveTheme(req)?.id ?? null,
     });
 }
-/** Menu du locataire (port de la vue tenant-menu) : locataire courant, autres locataires, création, profil. */
+/** Tenant menu: current tenant, other tenants, registration, profile. */
 async function renderTenantMenu(component, options) {
     const { panel, user } = component._ctx;
     const tenant = panel.getTenant();
@@ -3081,13 +3082,13 @@ async function renderTenantMenu(component, options) {
         switchable: others.map((other) => ({ name: provider.getName(other), url: panel.getUrl('', other), avatarUrl: panel.getTenantAvatarUrl(other) })),
     });
 }
-/** Sidebar : logo, menu du locataire, recherche, navigation, et — sans barre du haut — cloche et menu utilisateur. */
+/** Sidebar: logo, tenant menu, search, navigation and, without a topbar, the bell and user menu. */
 export class Sidebar extends Component {
     static callable = ['setTheme'];
     currentPath = '/';
     static locked = ['currentPath'];
     mount(params) { this.currentPath = String(params.path ?? '/'); }
-    /** Un élément de resource reste actif sur ses pages de création et d'édition. */
+    /** A resource item stays active on its create and edit pages. */
     async render() {
         const { panel, user } = this._ctx;
         if (!user)
@@ -3104,22 +3105,22 @@ export class Sidebar extends Component {
             livewireId: this.id,
         });
     }
-    /** Choix d'un thème par l'utilisateur : seul un thème déclaré par le panel est accepté ; la page est rechargée pour l'appliquer. */
+    /** Theme choice by the user: only a theme declared by the panel is accepted; the page reloads to apply it. */
     setTheme(id) { applyTheme(this, id); this.skipRender(); }
 }
-/** Choix d'un thème (sidebar ou barre du haut) : seul un thème déclaré par le panel est accepté ; la page est rechargée. */
+/** Theme choice (sidebar or topbar): only a theme declared by the panel is accepted; the page reloads. */
 function applyTheme(component, id) {
     const { req, res, panel, user } = component._ctx;
     if (!user)
-        throw new WireError(401, 'Non authentifié.');
+        throw new WireError(401, 'Unauthenticated.');
     const theme = panel.getThemes().find((candidate) => candidate.id === id);
     if (!theme)
-        throw new WireError(404, 'Thème inconnu.');
+        throw new WireError(404, 'Unknown theme.');
     panel.rememberTheme(res, theme);
     const referer = previousUrlOf(req);
     component.redirect(referer.replace(/^https?:\/\/[^/]+/, '') || '/');
 }
-/** Barre du haut (port de Filament\Livewire\Topbar) : logo, navigation éventuelle, recherche, cloche, menu utilisateur. */
+/** Topbar: logo, optional navigation, search, bell, user menu. */
 export class Topbar extends Component {
     static callable = ['setTheme'];
     currentPath = '/';
@@ -3147,7 +3148,7 @@ export class Topbar extends Component {
     }
     setTheme(id) { applyTheme(this, id); this.skipRender(); }
 }
-/** Menu utilisateur des pages simples d'un utilisateur connecté (port de SimpleUserMenu). */
+/** User menu on simple pages for a signed-in user. */
 export class SimpleUserMenu extends Component {
     static callable = ['setTheme'];
     async render() {
@@ -3159,32 +3160,76 @@ export class SimpleUserMenu extends Component {
     }
     setTheme(id) { applyTheme(this, id); this.skipRender(); }
 }
-// ------------------------------------------------------------------ routage
-/** Un runtime ne sert qu'un panel : chaque panel a son endpoint Livewire et ses composants. */
+/** `.ts`, `.mts`, `.js`, `.mjs` modules of a folder and its subfolders, in alphabetical path order. */
+function moduleFiles(directory) {
+    const root = directory instanceof URL ? fileURLToPath(directory) : directory;
+    if (!existsSync(root))
+        return [];
+    const files = [];
+    const walk = (dir) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+            const full = join(dir, entry.name);
+            if (entry.isDirectory())
+                walk(full);
+            else if (/\.(m?ts|m?js)$/.test(entry.name) && !/\.(d|test|spec)\.m?[tj]s$/.test(entry.name))
+                files.push(full);
+        }
+    };
+    walk(root);
+    return files;
+}
+/** Classes exported by a folder's modules that extend `base` (the base class itself, abstract or imported, is skipped). */
+async function discoverClasses(directory, base) {
+    const found = [];
+    for (const file of moduleFiles(directory)) {
+        const module = await import(__rewriteRelativeImportExtension(pathToFileURL(file).href));
+        for (const value of Object.values(module))
+            if (typeof value === 'function' && value.prototype instanceof base && !found.includes(value))
+                found.push(value);
+    }
+    return found;
+}
+/** Resources defined in a folder: `.resources(await discoverResources(new URL('./resources/', import.meta.url)))`. New files are picked up on the next start. */
+export const discoverResources = (directory) => discoverClasses(directory, Resource);
+/** Custom pages (and dashboards) defined in a folder. Resource and authentication pages are excluded. */
+export const discoverPages = async (directory) => (await discoverClasses(directory, Page)).filter((page) => !page.resource && !(page.prototype instanceof EditTenantProfile));
+/** Widgets defined in a folder. */
+export const discoverWidgets = (directory) => discoverClasses(directory, Widget);
+/** Panels default-exported (`export default Panel.make()…`) by a folder's modules. */
+export async function discoverPanels(directory) {
+    const panels = [];
+    for (const file of moduleFiles(directory)) {
+        const module = await import(__rewriteRelativeImportExtension(pathToFileURL(file).href));
+        if (module.default instanceof Panel)
+            panels.push(module.default);
+    }
+    return panels;
+}
+/** A runtime serves a single panel: each panel has its own Livewire endpoint and components. */
 const runtimePanels = new WeakMap();
-/** Segments réservés juste après le chemin d'un panel à locataires (ils ne sont pas des clés de locataire). */
+/** Reserved segments right after a multi-tenant panel's path (they are not tenant keys). */
 const RESERVED_SEGMENTS = new Set(['login', 'logout', 'register', 'password-reset', 'email-verification', 'profile', 'livewire']);
-/** Routeur Express d'un panel : assets, endpoint du runtime, authentification, locataires, pages protégées. */
+/** Express router for a panel: assets, runtime endpoint, authentication, tenants, protected pages. */
 export function panelRouter(panel, runtime) {
     const owner = runtimePanels.get(runtime);
     if (owner && owner !== panel)
-        throw new Error(`Ce WireRuntime sert déjà le panel « ${owner.getId()} » : créez un WireRuntime par panel.`);
+        throw new Error(`This WireRuntime already serves panel "${owner.getId()}": create one WireRuntime per panel.`);
     runtimePanels.set(runtime, panel);
-    // Les envois de fichiers passent par l'endpoint de ce panel (session et utilisateur du panel).
+    // File uploads go through this panel's endpoint (panel session and user).
     const runtimeOptions = runtime.options;
     runtimeOptions.uploadPrefix ??= panel.getLivewirePrefix();
-    // Un seul gestionnaire de couleurs pour tous les panels : chaque requête y pose les couleurs du sien.
+    // One color manager for all panels: each request sets its own panel's colors on it.
     useColorManager(sharedColors);
     useFormsColorManager(sharedColors);
     useTableColorManager(sharedColors);
     useInfolistsColorManager(sharedColors);
-    // HTML affiché tel quel par une entrée d'infolist : repassé par le schéma de l'éditeur de texte enrichi, qui ne garde que ses balises.
+    // HTML rendered by an infolist entry is sanitized through the rich editor schema, which only keeps its own tags.
     useHtmlSanitizer((html) => richDocumentToHtml(richHtmlToDocument(html)) ?? '');
     views.share({ assetUrl: (file) => panel.assetUrl(file) });
     for (const plugin of panel.getPlugins())
         plugin.boot?.(panel);
     assertAuthCapabilities(panel);
-    // Locataires : les resources cloisonnées ne voient que les enregistrements du locataire de la requête.
+    // Tenancy: scoped resources only see the records of the request's tenant.
     const ownership = panel.getTenantOwnershipColumn();
     if (panel.hasTenancy() && ownership) {
         for (const resource of panel.getResources()) {
@@ -3192,16 +3237,16 @@ export function panelRouter(panel, runtime) {
                 continue;
             const adapter = resource.adapter;
             if (typeof adapter?.scopeToTenant !== 'function')
-                throw new Error(`Resource ${resource.name} : son adaptateur ne sait pas se cloisonner par locataire (scopeToTenant).`);
+                throw new Error(`Resource ${resource.name}: its adapter does not support tenant scoping (scopeToTenant).`);
             adapter.scopeToTenant(resource.tenantOwnershipColumn ?? ownership, () => { const tenant = panel.getTenant(); return tenant ? panel.getTenantUrlKey(tenant) : null; });
         }
     }
     const router = express.Router();
     const name = (suffix) => `navette.${panel.getId()}.${suffix}`;
     const livewire = panel.getLivewirePrefix();
-    // La boîte aux lettres des notifications est propre au navigateur : on la rattache à son jeton CSRF.
+    // The notifications mailbox is per browser: it is keyed by the CSRF token.
     const context = async (req, res) => ({ req, res, panel, user: await panel.user(req), mailbox: csrfToken(req, res), tenant: null });
-    /** Locataire désigné par une adresse du panel, si l'utilisateur en est membre. */
+    /** Tenant designated by a panel URL, if the user is a member. */
     const tenantFromPath = async (path, user) => {
         if (!panel.hasTenancy() || !user)
             return null;
@@ -3223,7 +3268,7 @@ export function panelRouter(panel, runtime) {
         const tenant = await provider.find(key);
         return tenant && (await provider.canAccess(user, tenant)) ? tenant : null;
     };
-    /** Accueil de l'utilisateur : la racine du panel, ou dans un panel à locataires celle de son premier locataire (sinon la création d'un locataire). */
+    /** User's home: the panel root or, in a multi-tenant panel, their first tenant's root (otherwise tenant registration). */
     const homeUrl = async (user) => {
         if (!panel.hasTenancy())
             return panel.getUrl();
@@ -3271,9 +3316,9 @@ export function panelRouter(panel, runtime) {
         for (const manager of resource.relations)
             runtime.register(name(`relation-managers.${resource.slug.replace(/\//g, '.')}.${manager.relationship}`), manager);
     router.use(express.static(dir('../dist/filament'), { maxAge: '1y' }));
-    // Fichiers propres à Navette (hors balisage et styles de Filament).
+    // Navette's own front-end files.
     router.use(express.static(dir('../dist/navette')));
-    // Le locataire d'une mise à jour est celui de la page qui l'envoie (adresse du snapshot, signé), si l'utilisateur en est membre.
+    // An update's tenant is the one of the page sending it (from the signed snapshot URL), if the user is a member.
     const wireContext = async (req, res) => {
         const ctx = await context(req, res);
         let path = '';
@@ -3286,7 +3331,7 @@ export function panelRouter(panel, runtime) {
         ctx.tenant = await tenantFromPath(path, ctx.user);
         return ctx;
     };
-    // Port du middleware PublishNotifications : les notifications envoyées pendant la requête partent dans un lot annoncé au navigateur.
+    // Notifications sent during the request go into a batch announced to the browser.
     router.use(wireRouter(runtime, livewire, wireContext, async (ctx, _req, res, handle) => {
         const { result, pending } = await runInRequest(ctx.mailbox, () => panel.withTheme(ctx.req, () => panel.withTenant(ctx.tenant ?? null, handle)));
         if (pending.length) {
@@ -3298,23 +3343,23 @@ export function panelRouter(panel, runtime) {
                 res.setHeader('X-Filament-Notifications-Redirect', 'true');
         }
         return result;
-        // Seul un utilisateur connecté peut envoyer des fichiers.
+        // Only a signed-in user can upload files.
     }, (ctx) => !!ctx.user));
-    // Tout le rendu d'une page se fait avec les couleurs du thème de la requête, et pour son locataire.
+    // A page renders entirely with the request theme's colors, for the request's tenant.
     const document = (req, res, ctx, options) => panel.withTheme(req, () => panel.withTenant(ctx.tenant ?? null, () => renderDocument(req, res, ctx, options)));
     const renderDocument = async (req, res, ctx, options) => {
         const request = { path: req.path, method: req.method, ctx };
         const mounted = await runtime.mountWithInstance(options.component, options.params ?? {}, request);
-        // Une page qui redirige dès son montage (déjà connecté, adresse déjà vérifiée…) : redirection HTTP.
+        // A page that redirects on mount (already logged in, email already verified…): HTTP redirect.
         const redirect = mounted.component._effects?.redirect;
         if (typeof redirect === 'string')
             return void res.redirect(redirect);
         const slot = mounted.html;
-        // Le titre du document vient de l'instance (il peut dépendre de l'enregistrement).
+        // The document title comes from the instance (it may depend on the record).
         const instanceTitle = mounted.component.getTitle?.();
         if (typeof instanceTitle === 'string')
             options.title = instanceTitle;
-        // Les emplacements de la mise en page portent les portées de la page affichée.
+        // Layout render hooks use the scopes of the displayed page.
         const renderHookScopes = mounted.component.getRenderHookScopes?.() ?? [];
         const hasNavigation = panel.hasNavigation();
         const body = options.layout === 'simple'
@@ -3336,7 +3381,7 @@ export function panelRouter(panel, runtime) {
             notifications: (await runtime.mount('navette.notifications', {}, request)).replace(/^<div /, '<div wire:key="lw-1-0-0" '),
         }));
     };
-    /** Erreurs d'accès d'une page : 404 et 403 en clair, le reste remonte. */
+    /** Page access errors: 404 and 403 are answered directly, anything else is rethrown. */
     const guarded = async (res, render) => {
         try {
             await render();
@@ -3349,7 +3394,7 @@ export function panelRouter(panel, runtime) {
             throw error;
         }
     };
-    /** Page simple réservée aux invités (connexion, inscription, mot de passe oublié). */
+    /** Guest-only simple page (login, registration, password reset). */
     const guestPage = (path, component, title, params = () => ({})) => {
         router.get(panel.getBaseUrl(path), async (req, res) => {
             const ctx = await context(req, res);
@@ -3358,7 +3403,7 @@ export function panelRouter(panel, runtime) {
             await guarded(res, () => document(req, res, ctx, { title, component, layout: 'simple', params: params(req) }));
         });
     };
-    /** Page simple d'un utilisateur connecté, hors locataire (profil, vérification, création d'un locataire). */
+    /** Simple page for a signed-in user, outside any tenant (profile, email verification, tenant registration). */
     const userPage = (path, component, title, layout = 'simple') => {
         router.get(panel.getBaseUrl(path), async (req, res) => {
             const ctx = await context(req, res);
@@ -3371,7 +3416,7 @@ export function panelRouter(panel, runtime) {
         guestPage('login', name('auth.login'), t('filament-panels::auth/pages/login.title'));
         router.post(panel.getLogoutUrl(), express.urlencoded({ extended: false }), (req, res) => {
             if (!verifyCsrf(req, req.body?._token))
-                return res.status(419).send('Jeton CSRF invalide.');
+                return res.status(419).send('Invalid CSRF token.');
             panel.logOut(res);
             res.redirect(panel.getLoginUrl());
         });
@@ -3384,7 +3429,7 @@ export function panelRouter(panel, runtime) {
     }
     if (VerificationPrompt) {
         userPage('email-verification/prompt', name('auth.email-verification.prompt'), t('filament-panels::auth/pages/email-verification/email-verification-prompt.title'));
-        // Lien reçu par e-mail : signé, limité dans le temps, et valable seulement pour l'utilisateur connecté qu'il désigne.
+        // Emailed link: signed, time-limited, and only valid for the signed-in user it designates.
         router.get(panel.getBaseUrl('email-verification/verify/:id/:hash'), async (req, res) => {
             const ctx = await context(req, res);
             if (!ctx.user)
@@ -3401,7 +3446,7 @@ export function panelRouter(panel, runtime) {
         userPage(profile.page.slug, name('auth.profile'), profile.page.getLabel(), profile.isSimple || panel.hasTenancy() ? 'simple' : 'index');
     if (TenantRegistration)
         userPage(TenantRegistration.slug, name('tenancy.registration'), TenantRegistration.getLabel());
-    /** Contexte d'une page protégée : connexion, vérification de l'adresse, locataire. Rend null après avoir répondu. */
+    /** Context of a protected page: login, email verification, tenant. Returns `null` after responding. */
     const pageContext = async (req, res) => {
         const ctx = await context(req, res);
         if (!ctx.user) {
@@ -3423,7 +3468,7 @@ export function panelRouter(panel, runtime) {
     };
     const tenantSegment = panel.hasTenancy() ? ':tenant/' : '';
     if (panel.hasTenancy()) {
-        // Racine du panel : le premier locataire de l'utilisateur, sinon la création d'un locataire.
+        // Panel root: the user's first tenant, otherwise tenant registration.
         router.get(panel.getBaseUrl(), async (req, res) => {
             const ctx = await context(req, res);
             if (!ctx.user)
@@ -3435,7 +3480,7 @@ export function panelRouter(panel, runtime) {
                 return void res.status(404).send('Not Found');
             res.redirect(url);
         });
-        // Racine d'un locataire sans tableau de bord : la première page du menu (comme Filament).
+        // Tenant root without a dashboard: the first menu page.
         if (!panel.getPages().some((page) => page.slug === '')) {
             router.get(panel.getBaseUrl(':tenant'), async (req, res, next) => {
                 if (RESERVED_SEGMENTS.has(req.params.tenant) || req.params.tenant === TenantRegistration?.slug)
@@ -3453,7 +3498,7 @@ export function panelRouter(panel, runtime) {
     for (const PageClass of panel.getPages()) {
         const component = name(`pages.${(PageClass.slug || 'dashboard').replace(/[{}]/g, '')}`);
         runtime.register(component, PageClass);
-        // `{record}` dans le slug devient un paramètre de route, passé à mount().
+        // `{record}` in the slug becomes a route parameter, passed to mount().
         router.get(panel.getBaseUrl(tenantSegment + PageClass.slug).replace(/\{(\w+)\}/g, ':$1'), async (req, res, next) => {
             if (panel.hasTenancy() && (RESERVED_SEGMENTS.has(req.params.tenant) || req.params.tenant === TenantRegistration?.slug))
                 return next();
@@ -3466,7 +3511,7 @@ export function panelRouter(panel, runtime) {
     }
     return router;
 }
-/** Une option d'authentification exige certaines méthodes du fournisseur d'utilisateurs : on le dit au démarrage plutôt qu'au premier clic. */
+/** Each auth feature requires some auth provider methods: fail at startup rather than on first click. */
 function assertAuthCapabilities(panel) {
     if (!panel.hasRegistration() && !panel.hasPasswordReset() && !panel.hasEmailVerification() && !panel.hasProfile())
         return;
@@ -3474,14 +3519,14 @@ function assertAuthCapabilities(panel) {
     const missing = (feature, methods) => {
         const absent = methods.filter((method) => typeof auth[method] !== 'function');
         if (absent.length)
-            throw new Error(`${feature} : le fournisseur d'utilisateurs doit définir ${absent.join(', ')} (knexAuthProvider le fait).`);
+            throw new Error(`${feature}: the auth provider must implement ${absent.join(', ')} (knexAuthProvider does).`);
     };
     if (panel.hasRegistration())
-        missing('Inscription', ['create', 'findByEmail']);
+        missing('Registration', ['create', 'findByEmail']);
     if (panel.hasPasswordReset())
-        missing('Mot de passe oublié', ['findByEmail', 'update', 'getPasswordFingerprint']);
+        missing('Password reset', ['findByEmail', 'update', 'getPasswordFingerprint']);
     if (panel.hasEmailVerification())
-        missing('Vérification de l\'adresse', ['hasVerifiedEmail', 'markEmailAsVerified']);
+        missing('Email verification', ['hasVerifiedEmail', 'markEmailAsVerified']);
     if (panel.hasProfile())
-        missing('Profil', ['update']);
+        missing('Profile', ['update']);
 }