Export Web/SCORM : port complet du runtime jouable côté navigateur

Phase 1.2 de la feuille de route produit — un paquet SCORM tourne seul
dans le LMS du client, sans serveur Forge Engine disponible. Ajoute
static/js/play/offline/ (miroir JS de screens/rendering/ et
data_actions/, sous window.FORGE_OFFLINE) pour que variables, score,
données d'objet, répéteurs et conditions de visibilité fonctionnent
entièrement en mémoire côté navigateur ; branche actions.js et
bindings.js dessus au lieu d'un fetch() serveur. Ajoute
publish/build_scorm_package.py (paquet statique + imsmanifest.xml
SCORM 1.2 + wrapper API SCORM) et le bouton "Exporter (Web/SCORM)".

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

static/js/play/offline/apply-actions.js

@@ -0,0 +1,163 @@
+// Export Web/SCORM (voir le plan "port complet du runtime jouable côté
+// navigateur") — port fidèle des 5 handlers d'action qui, en ligne,
+// passent par le serveur (voir static/js/play/actions.js) : ici, ils
+// mutent gameData EN PLACE, sans aucun réseau. N'existe que pour
+// window.FORGE_OFFLINE === true (paquet exporté) ; le runtime en ligne
+// garde son comportement actuel, inchangé.
+//
+// Un score/statut de partie n'a PAS de notion per-player hors ligne (un
+// paquet exporté est joué par UNE seule personne à la fois, sur SON
+// poste) : gameData.scoring = {score, status}, pas une carte par joueur
+// comme db/scoring/ côté serveur (voir db.PLAYER_SHARED).
+
+// ---------- Modifier une variable globale ----------
+// Port de screens/data_actions/apply_variable_action.py — même
+// coercion de type, même vocabulaire d'opérations (compute-operation.js),
+// la valeur reste stockée en CHAÎNE (gameData.variables[name].value est
+// toujours une chaîne côté serveur, colonne SQLite TEXT — voir
+// full_game_payload.py) pour que conditions.js continue de la lire
+// exactement comme aujourd'hui.
+function forgeApplyVariableActionOffline(gameData, action) {
+  var varName = action.target_variable;
+  var operation = action.data_operation;
+  var rawValue = action.data_value;
+  if (!varName || !operation) return false;
+  var variable = gameData.variables && gameData.variables[varName];
+  if (!variable) return false;
+  var varType = variable.type;
+  var current = variable.value;
+  if (varType === "nombre_entier" || varType === "nombre_decimal") {
+    current = (current === null || current === undefined || current === "") ? 0 : parseFloat(current);
+    if (isNaN(current)) current = 0;
+  } else if (varType === "booleen") {
+    var normalized = String(current == null ? "" : current).trim().toLowerCase();
+    current = (normalized === "1" || normalized === "true" || normalized === "vrai") ? 1 : 0;
+  }
+  var newValue;
+  try {
+    newValue = forgeComputeNewValue(operation, current, rawValue, varType === "nombre_decimal");
+  } catch (e) {
+    return false;
+  }
+  variable.value = String(newValue);
+  return true;
+}
+
+// ---------- Modifier le score / Définir le statut de la partie ----------
+// Port de apply_score_action.py/apply_status_action.py — voir db/scoring/
+// pour le vocabulaire des statuts (db.SCORE_STATUS_LABELS côté serveur,
+// dupliqué ici en dur : ces 5 clés sont figées, voir db/constants.py).
+var FORGE_SCORE_STATUS_KEYS = ["non_commence", "en_cours", "termine", "reussi", "echoue"];
+
+function forgeApplyScoreActionOffline(gameData, action) {
+  var operation = action.data_operation;
+  var rawValue = action.data_value;
+  if (!operation) return false;
+  if (!gameData.scoring) gameData.scoring = { score: 0, status: "non_commence" };
+  var current = gameData.scoring.score || 0;
+  var newValue;
+  try {
+    newValue = forgeComputeNewValue(operation, current, rawValue, true);
+  } catch (e) {
+    return false;
+  }
+  gameData.scoring.score = newValue;
+  return true;
+}
+
+function forgeApplyStatusActionOffline(gameData, action) {
+  var status = action.data_value;
+  if (!status || FORGE_SCORE_STATUS_KEYS.indexOf(status) === -1) return false;
+  if (!gameData.scoring) gameData.scoring = { score: 0, status: "non_commence" };
+  gameData.scoring.status = status;
+  return true;
+}
+
+// ---------- Modifier une donnée d'un objet ----------
+// Port de apply_data_action.py — même bornage min_value/max_value (voir
+// full_game_payload.py, étendu pour transmettre ces deux bornes au
+// client). gameData.data[definitionId] est un tableau de lignes
+// {champ: valeur, id}, gameData.fields_meta[definitionId] la liste
+// {name, type, min_value, max_value} — même forme que le payload en
+// ligne (screens/payload/full_game_payload.py).
+function forgeFindFieldMeta(gameData, definitionId, fieldName) {
+  var fields = gameData.fields_meta && gameData.fields_meta[definitionId];
+  if (!fields) return null;
+  for (var i = 0; i < fields.length; i++) {
+    if (fields[i].name === fieldName) return fields[i];
+  }
+  return null;
+}
+
+function forgeClampToFieldBounds(value, fieldMeta) {
+  if (fieldMeta.type !== "nombre_entier" && fieldMeta.type !== "nombre_decimal") return value;
+  if (fieldMeta.min_value !== null && fieldMeta.min_value !== undefined && value < fieldMeta.min_value) {
+    value = fieldMeta.min_value;
+  }
+  if (fieldMeta.max_value !== null && fieldMeta.max_value !== undefined && value > fieldMeta.max_value) {
+    value = fieldMeta.max_value;
+  }
+  return fieldMeta.type === "nombre_decimal" ? value : Math.trunc(value);
+}
+
+function forgeApplyDataActionOffline(gameData, action) {
+  var definitionId = String(action.target_definition_id || "");
+  var rowId = action.target_row_id;
+  var fieldName = action.target_field;
+  var operation = action.data_operation;
+  var rawValue = action.data_value;
+  if (!(definitionId && rowId && fieldName && operation)) return false;
+  var fieldMeta = forgeFindFieldMeta(gameData, definitionId, fieldName);
+  if (!fieldMeta) return false;
+  var rows = gameData.data && gameData.data[definitionId];
+  if (!rows) return false;
+  var row = null;
+  for (var i = 0; i < rows.length; i++) {
+    if (rows[i].id === rowId) { row = rows[i]; break; }
+  }
+  if (!row) return false;
+  var current = row[fieldName];
+  var newValue;
+  try {
+    newValue = forgeComputeNewValue(operation, current, rawValue, fieldMeta.type === "nombre_decimal");
+  } catch (e) {
+    return false;
+  }
+  row[fieldName] = forgeClampToFieldBounds(newValue, fieldMeta);
+  return true;
+}
+
+// ---------- Ajouter une ligne à un objet ----------
+// Port de apply_add_row_action.py/db/rows/insert_row.py : une ligne VIDE
+// (aucun champ renseigné — c'est à un ou plusieurs nœuds "Modifier une
+// donnée" enchaînés, ciblant LAST_INSERTED_ROW_ID, de la remplir ensuite),
+// même défauts par type que row_columns_and_values.py (booléen -> 0,
+// tout le reste -> null). L'id est un simple auto-incrément local (pas
+// de vraie base : aucune ligne d'un autre joueur à ignorer hors ligne).
+function forgeApplyAddRowActionOffline(gameData, action) {
+  var definitionId = String(action.target_definition_id || "");
+  if (!definitionId) return null;
+  var fields = gameData.fields_meta && gameData.fields_meta[definitionId];
+  if (!fields) return null;
+  if (!gameData.data[definitionId]) gameData.data[definitionId] = [];
+  var rows = gameData.data[definitionId];
+  var maxId = 0;
+  rows.forEach(function (r) { if (r.id > maxId) maxId = r.id; });
+  var newRow = { id: maxId + 1 };
+  fields.forEach(function (f) {
+    newRow[f.name] = f.type === "booleen" ? 0 : null;
+  });
+  rows.push(newRow);
+  return newRow.id;
+}
+
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = {
+    forgeApplyVariableActionOffline, forgeApplyScoreActionOffline, forgeApplyStatusActionOffline,
+    forgeApplyDataActionOffline, forgeApplyAddRowActionOffline,
+    forgeFindFieldMeta, forgeClampToFieldBounds, FORGE_SCORE_STATUS_KEYS,
+  };
+  // node:test charge ce fichier isolément (voir __tests__/) — forgeComputeNewValue
+  // vit dans compute-operation.js, jamais un <script> séparé en test.
+  global.forgeComputeNewValue = global.forgeComputeNewValue || require('./compute-operation.js').forgeComputeNewValue;
+}