Update version

Author: johnsamuelwrites

.github/workflows/deploy.yml

@@ -48,18 +48,21 @@ jobs:
           test -f public/generated/automate_packed/abi_manifest.json
           test -f public/generated/automate_packed_runtime.mjs
           test -f public/generated/automate_packed/host_shim.mjs
+          test -f public/generated/automate_universel/browser_module.mjs
 
       - name: Verifier la syntaxe JavaScript
         run: |
           node --check public/automate-core.js
           node --check public/app.mjs
           node --check public/generated/automate_packed_runtime.mjs
           node --check public/generated/automate_packed/host_shim.mjs
+          node --check public/generated/automate_universel/browser_module.mjs
 
       - name: Valider le moteur et le WASM
         run: |
           python tests/french_core_smoke.py
           node tests/core_smoke.js
+          node tests/generated_browser_module_smoke.js
           node tests/packed_runtime_smoke.mjs
           node tests/static_site_smoke.js
 

docs/release-checklist.md

@@ -13,6 +13,7 @@ Before publishing a release:
    ```powershell
    python tests\french_core_smoke.py
    node tests\core_smoke.js
+   node tests\generated_browser_module_smoke.js
    node tests\packed_runtime_smoke.mjs
    node tests\static_site_smoke.js
    ```
@@ -40,6 +41,7 @@ Before publishing a release:
 
    - root URL
    - `public/generated/automate_packed/module.wasm`
+   - `public/generated/automate_universel/browser_module.mjs`
    - `examples/*.json`
 
 8. Confirm generated files are not staged:

public/automate-core.js

