upload_d_n_d 0.9.4 → 0.10.0

data/app/models/upload_d_n_d/temporary_attachment.rb

@@ -47,27 +47,46 @@ module UploadDND
       #     @user,
       #     { 'avatar' => :avatar, 'documents' => :documents }
       #   )
-      def attach_to_record(session_id, record, attribute_map = {})
+      # Transfère les fichiers temporaires d'une session vers un record.
+      #
+      # @param attribute_map [Hash, nil] mapping source => cible. nil (callback
+      #   after_create) = identité sur les attributs `uploadable` du modèle.
+      #
+      # SÉCURITÉ (F3) : on ne traite que les attributs explicitement demandés
+      # (clés de `attribute_map`, ou les `uploadable_attributes` du modèle), et
+      # seulement s'ils sont déclarés `uploadable` — un attribute_name forgé vers
+      # un autre champ (ex. "signed_contract") n'est jamais transféré.
+      # SÉCURITÉ (F4) : `max_files` et les contraintes du champ sont vérifiés au
+      # transfert (le déplacement par `update!` ne relance pas la validation).
+      def attach_to_record(session_id, record, attribute_map = nil)
+        uploadable = record.class.respond_to?(:uploadable_attributes) ? record.class.uploadable_attributes : {}
+        counts = Hash.new { |hash, attr| hash[attr] = current_attachment_count(record, attr) }
+
         for_session(session_id).find_each do |temp_attachment|
-          source_attr = temp_attachment.attribute_name
-          target_attr = attribute_map[source_attr]&.to_s || source_attr
+          target_attr = resolve_target(temp_attachment.attribute_name, attribute_map)
+          next if target_attr.nil? # non demandé explicitement : on laisse (nettoyage orphelins)
 
-          # SÉCURITÉ : attribute_name vient du client — seul un attachment
-          # déclaré sur le modèle est résolu, jamais une méthode quelconque.
-          attachment = UploadDND::AttachmentLookup.find(record, target_attr)
-          unless attachment
-            temp_attachment.destroy
-            next
-          end
+          # Champ non uploadable : ne pas transférer ET ne pas détruire — ce peut
+          # être un temporaire d'un autre formulaire ouvert dans la même session
+          # (autre modèle/onglet). Le job d'expiration les nettoie.
+          next unless uploadable.key?(target_attr.to_sym)
 
+          attachment = UploadDND::AttachmentLookup.find(record, target_attr)
           blob_attachment = temp_attachment.blob_attachment
-          if blob_attachment.nil? || temp_attachment.violates_constraints_of?(record, target_attr)
+          if attachment.nil? || blob_attachment.nil? || temp_attachment.violates_constraints_of?(record, target_attr)
             temp_attachment.destroy
             next
           end
 
           if attachment.is_a?(ActiveStorage::Attached::Many)
+            max = uploadable[target_attr.to_sym][:max_files]
+            if max && counts[target_attr] >= max
+              Rails.logger.warn "UploadDND: #{record.class}##{target_attr} max_files (#{max}) atteint au transfert - fichier refusé"
+              temp_attachment.destroy
+              next
+            end
             blob_attachment.update!(record: record, name: target_attr)
+            counts[target_attr] += 1
           elsif attachment.is_a?(ActiveStorage::Attached::One)
             if attachment.attached?
               temp_attachment.destroy
@@ -80,6 +99,25 @@ module UploadDND
           temp_attachment.destroy
         end
       end
+
+      private
+
+      # Cible pour un attribut source. Avec une map : uniquement ses clés (nil
+      # sinon). Sans map (after_create) : identité (filtré ensuite sur uploadable).
+      def resolve_target(source_attr, attribute_map)
+        return source_attr if attribute_map.nil?
+
+        attribute_map[source_attr]&.to_s
+      end
+
+      def current_attachment_count(record, attribute)
+        attachment = UploadDND::AttachmentLookup.find(record, attribute)
+        case attachment
+        when ActiveStorage::Attached::Many then attachment.count
+        when ActiveStorage::Attached::One then attachment.attached? ? 1 : 0
+        else 0
+        end
+      end
     end
 
     # Méthodes d'instance

data/app/views/upload_d_n_d/shared/_files_list.html.erb

@@ -23,7 +23,7 @@
             </div>
           </div>
 
