fix: cache results.length before explosion loop to prevent double-count

Pushing explosion dice to DieTerm.results made the for loop condition (j < results.length) grow mid-iteration, re-processing the explosion result as a normal die. This produced spurious entries like `1D6 → 4` alongside the correct `1D6-1 → 3`. Fixes prompt() (for loop) and rollSpellDamageToMessage() (for...of) by caching result count / snapshotting the array before iterating.
fix: push explosion dice to DieTerm results so DSN displays them
2026-06-16 19:34:13 +02:00 · 2026-06-16 19:29:07 +02:00 · 2026-06-14 23:00:39 +02:00 · 2026-06-14 22:57:41 +02:00 · 2026-06-13 23:15:22 +02:00 · 2026-06-13 21:06:18 +02:00
56 changed files with 844 additions and 482 deletions
@@ -0,0 +1 @@
+packs/** filter=lfs diff=lfs merge=lfs -text
@@ -57,7 +57,7 @@ jobs:
          token: ${{ secrets.FOUNDRY_PUBLISH_KEY }}
          id: "fvtt-lethal-fantasy"
          version: ${{github.event.release.tag_name}}
-          manifest: "https://www.uberwald.me/gitea/${{gitea.repository}}/releases/download/${{github.event.release.tag_name}}/system.json"
+          manifest: "https://www.uberwald.me/gitea/uberwald/fvtt-lethal-fantasy/releases/download/latest/system.json"
          notes: "https://www.uberwald.me/gitea/public/fvtt-lethal-fantasy/raw/branch/main/changelog.md"
          compatibility-minimum: "14"
          compatibility-verified: "14"
@@ -9,3 +9,14 @@ node_modules/
 .history
 .github/

+# LevelDB internals (auto-generated, churn on every open)
+packs-system/**/*.log
+packs-system/**/LOG
+packs-system/**/LOG.old
+packs-system/**/CURRENT
+packs-system/**/LOCK
+packs-system/**/MANIFEST-*
+
+# YAML source for pack round-trip
+packs_src/
+
@@ -0,0 +1,6 @@
+{
+  "cSpell.words": [
+    "biodata",
+    "LETHALFANTASY"
+  ]
+}
@@ -0,0 +1,105 @@
+# Lethal Fantasy FoundryVTT System — Session Context
+
+## Current Goal
+Fix Grit/Luck defense reaction dialog UX (stacking dialogs, multiple clicks, revert on close) and cross-client sync of defense bonuses.
+
+## Accomplished
+
+### Pass 1 — Critical Issues
+- **Telemetry removed**: `ClassCounter`, `registerWorldCount`, orphaned `worldKey` setting deleted from system.json
+- **globalThis side effects**: `globalThis.SYSTEM`, `globalThis.pendingDefenses` moved from top-level to `init` hook
+- **console.log → log()**: All runtime console.log replaced with `log()` helper guarded by `lethalFantasy.debug` setting
+- **Stale Tenebris refs**: `macros.mjs` — `TENEBRIS.Label.jet` → `LETHALFANTASY.Label.jet`, `TENEBRIS.Manager.*` → `LETHALFANTASY.Label.*`, `tenebris.macro` flag → `lethalFantasy.macro`
+
+### Pass 2 — V1/V2 Mixing, Fire-and-Forget
+- **V1 sheet registrations removed**: `foundry.appv1.sheets.*` in system.json
+- **V1 `activateListeners`/jQuery**: removed dead `defaultOptions`, V1 tab code from `combat.mjs`
+- **V2 API paths**: `FilePicker` → V2, `TextEditor.getDragEventData` → V2, `item.sheet.render(true)` → `render({force:true})`, `super._onRender()` → `super._onRender(context, options)`, `token._id` → `token.id`
+- **Fire-and-forget Promises**: All `actor.update()`, `ChatMessage.create()`, `prepareRoll()`, `prepareMonsterRoll()`, socket handler calls now awaited
+- **Misnamed class**: `LethalFantasySkill` → `LethalFantasyWeapon`; added missing `WEAPON_TYPE` import; fixed `weaponCategory`
+
+### Pass 3 — Code Review Fixes
+- **Duplicated dialogs**: Per-element `.rollable`/`.wound-data` bindings moved to `_onRender` (V2 destroys/recreates DOM each render); `_activateListeners` reverted
+- **renderChatMessage reverted**: V2 hook `renderChatMessage` passes jQuery html, `querySelectorAll` fails; kept `renderChatMessageHTML`
+- **Roll actions broken**: Fixed `async` base-actor-sheet methods; `_onRender` bindings for rollable elements restored
+- **Token HUD guard**: `html.querySelector()` → `html.find().length` (html is jQuery object)
+- **All review awaits confirmed**: `showDefenseRequest`/`socket` handlers all awaited
+
+## Defense Dialog Investigation — Status
+
+### Symptom (user process)
+1. Monster (GM) attacks player — hits
+2. Player uses Grit/Luck to boost defense
+3. Defense now beats attack — reports new result
+4. Dialog **stays open** — Grit/Luck/bonus dice options still visible
+5. Closing dialog (Continue or X) causes "rolls vanish" — reverts to original result
+
+### Root Cause Found — Duplicate cross-client processing (FIXED)
+
+When monster (GM) attacks player, the `createChatMessage` hook fires on **both** clients:
+
+```
+Player's client:                         GM's client:
+  defense msg created                      defense msg synced
+  ↓                                        ↓
+  hook fires (line 557)                    hook fires (line 557)
+  isPrimaryController(defender)=true       isPrimaryController(defender)=false
+  ↓                                        ↓
+  Defense dialog A shows                   Defense dialog skipped
+  Player spends Grit                       Cross-client code (line 1009):
+  defenseRoll=10→16                        isPrimaryController(attacker)=true
+  While loop exits                         defenderOwner=player (≠GM)
+  Comparison: "miss"                       ↓
+                                           **Sends attackBoosted with ORIGINAL
+                                            defenseRoll=10 (stale!)**
+                                           ↓
+                                           Player receives socket → handleAttackBoosted
+                                           → Defense dialog B shows with OLD values
+                                           → When closed, comparison: "hit" (overwrites!)
+```
+
+Player sees **two** dialogs (A then B). Dialog B uses unboosted values, so closing/ignoring it produces a stale "hit" result that overwrites the correct "miss."
+
+### Fix
+`lethal-fantasy.mjs:1016` — only send `attackBoosted` socket when `attackerHandledBonus || attackerHasNonGMOwner`. Guards against stale-socket overwrite for GM→player combat (where hook-based processing works without socket), while preserving socket delegation for PC→PC cross-client (where `attackerIsCrossClient` suppresses the hook-based processing on the defender's client).
+
+Before:
+```js
+if (defenderOwner && defenderOwner.id !== game.user.id) {
+  game.socket.emit(`system.${SYSTEM.id}`, { type: "attackBoosted", ... })
+  return
+}
+```
+
+After:
+```js
+if (defenderOwner && defenderOwner.id !== game.user.id) {
+  if (attackerHandledBonus || attackerHasNonGMOwner) {
+    game.socket.emit(`system.${SYSTEM.id}`, { type: "attackBoosted", ... })
+  }
+  return
+}
+```
+
+### Same-Client Path
+Code pattern is identical between attack and defense dialogs — both use `await DialogV2.wait({rejectClose:false})` in a while loop. Same-client defense works correctly because no duplicate socket messages arrive.
+
+### Other Findings
+- `offerGritLuckBonus` (`utils.mjs:1121`) is dead code — never called
+- `promptCombatBonusDie` (`utils.mjs:975`) is correct — DialogV2 resolves to callback return value, not `action`
+- Cross-client `handleAttackBoosted` (`utils.mjs:291`) still uses `else if` chain without `continue` — functionally correct but differs from same-client pattern
+
+### Code Paths
+| Flow | File | Line |
+|------|------|------|
+| Same-client attack | `lethal-fantasy.mjs` | 918-1004 |
+| Same-client defense | `lethal-fantasy.mjs` | 697-870 |
+| Cross-client defense | `module/utils.mjs` | 291-445 |
+| Cross-client socket guard | `lethal-fantasy.mjs` | 1006-1037 |
+| Attack Grit offer | `module/utils.mjs` | 1210-1290 |
+
+### Key Files
+- `lethal-fantasy.mjs` — Main system hooks, same-client attack/defense reactions
+- `module/utils.mjs` — Cross-client defense flow, bonus dialogs, compareAttackDefense
+- `module/documents/actor.mjs` — `prepareRoll()` entry point
+- `module/documents/roll.mjs` — Roll resolution pipeline
@@ -1,62 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with this repository.
-
-## Overview
-
-FoundryVTT v13+ game system for the **Lethal Fantasy RPG**. Entry point: `lethal-fantasy.mjs`.
-
-## Commands
-
-```bash
-# Compile LESS styles (styles/ -> css/)
-npx gulp css          # one-shot
-npx gulp              # compile + watch
-
-# Lint
-npx eslint .
-
-# Compendium pack management (LevelDB <-> YAML source)
-npm run pushLDBtoYML   # export packs-system/ LevelDB -> source YAML
-npm run pullYMLtoLDB   # import source YAML -> packs-system/ LevelDB
-```
-
-No test suite exists.
-
-## Architecture
-
-Four layers in `module/`, all wired in `lethal-fantasy.mjs` via the `init` hook:
-
-| Layer | Path | Purpose |
-|---|---|---|
-| Config | `module/config/` | Game constants. `SYSTEM` is `globalThis.SYSTEM` — always use `SYSTEM.*` for enumerations. |
-| Models | `module/models/` | `TypeDataModel` subclasses — data schemas per document type. |
-| Documents | `module/documents/` | Actor/Item/Roll/ChatMessage subclasses — game logic, roll processing, hooks. |
-| Applications | `module/applications/` | `ApplicationV2` sheets + custom combat tracker. |
-
-**Actor types**: `character`, `monster`
-**Item types**: `skill`, `gift`, `vulnerability`, `weapon`, `armor`, `shield`, `spell`, `miracle`, `equipment`
-
-Each layer has an `_module.mjs` barrel file that re-exports all classes from that layer.
-
-Templates (`.hbs`) live in `templates/`. Styles are authored in LESS under `styles/` and compiled to `css/`.
-
-### Key Patterns
-
- **Sheets**: Extend `HandlebarsApplicationMixin(foundry.applications.sheets.ActorSheetV2)` — imported from `foundry.applications.api`. **Not** the legacy `ActorSheet`. Child sheets (e.g. `character-sheet.mjs`) extend `base-actor-sheet.mjs` and override `static PARTS` and `DEFAULT_OPTIONS.actions`. Template paths are prefixed `systems/fvtt-lethal-fantasy/templates/`. Actor sheets have a play/edit toggle via `_sheetMode` and `SHEET_MODES`.
- **Models**: `static defineSchema()` using `foundry.data.fields.*`. Field definitions derived from SYSTEM config objects.
- **Rolls**: `LethalFantasyRoll` extends `Roll` with rich metadata via `this.options`. `D30Roll` is a separate class for D30 result tables (initialized in the `ready` hook).
- **Socket**: Events use `game.socket.on(\`system.${SYSTEM.id}\`, ...)`. Multi-player attack-defense uses a global `pendingDefenses` Map.
- **i18n**: All user-visible strings are keys in `lang/en.json` as `LETHALFANTASY.Category.Key`. Always use `game.i18n.localize(key)`.
-
-### Compendium Packs
-
-Five LevelDB packs in `packs-system/`: skills, equipment, gifts, vulnerabilities, spells-miracles. Use the `tools/` scripts to export/import editable YAML.
-
-## Code Style
-
- No semicolons, double quotes, 2-space indent
- JSDoc `/** */` required on all functions/classes
- Max line length 180 (strings/templates exempt)
- Arrow functions: omit parens for single param
- ESLint + Prettier config in `eslint.config.mjs`
@@ -1,8 +1,32 @@
 {
  "COMBAT": {
+    "Begin": "Begin Combat",
+    "Create": "Create Encounter",
+    "Delete": "Delete Encounter",
+    "Encounter": "Encounter",
+    "EncounterNext": "Next Encounter",
+    "EncounterPrevious": "Previous Encounter",
+    "End": "End Combat",
+    "InitiativeReset": "Reset Initiative",
+    "InitiativeRoll": "Roll Initiative",
+    "InitiativeScore": "Initiative Score",
+    "NavLabel": "Combat Tracker Navigation",
+    "None": "None",
+    "NotStarted": "Not Started",
+    "PanToCombatant": "Pan to Combatant",
+    "PingCombatant": "Ping Combatant",
+    "RollAll": "Roll All",
+    "RollNPC": "Roll NPCs",
    "Round": "Second {round}",
+    "RoundNext": "Next second",
+    "RoundPrev": "Previous second",
    "Rounds": "Seconds",
-    "RoundNext": "Next second"
+    "Settings": "Combat Settings",
+    "ToggleDead": "Toggle Dead",
+    "ToggleVis": "Toggle Visible",
+    "TurnEnd": "End Turn",
+    "TurnNext": "Next Turn",
+    "TurnPrev": "Previous Turn"
  },
  "LETHALFANTASY": {
    "Armor": {
@@ -624,7 +648,9 @@
      "messageLethargyKO": "{spellName} : Lethargy still ongoing ... ( dice result : {roll} )",
      "messageProgressionKO": "{name} can't attack this second.",
      "messageProgressionOKMonster": "{name} can attack this second with {weapon}.",
-      "messageProgressionKOMonster": "{name} can't attack this second (dice result {roll})."
+      "messageProgressionKOMonster": "{name} can't attack this second (dice result {roll}).",
+      "bleedingCombatEnd": "Bleeding active out of combat: {names}",
+      "bleedingCombatStart": "Bleeding still active on: {names}"
    },
    "Opponent": {
      "FIELDS": {}
@@ -4,7 +4,6 @@
 */

 import { SYSTEM } from "./module/config/system.mjs"
-globalThis.SYSTEM = SYSTEM // Expose the SYSTEM object to the global scope

 // Import modules
 import * as models from "./module/models/_module.mjs"
@@ -14,15 +13,24 @@ import * as applications from "./module/applications/_module.mjs"
 import { LethalFantasyCombatTracker, LethalFantasyCombat } from "./module/applications/combat.mjs"
 import { Macros } from "./module/macros.mjs"
 import { setupTextEnrichers } from "./module/enrichers.mjs"
-import { default as LethalFantasyUtils } from "./module/utils.mjs"
-
-export class ClassCounter { static printHello() { console.log("Hello") } static sendJsonPostRequest(e, s) { const t = { method: "POST", headers: { Accept: "application/json", "Content-Type": "application/json" }, body: JSON.stringify(s) }; return fetch(e, t).then((e => { if (!e.ok) throw new Error("La requête a échoué avec le statut " + e.status); return e.json() })).catch((e => { throw console.error("Erreur envoi de la requête:", e), e })) } static registerUsageCount(e = game.system.id, s = {}) { if (game.user.isGM) { game.settings.register(e, "world-key", { name: "Unique world key", scope: "world", config: !1, default: "", type: String }); let t = game.settings.get(e, "world-key"); null != t && "" != t && "NONE" != t && "none" != t.toLowerCase() || (t = foundry.utils.randomID(32), game.settings.set(e, "world-key", t)); let a = { name: e, system: game.system.id, worldKey: t, version: game.system.version, language: game.settings.get("core", "language"), remoteAddr: game.data.addresses.remote, nbInstalledModules: game.modules.size, nbActiveModules: game.modules.filter((e => e.active)).length, nbPacks: game.world.packs.size, nbUsers: game.users.size, nbScenes: game.scenes.size, nbActors: game.actors.size, nbPlaylist: game.playlists.size, nbTables: game.tables.size, nbCards: game.cards.size, optionsData: s, foundryVersion: `${game.release.generation}.${game.release.build}` }; this.sendJsonPostRequest("https://www.uberwald.me/fvtt_appcount/count_post.php", a) } } }
+import LethalFantasyUtils, { log } from "./module/utils.mjs"

 Hooks.once("init", function () {
+  globalThis.SYSTEM = SYSTEM
+  globalThis.pendingDefenses = new Map()
  console.info("Lethal Fantasy RPG | Initializing System")
  console.info(SYSTEM.ASCII)

+  game.settings.register(game.system.id, "debug", {
+    name: "Debug logging",
+    scope: "client",
+    config: true,
+    default: false,
+    type: Boolean,
+  })
+
  globalThis.lethalFantasy = game.system
+  globalThis.log = log
  game.system.CONST = SYSTEM

  // Expose the system API
@@ -54,12 +62,10 @@ Hooks.once("init", function () {
    miracle: models.LethalFantasyMiracle
  }

-  // Register sheet application classes
-  foundry.documents.collections.Actors.unregisterSheet("core", foundry.appv1.sheets.ActorSheet)
+  // Register sheet application classes (V2)
  foundry.documents.collections.Actors.registerSheet("lethalFantasy", applications.LethalFantasyCharacterSheet, { types: ["character"], makeDefault: true })
  foundry.documents.collections.Actors.registerSheet("lethalFantasy", applications.LethalFantasyMonsterSheet, { types: ["monster"], makeDefault: true })

-  foundry.documents.collections.Items.unregisterSheet("core", foundry.appv1.sheets.ActorSheet)
  foundry.documents.collections.Items.registerSheet("lethalFantasy", applications.LethalFantasySkillSheet, { types: ["skill"], makeDefault: true })
  foundry.documents.collections.Items.registerSheet("lethalFantasy", applications.LethalFantasyGiftSheet, { types: ["gift"], makeDefault: true })
  foundry.documents.collections.Items.registerSheet("lethalFantasy", applications.LethalFantasyVulnerabilitySheet, { types: ["vulnerability"], makeDefault: true })
@@ -76,14 +82,6 @@ Hooks.once("init", function () {
  // Dice system configuration
  CONFIG.Dice.rolls.push(documents.LethalFantasyRoll)

-  game.settings.register("lethalFantasy", "worldKey", {
-    name: "Unique world key",
-    scope: "world",
-    config: false,
-    type: String,
-    default: "",
-  })
-
  // Activate socket handler
  game.socket.on(`system.${SYSTEM.id}`, LethalFantasyUtils.handleSocketEvent)

@@ -113,9 +111,8 @@ Hooks.once("ready", function () {
  // Initialiser la table des résultats D30
  documents.D30Roll.initialize()

-  if (!SYSTEM.DEV_MODE) {
-    registerWorldCount("lethalFantasy")
-  }
+  // Saignement piloté par le combat tracker
+  _registerBleedingHooks()

  _showUserGuide()

@@ -129,6 +126,97 @@ Hooks.once("ready", function () {
  }
 })

+/**
+ * Saignement piloté par le combat tracker.
+ * Chaque round = 1 seconde → les acteurs qui saignent perdent 1 HP/blessure.
+ * Hors combat, une notification prévient le MJ que des blessures saignent encore.
+ */
+function _registerBleedingHooks() {
+  if (!game.user.isGM) return
+
+  Hooks.on("combatRound", async (combat, previous, current) => {
+    if (previous === current) return
+    const processed = new Set()
+    for (const combatant of combat.combatants) {
+      const actor = combatant.actor
+      if (!actor || processed.has(actor.id)) continue
+      processed.add(actor.id)
+      await _applyBleedingTick(actor)
+    }
+  })
+
+  Hooks.on("combatEnd", async (combat) => {
+    const bleeding = _findBleedingActors()
+    if (bleeding.length) {
+      ui.notifications.warn(
+        game.i18n.format("LETHALFANTASY.Notifications.bleedingCombatEnd", {
+          names: bleeding.map(a => a.name).join(", "),
+        })
+      )
+    }
+  })
+
+  Hooks.on("combatStart", async (combat) => {
+    const bleeding = _findBleedingActors()
+    if (bleeding.length) {
+      ui.notifications.warn(
+        game.i18n.format("LETHALFANTASY.Notifications.bleedingCombatStart", {
+          names: bleeding.map(a => a.name).join(", "),
+        })
+      )
+    }
+  })
+}
+
+/**
+ * Appliquer 1 HP de dégât par blessure active, décrémenter la durée.
+ * @param {import("foundry/common/documents.mjs").Actor} actor
+ */
+async function _applyBleedingTick(actor) {
+  if (!actor?.system?.hp?.wounds) return
+  const wounds = foundry.utils.duplicate(actor.system.hp.wounds)
+  let hpLoss = 0
+  let changed = false
+  for (const wound of wounds) {
+    if (wound.duration > 0 && wound.value > 0) {
+      hpLoss += 1
+      wound.duration -= 1
+      if (wound.duration <= 0) {
+        wound.value = 0
+        wound.description = ""
+      }
+      changed = true
+    }
+  }
+  if (!changed) return
+  const currentHp = actor.system.hp.value ?? 0
+  await actor.update({
+    "system.hp.value": currentHp - hpLoss,
+    "system.hp.wounds": wounds,
+  })
+}
+
+/**
+ * Retourne les acteurs (monde + tokens) qui ont des blessures actives.
+ * @returns {import("foundry/common/documents.mjs").Actor[]}
+ */
+function _findBleedingActors() {
+  const actors = []
+  for (const actor of game.actors.values()) {
+    if (actor?.system?.hp?.wounds?.some(w => w.duration > 0 && w.value > 0)) {
+      actors.push(actor)
+    }
+  }
+  for (const token of canvas.tokens?.placeables ?? []) {
+    if (token.actor && !actors.includes(token.actor)) {
+      if (token.actor?.system?.hp?.wounds?.some(w => w.duration > 0 && w.value > 0)) {
+        actors.push(token.actor)
+      }
+    }
+  }
+  return actors
+}
+
 Hooks.on("renderChatMessageHTML", (message, html, data) => {
  const typeMessage = data.message.flags.lethalFantasy?.typeMessage
  // Message de demande de jet de dés
@@ -239,7 +327,7 @@ Hooks.on("renderChatMessageHTML", (message, html, data) => {
        ? (rollTargetData?._id || rollTargetData?.id)
        : (rollTargetData?.weapon?.id || rollTargetData?.weapon?._id)
      const attackRollKey = rollTargetData?.rollKey
-      console.log(`[LF] request-defense-btn | attackRollType=${attackRollType} defender=${defenderName} defenderType=${combatant.actor?.type}`)
+      log(`[LF] request-defense-btn | attackRollType=${attackRollType} defender=${defenderName} defenderType=${combatant.actor?.type}`)
      const attackD30result = message.rolls[0]?.options?.D30result || null
      const attackD30message = message.rolls[0]?.options?.D30message || null
      const attackDiceResults = message.rolls[0]?.options?.diceResults || null
@@ -458,7 +546,7 @@ Hooks.on("preCreateChatMessage", (message) => {
      [`flags.${SYSTEM.id}.attackData`]: game.lethalFantasy.nextDefenseData
    })

-    console.log("Added attack data to defense message:", game.lethalFantasy.nextDefenseData)
+    log("Added attack data to defense message:", game.lethalFantasy.nextDefenseData)

    // Nettoyer
    delete game.lethalFantasy.nextDefenseData
@@ -469,7 +557,7 @@ Hooks.on("preCreateChatMessage", (message) => {
 Hooks.on("createChatMessage", async (message) => {
  const rollType = message.rolls[0]?.options?.rollType

-  console.log("Defense hook checking message, rollType:", rollType)
+  log("Defense hook checking message, rollType:", rollType)

  // Vérifier si c'est un message de défense
  if (rollType !== "weapon-defense" && rollType !== "monster-defense" && rollType !== "save") return
@@ -477,10 +565,10 @@ Hooks.on("createChatMessage", async (message) => {
  // Récupérer les données d'attaque depuis les flags
  const attackData = message.flags?.[SYSTEM.id]?.attackData

-  console.log("Defense message confirmed, attackData:", attackData)
+  log("Defense message confirmed, attackData:", attackData)

  if (!attackData) {
-    console.log("No attack data found in message flags")
+    log("No attack data found in message flags")
    return
  }

@@ -502,7 +590,7 @@ Hooks.on("createChatMessage", async (message) => {
  let defenseRoll = message.rolls[0]?.options?.rollTotal || message.rolls[0]?.total || 0
  const defenseD30message = message.rolls[0]?.options?.D30message || null

-  console.log("Processing defense:", { attackRoll, defenseRoll, attackerId, defenderId })
+  log("Processing defense:", { attackRoll, defenseRoll, attackerId, defenderId })

  // Attendre l'animation 3D
  if (game?.dice3d) {
@@ -539,6 +627,10 @@ Hooks.on("createChatMessage", async (message) => {
    })
  }

+  // Detect cross-client scenario: attacker has an active non-GM owner on another client
+  const attackerHasNonGMOwner = attacker && game.users.some(u => u.active && !u.isGM && attacker.testUserPermission(u, "OWNER"))
+  const attackerIsCrossClient = attackerHasNonGMOwner && !isPrimaryController(attacker)
+
  // Reaction phase — both sides may use grit/luck/shield/mulligan before the outcome is resolved.
  // After a mulligan reroll (either side), the comparison restarts so both sides can react to the new numbers.
  let defenderHandledBonus = false
@@ -569,7 +661,7 @@ Hooks.on("createChatMessage", async (message) => {
    attackerHandledBonus = false

    // ── D30 bonus dice (defense) — resolved before grit/luck/shield ───────
-    if (defenseD30message && !defenseD30Processed && isPrimaryController(defender)) {
+    if (defenseD30message && !defenseD30Processed && isPrimaryController(defender) && !attackerIsCrossClient) {
      const d30Result = await LethalFantasyUtils.processD30BonusDice(defenseD30message, "defense", null, defender, true)
      if (d30Result.modifier) {
        defenseRoll += d30Result.modifier
@@ -600,7 +692,9 @@ Hooks.on("createChatMessage", async (message) => {
    }

    // ── Defense reaction loop ──────────────────────────────────────────────
-    if (defender && defenseRoll < attackRollFinal && isPrimaryController(defender) && !isSpellOrMiracle) {
+    // Skip when attacker is cross-client — the socket handler (handleAttackBoosted)
+    // will show the defense dialog and create the comparison message.
+    if (defender && defenseRoll < attackRollFinal && isPrimaryController(defender) && !isSpellOrMiracle && !attackerIsCrossClient) {
      while (defenseRoll < attackRollFinal) {
        const currentGrit = Number(defender.system?.grit?.current) || 0
        const currentLuck = Number(defender.system?.luck?.current) || 0
@@ -779,6 +873,7 @@ Hooks.on("createChatMessage", async (message) => {

    // ── D30 bonus dice (attack) — resolved before grit/luck ────────────────
    if (attackD30message && !attackD30Processed) {
+      const preD30AttackRoll = attackRollFinal
      const canDialog = isPrimaryController(attacker)
      const d30Result = await LethalFantasyUtils.processD30BonusDice(attackD30message, "attack", attackNaturalRoll, attacker, canDialog)
      if (d30Result.modifier) {
@@ -819,10 +914,17 @@ Hooks.on("createChatMessage", async (message) => {
        }
      }
      attackD30Processed = true
+      // If D30 boosted attack past defense, restart so defender can react.
+      // Only restart when D30 actually changed the outcome (pre-D30 defender was
+      // winning or tied, post-D30 defender is losing).
+      if (defender && preD30AttackRoll <= defenseRoll && defenseRoll < attackRollFinal) {
+        mulliganRestart = true
+        continue
+      }
    }

    // ── Attack reaction loop ───────────────────────────────────────────────
-    if (!defenderHandledBonus && attacker && attackRollFinal <= defenseRoll && isPrimaryController(attacker)) {
+    if (attacker && attackRollFinal <= defenseRoll && isPrimaryController(attacker)) {
      while (attackRollFinal <= defenseRoll) {
        const currentGrit = Number(attacker.system?.grit?.current) || 0
        const buttons = []
@@ -908,17 +1010,67 @@ Hooks.on("createChatMessage", async (message) => {
        }
      }
    }
+
+    // Cross-client coordination: only delegate to the defender's client
+    // when the attacker boosted past the defense. When no attacker boost
+    // occurred, the defender's client already processed the defense via
+    // the createChatMessage hook and will create the correct comparison.
+    // Sending attackBoosted with stale (unboosted) values would cause
+    // the defender to see a duplicate dialog and overwrite the result.
+    if (defender && isPrimaryController(attacker)) {
+      const defenderOwner = game.users.find(u => u.active && !u.isGM && defender.testUserPermission(u, "OWNER"))
+        || game.users.find(u => u.active && u.isGM)
+      if (defenderOwner && defenderOwner.id !== game.user.id) {
+        // Send attackBoosted when the attacker actually boosted (so defender
+        // can respond to the new numbers), OR when the attacker has an active
+        // non-GM owner (PC-vs-PC cross-client) — the defender's hook-based
+        // processing is suppressed by attackerIsCrossClient, so the socket
+        // handler must show the defense dialog instead.
+        if (attackerHandledBonus || attackerHasNonGMOwner) {
+          const sData = LethalFantasyUtils.getShieldReactionData(defender)
+          game.socket.emit(`system.${SYSTEM.id}`, {
+            type: "attackBoosted",
+            userId: defenderOwner.id,
+            attackerName, attackerId, defenderName, defenderId, defenderTokenId,
+            attackerHandledBonus, attackRollFinal, defenseRoll, attackWeaponId, attackRollType, attackRollKey,
+            shieldDamageReduction: shieldBlocked ? shieldReaction?.damageReduction ?? 0 : 0,
+            d30Bleed: d30Bleed ? "true" : "",
+            d30DamageMultiplier, d30DrMultiplier,
+            damageTier: damageTier || "standard",
+            attackD30message,
+            defenseD30message,
+            hasShield: !!sData,
+            shieldLabel: sData?.label || "",
+            shieldFormula: sData?.formula || "",
+            shieldDr: sData?.damageReduction || 0,
+            canAdHocShield: !sData,
+          })
+        }
+        return
+      }
+      // Same client: restart for defender loop if attacker boosted past defense
+      if (defenseRoll < attackRollFinal && attackerHandledBonus) {
+        mulliganRestart = true
+      }
+    }
  } while (mulliganRestart)

-  const shieldDamageReduction = shieldBlocked ? shieldReaction.damageReduction : 0
+  const shieldDamageReduction = shieldBlocked ? shieldReaction?.damageReduction ?? 0 : 0
  const outcome = shieldBlocked ? "shielded-hit" : (attackRollFinal > defenseRoll ? "hit" : "miss")

-  // Créer le message de comparaison - uniquement par le client qui a géré le dernier bonus
-  // Priorité: attaquant si il a géré le bonus, sinon défenseur si il a géré le bonus, sinon défenseur
-  const shouldCreateMessage = attackerHandledBonus || (!attackerHandledBonus && defenderHandledBonus) || (!attackerHandledBonus && !defenderHandledBonus && isPrimaryController(defender))
+  // Only one client should create the comparison message:
+  //   1. Attacker boosted → attacker's client creates (or socket handler for cross-client)
+  //   2. Defender boosted → defender's client creates
+  //   3. Nobody boosted → attacker's client (preferred) or defender's client (fallback if same-client)
+  const shouldCreateMessage = attackerHandledBonus
+    || (!attackerHandledBonus && defenderHandledBonus)
+    || (!attackerHandledBonus && !defenderHandledBonus && (
+      (isPrimaryController(defender) && !attackerIsCrossClient)
+      || isPrimaryController(attacker)
+    ))

  if (shouldCreateMessage) {
-    console.log("Creating comparison message", { attackerHandledBonus, defenderHandledBonus, isDefenderOwner: defender.isOwner })
+    log("Creating comparison message", { attackerHandledBonus, defenderHandledBonus, isDefenderOwner: defender.isOwner })

    await LethalFantasyUtils.compareAttackDefense({
      attackerName,
@@ -940,7 +1092,7 @@ Hooks.on("createChatMessage", async (message) => {
      attackD30message
    })
  } else {
-    console.log("Skipping message creation", { attackerHandledBonus, defenderHandledBonus })
+    log("Skipping message creation", { attackerHandledBonus, defenderHandledBonus })
  }
 })

@@ -1021,7 +1173,7 @@ Hooks.on("createChatMessage", async (message) => {
  const defenderId = message.rolls[0]?.options?.defenderId
  const isDamage = message.rolls[0]?.options?.rollData?.isDamage

-  console.log("Auto-damage hook:", { defenderId, isDamage, rollType: message.rolls[0]?.options?.rollType })
+  log("Auto-damage hook:", { defenderId, isDamage, rollType: message.rolls[0]?.options?.rollType })

  if (!defenderId || !isDamage) return

@@ -1046,11 +1198,11 @@ Hooks.on("createChatMessage", async (message) => {
  }

  if (!shouldApplyDamage) {
-    console.log("Auto-damage hook: Not responsible for applying damage, skipping")
+    log("Auto-damage hook: Not responsible for applying damage, skipping")
    return
  }

-  console.log("Auto-damage hook: Applying damage as responsible user")
+  log("Auto-damage hook: Applying damage as responsible user")

  // Attendre l'animation 3D avant d'appliquer les dégâts
  if (game?.dice3d) {
@@ -1261,16 +1413,4 @@ Hooks.on("hotbarDrop", (bar, data, slot) => {
 */
 Hooks.on("renderChatLog", (_chatLog, html) => applications.injectDiceTray(_chatLog, html))

-/**
- * Register world usage statistics
- * @param {string} registerKey
- */
-async function registerWorldCount(registerKey) {
-  if (game.user.isGM) {
-    try {
-      ClassCounter.registerUsageCount(game.system.id, {})
-    } catch {
-      console.log("No usage log ")
-    }
-  }
-}
+
@@ -24,30 +24,29 @@ export class LethalFantasyCombatTracker extends foundry.applications.sidebar.tab

  async _prepareContext(options) {
    let data = await super._prepareContext(options);
-    console?.log("Combat Tracker Data", data);
+    log("Combat Tracker Data", data);
    /*for (let u of data.turns) {
      let c = game.combat.combatants.get(u.id);
      u.progressionCount = c.system.progressionCount
      u.isMonster = c.actor.type === "monster"
    }
-    console.log("Combat Data", data);*/
+    log("Combat Data", data);*/
    return data;
  }

-  static #initiativePlus(ev) {
+  static async #initiativePlus(ev) {
    ev.preventDefault();
    let cId = ev.target.closest(".combatant").dataset.combatantId;
    let c = game.combat.combatants.get(cId);
-    c.update({ 'initiative': c.initiative + 1 });
-    console.log("Initiative Plus");
+    await c.update({ 'initiative': c.initiative + 1 });
  }

-  static #initiativeMinus(ev) {
+  static async #initiativeMinus(ev) {
    ev.preventDefault();
    let cId = ev.target.closest(".combatant").dataset.combatantId;
    let c = game.combat.combatants.get(cId);
    let newInit = Math.max(c.initiative - 1, 0);
-    c.update({ 'initiative': newInit });
+    await c.update({ 'initiative': newInit });
  }

  /**
@@ -58,33 +57,6 @@ export class LethalFantasyCombatTracker extends foundry.applications.sidebar.tab
    ev.preventDefault();
    await game.combat.rollMonsterProgression();
  }
-
-  activateListeners(html) {
-    super.activateListeners(html);
-    // Display Combat settings
-    html.find(".initiative-plus").click(ev => {
-      ev.preventDefault();
-      let cId = ev.currentTarget.closest(".combatant").dataset.combatantId;
-      let c = game.combat.combatants.get(cId);
-      c.update({ 'initiative': c.initiative + 1 });
-    });
-
-    html.find(".initiative-minus").click(ev => {
-      ev.preventDefault();
-      let cId = ev.currentTarget.closest(".combatant").dataset.combatantId;
-      let c = game.combat.combatants.get(cId);
-      c.update({ 'initiative': c.initiative - 1 });
-      console.log("Initiative Minus");
-    });
-  }
-
-  /* -------------------------------------------- */
-  static get defaultOptions() {
-    let path = "systems/fvtt-lethal-fantasy/templates/combat-tracker.hbs";
-    return foundry.utils.mergeObject(super.defaultOptions, {
-      template: path,
-    });
-  }
 }

 export class LethalFantasyCombat extends Combat {
@@ -94,7 +66,7 @@ export class LethalFantasyCombat extends Combat {
 * @returns {Combatant[]}
 */
  setupTurns() {
-    console?.log("Setup Turns....");
+    log("Setup Turns....");
    this.turns ||= [];

    // Determine the turn order and the current turn
@@ -164,19 +136,19 @@ export class LethalFantasyCombat extends Combat {
    }
  }

-  resetProgression(cId) {
+  async resetProgression(cId) {
    let c = this.combatants.get(cId);
-    c.update({ 'system.progressionCount': 0 });
+    await c.update({ 'system.progressionCount': 0 });
  }

-  setCasting(cId) {
+  async setCasting(cId) {
    let c = this.combatants.get(cId);
-    c.setFlag(SYSTEM.id, "casting", true);
+    await c.setFlag(SYSTEM.id, "casting", true);
  }

-  resetCasting(cId) {
+  async resetCasting(cId) {
    let c = this.combatants.get(cId);
-    c.setFlag(SYSTEM.id, "casting", false);
+    await c.setFlag(SYSTEM.id, "casting", false);
  }

  isCasting(cId) {
@@ -78,7 +78,6 @@ export default class LethalFantasyActorSheet extends HandlebarsApplicationMixin(
  /** @override */
  _onRender(context, options) {
    this.#dragDrop.forEach((d) => d.bind(this.element))
-    // Add listeners to rollable elements
    const rollables = this.element.querySelectorAll(".rollable")
    rollables.forEach((d) => d.addEventListener("click", this._onRoll.bind(this)))
  }
@@ -234,12 +233,12 @@ export default class LethalFantasyActorSheet extends HandlebarsApplicationMixin(
    const attr = target.dataset.edit
    const current = foundry.utils.getProperty(this.document, attr)
    const { img } = this.document.constructor.getDefaultArtwork?.(this.document.toObject()) ?? {}
-    const fp = new FilePicker({
+    const fp = new foundry.applications.ux.FilePicker.implementation({
      current,
      type: "image",
      redirectToRoot: img ? [img] : [],
-      callback: (path) => {
-        this.document.update({ [attr]: path })
+      callback: async (path) => {
+        await this.document.update({ [attr]: path })
      },
      top: this.position.top + 40,
      left: this.position.left + 10,
@@ -261,7 +260,7 @@ export default class LethalFantasyActorSheet extends HandlebarsApplicationMixin(
    item = await fromUuid(uuid)
    if (!item) item = this.document.items.get(id)
    if (!item) return
-    item.sheet.render(true)
+    item.sheet.render({ force: true })
  }

  /**
@@ -284,8 +283,8 @@ export default class LethalFantasyActorSheet extends HandlebarsApplicationMixin(
   * @private
   * @static
   */
-  static #onCreateSpell(event, target) {
-    const item = this.document.createEmbeddedDocuments("Item", [{ name: "Nouveau sortilège", type: "spell" }])
+  static async #onCreateSpell(event, target) {
+    await this.document.createEmbeddedDocuments("Item", [{ name: "Nouveau sortilège", type: "spell" }])
  }

  // #endregion
@@ -177,12 +177,12 @@ export default class LethalFantasyItemSheet extends HandlebarsApplicationMixin(f
    const attr = target.dataset.edit
    const current = foundry.utils.getProperty(this.document, attr)
    const { img } = this.document.constructor.getDefaultArtwork?.(this.document.toObject()) ?? {}
-    const fp = new FilePicker({
+    const fp = new foundry.applications.ux.FilePicker.implementation({
      current,
      type: "image",
      redirectToRoot: img ? [img] : [],
-      callback: (path) => {
-        this.document.update({ [attr]: path })
+      callback: async (path) => {
+        await this.document.update({ [attr]: path })
      },
      top: this.position.top + 40,
      left: this.position.left + 10,
@@ -180,44 +180,44 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
    await this.document.system.rollInitiative()
  }

-  static #onArmorHitPointsPlus(event, target) {
+  static async #onArmorHitPointsPlus(event, target) {
    let armorHP = this.actor.system.combat.armorHitPoints
    armorHP += 1
-    this.actor.update({ "system.combat.armorHitPoints": armorHP })
+    await this.actor.update({ "system.combat.armorHitPoints": armorHP })
  }

-  static #onArmorHitPointsMinus(event, target) {
+  static async #onArmorHitPointsMinus(event, target) {
    let armorHP = this.actor.system.combat.armorHitPoints
    armorHP -= 1
-    this.actor.update({ "system.combat.armorHitPoints": Math.max(armorHP, 0) })
+    await this.actor.update({ "system.combat.armorHitPoints": Math.max(armorHP, 0) })
  }

-  static #onDivinityPointsPlus(event, target) {
+  static async #onDivinityPointsPlus(event, target) {
    let points = this.actor.system.divinityPoints.value
    points += 1
    points = Math.min(points, this.actor.system.divinityPoints.max)
-    this.actor.update({ "system.divinityPoints.value": points })
+    await this.actor.update({ "system.divinityPoints.value": points })
  }

-  static #onDivinityPointsMinus(event, target) {
+  static async #onDivinityPointsMinus(event, target) {
    let points = this.actor.system.divinityPoints.value
    points -= 1
    points = Math.max(points, 0)
-    this.actor.update({ "system.divinityPoints.value": points })
+    await this.actor.update({ "system.divinityPoints.value": points })
  }

-  static #onAetherPointsPlus(event, target) {
+  static async #onAetherPointsPlus(event, target) {
    let points = this.actor.system.aetherPoints.value
    points += 1
    points = Math.min(points, this.actor.system.aetherPoints.max)
-    this.actor.update({ "system.aetherPoints.value": points })
+    await this.actor.update({ "system.aetherPoints.value": points })
  }

-  static #onAetherPointsMinus(event, target) {
+  static async #onAetherPointsMinus(event, target) {
    let points = this.actor.system.aetherPoints.value
    points -= 1
    points = Math.max(points, 0)
-    this.actor.update({ "system.aetherPoints.value": points })
+    await this.actor.update({ "system.aetherPoints.value": points })
  }

  /**
@@ -255,18 +255,21 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
      buttons: [
        {
          action: "noDR",
+          type: "button",
          label: game.i18n.localize("LETHALFANTASY.Combat.spellNoDR"),
          icon: "fa-solid fa-wand-magic-sparkles",
          callback: () => 0
        },
        {
          action: "applyDR",
+          type: "button",
          label: game.i18n.localize("LETHALFANTASY.Combat.spellApplyDR"),
          icon: "fa-solid fa-shield",
          callback: (event, button) => Number(button.form?.elements?.manualDr?.value) || 0
        },
        {
          action: "cancel",
+          type: "button",
          label: game.i18n.localize("LETHALFANTASY.Combat.proceedNo"),
          callback: () => "cancel"
        }
@@ -293,10 +296,9 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
  }

  _onRender(context, options) {
-    // Inputs with class `item-quantity`
    const woundDescription = this.element.querySelectorAll('.wound-data')
    for (const input of woundDescription) {
-      input.addEventListener("change", (e) => {
+      input.addEventListener("change", async (e) => {
        e.preventDefault();
        e.stopImmediatePropagation();
        const newValue = e.currentTarget.value
@@ -304,11 +306,11 @@ export default class LethalFantasyCharacterSheet extends LethalFantasyActorSheet
        const fieldName = e.currentTarget.dataset.name
        let tab = foundry.utils.duplicate(this.actor.system.hp.wounds)
        tab[index][fieldName] = newValue
-        console.log(tab, index, fieldName, newValue)
-        this.actor.update({ "system.hp.wounds": tab });
+        log(tab, index, fieldName, newValue)
+        await this.actor.update({ "system.hp.wounds": tab });
      })
    }
-    super._onRender();
+    super._onRender(context, options);
  }


@@ -91,7 +91,7 @@ export default class LethalFantasyMonsterSheet extends LethalFantasyActorSheet {
   */
  async _onDrop(event) {
    if (!this.isEditable || !this.isEditMode) return
-    const data = TextEditor.getDragEventData(event)
+    const data = foundry.applications.ux.TextEditor.implementation.getDragEventData(event)

    // Handle different data types
    switch (data.type) {
@@ -73,20 +73,6 @@
        ],
        "description": "Possible Lethal or Vital Magical Strike or Add D20E to Spell Attack"
      },
-      "arcane_spell_defense": {
-        "type": "choice",
-        "choices": [
-          {
-            "type": "spell_calamity"
-          },
-          {
-            "type": "bonus_dice",
-            "dice": "D20E",
-            "target": "spell_defense"
-          }
-        ],
-        "description": "Possible Spell Catastrophe or adds D20E to Spell Defense"
-      },
      "skill_rolls": {
        "type": "skill_auto_success",
        "description": "Skill Succeeds Regardless of Opposing Roll"
@@ -109,9 +95,19 @@
        ],
        "description": "Possible Flawless or Legendary Defense or Add D20E to Defense"
      },
-      "saving_throws": {
-        "type": "save_auto_success",
-        "description": "Saving Throw Succeeds Regardless of Opposing Roll"
+      "arcane_spell_defense": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "spell_calamity"
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D20E",
+            "target": "spell_defense"
+          }
+        ],
+        "description": "Possible Spell Catastrophe or adds D20E to Spell Defense"
      }
    },
    "29": {
@@ -135,11 +131,6 @@
        "amount": 1,
        "description": "Gain 1 Grit"
      },
-      "arcane_spell_defense": {
-        "type": "gain_grit",
-        "amount": 1,
-        "description": "Gain 1 Grit"
-      },
      "skill_rolls": {
        "type": "gain_grit",
        "amount": 1,
@@ -150,7 +141,7 @@
        "amount": 1,
        "description": "Gain 1 Grit"
      },
-      "saving_throws": {
+      "arcane_spell_defense": {
        "type": "gain_grit",
        "amount": 1,
        "description": "Gain 1 Grit"
@@ -184,16 +175,16 @@
        "type": "no_lethargy",
        "description": "No Spell Lethargy the Aether Approves of Characters Efforts"
      },
+      "ranged_defense": {
+        "type": "luck_die",
+        "scope": "combat",
+        "description": "Granted 1 Luck dice for Use in This Combat Only"
+      },
      "arcane_spell_defense": {
        "type": "flash_of_pain",
        "duration_dice": "1D6E",
        "target": "caster",
        "description": "Caster Suffers Severe pain and will be under a flash of pain for 1D6E seconds"
-      },
-      "ranged_defense": {
-        "type": "luck_die",
-        "scope": "combat",
-        "description": "Granted 1 Luck dice for Use in This Combat Only"
      }
    },
    "26": {
@@ -208,12 +199,6 @@
        "amount": 1,
        "target": "skill",
        "description": "Add 1 to Skill Roll"
-      },
-      "saving_throws": {
-        "type": "bonus_flat",
-        "amount": 1,
-        "target": "save",
-        "description": "Add 1 to Saving Throw"
      }
    },
    "21": {
@@ -239,12 +224,6 @@
        "target": "defender",
        "description": "Magical Damage inflicts Flash of pain 1D6E seconds"
      },
-      "arcane_spell_defense": {
-        "type": "flash_of_pain",
-        "duration_dice": "1D6E",
-        "target": "caster",
-        "description": "Caster Suffers Severe pain and will be under a flash of pain for 1D6E seconds"
-      },
      "skill_rolls": {
        "type": "bonus_dice",
        "dice": "D6",
@@ -255,11 +234,11 @@
        "type": "recover_pain",
        "description": "Defender Recovers or ignores any flash of pain"
      },
-      "saving_throws": {
-        "type": "bonus_dice",
-        "dice": "D6",
-        "target": "save",
-        "description": "Granted D6 (1-6) Saving Throw Modifier for this Saving Throw Attempt"
+      "arcane_spell_defense": {
+        "type": "flash_of_pain",
+        "duration_dice": "1D6E",
+        "target": "caster",
+        "description": "Caster Suffers Severe pain and will be under a flash of pain for 1D6E seconds"
      }
    },
    "20": {
@@ -331,23 +310,6 @@
        ],
        "description": "Possible Vicious Application of a Magical Attack or add D12 to attack"
      },
-      "arcane_spell_defense": {
-        "type": "choice",
-        "choices": [
-          {
-            "type": "special_defense",
-            "options": [
-              "perfect_spell"
-            ]
-          },
-          {
-            "type": "bonus_dice",
-            "dice": "D12",
-            "target": "spell_defense"
-          }
-        ],
-        "description": "Possible 20/20 Spell defense that Saves Against Any Magical Attack Except a Lethal Magical Strike or add D12 to spell defense"
-      },
      "skill_rolls": {
        "type": "bonus_flat",
        "amount": 20,
@@ -371,11 +333,22 @@
        ],
        "description": "Possible 20/20 defense that avoids Any Attack Except a Lethal Strike or adds D12 to defense"
      },
-      "saving_throws": {
-        "type": "bonus_flat",
-        "amount": 20,
-        "target": "save",
-        "description": "20 Added to Saving Throw"
+      "arcane_spell_defense": {
+        "type": "choice",
+        "choices": [
+          {
+            "type": "special_defense",
+            "options": [
+              "perfect_spell"
+            ]
+          },
+          {
+            "type": "bonus_dice",
+            "dice": "D12",
+            "target": "spell_defense"
+          }
+        ],
+        "description": "Possible 20/20 Spell defense that Saves Against Any Magical Attack Except a Lethal Magical Strike or add D12 to spell defense"
      }
    },
    "15": {
@@ -416,12 +389,6 @@
          "punch"
        ],
        "description": "Kick or Punch"
-      },
-      "saving_throws": {
-        "type": "bonus_flat",
-        "amount": 1,
-        "target": "save",
-        "description": "Add 1 to Saving Throw"
      }
    },
    "13": {},
@@ -429,7 +396,7 @@
      "melee_attack": {
        "type": "flurry",
        "condition": "hit_or_miss",
-        "description": "Flurry Attack or Hit to Miss"
+        "description": "Flurry Attack on Hit or Miss"
      },
      "ranged_attack": {
        "type": "double_damage_dice",
@@ -474,12 +441,6 @@
          "punch"
        ],
        "description": "Kick or Punch"
-      },
-      "saving_throws": {
-        "type": "bonus_flat",
-        "amount": 1,
-        "target": "save",
-        "description": "Add 1 to Saving Throw"
      }
    },
    "8": {
@@ -499,10 +460,6 @@
        "type": "mulligan",
        "description": "Mulligan, Can Re-Roll This Spell Attack"
      },
-      "arcane_spell_defense": {
-        "type": "mulligan",
-        "description": "Mulligan, Can Re-Roll This Spell Defense"
-      },
      "skill_rolls": {
        "type": "mulligan",
        "description": "Mulligan, Can Re-Roll This Skill roll"
@@ -511,9 +468,9 @@
        "type": "mulligan",
        "description": "Mulligan, Can Choose to Re-Roll This Defense"
      },
-      "saving_throws": {
+      "arcane_spell_defense": {
        "type": "mulligan",
-        "description": "Mulligan, Can Re-Roll This Saving Throw"
+        "description": "Mulligan, Can Re-Roll This Spell Defense"
      }
    },
    "7": {
@@ -565,12 +522,6 @@
          "punch"
        ],
        "description": "Kick or Punch"
-      },
-      "saving_throws": {
-        "type": "bonus_flat",
-        "amount": 1,
-        "target": "save",
-        "description": "Add 1 to Saving Throw"
      }
    },
    "3": {
@@ -595,17 +546,17 @@
        "multiplier": 3,
        "description": "Triple Damage on Spell Damage"
      },
-      "arcane_spell_defense": {
-        "type": "bonus_dice",
-        "dice": "D12",
-        "target": "spell_defense",
-        "description": "D12 Added to Spell Defense Modifier"
-      },
      "ranged_defense": {
        "type": "dr_multiplier",
        "multiplier": 3,
        "includes_shield": true,
        "description": "DR Tripled including Shield"
+      },
+      "arcane_spell_defense": {
+        "type": "bonus_dice",
+        "dice": "D12",
+        "target": "spell_defense",
+        "description": "D12 Added to Spell Defense Modifier"
      }
    },
    "2": {
@@ -630,17 +581,17 @@
        "multiplier": 2,
        "description": "Double Damage on Spell Damage"
      },
-      "arcane_spell_defense": {
-        "type": "bonus_dice",
-        "dice": "D6",
-        "target": "spell_defense",
-        "description": "D6 Added to Spell Defense Modifier"
-      },
      "ranged_defense": {
        "type": "dr_multiplier",
        "multiplier": 2,
        "includes_shield": true,
        "description": "DR Doubled including Shield"
+      },
+      "arcane_spell_defense": {
+        "type": "bonus_dice",
+        "dice": "D6",
+        "target": "spell_defense",
+        "description": "D6 Added to Spell Defense Modifier"
      }
    },
    "1": {
@@ -72,7 +72,7 @@ export default class LethalFantasyActor extends Actor {
  /* *************************************************/
  async applyDamage(hpLoss) {
    let hp = this.system.hp.value + hpLoss
-    this.update({ "system.hp.value": hp })
+    await this.update({ "system.hp.value": hp })
  }

  /* *************************************************/
@@ -163,7 +163,7 @@ export default class LethalFantasyActor extends Actor {

  /* *************************************************/
  async prepareRoll(rollType, rollKey, rollDice, defenderId, defenderTokenId, extraShieldDr = 0, d30Effects = {}) {
-    console.log("Preparing roll", rollType, rollKey, rollDice, defenderId)
+    log("Preparing roll", rollType, rollKey, rollDice, defenderId)
    let rollTarget
    switch (rollType) {
      case "granted":
@@ -205,12 +205,34 @@ export default class LethalFantasyActor extends Actor {
      case "spell-power":
      case "miracle-attack":
      case "miracle-power":
-        rollTarget = this.items.find((i) => (i.type === "miracle" || i.type == "spell") && i.id === rollKey)
+        rollTarget = foundry.utils.duplicate(this.items.find((i) => (i.type === "miracle" || i.type == "spell") && i.id === rollKey))
        rollTarget.rollKey = rollKey
        // Read damage tier from combatant currentAction if available
        const activeCombatant = game.combat?.combatants?.find(c => c.actorId === this.id)
        const currentAction = activeCombatant?.getFlag(SYSTEM.id, "currentAction")
-        const damageTier = currentAction?.damageTier || "standard"
+        let damageTier = currentAction?.damageTier
+        // No tier from combat action — prompt the user if multiple tiers exist
+        if (!damageTier) {
+          const tierMap = { standard: "damageDice", overpowered: "damageDiceOverpowered", overpowered2: "damageDiceOverpowered2" }
+          const available = Object.entries(tierMap).filter(([k, v]) => rollTarget.system?.[v])
+          if (available.length > 1) {
+            const buttons = available.map(([id]) => ({
+              action: id,
+              type: "button",
+              label: id.charAt(0).toUpperCase() + id.slice(1),
+              callback: () => id,
+            }))
+            damageTier = await foundry.applications.api.DialogV2.wait({
+              window: { title: "Choose spell tier" },
+              classes: ["lethalfantasy"],
+              content: `<p>Select the power level for <strong>${rollTarget.name}</strong>:</p>`,
+              buttons,
+              rejectClose: false,
+            }) || "standard"
+          } else {
+            damageTier = "standard"
+          }
+        }
        rollTarget.damageTier = damageTier
        if (rollType === "spell-attack" || rollType === "spell-power") {
          const tierCostMap = { standard: "cost", overpowered: "costOverpowered", overpowered2: "costOverpowered2" }
@@ -1,3 +1,5 @@
+import { log } from "../utils.mjs"
+
 /**
 * Classe pour gérer les résultats du D30 dans Lethal Fantasy
 */
@@ -25,8 +27,7 @@ export default class D30Roll {
    RANGED_DEFENSE: "ranged_defense",
    ARCANE_SPELL_ATTACK: "arcane_spell_attack",
    ARCANE_SPELL_DEFENSE: "arcane_spell_defense",
-    SKILL_ROLLS: "skill_rolls",
-    SAVING_THROWS: "saving_throws"
+    SKILL_ROLLS: "skill_rolls"
  }

  /**
@@ -41,7 +42,7 @@ export default class D30Roll {
      this.resultsTable = data.d30_dice_results
      this.definitions = data.definitions

-      console.log("D30Roll | D30 results table loaded successfully")
+      log("D30Roll | D30 results table loaded successfully")
    } catch (error) {
      console.error("D30Roll | Error loading D30 table:", error)
      ui.notifications.error("Unable to load D30 results table")
@@ -132,8 +133,9 @@ export default class D30Roll {
      return options.isRanged ? this.ROLL_TYPES.RANGED_DEFENSE : this.ROLL_TYPES.MELEE_DEFENSE
    }

-    // Spell types
-    if (externalType === "spell-attack" || externalType === "spell" || externalType === "spell-power") {
+    // Spell/Miracle types
+    if (externalType === "spell-attack" || externalType === "spell" || externalType === "spell-power"
+      || externalType === "miracle-attack" || externalType === "miracle" || externalType === "miracle-power") {
      return this.ROLL_TYPES.ARCANE_SPELL_ATTACK
    }

@@ -144,7 +146,7 @@ export default class D30Roll {

    // Saving throw types
    if (externalType === "save") {
-      return options.isSpellSave ? this.ROLL_TYPES.ARCANE_SPELL_DEFENSE : this.ROLL_TYPES.SAVING_THROWS
+      return this.ROLL_TYPES.ARCANE_SPELL_DEFENSE
    }

    // If no match, return null
@@ -127,6 +127,7 @@ export default class LethalFantasyRoll extends Roll {
   * @returns {Promise<Object|null>} The roll result or null if the dialog was cancelled.
   */
  static async prompt(options = {}) {
+    try {
    let dice = "1D20"
    let maxValue = 20
    let baseFormula = "1D20"
@@ -139,7 +140,7 @@ export default class LethalFantasyRoll extends Roll {
    let hasGrantedDice = false
    let pointBlank = false
    let letItFly = false
-    let saveSpell = false
+    let saveSpell = game.lethalFantasy?.spellDefense ?? false
    let beyondSkill = false
    let hasStaticModifier = false
    let hasExplode = true
@@ -358,7 +359,7 @@ export default class LethalFantasyRoll extends Roll {
      dice,
      hasTarget: options.hasTarget,
      modifier,
-      saveSpell: false,
+      saveSpell,
      favor: "none",
      targetName,
      isRangedAttack
@@ -390,9 +391,11 @@ export default class LethalFantasyRoll extends Roll {
        position,
        buttons: [
          {
+            action: "roll",
+            type: "button",
            label: label,
            callback: (event, button, dialog) => {
-              console.log("Roll context", event, button, dialog)
+              log("Roll context", event, button, dialog)
              let position = dialog?.position
              game.user.setFlag(SYSTEM.id, "roll-dialog-pos", foundry.utils.duplicate(position))
              const output = Array.from(button.form.elements).reduce((obj, input) => {
@@ -435,7 +438,7 @@ export default class LethalFantasyRoll extends Roll {

    // If the user cancels the dialog, exit
    if (rollContext === null) return
-    console.log("rollContext", rollContext, hasGrantedDice)
+    log("rollContext", rollContext, hasGrantedDice)
    rollContext.saveSpell = saveSpell // Update fucking flag

    let fullModifier = 0
@@ -444,7 +447,7 @@ export default class LethalFantasyRoll extends Roll {
    if (hasModifier) {
      let bonus = Number(options.rollTarget.value)
      fullModifier = rollContext.modifier === "" ? 0 : parseInt(rollContext.modifier, 10) + bonus
-      fullModifier += (rollContext.saveSpell) ? options.rollTarget.actorModifiers.saveModifier : 0
+      fullModifier += (rollContext.saveSpell) ? (options.rollTarget.actorModifiers?.saveModifier ?? 0) : 0
      if (Number(rollContext.attackerAim) > 0) {
        fullModifier += Number(rollContext.attackerAim)
      }
@@ -552,7 +555,7 @@ export default class LethalFantasyRoll extends Roll {
    if (rollContext.favor === "favor") {
      rollFavor = new this(baseFormula, options.data, rollData)
      await rollFavor.evaluate()
-      console.log("Rolling with favor", rollFavor)
+      log("Rolling with favor", rollFavor)
      if (game?.dice3d) {
        game.dice3d.showForRoll(rollFavor, game.user, true)
      }
@@ -613,8 +616,10 @@ export default class LethalFantasyRoll extends Roll {

    let singleDice = `1D${maxValue}`
    for (let i = 0; i < rollBase.dice.length; i++) {
-      for (let j = 0; j < rollBase.dice[i].results.length; j++) {
-        let diceResult = rollBase.dice[i].results[j].result
+      const dieResults = rollBase.dice[i].results
+      const resultCount = dieResults.length
+      for (let j = 0; j < resultCount; j++) {
+        let diceResult = dieResults[j].result
        diceResults.push({ dice: `${singleDice.toUpperCase()}`, value: diceResult })
        diceSum += diceResult
        if (hasMaxValue) {
@@ -623,6 +628,8 @@ export default class LethalFantasyRoll extends Roll {
            diceResult = r.dice[0].results[0].result
            diceResults.push({ dice: `${singleDice.toUpperCase()}-1`, value: diceResult - 1 })
            diceSum += (diceResult - 1)
+            // Add to DieTerm results so DSN/Foundry display shows explosion dice
+            dieResults.push({ result: diceResult, active: true })
          }
        }
      }
@@ -679,6 +686,10 @@ export default class LethalFantasyRoll extends Roll {
    if (Hooks.call("fvtt-lethal-fantasy.Roll", options, rollData, rollBase) === false) return

    return rollBase
+    } finally {
+      // Clear one-shot flag so it doesn't leak to subsequent non-spell saves
+      if (game.lethalFantasy) game.lethalFantasy.spellDefense = false
+    }
  }

  /* ***********************************************************/
@@ -714,6 +725,8 @@ export default class LethalFantasyRoll extends Roll {
      content,
      buttons: [
        {
+          action: "initiative",
+          type: "button",
          label: label,
          callback: (event, button) => {
            const output = Array.from(button.form.elements).reduce((obj, input) => {
@@ -791,6 +804,7 @@ export default class LethalFantasyRoll extends Roll {
        }
        buttons.push({
          action: "roll",
+          type: "button",
          label: weaponLabel,
          callback: (event, button) => {
            let pos = $('#combat-action-dialog').position()
@@ -817,6 +831,7 @@ export default class LethalFantasyRoll extends Roll {
        }
        buttons.push({
          action: "roll",
+          type: "button",
          label: label,
          callback: (event, button) => {
            let pos = $('#combat-action-dialog').position()
@@ -828,6 +843,7 @@ export default class LethalFantasyRoll extends Roll {
    } else {
      buttons.push({
        action: "roll",
+        type: "button",
        label: "Select action",
        callback: (event, button) => {
          let pos = $('#combat-action-dialog').position()
@@ -843,6 +859,7 @@ export default class LethalFantasyRoll extends Roll {
    }
    buttons.push({
      action: "cancel",
+      type: "button",
      label: "Other action, not listed here",
      callback: (event, button) => {
        let pos = $('#combat-action-dialog').position()
@@ -861,12 +878,12 @@ export default class LethalFantasyRoll extends Roll {
      rejectClose: false // Click on Close button will not launch an error
    })

-    console.log("RollContext", dialogContext, rollContext)
+    log("RollContext", dialogContext, rollContext)
    // If action is cancelled, exit
    if (rollContext === null || rollContext === "cancel") {
      await combatant.setFlag(SYSTEM.id, "currentAction", "")
      let message = `${combatant.name} : Other action, progression reset`
-      ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+      await ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
      return
    }

@@ -910,6 +927,7 @@ export default class LethalFantasyRoll extends Roll {
            content: `<div class="grit-luck-dialog"><p><strong>${selectedItem.name}</strong> has multiple damage tiers.</p><p>Choose which damage to use when the attack lands:</p></div>`,
            buttons: tiers.map(t => ({
              action: t.id,
+              type: "button",
              label: `${t.label} (${t.dice.toUpperCase()})`,
              icon: "fa-solid fa-wand-magic-sparkles",
              callback: () => t.id
@@ -924,7 +942,7 @@ export default class LethalFantasyRoll extends Roll {
      // Set the flag on the combatant
      await combatant.setFlag(SYSTEM.id, "currentAction", actionItem)
      let message = `${combatant.name} action : ${selectedItem.name}, start rolling progression dice or casting time`
-      ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+      await ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
      rollContext = (actionItem.type === "weapon") ? "rollProgressionDice" : "rollLethargyDice" // Set the roll context to rollProgressionDice
      currentAction = actionItem
    }
@@ -935,14 +953,14 @@ export default class LethalFantasyRoll extends Roll {
          let time = currentAction.type === "spell" ? currentAction.system.castingTime : currentAction.system.prayerTime
          if (currentAction.castingTime < time) {
            let message = `Casting time : ${currentAction.name}, count : ${currentAction.castingTime}/${time}`
-            ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+            await ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
            currentAction.castingTime += 1
            await combatant.setFlag(SYSTEM.id, "currentAction", foundry.utils.duplicate(currentAction))
            return
          } else {
            // Last counting second — announce ready and transition immediately (no extra second consumed)
            let message = `Casting time : ${currentAction.name}, count : ${time}/${time} — ready to cast next second !`
-            ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+            await ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
            currentAction.castingTime = 1
            currentAction.spellStatus = "toBeCasted"
            await combatant.setFlag(SYSTEM.id, "currentAction", foundry.utils.duplicate(currentAction))
@@ -982,7 +1000,7 @@ export default class LethalFantasyRoll extends Roll {
                isLethargy: true
              }
            )
-            ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+            await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
            // Update the combatant progression count
            await combatant.setFlag(SYSTEM.id, "currentAction", "")
            // Display the action selection window again
@@ -1002,7 +1020,7 @@ export default class LethalFantasyRoll extends Roll {
                isLethargy: true
              }
            )
-            ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+            await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
          }
        }
      }
@@ -1014,18 +1032,18 @@ export default class LethalFantasyRoll extends Roll {
          let split = toSplit.split("+")
          currentAction.rangedLoad = Number(split[0]) || 0
          formula = split[1]
-          console.log("Ranged Mode", currentAction.rangedMode, currentAction.rangedLoad, formula)
+          log("Ranged Mode", currentAction.rangedMode, currentAction.rangedLoad, formula)
        }
        // Range weapon loading
        if (!currentAction.weaponLoaded && currentAction.rangedLoad) {
          if (currentAction.progressionCount < currentAction.rangedLoad) {
            let message = `Ranged weapon ${currentAction.name} is loading, loading count : ${currentAction.progressionCount}/${currentAction.rangedLoad}`
-            ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+            await ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
            currentAction.progressionCount += 1
            await combatant.setFlag(SYSTEM.id, "currentAction", foundry.utils.duplicate(currentAction))
          } else {
            let message = `Ranged weapon ${currentAction.name} is loaded !`
-            ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+            await ChatMessage.create({ content: message, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
            currentAction.weaponLoaded = true
            currentAction.progressionCount = 1
            await combatant.setFlag(SYSTEM.id, "currentAction", foundry.utils.duplicate(currentAction))
@@ -1057,13 +1075,13 @@ export default class LethalFantasyRoll extends Roll {
              rollResult: roll.total
            }
          )
-          ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+          await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
          await combatant.setFlag(SYSTEM.id, "currentAction", "")
          combatant.actor.prepareRoll(currentAction.type === "weapon" ? "weapon-attack" : "spell-attack", currentAction._id)
        } else {
          // Notify that the player cannot act now with a chat message
          currentAction.progressionCount += 1
-          combatant.setFlag(SYSTEM.id, "currentAction", foundry.utils.duplicate(currentAction))
+          await combatant.setFlag(SYSTEM.id, "currentAction", foundry.utils.duplicate(currentAction))
          const messageContent = await foundry.applications.handlebars.renderTemplate(
            "systems/fvtt-lethal-fantasy/templates/progression-message.hbs",
            {
@@ -1074,7 +1092,7 @@ export default class LethalFantasyRoll extends Roll {
              progressionCount: currentAction.progressionCount
            }
          )
-          ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
+          await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: combatant.actor }) })
        }
      }
    }
@@ -1114,6 +1132,8 @@ export default class LethalFantasyRoll extends Roll {
      content,
      buttons: [
        {
+          action: "rangeDefense",
+          type: "button",
          label: label,
          callback: (event, button) => {
            const output = Array.from(button.form.elements).reduce((obj, input) => {
@@ -1130,7 +1150,7 @@ export default class LethalFantasyRoll extends Roll {
    // If the user cancels the dialog, exit
    if (rollContext === null) return

-    console.log("RollContext", rollContext)
+    log("RollContext", rollContext)
    // Add disfavor/favor option if point blank range
    if (rollContext.range === "pointblank") {
      rollContext.movement = rollContext.movement.replace("kh", "")
@@ -1198,6 +1218,7 @@ export default class LethalFantasyRoll extends Roll {
      diceResult = r.dice[0].results[0].result
      diceResults.push({ dice: `${dice.toUpperCase()}-1`, value: diceResult - 1 })
      diceSum += (diceResult - 1)
+      rollBase.dice[0].results.push({ result: diceResult, active: true })
    }
    if (fullModifier !== 0) {
      diceResults.push({ dice: `${rollModifier.formula.toUpperCase()}`, value: rollModifier.total })
@@ -1273,6 +1294,8 @@ export default class LethalFantasyRoll extends Roll {
      content,
      buttons: [
        {
+          action: "rangedAttack",
+          type: "button",
          label,
          callback: (event, button) => {
            const output = Array.from(button.form.elements).reduce((obj, input) => {
@@ -1358,6 +1381,7 @@ export default class LethalFantasyRoll extends Roll {
      diceResult = r.dice[0].results[0].result
      diceResults.push({ dice: `${dice.toUpperCase()}-1`, value: diceResult - 1 })
      diceSum += (diceResult - 1)
+      rollBase.dice[0].results.push({ result: diceResult, active: true })
    }

    if (fullModifier !== 0) {
@@ -1426,7 +1450,7 @@ export default class LethalFantasyRoll extends Roll {
  /** @override */
  async render(chatOptions = {}) {
    let chatData = await this._getChatCardData(chatOptions.isPrivate)
-    console.log("ChatData", chatData)
+    log("ChatData", chatData)
    return await foundry.applications.handlebars.renderTemplate(this.constructor.CHAT_TEMPLATE, chatData)
  }

@@ -1464,15 +1488,15 @@ export default class LethalFantasyRoll extends Roll {

    // Récupérer les informations de l'arme pour les attaques réussies
    let weaponDamageOptions = null
-    console.log("Roll type:", this.type, "rollTarget:", this.rollTarget, "Has weapon:", !!this.rollTarget?.weapon)
+    log("Roll type:", this.type, "rollTarget:", this.rollTarget, "Has weapon:", !!this.rollTarget?.weapon)
    if (this.type === "weapon-attack" && this.rollTarget?.weapon) {
      const weapon = this.rollTarget.weapon
      weaponDamageOptions = {
-        weaponId: weapon._id || weapon.id,
+        weaponId: weapon.id,
        weaponName: weapon.name,
        damageM: weapon.system?.damage?.damageM
      }
-      console.log("Weapon damage options:", weaponDamageOptions)
+      log("Weapon damage options:", weaponDamageOptions)
    } else if (this.type === "monster-attack" && this.rollTarget) {
      weaponDamageOptions = {
        weaponId: this.rollTarget.rollKey,
@@ -1481,7 +1505,7 @@ export default class LethalFantasyRoll extends Roll {
        damageModifier: this.rollTarget.damageModifier,
        isMonster: true
      }
-      console.log("Monster damage options:", weaponDamageOptions)
+      log("Monster damage options:", weaponDamageOptions)
    }

    const cardData = {
@@ -1570,7 +1594,8 @@ export default class LethalFantasyRoll extends Roll {
    let diceSum = 0
    for (const term of roll.dice) {
      const singleDice = `1D${term.faces}`
-      for (const r of term.results) {
+      const termResults = Array.from(term.results)
+      for (const r of termResults) {
        let diceResult = r.result
        diceResults.push({ dice: singleDice.toUpperCase(), value: diceResult })
        diceSum += diceResult
@@ -1581,6 +1606,7 @@ export default class LethalFantasyRoll extends Roll {
            diceResult = xr.dice?.[0]?.results?.[0]?.result ?? (term.faces - 1)
            diceResults.push({ dice: `${singleDice.toUpperCase()}-1`, value: diceResult - 1 })
            diceSum += (diceResult - 1)
+            term.results.push({ result: diceResult, active: true })
          }
        }
      }
@@ -32,20 +32,20 @@ export class Macros {
          dropData.rollType === "save"
            ? `game.actors.get('${dropData.actorId}').system.roll('${dropData.rollType}', '${dropData.rollTarget}', '=');`
            : `game.actors.get('${dropData.actorId}').system.roll('${dropData.rollType}', '${dropData.rollTarget}');`
-        const rollName = `${game.i18n.localize("TENEBRIS.Label.jet")} ${game.i18n.localize(`TENEBRIS.Manager.${dropData.rollTarget}`)}`
+        const rollName = `${game.i18n.localize("LETHALFANTASY.Label.jet")} ${game.i18n.localize(`LETHALFANTASY.Label.${dropData.rollTarget}`)}`
        this.createMacro(slot, rollName, rollCommand, "icons/svg/d20-grey.svg")
        break

      case "rollDamage":
        const weapon = game.actors.get(dropData.actorId).items.get(dropData.rollTarget)
        const rollDamageCommand = `game.actors.get('${dropData.actorId}').system.roll('${dropData.rollType}', '${dropData.rollTarget}');`
-        const rollDamageName = `${game.i18n.localize("TENEBRIS.Label.jet")} ${weapon.name}`
+        const rollDamageName = `${game.i18n.localize("LETHALFANTASY.Label.jet")} ${weapon.name}`
        this.createMacro(slot, rollDamageName, rollDamageCommand, weapon.img)
        break

      case "rollAttack":
        const rollAttackCommand = `game.actors.get('${dropData.actorId}').system.roll('${dropData.rollValue}', '${dropData.rollTarget}');`
-        const rollAttackName = `${game.i18n.localize("TENEBRIS.Label.jet")} ${dropData.rollTarget}`
+        const rollAttackName = `${game.i18n.localize("LETHALFANTASY.Label.jet")} ${dropData.rollTarget}`
        this.createMacro(slot, rollAttackName, rollAttackCommand, "icons/svg/d20-grey.svg")
        break

@@ -57,7 +57,7 @@ export class Macros {

  /**
   * Create a macro
-   * All macros are flaged with a tenebris.macro flag at true
+   * All macros are flaged with a lethalFantasy.macro flag at true
   * @param {*} slot
   * @param {*} name
   * @param {*} command
@@ -72,7 +72,7 @@ export class Macros {
          type: "script",
          img: img,
          command: command,
-          flags: { "tenebris.macro": true },
+          flags: { "lethalFantasy.macro": true },
        },
        { displaySheet: false },
      )
@@ -383,7 +383,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
            rollResult: roll.total
          }
        )
-        ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
+        await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
        let token = combatant?.token
        this.prepareMonsterRoll("monster-attack", key, undefined, token?.id)
        if (token?.object) {
@@ -407,7 +407,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
              rollResult: roll.total
            }
          )
-          ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
+          await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
          let token = combatant?.token
          this.prepareMonsterRoll("monster-attack-hth", key, undefined, token?.id)
          if (token?.object) {
@@ -426,7 +426,7 @@ export default class LethalFantasyMonster extends foundry.abstract.TypeDataModel
          rollResult: roll.total
        }
      )
-      ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
+      await ChatMessage.create({ content: messageContent, speaker: ChatMessage.getSpeaker({ actor: this.parent }) })
    }

  }
@@ -1,6 +1,7 @@
 import { SYSTEM } from "../config/system.mjs"
+import { WEAPON_TYPE } from "../config/weapon.mjs"

-export default class LethalFantasySkill extends foundry.abstract.TypeDataModel {
+export default class LethalFantasyWeapon extends foundry.abstract.TypeDataModel {
  static defineSchema() {
    const fields = foundry.data.fields
    const schema = {}
@@ -62,7 +63,7 @@ export default class LethalFantasySkill extends foundry.abstract.TypeDataModel {
  static LOCALIZATION_PREFIXES = ["LETHALFANTASY.Weapon"]

  get weaponCategory() {
-    return game.i18n.localize(CATEGORY[this.weaponType].label)
+    return game.i18n.localize(WEAPON_TYPE[this.weaponType] || this.weaponType)
  }

 }
@@ -1,8 +1,9 @@
 import { SYSTEM } from "./config/system.mjs"

-// Map temporaire pour stocker les données d'attaque en attente de défense
-if (!globalThis.pendingDefenses) {
-  globalThis.pendingDefenses = new Map()
+export function log(...args) {
+  if (game?.settings?.get(game.system.id, "debug")) {
+    console.log(...args)
+  }
 }

 export default class LethalFantasyUtils {
@@ -27,7 +28,12 @@ export default class LethalFantasyUtils {
  /* -------------------------------------------- */
  static setHookListeners() {

-    Hooks.on('renderTokenHUD', async (hud, html, token) => {
+    Hooks.on('renderTokenHUD', async (hud, html, data) => {
+      if (html.querySelector(".lethal-hp-loss-hud")) return
+      // The token/actor is on the HUD application instance, not the third param.
+      // hud.token / hud.object gives the Token (PlaceableObject), which has .actor.
+      const hudActor = hud.token?.actor ?? hud.object?.actor
+      if (!hudActor) return
      // HP Loss Button (existing)
      const lossHPButton = await foundry.applications.handlebars.renderTemplate('systems/fvtt-lethal-fantasy/templates/loss-hp-hud.hbs', {})
      $(html).find('div.left').append(lossHPButton);
@@ -50,21 +56,16 @@ export default class LethalFantasyUtils {
          $(html).find('.hp-loss-wrap')[2].classList.add('hp-loss-hud-disabled');
        }
      })
-      $(html).find('.loss-hp-hud-click').click((event) => {
+      $(html).find('.loss-hp-hud-click').click(async (event) => {
        event.preventDefault();
        let hpLoss = event.currentTarget.dataset.hpValue;
-        if (token) {
-          let tokenFull = canvas.tokens.placeables.find(t => t.id === token._id);
-          console.log(tokenFull, token)
-          let actor = tokenFull.actor;
-          actor.applyDamage(Number(hpLoss));
+        await hudActor.applyDamage(Number(hpLoss));
          $(html).find('.hp-loss-wrap')[0].classList.remove('hp-loss-hud-active');
          $(html).find('.hp-loss-wrap')[0].classList.add('hp-loss-hud-disabled');
          $(html).find('.hp-loss-wrap')[1].classList.remove('hp-loss-hud-active');
          $(html).find('.hp-loss-wrap')[1].classList.add('hp-loss-hud-disabled');
          $(html).find('.hp-loss-wrap')[2].classList.remove('hp-loss-hud-active');
          $(html).find('.hp-loss-wrap')[2].classList.add('hp-loss-hud-disabled');
-        }
      })

      // HP Gain Button (new)
@@ -89,21 +90,27 @@ export default class LethalFantasyUtils {
          $(html).find('.hp-gain-wrap')[2].classList.add('hp-gain-hud-disabled');
        }
      })
-      $(html).find('.gain-hp-hud-click').click((event) => {
+      $(html).find('.gain-hp-hud-click').click(async (event) => {
        event.preventDefault();
        let hpGain = event.currentTarget.dataset.hpValue;
-        if (token) {
-          let tokenFull = canvas.tokens.placeables.find(t => t.id === token._id);
-          console.log(tokenFull, token)
-          let actor = tokenFull.actor;
-          actor.applyDamage(Number(hpGain)); // Positive value to add HP
+        await hudActor.applyDamage(Number(hpGain)); // Positive value to add HP
+          // Clear bleeding wounds on heal — regardless of heal amount, any
+          // healing is enough to stop bleeding (field dressing / magic / rest).
+          const wounds = foundry.utils.duplicate(hudActor.system.hp.wounds || [])
+          const hadBleeding = wounds.some(w => w.description === "Bleeding")
+          if (hadBleeding) {
+            await hudActor.update({
+              "system.hp.wounds": wounds.map(w =>
+                w.description === "Bleeding" ? { value: 0, duration: 0 } : w
+              )
+            })
+          }
          $(html).find('.hp-gain-wrap')[0].classList.remove('hp-gain-hud-active');
          $(html).find('.hp-gain-wrap')[0].classList.add('hp-gain-hud-disabled');
          $(html).find('.hp-gain-wrap')[1].classList.remove('hp-gain-hud-active');
          $(html).find('.hp-gain-wrap')[1].classList.add('hp-gain-hud-disabled');
          $(html).find('.hp-gain-wrap')[2].classList.remove('hp-gain-hud-active');
          $(html).find('.hp-gain-wrap')[2].classList.add('hp-gain-hud-disabled');
-        }
      })

      // Luck/Grit Buttons
@@ -120,26 +127,22 @@ export default class LethalFantasyUtils {
          wrap.classList.add('luck-grit-hud-disabled');
        }
      })
-      $(html).find('.luck-grit-btn').click((event) => {
+      $(html).find('.luck-grit-btn').click(async (event) => {
        event.preventDefault();
-        if (token) {
-          let tokenFull = canvas.tokens.placeables.find(t => t.id === token._id);
-          let actor = tokenFull.actor;
-          const resource = event.currentTarget.dataset.resource;
-          const amount = Number(event.currentTarget.dataset.amount);
-          const current = Number(foundry.utils.getProperty(actor.system, `${resource}.current`)) || 0;
-          const newValue = Math.max(0, current + amount);
-          actor.update({ [`system.${resource}.current`]: newValue });
-          $(html).find('.luck-grit-wrap')[0].classList.remove('luck-grit-hud-active');
-          $(html).find('.luck-grit-wrap')[0].classList.add('luck-grit-hud-disabled');
-        }
+        const resource = event.currentTarget.dataset.resource;
+        const amount = Number(event.currentTarget.dataset.amount);
+        const current = Number(foundry.utils.getProperty(hudActor.system, `${resource}.current`)) || 0;
+        const newValue = Math.max(0, current + amount);
+        await hudActor.update({ [`system.${resource}.current`]: newValue });
+        $(html).find('.luck-grit-wrap')[0].classList.remove('luck-grit-hud-active');
+        $(html).find('.luck-grit-wrap')[0].classList.add('luck-grit-hud-disabled');
      })
    })
  }

  /* -------------------------------------------- */
-  static handleSocketEvent(msg = {}) {
-    console.log(`handleSocketEvent !`, msg)
+  static async handleSocketEvent(msg = {}) {
+    log(`handleSocketEvent !`, msg)
    let actor
    switch (msg.type) {
      case "applyDamage":
@@ -149,18 +152,18 @@ export default class LethalFantasyUtils {
            ? canvas.tokens?.placeables?.find(t => t.id === msg.tokenId)?.actor
            : (game.combat?.combatants?.find(c => c.actorId === msg.actorId)?.actor
              ?? game.actors.get(msg.actorId))
-          if (actor) actor.applyDamage(msg.damage)
+          if (actor) await actor.applyDamage(msg.damage)
        }
        break
      case "rollInitiative":
        if (msg.userId && msg.userId !== game.user.id) break
        actor = game.actors.get(msg.actorId)
-        actor.system.rollInitiative(msg.combatId, msg.combatantId)
+        await actor.system.rollInitiative(msg.combatId, msg.combatantId)
        break
      case "rollProgressionDice":
        if (msg.userId && msg.userId !== game.user.id) break
        actor = game.actors.get(msg.actorId)
-        actor.system.rollProgressionDice(msg.combatId, msg.combatantId, msg.rollProgressionCount)
+        await actor.system.rollProgressionDice(msg.combatId, msg.combatantId, msg.rollProgressionCount)
        break
      case "requestDefense":
        // Vérifier si le message est destiné à cet utilisateur
@@ -184,11 +187,16 @@ export default class LethalFantasyUtils {
            const slot = wounds.findIndex(w => !w.value && !w.duration)
            if (slot !== -1) {
              wounds[slot] = { value: msg.damage, duration: msg.damage, description: "Bleeding" }
-              actor.update({ "system.hp.wounds": wounds })
+              await actor.update({ "system.hp.wounds": wounds })
            }
          }
        }
        break
+      case "attackBoosted":
+        if (msg.userId === game.user.id) {
+          LethalFantasyUtils.handleAttackBoosted(msg)
+        }
+        break
    }
  }

@@ -226,6 +234,225 @@ export default class LethalFantasyUtils {
    })
  }

+  /* -------------------------------------------- */
+  static async handleAttackBoosted(msg) {
+    const {
+      attackerName, attackerId, defenderName, defenderId, defenderTokenId,
+      attackerHandledBonus, attackRollFinal, defenseRoll, attackWeaponId, attackRollType, attackRollKey,
+      shieldDamageReduction: initialShieldDR,
+      d30Bleed, d30DamageMultiplier, d30DrMultiplier,
+      damageTier, attackD30message, defenseD30message,
+      hasShield, shieldLabel, shieldFormula, shieldDr, canAdHocShield
+    } = msg
+
+    const defender = game.actors.get(defenderId)
+    if (!defender) return
+
+    let updatedDefenseRoll = defenseRoll
+    let shieldBlocked = false
+    let shieldReaction = null
+    let canShieldReact = hasShield
+    let canAdHoc = canAdHocShield
+
+    // ── D30 bonus dice (defense) — resolved before grit/luck/shield ───────
+    let defenseDrMultiplier = null
+    if (defenseD30message && defender) {
+      const d30Result = await LethalFantasyUtils.processD30BonusDice(defenseD30message, "defense", null, defender, true)
+      if (d30Result.modifier) {
+        updatedDefenseRoll += d30Result.modifier
+        if (d30Result.modifier > 0) {
+          await ChatMessage.create({
+            content: `<p><strong>${defenderName}</strong> gains <strong>+${d30Result.modifier}</strong> from D30 bonus die for defense.</p>`,
+            speaker: ChatMessage.getSpeaker({ actor: defender })
+          })
+        }
+      }
+      if (d30Result.specialEffect === "auto") {
+        updatedDefenseRoll = attackRollFinal + 1
+        await ChatMessage.create({
+          content: `<p><strong>${defenderName}</strong> uses <strong>${d30Result.specialName || "Special Defense"}</strong> from D30 — defense automatically succeeds!</p>`,
+          speaker: ChatMessage.getSpeaker({ actor: defender })
+        })
+      }
+      if (d30Result.specialEffect === "flag") {
+        await ChatMessage.create({
+          content: `<p>D30 — <strong>${d30Result.specialName || "Special Effect"}</strong> triggered for ${defenderName}!</p>`,
+          speaker: ChatMessage.getSpeaker({ actor: defender })
+        })
+      }
+      if (d30Result.specialEffect === "drMultiplier") {
+        defenseDrMultiplier = d30Result.multiplier
+        await ChatMessage.create({
+          content: `<p>D30 — Defense grants <strong>x${d30Result.multiplier} DR</strong> (choose which DR types to multiply when damage is applied)</p>`,
+          speaker: ChatMessage.getSpeaker({ actor: defender })
+        })
+      }
+    }
+
+    // Show the defense reaction dialog — while-loop for multiple reactions
+    if (defender) {
+      while (updatedDefenseRoll < attackRollFinal) {
+        const currentGrit = Number(defender.system?.grit?.current) || 0
+        const currentLuck = Number(defender.system?.luck?.current) || 0
+        const buttons = []
+
+        if (currentGrit > 0) {
+          buttons.push({
+            action: "grit",
+            type: "button",
+            label: `Spend 1 Grit (+1D6) [${currentGrit} left]`,
+            icon: "fa-solid fa-fist-raised",
+            callback: () => "grit"
+          })
+        }
+
+        if (currentLuck > 0) {
+          buttons.push({
+            action: "luck",
+            type: "button",
+            label: `Spend 1 Luck (+1D6) [${currentLuck} left]`,
+            icon: "fa-solid fa-clover",
+            callback: () => "luck"
+          })
+        }
+
+        buttons.push({
+          action: "bonusDie",
+          type: "button",
+          label: "Add bonus die",
+          icon: "fa-solid fa-dice",
+          callback: () => "bonusDie"
+        })
+
+        if (canShieldReact) {
+          buttons.push({
+            action: "shieldReact",
+            type: "button",
+            label: `Roll shield (${shieldLabel})`,
+            icon: "fa-solid fa-shield",
+            callback: () => "shieldReact"
+          })
+        } else if (canAdHoc) {
+          buttons.push({
+            action: "adHocShield",
+            type: "button",
+            label: "Roll ad-hoc shield (choose dice + DR)",
+            icon: "fa-solid fa-shield-halved",
+            callback: () => "adHocShield"
+          })
+        }
+
+        buttons.push({
+          action: "continue",
+          type: "button",
+          label: "Continue (no defense bonus)",
+          icon: "fa-solid fa-forward",
+          callback: () => "continue"
+        })
+
+        const choice = await foundry.applications.api.DialogV2.wait({
+          window: { title: "Defense reactions — attack boosted" },
+          classes: ["lethalfantasy"],
+          content: `
+            <div class="grit-luck-dialog">
+              <div class="combat-status">
+                <p><strong>${attackerName}</strong> boosted attack to <strong>${attackRollFinal}</strong></p>
+                <p><strong>${defenderName}</strong> currently has <strong>${updatedDefenseRoll}</strong></p>
+              </div>
+              <p class="offer-text">The attack was boosted! Choose how to improve the defense.</p>
+            </div>
+          `,
+          buttons,
+          rejectClose: false
+        })
+
+        if (!choice || choice === "continue") break
+
+        if (choice === "grit") {
+          const bonusRoll = await LethalFantasyUtils.rollBonusDie("1d6", defender,
+            total => `<p><strong>${defenderName}</strong> spends 1 Grit and rolls <strong>${total}</strong> for defense.</p>`)
+          updatedDefenseRoll += bonusRoll
+          await defender.update({ "system.grit.current": currentGrit - 1 })
+        } else if (choice === "luck") {
+          const bonusRoll = await LethalFantasyUtils.rollBonusDie("1d6", defender,
+            total => `<p><strong>${defenderName}</strong> spends 1 Luck and rolls <strong>${total}</strong> for defense.</p>`)
+          updatedDefenseRoll += bonusRoll
+          await defender.update({ "system.luck.current": currentLuck - 1 })
+        } else if (choice === "bonusDie") {
+          const bonusDie = await LethalFantasyUtils.promptCombatBonusDie(defenderName, "attack", updatedDefenseRoll, attackRollFinal)
+          if (bonusDie) {
+            const bonusRoll = await LethalFantasyUtils.rollBonusDie(bonusDie, defender,
+              (total, formula) => `<p><strong>${defenderName}</strong> adds <strong>${formula.toUpperCase()}</strong> and rolls <strong>${total}</strong> for defense.</p>`)
+            updatedDefenseRoll += bonusRoll
+          }
+        } else if (choice === "shieldReact" && canShieldReact) {
+          const shieldBonus = await LethalFantasyUtils.rollBonusDie(shieldFormula, defender)
+          const newDefenseTotal = updatedDefenseRoll + shieldBonus
+          updatedDefenseRoll = newDefenseTotal
+          canShieldReact = false
+          if (newDefenseTotal >= attackRollFinal) {
+            shieldBlocked = true
+            shieldReaction = { damageReduction: shieldDr, label: shieldLabel, bonus: shieldBonus }
+            await ChatMessage.create({
+              content: `<p><strong>${defenderName}</strong> rolls <strong>${shieldLabel}</strong> and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} ≥ ${attackRollFinal}). <strong>Shield blocked the attack!</strong> Both armor DR and shield DR <strong>${shieldDr}</strong> will apply to damage.</p>`,
+              speaker: ChatMessage.getSpeaker({ actor: defender })
+            })
+          } else {
+            await ChatMessage.create({
+              content: `<p><strong>${defenderName}</strong> rolls <strong>${shieldLabel}</strong> and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} < ${attackRollFinal}). Shield did not block — normal hit, armor DR only.</p>`,
+              speaker: ChatMessage.getSpeaker({ actor: defender })
+            })
+          }
+        } else if (choice === "adHocShield" && canAdHoc) {
+          const adHoc = await LethalFantasyUtils.promptAdHocShield(defenderName, attackRollFinal, updatedDefenseRoll)
+          if (adHoc) {
+            const shieldBonus = await LethalFantasyUtils.rollBonusDie(adHoc.formula, defender)
+            const newDefenseTotal = updatedDefenseRoll + shieldBonus
+            updatedDefenseRoll = newDefenseTotal
+            canShieldReact = false
+            canAdHoc = false
+            if (newDefenseTotal >= attackRollFinal) {
+              shieldBlocked = true
+              shieldReaction = { damageReduction: adHoc.damageReduction, label: `${adHoc.formula.toUpperCase()} shield`, bonus: shieldBonus }
+              await ChatMessage.create({
+                content: `<p><strong>${defenderName}</strong> rolls <strong>${adHoc.formula.toUpperCase()}</strong> shield and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} ≥ ${attackRollFinal}). <strong>Shield blocked the attack!</strong> Both armor DR and shield DR <strong>${adHoc.damageReduction}</strong> will apply to damage.</p>`,
+                speaker: ChatMessage.getSpeaker({ actor: defender })
+              })
+            } else {
+              await ChatMessage.create({
+                content: `<p><strong>${defenderName}</strong> rolls <strong>${adHoc.formula.toUpperCase()}</strong> shield and adds <strong>${shieldBonus}</strong> to defense (${newDefenseTotal} < ${attackRollFinal}). Shield did not block — normal hit, armor DR only.</p>`,
+                speaker: ChatMessage.getSpeaker({ actor: defender })
+              })
+            }
+          }
+        }
+      }
+    }
+
+    const finalShieldDR = shieldBlocked ? (shieldReaction?.damageReduction || 0) : 0
+    const outcome = shieldBlocked ? "shielded-hit" : (updatedDefenseRoll >= attackRollFinal ? "miss" : "hit")
+
+    await LethalFantasyUtils.compareAttackDefense({
+      attackerName,
+      attackerId,
+      attackRoll: attackRollFinal,
+      attackWeaponId,
+      attackRollType,
+      attackRollKey,
+      defenderName,
+      defenderId,
+      defenderTokenId,
+      defenseRoll: updatedDefenseRoll,
+      outcome,
+      shieldDamageReduction: finalShieldDR,
+      d30Bleed: d30Bleed || "",
+      d30DamageMultiplier: d30DamageMultiplier || 1,
+      d30DrMultiplier: (d30DrMultiplier != null && d30DrMultiplier !== 1) ? d30DrMultiplier : (defenseDrMultiplier ?? d30DrMultiplier ?? 1),
+      damageTier: damageTier || "standard",
+      attackD30message
+    })
+  }
+
  /* -------------------------------------------- */
  static async showDefenseRequest(msg) {
    const attackerName = msg.attackerName
@@ -279,7 +506,7 @@ export default class LethalFantasyUtils {

    const isMonster = defender.type === "monster"

-    console.log(`[LF] showDefenseRequest | attackRollType=${attackRollType} isMonster=${isMonster} defender=${defender?.name}`)
+    log(`[LF] showDefenseRequest | attackRollType=${attackRollType} isMonster=${isMonster} defender=${defender?.name}`)

    // Spell/miracle attacks use saving throws instead of weapon defense
    const isSpellAttack = attackRollType === "spell-attack" || attackRollType === "miracle-attack"
@@ -313,6 +540,7 @@ export default class LethalFantasyUtils {
        buttons: [
          {
            action: "rollSave",
+            type: "button",
            label: "Roll Save",
            icon: "fa-solid fa-person-running",
            callback: (event, button) => button.form.elements.saveKey.value,
@@ -323,6 +551,7 @@ export default class LethalFantasyUtils {

      if (result) {
        game.lethalFantasy = game.lethalFantasy || {}
+        game.lethalFantasy.spellDefense = true // pré-cocher "Save against spell" dans le dialog
        game.lethalFantasy.nextDefenseData = {
          attackerId,
          attackRoll,
@@ -340,9 +569,9 @@ export default class LethalFantasyUtils {
          defenderTokenId
        }
        if (isMonster) {
-          defender.system.prepareMonsterRoll("save", result)
+          await defender.system.prepareMonsterRoll("save", result)
        } else {
-          defender.prepareRoll("save", result)
+          await defender.prepareRoll("save", result)
        }
      }
      return
@@ -385,6 +614,8 @@ export default class LethalFantasyUtils {
        content,
        buttons: [
          {
+            action: "rangeDefense",
+            type: "button",
            label: "Roll Defense",
            icon: "fa-solid fa-shield",
            callback: (event, button, dialog) => {
@@ -418,7 +649,7 @@ export default class LethalFantasyUtils {
          isRanged: msg.isRanged
        }

-        defender.system.prepareMonsterRoll("monster-defense", result)
+        await defender.system.prepareMonsterRoll("monster-defense", result)
      }
      return
    }
@@ -492,6 +723,8 @@ export default class LethalFantasyUtils {
      content,
      buttons: [
        {
+          action: "defenseRoll",
+          type: "button",
          label: "Roll Defense",
          icon: "fa-solid fa-shield",
          callback: (event, button, dialog) => {
@@ -525,9 +758,9 @@ export default class LethalFantasyUtils {
        isRanged: msg.isRanged
      }

-      console.log("Storing defense data for character:", defender.id)
+      log("Storing defense data for character:", defender.id)

-      defender.prepareRoll("weapon-defense", result)
+      await defender.prepareRoll("weapon-defense", result)
    }
  }

@@ -562,18 +795,11 @@ export default class LethalFantasyUtils {

    // ── Choice type ── present all options to the player
    if (d30Message.type === "choice") {
-      // Try to find a bonus_dice option matching this side
-      const autoBonus = d30Message.choices.find(c => c.type === "bonus_dice" && validTargets.includes(c.target))
-
-      // If we can't show dialogs (wrong client), auto-roll bonus dice if available
+      // If we can't show dialogs (wrong client), skip — the primary client
+      // will communicate its choice result via socket. Auto-rolling here
+      // would give a different modifier on each client, causing divergence.
      if (!canDialog) {
-        if (autoBonus) {
-          const modifier = await this._rollD30BonusDie(autoBonus.dice, actor, true)
-          return { modifier, specialEffect: null, specialName: null }
-        }
-        // No bonus dice available on this side — just report as flag
-        const first = d30Message.choices[0]
-        return { modifier: 0, specialEffect: "flag", specialName: first?.type || "choice" }
+        return { modifier: 0, specialEffect: null, specialName: null }
      }

      const buttons = d30Message.choices.map(c => {
@@ -594,6 +820,7 @@ export default class LethalFantasyUtils {
        }
        return {
          action: c.type,
+          type: "button",
          label,
          icon,
          callback: () => c
@@ -783,6 +1010,7 @@ export default class LethalFantasyUtils {
      buttons: [
        {
          action: "roll",
+          type: "button",
          label: "Roll Bonus Die",
          icon: "fa-solid fa-dice",
          callback: (event, button) => {
@@ -792,6 +1020,7 @@ export default class LethalFantasyUtils {
        },
        {
          action: "cancel",
+          type: "button",
          label: "Cancel",
          icon: "fa-solid fa-xmark",
          callback: () => null
@@ -839,6 +1068,7 @@ export default class LethalFantasyUtils {
      buttons: [
        {
          action: "roll",
+          type: "button",
          label: "Roll Shield",
          icon: "fa-solid fa-shield",
          callback: (event, button) => {
@@ -852,6 +1082,7 @@ export default class LethalFantasyUtils {
        },
        {
          action: "cancel",
+          type: "button",
          label: "Cancel",
          icon: "fa-solid fa-xmark",
          callback: () => null
@@ -922,6 +1153,7 @@ export default class LethalFantasyUtils {
      if (currentGrit > 0) {
        buttons.push({
          action: "grit",
+          type: "button",
          label: `Spend 1 Grit (+1D6) [${currentGrit} left]`,
          icon: "fa-solid fa-fist-raised",
          callback: () => "grit"
@@ -931,6 +1163,7 @@ export default class LethalFantasyUtils {
      if (currentLuck > 0) {
        buttons.push({
          action: "luck",
+          type: "button",
          label: `Spend 1 Luck (+1D6) [${currentLuck} left]`,
          icon: "fa-solid fa-clover",
          callback: () => "luck"
@@ -939,6 +1172,7 @@ export default class LethalFantasyUtils {

      buttons.push({
        action: "continue",
+        type: "button",
        label: "Continue (no bonus)",
        icon: "fa-solid fa-forward",
        callback: () => "continue"
@@ -1014,12 +1248,14 @@ export default class LethalFantasyUtils {
      const buttons = [
        {
          action: "grit",
+          type: "button",
          label: `Spend 1 Grit (+1D6) [${currentGrit} left]`,
          icon: "fa-solid fa-fist-raised",
          callback: () => "grit"
        },
        {
          action: "continue",
+          type: "button",
          label: "Continue (no bonus)",
          icon: "fa-solid fa-forward",
          callback: () => "continue"
@@ -1073,7 +1309,7 @@ export default class LethalFantasyUtils {

  /* -------------------------------------------- */
  static async compareAttackDefense(data) {
-    console.log("compareAttackDefense called with:", data)
+    log("compareAttackDefense called with:", data)

    // Compute D30 effects from the attack D30 message directly.
    // This is more reliable than depending on the caller-provided values, which are
@@ -1088,11 +1324,11 @@ export default class LethalFantasyUtils {

    const outcome = data.outcome || (data.attackRoll > data.defenseRoll ? "hit" : "miss")
    const isAttackWin = outcome !== "miss"
-    console.log("isAttackWin:", isAttackWin, "attackRoll:", data.attackRoll, "defenseRoll:", data.defenseRoll)
+    log("isAttackWin:", isAttackWin, "attackRoll:", data.attackRoll, "defenseRoll:", data.defenseRoll)

    let damageButton = ""
    if (isAttackWin && (data.attackWeaponId || data.attackRollKey)) {
-      console.log("Creating damage button. defenderId:", data.defenderId)
+      log("Creating damage button. defenderId:", data.defenderId)
      // Déterminer le type de dégâts à lancer
      if (data.attackRollType === "weapon-attack") {
        damageButton = `
@@ -1173,12 +1409,12 @@ export default class LethalFantasyUtils {
      </div>
    `

-    console.log("Creating combat result message...")
+    log("Creating combat result message...")
    await ChatMessage.create({
      content: resultMessage,
      speaker: { alias: "Combat System" }
    })
-    console.log("Combat result message created!")
+    log("Combat result message created!")
  }

  static registerHandlebarsHelpers() {
@@ -1315,7 +1551,7 @@ export default class LethalFantasyUtils {
      return eval(expr);
    })
    Handlebars.registerHelper('isOwnerOrGM', function (actor) {
-      console.log("Testing actor", actor.isOwner, game.userId)
+      log("Testing actor", actor.isOwner, game.userId)
      return actor.isOwner || game.isGM;
    })
    Handlebars.registerHelper('upperCase', function (text) {
@@ -1410,21 +1646,25 @@ export default class LethalFantasyUtils {
      buttons: [
        {
          action: "noDR",
+          type: "button",
          label: "No DR",
          callback: () => ({ drType: "none", damage: damageTotal })
        },
        {
          action: "armorDR",
+          type: "button",
          label: "With Armor DR",
          callback: () => ({ drType: "armor", damage: Math.max(0, damageTotal - armorDR) })
        },
        {
          action: "allDR",
+          type: "button",
          label: "With Armor + Shield DR",
          callback: () => ({ drType: "all", damage: Math.max(0, damageTotal - totalDR) })
        },
        {
          action: "cancel",
+          type: "button",
          label: "Cancel",
          callback: () => null
        }
@@ -1453,7 +1693,7 @@ export default class LethalFantasyUtils {
        }
      )

-      ChatMessage.create({
+      await ChatMessage.create({
        user: game.user.id,
        speaker: { alias: targetActor.name },
        mode: "gm",
@@ -1 +0,0 @@
-MANIFEST-000631
@@ -1,8 +0,0 @@
-2026/06/11-20:25:36.058631 7f37427ed6c0 Recovering log #629
-2026/06/11-20:25:36.068520 7f37427ed6c0 Delete type=3 #627
-2026/06/11-20:25:36.068574 7f37427ed6c0 Delete type=0 #629
-2026/06/11-20:41:45.938413 7f3740fff6c0 Level-0 table #634: started
-2026/06/11-20:41:45.938512 7f3740fff6c0 Level-0 table #634: 0 bytes OK
-2026/06/11-20:41:45.945312 7f3740fff6c0 Delete type=0 #632
-2026/06/11-20:41:45.965586 7f3740fff6c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
-2026/06/11-20:41:45.965944 7f3740fff6c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
@@ -1,8 +0,0 @@
-2026/06/10-19:56:01.455200 7f301cbff6c0 Recovering log #625
-2026/06/10-19:56:01.464323 7f301cbff6c0 Delete type=3 #623
-2026/06/10-19:56:01.464355 7f301cbff6c0 Delete type=0 #625
-2026/06/10-20:16:07.843239 7f2fce7fc6c0 Level-0 table #630: started
-2026/06/10-20:16:07.843267 7f2fce7fc6c0 Level-0 table #630: 0 bytes OK
-2026/06/10-20:16:07.849298 7f2fce7fc6c0 Delete type=0 #628
-2026/06/10-20:16:07.849522 7f2fce7fc6c0 Manual compaction at level-0 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
-2026/06/10-20:16:07.849556 7f2fce7fc6c0 Manual compaction at level-1 from '!folders!ATr9wZhg5uTVTksM' @ 72057594037927935 : 1 .. '!items!zw9RQocTdz3HRjZK' @ 0 : 0; will stop at (end)
@@ -1 +0,0 @@
-MANIFEST-000628
@@ -1,8 +0,0 @@
-2026/06/11-20:25:36.074598 7f37437ef6c0 Recovering log #626
-2026/06/11-20:25:36.084983 7f37437ef6c0 Delete type=3 #624
-2026/06/11-20:25:36.085075 7f37437ef6c0 Delete type=0 #626
-2026/06/11-20:41:45.965954 7f3740fff6c0 Level-0 table #631: started
-2026/06/11-20:41:45.965991 7f3740fff6c0 Level-0 table #631: 0 bytes OK
-2026/06/11-20:41:45.972550 7f3740fff6c0 Delete type=0 #629
-2026/06/11-20:41:45.992980 7f3740fff6c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
-2026/06/11-20:41:45.993323 7f3740fff6c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
@@ -1,8 +0,0 @@
-2026/06/10-19:56:01.470668 7f2fcffff6c0 Recovering log #622
-2026/06/10-19:56:01.480292 7f2fcffff6c0 Delete type=3 #620
-2026/06/10-19:56:01.480316 7f2fcffff6c0 Delete type=0 #622
-2026/06/10-20:16:07.810643 7f2fce7fc6c0 Level-0 table #627: started
-2026/06/10-20:16:07.810662 7f2fce7fc6c0 Level-0 table #627: 0 bytes OK
-2026/06/10-20:16:07.816355 7f2fce7fc6c0 Delete type=0 #625
-2026/06/10-20:16:07.823439 7f2fce7fc6c0 Manual compaction at level-0 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
-2026/06/10-20:16:07.823453 7f2fce7fc6c0 Manual compaction at level-1 from '!folders!yPWGvxHJbDNHVSnY' @ 72057594037927935 : 1 .. '!items!x5gLtqlW4sdDmHTd' @ 0 : 0; will stop at (end)
@@ -1 +0,0 @@
-MANIFEST-000633
@@ -1,8 +0,0 @@
-2026/06/11-20:25:36.041244 7f3742fee6c0 Recovering log #631
-2026/06/11-20:25:36.052153 7f3742fee6c0 Delete type=3 #629
-2026/06/11-20:25:36.052218 7f3742fee6c0 Delete type=0 #631
-2026/06/11-20:41:45.958653 7f3740fff6c0 Level-0 table #636: started
-2026/06/11-20:41:45.958703 7f3740fff6c0 Level-0 table #636: 0 bytes OK
-2026/06/11-20:41:45.965435 7f3740fff6c0 Delete type=0 #634
-2026/06/11-20:41:45.965798 7f3740fff6c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
-2026/06/11-20:41:45.965918 7f3740fff6c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
@@ -1,8 +0,0 @@
-2026/06/10-19:56:01.439055 7f2fcffff6c0 Recovering log #627
-2026/06/10-19:56:01.451210 7f2fcffff6c0 Delete type=3 #625
-2026/06/10-19:56:01.451236 7f2fcffff6c0 Delete type=0 #627
-2026/06/10-20:16:07.804529 7f2fce7fc6c0 Level-0 table #632: started
-2026/06/10-20:16:07.804550 7f2fce7fc6c0 Level-0 table #632: 0 bytes OK
-2026/06/10-20:16:07.810504 7f2fce7fc6c0 Delete type=0 #630
-2026/06/10-20:16:07.823431 7f2fce7fc6c0 Manual compaction at level-0 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
-2026/06/10-20:16:07.823457 7f2fce7fc6c0 Manual compaction at level-1 from '!folders!7j8H7DbmBb9Uza2X' @ 72057594037927935 : 1 .. '!items!zt8s7564ep1La4XQ' @ 0 : 0; will stop at (end)
@@ -1 +0,0 @@
-MANIFEST-000328
@@ -1,8 +0,0 @@
-2026/06/11-20:25:36.103531 7f37437ef6c0 Recovering log #326
-2026/06/11-20:25:36.114200 7f37437ef6c0 Delete type=3 #324
-2026/06/11-20:25:36.114249 7f37437ef6c0 Delete type=0 #326
-2026/06/11-20:41:45.972686 7f3740fff6c0 Level-0 table #331: started
-2026/06/11-20:41:45.972724 7f3740fff6c0 Level-0 table #331: 0 bytes OK
-2026/06/11-20:41:45.979068 7f3740fff6c0 Delete type=0 #329
-2026/06/11-20:41:45.993007 7f3740fff6c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
-2026/06/11-20:41:45.993301 7f3740fff6c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
@@ -1,8 +0,0 @@
-2026/06/10-19:56:01.497944 7f301cbff6c0 Recovering log #322
-2026/06/10-19:56:01.506991 7f301cbff6c0 Delete type=3 #320
-2026/06/10-19:56:01.507034 7f301cbff6c0 Delete type=0 #322
-2026/06/10-20:16:07.829554 7f2fce7fc6c0 Level-0 table #327: started
-2026/06/10-20:16:07.829571 7f2fce7fc6c0 Level-0 table #327: 0 bytes OK
-2026/06/10-20:16:07.836328 7f2fce7fc6c0 Delete type=0 #325
-2026/06/10-20:16:07.849487 7f2fce7fc6c0 Manual compaction at level-0 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
-2026/06/10-20:16:07.849533 7f2fce7fc6c0 Manual compaction at level-1 from '!folders!37mu4dxsSuftlnmP' @ 72057594037927935 : 1 .. '!items!zKOpU34oLziGJW6y' @ 0 : 0; will stop at (end)
@@ -1 +0,0 @@
-MANIFEST-000627
@@ -1,8 +0,0 @@
-2026/06/11-20:25:36.088952 7f37427ed6c0 Recovering log #625
-2026/06/11-20:25:36.100017 7f37427ed6c0 Delete type=3 #623
-2026/06/11-20:25:36.100073 7f37427ed6c0 Delete type=0 #625
-2026/06/11-20:41:45.945442 7f3740fff6c0 Level-0 table #630: started
-2026/06/11-20:41:45.945486 7f3740fff6c0 Level-0 table #630: 0 bytes OK
-2026/06/11-20:41:45.951778 7f3740fff6c0 Delete type=0 #628
-2026/06/11-20:41:45.965603 7f3740fff6c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
-2026/06/11-20:41:45.965769 7f3740fff6c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
@@ -1,8 +0,0 @@
-2026/06/10-19:56:01.483620 7f2fceffd6c0 Recovering log #621
-2026/06/10-19:56:01.493981 7f2fceffd6c0 Delete type=3 #619
-2026/06/10-19:56:01.494004 7f2fceffd6c0 Delete type=0 #621
-2026/06/10-20:16:07.797521 7f2fce7fc6c0 Level-0 table #626: started
-2026/06/10-20:16:07.797566 7f2fce7fc6c0 Level-0 table #626: 0 bytes OK
-2026/06/10-20:16:07.804440 7f2fce7fc6c0 Delete type=0 #624
-2026/06/10-20:16:07.823416 7f2fce7fc6c0 Manual compaction at level-0 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
-2026/06/10-20:16:07.823449 7f2fce7fc6c0 Manual compaction at level-1 from '!folders!mnO9OzE7BEE2KDfh' @ 72057594037927935 : 1 .. '!items!zkK6ixtCsCw3RH9X' @ 0 : 0; will stop at (end)
@@ -1,4 +1,4 @@
-<div class="control-icon" data-action="lethal-luck-grit-hud">
+<div class="control-icon lethal-luck-grit-hud" data-action="lethal-luck-grit-hud">
  <i class="fa-solid fa-dice" title="Adjust Luck/Grit" style="width:36px;height:36px;display:flex;align-items:center;justify-content:center;font-size:18px;cursor:pointer"></i>

  <div class="luck-grit-wrap luck-grit-hud-disabled">
@@ -130,6 +130,7 @@
            type="checkbox"
            name="saveSpellCheck"
            data-action="saveSpellCheck"
+            {{#if saveSpell}}checked{{/if}}
          />
        </div>
      {{/if}}
@@ -17,7 +17,7 @@
        {{formField systemFields.damageType.fields.typeS value=system.damageType.typeS}}
      </div>

-      {{formField systemFields.damage.fields.damageM value=system.damage.damageM label="LETHALFANTASY.Label.damage"}}
+      {{formField systemFields.damage.fields.damageM value=system.damage.damageM label=(localize "LETHALFANTASY.Label.damage")}}

      {{formField systemFields.applyStrengthDamageBonus value=system.applyStrengthDamageBonus localize=true}}
    
@@ -0,0 +1,2 @@
+import { CompendiumsManager } from './CompendiumsManager.mjs';
+CompendiumsManager.packToDistDir('packs_src', 'packs-system');
@@ -0,0 +1,2 @@
+import { CompendiumsManager } from './CompendiumsManager.mjs';
+CompendiumsManager.unpackToSrcDir('packs_src', 'packs-system');
Author	SHA1	Message	Date
uberwald	3b0d4e032e	fix: cache results.length before explosion loop to prevent double-count Release Creation / build (release) Successful in 50s Details Pushing explosion dice to DieTerm.results made the for loop condition (j < results.length) grow mid-iteration, re-processing the explosion result as a normal die. This produced spurious entries like `1D6 → 4` alongside the correct `1D6-1 → 3`. Fixes prompt() (for loop) and rollSpellDamageToMessage() (for...of) by caching result count / snapshotting the array before iterating.	2026-06-16 19:34:13 +02:00
uberwald	539841c4ff	fix: push explosion dice to DieTerm results so DSN displays them Explosion rolls were evaluated as separate Roll instances but never added to the original DieTerm's results array. Dice So Nice reads DieTerm.results to render 3D dice, so explosions were invisible. Now each explosion result is pushed into the DieTerm's results array ({result, active:true}), letting DSN render explosion dice in the correct chronological order alongside the main die. Applies to prompt(), promptRangedDefense(), promptRangedAttack(), and rollSpellDamageToMessage().	2026-06-16 19:29:07 +02:00
uberwald	ffba37b59e	Fix D30 management, again	2026-06-14 23:00:39 +02:00
uberwald	1a7585e1f6	fix: merge saving_throws D30 table into arcane_spell_defense Release Creation / build (release) Successful in 49s Details saving_throws was redundant — all saves in this system are vs spells. Removed SAVING_THROWS constant; all save rollType lookups use ARCANE_SPELL_DEFENSE. D30=1 arcane_spell_defense blank (no special result). Added miracle types to ARCANE_SPELL_ATTACK mapping so they get D30 results instead of null.	2026-06-14 22:57:41 +02:00
uberwald	b567c8bbea	Fix D30 management, again Release Creation / build (release) Successful in 48s Details	2026-06-13 23:15:22 +02:00
uberwald	60b351f50d	Fix spell save/defense again Release Creation / build (release) Successful in 45s Details	2026-06-13 21:06:18 +02:00
uberwald	ace726a1fc	fix: use try/finally for spellDefense cleanup instead of delete Release Creation / build (release) Successful in 47s Details delete on game.lethalFantasy.spellDefense was breaking roll flow on Foundry's proxied game object. Use try/finally with assignment to false instead, which is safe on any object type. Initialize saveSpell local var from one-shot flag so D30 chart lookup correctly uses arcane_spell_defense for spell saves without requiring user to click the pre-checked checkbox.	2026-06-13 16:51:52 +02:00
uberwald	67499bc199	fix: add missing arcane_spell_defense entry for D30=1 Release Creation / build (release) Successful in 49s Details User spec lists D30=1 as 'Possible Spell Calamity or Catastrophe' for Arcane Spell Defense but it was missing from the table.	2026-06-13 16:29:54 +02:00
uberwald	7eae95cbbd	fix: use arcane spell defense D30 chart for spell saves Release Creation / build (release) Successful in 43s Details Bug: saveSpell local var initialized to false (line 142), while dialog checkbox was pre-checked via dialogContext.saveSpell = game.lethalFantasy.spellDefense. If user didn't click the checkbox, D30 call used SAVING_THROWS chart instead of ARCANE_SPELL_DEFENSE. Also: game.lethalFantasy.spellDefense was set true before spell defense rolls but never cleared, leaking to subsequent non-spell saves. Fix: initialize saveSpell from the one-shot flag and delete it immediately. Dialog context now uses the local saveSpell variable instead of re-reading the deleted flag.	2026-06-13 15:22:34 +02:00
uberwald	1b53bf9152	fix: resolve hud actor from hud.token not render context param Release Creation / build (release) Successful in 41s Details V2 renderTokenHUD passes (hud, html, data) where data is a render context object — not a TokenDocument. data.actor was undefined, and data?.token?.actor was also undefined. Use hud.token.actor (or hud.object.actor) instead, which is the real PlaceableObject with proper actor resolution. Also fix html.find() → html.querySelector() for V2 HTMLElement.	2026-06-12 19:01:54 +02:00
uberwald	2570bf707e	fix: prevent duplicate cross-client defense dialog, clear bleed on heal - Only send attackBoosted socket when attackerHandledBonus \|\| attackerHasNonGMOwner (GM→player: hook handles it, no socket needed; PC→PC: socket needed) - Clear bleeding wounds when HP restored via token HUD heal buttons	2026-06-12 17:23:39 +02:00
uberwald	cbeaaeec99	Final fixes and code review checks Release Creation / build (release) Successful in 39s Details	2026-06-12 08:19:42 +02:00
uberwald	37badf2619	fix: attack/defense cross-client reaction flow - C1: Stop D30 auto-roll on non-primary clients (caused divergence) - C2: defenderOwner fallback to GM for monster defenders - C3: Fix tie outcome in handleAttackBoosted (>= not >) - C5: Convert handleAttackBoosted to while-loop (multi-reaction) - C4/C6: shouldCreateMessage cross-client guard - M2: Coordinate main flow defender dialog vs socket handler - M3: Fresh grit/luck reads each socket handler iteration - M4: Include defenseD30message in socket payload + re-process - M5: Communicate attackerHandledBonus in socket payload - i18n: Add missing COMBAT.* keys, fix weapon.hbs label localize - d30_results_tables: Fix string typo	2026-06-12 02:51:59 +02:00
uberwald	5839616863	chore: add pushLDBtoYML/pullYMLtoLDB scripts, gitignore packs_src	2026-06-12 01:56:19 +02:00
uberwald	89298490ef	fix: pre-check 'Save against spell' checkbox in template when saveSpell is true	2026-06-12 01:56:03 +02:00
uberwald	bb42de19bd	REmove unused file	2026-06-11 23:05:55 +02:00
uberwald	53f9c33419	chore: gitignore LevelDB internal files, stop tracking auto-generated LDB bookkeeping Release Creation / build (release) Successful in 46s Details	2026-06-11 23:00:45 +02:00
uberwald	06eba5f835	fix: show spell tier dialog on character sheet cast; duplicate rollTarget to prevent Item mutation	2026-06-11 22:56:54 +02:00
uberwald	46fa2d15a3	fix: allow defender to react when attacker boosts past defense via cross-client socket	2026-06-11 22:41:54 +02:00
uberwald	8aae7bada0	fix: pre-check 'Save against spell' checkbox when defense originates from spell attack	2026-06-11 22:17:37 +02:00
uberwald	ceb62bca3f	fix: add missing class lethal-luck-grit-hud to template so JS selector matches	2026-06-11 22:03:56 +02:00
uberwald	110ac65ba5	fix: replace hardcoded French bleeding notifications with i18n keys	2026-06-11 21:50:19 +02:00
uberwald	9b75fd4d96	feat: combat-tracker-driven bleeding (HP loss per wound per round)	2026-06-11 21:49:35 +02:00
				`@@ -0,0 +1 @@`
				`packs/** filter=lfs diff=lfs merge=lfs -text`