@@ -247,6 +247,9 @@ function prochaineGeneration(generation, configuration, seed) {
 }
 
 function genererUnivers(configurationBrute) {
+  if (window.AutomaginariumUniversVivant?.generer_univers_detaille) {
+    return window.AutomaginariumUniversVivant.generer_univers_detaille(configurationBrute);
+  }
   const configuration = normaliserConfiguration(configurationBrute);
   const lignes = [creerGenerationInitiale(configuration)];
   const sorties = [lignes[0].map((value) => (
@@ -446,6 +449,9 @@ function encodeList(values) {
 }
 
 function formStateToConfig(formState, currentConfig = {}) {
+  if (window.AutomaginariumUniversVivant?.etat_formulaire_vers_configuration) {
+    return window.AutomaginariumUniversVivant.etat_formulaire_vers_configuration(formState, currentConfig);
+  }
   const inputAlphabet = parseCommaList(formState.alphabetInput, [0, 1]);
   const outputAlphabet = parseCommaList(formState.alphabetOutput, inputAlphabet);
   let neighborhood = Number(formState.neighborhood || 3);
@@ -490,6 +496,13 @@ function formStateToConfig(formState, currentConfig = {}) {
 }
 
 function configToFormState(config) {
+  if (window.AutomaginariumUniversVivant?.configuration_vers_etat_formulaire) {
+    const formState = window.AutomaginariumUniversVivant.configuration_vers_etat_formulaire(config);
+    return {
+      ...formState,
+      json: JSON.stringify({ ...config, numero_regle: String(config.numero_regle || 0n) }, null, 2),
+    };
+  }
   return {
     name: config.nom || "",
     alphabetInput: encodeList(config.alphabet_entree || [0, 1]),
@@ -527,6 +540,9 @@ function individuMutationDepuis(configurationBrute, tauxSur1000, graine) {
 }
 
 function populationInitiale(configBase, taille, graine) {
+  if (window.AutomaginariumUniversVivant?.population_initiale) {
+    return window.AutomaginariumUniversVivant.population_initiale(configBase, taille, graine);
+  }
   const gen = mulberry32(graine);
   const population = [];
   const config = normaliserConfiguration(configBase);
@@ -550,6 +566,9 @@ function selectionTournoi(scores, tailleTournoi, graine) {
 }
 
 function nouvelleGeneration(population, scores, tauxMutationSur1000, graine) {
+  if (window.AutomaginariumUniversVivant?.nouvelle_generation) {
+    return window.AutomaginariumUniversVivant.nouvelle_generation(population, scores, tauxMutationSur1000, graine);
+  }
   const gen = mulberry32(graine);
   const nouvelle = [];
   const meilleurIdx = scores.reduce((best, score, idx) => (score > scores[best] ? idx : best), 0);
@@ -719,6 +738,9 @@ function evaluerPopulation(population, poidsObj = {}) {
 }
 
 function presetPoidsGenetique(nom) {
+  if (window.AutomaginariumUniversVivant?.preset_poids_genetique) {
+    return window.AutomaginariumUniversVivant.preset_poids_genetique(nom);
+  }
   const presets = {
     beau: { symetrie: 8, densite: 5, stabilite: 3, oscillation: 2, complexite: 4, croissance: 1 },
     chaotique: { symetrie: 1, densite: 3, stabilite: 1, oscillation: 2, complexite: 9, croissance: 2 },
@@ -730,6 +752,9 @@ function presetPoidsGenetique(nom) {
 }
 
 function appliquerPerturbation(univers, evenement) {
+  if (window.AutomaginariumUniversVivant?.appliquer_perturbation) {
+    return window.AutomaginariumUniversVivant.appliquer_perturbation(univers, evenement);
+  }
   const { cx, cy, rayon, force, type, graine } = evenement;
   const { configuration, lignes, sorties } = univers;
   const nouvelleLignes = lignes.map((ligne) => [...ligne]);
@@ -830,6 +855,9 @@ function randomRuleNumber(max, seed = Date.now() >>> 0) {
 }
 
 function hudRuleLabel(ruleState) {
+  if (window.AutomaginariumUniversVivant?.etiquette_regle_hud) {
+    return window.AutomaginariumUniversVivant.etiquette_regle_hud(ruleState);
+  }
   const neighborhood = Number(ruleState.neighborhood || 3);
   const channels = Number(ruleState.channels || 1);
   const ruleMode = ruleState.ruleMode || "table";
@@ -1078,6 +1106,9 @@ const construireUniversVivant = buildSemanticCoreV1;
 const sourceUniversVivant = semanticCoreSource;
 
 function ruleSpaceLabel(configuration) {
+  if (window.AutomaginariumUniversVivant?.etiquette_espace_regles) {
+    return window.AutomaginariumUniversVivant.etiquette_espace_regles(configuration);
+  }
   const { s, k, t, m, maxRule } = ruleConfiguration(configuration);
   return `${t}^(${m}·${s}^${k}) = ${maxRule} regles possibles`;
 }
@@ -1096,6 +1127,9 @@ function toutesClesVoisinage(alphabet, taille) {
 }
 
 function validerConfiguration(configurationBrute) {
+  if (window.AutomaginariumUniversVivant?.valider_configuration) {
+    return window.AutomaginariumUniversVivant.valider_configuration(configurationBrute);
+  }
   const config = normaliserConfiguration(configurationBrute);
   const erreurs = [];
   const avertissements = [];

requirements-build.txt

@@ -1 +1 @@
-multilingualprogramming[wasm]==0.6.0
+multilingualprogramming[wasm]==0.8.0

scripts/build_wasm_bundle.py

@@ -71,7 +71,11 @@ def build_french_core() -> None:
                 "resumer_univers_vivant,construire_univers_vivant,source_univers_vivant,"
                 "resumer_configuration,resumer_transition,decrire_configuration,signaux_transition,"
                 "table_wolfram,table_totalistique,assurer_configuration_rendable,"
-                "construire_configuration_regle_generee"
+                "construire_configuration_regle_generee,"
+                "etat_formulaire_vers_configuration,configuration_vers_etat_formulaire,"
+                "valider_configuration,etiquette_espace_regles,etiquette_regle_hud,"
+                "generer_univers_detaille,population_initiale,nouvelle_generation,"
+                "preset_poids_genetique,appliquer_perturbation"
             ),
             "--out",
             str(RICH_BROWSER / "browser_module.mjs"),

src/automate_universel.multi

@@ -458,7 +458,7 @@ def generer_univers_detaille(configuration_brute):
     soit lignes = []
     soit sorties = []
     lignes.append(creer_generation_initiale(configuration))
-    sorties.append([[valeur] pour valeur dans lignes[0]])
+    sorties.append([[valeur pour _ dans range(configuration["nombre_canaux_sortie"])] pour valeur dans lignes[0]])
     pour rang dans range(1, configuration["hauteur"]):
         soit detail = prochaine_generation_detaillee(lignes[rang - 1], configuration, rang)
         lignes.append(detail["generation"])
@@ -737,6 +737,17 @@ def preset_fitness_oscillant():
     retour [4, 5, 3, 9, 5, 1]
 
 
+def preset_poids_genetique(nom):
+    soit presets = {
+        "beau": {"symetrie": 8, "densite": 5, "stabilite": 3, "oscillation": 2, "complexite": 4, "croissance": 1},
+        "chaotique": {"symetrie": 1, "densite": 3, "stabilite": 1, "oscillation": 2, "complexite": 9, "croissance": 2},
+        "stable": {"symetrie": 3, "densite": 4, "stabilite": 9, "oscillation": 1, "complexite": 5, "croissance": 0},
+        "croissance": {"symetrie": 2, "densite": 3, "stabilite": 0, "oscillation": 1, "complexite": 3, "croissance": 9},
+        "oscillant": {"symetrie": 4, "densite": 5, "stabilite": 3, "oscillation": 9, "complexite": 5, "croissance": 1},
+    }
+    retour presets.get(nom, presets["beau"])
+
+
 def etiquette_regle_hud(etat_regle):
     soit voisinage = int(etat_regle.get("neighborhood", 3))
     soit canaux = int(etat_regle.get("channels", 1))
@@ -1107,6 +1118,57 @@ def decrementer_masque_gel(masque_gel):
     retour masque_nouveau
 
 
+def appliquer_perturbation(univers, evenement):
+    soit cx = int(evenement.get("cx", 0))
+    soit cy = int(evenement.get("cy", 0))
+    soit rayon = int(evenement.get("rayon", 1))
+    soit force = float(evenement.get("force", 0.5))
+    soit type_perturbation = evenement.get("type", "pulse")
+    soit graine = int(evenement.get("graine", 1))
+    soit configuration = univers["configuration"]
+    soit lignes = univers["lignes"]
+    soit sorties = univers.get("sorties", None)
+    soit nouvelles_lignes = [list(ligne) pour ligne dans lignes]
+    soit nouvelles_sorties = [[list(cellule) pour cellule dans ligne] pour ligne dans sorties] si sorties != None sinon None
+    soit generateur = random.Random(graine)
+    soit alphabet = configuration.get("alphabet_sortie", configuration.get("alphabet_entree", [0, 1]))
+
+    pour y dans range(max(0, cy - rayon), min(configuration["hauteur"], cy + rayon + 1)):
+        pour x dans range(max(0, cx - rayon), min(configuration["largeur"], cx + rayon + 1)):
+            soit dx = x - cx
+            soit dy = y - cy
+            soit distance = ((dx * dx) + (dy * dy)) ** 0.5
+            si distance > rayon:
+                continuer
+            soit intensite = max(0.0, 1.0 - (distance / (rayon + 1)))
+            soit probabilite = force * intensite
+            si generateur.random() >= probabilite:
+                continuer
+
+            si type_perturbation == "pulse":
+                nouvelles_lignes[y][x] = generateur.choice(alphabet)
+            sinon si type_perturbation == "effacer" ou type_perturbation == "geler":
+                nouvelles_lignes[y][x] = alphabet[0] si len(alphabet) > 0 sinon 0
+            sinon si type_perturbation == "inverser":
+                soit index = alphabet.index(nouvelles_lignes[y][x]) si nouvelles_lignes[y][x] dans alphabet sinon -1
+                nouvelles_lignes[y][x] = alphabet[(index + 1) % len(alphabet)] si index >= 0 sinon alphabet[1] si len(alphabet) > 1 sinon alphabet[0]
+            sinon si type_perturbation == "attirer":
+                nouvelles_lignes[y][x] = alphabet[len(alphabet) // 2]
+            sinon si type_perturbation == "muter":
+                soit index_mutation = alphabet.index(nouvelles_lignes[y][x]) si nouvelles_lignes[y][x] dans alphabet sinon -1
+                si index_mutation >= 0:
+                    soit index_suivant = (index_mutation + 1) % len(alphabet)
+                    nouvelles_lignes[y][x] = alphabet[index_mutation - 1] si generateur.random() < 0.5 et index_mutation > 0 sinon alphabet[index_suivant]
+                sinon:
+                    nouvelles_lignes[y][x] = alphabet[1] si len(alphabet) > 1 sinon alphabet[0]
+
+    retour {
+        "configuration": configuration,
+        "lignes": nouvelles_lignes,
+        "sorties": nouvelles_sorties,
+    }
+
+
 def variance_densite(historique_densites):
     """Returns variance of densities across generation history."""
     si len(historique_densites) < 2:

tests/core_smoke.js

@@ -345,6 +345,36 @@ function testGeneratedLivingUniverseModulePrecedence() {
           effectiveGenerator: `generated-${generator}`,
         };
       },
+      etat_formulaire_vers_configuration(formState) {
+        return { nom: `generated ${formState.name}`, generatedFormConfig: true };
+      },
+      configuration_vers_etat_formulaire(config) {
+        return { name: `generated ${config.nom}`, generatedFormState: true };
+      },
+      valider_configuration() {
+        return { valide: true, erreurs: [], avertissements: ["generated"] };
+      },
+      etiquette_espace_regles() {
+        return "generated rule space";
+      },
+      etiquette_regle_hud() {
+        return "generated hud";
+      },
+      generer_univers_detaille(config) {
+        return { configuration: config, lignes: [["generated"]], sorties: [[["generated"]]] };
+      },
+      population_initiale(_config, taille) {
+        return Array.from({ length: taille }, (_, index) => ({ generatedPopulation: index }));
+      },
+      nouvelle_generation(population) {
+        return [{ generatedNextPopulation: population.length }];
+      },
+      preset_poids_genetique(nom) {
+        return { generatedPreset: nom };
+      },
+      appliquer_perturbation(univers, evenement) {
+        return { ...univers, generatedPerturbation: evenement.type };
+      },
     };
 
     const config = {
@@ -374,6 +404,16 @@ function testGeneratedLivingUniverseModulePrecedence() {
     const built = AutomaginariumCore.buildGeneratedRuleConfig(config, "wolfram", 90);
     assert.equal(built.effectiveGenerator, "generated-wolfram");
     assert.equal(built.config.generatedRuleConfig, true);
+    assert.equal(AutomaginariumCore.formStateToConfig({ name: "Form" }).generatedFormConfig, true);
+    assert.equal(AutomaginariumCore.configToFormState(config).generatedFormState, true);
+    assert.equal(AutomaginariumCore.validerConfiguration(config).avertissements[0], "generated");
+    assert.equal(AutomaginariumCore.ruleSpaceLabel(config), "generated rule space");
+    assert.equal(AutomaginariumCore.hudRuleLabel({}), "generated hud");
+    assert.equal(AutomaginariumCore.genererUnivers(config).lignes[0][0], "generated");
+    assert.equal(AutomaginariumCore.populationInitiale(config, 3, 1).length, 3);
+    assert.equal(AutomaginariumCore.nouvelleGeneration([{ a: 1 }, { b: 2 }], [1, 2], 50, 1)[0].generatedNextPopulation, 2);
+    assert.equal(AutomaginariumCore.presetPoidsGenetique("stable").generatedPreset, "stable");
+    assert.equal(AutomaginariumCore.appliquerPerturbation({ configuration: config, lignes: [], sorties: [] }, { type: "pulse" }).generatedPerturbation, "pulse");
   } finally {
     global.AutomaginariumUniversVivant = previousGenerated;
   }