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

package/README.md

@@ -2,7 +2,7 @@
 
 Server-side runtime compatible with Livewire 3 for Node.js and Express.
 
-Part of [Navette](https://github.com/NavetteJS/navette), a Node.js port of [Filament](https://filamentphp.com). Install the whole framework with `npm install @navette-js/panels`.
+Part of [Navette](https://github.com/NavetteJS/navette), admin panels for Node.js. Start a project with `npm create navette@latest`, or install the framework with `npm install @navette-js/panels`.
 
 **Beta:** the API may still change between beta releases.
 

package/THIRD-PARTY-NOTICES.md

@@ -1,10 +1,10 @@
 # Third-party notices
 
-Navette is an independent Node.js port of Filament. It is not affiliated with or endorsed by the Filament, Livewire or Heroicons projects. It reuses the following works, each under its own license; the full license texts ship next to the files they cover.
+Navette is an independent project, not affiliated with or endorsed by the Filament, Livewire or Heroicons projects. It reuses the following works, each under its own license; the full license texts ship next to the files they cover.
 
 | Work | Used for | License | License file |
 |---|---|---|---|
-| [Filament](https://github.com/filamentphp/filament) © Filament | HTML markup ported from its Blade views, compiled CSS and JavaScript (`@navette-js/panels/dist/filament`), English translations (`@navette-js/support/data`) | MIT | `packages/panels/dist/FILAMENT-LICENSE.md` |
+| [Filament](https://github.com/filamentphp/filament) © Filament | HTML markup derived from its Blade views, compiled CSS and JavaScript (`@navette-js/panels/dist/filament`), English translations (`@navette-js/support/data`) | MIT | `packages/panels/dist/FILAMENT-LICENSE.md` |
 | [Livewire](https://github.com/livewire/livewire) © Caleb Porzio | Client script `livewire.js` (`@navette-js/wire/vendor`); the server runtime follows its protocol | MIT | `packages/wire/vendor/LIVEWIRE-LICENSE.md` |
 | [Heroicons](https://github.com/tailwindlabs/heroicons) | SVG icons (`@navette-js/support/icons`) | MIT | `packages/support/icons/HEROICONS-LICENSE.md` |
 | [Inter](https://github.com/rsms/inter) © The Inter Project Authors | Default font files (`@navette-js/panels/dist/filament/fonts`) | SIL Open Font License 1.1 | `packages/panels/dist/filament/fonts/INTER-LICENSE.txt` |

package/lib/express.d.ts

@@ -1,15 +1,15 @@
 import type { Request, Response, Router } from 'express';
 import { type WireRuntime } from './index.ts';
-/** Jeton CSRF par double soumission : cookie HttpOnly + jeton renvoyé dans le corps par livewire.js (`_token`). */
+/** Double-submit CSRF token: an HttpOnly cookie, plus the token livewire.js sends back in the body (`_token`). */
 export declare function csrfToken(req: Request, res: Response): string;
-/** Vérifie le jeton envoyé (corps ou formulaire) contre le cookie, en temps constant. */
+/** Checks the submitted token (body or form field) against the cookie, in constant time. */
 export declare function verifyCsrf(req: Request, token: unknown): boolean;
 export declare function wireRouter(runtime: WireRuntime, prefix?: string, makeContext?: (req: Request, res: Response) => unknown | Promise<unknown>, 
-/** Exécute le traitement dans un contexte de requête et permet d'enrichir la réponse (notifications…). */
+/** Wraps the handling in a request context and can enrich the response (notifications…). */
 around?: (ctx: any, req: Request, res: Response, handle: () => Promise<any>) => Promise<any>, 
-/** Autorise un envoi de fichier (par exemple : utilisateur connecté). Sans cette fonction, tout porteur d'une adresse signée et du jeton CSRF peut envoyer. */
+/** Authorizes a file upload (e.g. signed-in user). Without it, anyone holding a signed URL and the CSRF token can upload. */
 canUpload?: (ctx: any) => boolean | Promise<boolean>): Router;
-/** Balise <script> attendue par livewire.js (équivalent de FrontendAssets::js). */
+/** `<script>` tag that loads livewire.js with its CSRF token and endpoint URLs. */
 export declare function wireScripts(req: Request, res: Response, prefix?: string): string;
-/** Styles attendus par livewire.js (équivalent de FrontendAssets::styles) : à placer dans <head>. */
+/** Styles livewire.js expects (loading states, cloak, progress bar); place them in `<head>`. */
 export declare function wireStyles(progressBarColor?: string): string;

package/lib/express.js

@@ -1,4 +1,4 @@
-// Intégration Express du runtime : sert livewire.js embarqué, expose l'endpoint de mise à jour, protège par jeton CSRF.
+// Express integration: serves the bundled livewire.js and exposes the CSRF-protected update and upload endpoints.
 import { randomBytes, timingSafeEqual } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
@@ -8,7 +8,7 @@ const vendor = (f) => fileURLToPath(new URL(`../vendor/${f}`, import.meta.url));
 const versionHash = JSON.parse(readFileSync(vendor('manifest.json'), 'utf8'))['/livewire.js'];
 const COOKIE = 'navette_csrf';
 const readCookie = (req, name) => (req.headers.cookie ?? '').split(';').map((c) => c.trim().split('=')).find(([k]) => k === name)?.[1];
-/** Jeton CSRF par double soumission : cookie HttpOnly + jeton renvoyé dans le corps par livewire.js (`_token`). */
+/** Double-submit CSRF token: an HttpOnly cookie, plus the token livewire.js sends back in the body (`_token`). */
 export function csrfToken(req, res) {
     let token = readCookie(req, COOKIE) ?? res.locals.navetteCsrf;
     if (!token) {
@@ -18,15 +18,15 @@ export function csrfToken(req, res) {
     }
     return token;
 }
-/** Vérifie le jeton envoyé (corps ou formulaire) contre le cookie, en temps constant. */
+/** Checks the submitted token (body or form field) against the cookie, in constant time. */
 export function verifyCsrf(req, token) {
     const cookie = Buffer.from(readCookie(req, COOKIE) ?? ''), sent = Buffer.from(String(token ?? ''));
     return cookie.length > 0 && cookie.length === sent.length && timingSafeEqual(cookie, sent);
 }
 export function wireRouter(runtime, prefix = '/livewire', makeContext = (req, res) => ({ req, res }), 
-/** Exécute le traitement dans un contexte de requête et permet d'enrichir la réponse (notifications…). */
+/** Wraps the handling in a request context and can enrich the response (notifications…). */
 around = (_ctx, _req, _res, handle) => handle(), 
-/** Autorise un envoi de fichier (par exemple : utilisateur connecté). Sans cette fonction, tout porteur d'une adresse signée et du jeton CSRF peut envoyer. */
+/** Authorizes a file upload (e.g. signed-in user). Without it, anyone holding a signed URL and the CSRF token can upload. */
 canUpload = () => true) {
     const router = express.Router();
     router.get(`${prefix}/livewire.js`, (_req, res) => {
@@ -35,7 +35,7 @@ canUpload = () => true) {
     router.post(`${prefix}/update`, express.json({ limit: '2mb' }), async (req, res) => {
         try {
             if (!verifyCsrf(req, req.body?._token))
-                throw new WireError(419, 'Jeton CSRF invalide.');
+                throw new WireError(419, 'Invalid CSRF token.');
             const ctx = await makeContext(req, res);
             res.json(await around(ctx, req, res, () => runtime.handle(req.body, ctx)));
         }
@@ -45,39 +45,39 @@ canUpload = () => true) {
                 console.error(e);
             else if (process.env.NODE_ENV !== 'production')
                 console.warn(`[wire] ${status} ${e.message} — calls=${JSON.stringify(req.body?.components?.map((c) => c.calls))} updates=${JSON.stringify(req.body?.components?.map((c) => c.updates))}`);
-            res.status(status).send(e instanceof Error ? e.message : 'Erreur');
+            res.status(status).send(e instanceof Error ? e.message : 'Error');
         }
     });
-    // Envoi de fichiers : adresse signée par `_startUpload`, jeton CSRF en en-tête, fichiers reçus dans le dossier temporaire.
+    // File uploads: URL signed by `_startUpload`, CSRF token in a header, files stored in the temporary directory.
     router.post(`${prefix}/upload-file`, async (req, res) => {
         try {
             const store = runtime.uploads;
             if (!store)
-                throw new WireError(404, 'Téléversement indisponible.');
+                throw new WireError(404, 'Uploads are not available.');
             if (!store.verifySignature(req.query.expires, req.query.signature))
-                throw new WireError(401, 'Adresse d\'envoi invalide ou expirée.');
+                throw new WireError(401, 'Invalid or expired upload URL.');
             if (!verifyCsrf(req, req.get('x-csrf-token')))
-                throw new WireError(419, 'Jeton CSRF invalide.');
+                throw new WireError(419, 'Invalid CSRF token.');
             if (!(await canUpload(await makeContext(req, res))))
-                throw new WireError(401, 'Non authentifié.');
+                throw new WireError(401, 'Unauthenticated.');
             res.json({ paths: await store.receive(req) });
         }
         catch (e) {
             const status = e instanceof WireError ? e.status : Number(e?.status) || 500;
             if (status === 500)
                 console.error(e);
-            res.status(status).json({ message: e instanceof Error ? e.message : 'Erreur' });
+            res.status(status).json({ message: e instanceof Error ? e.message : 'Error' });
         }
     });
     return router;
 }
-/** Balise <script> attendue par livewire.js (équivalent de FrontendAssets::js). */
+/** `<script>` tag that loads livewire.js with its CSRF token and endpoint URLs. */
 export function wireScripts(req, res, prefix = '/livewire') {
     return `<script src="${prefix}/livewire.js?id=${versionHash}" data-csrf="${csrfToken(req, res)}" data-module-url="${prefix}" data-update-uri="${prefix}/update" data-navigate-once="true"></script>`;
 }
-/** Styles attendus par livewire.js (équivalent de FrontendAssets::styles) : à placer dans <head>. */
+/** Styles livewire.js expects (loading states, cloak, progress bar); place them in `<head>`. */
 export function wireStyles(progressBarColor = '#2299dd') {
-    const BS = String.fromCharCode(92); // barre oblique inverse : échappe « : » et « . » dans les sélecteurs CSS
+    const BS = String.fromCharCode(92); // backslash: escapes `:` and `.` in CSS selectors
     const sel = (n) => `[wire${BS}:${n.replaceAll('.', BS + '.')}]`;
     const doubled = (names) => names.map((n) => sel(n) + sel(n)).join(', ');
     return '<!-- Livewire Styles --><style>'

package/lib/index.d.ts

@@ -35,65 +35,65 @@ export declare class WireError extends Error {
     status: number;
     constructor(status: number, message: string);
 }
-/** Classe de base d'un composant. Toute propriété propre énumérable ne commençant pas par `_` est de l'état public. */
+/** Base class of a component. Every own enumerable property not starting with `_` is public state. */
 export declare abstract class Component {
     _id: string;
     _effects: Effects;
     _skipRender: boolean;
     _errors: Record<string, string[]>;
-    /** Contexte de la requête HTTP en cours (requête, réponse, panel…), fourni par l'intégration. */
+    /** Context of the current HTTP request (request, response, panel…), supplied by the integration. */
     _ctx: any;
-    /** Runtime et requête d'origine : servent à monter des composants enfants pendant le rendu. */
+    /** Runtime and originating request, used to mount child components while rendering. */
     _runtime: WireRuntime | null;
     _request: {
         path?: string;
         method?: string;
     };
-    /** Enfants rendus pendant cette requête, et enfants déjà présents dans le navigateur : clé → [balise, identifiant]. */
+    /** Children rendered during this request, and children already in the browser: key → [tag, id]. */
     _children: Record<string, [string, string]>;
     _previousChildren: Record<string, [string, string]>;
-    /** HTML affiché tant qu'un composant « lazy » n'est pas chargé : une seule racine. */
+    /** HTML shown until a lazy component is loaded; must have a single root. */
     placeholder(): string | Promise<string>;
     /**
-     * Monte un composant enfant et rend son HTML, à insérer dans le rendu du parent (équivalent de `@livewire`).
-     * Si le navigateur possède déjà cet enfant (même clé), seule une souche est rendue : le client conserve l'enfant tel quel.
-     * `lazy` : l'enfant affiche son `placeholder()` et se charge quand il devient visible.
+     * Mounts a child component and returns its HTML, to insert into the parent's render.
+     * If the browser already has this child (same key), only a stub is rendered and the client keeps the child as is.
+     * `lazy`: the child shows its `placeholder()` and loads once it becomes visible.
      */
     mountChild(name: string, params: Record<string, unknown>, key: string, options?: {
         lazy?: boolean;
     }): Promise<string>;
-    /** Rend le HTML du composant : une seule racine. */
+    /** Renders the component's HTML; must have a single root element. */
     abstract render(): string | Promise<string>;
     mount(_params: Record<string, unknown>): void | Promise<void>;
     boot(): void | Promise<void>;
     hydrate(): void | Promise<void>;
     dehydrate(): void | Promise<void>;
     get id(): string;
-    /** `self` : l'événement n'est reçu que par ce composant (équivalent de `->self()`). */
+    /** Dispatches a browser event; with `self`, only this component receives it. */
     dispatch(name: string, params?: Record<string, unknown> | unknown[], options?: {
         self?: boolean;
     }): void;
     redirect(url: string, navigate?: boolean): void;
     skipRender(): void;
-    /** Rendu partiel à la Filament : seul le fragment `wire:partial="<nom>"` est renvoyé (effects.partials), sans re-rendre tout le composant. */
+    /** Partial render: only the `wire:partial="<name>"` fragment is sent back (effects.partials), the component is not re-rendered. */
     renderPartial(name: string, html: string): void;
     addError(path: string, message: string): void;
     resetErrorBag(): void;
 }
 /**
- * Méthodes appelables depuis le navigateur : uniquement celles que la classe (ou une classe parente) nomme dans `static callable`.
- * TypeScript efface `protected` et `private` à l'exécution : sans cette liste, toute méthode interne serait appelable par une
- * requête forgée, et sa valeur de retour renvoyée au navigateur.
+ * Methods callable from the browser: only those the class (or a parent class) lists in `static callable`.
+ * TypeScript erases `protected` and `private` at runtime: without this allowlist, any internal method could be called by a
+ * forged request and its return value sent back to the browser.
  */
 export declare function callableMethods(component: Component): Set<string>;
 export declare function publicProperties(component: Component): string[];
 export declare function dehydrateValue(value: unknown): unknown;
 export declare function hydrateValue(value: unknown): unknown;
-/** Équivalent de Utils::insertAttributesIntoHtmlRoot : pose des attributs sur la balise racine. */
+/** Adds attributes to the root element of an HTML fragment. */
 export declare function insertAttributesIntoHtmlRoot(html: string, attributes: Record<string, unknown>): string;
 export type RuntimeOptions = {
     key: string;
-    locale?: string; /** Dossier des téléversements temporaires ; sans lui, les envois de fichiers sont refusés. */
+    locale?: string; /** Temporary upload store; without it, file uploads are refused. */
     uploads?: UploadStore;
     uploadPrefix?: string;
 };
@@ -102,27 +102,32 @@ export declare class WireRuntime {
     private options;
     constructor(options: RuntimeOptions);
     get uploads(): UploadStore | null;
-    /** Paramètres passés par un parent à ses enfants déjà présents, pendant la requête en cours : identifiant de l'enfant → paramètres. */
+    /** Params passed by a parent to its existing children during the current request: child id → params. */
     private requestScope;
     passPropsToChild(childId: string, params: Record<string, unknown>): void;
+    private names;
     register(name: string, cls: ComponentClass): this;
+    /** Name under which this runtime registered a class. A class shared by several runtimes (one per panel) keeps one name per runtime. */
+    nameOf(cls: ComponentClass): string;
     private make;
     checksum(snapshot: Omit<Snapshot, 'checksum'>): string;
     private snapshot;
-    /** Paramètres de montage d'un composant « lazy », signés : le navigateur les renvoie tels quels à `__lazyLoad` (conteneur `__mountParamsContainer` de Livewire). */
+    /** Signed mount params of a lazy component, in a `__mountParamsContainer`: the browser sends them back unchanged to `__lazyLoad`. */
     private encodeMountParams;
     private decodeMountParams;
-    /** Comme Livewire : un paramètre de montage du même nom qu'une propriété publique y est copié. */
+    /** A mount param named like a public property is copied into it. */
     private assignMatchingProperties;
     private renderRoot;
-    /** Premier rendu : HTML avec wire:snapshot et wire:effects sur la racine.
-     *  Le mémo ne porte `lazyLoaded` / `lazyIsolated` que pour un composant réellement « lazy » : leur seule présence fait ignorer les événements au client. */
+    /**
+     * Initial render: HTML with wire:snapshot and wire:effects on the root.
+     * The memo only carries `lazyLoaded` / `lazyIsolated` for lazy components: their mere presence makes the client ignore events.
+     */
     mount(name: string, params?: Record<string, unknown>, request?: {
         path?: string;
         method?: string;
         ctx?: unknown;
     }): Promise<string>;
-    /** Comme mount(), mais rend aussi l'instance montée (pour lire son titre, par exemple). */
+    /** Like mount(), but also returns the mounted instance (to read its title, for example). */
     mountWithInstance(name: string, params?: Record<string, unknown>, request?: {
         path?: string;
         method?: string;
@@ -133,12 +138,12 @@ export declare class WireRuntime {
         html: string;
         component: Component;
     }>;
-    /** Requête de mise à jour d'un composant : hydratation, mises à jour, appels, rendu, déshydratation. */
+    /** Component update request: hydrate, apply updates, run calls, render, dehydrate. */
     update(snapshot: Snapshot, updates: Record<string, unknown>, calls: Call[], ctx?: unknown): Promise<{
         snapshot: Snapshot;
         effects: Effects;
     }>;
-    /** Point d'entrée HTTP : corps `{ _token, components: [{ snapshot, updates, calls }] }`. */
+    /** HTTP entry point; body: `{ _token, components: [{ snapshot, updates, calls }] }`. */
     handle(body: any, ctx?: unknown): Promise<{
         components: {
             snapshot: string;

package/lib/index.js

@@ -1,5 +1,4 @@
-// @navette-js/wire — runtime serveur de composants à état, compatible avec le protocole du client livewire.js 4.4.8.
-// Prototype du jalon 0 (ADR 0001). Référence : sources/demo/vendor/livewire/livewire/src/Mechanisms/HandleComponents.
+// @navette-js/wire — server runtime for stateful components, speaking the Livewire client protocol (livewire.js 4.4.8).
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
 import { UploadStore } from "./uploads.js";
@@ -8,34 +7,34 @@ export class WireError extends Error {
     status;
     constructor(status, message) { super(message); this.status = status; }
 }
-/** Classe de base d'un composant. Toute propriété propre énumérable ne commençant pas par `_` est de l'état public. */
+/** Base class of a component. Every own enumerable property not starting with `_` is public state. */
 export class Component {
     _id = '';
     _effects = {};
     _skipRender = false;
     _errors = {};
-    /** Contexte de la requête HTTP en cours (requête, réponse, panel…), fourni par l'intégration. */
+    /** Context of the current HTTP request (request, response, panel…), supplied by the integration. */
     _ctx = null;
-    /** Runtime et requête d'origine : servent à monter des composants enfants pendant le rendu. */
+    /** Runtime and originating request, used to mount child components while rendering. */
     _runtime = null;
     _request = {};
-    /** Enfants rendus pendant cette requête, et enfants déjà présents dans le navigateur : clé → [balise, identifiant]. */
+    /** Children rendered during this request, and children already in the browser: key → [tag, id]. */
     _children = {};
     _previousChildren = {};
-    /** HTML affiché tant qu'un composant « lazy » n'est pas chargé : une seule racine. */
+    /** HTML shown until a lazy component is loaded; must have a single root. */
     placeholder() { return '<div></div>'; }
     /**
-     * Monte un composant enfant et rend son HTML, à insérer dans le rendu du parent (équivalent de `@livewire`).
-     * Si le navigateur possède déjà cet enfant (même clé), seule une souche est rendue : le client conserve l'enfant tel quel.
-     * `lazy` : l'enfant affiche son `placeholder()` et se charge quand il devient visible.
+     * Mounts a child component and returns its HTML, to insert into the parent's render.
+     * If the browser already has this child (same key), only a stub is rendered and the client keeps the child as is.
+     * `lazy`: the child shows its `placeholder()` and loads once it becomes visible.
      */
     async mountChild(name, params = {}, key, options = {}) {
         if (!this._runtime)
-            throw new Error('mountChild() : composant hors runtime.');
+            throw new Error('mountChild(): component is not attached to a runtime.');
         const previous = this._previousChildren[key];
         if (previous) {
             this._children[key] = previous;
-            // Propriétés réactives : l'enfant, mis à jour dans la même requête, reprendra ces valeurs (équivalent de #[Reactive]).
+            // Reactive props: the child, updated later in the same request, picks these values up.
             this._runtime.passPropsToChild(previous[1], params);
             return `<${previous[0]} wire:id="${previous[1]}" wire:name="${escapeAttr(name)}" wire:key="${escapeAttr(key)}"></${previous[0]}>`;
         }
@@ -48,7 +47,7 @@ export class Component {
     hydrate() { }
     dehydrate() { }
     get id() { return this._id; }
-    /** `self` : l'événement n'est reçu que par ce composant (équivalent de `->self()`). */
+    /** Dispatches a browser event; with `self`, only this component receives it. */
     dispatch(name, params = {}, options = {}) {
         (this._effects.dispatches ??= []).push({ name, params: params, ...(options.self ? { self: true } : {}) });
     }
@@ -58,18 +57,18 @@ export class Component {
             this._effects.redirectUsingNavigate = true;
     }
     skipRender() { this._skipRender = true; }
-    /** Rendu partiel à la Filament : seul le fragment `wire:partial="<nom>"` est renvoyé (effects.partials), sans re-rendre tout le composant. */
+    /** Partial render: only the `wire:partial="<name>"` fragment is sent back (effects.partials), the component is not re-rendered. */
     renderPartial(name, html) { (this._effects.partials ??= {})[name] = html; this._skipRender = true; }
     addError(path, message) { (this._errors[path] ??= []).push(message); }
     resetErrorBag() { this._errors = {}; }
 }
 const LIFECYCLE = new Set(['constructor', 'render', 'mount', 'boot', 'hydrate', 'dehydrate', 'dispatch', 'redirect', 'skipRender', 'renderPartial', 'addError', 'resetErrorBag', 'mountChild', 'placeholder']);
-// Seuls les hooks de propriété (updatingFoo / updatedFoo) sont réservés par préfixe : `mountAction`, par exemple, est une méthode publique ordinaire.
+// Only property hooks (updatingFoo / updatedFoo) are reserved by prefix: `mountAction`, for example, is an ordinary public method.
 const isLifecycleHook = (m) => LIFECYCLE.has(m) || /^(updating|updated)[A-Z]/.test(m) || m.startsWith('_');
 /**
- * Méthodes appelables depuis le navigateur : uniquement celles que la classe (ou une classe parente) nomme dans `static callable`.
- * TypeScript efface `protected` et `private` à l'exécution : sans cette liste, toute méthode interne serait appelable par une
- * requête forgée, et sa valeur de retour renvoyée au navigateur.
+ * Methods callable from the browser: only those the class (or a parent class) lists in `static callable`.
+ * TypeScript erases `protected` and `private` at runtime: without this allowlist, any internal method could be called by a
+ * forged request and its return value sent back to the browser.
  */
 export function callableMethods(component) {
     const out = new Set();
@@ -85,7 +84,7 @@ export function callableMethods(component) {
 export function publicProperties(component) {
     return Object.keys(component).filter((k) => !k.startsWith('_'));
 }
-// --- Synthétiseurs : les tableaux et objets voyagent sous la forme [valeur, { s: 'arr' }] (HandleSynths de Livewire).
+// Wire format: arrays and objects travel as [value, { s: 'arr' }] tuples.
 export function dehydrateValue(value) {
     if (value === undefined)
         return null;
@@ -105,11 +104,11 @@ export function hydrateValue(value) {
     return value;
 }
 const escapeAttr = (s) => s.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/'/g, '&#039;');
-/** Équivalent de Utils::insertAttributesIntoHtmlRoot : pose des attributs sur la balise racine. */
+/** Adds attributes to the root element of an HTML fragment. */
 export function insertAttributesIntoHtmlRoot(html, attributes) {
     const m = /^\s*<([a-zA-Z0-9-]+)/.exec(html);
     if (!m)
-        throw new WireError(500, 'Le rendu d\'un composant doit commencer par une balise racine.');
+        throw new WireError(500, 'A component render must start with a root element.');
     const attrs = Object.entries(attributes)
         .map(([k, v]) => `${k}="${escapeAttr(typeof v === 'string' ? v : JSON.stringify(v))}"`)
         .join(' ');
@@ -131,11 +130,11 @@ function setByPath(target, segments, value) {
     else
         node[last] = value;
 }
-/** Identifiant alphanumérique de 20 caractères, comme Str::random(20) de Livewire (il sert dans des id HTML et des sélecteurs). */
+/** 20-character alphanumeric id (used in HTML ids and CSS selectors, so no symbols). */
 const randomId = () => Array.from(randomBytes(20), (b) => 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'[b % 62]).join('');
 const MAGIC_ACTIONS = new Set(['$refresh', '$set', '$sync', '$commit']);
 const studly = (s) => s.replace(/(^|[_.-])(\w)/g, (_, __, c) => c.toUpperCase());
-/** Faux si la valeur contient, à n'importe quelle profondeur, une référence de fichier temporaire qui ne désigne aucun fichier reçu. */
+/** False if the value contains, at any depth, a temporary file reference that does not point to a received file. */
 function uploadReferencesAreValid(value, store, depth = 0) {
     if (typeof value === 'string')
         return value.startsWith('livewire-files:') ? false : value.startsWith('livewire-file:') ? !!store?.resolve(value) : true;
@@ -145,25 +144,29 @@ function uploadReferencesAreValid(value, store, depth = 0) {
         return false;
     return Object.values(value).every((v) => uploadReferencesAreValid(v, store, depth + 1));
 }
-/** Propriétés réactives d'un composant (`static reactive`) : fixées par le parent, jamais par le navigateur. */
+/** Reactive props of a component (`static reactive`): set by the parent, never by the browser. */
 const reactiveProps = (component) => component.constructor.reactive ?? [];
 export class WireRuntime {
     registry = new Map();
     options;
     constructor(options) { this.options = options; }
     get uploads() { return this.options.uploads ?? null; }
-    /** Paramètres passés par un parent à ses enfants déjà présents, pendant la requête en cours : identifiant de l'enfant → paramètres. */
+    /** Params passed by a parent to its existing children during the current request: child id → params. */
     requestScope = new AsyncLocalStorage();
     passPropsToChild(childId, params) { this.requestScope.getStore()?.childProps.set(childId, params); }
-    register(name, cls) { this.registry.set(name, cls); cls.componentName = name; return this; }
+    names = new Map();
+    register(name, cls) { this.registry.set(name, cls); if (!this.names.has(cls))
+        this.names.set(cls, name); cls.componentName = name; return this; }
+    /** Name under which this runtime registered a class. A class shared by several runtimes (one per panel) keeps one name per runtime. */
+    nameOf(cls) { return this.names.get(cls) ?? cls.componentName ?? ''; }
     make(name) {
         const cls = this.registry.get(name);
         if (!cls)
-            throw new WireError(404, `Composant inconnu : ${name}`);
+            throw new WireError(404, `Unknown component: ${name}`);
         return new cls();
     }
     checksum(snapshot) {
-        const { children: _children, ...memo } = snapshot.memo; // les enfants peuvent être modifiés par le client
+        const { children: _children, ...memo } = snapshot.memo; // the client may rewrite `children`, so it is not signed
         return createHmac('sha256', this.options.key).update(JSON.stringify({ data: snapshot.data, memo })).digest('hex');
     }
     snapshot(component, name, memo) {
@@ -173,7 +176,7 @@ export class WireRuntime {
         const body = { data, memo: { id: component.id, name, ...memo, errors: component._errors } };
         return { ...body, checksum: this.checksum(body) };
     }
-    /** Paramètres de montage d'un composant « lazy », signés : le navigateur les renvoie tels quels à `__lazyLoad` (conteneur `__mountParamsContainer` de Livewire). */
+    /** Signed mount params of a lazy component, in a `__mountParamsContainer`: the browser sends them back unchanged to `__lazyLoad`. */
     encodeMountParams(name, params, request) {
         const body = { data: { forMount: dehydrateValue(params), forComponent: name }, memo: { id: randomId(), name: '__mountParamsContainer', path: request.path ?? '/', method: request.method ?? 'GET', release: 'a-a-a' } };
         return Buffer.from(JSON.stringify({ ...body, checksum: this.checksum(body) })).toString('base64');
@@ -184,19 +187,19 @@ export class WireRuntime {
             container = JSON.parse(Buffer.from(String(encoded), 'base64').toString('utf8'));
         }
         catch {
-            throw new WireError(404, 'Paramètres de montage illisibles.');
+            throw new WireError(404, 'Unreadable mount params.');
         }
         if (!container || typeof container.data !== 'object' || typeof container.memo !== 'object' || typeof container.checksum !== 'string')
-            throw new WireError(404, 'Paramètres de montage invalides.');
+            throw new WireError(404, 'Invalid mount params.');
         const expected = Buffer.from(this.checksum(container)), given = Buffer.from(container.checksum);
         if (expected.length !== given.length || !timingSafeEqual(expected, given))
-            throw new WireError(419, 'Somme de contrôle des paramètres de montage invalide.');
-        // Les paramètres signés pour un composant ne valent pas pour un autre.
+            throw new WireError(419, 'Invalid mount params checksum.');
+        // Params signed for one component are not valid for another.
         if (container.memo.name !== '__mountParamsContainer' || container.data.forComponent !== name)
-            throw new WireError(403, 'Paramètres de montage destinés à un autre composant.');
+            throw new WireError(403, 'Mount params were issued for another component.');
         return (hydrateValue(container.data.forMount) ?? {});
     }
-    /** Comme Livewire : un paramètre de montage du même nom qu'une propriété publique y est copié. */
+    /** A mount param named like a public property is copied into it. */
     assignMatchingProperties(component, params) {
         const known = new Set(publicProperties(component));
         for (const [k, v] of Object.entries(params))
@@ -207,16 +210,17 @@ export class WireRuntime {
         const html = await component.render();
         return insertAttributesIntoHtmlRoot(html, { 'wire:id': component.id, 'wire:name': name });
     }
-    /** Premier rendu : HTML avec wire:snapshot et wire:effects sur la racine.
-     *  Le mémo ne porte `lazyLoaded` / `lazyIsolated` que pour un composant réellement « lazy » : leur seule présence fait ignorer les événements au client. */
+    /**
+     * Initial render: HTML with wire:snapshot and wire:effects on the root.
+     * The memo only carries `lazyLoaded` / `lazyIsolated` for lazy components: their mere presence makes the client ignore events.
+     */
     async mount(name, params = {}, request = {}) {
         return (await this.mountWithInstance(name, params, request)).html;
     }
-    /** Comme mount(), mais rend aussi l'instance montée (pour lire son titre, par exemple). */
+    /** Like mount(), but also returns the mounted instance (to read its title, for example). */
     async mountWithInstance(name, params = {}, request = {}) {
         const component = this.make(name);
         component._ctx = request.ctx ?? null;
-        // Identifiant alphanumérique de 20 caractères, comme Str::random(20) de Livewire (il sert dans des id HTML et des sélecteurs).
         component._id = randomId();
         component._runtime = this;
         component._request = { path: request.path, method: request.method };
@@ -224,7 +228,7 @@ export class WireRuntime {
         this.assignMatchingProperties(component, params);
         let html;
         if (request.lazy) {
-            // Composant « lazy » : `mount()` et le rendu attendent l'appel `__lazyLoad` du navigateur.
+            // Lazy component: `mount()` and rendering wait for the browser's `__lazyLoad` call.
             const placeholder = insertAttributesIntoHtmlRoot(await component.placeholder(), { 'x-intersect': `$wire.__lazyLoad('${this.encodeMountParams(name, params, request)}')` });
             html = insertAttributesIntoHtmlRoot(placeholder, { 'wire:id': component.id, 'wire:name': name });
         }
@@ -238,19 +242,19 @@ export class WireRuntime {
             ...(request.lazy ? { lazyLoaded: false, lazyIsolated: true } : {}), ...(reactiveProps(component).length ? { props: reactiveProps(component) } : {}), locale: this.options.locale ?? 'en', islands: [],
         });
         const { html: _h, ...effects } = component._effects;
-        // Écouteurs d'événements (équivalent de #[On]) : le client appellera `__dispatch(événement, paramètres)`.
+        // Event listeners: the client calls `__dispatch(event, params)` when one fires.
         const listeners = Object.keys(component.constructor.listeners ?? {});
         if (listeners.length)
             effects.listeners = listeners;
         return { html: insertAttributesIntoHtmlRoot(html, { ...(request.key !== undefined ? { 'wire:key': request.key } : {}), 'wire:snapshot': JSON.stringify(snapshot), 'wire:effects': JSON.stringify(effects) }), component };
     }
-    /** Requête de mise à jour d'un composant : hydratation, mises à jour, appels, rendu, déshydratation. */
+    /** Component update request: hydrate, apply updates, run calls, render, dehydrate. */
     async update(snapshot, updates, calls, ctx = null) {
         if (!snapshot || typeof snapshot.data !== 'object' || typeof snapshot.memo !== 'object' || typeof snapshot.checksum !== 'string')
-            throw new WireError(404, 'Snapshot invalide.');
+            throw new WireError(404, 'Invalid snapshot.');
         const expected = Buffer.from(this.checksum(snapshot)), given = Buffer.from(snapshot.checksum);
         if (expected.length !== given.length || !timingSafeEqual(expected, given))
-            throw new WireError(419, 'Somme de contrôle du snapshot invalide.');
+            throw new WireError(419, 'Invalid snapshot checksum.');
         const name = snapshot.memo.name;
         const component = this.make(name);
         const cls = component.constructor;
@@ -259,7 +263,7 @@ export class WireRuntime {
         component._errors = { ...(snapshot.memo.errors ?? {}) };
         component._runtime = this;
         component._request = { path: snapshot.memo.path, method: snapshot.memo.method };
-        // `memo.children` n'est pas couvert par la somme de contrôle (le client le tient à jour) : seules les entrées bien formées sont retenues.
+        // `memo.children` is not covered by the checksum (the client maintains it): only well-formed entries are kept.
         if (snapshot.memo.children && typeof snapshot.memo.children === 'object' && !Array.isArray(snapshot.memo.children)) {
             for (const [key, value] of Object.entries(snapshot.memo.children)) {
                 if (Array.isArray(value) && /^[a-zA-Z][a-zA-Z0-9-]*$/.test(String(value[0])) && /^[A-Za-z0-9]{1,64}$/.test(String(value[1])))
@@ -272,7 +276,7 @@ export class WireRuntime {
         for (const [k, v] of Object.entries(snapshot.data))
             if (known.has(k))
                 component[k] = hydrateValue(v);
-        // Propriétés réactives : elles ne viennent que du parent, rendu plus tôt dans la même requête.
+        // Reactive props only come from the parent, rendered earlier in the same request.
         const reactive = new Set(reactiveProps(component));
         const passed = this.requestScope.getStore()?.childProps.get(component.id);
         if (passed)
@@ -285,14 +289,14 @@ export class WireRuntime {
             const segments = path.split('.');
             const prop = segments[0];
             if (!known.has(prop))
-                throw new WireError(404, `Propriété publique introuvable : ${prop}`);
+                throw new WireError(404, `Public property not found: ${prop}`);
             if (cls.locked?.includes(prop))
-                throw new WireError(403, `Propriété verrouillée : ${prop}`);
+                throw new WireError(403, `Locked property: ${prop}`);
             if (reactive.has(prop))
-                throw new WireError(403, `Propriété réactive, fixée par le composant parent : ${prop}`);
-            // Un segment comme `__proto__` écrirait dans le prototype partagé par tous les objets du serveur.
+                throw new WireError(403, `Reactive property, set by the parent component: ${prop}`);
+            // A segment such as `__proto__` would write into the prototype shared by every object on the server.
             if (segments.some((segment) => segment === '__proto__' || segment === 'constructor' || segment === 'prototype'))
-                throw new WireError(403, `Chemin d'état refusé : ${path}`);
+                throw new WireError(403, `State path rejected: ${path}`);
             const anyC = component;
             await anyC.updating?.(path, value);
             await anyC[`updating${studly(prop)}`]?.(value, segments.slice(1).join('.') || null);
@@ -301,24 +305,24 @@ export class WireRuntime {
             await anyC[`updated${studly(prop)}`]?.(value, segments.slice(1).join('.') || null);
         };
         for (const [path, value] of Object.entries(updates)) {
-            // Une référence de fichier temporaire renvoyée par le navigateur doit désigner un fichier réellement reçu.
+            // A temporary file reference sent by the browser must point to a file that was actually received.
             if (!uploadReferencesAreValid(value, this.uploads))
-                throw new WireError(403, `Référence de fichier refusée : ${path}`);
+                throw new WireError(403, `File reference rejected: ${path}`);
             await applyUpdate(path, value);
         }
         const allowed = callableMethods(component);
         const returns = [];
         for (const call of calls) {
             if (typeof call?.method !== 'string' || !Array.isArray(call.params))
-                throw new WireError(404, 'Appel invalide.');
-            // Actions magiques : sans effet côté serveur, les valeurs voyagent dans `updates` (SupportMagicActions de Livewire).
+                throw new WireError(404, 'Invalid call.');
+            // Magic actions are no-ops on the server: their values travel in `updates`.
             if (MAGIC_ACTIONS.has(call.method)) {
                 returns.push(null);
                 continue;
             }
             if (call.method === '__lazyLoad') {
                 if (!awaitsLazyLoad || lazyLoaded)
-                    throw new WireError(404, 'Ce composant n\'attend pas de chargement différé.');
+                    throw new WireError(404, 'This component is not waiting for a lazy load.');
                 const params = this.decodeMountParams(name, call.params[0]);
                 this.assignMatchingProperties(component, params);
                 await component.mount(params);
@@ -326,15 +330,15 @@ export class WireRuntime {
                 returns.push(null);
                 continue;
             }
-            // Tant qu'il n'est pas chargé, un composant « lazy » n'a pas été monté : rien d'autre n'est appelable.
+            // Until it is loaded, a lazy component has not been mounted: nothing else is callable.
             if (awaitsLazyLoad && !lazyLoaded)
-                throw new WireError(404, 'Composant non chargé.');
-            // --- téléversement de fichiers (port de WithFileUploads) : la cible est un chemin d'état, soumis aux mêmes gardes qu'une mise à jour
+                throw new WireError(404, 'Component not loaded yet.');
+            // File uploads: the target is a state path, subject to the same guards as an update.
             if (call.method === '_startUpload' || call.method === '_finishUpload' || call.method === '_uploadErrored' || call.method === '_removeUpload') {
                 const store = this.uploads;
                 const target = call.params[0];
                 if (!store || typeof target !== 'string' || target.length > 500)
-                    throw new WireError(404, 'Téléversement indisponible.');
+                    throw new WireError(404, 'Uploads are not available.');
                 if (call.method === '_startUpload') {
                     component.dispatch('upload:generatedSignedUrl', { name: target, url: store.signedUrl(this.options.uploadPrefix ?? '/livewire') }, { self: true });
                     component._skipRender = true;
@@ -342,7 +346,7 @@ export class WireRuntime {
                 else if (call.method === '_finishUpload') {
                     const ids = Array.isArray(call.params[1]) ? call.params[1].map(String) : [];
                     if (!ids.length || ids.some((id) => !store.resolve(id)))
-                        throw new WireError(404, 'Fichier temporaire introuvable.');
+                        throw new WireError(404, 'Temporary file not found.');
                     await applyUpdate(target, call.params[2] === true ? ids.map((id) => UploadStore.reference(id)) : UploadStore.reference(ids[0]));
                     component.dispatch('upload:finished', { name: target, tmpFilenames: ids }, { self: true });
                 }
@@ -360,16 +364,16 @@ export class WireRuntime {
             if (call.method === '__dispatch') {
                 const handler = cls.listeners?.[String(call.params[0])];
                 if (!handler)
-                    throw new WireError(404, `Aucun écouteur pour l'événement : ${String(call.params[0])}`);
+                    throw new WireError(404, `No listener for event: ${String(call.params[0])}`);
                 const args = call.params[1] && typeof call.params[1] === 'object' ? Object.values(call.params[1]) : [];
                 returns.push((await component[handler](...args)) ?? null);
                 continue;
             }
             if (!allowed.has(call.method)) {
-                // Aide au développement : la méthode existe mais n'est pas déclarée appelable.
+                // Development hint: the method exists but is not declared callable.
                 if (process.env.NODE_ENV !== 'production' && typeof component[call.method] === 'function' && !isLifecycleHook(call.method))
-                    console.warn(`[wire] ${name} : « ${call.method} » existe mais n'est pas dans static callable — appel refusé.`);
-                throw new WireError(404, `Méthode introuvable : ${call.method}`);
+                    console.warn(`[wire] ${name}: "${call.method}" exists but is not listed in static callable; call rejected.`);
+                throw new WireError(404, `Method not found: ${call.method}`);
             }
             returns.push((await component[call.method](...call.params)) ?? null);
         }
@@ -384,7 +388,7 @@ export class WireRuntime {
         }
         await component.dehydrate();
         const { id: _i, name: _n, errors: _e, ...memo } = snapshot.memo;
-        // Après un rendu complet, la liste des enfants est celle qui vient d'être rendue ; sinon elle est conservée.
+        // After a full render, the children list is the one just rendered; otherwise it is kept.
         if (rendered)
             memo.children = Object.keys(component._children).length ? component._children : [];
         if (lazyLoaded) {
@@ -393,17 +397,17 @@ export class WireRuntime {
         }
         return { snapshot: this.snapshot(component, name, memo), effects };
     }
-    /** Point d'entrée HTTP : corps `{ _token, components: [{ snapshot, updates, calls }] }`. */
+    /** HTTP entry point; body: `{ _token, components: [{ snapshot, updates, calls }] }`. */
     async handle(body, ctx = null) {
         const list = body?.components;
         if (!Array.isArray(list) || list.length === 0)
-            throw new WireError(404, 'Charge utile invalide.');
+            throw new WireError(404, 'Invalid payload.');
         const components = [];
-        // Les composants d'une requête sont traités dans l'ordre : un parent passe ses propriétés réactives aux enfants qui le suivent.
+        // Components are processed in order so a parent can pass its reactive props to the children that follow it.
         await this.requestScope.run({ childProps: new Map() }, async () => {
             for (const c of list) {
                 if (typeof c?.snapshot !== 'string' || typeof c.updates !== 'object' || !Array.isArray(c.calls))
-                    throw new WireError(404, 'Charge utile invalide.');
+                    throw new WireError(404, 'Invalid payload.');
                 const { snapshot, effects } = await this.update(JSON.parse(c.snapshot), c.updates ?? {}, c.calls, ctx);
                 components.push({ snapshot: JSON.stringify(snapshot), effects });
             }

package/lib/uploads.d.ts

@@ -22,16 +22,16 @@ export declare class UploadStore {
     private urlTtl;
     constructor(dir: string, key: string, options?: UploadOptions);
     private sign;
-    /** Adresse d'envoi signée, valable quelques minutes. */
+    /** Signed upload URL, valid for a few minutes (`urlTtl`). */
     signedUrl(prefix?: string): string;
     verifySignature(expires: unknown, signature: unknown): boolean;
-    /** Reçoit un envoi `multipart/form-data` (champ `files[]`) et rend les identifiants temporaires, dans l'ordre. */
+    /** Receives a `multipart/form-data` upload (`files[]` field) and returns the temporary ids, in order. */
     receive(req: IncomingMessage): Promise<string[]>;
-    /** Fichier temporaire désigné par une valeur d'état (`livewire-file:<id>`) ou un identifiant, s'il existe encore. */
+    /** Temporary file referenced by a state value (`livewire-file:<id>`) or a bare id, if it still exists. */
     resolve(value: unknown): TemporaryFile | null;
     static isTemporary(value: unknown): boolean;
     static reference(id: string): string;
     remove(id: string): void;
-    /** Supprime les fichiers temporaires plus vieux que la durée de conservation. */
+    /** Deletes temporary files older than the retention time (`ttl`). */
     private sweep;
 }

package/lib/uploads.js

@@ -1,6 +1,5 @@
-// Téléversements temporaires (équivalent de WithFileUploads / TemporaryUploadedFile de Livewire).
-// Le navigateur demande une adresse signée (`_startUpload`), y envoie les fichiers, puis annonce leurs noms temporaires (`_finishUpload`) :
-// la propriété visée reçoit alors `livewire-file:<identifiant>`. Le fichier ne quitte le dossier temporaire que si l'application l'enregistre.
+// Temporary uploads. The browser asks for a signed URL (`_startUpload`), posts the files to it, then reports their temporary ids
+// (`_finishUpload`): the target property then holds `livewire-file:<id>`. A file only leaves the temporary directory if the app stores it.
 import busboy from 'busboy';
 import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
 import { createWriteStream, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
@@ -8,7 +7,7 @@ import { open } from 'node:fs/promises';
 import path from 'node:path';
 const PREFIX = 'livewire-file:';
 const ID = /^[a-f0-9]{32}$/;
-/** Types reconnus à leur signature binaire : le type annoncé par le navigateur n'est jamais cru. */
+/** Types detected from their magic bytes: the type announced by the browser is never trusted. */
 const SIGNATURES = [
     { type: 'image/jpeg', extension: 'jpg', test: (b) => b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff },
     { type: 'image/png', extension: 'png', test: (b) => b.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])) },
@@ -17,7 +16,7 @@ const SIGNATURES = [
     { type: 'application/pdf', extension: 'pdf', test: (b) => b.subarray(0, 5).toString('latin1') === '%PDF-' },
     { type: 'application/zip', extension: 'zip', test: (b) => b[0] === 0x50 && b[1] === 0x4b && b[2] === 0x03 && b[3] === 0x04 },
 ];
-/** Texte brut : uniquement pour ces extensions, et seulement si le début du fichier ne contient pas d'octet nul. */
+/** Plain text: only for these extensions, and only if the start of the file contains no null byte. */
 const TEXT = { txt: 'text/plain', csv: 'text/csv', json: 'application/json', md: 'text/markdown' };
 export class UploadStore {
     dir;
@@ -29,14 +28,14 @@ export class UploadStore {
     constructor(dir, key, options = {}) {
         this.dir = dir;
         this.key = key;
-        this.maxFileSize = options.maxFileSize ?? 12 * 1024 * 1024; // 12 Mo, comme la règle par défaut de Livewire
+        this.maxFileSize = options.maxFileSize ?? 12 * 1024 * 1024; // 12 MB
         this.maxFiles = options.maxFiles ?? 20;
         this.ttl = options.ttl ?? 24 * 60 * 60 * 1000;
         this.urlTtl = options.urlTtl ?? 5 * 60 * 1000;
         mkdirSync(dir, { recursive: true });
     }
     sign(expires) { return createHmac('sha256', this.key).update(`upload:${expires}`).digest('hex'); }
-    /** Adresse d'envoi signée, valable quelques minutes. */
+    /** Signed upload URL, valid for a few minutes (`urlTtl`). */
     signedUrl(prefix = '/livewire') {
         const expires = Date.now() + this.urlTtl;
         return `${prefix}/upload-file?expires=${expires}&signature=${this.sign(expires)}`;
@@ -48,7 +47,7 @@ export class UploadStore {
         const expected = Buffer.from(this.sign(at)), given = Buffer.from(String(signature ?? ''));
         return expected.length === given.length && timingSafeEqual(expected, given);
     }
-    /** Reçoit un envoi `multipart/form-data` (champ `files[]`) et rend les identifiants temporaires, dans l'ordre. */
+    /** Receives a `multipart/form-data` upload (`files[]` field) and returns the temporary ids, in order. */
     receive(req) {
         this.sweep();
         return new Promise((resolve, reject) => {
@@ -61,7 +60,7 @@ export class UploadStore {
                 parser = busboy({ headers: req.headers, limits: { fileSize: this.maxFileSize, files: this.maxFiles, fields: 5 } });
             }
             catch {
-                reject(Object.assign(new Error('Envoi invalide.'), { status: 422 }));
+                reject(Object.assign(new Error('Invalid upload.'), { status: 422 }));
                 return;
             }
             parser.on('file', (_field, stream, info) => {
@@ -69,8 +68,8 @@ export class UploadStore {
                 const target = path.join(this.dir, id);
                 ids.push(id);
                 const out = createWriteStream(target, { flags: 'wx' });
-                stream.on('limit', () => fail('Fichier trop volumineux.'));
-                pending.push(new Promise((done) => { out.on('close', done); out.on('error', () => { fail('Écriture impossible.'); done(); }); }).then(async () => {
+                stream.on('limit', () => fail('File too large.'));
+                pending.push(new Promise((done) => { out.on('close', done); out.on('error', () => { fail('Could not write the file.'); done(); }); }).then(async () => {
                     if (failure)
                         return;
                     const detected = await detect(target, info.filename);
@@ -78,14 +77,14 @@ export class UploadStore {
                 }));
                 stream.pipe(out);
             });
-            parser.on('filesLimit', () => fail('Trop de fichiers.'));
-            parser.on('error', () => fail('Envoi invalide.'));
+            parser.on('filesLimit', () => fail('Too many files.'));
+            parser.on('error', () => fail('Invalid upload.'));
             parser.on('close', async () => {
                 await Promise.all(pending);
                 if (failure || !ids.length) {
                     for (const id of ids)
                         this.remove(id);
-                    reject(failure ?? Object.assign(new Error('Aucun fichier.'), { status: 422 }));
+                    reject(failure ?? Object.assign(new Error('No file.'), { status: 422 }));
                     return;
                 }
                 resolve(ids);
@@ -93,7 +92,7 @@ export class UploadStore {
             req.pipe(parser);
         });
     }
-    /** Fichier temporaire désigné par une valeur d'état (`livewire-file:<id>`) ou un identifiant, s'il existe encore. */
+    /** Temporary file referenced by a state value (`livewire-file:<id>`) or a bare id, if it still exists. */
     resolve(value) {
         const id = typeof value === 'string' ? (value.startsWith(PREFIX) ? value.slice(PREFIX.length) : value) : '';
         if (!ID.test(id))
@@ -117,7 +116,7 @@ export class UploadStore {
         for (const suffix of ['', '.json'])
             rmSync(path.join(this.dir, id + suffix), { force: true });
     }
-    /** Supprime les fichiers temporaires plus vieux que la durée de conservation. */
+    /** Deletes temporary files older than the retention time (`ttl`). */
     sweep() {
         const limit = Date.now() - this.ttl;
         try {
@@ -127,7 +126,7 @@ export class UploadStore {
                     rmSync(file, { force: true });
             }
         }
-        catch { /* dossier inaccessible : rien à nettoyer */ }
+        catch { /* directory unreadable: nothing to sweep */ }
     }
 }
 async function detect(file, filename) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navette-js/wire",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.2",
   "description": "Server-side runtime compatible with Livewire 3 for Node.js and Express.",
   "license": "MIT",
   "type": "module",
@@ -36,7 +36,6 @@
   },
   "keywords": [
     "navette",
-    "filament",
     "admin",
     "panel",
     "livewire",