-          <% delete_url = udnd_remove_file_url(record, attachment, attribute_name) %>
+          <% delete_url = udnd_remove_file_url(record, attachment, attribute_name, namespace: local_assigns[:namespace]) %>
 
           <div class="udnd-file-actions">
             <%# Bouton de prévisualisation (images et PDFs uniquement) %>

data/docs/CHANGELOG.md

@@ -7,6 +7,42 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.10.0] - 2026-10-30
+
+Lot sécurité majeur (audit de la gem) : la cible d'un dépôt/suppression provient désormais d'un **jeton signé** (plus de paramètres bruts du client), l'autorisation est **fail-closed** et le flux des fichiers temporaires est durci. **Changement de contrat** — voir la section Migration. Mineure, rétrocompatible pour le code applicatif (le composant émet le jeton ; une app met la gem à jour et re-rend ses vues).
+
+### Security
+- **Cible d'upload signée** (`UploadDND::SignedTarget`, remplace `UploadDND::FieldReference`) — le dépôt et la suppression sur un record ne reposent plus sur un `record_gid`/`attribute_name`/`namespace` **bruts** fournis par le client. Le composant émet un jeton **signé** (modèle + attribut + record + namespace de policy) ; le contrôleur en déduit la cible et ignore les paramètres bruts. Ferme l'usurpation de record via `GlobalID` non signé, restreint le dépôt aux seuls champs déclarés `uploadable` (un `has_one_attached`/`has_many_attached` quelconque n'est plus ciblable), et transporte le namespace de policy de façon fiable. **Coupure franche** : un client qui n'envoie pas de jeton valide est refusé.
+- **Autorisation record fail-closed, avec namespace** — les routes du moteur autorisent sur le record (`:update`) en passant le namespace du jeton (`Admin::RecordPolicy` essayée d'abord, repli sur la policy top-level). Si **aucune** policy n'existe pour le record, la requête est **refusée (403)** (plus de repli sur la policy générique `UploadDNDAttachmentPolicy`), avec un avertissement en log nommant la policy manquante. La garde générique est retirée des routes permanentes ; le flux temporaire conserve `:upload_d_n_d_temporary_attachment`, désormais fail-closed lui aussi.
+- **Référence de champ obligatoire au dépôt temporaire** — plus de repli silencieux sur les contraintes globales : les limites appliquées sont celles du champ visé par le jeton.
+- **Transfert des fichiers temporaires durci** — `TemporaryAttachment.attach_to_record` et le callback `attach_temporary_uploads` ne transfèrent que les attributs **explicitement demandés** (clés de l'`attribute_map`, ou les `uploadable_attributes` du modèle), et seulement s'ils sont déclarés `uploadable` : un `attribute_name` forgé vers un autre champ n'est plus transféré (et un temporaire non concerné n'est pas détruit). `max_files` et les contraintes du champ sont désormais appliqués **au transfert** (le déplacement par `update!` ne relançait pas la validation).
+- **Plus d'alias global `::FileValidator`** — la gem n'enregistre plus de constante `::FileValidator` au boot. Elle masquait silencieusement le `FileValidator` d'une app hôte (chargé plus tard par Zeitwerk), désactivant ses propres validations. `uploadable` référence désormais `UploadDND::FileValidator` explicitement (`validates_with`). L'installeur ne traite plus `app/validators/file_validator.rb` comme un fichier obsolète.
+- **Durée de vie des jetons** — `config.signed_target_expires_in` (24 h par défaut, `nil` pour désactiver) limite la fenêtre d'usage d'un jeton de cible. L'autorisation reste revérifiée à chaque requête.
+- **Énumération de records fermée** — le `record_gid` brut non signé est remplacé par le jeton signé : on ne peut plus forger d'identifiant pour sonder l'existence de records (404 vs 403).
+- **Purge de blob restreinte aux requêtes autorisées sur le record** — l'autorisation de purge des blobs refusés n'est plus posée par la policy générique seule. Une requête qui échoue avant la localisation et l'autorisation du record (400/404) ne purge plus le blob déposé : sans ce correctif, un utilisateur disposant du droit générique pouvait forcer la purge d'un blob récent non rattaché dont il connaissait le `signed_id`. Les orphelins restent nettoyés par la purge dédiée.
+
+### Added
+- **Contrôleur parent configurable** — `config.parent_controller` (défaut `"ActionController::Base"`). Mettre `"ApplicationController"` pour que les routes du moteur héritent de `pundit_user`, `current_ability` et des `before_action` d'authentification/multi-tenant de l'app hôte. Quand Pundit est présent, le moteur marque la requête comme vérifiée (`skip_policy_scope`/`skip_authorization`) pour que les `after_action verify_*` de l'hôte passent **quel que soit leur nom** — le moteur appliquant malgré tout sa propre autorisation fail-closed. `current_user` est public et délègue au parent (`super`) avant un repli Warden, pour que l'app hôte le voie (`respond_to?`) et alimente son contexte (ex. `Current.user`).
+
+### Fixed
+- **`upload_d_n_d:link_js` : copie rafraîchie sur changement de contenu** — la tâche comparait seulement la version du `package.json` ; une gem branchée en `path:`/`git:` (même version) gardait l'ancien JS. La copie est désormais rafraîchie dès qu'un fichier diffère.
+- **CSS : `@import "upload_d_n_d/styles"` fonctionne sur tous les bundlers** — un vrai fichier `styles.css` est livré à la racine du paquet (il ré-importe le CSS réel, source unique). postcss-import (Tailwind 3) ignore les `exports` et cherche un fichier réel : il le trouve désormais ; esbuild/bun continuent via `exports`. `JsLink` copie `styles.css` **et** le CSS qu'il importe ; `styles.css` est ajouté aux fichiers du gemspec.
+- **Libellé : types MIME non standard** — `image/jpg` (et `image/pjpeg`) sont normalisés en `image/jpeg` → le libellé sous la zone affiche `.jpg,.jpeg` au lieu du type brut.
+- **Signature de blob invalide : 401 au lieu de 500** — `find_blob` ne gardait pas le cas où `ActiveStorage::Blob.find_signed` renvoie `nil` (signature invalide ou blob supprimé), ce qui provoquait une erreur 500. La requête est désormais refusée proprement en 401.
+- **`root_path` dans un moteur isolé** — la branche `format.html` (réponse non Turbo/JSON) de la liste de fichiers utilise désormais `main_app.root_path` (repli `"/"`) au lieu de `root_path`, qui levait une `NameError` (500) dans un moteur isolé.
+
+### Changed
+- **Installeur** : message de post-installation mis à jour (jsbundling/bun + importmap, `javascript:build`, autorisation fail-closed, `parent_controller`) ; retrait du template mort `concerns/upload_authorization.rb` (autorisation via le port adaptateur).
+
+### Removed
+- **Helper mort retiré** (`app/helpers/upload_d_n_d/controllers/helpers.rb`, `UploadDND::Controllers::Helpers`) : un duplicata inutilisé de `attach_upload_d_n_d_files` qui attachait sans passer par `AttachmentLookup` ni les contraintes de champ. L'implémentation utilisée reste le concern `UploadDND::Controllers::Uploadable`.
+
+### Migration
+- **Jeton de test** : `UploadDND::FieldReference` est remplacé par `UploadDND::SignedTarget`. Pour poster sur les endpoints du moteur dans un spec, générer le jeton avec `UploadDND::SignedTarget.for(record, :attribut, namespace: nil)` (record persisté ou non) et le passer en `params[:target]`.
+- **Changement de comportement** : un attribut forgé ou non déclaré `uploadable`, ou un record non autorisé, est désormais rejeté **dès le POST** (400 pour un jeton invalide, 403 pour l'autorisation) — et non plus à l'enregistrement.
+- **Policies** : chaque modèle `uploadable` doit avoir une policy (fail-closed). Pour un espace admin, passer `namespace:` au helper (`upload_field :doc, record: @r, namespace: :admin`).
+- **Multi-tenant / auth custom** : si le moteur doit voir `pundit_user`/`current_ability` ou les `before_action` de votre `ApplicationController`, régler `config.parent_controller = "ApplicationController"` dans un initializer.
+
 ## [0.9.4] - 2026-10-29
 
 `link_js` copie le JS/CSS dans `node_modules` au lieu d'un lien symbolique, pour que les imports tiers de la gem se résolvent dans l'app (jsbundling/bun/esbuild). Patch, sans changement d'API.

data/lib/generators/upload_d_n_d/install_generator.rb

@@ -41,19 +41,11 @@ module UploadDND
       end
 
       def copy_concerns
-        say "Installation des concerns...", :green
+        say "Les concerns (Uploadable, Controllers::Uploadable, FileValidator) " \
+            "sont fournis par le runtime de la gem (lib/) — rien à copier.", :green
 
-        # Les concerns critiques (Uploadable, Controllers::Uploadable, FileValidator)
-        # sont désormais fournis par le runtime de la gem (lib/).
-        # Seul upload_authorization reste un template car il est personnalisable.
-        say "  ✓ UploadDND::Uploadable         → fourni par la gem (lib/)", :cyan
-        say "  ✓ UploadDND::Controllers::Uploadable → fourni par la gem (lib/)", :cyan
-        say "  ✓ UploadDND::FileValidator       → fourni par la gem (lib/)", :cyan
-
-        template "concerns/upload_authorization.rb",
-                 "app/controllers/concerns/upload_d_n_d/upload_authorization.rb"
-
-        # Nettoyage : supprime les anciennes copies si elles existent (migration depuis v0.3.x)
+        # Nettoyage : supprime les anciennes copies si elles existent (migration
+        # depuis les versions qui copiaient des concerns dans l'app).
         remove_stale_overrides
       end
 
@@ -132,11 +124,15 @@ module UploadDND
 
       # Supprime les fichiers qui étaient copiés par les anciennes versions (< 0.4.0)
       # et qui shadowent désormais le runtime de la gem.
+      # Anciennes copies désormais servies par le runtime de la gem. On n'y met
+      # PAS app/validators/file_validator.rb : une app hôte peut légitimement
+      # avoir son propre FileValidator, et la gem n'en fournit plus de global.
       STALE_OVERRIDES = [
         "app/models/concerns/upload_d_n_d/uploadable.rb",
         "app/controllers/concerns/upload_d_n_d/controllers/uploadable.rb",
-        "app/validators/file_validator.rb",
-        # Fichiers copiés par les versions < 0.5.0 (désormais servis depuis la gem)
+        # Concern d'autorisation devenu inutile (autorisation via le port adaptateur).
+        "app/controllers/concerns/upload_d_n_d/upload_authorization.rb",
+        # Fichiers copiés par les anciennes versions (désormais servis depuis la gem)
         "app/javascript/controllers/upload_d_n_d/uploads_controller.js",
         "app/javascript/controllers/upload_d_n_d/preview_controller.js",
         "app/assets/stylesheets/upload_d_n_d.css",

data/lib/generators/upload_d_n_d/templates/POST_INSTALL

@@ -1,6 +1,6 @@
 ===============================================================================
 
-  UploadDND v0.5.0 installé avec succès !
+  UploadDND installé avec succès !
 
 ===============================================================================
 
@@ -15,48 +15,50 @@ Prochaines étapes :
      rails active_storage:install
      rails db:migrate
 
-  3. Ajouter l'import JavaScript dans votre application.js :
+  3. JavaScript — importer le module de la gem dans votre application.js :
 
      import "upload_d_n_d"
 
      Les contrôleurs Stimulus sont auto-enregistrés depuis la gem.
 
-  4. Ajouter le CSS dans votre layout :
+     - jsbundling (esbuild/bun) : la tâche upload_d_n_d:link_js copie le JS de la
+       gem dans node_modules/upload_d_n_d ; elle tourne automatiquement sur
+       `rails javascript:build` (et `assets:precompile` au déploiement). Après une
+       montée de version de la gem, lancer une fois `rails javascript:build` en
+       local (un serveur en watch ne déclenche pas la tâche).
+     - importmap : les pins de la gem sont ajoutés automatiquement.
 
-     <%= stylesheet_link_tag "upload_d_n_d/application", media: "all" %>
+  4. CSS :
 
-  5. (Optionnel) Configurer les policies Pundit :
+     - Tailwind / bundler CSS :   @import "upload_d_n_d/styles";
+     - Sprockets / asset pipeline : <%= stylesheet_link_tag "upload_d_n_d/application", media: "all" %>
 
-     rails generate upload_d_n_d:policy
+  5. Autorisation (Pundit ou CanCanCan) — fail-closed :
 
-     Ceci génère les deux policies :
-       - app/policies/upload_d_n_d_temporary_attachment_policy.rb
-       - app/policies/upload_d_n_d_attachment_policy.rb
+     Chaque modèle qui expose un champ `uploadable` doit avoir une policy pour le
+     record (ex. ProjectPolicy#update?). Sans policy, les dépôts/suppressions sont
+     refusés (403). Pour un espace admin, passez le namespace au helper :
 
-  6. Utiliser le générateur de modèle (recommandé) :
+       <%= upload_field :documents, record: @document, namespace: :admin %>
+
+     ce qui autorise via Admin::DocumentPolicy. Générateur de policies génériques :
+
+       rails generate upload_d_n_d:policy
+
+  6. Déclarer le champ sur le modèle (recommandé via le générateur) :
 
      rails g upload_d_n_d:model User --attribute=avatar
      rails g upload_d_n_d:model Project --attribute=documents --multiple --content_type=pdf docx xlsx
 
-  7. Utiliser dans vos vues :
+  7. Utiliser dans vos vues (un record: est requis, même une instance neuve) :
 
      <%= upload_field :avatar, record: @user %>
 
-  8. Architecture v0.5.0 :
-
-     Tout est servi directement depuis la gem :
-       - UploadDND::Uploadable          (model concern)
-       - UploadDND::Controllers::Uploadable (controller concern)
-       - UploadDND::FileValidator        (file validation)
-       - Contrôleurs Stimulus            (auto-enregistrés via importmap)
-       - CSS                             (servi via asset pipeline)
-       - ViewComponent                   (servi depuis la gem)
-
-     Un simple `bundle update` suffit pour tout mettre à jour.
+  Tout le reste (concerns, FileValidator, contrôleurs Stimulus, CSS, ViewComponent)
+  est servi depuis la gem : un `bundle update` suffit pour mettre à jour.
 
-     Fichiers personnalisables (copiés dans votre app) :
-       - app/controllers/concerns/upload_d_n_d/upload_authorization.rb
-       - app/helpers/upload_d_n_d/upload_helper.rb
-       - config/initializers/upload_d_n_d.rb
+  Fichiers personnalisables copiés dans votre app :
+    - app/helpers/upload_d_n_d/upload_helper.rb
+    - config/initializers/upload_d_n_d.rb
 
 ===============================================================================

data/lib/generators/upload_d_n_d/templates/initializers/upload_d_n_d.rb

@@ -43,9 +43,10 @@ UploadDND.configure do |config|
   # pour s'en passer. Sans adaptateur utilisable, tout est refusé (403).
   # config.authorization_adapter = :pundit # ou :cancancan, ou :none
 
-  # Validateur personnalisé
-  # Par défaut, utilise FileValidator si disponible
-  # config.validator_class = 'FileValidator'
+  # Contrôleur parent des routes du moteur (défaut "ActionController::Base").
+  # Mettre "ApplicationController" pour hériter de pundit_user / current_ability
+  # et des before_action d'authentification/multi-tenant de l'app hôte.
+  # config.parent_controller = "ApplicationController"
 
   # Configuration du stockage ActiveStorage (optionnel)
   # Exemple: forcer l'utilisation d'un service spécifique

data/lib/upload_d_n_d/configuration.rb

@@ -21,6 +21,8 @@ module UploadDND
                   :on_upload_error,
                   :on_file_removed,
                   :delete_route,
+                  :parent_controller,
+                  :signed_target_expires_in,
                   :rate_limit_enabled,
                   :rate_limit_max_requests,
                   :rate_limit_period
@@ -61,6 +63,16 @@ module UploadDND
       #   de l'app (concern Controllers::Uploadable) — nécessite une route
       #   polymorphique pour le record (cf. README, "Records imbriqués").
       @delete_route = :engine
+      # Contrôleur parent des contrôleurs du moteur. Par défaut ActionController::Base
+      # (isolé). Mettre "ApplicationController" pour hériter de l'app hôte :
+      # pundit_user, current_ability, before_action d'authentification/multi-tenant.
+      # À régler dans un initializer (avant le premier chargement des contrôleurs).
+      @parent_controller = "ActionController::Base"
+      # Durée de vie des jetons de cible signée (SignedTarget). nil = pas
+      # d'expiration. 24h par défaut : assez long pour un onglet de formulaire
+      # laissé ouvert, assez court pour limiter la portée d'une fuite de jeton.
+      # L'autorisation reste revérifiée à chaque requête quoi qu'il arrive.
+      @signed_target_expires_in = 24.hours
       @rate_limit_enabled = false
       @rate_limit_max_requests = 10
       @rate_limit_period = 60 # secondes

data/lib/upload_d_n_d/file_validator.rb

@@ -2,9 +2,10 @@
 
 # Validateur de fichiers pour ActiveStorage.
 #
-# Rails associe `validates :avatar, file: {...}` à une constante `FileValidator`.
-# Pour garder l'API ergonomique, on expose `UploadDND::FileValidator` ET on
-# fournit un alias top-level `::FileValidator` si absent.
+# Référencé explicitement par UploadDND::Uploadable#uploadable
+# (`validates_with UploadDND::FileValidator`). On ne définit AUCUN alias
+# top-level `::FileValidator` : il masquerait le validateur d'une app hôte
+# chargé plus tard par Zeitwerk (voir bas de fichier).
 module UploadDND
   class FileValidator < ActiveModel::EachValidator
     def validate_each(record, attribute, value)
@@ -152,5 +153,7 @@ module UploadDND
   end
 end
 
-# Alias top-level pour l'API `validates ..., file: ...`
-::FileValidator = UploadDND::FileValidator unless defined?(::FileValidator)
+# Pas d'alias top-level `::FileValidator` : il masquerait silencieusement le
+# FileValidator d'une app hôte (chargé plus tard par Zeitwerk), désactivant ses
+# propres validations. `uploadable` référence `UploadDND::FileValidator`
+# explicitement (voir UploadDND::Uploadable#uploadable).

data/lib/upload_d_n_d/js_link.rb

@@ -37,9 +37,9 @@ module UploadDND
         :updated
       elsif File.directory?(dest)
         return :conflict unless ours?(dest) # dossier étranger : on n'y touche jamais
-        return :unchanged if same_version?(source, dest)
+        return :unchanged if up_to_date?(source, dest)
 
-        replace(source, dest) # notre copie, version périmée
+        replace(source, dest) # notre copie, contenu périmé
         :updated
       elsif File.exist?(dest)
         :conflict # fichier étranger
@@ -58,11 +58,16 @@ module UploadDND
     end
     private_class_method :ours?
 
-    def same_version?(source, dest)
-      read_json(File.join(source, "package.json"))["version"] ==
-        read_json(File.join(dest, "package.json"))["version"]
+    # Compare le CONTENU (pas seulement la version du package.json) : une gem
+    # branchée en `path:`/`git:` peut garder la même version tout en changeant le
+    # JS. La copie est à jour si chaque fichier attendu existe et est identique.
+    def up_to_date?(source, dest)
+      package_files(source).all? do |rel|
+        target = File.join(dest, rel)
+        File.file?(target) && FileUtils.identical?(File.join(source, rel), target)
+      end
     end
-    private_class_method :same_version?
+    private_class_method :up_to_date?
 
     def replace(source, dest)
       FileUtils.remove_entry(dest)
@@ -83,7 +88,7 @@ module UploadDND
     private_class_method :copy
 
     def package_files(source)
-      exports = read_json(File.join(source, "package.json"))["exports"] || {}
+      pkg = read_json(File.join(source, "package.json"))
       targets = []
       collect = lambda do |value|
         case value
@@ -91,7 +96,10 @@ module UploadDND
         when Hash then value.each_value(&collect)
         end
       end
-      exports.each_value(&collect)
+      (pkg["exports"] || {}).each_value(&collect)
+      # Le champ `style` de premier niveau (postcss-import / Tailwind 3) n'est pas
+      # dans `exports` : on l'ajoute pour copier aussi le styles.css racine.
+      targets << pkg["style"] if pkg["style"]
 
       files = [ "package.json" ]
       targets.each do |target|

data/lib/upload_d_n_d/mime_types.rb

@@ -34,6 +34,13 @@ module UploadDND
       (hash[mime] ||= []) << ".#{ext}"
     end.transform_values(&:freeze).freeze
 
+    # Types MIME non standard mais courants, normalisés vers leur forme standard
+    # pour que le libellé affiche des extensions et non le type brut.
+    MIME_SYNONYMS = {
+      "image/jpg" => "image/jpeg",
+      "image/pjpeg" => "image/jpeg"
+    }.freeze
+
     # Converts an array of symbols (extensions) and/or MIME strings into MIME strings.
     #
     # @param types [Array<Symbol, String>] e.g. [:jpg, :png, "application/pdf"]
@@ -64,6 +71,7 @@ module UploadDND
     # En dernier recours (type inconnu de la gem ET de Marcel), on garde le type
     # pour que la contrainte ne disparaisse pas de l'attribut `accept`.
     def self.extensions_for(mime)
+      mime = MIME_SYNONYMS.fetch(mime, mime)
       return MIME_TO_EXTENSIONS[mime] if MIME_TO_EXTENSIONS.key?(mime)
 
       marcel = Marcel::TYPE_EXTS[mime]

data/lib/upload_d_n_d/signed_target.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module UploadDND
+  # Cible d'upload signée : modèle + attribut + (record) + namespace de policy,
+  # émise par UploadComponent et vérifiée par les contrôleurs du moteur. Elle
+  # remplace les paramètres bruts `record_gid` / `attribute_name` / `namespace`
+  # du client : le serveur ne fait plus confiance au client pour désigner la
+  # cible ni le namespace d'autorisation.
+  #
+  # - Permanent (record persisté) : record_id présent → le record est résolu
+  #   par `model_class.find(record_id)` (sûr, puisque le couple est signé).
+  # - Temporaire (record non persisté) : record_id nil.
+  #
+  # Garde-fou : l'attribut doit être déclaré via `uploadable` sur le modèle
+  # (pas seulement un `has_one_attached`/`has_many_attached` quelconque).
+  module SignedTarget
+    PURPOSE = :upload_d_n_d_target
+
+    class Invalid < UploadDND::Error; end
+
+    Target = Data.define(:model_class, :attribute, :record_id, :namespace) do
+      # Résout le record signé. Lève ActiveRecord::RecordNotFound s'il a disparu
+      # (traduit en 404 par le contrôleur). nil pour une cible temporaire.
+      def record
+        return nil if record_id.nil?
+
+        model_class.find(record_id)
+      end
+
+      def constraints
+        UploadDND::FieldConstraints.for(model_class, attribute)
+      end
+    end
+
+    class << self
+      # Construit un jeton directement depuis une instance de record (persistée
+      # ou non). Pratique pour les vues, helpers et specs d'apps hôtes :
+      #   UploadDND::SignedTarget.for(@document, :file, namespace: :admin)
+      def for(record, attribute, namespace: nil)
+        generate(record.class, attribute, record_id: (record.id if record.persisted?), namespace: namespace)
+      end
+
+      # @param record_id [Object, nil] id du record (nil pour une cible temporaire)
+      # @param namespace [Array<Symbol>, nil] namespace de policy
+      def generate(model_class, attribute, record_id: nil, namespace: nil)
+        payload = [ model_class.name, attribute.to_s, record_id, Array(namespace).map(&:to_s).presence ]
+        verifier.generate(payload, purpose: PURPOSE, expires_in: UploadDND.configuration.signed_target_expires_in)
+      end
+
+      # @raise [Invalid] signature fausse, charge malformée, modèle inconnu, ou
+      #   attribut non déclaré `uploadable`
+      # @return [Target]
+      def verify(token)
+        payload = verifier.verified(token.to_s, purpose: PURPOSE)
+        raise Invalid unless payload.is_a?(Array) && payload.size == 4
+
+        model_name, attribute, record_id, namespace = payload
+        model_class = model_name.to_s.safe_constantize
+        raise Invalid unless model_class && uploadable?(model_class, attribute)
+
+        Target.new(
+          model_class: model_class,
+          attribute: attribute.to_s,
+          record_id: record_id,
+          namespace: namespace&.map(&:to_sym)
+        )
+      rescue ActiveSupport::MessageVerifier::InvalidSignature, ArgumentError
+        raise Invalid
+      end
+
+      def uploadable?(model_class, attribute)
+        model_class.respond_to?(:uploadable_attributes) &&
+          model_class.uploadable_attributes.key?(attribute.to_sym)
+      end
+
+      private
+
+      def verifier
+        Rails.application.message_verifier("upload_d_n_d/signed_target")
+      end
+    end
+  end
+end

data/lib/upload_d_n_d/uploadable.rb

@@ -52,8 +52,12 @@ module UploadDND
           end
         end
 
-        validates attribute_name,
-                  file: options.slice(:content_type, :max_size, :max_files, :message, :strict_mime_check, :spoofing_message)
+        # On référence UploadDND::FileValidator explicitement (plutôt que la clé
+        # `file:`, qui résout un `::FileValidator` global et masquerait le
+        # validateur de l'app hôte).
+        validates_with UploadDND::FileValidator,
+                       attributes: [ attribute_name ],
+                       **options.slice(:content_type, :max_size, :max_files, :message, :strict_mime_check, :spoofing_message)
 
         # Stocke les options pour usage ultérieur (ViewComponent, helpers, etc.)
         (@uploadable_attributes ||= {})[attribute_name] = options
@@ -68,47 +72,10 @@ module UploadDND
 
     def attach_temporary_uploads
       return unless temp_upload_session_id.present?
-      return unless UploadDND::TemporaryAttachment.exists?(session_id: temp_upload_session_id)
 
-      UploadDND::TemporaryAttachment.where(session_id: temp_upload_session_id).find_each do |temp_attachment|
-        attribute_name = temp_attachment.attribute_name
-
-        # SÉCURITÉ : attribute_name vient du client — seul un attachment déclaré
-        # sur le modèle est résolu. Détection serveur du type (has_one vs has_many).
-        attachment = UploadDND::AttachmentLookup.find(self, attribute_name)
-        unless attachment
-          # Si l'attribut n'est pas un attachment du record, on nettoie quand même
-          # pour éviter de laisser des fichiers orphelins en base.
-          temp_attachment.destroy
-          next
-        end
-
-        blob_attachment = temp_attachment.blob_attachment
-        if blob_attachment.nil? || temp_attachment.violates_constraints_of?(self, attribute_name)
-          temp_attachment.destroy
-          next
-        end
-
-        if attachment.is_a?(ActiveStorage::Attached::Many)
-          # has_many_attached: on "déplace" l'attachment (pas de purge du blob)
-          blob_attachment.update!(record: self, name: attribute_name)
-        elsif attachment.is_a?(ActiveStorage::Attached::One)
-          # has_one_attached: utiliser = (remplace automatiquement)
-          # Ne transférer que le PREMIER fichier temporaire si plusieurs existent
-          if attachment.attached?
-            # Le record a déjà un fichier: on purgera le temporaire.
-            temp_attachment.destroy
-            next
-          end
-
-          blob_attachment.update!(record: self, name: attribute_name)
-        end
-
-        # Après déplacement, temp_attachment n'a plus d'attachment ActiveStorage.
-        # On reload pour éviter les caches d'association avant destroy.
-        temp_attachment.reload
-        temp_attachment.destroy
-      end
+      # Délègue au transfert durci (restreint aux champs `uploadable`, applique
+      # max_files et les contraintes du champ au transfert — cf. F3/F4).
+      UploadDND::TemporaryAttachment.attach_to_record(temp_upload_session_id, self)
 
       # Nettoie le session_id après utilisation
       @_temp_upload_session_id = nil

data/lib/upload_d_n_d/version.rb

@@ -1,3 +1,3 @@
 module UploadDND
-  VERSION = "0.9.4"
+  VERSION = "0.10.0"
 end

data/lib/upload_d_n_d.rb

@@ -25,7 +25,7 @@ end
 
 require "upload_d_n_d/authorization"
 require "upload_d_n_d/field_constraints"
-require "upload_d_n_d/field_reference"
+require "upload_d_n_d/signed_target"
 
 module UploadDND
   # Autoload des concerns, helpers et autres composants

data/package.json

@@ -1,13 +1,15 @@
 {
     "name": "upload_d_n_d",
-    "version": "0.9.4",
+    "version": "0.10.0",
     "type": "module",
     "main": "app/javascript/upload_d_n_d/index.js",
+    "style": "./styles.css",
     "exports": {
         ".": "./app/javascript/upload_d_n_d/index.js",
         "./controllers/*": "./app/javascript/upload_d_n_d/controllers/*.js",
         "./styles": {
-            "style": "./app/assets/stylesheets/upload_d_n_d/application.css"
+            "style": "./app/assets/stylesheets/upload_d_n_d/application.css",
+            "default": "./app/assets/stylesheets/upload_d_n_d/application.css"
         }
     },
     "dependencies": {
@@ -16,4 +18,4 @@
     "peerDependencies": {
         "@hotwired/stimulus": "^3.0.0"
     }
-}
+}

data/styles.css

@@ -0,0 +1,4 @@
+/* Point d'entrée CSS pour les bundlers (Tailwind 3/postcss-import, esbuild, bun).
+   @import "upload_d_n_d/styles";  →  résout ce fichier, qui ré-importe le CSS
+   réel (source unique, servie aussi par Sprockets via app/assets). */
+@import "./app/assets/stylesheets/upload_d_n_d/application.css";