Add connected edge highlights and stable shadow projection for beta.129

README.md

@@ -20,9 +20,13 @@ La [vision complète](docs/vision.md) conserve les intentions ; le
 L’économie, les claims et les dimensions décrits dans la vision restent
 à implémenter.
 
-La version **beta.112** limite l’atelier d’argile à la hotbar active du joueur,
-dans un cadre compact. Les statuaires suivent toujours le regard à la pose.
-Le [ticket](docs/clay-workshop-hotbar-beta112.md) décrit le comportement et les essais.
+La version **beta.129** ajoute les reflets CTM optionnels sur les contours du
+relief, avec une portée indépendante de 16 à 256 blocs. Les surfaces plates
+se raccordent entre tous les matériaux. Les ombres gagnent les portées
+128/256, gardent leur intensité à midi et ne réalignent plus leur grille à
+chaque mouvement du soleil. **Options → Shaders → Sanctuary · Vanilla Light**.
+Le [ticket de livraison](docs/shader-beta129.md) précise le résultat et ses
+vérifications. Publication et synchronisation en cours de préparation.
 La [livraison précédente](docs/clay-workshop-integration-beta110.md) réunit déjà
 l’atelier, les œufs et la neige saisonnière dans l’instance **Sanctuary Beta**.
 Les [synchronisations antérieures](docs/git-sync-beta092.md) restent documentées.
@@ -33,13 +37,140 @@ La [carte native beta.005](docs/atlas-beta005.md) prend le relais après
 l’étude de Xaero et des alternatives libres.
 
 
+## beta.129 — Reflets CTM et ombres jusqu'à 256 blocs
+
+Reflets connectés réglables, cinq portées indépendantes, soleil plein à midi
+et correction du réalignement cyclique de la grille d'ombres.
+[Contrat et vérifications](docs/shader-beta129.md).
+
+## beta.128 — Ombres stables, lune et feuillage
+
+Grille de réception stabilisée, contours nets des blocs, atténuation à midi,
+ombre lunaire légère et feuillage nuancé selon son épaisseur.
+[Contrat et vérifications](docs/shader-beta128.md) ·
+[Pack normal](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.128/Sanctuary-beta.128.mrpack) ·
+[Pack de test](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.128/Sanctuary-Test-beta.128.mrpack).
+
+## beta.127 — Shader : ombres portées pixélisées
+
+Ombres solaires natives, finesse 8/16/32 pixels par bloc et portée 16/32/64 blocs.
+Option désactivée par défaut, réglable sans rechargement des ressources.
+[Contrat et vérifications](docs/shader-beta127.md) ·
+[Pack normal](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.127/Sanctuary-beta.127.mrpack) ·
+[Pack de test](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.127/Sanctuary-Test-beta.127.mrpack).
+
+## beta.126 — Gemmes, argile et découvertes
+
+Rubis et saphir avec filons configurables, couleurs originales avec l'argile,
+commandes de découverte globales ou ciblées.
+[Contrat et vérifications](docs/gems-beta126.md) ·
+[Pack normal](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.126/Sanctuary-beta.126.mrpack) ·
+[Pack de test](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.126/Sanctuary-Test-beta.126.mrpack).
+
+## beta.125 — Sculptures : placement, éclats et animaux
+
+Coins et trois hauteurs sur la grille 1/16 ; particules issues des voxels ;
+modèles découverts disponibles dans le Clay Workshop.
+[Contrat et vérifications](docs/sculpture-placement-beta125.md) ·
+[Pack normal](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.125/Sanctuary-beta.125.mrpack) ·
+[Pack de test](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.125/Sanctuary-Test-beta.125.mrpack).
+
+## beta.124 — Une boîte par sculpture
+
+Sélection et collisions simplifiées, dimensions ajustées et lumière conservée.
+[Contrat et vérifications](docs/sculpture-bounds-beta124.md) ·
+[Pack normal](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.124/Sanctuary-beta.124.mrpack) ·
+[Pack de test](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.124/Sanctuary-Test-beta.124.mrpack).
+
+## beta.123 — Clé dorée et clé de Steve
+
+Orientations cohérentes, inventaires et eau préservés ; clé de Steve pour
+l’édition libre, utilisable aussi en survie. [Contrat et vérifications](docs/wrench-safety-beta123.md) ·
+[Pack normal](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.123/Sanctuary-beta.123.mrpack) ·
+[Pack de test](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.123/Sanctuary-Test-beta.123.mrpack).
+
+## beta.122 — Sculptures : forme et lumière
+
+Collisions et sélection sur les voxels réels, creux traversables, lumière sans
+occlusion cubique. [Contrat et vérifications](docs/sculpture-shape-light-beta122.md) ·
+[Pack normal](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.122/Sanctuary-beta.122.mrpack) ·
+[Pack de test](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.122/Sanctuary-Test-beta.122.mrpack).
+
+## beta.121 — Texture de clé et pack personnel
+
+Copie complète des ressources, création depuis le jeu et guide FR/EN inclus.
+[Contrat et vérifications](docs/resourcepack-template-beta121.md) ·
+[Template personnel](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.121/Sanctuary-Template-beta.121.zip) ·
+[Pack normal](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.121/Sanctuary-beta.121.mrpack) ·
+[Pack de test](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.121/Sanctuary-Test-beta.121.mrpack).
+
+## beta.120 — Clé dorée et états de blocs
+
+Gestes du debug stick, rotation de textures et assemblage des machines conservé.
+[Contrat et vérifications](docs/golden-wrench-beta120.md) ·
+[Pack normal](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.120/Sanctuary-beta.120.mrpack) ·
+[Pack de test](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.120/Sanctuary-Test-beta.120.mrpack).
+
+## beta.119 — Sculptures au centre ou au bord
+
+Pose selon le point visé, centrage sur la grille entière et ancrage conservé
+en sauvegarde. [Contrat et vérifications](docs/sculpture-center-beta119.md) ·
+[Pack normal](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.119/Sanctuary-beta.119.mrpack) ·
+[Pack de test](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.119/Sanctuary-Test-beta.119.mrpack).
+
+## beta.118 — Murets en briques colorées
+
+Seize couleurs, fabrication et tailleur de pierre, eau, raccords et collisions
+natifs. [Contrat et vérifications](docs/colored-brick-walls-beta118.md) ·
+[Pack normal](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.118/Sanctuary-beta.118.mrpack) ·
+[Pack de test](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.118/Sanctuary-Test-beta.118.mrpack).
+
+## beta.117 — Grain des textures et sculptures en chapeau
+
+Les petits cubes d'une sculpture reprennent plusieurs nuances des textures
+de la matière. Le modèle reste intact dans le slot chapeau et au retrait.
+[Contrat et vérifications](docs/sculpture-texture-grain-beta117.md) ·
+[Pack normal](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.117/Sanctuary-beta.117.mrpack) ·
+[Pack de test](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.117/Sanctuary-Test-beta.117.mrpack).
+
+## beta.116 — Matières de sculpture et Fourneau
+
+Un bloc de matière devient une sculpture aux couleurs de sa texture. Hotbar,
+orientation et ancrage conservés. Le Fourneau accepte les dépôts dans chacune
+de ses 27 cases et explique sa chauffe commune.
+[Contrat et vérifications](docs/sculpture-materials-beta116.md) ·
+[Pack normal](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.116/Sanctuary-beta.116.mrpack) ·
+[Pack de test](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.116/Sanctuary-Test-beta.116.mrpack).
+
+## beta.115 — Fourneau : dépôts et chauffe
+
+Correctif du décalage par trois cases, combustible stable et progression
+par cuisson. [Diagnostic et essais](docs/fourneau-transfers-beta115.md).
+Étape locale intégrée à la livraison commune beta.116.
+
+## beta.114 — Animaux portés et fuite en vol
+
+Un animal volant porté entraîne son porteur après un coup. La trajectoire
+aléatoire prend brièvement le dessus sur les commandes ; déposer l’animal
+interrompt le vol. [Contrat et vérifications](docs/carried-flight-panic-beta114.md) ·
+[Pack normal](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.114/Sanctuary-beta.114.mrpack) ·
+[Pack de test](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.114/Sanctuary-Test-beta.114.mrpack).
+
+## beta.113 — Sculptures d’argile et alignement
+
+Pose contre le bord visé, orientation selon le regard et coordonnées entières
+pour chaque voxel, y compris les modèles de largeur impaire. L’accroche est
+conservée à la reconnexion. [Contrat et vérifications](docs/clay-sculpture-grid-beta113.md) ·
+[Pack normal](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.113/Sanctuary-beta.113.mrpack) ·
+[Pack de test](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.113/Sanctuary-Test-beta.113.mrpack).
+
 ## beta.112 — Atelier d’argile et hotbar
 
 Neuf cases de hotbar et deux emplacements de fabrication, dans un cadre fixe.
 Les transferts restent dans la hotbar ; une barre pleine ne consomme pas d’argile.
 [Contrat et vérifications](docs/clay-workshop-hotbar-beta112.md) ·
-[Pack normal](build/Sanctuary-beta.112.mrpack) ·
-[Pack de test](build/Sanctuary-Test-beta.112.mrpack).
+[Pack normal](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.112/Sanctuary-beta.112.mrpack) ·
+[Pack de test](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.112/Sanctuary-Test-beta.112.mrpack).
 
 ## beta.111 — Atelier d’argile et pose orientée
 
@@ -2071,7 +2202,7 @@ Depuis beta.090, la cible est **Minecraft 26.3 finale**, publiée le 15 septembr
 | Fabric API | 0.160.5+26.3 |
 | Fabric Loom | 1.17.20 |
 | Gradle Wrapper | 9.5.1, distribution vérifiée par SHA-256 |
-| Sanctuary / pack | beta.112 |
+| Sanctuary / pack | beta.122 |
 
 Java 25 et Python 3.11 ou plus récent sont nécessaires. Le script pack utilise
 uniquement la bibliothèque standard et repère aussi une installation Python
@@ -2100,7 +2231,7 @@ décrits dans [Validation](docs/testing.md).
 
 Résultats :
 
-- `mods/sanctuary/build/libs/sanctuary-beta.112.jar` : mod à installer avec
+- `mods/sanctuary/build/libs/sanctuary-beta.122.jar` : mod à installer avec
   Fabric API sur la version Minecraft indiquée.
 - `build/packwiz/` : pack de développement complet, avec le mod construit et
   l'index vérifié. Voir [Installation packwiz](packwiz/README.md).

THIRD_PARTY_NOTICES.md

@@ -127,3 +127,12 @@ de modèles, butin et états reprennent leurs équivalents natifs 26.3.
 `tools/generate-colored-bricks.py` documente cette transformation ;
 `tools/colored-bricks-palette.json` conserve couleurs et empreintes des PNG fournis.
 Ces ressources dérivées ne sont pas présentées comme des créations originales.
+
+## Clé dorée beta.121
+
+Le PNG 16 × 16 `golden_wrench.png` a été fourni par le créateur de Sanctuary
+le 17 septembre 2026. Il est conservé octet pour octet dans le mod, le pack
+intégré et le template personnel (SHA-256
+`a97570908db75caf8e6fc2f5ecabf12c54fd99bfea7be634df66c4310dca22af`).
+Le template regroupe les ressources client déjà distribuées par Sanctuary ;
+leurs crédits et conditions respectives restent applicables.

build.gradle

@@ -15,7 +15,7 @@ tasks.register('verifyPack', Exec) {
 tasks.register('assemblePack', Exec) {
     group = 'distribution'
     description = 'Assemble a local packwiz pack including the built Sanctuary mod.'
-    dependsOn(':sanctuary:build', 'verifyPack', 'assembleResourcePack')
+    dependsOn(':sanctuary:build', 'verifyPack', 'assembleResourcePack', 'assembleResourceTemplate')
     commandLine('python3', 'scripts/pack.py', 'assemble')
 }
 
@@ -46,3 +46,21 @@ tasks.register('assembleTestPack', Exec) {
     dependsOn('assemblePack', ':sanctuary-test:build')
     commandLine('python3', 'scripts/test_pack.py')
 }
+
+tasks.register('assembleResourceTemplate', Zip) {
+    group = 'distribution'
+    description = 'Export all Sanctuary client assets as an editable personal resource pack.'
+    dependsOn(':sanctuary:processResources', 'verifyResourcePack')
+    def resources = project(':sanctuary').layout.buildDirectory.dir('resources/main')
+    // Same precedence as the native exporter: built-in textures override mod defaults.
+    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+    from(resources.map { it.dir('resourcepacks/textures/assets') }) { into 'assets' }
+    from(resources.map { it.dir('assets') }) { into 'assets' }
+    from(resources.map { it.dir('resourcepacks/template') })
+    from(resources.map { it.file('resourcepacks/textures/pack.png') })
+    exclude '**/.DS_Store'
+    destinationDirectory = layout.buildDirectory
+    archiveFileName = "Sanctuary-Template-${mod_version}.zip"
+    preserveFileTimestamps = false
+    reproducibleFileOrder = true
+}

docs/carried-flight-panic-beta114.md

@@ -0,0 +1,91 @@
+# CARRY-08 — Fuite des animaux volants portés — beta.114
+
+Contrat du 17 septembre 2026, branche `codex/carried-flight-panic-beta114`.
+
+Un coup reçu par un animal volant porté sur la tête déclenche une fuite de
+40 à 60 ticks : il entraîne son porteur vers le haut, dans une direction
+aléatoire, avec des embardées. Le serveur choisit le départ et la trajectoire,
+transmis au client pour la physique native. Les touches de déplacement et le
+regard ne pilotent pas cette brève fuite. La caméra reste libre. Un nouveau coup peut relancer la fuite avec un autre
+cap après dix ticks, sans cumuler les vitesses.
+
+Le porteur peut viser et frapper son animal volant. Les animaux ordinaires
+reçoivent les dégâts habituels ; le familier conserve son coup amical sans
+perte de santé. Les attaques extérieures acceptées déclenchent aussi la fuite.
+Les autres protections entre passagers et porteurs restent en place.
+Les espèces reprennent le groupe déjà utilisé pour planer, poule comprise.
+
+La vitesse reste bornée, les collisions sont natives et aucun bloc n’est
+traversé ni déplacé. Déposer l’animal (Maj + clic droit), le perdre, mourir,
+se déconnecter ou changer de dimension arrête la propulsion. Immersion,
+mode spectateur, vol créatif, élytres et porteur lui-même passager l’inhibent.
+La fin de fuite rend le contrôle au joueur et conserve le planeur existant
+si l’animal reste porté. Les montures colossales gardent leur pilotage actuel.
+
+L’état de fuite est temporaire, synchronisé et non sauvegardé. Aucun format
+persistant, identifiant existant ou monde personnel n’est modifié. Les nouveaux
+retours d’interface sont traduits FR/EN. Client et serveur utilisent beta.114.
+
+## Vérifications natives
+
+`CarryPanic114ClientChecks` passe en **56 secondes** avec un serveur intégré
+Minecraft 26.3 et un monde plat jetable de graine 114 :
+
+- Véritable ciblage du perroquet sur la tête et frappe avec la touche native,
+  perte de santé de l’animal ordinaire, décollage et déplacement du joueur.
+- Trajectoire synchronisée et priorité sur les touches avant/droite/saut et
+  le regard ; comparaison exacte avec la vitesse du tick de physique.
+- Expiration, suppression de l’état temporaire et retour au planeur normal.
+- 32 trajectoires tirées côté serveur couvrent les quatre quadrants, toutes
+  dans les bornes de durée et de vitesse ; Maj + clic droit natif interrompt.
+- Sept espèces ordinaires : poule, chauve-souris, abeille, allay, perroquet,
+  blaze et breeze. Une vache portée reste protégée et ne déclenche aucun vol.
+- Attaque extérieure, mort, activation du vol créatif et détachement arrêtent
+  ou déclenchent la réaction selon le contrat.
+- Plafond bas : aucune traversée ; le passager bloqué est déposé par les
+  contrôles de place existants et la propulsion s’interrompt.
+- Véritable coup amical sur un familier perroquet : lancement sans perte de
+  santé, puis arrêt immédiat lors du détachement.
+
+```sh
+./gradlew :sanctuary:runClientGameTest \
+  -PsanctuaryClientTests=true -PsanctuaryCarryPanic114ClientTests=true \
+  -PsanctuaryClientNoVsync=true -PsanctuaryQuickTests=true
+```
+
+Marqueurs `CARRY114_NATIVE_FLIGHT_PASS` et `CARRY114_PASS` dans
+`build/carry-panic114-client.log`. Capture en jeu relue dans
+`build/carry-panic114-evidence/`. Le GameTest dédié reste exclu conformément
+au refus antérieur de son EULA. Pas de test Windows, de réseau distant ou de
+latence simulée ; aucun monde personnel n’a été ouvert.
+
+## Livraison
+
+`./gradlew check build assemblePack assembleTestPack -x :sanctuary:runGameTest`
+passe en **2 min 22 s**, 125 tâches. Les sources JAR correspondent exactement
+aux sources du dépôt. Les classes et ressources hors de ce ticket restent
+identiques à beta.113, notamment les sculptures d’argile. Les deux packs
+contiennent le même JAR, sans monde, GLB ni classes de test.
+
+- Sanctuary-beta.114.mrpack : 10179428 octets, SHA-256
+  `92aac61c2c00a2206f3f5ac3d170ab058f6765526cf5a2a64c5336261db3f5bf`.
+- Sanctuary-Test-beta.114.mrpack : 10198350 octets, SHA-256
+  `5e8ec1f18e34ca51e09e2738f2b04f9a1bbac5d14c7a7c2d766218a4cff6021f`.
+- JAR Sanctuary : SHA-256
+  `18105b76f63008210c62d5728f999c7abc083a861ecc1de2c7ee87262dde5a40`.
+
+Reçu local : `build/carry-panic114-artifact.json`.
+
+## Publication et installation
+
+La [release beta.114](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.114)
+est publiée depuis `21845bd7367a260ee6a3d189417a8620aa5bf738`. Le tag exact
+et les artefacts sont immuables ; les téléchargements publics sont vérifiés.
+Le canal packwiz avance à `c26f3bb59491c9bb4bbdd27f59571ef84f417f7b`.
+
+Deux synchronisations isolées puis deux passages dans **Sanctuary Beta** ont
+réussi. Un seul JAR Sanctuary beta.114 est actif, et le second passage conserve
+les mêmes hashes. Les **923 fichiers personnels et réglages suivis** restent
+identiques. Aucun monde personnel n’a été ouvert. La sauvegarde ciblée est
+`sanctuary-backups/before-beta.114/` dans l’instance existante. Reçus locaux :
+`build/carry-panic114-isolated.json` et `build/carry-panic114-prism.json`.

docs/clay-sculpture-grid-beta113.md

@@ -0,0 +1,90 @@
+# STAT-04 — Sculptures d’argile et accroche au bord — beta.113
+
+Contrat du 17 septembre 2026, branche `codex/clay-sculpture-grid-beta113`.
+
+Les miniatures de l’atelier deviennent des « sculptures d’argile » / « Clay
+sculptures ». Le nom du modèle reste dans leur infobulle. Les statues en blocs
+du Métabli restent une catégorie distincte.
+
+À la pose, le bord horizontal le plus proche du point visé accueille la
+sculpture. L’autre axe est centré au pixel entier le plus proche, sur la grille
+de 1/16 de bloc. Sur une face latérale, elle touche le bord du bloc support.
+À égalité exacte entre deux bords, l’axe Z départage ; au centre exact,
+le bord côté joueur est retenu. L’orientation suit toujours le regard.
+Le bouton Tourner prépare le modèle avant fabrication. Les marges horizontales vides du modèle ne créent pas de décalage au bord.
+Tous les sommets restent
+sur la grille entière, même avec des dimensions impaires et après rotation.
+
+## Compatibilité préalable
+
+La propriété native additive `anchor` du bloc `sanctuary:statuary` mémorise
+`center`, `north`, `south`, `east` ou `west`. Un ancien état sans cette propriété
+prend `center` : il reste centré, avec la correction visuelle du demi-voxel.
+Le schéma 1, les voxels, noms de modèles et identifiants ne changent pas.
+Il n’y a aucun parcours ni réécriture de chunks existants. La sauvegarde native
+conserve l’accroche ; les rotations et miroirs de structures la transforment.
+Casser et reposer choisit une nouvelle accroche sans modifier le modèle.
+Les nouveaux objets emploient le nom traduit de leur type ; les noms déjà
+enregistrés et les noms personnalisés restent conservés. La collision cubique
+et la limite d’une sculpture par bloc restent inchangées. Client et serveur
+doivent utiliser ensemble beta.113.
+
+## Vérifications natives
+
+Le parcours `Statuary106ClientChecks`, étendu par `Sculpture113ClientChecks`,
+passe en **1 min 25 s**, sur Minecraft 26.3 et un monde plat jetable de graine 106 :
+
+- 5 120 combinaisons de largeur/profondeur, orientation et accroche : contrôle
+  de la géométrie émise, grille exacte de 1/16 et absence de dépassement du bloc.
+- Modèles avec marges transparentes, repères colorés pour vérifier le sens du
+  rendu et égalité de la géométrie centrée entre l’objet et le bloc.
+- Vrais clics de pose sur les quatre bords : orientation, bord côté serveur,
+  réception côté client, butin/repose et conservation après reconnexion.
+- Contextes natifs de pose sur les faces latérales et coordonnées négatives.
+- Rotation/miroir de chaque combinaison d’accroche et d’orientation ; lecture
+  des anciens états sans `anchor`, avec et sans `facing`.
+- Noms français/anglais des objets fabriqués, menu aux échelles 2 et 3,
+  fabrication payée, Maj-clic limité à la hotbar et régression Métabli.
+
+```sh
+./gradlew :sanctuary:runClientGameTest \
+  -PsanctuaryClientTests=true -PsanctuaryStatuary106ClientTests=true \
+  -PsanctuaryClientNoVsync=true -PsanctuaryQuickTests=true
+```
+
+Marqueurs `STATUARY113_PASS` et `SCULPTURE113_GEOMETRY_PASS` dans
+`build/clay-grid113-client.log`. Captures relues dans
+`build/clay-grid113-evidence/`. Le GameTest dédié reste exclu conformément au
+refus antérieur de son EULA ; ces essais utilisent le serveur intégré macOS.
+Pas de validation Windows ni depuis deux ordinateurs. Aucun monde personnel
+n’a été ouvert.
+
+## Livraison
+
+`./gradlew check build assemblePack assembleTestPack -x :sanctuary:runGameTest`
+passe en **3 min 11 s**, 125 tâches. Les sources JAR correspondent exactement
+aux sources du dépôt. Les classes et ressources hors du ticket sont identiques
+à beta.112. Les deux packs contiennent le même JAR, sans monde, GLB ni test.
+
+- Sanctuary-beta.113.mrpack : 10173807 octets, SHA-256
+  `ed082ff29a0e9a70fd6786bc024241b276cb516bc09fb5151d6cb324604429bb`.
+- Sanctuary-Test-beta.113.mrpack : 10192733 octets, SHA-256
+  `387f54dc77884a9c9bccdcc1904778ca7f0b2fbda126754fdc49b10a492e4602`.
+- JAR Sanctuary : SHA-256
+  `e242d9fd2edeede922a72a10e988e29c2b49dea52105cfc9fc8573154849ead3`.
+
+Reçu local : `build/clay-grid113-artifact.json`.
+
+## Publication et installation
+
+La [release beta.113](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.113)
+est publiée depuis `6166d0aa9eba3c3dd84b8b9f1501e3346231ac82`. Le tag exact
+et les artefacts sont immuables ; les téléchargements publics sont vérifiés.
+Le canal packwiz avance à `e4c16d517bfda4f2b688604cc61945a46a4513a9`.
+
+Deux synchronisations isolées puis deux passages dans **Sanctuary Beta** ont
+réussi. Un seul JAR Sanctuary beta.113 est actif, et le second passage conserve
+les mêmes hashes. Les **923 fichiers personnels et réglages suivis** restent
+identiques. Aucun monde personnel n’a été ouvert. La sauvegarde ciblée est
+`sanctuary-backups/before-beta.113/` dans l’instance existante. Reçus locaux :
+`build/clay-grid113-isolated.json` et `build/clay-grid113-prism.json`.

docs/clay-workshop-hotbar-beta112.md

@@ -62,5 +62,18 @@ Les deux packs contiennent le même JAR, sans monde, GLB ni classes de tests.
 - JAR : SHA-256
   `9007a770bbe69db5846f93140d910514f10839cc34ec7c6315a9381d8850adaa`.
 
-Reçu local : `build/clay-hotbar112-artifact.json`. Publication et mise à jour
-de l’instance stable préparées après ces contrôles.
+Reçu local : `build/clay-hotbar112-artifact.json`.
+
+## Publication et installation
+
+La [release beta.112](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.112)
+est publiée depuis `1eaa976ecf328c6c20afe5e4eb67c48118f87f95`. Le tag exact
+et les artefacts sont immuables ; les téléchargements publics sont vérifiés.
+Le canal packwiz avance à `573c5b0d84fcb3e9fec7cc8a83981cf35eaa1ead`.
+
+Deux synchronisations isolées puis deux passages dans **Sanctuary Beta** ont
+réussi. Un seul JAR Sanctuary beta.112 est actif, et le second passage conserve
+les mêmes hashes. Les **923 fichiers personnels et réglages suivis** restent
+identiques. Aucun monde personnel n’a été ouvert. La sauvegarde ciblée est
+`sanctuary-backups/before-beta.112/` dans l’instance existante. Reçus locaux :
+`build/clay-hotbar112-isolated.json` et `build/clay-hotbar112-prism.json`.

docs/colored-brick-walls-beta118.md

@@ -0,0 +1,83 @@
+# beta.118 — Murets en briques de couleur
+
+Ticket sur `codex/colored-brick-walls-beta118`, Minecraft 26.3.
+
+Les seize familles de briques reçoivent un muret natif `WallBlock`, sous
+l'identifiant `sanctuary:<couleur>_brick_wall`. Chaque muret réutilise la texture
+de briques fournie de sa couleur, sans nouvelle image ni recoloration.
+
+Les murets forment une série de seize dans **Blocs colorés**, après les dalles
+et avant les argiles, dans l'ordre des couleurs vanilla retenu en beta.103.
+Les libellés sont traduits FR/EN.
+
+Recettes : six briques de même couleur, en deux rangées de trois, donnent six
+murets ; le tailleur de pierre donne un muret par bloc de briques. Les deux
+recettes par couleur rejoignent la collection Argile et briques et leurs
+déblocages. Totaux des ajouts colorés : 80 blocs, 112 objets dont ces blocs,
+224 recettes. Les recettes et identifiants préexistants sont conservés.
+
+Piliers, raccords entre couleurs et aux murets vanilla, côtés hauts/bas,
+collisions et immersion dans l'eau viennent du jeu. Tags natifs `walls`
+pour blocs et objets, pioche et butin de la bonne couleur. États, modèles
+multipart et butins sont repris des ressources exactes Minecraft 26.3.
+
+La génération reste reproductible dans `tools/generate-colored-bricks.py` ;
+elle conserve les ajouts externes à ses briques, notamment la recette du
+Clay Workshop et les membres Sculpture/Atelier. Le compilateur des collections
+reste leur seul générateur. Aucun ajout au
+terrain, changement de format ou migration de sauvegarde. Les dépendances
+et le pack de textures intégré beta.090 restent inchangés.
+
+## Vérifications et livraison
+
+Le scénario natif `Bricks102ClientChecks`, complété par `Walls118Checks`,
+passe en **38 secondes** sur un nouveau monde plat de graine 102 avec serveur
+intégré Minecraft 26.3 :
+
+- Seize murets réellement posés, dont une seconde série dans l'eau.
+- Recette de six murets et tailleur de pierre pour chaque couleur ; les
+  anciennes recettes de briques, dalles, escaliers et argiles passent aussi.
+- Raccords entre couleurs et au muret vanilla, retrait des piliers intermédiaires,
+  côtés relevés sous un bloc plein, collisions identiques au muret vanilla.
+- Eau conservée, pioche, butin de la bonne couleur, collection et recettes
+  découvertes, recette du Clay Workshop toujours découverte, série créative
+  de seize dans l'ordre natif.
+- États et modèles de tous les blocs de la famille vérifiés, sans texture
+  manquante ; sauvegarde et reconnexion conservent les murets et leur eau.
+
+Log : `build/walls118-client.log`, marqueur `WALLS118_PASS`. Capture de la
+galerie relue dans `build/walls118-evidence/`. Aucun essai Windows ou LAN ;
+GameTest dédié exclu selon le refus antérieur de son EULA. Aucun monde personnel
+ouvert. La régénération finale conserve à l'identique 2 024 fichiers de
+ressources et métadonnées.
+
+`check build assemblePack assembleTestPack -x :sanctuary:runGameTest` réussit
+en **2 min 5 s**, 125 tâches dont 101 exécutées. Sources et JAR concordants,
+intégrité ZIP, versions, modèles natifs, recettes et empreintes vérifiés.
+La comparaison avec beta.117 limite les changements de classes à
+`ColoredBricks` et ses classes internes ; les sculptures et chapeaux restent
+identiques. Les textures existantes sont toutes conservées octet pour octet.
+
+- `Sanctuary-beta.118.mrpack` : 10216437 octets, SHA-256
+  `75bb04aad981644888690aaeda9a293a94c5d32f6439ca24613365a41aba1b6b`.
+- `Sanctuary-Test-beta.118.mrpack` : 10235359 octets, SHA-256
+  `f7f0a177b8472f0e8c34ad99a1ccef5d61396014017d260e934e910c4e6eb00f`.
+- JAR Sanctuary :
+  `fc6edf4046a8ace357d561ed942213a22c7a27164fa160cdb4316f72ec302575`.
+
+Reçu : `build/walls118-artifact.json`.
+
+## Publication et instance
+
+La [release beta.118](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.118)
+est publiée : JAR, MRpack normal/Test et amorçage Prism, téléchargements publics
+et empreintes vérifiés. Le tag immuable désigne
+`0a81b3c1471c43d705eec4e31a8f6f1820049ca8`. Le canal packwiz avance au commit
+`e6bab433bea9528f67d39af0d6c7bcb6443e4817`.
+
+Deux synchronisations isolées puis deux dans l'unique instance **Sanctuary
+Beta** réussissent, la seconde passe laissant les fichiers gérés identiques.
+Un seul JAR Sanctuary beta.118 est actif. Les 923 fichiers personnels et
+réglages suivis sont inchangés ; aucun monde personnel n'a été ouvert.
+Copie préalable des fichiers remplacés dans `sanctuary-backups/before-beta.118/`.
+Reçus : `build/walls118-isolated.json`, `build/walls118-prism.json`.

docs/fourneau-transfers-beta115.md

@@ -0,0 +1,74 @@
+# beta.115 — Dépôts et chauffe du Fourneau
+
+Ticket sur `codex/fourneau-transfers-beta115`, après le signalement de piles
+qui se réalignent pendant les dépôts rapides avec Maj, dans Ingrédients et
+Combustibles, et d'une chauffe difficile à comprendre.
+
+## Diagnostic
+
+La méthode `mayPlace` de la case serveur utilisait `index`, masqué par le
+champ hérité `Slot.index` (position affichée). Elle validait donc successivement
+une entrée, un combustible et une sortie, au lieu des 27 entrées ou des
+27 combustibles. Le client acceptait le dépôt puis le serveur le refusait.
+Le test reproduit le refus d’un déplacement de la case 1 vers la case 23.
+Le correctif utilise explicitement `physicalIndex` pour la validation.
+
+## Comportement
+
+Les transferts Maj dans les vues complètes du Fourneau sont anticipés sur le
+client, avec les mêmes destinations et règles de combustible que le serveur.
+Les cases se remplissent dans l'ordre, après fusion des piles compatibles.
+Un dépôt manuel conserve la case choisie ; aucun tri périodique des ingrédients
+n'est ajouté. Les recherches masquent une partie du stock : leurs transferts
+entrants continuent d'attendre la réponse du serveur, qui connaît tout le stock.
+
+La chauffe emprunte du combustible à une autre case uniquement pendant le tick
+natif. La pile non brûlée retourne immédiatement à sa case d'origine, avec tous
+ses composants. Les restes natifs restent associés à leur cuisson : un seau de
+lave devient un seau, puis un seau d'eau avec une éponge mouillée.
+
+Les 27 entrées ont chacune une barre et une infobulle : cuisson en cours,
+manque de combustible avec progression conservée, résultat bloqué, absence de
+recette. Le panneau indique le nombre de cuissons et la réserve allumée en
+secondes de travail cumulées. Ce n'est pas une durée réelle restante : les
+cuissons parallèles se partagent la réserve. « Fonctionnement » explique les
+onglets, les gestes et le rendement normal du combustible en FR/EN.
+
+Les recettes, résultats, expérience et règles de trémies restent natifs.
+Aucun changement de format, de monde ou de génération ; les 27 fours physiques
+conservent l'unique copie des objets et de leurs temps de chauffe.
+
+## Vérifications
+
+Le test natif `Furnace115ClientChecks` passe avec un serveur intégré, sur un
+nouveau monde plat de graine 115 : vrai glisser avec Maj sur neuf piles nommées,
+remplissage consécutif, déplacement manuel vers la case 23 et répartition native
+sur six cases de colonnes différentes. Les 27 cases de chaque onglet valident
+leur rôle physique. Le combustible nommé conserve sa position et ses composants.
+
+La cuisson parallèle, ses états synchronisés, la progression conservée à court
+de combustible, les 27 cuissons ravitaillées, le seau de lave et l'éponge,
+l'extraction des résultats et la sauvegarde native passent. Captures FR/EN
+relues dans `build/furnace115-evidence/`. Marqueur `FURNACE115_PASS` dans
+`build/furnace115-client.log`.
+
+`check build assemblePack assembleTestPack -x :sanctuary:runGameTest` réussit
+en 2 min 29 s, 125 tâches. Le panneau d'aide reçoit ensuite une dernière
+vérification client et une reconstruction ; la livraison commune beta.116
+repasse les contrôles complets en 2 min 23 s et le scénario Fourneau en 42 s.
+
+Le GameTest dédié reste exclu conformément au refus antérieur de son EULA.
+Pas d'essai Windows ou de réseau distant avec latence simulée. Aucun monde
+personnel ouvert. Cette étape reste locale et rejoint la livraison commune
+avec les matériaux de sculpture : [beta.116](sculpture-materials-beta116.md).
+
+Archives locales vérifiées (même JAR Sanctuary, sources concordantes, aucune
+classe de test ni changement de production extérieur au ticket) :
+
+- `Sanctuary-beta.115.mrpack` : 10184430 octets, SHA-256
+  `8fcac63b1bf5a01f680fb46666924705db3a2675e102037278e9d650d04cbf22`.
+- `Sanctuary-Test-beta.115.mrpack` : 10203354 octets, SHA-256
+  `5b98fdb8842690158a20b422d6aa5496d74e572b3429498ffb25476d24e87f8a`.
+- JAR Sanctuary : `2066d3191d7ee27904927fab269d8160136f048742c3223713e8ed4fe90dd8f5`.
+
+Reçu : `build/furnace115-artifact.json`.

docs/gems-beta126.md

@@ -0,0 +1,152 @@
+# GEM-01 — Gemmes, argile et découvertes — beta.126
+
+Contrat du 17 septembre 2026, branche `codex/gems-beta126`, Minecraft 26.3.
+
+Deux gemmes natives complètent l'émeraude : `sanctuary:ruby` et
+`sanctuary:sapphire`. Chaque famille comprend un bloc de stockage, un minerai
+ordinaire et un minerai des abîmes. Les huit PNG du créateur sont copiés à
+l'identique ; leurs empreintes figurent dans `tools/gems-textures-beta126.json`.
+Les noms des fichiers français `saphir` sont associés aux identifiants anglais
+stables `sapphire`, sans modifier les pixels. Les deux items utilisent les fichiers de remplacement
+`Desktop/ruby.png` et `Desktop/saphir.png` fournis en fin de livraison.
+
+L'ordre créatif est émeraude, rubis, saphir : ingrédients, blocs de stockage,
+minerais ordinaires et minerais des abîmes dans leurs onglets natifs respectifs.
+Minage à la pioche de fer ou mieux, résistance et expérience comme l'émeraude,
+Fortune, Toucher de soie, cuisson/four à fusion et conversion 9 gemmes ↔ 1 bloc.
+Les blocs peuvent former un socle de balise et les gemmes servir de paiement.
+Les recettes rejoignent la collection actuelle de l'émeraude, sans ajouter de
+transactions de villageois. Libellés français et anglais, tags communs `c:`.
+
+## Génération procédurale et contrat de compatibilité
+
+Profil initial **gemmes 1 / beta.126** : quatre tentatives par chunk et par
+gemme, filons natifs de taille 3, hauteur uniforme Y0–256, probabilité de rejet
+au contact de l'air de 0,25. Ces nombres sont un réglage initial à équilibrer
+lors de la future refonte ; aucun quota de gemmes par chunk n'est garanti.
+Les variantes ordinaires remplacent les roches du tag vanilla
+`stone_ore_replaceables`, les variantes des abîmes celles de
+`deepslate_ore_replaceables`.
+
+Les fichiers `worldgen/feature/ore_<gemme>.json`,
+`worldgen/placed_feature/ore_<gemme>.json` et les tags de biomes
+`has_ore/<gemme>` séparent les cibles, la forme, la fréquence, la hauteur et
+les régions. Un datapack peut les remplacer sans recompiler le mod. Le code
+réutilise `OreFeature` et le hasard natif issu de la graine ; il limite ces
+filons aux mondes utilisant `SanctuaryChunkGenerator`. Les biomes vanilla
+partagés avec Sanctuary restent compatibles sans ajouter les gemmes aux
+mondes vanilla, au Nether ou à l'End.
+
+Cette évolution additive est autorisée pour les **nouveaux chunks uniquement**.
+Aucun remplissage rétrospectif, aucune régénération, aucun remplacement de chunk
+sauvegardé ni activation d'expansion. Les codecs du relief, les dimensions et
+le format des sauvegardes restent inchangés. Les filons suivent les protections
+existantes de la décoration native. Les anciens profils expérimentaux précédant
+le générateur Sanctuary unifié ne sont pas étendus.
+
+## Argile spéciale dans le Clay Workshop
+
+Le bloc d'argile vanilla conserve les couleurs échantillonnées sur le modèle
+original, animal découvert ou import GLB. Les argiles colorées et les autres
+blocs continuent à transférer leur palette de texture. Une même règle est
+appliquée à l'aperçu client et au résultat serveur. Le changement de matériau
+invalide le résultat même si les deux palettes sont identiques. Le texte de
+l'atelier explique l'exception en français et en anglais.
+
+Une sculpture coûte toujours un bloc ; aucune recette, découverte, donnée de
+sculpture déjà fabriquée ni règle de placement n'est modifiée.
+
+## Commande de découverte commune
+
+`/sanctuary discovery all` découvre tous les blocs, objets et espèces enregistrés.
+Les variantes `blocks all`, `items all` et `mobs all` ciblent une catégorie ;
+`block <identifiant>`, `item <identifiant>` et `mob <identifiant>` ciblent une
+entrée avec la complétion native. Un sélecteur de joueurs en fin de commande
+est facultatif ; sans cible, elle s'applique au joueur qui l'exécute.
+
+Exemples :
+
+```mcfunction
+/sanctuary discovery all
+/sanctuary discovery mobs all
+/sanctuary discovery block minecraft:stone
+/sanctuary discovery item minecraft:diamond
+/sanctuary discovery mob minecraft:cow
+/sanctuary discovery all @a
+```
+
+La permission suit « Autoriser les commandes » en solo et les droits opérateur
+sur serveur. La console doit préciser la cible. Les identifiants invalides,
+l'air et les types d'entités sans espèce découvrable sont refusés.
+
+Les blocs passent par le registre de découvertes et son événement existant ;
+les objets passent par `RecipeService.discover`. Les collections et recettes
+sont ensuite recalculées normalement. Les espèces rejoignent `seen_mobs`,
+la même donnée que l'observation naturelle, consommée par les familiers,
+le Métabli et le Clay Workshop. Il n'existe aucun drapeau de déblocage parallèle.
+Les catalogues déjà ouverts sont à rouvrir après la commande.
+
+La commande conserve les quantités possédées et les compteurs de combat,
+minage, pose et fabrication. Elle ne donne pas d'objets, n'achète pas les skills
+et n'attribue pas d'advancements. Les recettes réservées aux opérateurs gardent
+leurs règles. Les historiques personnels sont enrichis sans changer leur
+schéma ; la commande refuse les données illisibles plutôt que les remplacer.
+
+## Vérifications
+
+Client natif Minecraft 26.3 / Java 25, `Gems126ClientChecks`, réussi en
+1 min 08 s. Les mondes sont jetables, sans sauvegarde personnelle ouverte :
+
+- Les huit items et six blocs sont présents, avec les huit textures exactes.
+  Quatre groupes créatifs respectent émeraude → rubis → saphir, sans doublons.
+- Douze recettes natives, découverte du bloc de stockage, outil fer minimum,
+  Fortune III, Toucher de soie et balises passent les contrôles serveur.
+- Graine **126**, profil gemmes 1, 81 chunks autour de l'origine : 7 rubis dans
+  la pierre et 8 dans la roche des abîmes ; 15 saphirs dans la pierre et 10 dans
+  la roche des abîmes. La génération est refusée dans le monde plat vanilla.
+  Les minerais persistent à la reconnexion, et un minerai retiré ne réapparaît pas.
+- L'argile conserve exactement les couleurs des voxels d'une vache et d'un GLB
+  texturé. Bois et argile colorée transfèrent toujours leur palette. Le retour
+  à l'argile, l'égalité aperçu/résultat et le coût d'un bloc en survie sont vérifiés.
+- La commande native respecte « Autoriser les commandes », accepte une cible
+  et la console, refuse les identifiants invalides et permet une espèce, un
+  bloc, un objet, toutes les espèces ou tout le contenu. Les recettes liées
+  sont recalculées. La répétition est idempotente et les découvertes survivent
+  à la reconnexion sans inventer de compteurs de combat ou de possession.
+
+Logs et captures dans `build/gems126-client.log` et
+`mods/sanctuary/build/run/clientGameTest/screenshots/`. Le GameTest dédié
+reste exclu conformément au refus antérieur de son EULA. Le build complet et
+les archives sont vérifiés séparément avant publication.
+
+
+Build final `./gradlew check build assemblePack assembleTestPack
+-x :sanctuary:runGameTest` réussi en **2 min 10 s**, 126 tâches. Les contrôles
+natifs de gameplay précèdent uniquement le remplacement final des deux PNG
+d'items ; les huit fichiers livrés sont vérifiés à l'octet près contre les
+sources, tous en 16 × 16. Les JAR de sources correspondent aux sources courantes.
+L'audit entre les binaires beta.125 et beta.126 ne trouve que les 112 entrées
+de production prévues. Les archives normal/Test contiennent le même mod et
+le template reproduit exactement ses ressources exportables.
+
+| Artefact | SHA-256 |
+| --- | --- |
+| `Sanctuary-beta.126.mrpack` | `716221ce24549781ab91f5437ad2310497b198a4b61c43c40c67a27984365ae5` |
+| `Sanctuary-Test-beta.126.mrpack` | `bbf22d7dd72e6746538b4ec28686f699225d4a59372304e5db42140a80e88bd1` |
+| `sanctuary-beta.126.jar` | `85dbe1b41d98751029bb62e87d259522f8609758896c797b1e02fa7656ec0342` |
+
+## Publication et synchronisation
+
+[Release beta.126](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.126)
+publiée depuis `99860af312a1737d938812f3515fcc4acb4291b2` ; artefacts
+immuables retéléchargés et vérifiés. Canal packwiz : `31749b95d21ce5bced6b9e5759499da6f8a67e6e`.
+Deux synchronisations isolées, puis deux synchronisations de l'instance existante
+**Sanctuary Beta** ont réussi. Un seul JAR Sanctuary beta.126, correspondant
+à l'empreinte ci-dessus. Les **923 fichiers personnels** suivis sont conservés,
+sauvegardes restées fermées ; copie préalable dans
+`sanctuary-backups/before-beta.126/`.
+
+Packs normal/Test et template copiés et vérifiés dans
+`sanctuary-beta/build/`. Reçus locaux : `build/gems126-artifact.json`,
+`build/gems126-isolated.json`, `build/gems126-prism.json` et
+`build/gems126-publication.log`.

docs/golden-wrench-beta120.md

@@ -0,0 +1,109 @@
+# TOOL-01 — Clé dorée et états de blocs — beta.120
+
+Contrat du 17 septembre 2026, branche `codex/golden-wrench-beta120`.
+Le créateur valide les gestes du debug stick : clic gauche choisit la propriété,
+clic droit parcourt ses valeurs, Maj inverse le parcours. L'orientation est
+proposée en premier, puis les propriétés de forme et les autres états natifs.
+La sélection est personnelle, par type de bloc, pour la session courante.
+Une indication dans la barre d'action affiche la propriété et sa valeur.
+La clé ne casse pas le bloc, y compris en créatif, et ne remplace pas son type.
+
+Les propriétés natives sont disponibles en survie avec la clé, sans condition
+opérateur, dans le respect des droits de construction, protections, portée et
+verrous de conteneurs. Comme avec le debug stick, les formes choisies restent
+en place immédiatement ; les mises à jour ultérieures du jeu peuvent recalculer
+les états dynamiques (redstone, connexions, cultures…).
+
+Les multiblocs assemblés gardent leurs commandes d'ouverture/dissociation et
+leurs propriétés techniques ne sont pas éditées individuellement. Un assemblage
+complet garde priorité au clic droit ; Maj permet de régler les composants
+non assemblés. Hors d'un assemblage complet, même un four, un baril, un piston
+ou un établi reçoit l'action générique.
+
+## Rotation de texture et contrat de stockage
+
+La terre n'a pas d'orientation dans son blockstate vanilla. Une propriété
+supplémentaire de la clé, « Rotation des textures », parcourt 0°, 90°, 180° et
+270° sur les faces des modèles de blocs. La géométrie, l'éclairage, les teintes,
+les ressources actives, le bloc, son inventaire et son butin restent natifs.
+Les rendus spéciaux d'entités de blocs ne sont pas transformés par ce réglage
+des faces ; leur orientation demeure modifiable par leurs états natifs.
+
+Nouvelle donnée facultative `sanctuary:wrench_textures_v1`, attachée au chunk :
+table immuable position entière → quart de tour (1 à 3). Une absence signifie
+0°. Elle n'est créée qu'après une action de clé ; revenir à 0° retire l'entrée,
+puis l'attachement s'il est vide. Aucun état vanilla ni format existant n'est
+modifié ; aucun parcours, conversion ou régénération des anciens mondes.
+Les modifications de blockstate du même type conservent la rotation. Casser,
+remplacer ou déplacer par piston retire la rotation à l'ancienne position ;
+les objets récupérés restent ordinaires. Les nouveaux clients la reçoivent
+après le chunk natif, par lots bornés de 1 024 entrées au maximum.
+Déconnexion, changement de dimension et déchargement libèrent le cache visuel.
+Revenir à une ancienne version du mod supprime seulement cet effet visuel ;
+les blocs conservent leurs identifiants, données et états natifs.
+
+## Vérifications et livraison
+
+Le parcours `Wrench120ClientChecks` passe en **47 s** sur Minecraft 26.3,
+client macOS et serveur intégré, dans un monde plat jetable de graine 120 :
+
+- **2 522 propriétés natives** parcourues, avec valeurs inverses et type conservé.
+- Vrais clics sur les escaliers : orientation, moitié supérieure et forme,
+  sans casser le bloc en créatif ; gestes inverses et sélection distincte.
+  Les doubles événements créatifs d'un même clic sont filtrés à la cadence
+  native de cinq ticks.
+- Terre en survie : rotation réelle des UV émis, positions des sommets et nombre
+  de faces identiques ; retour exact après quatre quarts de tour ou un inverse.
+- Rechargement des ressources conservant les UV tournés ; capture de terre relue.
+- Coffre tourné avec ses 23 diamants intacts, sans ouverture accidentelle.
+- Assemblage/dissociation par vrais clics des quatre familles : Métabli, Fût,
+  Fourneau et super piston. Un clic gauche sur un assemblage ne modifie pas
+  les numéros de composants ; barils et pistons isolés tournent normalement.
+- Refus en aventure, spectateur ou hors portée ; retrait des données visuelles
+  après remplacement, maintien lors d'un changement d'état du même bloc.
+- Sauvegarde/reconnexion : rotation de terre côté serveur et client, état
+  natif de l'escalier et inventaire du coffre conservés.
+
+```sh
+./gradlew :sanctuary:runClientGameTest \
+  -PsanctuaryClientTests=true -PsanctuaryWrench120ClientTests=true \
+  -PsanctuaryClientNoVsync=true -PsanctuaryQuickTests=true
+```
+
+Marqueurs `WRENCH120_PASS` et `WRENCH120_PROPERTIES 2522` dans
+`build/wrench120-client.log`, captures dans `build/wrench120-evidence/`.
+Aucun monde personnel ouvert ; pas de validation Windows ni depuis deux
+ordinateurs. Les rendus de faces natifs et le rechargement du pack sont vérifiés ;
+pas de validation spécifique d'un shader tiers.
+Le GameTest dédié reste exclu conformément au refus antérieur de son EULA.
+
+`./gradlew check build assemblePack assembleTestPack -x :sanctuary:runGameTest`
+passe en **2 min 12 s**, 125 tâches. Les sources JAR correspondent exactement
+aux sources du dépôt. La comparaison avec beta.119 limite les différences de
+production aux classes de clé/assemblage, aux deux nouveaux hooks, au rendu
+et aux libellés prévus ; toutes les autres ressources sont identiques.
+Les packs normal/Test contiennent le même JAR Sanctuary et aucune sauvegarde
+ni fixture de test.
+
+- Sanctuary-beta.120.mrpack : 10237973 octets, SHA-256
+  `86b5e480a12ba20b5c1e308c77dbb54bdf8a56806915fb32ca2d16f9a72cc9c9`.
+- Sanctuary-Test-beta.120.mrpack : 10256895 octets, SHA-256
+  `2e3818483ba7dfa6e5652b97933e105a44e7cc4b269fc567116bf895d54bd8d9`.
+- JAR Sanctuary : SHA-256
+  `8e35ef0f134a46b7760604175ad768264946d31fdd0694982e049e7a928fde2a`.
+
+Reçu local : `build/wrench120-artifact.json`.
+
+## Publication et installation
+
+La [release beta.120](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.120)
+est publiée depuis `248dff47b7a0ebd11026230581fe69641dbde76d`. Le tag exact et les
+artefacts sont immuables ; leurs téléchargements publics sont vérifiés.
+Le canal packwiz avance à `e8060764a444a58b0a17318a3821dfeb1a0c33c6`.
+
+Deux synchronisations isolées puis deux dans **Sanctuary Beta** réussissent.
+Un seul JAR Sanctuary beta.120 est actif ; le second passage est identique.
+Les **923 fichiers personnels et réglages suivis** restent inchangés, sans
+ouvrir de monde personnel. Copie préalable dans
+`sanctuary-backups/before-beta.120/` de l'instance existante. Reçus locaux :
+`build/wrench120-isolated.json` et `build/wrench120-prism.json`.

docs/packwiz.md

@@ -14,6 +14,157 @@ JAR Sanctuary sont des pièces jointes de releases Gitea. Aucun JAR de mod ou
 dépendance téléchargée n'entre dans l'historique Git. Le canal Beta est distinct
 de l'ancien pack 26.2.
 
+## beta.128 — stabilité des ombres, lune et feuillage
+
+Ombres des blocs nettes et stabilisées, atténuation à midi, lune légère et
+feuillage nuancé selon son épaisseur. [Contrat et vérifications](shader-beta128.md).
+[Release beta.128](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.128)
+publiée ; canal `eba01726ee132a6e548d129fa7ee04f24c880917`. Deux synchronisations isolées
+puis deux dans la même instance **Sanctuary Beta** réussies. Les 923 fichiers
+personnels suivis, réglages de shaders compris, sont conservés. Aucun monde
+personnel ouvert ; copie préalable dans `sanctuary-backups/before-beta.128/`.
+Packs normal/Test et template copiés et vérifiés dans `sanctuary-beta/build/`.
+
+## beta.127 — shader et ombres pixélisées
+
+Ombres solaires optionnelles intégrées à Sanctuary · Vanilla Light, avec finesse
+et portée réglables. Socle beta.126 conservé. [Contrat et vérifications](shader-beta127.md).
+[Release beta.127](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.127)
+publiée ; canal `7fd24a43e01ee497a23311e3c78e1dd3dddd877a`. Deux synchronisations
+isolées puis deux dans la même instance **Sanctuary Beta** réussies.
+Les 923 fichiers personnels suivis, réglages de shaders compris, sont conservés.
+Aucun monde personnel ouvert ; copie préalable dans `sanctuary-backups/before-beta.127/`.
+Packs normal/Test et template copiés et vérifiés dans `sanctuary-beta/build/`.
+
+## beta.126 — gemmes, argile et découvertes
+
+Rubis et saphir, nouvelles textures d'items, argile conservant les couleurs
+originales et commandes de découverte communes aux recettes et catalogues.
+[Contrat et vérifications](gems-beta126.md).
+[Release beta.126](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.126)
+publiée ; canal `31749b95d21ce5bced6b9e5759499da6f8a67e6e`. Deux synchronisations
+isolées puis deux dans la même instance **Sanctuary Beta** réussies.
+Les 923 fichiers personnels et réglages suivis sont inchangés ; sauvegardes
+restées fermées. Copie préalable dans `sanctuary-backups/before-beta.126/`.
+Packs normal/Test et template copiés et vérifiés dans `sanctuary-beta/build/`.
+
+## beta.125 — placement, éclats et animaux sculptés
+
+Coins et trois hauteurs, particules de voxels et espèces découvertes au Clay
+Workshop. [Contrat et vérifications](sculpture-placement-beta125.md).
+[Release beta.125](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.125)
+publiée ; canal `47eb833911a96eef0b13805dafe65b2ab7b95c87`. Deux
+synchronisations isolées puis deux dans la même instance **Sanctuary Beta**
+réussies. Les 923 fichiers personnels et réglages suivis sont inchangés ;
+sauvegardes restées fermées. Copie préalable dans
+`sanctuary-backups/before-beta.125/`. Packs normal/Test et template copiés
+et vérifiés dans le dossier habituel `sanctuary-beta/build/`.
+
+## beta.124 — une boîte par sculpture
+
+Une boîte ajustée commune à la sélection et aux collisions ; détails physiques
+simplifiés, orientation/ancrage et éclairage conservés.
+[Contrat et vérifications](sculpture-bounds-beta124.md).
+[Release beta.124](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.124)
+publiée ; canal `67ebcc7d07f8b75e8988f6099e3d6e5704f123fb`. Deux
+synchronisations isolées puis deux dans la même instance **Sanctuary Beta**
+réussies. Les 923 fichiers personnels et réglages suivis sont inchangés ;
+sauvegardes restées fermées. Copie préalable des fichiers remplacés dans
+`sanctuary-backups/before-beta.124/`. Packs normal/Test et template également
+copiés et vérifiés dans le dossier habituel `sanctuary-beta/build/`.
+
+## beta.123 — clé dorée et clé de Steve
+
+La clé dorée se limite aux orientations cohérentes ; la clé de Steve reprend
+les états et textures libres, utilisables aussi en survie dès sa récupération.
+[Contrat et vérifications](wrench-safety-beta123.md).
+[Release beta.123](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.123)
+publiée ; canal `f988d01b901f2d3eda0b4ab47a48540dc627d1b5`. Deux
+synchronisations isolées puis deux dans la même instance **Sanctuary Beta**
+réussies. Les 923 fichiers personnels et réglages suivis sont inchangés ;
+sauvegardes restées fermées. Copie préalable des fichiers remplacés dans
+`sanctuary-backups/before-beta.123/`.
+
+## beta.122 — formes et lumière des sculptures
+
+Sélection et collisions sur les voxels réels ; suppression de l'occlusion cubique.
+[Contrat et vérifications](sculpture-shape-light-beta122.md).
+[Release beta.122](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.122)
+publiée ; canal `3d340bea0093b709c6018624795a1b3ca557b72d`. Deux
+synchronisations isolées puis deux dans la même instance **Sanctuary Beta**
+réussies. Les 923 fichiers personnels et réglages suivis sont inchangés ;
+sauvegardes restées fermées. Copie préalable des fichiers remplacés dans
+`sanctuary-backups/before-beta.122/`.
+
+## beta.121 — texture de clé et pack personnel
+
+PNG du créateur et copie complète modifiable depuis l'écran des packs.
+[Contrat et vérifications](resourcepack-template-beta121.md).
+[Release beta.121](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.121)
+publiée ; canal `e3e6572da9288fbbcfa36bf6b7dd3aa0d1c54f5e`. Deux
+synchronisations isolées puis deux dans la même instance **Sanctuary Beta**
+réussies. Les 923 fichiers personnels et réglages suivis sont inchangés ;
+sauvegardes restées fermées. Copie préalable des fichiers remplacés dans
+`sanctuary-backups/before-beta.121/`. Le template personnel est créé par le
+joueur, jamais géré ou réécrit par packwiz.
+
+## beta.120 — clé dorée et états de blocs
+
+Gestes du debug stick, rotation des textures et assemblages prioritaires.
+[Contrat et vérifications](golden-wrench-beta120.md).
+[Release beta.120](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.120)
+publiée ; canal `e8060764a444a58b0a17318a3821dfeb1a0c33c6`. Deux
+synchronisations isolées puis deux dans la même instance **Sanctuary Beta**
+réussies. Les 923 fichiers personnels et réglages suivis sont inchangés ;
+sauvegardes restées fermées. Copie préalable des fichiers remplacés dans
+`sanctuary-backups/before-beta.120/`.
+
+## beta.119 — pose centrée des sculptures
+
+Centre accessible au point visé, bords conservés et grille entière de 1/16.
+[Contrat et vérifications](sculpture-center-beta119.md).
+[Release beta.119](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.119)
+publiée ; canal `5e823af7807f524f6394acad402fe62328c7e4ab`. Deux
+synchronisations isolées puis deux dans la même instance **Sanctuary Beta**
+réussies. Les 923 fichiers personnels et réglages suivis sont inchangés ;
+sauvegardes restées fermées. Copie préalable des fichiers remplacés dans
+`sanctuary-backups/before-beta.119/`.
+
+## beta.118 — murets en briques colorées
+
+Seize murets natifs, recettes, tailleur, eau et série créative par couleurs.
+[Contrat et vérifications](colored-brick-walls-beta118.md).
+[Release beta.118](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.118)
+publiée ; canal `e6bab433bea9528f67d39af0d6c7bcb6443e4817`. Deux
+synchronisations isolées puis deux dans la même instance **Sanctuary Beta**
+réussies. Les 923 fichiers personnels et réglages suivis sont inchangés ;
+sauvegardes restées fermées. Copie préalable des fichiers remplacés dans
+`sanctuary-backups/before-beta.118/`.
+
+## beta.117 — grain des textures et sculptures en chapeau
+
+Échantillonnage des pixels de plusieurs textures, grain stable même sur un
+modèle uni et conservation des données du chapeau.
+[Contrat et vérifications](sculpture-texture-grain-beta117.md).
+[Release beta.117](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.117)
+publiée ; canal `a5b75a70f86e42afb8e06ba4daa9880d61c6373e`. Deux
+synchronisations isolées puis deux dans la même instance **Sanctuary Beta**
+réussies. Les 923 fichiers personnels et réglages suivis sont inchangés ;
+sauvegardes restées fermées. Copie préalable des fichiers remplacés dans
+`sanctuary-backups/before-beta.117/`.
+
+## beta.116 — palettes de sculpture et Fourneau
+
+Le Clay Workshop utilise les nuances des textures de blocs ; le Fourneau
+corrige les décalages de cases et explique la chauffe.
+[Contrat et vérifications](sculpture-materials-beta116.md).
+[Release beta.116](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.116)
+publiée ; canal `c741870160f8a21f0a9793f20f0e624ebdbacdb6`. Deux
+synchronisations isolées puis deux dans la même instance **Sanctuary Beta**
+réussies. Les 923 fichiers personnels et réglages suivis sont inchangés ;
+sauvegardes restées fermées. Copie préalable des fichiers remplacés dans
+`sanctuary-backups/before-beta.116/`.
+
 ## beta.110 — version commune
 
 Clay Workshop, Statuaire et import GLB intégrés aux œufs et à la neige saisonnière.

docs/pixel-shadows-source122.md

@@ -0,0 +1,128 @@
+# Préparation locale des ombres portées pixélisées (ancien numéro beta.122)
+
+Ticket du 17 septembre 2026, branche locale `codex/pixel-shadows-beta122`.
+Cette préparation n'a jamais été publiée sous le numéro beta.122, déjà utilisé
+par une autre livraison. Elle est intégrée au socle beta.126 et livrée en
+[beta.127](shader-beta127.md). Les chemins et mesures ci-dessous décrivent
+les essais historiques dans le dossier de préparation.
+Demande : ajouter aux réglages de Sanctuary · Vanilla Light des ombres portées
+pixélisées, avec une finesse et une distance réglables.
+
+## Utilisation
+
+Dans **Options → Shaders**, activer **Sanctuary · Vanilla Light**, puis
+**Ombres portées pixélisées**. L'option est désactivée par défaut pour conserver
+le coût et le rendu des installations existantes. Les choix sont :
+
+- finesse de **8, 16 ou 32 pixels par bloc**, défaut 16 ;
+- distance de **16, 32 ou 64 blocs**, défaut 32.
+
+Ces préférences sont conservées dans `config/sanctuary-shaders.json`, avec les
+anciens champs de couleur. Leurs valeurs numériques sont ramenées aux choix
+admis au chargement. Les libellés et explications sont disponibles en FR/EN.
+Les réglages s'appliquent sans recharger les ressources.
+
+## Rendu et périmètre
+
+Une carte de profondeur rend les formes d'occultation des blocs solides chargés
+autour de la caméra, indépendamment de leur présence à l'écran. Les dalles et
+escaliers conservent leurs formes. Le cache est invalidé par les changements de
+blocs, les paquets de chunks et les reconstructions du moteur natif.
+La direction solaire vient du ciel natif extrait par Minecraft, et respecte
+ainsi l'angle solaire de Sanctuary. L'effet s'atténue sous la pluie, à l'horizon,
+dans la brume et à la limite de sa portée. Il s'arrête la nuit, dans les dimensions
+sans soleil, dans les fluides et lorsqu'un moteur externe suspend Vanilla Light.
+
+La profondeur du monde est lue directement par le GPU après le rendu du monde,
+avant la main et l'interface. L'inverse de la projection réelle inclut les effets
+de caméra. Les points recevant l'ombre sont arrondis sur une grille ancrée dans
+le monde ; le plan de la face est conservé pour limiter les auto-ombres.
+La carte solaire utilise également une origine alignée sur ses texels.
+Le HUD, la main, les étoiles et les captures panoramiques techniques gardent leur
+chemin de rendu. Aucun niveau de lumière de gameplay, règle serveur, sauvegarde
+ou générateur n'est changé. Aucune dépendance de rendu n'est ajoutée.
+
+Cette première version couvre les **formes d'occultation des blocs** : les entités
+conservent leurs ombres natives ; les feuillages ajourés, modèles non occultants,
+block entities animés, eau et verre ne projettent pas de nouvelles silhouettes.
+Les transparences et particules déjà composées peuvent recevoir l'assombrissement
+du terrain derrière elles. Il n'y a pas d'ombres de lune ou de torches, ni de
+séparation de l'éclairage local émissif dans cette passe d'assombrissement.
+
+## Coût et cycle de vie
+
+Les maillages sont mis en cache par section de 16³, avec au plus quatre sections
+commencées par image et un budget souple de 3 ms pour leur construction. Les
+ombres apparaissent progressivement pendant la préparation après activation ou
+déplacement. Le volume des obstacles part de la portée choisie avec une marge de huit blocs,
+puis s’étend vers le soleil sur deux fois cette portée, arrondi aux sections.
+Les obstacles au-delà de ce volume ou dans des chunks non chargés ne sont pas
+représentés. Les mises à jour de lumière seule ne reconstruisent pas les formes.
+Le cache de sommets est plafonné à 96 Mio et omet les formes pathologiques qui
+dépassent ses limites. Les textures de profondeur font entre 512 et 4 096 pixels
+de côté selon finesse et portée. Le coût exact dépend de la scène et du GPU.
+
+Les ressources sont libérées à la désactivation, au changement de monde, à la
+reconstruction des ressources et à l'arrêt du client. Cette livraison est locale :
+aucun avancement du canal packwiz ni installation personnelle ne fait partie du
+ticket.
+
+## Vérification
+
+Validation native sur **Minecraft 26.3, Java 25, macOS / Apple M1, OpenGL 4.1**,
+dans un nouveau monde plat de développement, graine **122** :
+
+- Comparaison GPU activation/désactivation sur une plateforme blanche avec
+  pilier, dalle et escalier : **920 échantillons assombris**, 63 412 inchangés,
+  aucun éclairci sur les 64 332 échantillons de sol retenus.
+- Pilier entièrement hors du frustum : **42 048 échantillons** restent dans
+  son ombre. Le retrait du pilier restitue la lumière sur **42 048 / 42 048**
+  échantillons et préserve les 23 616 échantillons déjà éclairés. Sa repose
+  restitue la même ombre, sans désactiver le cache entre ces manipulations.
+- Les trois finesses et les trois portées sont appliquées en direct ; les cartes
+  GPU sont redimensionnées aux dimensions attendues. Désactiver l'option libère
+  la texture et ne soumet plus de passe d'ombres.
+- À minuit, activer ou désactiver l'option donne la même image et aucune passe
+  solaire n'est soumise. Au retour du jour, le rendu reprend.
+- Le rechargement des ressources restitue la même image. Les préférences
+  persistent à la relecture du fichier et leurs valeurs extrêmes sont bornées.
+- Menus FR/EN inspectés en capture ; les libellés tiennent dans les contrôles
+  natifs à la taille de test. Les vues de finesse 8/16/32 sont conservées.
+
+```sh
+./gradlew :sanctuary:runClientGameTest \
+  -PsanctuaryClientTests=true -PsanctuaryPixelShadows122ClientTests=true \
+  -PsanctuaryClientNoVsync=true -PsanctuaryQuickTests=true
+```
+
+Succès en **1 min 17 s**, marqueur `PIXEL_SHADOWS122_CLIENT_PASS` dans
+`build/pixel-shadows122-client.log`. Captures inspectées dans
+`build/pixel-shadows122-evidence/final/`. Les pixels sont relus uniquement dans
+le test ; le code de rendu de production n'effectue aucune lecture CPU de GPU.
+Les premiers démarrages ont permis de corriger les identifiants de pipelines,
+la directive GLSL `#include` attendue par 26.3 et deux libellés répétés du menu.
+
+La commande de livraison est :
+
+```sh
+./gradlew check build assemblePack assembleTestPack -x :sanctuary:runGameTest
+```
+
+Le serveur GameTest dédié est exclu, conformément au refus de son EULA déjà
+consigné dans les livraisons précédentes. Le test graphique utilise le serveur
+intégré de son monde neuf. Aucun monde personnel n'est ouvert.
+La construction finale **réussit en 2 min 18 s** (126 tâches), journal
+`build/pixel-shadows122-build-final.log`. Le contrôle des archives confirme
+**868 sources Java** et **1 869 classes** identiques aux sorties construites,
+les ressources GLSL/FR/EN exactes dans le JAR et le template, et le même JAR
+dans les profils packwiz normal et Test. Aucune fixture cliente n'est embarquée.
+Reçu : `build/pixel-shadows122-artifact.json`.
+
+Artefacts locaux : `mods/sanctuary/build/libs/sanctuary-beta.122.jar`,
+`build/packwiz/`, `build/packwiz-test/` et `build/Sanctuary-Template-beta.122.zip`.
+SHA-256 du JAR :
+`66987681cede1d2adc1dda449078e8fa85310eb2c3fecd7a905d772ce75739c9`.
+
+Pas de mesure de FPS, d'essai Windows/Vulkan, de pack Iris ni de silhouettes
+animées revendiqués. Le shader reste un assombrissement graphique appliqué au
+rendu opaque et déjà composé, avec les limites de transparence décrites plus haut.

docs/resourcepack-template-beta121.md

@@ -0,0 +1,125 @@
+# RP-02 — Clé dorée et pack personnel — beta.121
+
+Contrat du 17 septembre 2026, branche `codex/resourcepack-template-beta121`.
+Le créateur fournit `golden_wrench.png` et valide un bouton qui crée une copie
+personnelle complète, modifiable et jamais écrasée par les mises à jour.
+
+## Résultat
+
+La clé dorée reprend exactement le PNG fourni, 16 × 16, sans conversion ni
+redessin. Le modèle reste un item plat `minecraft:item/handheld`. Empreinte :
+`a97570908db75caf8e6fc2f5ecabf12c54fd99bfea7be634df66c4310dca22af`.
+Le même fichier est fourni par le mod et par « Textures Sanctuary » ; désactiver
+le pack intégré conserve donc aussi la nouvelle clé.
+
+Dans **Options → Packs de ressources**, **Personnaliser Sanctuary** crée
+`resourcepacks/Sanctuary-Custom/`. Le bouton devient **Ouvrir ma copie**.
+La copie contient toutes les ressources client de Sanctuary : textures, modèles,
+étiquettes d'items, blockstates, sons, shaders, langues et remplacements Minecraft
+présents dans le pack intégré. Celui-ci prend priorité sur les assets de base
+lors de l'export. Un guide FR/EN, la licence et les crédits accompagnent la copie.
+
+Le joueur active sa copie avec les commandes natives et la place au-dessus des
+packs qu'il veut remplacer. Créer la copie ne change ni l'ordre ni la sélection.
+Une modification se recharge avec F3 + T ; désactiver le pack retrouve les
+ressources fournies par le mod. L'écran de sélection des datapacks n'est pas modifié.
+
+La copie est un **instantané**. Elle ne se synchronise pas avec les mises à jour :
+les fichiers personnalisés restent toujours intacts. Le guide recommande de
+supprimer les fichiers non personnalisés pour laisser les prochaines ressources
+du mod s'appliquer. Pour repartir d'un instantané récent, renommer le dossier
+existant puis créer une nouvelle copie. Aucun fichier utilisateur n'est écrasé.
+
+La copie s'effectue hors du fil de rendu, dans un dossier temporaire voisin,
+puis le résultat complet rejoint la liste native. Une erreur de copie est
+signalée par le bouton et le journal du jeu ; un chemin occupé par un fichier
+n'est pas remplacé. Aucune extraction au démarrage ni pendant les mises à jour.
+
+## Distribution
+
+`./gradlew assembleResourceTemplate` produit
+`build/Sanctuary-Template-beta.121.zip`, un pack personnel complet à décompresser
+dans `resourcepacks/Sanctuary-Custom/`. `assemblePack` le produit aussi.
+`build/Sanctuary-Resource-Pack-beta.121.zip` reste l'export du pack graphique
+intégré ; son manifeste versionné contient 151 fichiers et les images historiques
+sont conservées. L'identifiant intégré `sanctuary:textures` reste stable et son
+activation reste contrôlée par le joueur.
+
+Le template ne contient pas tous les assets vanilla ni ceux des autres mods.
+Il ne contient pas les recettes, règles serveur ou sauvegardes. Il conserve
+les crédits et conditions des ressources d'origine. Aucune génération, aucun
+identifiant de bloc et aucun format de sauvegarde ne changent.
+
+## Vérifications
+
+Le parcours `ResourceTemplate121ClientChecks` passe en **35 s** sur le client
+Minecraft 26.3 macOS, sans ouvrir de monde :
+
+- Bouton natif et disposition FR/EN aux échelles 2 et 3, captures relues.
+- Export complet de **1 202 fichiers**, empreintes identiques aux ressources
+  sources après application des priorités du pack intégré.
+- PNG fourni vérifié par SHA-256 et affiché avec sa transparence.
+- Création sans changer la sélection ni l'ordre des packs.
+- Modification d'une texture et ajout d'un fichier personnel : aucun octet
+  réécrit lors d'un second export ni au rechargement des ressources.
+- Priorité réelle de la texture personnalisée, puis retour à la clé fournie
+  après désactivation. Activation et désactivation conservées à la redécouverte.
+- Chemin occupé par un fichier refusé sans le modifier ; aucun bouton ajouté
+  à l'écran des datapacks.
+
+```sh
+./gradlew :sanctuary:runClientGameTest \
+  -PsanctuaryClientTests=true -PsanctuaryResourceTemplate121ClientTests=true \
+  -PsanctuaryClientNoVsync=true -PsanctuaryQuickTests=true
+```
+
+Marqueur `TEMPLATE121_PASS` dans `build/template121-client.log` ; captures et
+empreintes de la copie dans `build/template121-evidence/`. Le premier essai
+avait échoué dans l'aperçu du test qui créait un ItemStack avant connexion à
+un monde ; cet aperçu affiche maintenant directement la texture résolue.
+Le modèle plat existant n'est pas modifié. Pas d'essai Windows ni d'ouverture
+automatisée du gestionnaire de fichiers. Le GameTest serveur dédié reste exclu
+conformément au refus antérieur de son EULA.
+
+`./gradlew check build assemblePack assembleTestPack -x :sanctuary:runGameTest`
+passe en **2 min 10 s**, 126 tâches. Les sources JAR correspondent aux sources
+Java du dépôt. La comparaison avec beta.120 limite les différences de production
+aux deux nouvelles classes, au hook d'interface, aux libellés et aux ressources
+prévues (12 entrées). Aucun changement de gameplay, de données serveur ou de
+monde. Les packs normal/Test contiennent le même JAR Sanctuary, sans fixture
+ni sauvegarde. Le ZIP du template et l'export natif ont exactement les mêmes
+1 202 fichiers et empreintes. Le pack intégré conserve ses 151 fichiers vérifiés.
+
+Reçu : `build/template121-artifact.json`. Artefacts locaux validés :
+
+- `Sanctuary-beta.121.mrpack` : 10261791 octets, SHA-256
+  `040d68f342155120fa21e0ffcdf34aa38e3225c78862960536622de53ed9fd9f`.
+- `Sanctuary-Test-beta.121.mrpack` : 10280716 octets, SHA-256
+  `7f5bbd4e13aea4c245d072725c094ca64826ee8debc8607623783c114d437685`.
+- `Sanctuary-Resource-Pack-beta.121.zip` : 3757952 octets, SHA-256
+  `bbf3c18ea6abc64d951911215975cb6c48c7fc5e0246f6e5f5192a3d061c211d`.
+- `Sanctuary-Template-beta.121.zip` : 4315131 octets, SHA-256
+  `6fad376c53474fa8bcb0a2e6ae4c13ea61ab91bdd78735be443032d485ed541a`.
+
+JAR Sanctuary : SHA-256
+`4276f4fc9834805e3e6d12cd19adba7837e3007656b77f31d525c7b976f9925d`.
+
+## Publication et installation
+
+La [release beta.121](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.121)
+est publiée depuis `d9b3dd6bedf32448f8c6e5bfa4da10cb69968bc7`. Tag et artefacts immuables,
+téléchargements publics vérifiés. Canal packwiz :
+`e3e6572da9288fbbcfa36bf6b7dd3aa0d1c54f5e`.
+
+Deux synchronisations isolées puis deux dans **Sanctuary Beta** réussissent.
+Un seul JAR Sanctuary beta.121 est actif ; le second passage est identique.
+Les **923 fichiers personnels et réglages suivis** restent inchangés,
+y compris les packs de ressources. Aucune copie personnelle n'est créée par
+la mise à jour : chaque joueur utilise le bouton quand il le souhaite.
+Aucun monde personnel ouvert. Copie préalable dans
+`sanctuary-backups/before-beta.121/` de l'instance existante ; reçus
+`build/template121-isolated.json` et `build/template121-prism.json`.
+
+- [Template personnel complet](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.121/Sanctuary-Template-beta.121.zip).
+- [Pack normal](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.121/Sanctuary-beta.121.mrpack).
+- [Pack de test](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.121/Sanctuary-Test-beta.121.mrpack).

docs/sculpture-bounds-beta124.md

@@ -0,0 +1,93 @@
+# SCULPT-10 — Une boîte par sculpture — beta.124
+
+Contrat du 17 septembre 2026, branche `codex/sculpture-bounds-beta124`.
+Le créateur choisit **une seule boîte pour la sélection et les collisions**.
+Ce ticket remplace la forme physique détaillée de beta.122.
+
+La boîte englobe exactement les dimensions occupées par la sculpture, après
+orientation et ancrage au centre ou au bord. Elle suit toujours la grille 1/16,
+y compris les tailles impaires et les modèles comportant des marges vides.
+Les trous et petits détails restent visibles mais n'ont plus leurs propres
+surfaces de collision : on ne grimpe plus sur leurs petites marches. Une arche
+se sélectionne et bloque désormais sur tout son volume englobant.
+
+La pose utilise la même boîte avant la création de l'entité de bloc : elle
+refuse une intersection avec le joueur, y compris dans les trous visuels.
+Les petites sculptures laissent libre le reste du bloc autour de leur boîte.
+La forme reste mise en cache par modèle et état ; elle ne se recalcule qu'après
+un changement de modèle, d'orientation ou d'ancrage. Les requêtes physiques et
+le contour partagent cette même forme native.
+
+Le calcul parcourt les cellules une seule fois, sans créer de copies tournées
+ni de grille de collisions 16³. Le contour émet toujours douze arêtes.
+Il s'agit d'une simplification du travail géométrique ; aucun gain de FPS global
+n'est annoncé sans mesure sur une scène représentative.
+
+Le rendu des sculptures et les règles de lumière de beta.122 restent inchangés :
+pas d'occlusion de cube plein, pas d'émission artificielle de lumière. Aucun
+identifiant, format d'item ou de sauvegarde ne change. Les anciennes sculptures
+utilisent la nouvelle forme à partir de leurs données existantes, sans réécriture
+des mondes ni régénération de chunks. L'atelier et les clés restent inchangés.
+
+## Vérifications
+
+Le parcours `Sculpture122ClientChecks`, adapté au nouveau contrat, passe en
+**39 s** sur Minecraft 26.3, client macOS et serveur intégré jetable de graine 122.
+
+- Sélection native de tout le volume, y compris le trou visuel d'une arche ;
+  contour rectangulaire relu dans la capture.
+- Même boîte physique et de sélection sur client et serveur ; intérieur rempli,
+  dimensions exactes sans profondeur artificielle de bloc entier.
+- **80 cas** : boîte unique comparée aux limites du maillage réellement émis,
+  douze arêtes exactement, même objet réutilisé lors des requêtes répétées.
+  Arche, marges vides, cube de 4 096 cellules et voxel unique, dans les quatre
+  orientations et cinq ancrages.
+- **5 120 placements** de rendu toujours alignés sur la grille entière.
+- Pose refusée dans le joueur, y compris entre deux piliers séparés ; petite
+  sculpture autorisée à côté du joueur, hors de sa boîte physique.
+- Cache renouvelé après changement d'orientation/ancrage ou de modèle ;
+  conservation après sauvegarde/reconnexion.
+- **75 sculptures superposées** : ciel à 15 ; toit de pierre témoin sombre ;
+  lumière de bloc transmise avec atténuation normale ; pièce close à 0.
+
+Marqueurs dans `build/sculpture124-client.log`, notamment
+`SCULPTURE124_BOUNDS_PASS 80`, plus les contrôles de régression de beta.122.
+Captures relues dans `build/sculpture124-evidence/`. Aucun essai Windows,
+client distant ou shader tiers ; le coût des boîtes est simplifié sans benchmark
+FPS global.
+
+`./gradlew check build assemblePack assembleTestPack -x :sanctuary:runGameTest`
+passe en **2 min 9 s**, 126 tâches (110 exécutées, 16 à jour).
+Les sources des JAR correspondent aux sources du dépôt. La comparaison avec
+beta.123 limite les différences de production aux trois classes de
+`SculptureGeometry` ; ressources, clés, interfaces, données et éclairage restent
+identiques. Les packs normal/Test contiennent le même JAR, sans sauvegarde
+ni fixture. Le template personnel conserve exactement les ressources de beta.123.
+
+- Pack normal : 10 271 059 octets, SHA-256
+  `2075e4ac7a7e7e2effcd82586d46769607ca1a67e8d9110b000fa378d1bc5506`.
+- Pack Test : 10 289 985 octets, SHA-256
+  `88263e6896590ea9694b18084666e7234e934064e8d7d596d34866a68cc5ea23`.
+- JAR Sanctuary : SHA-256
+  `b3969b1a3738b8a5d332b2083db0dd722900239f73035c335b738f70328d43f1`.
+
+Reçu local : `build/sculpture124-artifact.json`. Les packs normal/Test et le
+template sont aussi copiés, avec vérification octet pour octet, dans le dossier
+habituel `sanctuary-beta/build/`.
+
+Le GameTest dédié reste exclu conformément au refus antérieur de son EULA.
+Aucun monde personnel n'est ouvert par les essais.
+
+## Publication et installation
+
+La [release beta.124](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.124)
+est publiée depuis `00179e30ef0b45ef98378bc164a7810552dd1bdd`.
+Le tag exact et les artefacts sont immuables, leurs téléchargements publics
+vérifiés. Canal packwiz : `67ebcc7d07f8b75e8988f6099e3d6e5704f123fb`.
+
+Deux synchronisations isolées puis deux dans **Sanctuary Beta** réussissent.
+Un seul JAR Sanctuary beta.124 est actif, conforme au hash vérifié ; le second
+passage ne change rien. Les **923 fichiers personnels et réglages suivis**
+restent inchangés, sans ouverture de monde personnel. Copie préalable dans
+`sanctuary-backups/before-beta.124/` de l'instance existante.
+Reçus : `build/sculpture124-isolated.json` et `build/sculpture124-prism.json`.

docs/sculpture-center-beta119.md

@@ -0,0 +1,84 @@
+# STAT-07 — Pose centrée des sculptures — beta.119
+
+Contrat du 17 septembre 2026, branche `codex/sculpture-center-beta119`.
+
+Viser le carré central de 8 × 8 pixels de la face supérieure ou inférieure
+du bloc place la sculpture au centre. Les limites de cette zone sont incluses.
+Autour, le bord horizontal le plus proche reste choisi ; une pose latérale
+continue à s'appuyer contre le bloc support. L'orientation suit le regard.
+L'aide du Clay Workshop explique les deux possibilités en français et anglais.
+
+Le centrage utilise l'emprise réelle des voxels après rotation, en ignorant les
+marges transparentes. Tous les sommets restent sur la grille de 1/16 de bloc.
+Une dimension impaire ne peut pas être parfaitement symétrique dans un bloc de
+16 pixels sans décaler ses voxels : elle prend donc le centrage entier le plus
+proche, avec un pixel de différence entre les deux marges. Aucune position à
+un demi-voxel n'est introduite.
+
+## Compatibilité
+
+La pose réutilise `anchor=center`, déjà présent depuis beta.113. Aucun nouvel
+état, identifiant, composant ou format de sauvegarde. Les sculptures existantes
+gardent leur ancrage ; casser et reposer choisit l'emplacement visé. Le rendu,
+les couleurs, les chapeaux et les collisions restent inchangés. Aucun parcours
+de monde existant, aucune régénération. Client et serveur doivent utiliser
+ensemble la nouvelle version pour le choix de pose.
+
+## Vérifications et livraison
+
+Le parcours natif `Statuary106ClientChecks`, avec `Sculpture113ClientChecks`,
+passe en **54 s** sur Minecraft 26.3/macOS :
+
+- Vrais clics de pose centrée dans quatre orientations, sur client et serveur,
+  puis pose contre les quatre bords sans modifier les couleurs du modèle.
+- Limites incluses et points immédiatement de part et d'autre de la zone,
+  faces supérieure/inférieure et positions positives/négatives ; faces
+  latérales toujours calées contre le support.
+- 5 120 combinaisons de largeur/profondeur, orientation et ancrage : géométrie
+  effectivement rendue sur la grille exacte, emprise sans dépassement,
+  centrage pair/impair et marges transparentes.
+- Sauvegarde/reconnexion des sculptures centrées et aux bords, sans fichier
+  source ; rotations/miroirs, anciens états, fabrication et hotbar vérifiés.
+
+```sh
+./gradlew :sanctuary:runClientGameTest \
+  -PsanctuaryClientTests=true -PsanctuaryStatuary106ClientTests=true \
+  -PsanctuaryClientNoVsync=true -PsanctuaryQuickTests=true
+```
+
+Marqueurs `SCULPTURE119_PASS`, `STATUARY113_PASS` et
+`SCULPTURE113_GEOMETRY_PASS` dans `build/sculpture119-client.log`.
+Captures conservées dans `build/sculpture119-evidence/`, vue centrée relue.
+Monde plat jetable de graine 106 ; aucun monde personnel ouvert. Pas de
+validation Windows ni de test depuis deux ordinateurs.
+Le GameTest dédié reste exclu conformément au refus antérieur de son EULA ;
+le parcours natif utilise le serveur intégré.
+
+`./gradlew check build assemblePack assembleTestPack -x :sanctuary:runGameTest`
+passe en **2 min 24 s**, 125 tâches. Les sources JAR correspondent aux sources
+du dépôt ; seuls `SculptureAnchor.class` et le texte d'aide FR/EN diffèrent
+parmi les classes et ressources de production de beta.118. Les deux packs
+contiennent le même JAR, sans monde ni fixture de test.
+
+- Sanctuary-beta.119.mrpack : 10216447 octets, SHA-256
+  `ce29702eaaac7301c77fb6af63a76c6bc1c0c704313ce1b8243c95b5fe59d893`.
+- Sanctuary-Test-beta.119.mrpack : 10235369 octets, SHA-256
+  `a1a2845f9678b1144d7d9eab4867970cc1776fe0ad5d51722c8110b7c1d4c682`.
+- JAR Sanctuary : SHA-256
+  `d353bd89b16c53ee1ee48836fa2ff4b311249b280992300c28bf03048d805bff`.
+
+Reçu local : `build/sculpture119-artifact.json`.
+
+## Publication et installation
+
+La [release beta.119](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.119)
+est publiée depuis `3fd64e1f2a77ea2584b087d6339cf605d8ee0e9b`. Le tag exact et les
+artefacts sont immuables ; leurs téléchargements publics sont vérifiés.
+Le canal packwiz avance à `5e823af7807f524f6394acad402fe62328c7e4ab`.
+
+Deux synchronisations isolées puis deux dans **Sanctuary Beta** réussissent.
+Un seul JAR Sanctuary beta.119 est actif ; le second passage est identique.
+Les **923 fichiers personnels et réglages suivis** restent inchangés, sans
+ouvrir de monde personnel. Copie préalable dans
+`sanctuary-backups/before-beta.119/` de l'instance existante. Reçus locaux :
+`build/sculpture119-isolated.json` et `build/sculpture119-prism.json`.

docs/sculpture-materials-beta116.md

@@ -0,0 +1,102 @@
+# beta.116 — Sculptures à partir des textures de blocs
+
+Ticket sur `codex/sculpture-materials-beta116`, comprenant aussi le correctif
+Fourneau beta.115 dans la livraison commune.
+
+Le Clay Workshop accepte les objets-blocs comme matière. Le client prélève une
+palette bornée dans la texture du bloc issue du pack actif, avec sa teinte, puis
+le modèle conserve sa géométrie et transpose ses valeurs claires/sombres dans
+cette palette. L'aperçu et le résultat utilisent le même calcul. Un bloc est
+consommé par sculpture ; les neuf cases de hotbar restent les seules accessibles.
+
+## Contrat des données et du réseau
+
+Les sculptures existantes conservent exactement leurs voxels sauvegardés :
+schéma 1 inchangé, identifiants `sanctuary:*` stables. Les nouvelles sculptures
+stockent elles aussi leurs couleurs finales dans ce format. Aucun chargement
+ne recolore les objets ou constructions existants. Orientation et ancrage
+beta.113 inchangés, sans migration ni modification d'un monde personnel.
+
+La sélection du menu ajoute l'identité de la matière et une palette de 256
+couleurs opaques au maximum. Ce sont des données d'apparence fournies par le
+client, comme le modèle déjà importé ; elles n'octroient ni objets ni propriétés
+de bloc. Le serveur vérifie le menu, son jeton, l'accès à l'atelier, les limites
+et l'objet effectivement présent. Il applique lui-même la palette et facture
+chaque résultat. Un changement de matière invalide immédiatement l'ancien
+résultat jusqu'à réception de la sélection correspondante. Les deux côtés
+doivent utiliser beta.116. Aucun nouveau format de sauvegarde.
+
+## Vérifications natives
+
+`Sculpture116ClientChecks` passe en 1 min 7 s, sur un nouveau monde plat de
+Minecraft 26.3, graine 116, puis la régression complète de l'atelier :
+
+- Les 1 207 objets-blocs enregistrés ont une palette opaque, non vide et bornée.
+- Fabrication payée avec pierre, planches de chêne, or, laine rouge, verre,
+  feuilles de chêne, argile et ardoise ; aperçu identique au résultat serveur.
+- Conservation des tons clairs/sombres du modèle et de ses coordonnées, sans
+  convertir les 16 argiles colorées en une simple couleur unie.
+- Une matière différente efface aussitôt l'ancien résultat ; une sélection
+  périmée ou un jeton incorrect ne fabrique rien et ne consomme aucun objet.
+- Les conteneurs contenant des objets sont refusés ; ils peuvent servir de
+  matière une fois vidés. Les objets qui ne sont pas des blocs sont refusés.
+- Bornes et opacité des palettes, véritable rechargement des ressources,
+  neuf cases de hotbar, stock plein, consommation exacte et restitution.
+- Poses selon les quatre regards, accroche au bord, grille de voxels,
+  casse/repose, sauvegarde et reconnexion après suppression du fichier GLB.
+- Interface FR/EN aux échelles 2/3, génération de plan au Métabli inchangée.
+
+Marqueurs `SCULPTURE116_PALETTES`, `SCULPTURE116_MATERIALS_PASS`,
+`SCULPTURE116_PASS` et régressions 106/111/112/113 dans
+`build/sculpture116-client.log`. Captures relues dans
+`build/sculpture116-evidence/`. Un libellé est raccourci en « Bloc » pour éviter
+le contact avec « Sculpture » dans le cadre compact.
+
+La palette vient de la texture représentative du modèle de bloc du pack actif,
+avec la teinte locale ; une texture animée utilise sa première image. Les blocs
+sans texture lisible utilisent leur couleur de carte. Il s'agit d'un transfert
+de couleurs sur les voxels opaques, sans transparence, émission ou fonction
+spéciale du bloc d'origine. Les sculptures existantes gardent leurs couleurs.
+
+Essais natifs macOS avec serveur intégré ; pas de client Windows ni de test
+LAN à plusieurs joueurs. Le serveur dédié de GameTest reste exclu selon le
+refus antérieur de son EULA. Aucun monde personnel ouvert.
+
+La régression native du Fourneau passe également dans beta.116, en 42 s :
+`build/sculpture116-furnace.log`, captures FR/EN dans
+`build/sculpture116-furnace-evidence/`. Les 27 cases, le glisser-déposer, les
+combustibles et les états de cuisson restent conformes au ticket beta.115.
+
+## Construction et archives
+
+`check build assemblePack assembleTestPack -x :sanctuary:runGameTest` réussit
+en 2 min 23 s : 125 tâches, dont 105 exécutées. Sources Java concordantes avec
+les JAR sources, versions alignées et intégrité des deux MRpack vérifiées.
+Le JAR conserve à l'identique le correctif Fourneau beta.115 ; seuls les
+classes de matière de sculpture et libellés FR/EN changent dans la production.
+Les classes de test et modèles GLB de test sont absents des archives.
+
+- `Sanctuary-beta.116.mrpack` : 10189831 octets, SHA-256
+  `7df04a6e2a57e76a55ca57bd7520b05cbb573392690b401b868837498807d252`.
+- `Sanctuary-Test-beta.116.mrpack` : 10208754 octets, SHA-256
+  `f4c9293e20384b05366d092fc7ee1abea275940a02373ee4036f73f0caa43747`.
+- JAR Sanctuary :
+  `76a9205783c8b18506c32c9eef6c481d95fd3ba0746a2bdd558a194534a51a32`.
+
+Reçu local : `build/sculpture116-artifact.json`.
+
+## Publication et instance
+
+La [release beta.116](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.116)
+est publiée avec le JAR, les deux MRpack et l'amorçage Prism. Le tag immuable
+désigne `e3ca9fcd6383f7646e4fea7e5098e7097ebb30aa` ; téléchargements publics
+et empreintes vérifiés. Le canal packwiz avance au commit
+`c741870160f8a21f0a9793f20f0e624ebdbacdb6`.
+
+Deux synchronisations isolées, puis deux dans l'unique instance **Sanctuary
+Beta**, réussissent. La seconde passe laisse les fichiers gérés inchangés,
+avec un seul JAR Sanctuary beta.116. Minecraft 26.3, Loader 0.19.5 et Fabric
+API 0.160.5+26.3 conservés. Les 923 fichiers personnels et réglages suivis
+restent identiques ; aucun monde personnel n'a été ouvert. Sauvegarde des
+fichiers remplacés dans `sanctuary-backups/before-beta.116/` de cette instance.
+Reçus : `build/sculpture116-isolated.json`, `build/sculpture116-prism.json`.

docs/sculpture-placement-beta125.md

@@ -0,0 +1,108 @@
+# SCULPT-11 — Placement, éclats et modèles découverts — beta.125
+
+Contrat du 17 septembre 2026, branche `codex/sculpture-placement-beta125`.
+
+Le point visé choisit neuf positions horizontales (centre, quatre bords et quatre
+coins) et trois hauteurs (bas, milieu et haut). Sur un support, la sculpture
+repose au bas de son bloc ; sous un plafond, elle touche le haut ; sur une face
+latérale, elle suit la hauteur visée et reste contre le support. Les sculptures
+restent debout et s'orientent selon le regard horizontal du joueur.
+La bande centrale occupe les huit pixels médians, limites incluses. Toute pose
+reste sur la grille 1/16 : une dimension impaire utilise le centre entier le
+plus proche, jamais un demi-voxel. Rendu, boîte unique de sélection et collision
+partagent les mêmes offsets. La lumière conserve les règles de beta.122.
+
+## Compatibilité additive des états existants
+
+Les cinq anciennes valeurs `anchor` gardent exactement leurs noms. Quatre
+valeurs de coin sont ajoutées. La nouvelle propriété `vertical_anchor` accepte
+`bottom`, `center`, `top` et `original`, valeur par défaut réservée à la
+compatibilité. La lecture d'un ancien bloc sans cette propriété conserve
+l'ancienne hauteur, même si le modèle a des marges transparentes en bas.
+Le bloc possède 144 états : 108 placements nouveaux et 36 états de compatibilité.
+
+Le schéma 1 des sculptures, leurs données de voxels et tous leurs identifiants
+restent inchangés. Aucun monde n'est parcouru ou réécrit, aucun chunk régénéré.
+Les nouveaux ancrages nécessitent beta.125 ; le retour à une version antérieure
+ne garantit pas leur position. Ce contrat autorise l'ajout compatible des états,
+pas une migration destructive des sauvegardes personnelles.
+
+## Particules
+
+Les coups et la casse émettent des éclats de la couleur des surfaces voxelisées
+réellement affichées, avec leur orientation et leur ancrage. Un coup vise la
+surface réelle la plus proche du point sélectionné, même devant un trou visuel.
+La casse échantillonne au plus 64 faces ; aucun calcul de texture n'est refait.
+Les éclats utilisent une taille de voxel, la gravité et la lumière natives.
+Une petite mémoire par monde (128 entrées de 64 faces, validité 40 ticks) conserve les
+surfaces si la suppression du bloc précède l'événement de casse. Les autres
+blocs gardent leurs particules habituelles.
+
+## Clay Workshop
+
+L'onglet Animaux utilise exactement les découvertes serveur du catalogue de
+statues (rencontre, victoire ou mort face à l'espèce). Le menu transmet cette
+liste à chaque ouverture, sans dépendre d'une visite préalable au Métabli.
+Le modèle natif et sa texture sont capturés localement, voxelisés en miniature,
+puis recolorés par la matière choisie. Le résultat reste fabriqué et payé côté
+serveur. Les sélections d'espèces non découvertes sont refusées. L'onglet Imports
+conserve les fichiers GLB. Aucun nouveau format de sculpture n'est introduit.
+Libellés FR et EN.
+
+## Vérifications
+
+Le parcours natif `Sculpture125ClientChecks` passe en **1 min 2 s**, client
+Minecraft 26.3 sur macOS et serveur intégré jetable (graines 125 et 122).
+
+- 54 clics réels sur les six faces : centres, bords, coins et hauteurs.
+- 432 contextes de pose, coordonnées positives/négatives, quatre orientations,
+  rotations et miroirs ; 144 états valides.
+- 20 anciens états sans `vertical_anchor` conservent leur hauteur et marges.
+- Couleur exacte des éclats au point frappé, surfaces réellement occupées,
+  limite de 64 fragments, événement après suppression et particules normales
+  d'un bloc de pierre témoin.
+- Atelier : découvertes par rencontre, victoire et mort, transmission native
+  du menu, refus serveur d'une espèce inconnue, trois modèles natifs (vache,
+  mouton, cochon), paiement d'un bloc en survie et import GLB conservé.
+- Sauvegarde et reconnexion avec les nouveaux coins et hauteurs.
+- 576 formes comparées aux limites du maillage affiché, boîte unique partagée,
+  cache réutilisé et 12 arêtes ; 9 216 empreintes orientées sur grille entière.
+- 75 sculptures superposées : ciel à 15, lumière de bloc à 13 après traversée,
+  pièce noire à 0. Pose dans le joueur refusée, même devant un trou visuel.
+
+Marqueurs dans `build/sculpture125-client.log`. Captures de plafond, murs et
+atelier relues dans `build/sculpture125-evidence/`. Aucun essai Windows,
+client distant ou shader tiers ; trois espèces vérifiées visuellement, sans
+prétendre avoir inspecté chaque espèce. Aucun benchmark FPS global.
+
+Le GameTest dédié demeure exclu conformément au refus antérieur de son EULA.
+Les mondes de test sont jetables ; aucun monde personnel n'est ouvert.
+
+`./gradlew check build assemblePack assembleTestPack -x :sanctuary:runGameTest`
+passe en **2 min 16 s**, 126 tâches (110 exécutées, 16 à jour). Les sources
+des JAR correspondent exactement au dépôt. La comparaison avec beta.124
+limite les différences aux classes de placement, particules et atelier prévues,
+aux nouveaux libellés FR/EN, au mixin client et à la source blanche de particules.
+Les packs normal/Test partagent le même JAR, sans monde ni fixture ; le template
+reproduit les ressources du mod et du pack intégré.
+
+- Sanctuary-beta.125.mrpack : 10286360 octets, SHA-256 `9277e59c640c40392ab3750b402bb840020884878f6ece6978e6c4653e18655e`.
+- Sanctuary-Test-beta.125.mrpack : 10305282 octets, SHA-256 `9e3dbfa14b5382ba4eb62a78fa7d2161758c2f0e1fdc50fbd5ed776fd4ce32c5`.
+- JAR Sanctuary : SHA-256 `b38b75b900dd8cbe015318c739d5547fd7eac52f4337fa517e98f3f6f0ce3b46`.
+
+Reçu local : `build/sculpture125-artifact.json`. Les deux packs et le template
+sont copiés et vérifiés dans le dossier habituel `sanctuary-beta/build/`.
+
+## Publication et installation
+
+La [release beta.125](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.125)
+est publiée depuis `4ec5b0d028a23a9f753770988ffba61015e2e49a`.
+Tag et artefacts immuables, téléchargements publics vérifiés. Canal packwiz :
+`47eb833911a96eef0b13805dafe65b2ab7b95c87`.
+
+Deux synchronisations isolées puis deux dans l'instance **Sanctuary Beta**
+réussissent. Un seul JAR Sanctuary beta.125 est actif, conforme au hash vérifié ;
+le second passage ne change rien. Les **923 fichiers personnels et réglages
+suivis** restent inchangés, sans ouverture de monde personnel. Copie préalable
+sous `sanctuary-backups/before-beta.125/`. Reçus :
+`build/sculpture125-isolated.json` et `build/sculpture125-prism.json`.

docs/sculpture-shape-light-beta122.md

@@ -0,0 +1,108 @@
+# SCULPT-09 — Forme physique et lumière — beta.122
+
+Contrat du 17 septembre 2026, branche `codex/sculpture-shape-light-beta122`.
+Le créateur demande des bounding boxes adaptées aux sculptures et la suppression
+des ombres cubiques visibles lorsqu'on en pose plusieurs côte à côte.
+
+La sélection, le contact avec les entités et les collisions suivent les voxels
+occupés de chaque sculpture, y compris les creux. Le rendu et la forme physique
+partagent leur placement entier sur la grille 1/16, après orientation et ancrage.
+Le centre, les quatre bords et les dimensions impaires gardent leur alignement.
+La pose vérifie aussi les voxels portés avant que l’entité de bloc existe :
+elle refuse une intersection avec le joueur et autorise les espaces libres.
+La forme est construite directement sur une grille native 16³ et mise en cache
+par entité de bloc, modèle et état ; aucun calcul complet à chaque interrogation.
+
+Les sculptures transmettent la lumière et ne sont plus utilisées comme cubes
+pleins par l'occlusion ambiante. Leurs faces restent éclairées par le monde,
+sans émission de lumière et sans rendu à luminosité maximale. Cette règle est
+commune aux sculptures : l'éclairage natif stocké par bloc ne permet pas une
+ombre distincte pour chaque petit voxel. L'atelier d'argile reste inchangé.
+
+Aucun identifiant, blockstate, format d'item ou schéma sauvegardé ne change.
+Les formes sont recalculées à partir des voxels existants ; aucune migration,
+aucun parcours de monde ni régénération de chunk. Les données inconnues gardent
+leur conservation opaque et une petite base sélectionnable pour récupérer l'item.
+Le travail de documentation déjà présent dans l'autre branche reste intact.
+
+## Vérifications et livraison
+
+Le parcours `Sculpture122ClientChecks` passe en **37 s** sur Minecraft 26.3,
+client macOS et serveur intégré, dans un monde plat jetable de graine 122 :
+
+- Pose par la commande native d'utilisation ; sélection du pilier et visée
+  à travers le trou d'une arche jusqu'au bloc derrière, captures relues.
+- Requêtes natives de collision côté serveur et client : voxels occupés solides,
+  espace vide libre, aucune profondeur artificielle d'un bloc entier.
+- Pose refusée dans le joueur, sans consommer l'objet ; petite sculpture acceptée
+  dans la partie libre du même bloc, sans intersection avec le joueur.
+- **80 cas** confrontent le volume et les faces de collision au maillage réellement
+  émis : arche creuse, marges vides, cube de 4 096 voxels, voxel unique, quatre
+  orientations et cinq ancrages. Chaque interrogation répétée réutilise la forme.
+- Régression de **5 120 placements** du rendu existant : dimensions paires/impaires,
+  orientations et ancrages, plus marqueurs de direction et modèles avec marges.
+- Changement d'orientation/ancrage puis changement des voxels sur la même entité :
+  cache recalculé et forme client synchronisée.
+- **75 sculptures en trois couches** : skylight natif conservé à 15 partout.
+  Un toit de pierre témoin produit toujours une ombre. La lumière d'un bloc
+  traverse une sculpture avec l'atténuation de distance native (13 à deux blocs).
+- Le rendu reçoit la lumière réelle du monde : 15 au ciel, **0 dans une pièce
+  fermée et obscure**. Aucun rendu artificiellement lumineux.
+- Sauvegarde/reconnexion : modèle, collisions et lumière conservés sur les
+  deux côtés, sans fichier 3D source.
+
+```sh
+./gradlew :sanctuary:runClientGameTest \
+  -PsanctuaryClientTests=true -PsanctuarySculpture122ClientTests=true \
+  -PsanctuaryClientNoVsync=true -PsanctuaryQuickTests=true
+```
+
+Marqueurs `SCULPTURE122_PASS`, `SCULPTURE122_GEOMETRY_PASS`,
+`SCULPTURE122_PLACEMENT_PASS`, `SCULPTURE122_LIGHT_PASS` et
+`SCULPTURE113_GEOMETRY_PASS` dans `build/sculpture122-client.log` ; captures
+conservées dans `build/sculpture122-evidence/`. Le test prépare explicitement
+son sol à Y=0 : le preset plat nu commence à Y=-1.
+Aucun monde personnel ouvert ; pas d'essai Windows ni depuis deux ordinateurs,
+ni de garantie sur les ombres ajoutées par des shaders tiers.
+Le GameTest serveur dédié reste exclu conformément au refus antérieur de son EULA.
+
+`./gradlew check build assemblePack assembleTestPack -x :sanctuary:runGameTest`
+passe en **2 min 13 s**, 126 tâches. Les sources JAR correspondent aux sources
+Java du dépôt. Par rapport à beta.121, les différences de production se limitent
+aux classes des sculptures et à la nouvelle géométrie partagée (14 entrées,
+y compris le déplacement du sélecteur synthétique d'orientation). Toutes les
+ressources client, données serveur et configurations de mixins sont identiques.
+Les packs normal/Test contiennent le même JAR, sans sauvegarde ni fixture.
+Le template beta.122 contient les mêmes ressources que beta.121, octet pour octet.
+
+Reçu local : `build/sculpture122-artifact.json`.
+
+- `Sanctuary-beta.122.mrpack` : 10267459 octets, SHA-256
+  `b6e24d65797eb7f16670d2f3a591b5f2476820608f72241ecd37fb78a486008e`.
+- `Sanctuary-Test-beta.122.mrpack` : 10286380 octets, SHA-256
+  `90487ee3ad4298fccb8c24e8781af4cbf043d88dc0379fba5c21d99733dac92d`.
+
+JAR Sanctuary : SHA-256
+`ff8ebf89f39a64809fae6912253386793e9b5e66ec0adb9fa7521729893d406e`.
+
+## Publication et installation
+
+La [release beta.122](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.122)
+est publiée depuis `edc7fc3dfb117cde61be42c1d79b03af11f5dec6`. Tag et artefacts immuables,
+téléchargements publics vérifiés. Canal packwiz :
+`3d340bea0093b709c6018624795a1b3ca557b72d`.
+
+Deux synchronisations isolées puis deux dans **Sanctuary Beta** réussissent.
+Un seul JAR Sanctuary beta.122 est actif ; le second passage est identique.
+Les **923 fichiers personnels et réglages suivis** restent inchangés.
+Aucun monde personnel ouvert. Copie préalable dans
+`sanctuary-backups/before-beta.122/` de l'instance existante ; reçus
+`build/sculpture122-isolated.json` et `build/sculpture122-prism.json`.
+
+Le ticket a été réalisé dans le worktree `sanctuary-sculpture-beta122` afin de
+préserver les changements de `docs/vision.md` et `docs/villageois-illageois.md`
+déjà présents sur la branche de documentation du checkout principal.
+
+- [Pack normal](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.122/Sanctuary-beta.122.mrpack).
+- [Pack de test](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.122/Sanctuary-Test-beta.122.mrpack).
+- [Template personnel](https://git.botsu.net/koka/sanctuary-beta/releases/download/beta.122/Sanctuary-Template-beta.122.zip).

docs/sculpture-texture-grain-beta117.md

@@ -0,0 +1,110 @@
+# beta.117 — Grain des textures et sculptures en chapeau
+
+Ticket sur `codex/sculpture-texture-grain-beta117`, Minecraft 26.3.
+
+En beta.116, une couleur du modèle source était associée à une seule nuance
+de matière. Un modèle uni restait donc uni malgré les pixels différents de la
+texture. La sélection utilise maintenant les textures des faces du modèle de
+bloc, avec leurs propres teintes du pack actif. Un échantillonnage de pixels
+répartit leurs couleurs exactes dans les voxels, sans couleur interpolée.
+
+## Coût et comportement
+
+Au maximum 32 matériaux de faces et 16 × 16 échantillons par matériau sont lus,
+puis ramenés à la palette existante de 256 entrées. Les répétitions conservent
+la fréquence des nuances. Les pixels transparents sont écartés ; les textures
+animées utilisent la première image. Les blocs sans texture lisible gardent
+le repli antérieur sur la texture représentative, puis la couleur de carte.
+
+La sélection d'une nuance utilise un mélange entier déterministe des coordonnées
+de chaque voxel. Un modèle uni utilise toute la palette ; un modèle ombré
+utilise des plages de nuances qui suivent ses zones claires et sombres.
+Ce grain est un transfert de palette, pas une projection UV conservant les
+motifs ou les veinures du bloc. Les voxels restent opaques.
+
+Le calcul utilise Java standard et les modèles/textures déjà chargés par
+Minecraft, sans bibliothèque supplémentaire. Aucun calcul de matière dans
+le rendu par image. Le client ne rééchantillonne qu'au changement de matière
+ou de ressources ; une rotation réutilise la palette. Le serveur conserve
+le modèle recoloré pour les fabrications suivantes avec la même sélection.
+
+## Chapeaux et données
+
+Le système de blocs portés retirait `BLOCK_ENTITY_DATA` des objets pour isoler
+les inventaires des coffres et fourneaux. Sur une sculpture, ce composant est
+la géométrie elle-même : le slot contenait encore un objet, devenu invisible.
+Les sculptures conservent désormais ce composant à l'équipement et au retrait.
+
+Si une ancienne sculpture équipée a perdu ce composant, mais que sa session
+de chapeau possède encore le modèle, il est restauré depuis cette donnée
+serveur. La restauration ne fabrique aucune géométrie manquante. Les objets
+déjà retirés et dépourvus de toute copie du modèle ne sont pas reconstructibles
+par ce correctif. Les règles de contenu des coffres restent inchangées.
+
+Identifiants, schéma 1 des sculptures, structure des accessoires et paquet
+de sélection inchangés. Les couleurs déjà sauvegardées restent intactes.
+Les deux côtés utilisent beta.117 pour le même calcul de prévisualisation et
+de fabrication. Aucun monde personnel ouvert ni migration de sauvegarde.
+
+## Vérifications
+
+Le scénario client natif complet passe en 2 min 1 s sur macOS avec serveur
+intégré, monde plat jetable de graine 116. Il reprend le scénario beta.116
+avec un GLB entièrement uni, plus les régressions de l'atelier 106/111/112/113 :
+
+- 1 207 objets-blocs échantillonnés, huit fabrications payées avec aperçu
+  identique au résultat serveur, consommation exacte d'un bloc.
+- Répartition 25 % / 75 % de deux couleurs de texture sur un modèle uni,
+  aucune couleur inventée, conservation des zones claires et sombres.
+- Couleurs réellement présentes dans les textures natives des faces, avec
+  plusieurs matériaux d'une bûche ; grain présent sur pierre, bois et minerai.
+- Motif indépendant de l'ordre des voxels, stable et sauvegardé ; rechargement
+  des ressources, palette bornée, inventaire plein et sélections périmées.
+- Vrais clics des slots hotbar/chapeau, conservation exacte des composants
+  et du nom personnalisé, icône et modèle porté visibles, retrait/rééquipement.
+- Restauration d'un objet privé de sa géométrie depuis une ancienne session
+  équipée, puis sauvegarde et reconnexion du client avec le chapeau intact.
+- Pose, bord visé, orientation, casse/repose, reconnexion sans fichier source,
+  menus FR/EN et génération du plan du Métabli inchangés.
+
+Mesure indicative après échauffement, modèle maximal de 4 096 voxels,
+101 applications sur le Mac de développement : médiane **0,283 ms**, p95
+**0,971 ms**. Ce n'est pas une garantie de temps sur d'autres machines ; le
+calcul n'est exécuté ni chaque image ni à chaque objet fabriqué identique.
+
+Marqueurs `SCULPTURE117_GRAIN_PASS`, `SCULPTURE117_HAT_PASS`,
+`SCULPTURE117_HAT_RECONNECT_PASS`, `SCULPTURE116_PASS` dans
+`build/sculpture117-final-client.log`. Captures relues dans
+`build/sculpture117-evidence/`. Pas d'essai Windows ou LAN. Le GameTest dédié
+reste exclu selon le refus antérieur de son EULA.
+
+`check build assemblePack assembleTestPack -x :sanctuary:runGameTest` réussit
+en **3 min 7 s**, 125 tâches dont 105 exécutées. JAR sources concordants,
+versions, contenu et intégrité des deux archives vérifiés. La comparaison
+avec beta.116 limite les changements de production au calcul des matières,
+à son cache dans le menu et au traitement des sculptures en chapeau.
+Les modèles de test et classes de GameTest sont absents de la livraison.
+
+- `Sanctuary-beta.117.mrpack` : 10191137 octets, SHA-256
+  `adbe5a40bbd050ebc84ff8aca61a7a3643dcf25ec8f2ac59b91561e48275cbbb`.
+- `Sanctuary-Test-beta.117.mrpack` : 10210059 octets, SHA-256
+  `0dacb12b30bde66c647871101a4f4c6b0b58e7ceb29f7743398f8a569b958a6e`.
+- JAR Sanctuary :
+  `1ce63f97f17c6098f3c86c6753f9b912bce39d88e05ba240423c38bdc97307ee`.
+
+Reçu : `build/sculpture117-artifact.json`.
+
+## Publication et instance
+
+La [release beta.117](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.117)
+est publiée : JAR, MRpack normal/Test et amorçage Prism, téléchargements publics
+et empreintes vérifiés. Le tag immuable désigne
+`0f1efdec830342e25d3316b356330ad937d0d942`. Le canal packwiz avance au commit
+`a5b75a70f86e42afb8e06ba4daa9880d61c6373e`.
+
+Deux synchronisations isolées puis deux dans l'unique instance **Sanctuary
+Beta** réussissent, la seconde passe laissant les fichiers gérés identiques.
+Un seul JAR Sanctuary beta.117 est actif. Les 923 fichiers personnels et
+réglages suivis sont inchangés ; aucun monde personnel n'a été ouvert.
+Copie préalable des fichiers remplacés dans `sanctuary-backups/before-beta.117/`.
+Reçus : `build/sculpture117-isolated.json`, `build/sculpture117-prism.json`.

docs/shader-beta127.md

@@ -0,0 +1,88 @@
+# SHADER-127 — intégration des ombres portées pixélisées
+
+Demande du 17 septembre 2026 : livrer le shader dans **beta.127**.
+Branche `codex/shader-beta127`, socle publié beta.126, Minecraft 26.3 / Java 25.
+
+La préparation locale [des ombres pixélisées](pixel-shadows-source122.md) est
+intégrée sans écraser les changements non publiés du dossier d'origine.
+Les gemmes, dernières textures de rubis/saphir, l'argile spéciale et les
+commandes de découverte de beta.126 sont conservées.
+
+## Utilisation
+
+**Options → Shaders → Sanctuary · Vanilla Light → Ombres portées pixélisées**.
+L'option est désactivée par défaut ; son activation reste un choix du joueur.
+Finesse : 8/16/32 pixels par bloc ; portée : 16/32/64 blocs. Défauts : 16 et 32.
+Les paramètres FR/EN s'appliquent immédiatement et persistent dans
+`config/sanctuary-shaders.json`. La mise à jour préserve les réglages personnels.
+Le rendu est natif au mod : aucun pack Iris, téléchargement supplémentaire ou
+nouvelle dépendance de rendu.
+
+## Périmètre
+
+Ombres solaires des formes d'occultation des blocs chargés, incluant dalles,
+escaliers et obstacles hors écran. Carte de profondeur GPU, grille ancrée dans
+le monde, atténuation selon soleil, pluie et brume. L'effet s'arrête la nuit,
+dans les dimensions sans soleil, dans les fluides ou avec un moteur externe.
+Le HUD et la main ne passent pas dans cet effet. La lumière de gameplay,
+les règles serveur, les sauvegardes et la génération ne sont pas modifiées.
+
+La préparation limite le cache à 96 Mio et sa construction à quatre sections
+par image dans un budget souple de 3 ms. L'intégration supprime seulement une
+invalidation de bord exécutée deux fois à l'identique dans le cache de terrain.
+Les formes non occultantes, feuillages ajourés, eau/verre et entités animées ne
+projettent pas de nouvelles silhouettes. Les transparences déjà composées
+peuvent recevoir l'assombrissement du terrain situé derrière elles. Pas
+d'ombres de torches/lune ni de mesure de FPS revendiquée.
+
+## Vérifications et livraison
+
+Client natif Minecraft 26.3 / Java 25 sur macOS, monde neuf plat, graine 122 :
+`PixelShadows122ClientChecks` réussit sur la beta.127 en **1 min 26 s**.
+Le nom de cette fixture historique est conservé pour suivre la même scène.
+
+- Activation : 920 échantillons de sol assombris, 63 412 inchangés, aucun éclairci.
+- Pilier hors écran : 42 048 échantillons restent ombrés ; le retrait du pilier
+  restitue la lumière sur les 42 048 et conserve les 23 616 déjà éclairés.
+  La repose rétablit la même ombre sans désactiver le cache.
+- Trois finesses et trois portées, redimensionnement GPU, désactivation/libération,
+  arrêt nocturne, reprise diurne et rechargement des ressources vérifiés.
+- Préférences persistantes et bornées ; captures FR/EN inspectées, sans texte
+  tronqué. La scène pilier/dalle/escalier est également inspectée visuellement.
+
+Logs : `build/shader127-client.log`. Captures :
+`mods/sanctuary/build/run/clientGameTest/screenshots/`.
+Le serveur GameTest dédié reste exclu conformément au refus antérieur de son
+EULA. Aucun monde personnel n'est ouvert. Aucun essai Windows/Vulkan ou FPS
+n'est revendiqué ; la validation graphique est celle du client natif local.
+
+
+Build `./gradlew check build assemblePack assembleTestPack
+-x :sanctuary:runGameTest` réussi en **2 min 25 s**, 126 tâches. Les sources
+Java dans les archives correspondent aux sources du ticket. La comparaison
+avec le JAR beta.126 ne trouve que **21 entrées de production modifiées**,
+toutes liées au shader, à son initialisation, ses mixins et ses libellés.
+Les règles de jeu, données, textures de gemmes, sculptures et découvertes
+sont identiques. Normal et Test contiennent le même JAR ; le template exporte
+exactement les ressources du mod. Aucune fixture de test ni monde embarqué.
+
+| Artefact | SHA-256 |
+| --- | --- |
+| `Sanctuary-beta.127.mrpack` | `23fa6ca0c5d1f1033e13e5370d669491b398d5a99e13f8bd1e983f998a24a20a` |
+| `Sanctuary-Test-beta.127.mrpack` | `f185f3a743ba23cd6c024d1c1e46587706bf4f3edb5e14d7e5dee522a1ebf2c2` |
+| `sanctuary-beta.127.jar` | `3ef3fab67f4f703864a1acc9ae2395c636d206f3128d3399140eaf045a46d5f3` |
+
+## Publication et synchronisation
+
+[Release beta.127](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.127)
+publiée depuis `00be1eb0d0bfe042442d90255385033a7765092f` ; artefacts immuables retéléchargés
+et vérifiés. Canal packwiz : `7fd24a43e01ee497a23311e3c78e1dd3dddd877a`.
+Deux synchronisations isolées puis deux dans l'instance existante
+**Sanctuary Beta** ont réussi. Les **923 fichiers personnels** suivis,
+y compris les préférences de shaders, sont conservés. Aucun monde personnel
+ouvert ; copie préalable dans `sanctuary-backups/before-beta.127/`.
+
+Les packs normal/Test et le template sont aussi copiés et vérifiés dans
+`sanctuary-beta/build/`. Reçus locaux : `build/shader127-artifact.json`,
+`build/shader127-isolated.json`, `build/shader127-prism.json` et journal de
+publication `build/shader127-publication.log`.

docs/shader-beta128.md

@@ -0,0 +1,106 @@
+# SHADER-128 — stabilité, lune et feuillage
+
+Demandes du 17 septembre 2026 : réduire le jitter des bords et à midi, conserver
+des ombres de blocs nettes et un feuillage nuancé, ajouter une ombre lunaire
+fine et une transmission
+irrégulière du feuillage selon son épaisseur. Branche `codex/moon-foliage-beta128`,
+socle publié beta.127, Minecraft 26.3 / Java 25.
+
+## Résultat
+
+Les faces de voxels reçoivent l'ombre sur une grille fixe ; leur plan est
+stabilisé au 1/16 de bloc et les faces inclinées conservent leur normale. La
+carte de profondeur utilise un ancrage par 16 blocs avec alignement de ses
+texels. **Les ombres des blocs restent nettes** : le créateur a écarté leur
+adoucissement après l'essai visuel. Le filtrage est réservé au feuillage.
+Le soleil continue de se déplacer : ce mouvement naturel peut toujours faire
+avancer une ombre d'une case. L'objectif est de supprimer les oscillations
+liées à la caméra, pas de figer le temps.
+
+Entre une élévation solaire de 0,92 et le zénith, l'intensité diminue doucement
+jusqu'à 25 % de sa valeur habituelle : alpha maximal 0,095 au lieu de 0,38.
+La lune réutilise la même carte et son angle natif ; alpha maximal 0,10 selon
+sa phase, nul à la nouvelle lune. Horizon, pluie, portée et brume atténuent
+les deux lumières. Pas de seconde passe de carte lunaire simultanée.
+
+Les blocs du tag vanilla `leaves` projettent une couverture probabiliste fixe
+sur une grille de quart de bloc. Les faces internes restent présentes : plus
+le rayon traverse de couches, moins il a de chances de passer. Il s'agit d'une
+approximation statistique de l'épaisseur, pas d'un comptage des feuilles ni
+d'une lecture des trous de leur texture. Quatre échantillons bilinéaires sur
+un quart de bloc mélangent cette couverture
+en nuances, évaluées sur la grille pixélisée. Un masque R8 distingue feuilles
+et blocs dans la même passe de profondeur, pour garder les silhouettes opaques
+nettes. Les comparaisons suivent le plan récepteur pour éviter l'auto-ombrage
+sur les surfaces obliques. Le motif ne dépend ni du temps ni de la caméra et
+ne demande aucune lecture GPU côté CPU en production.
+Les budgets du cache restent 96 Mio, quatre sections et 3 ms souples par image.
+Le feuillage ajoute des faces ; son filtrage utilise seize comparaisons de
+profondeur et, selon le cas, autant de lectures du masque. Les ombres opaques
+pleines utilisent le chemin court. Le masque prend 4 Mio à la définition
+par défaut, 16 Mio au maximum ; aucune promesse de FPS n'est faite.
+
+Réglages existants et libellés FR/EN conservés/actualisés. Les ombres restent
+optionnelles et désactivées par défaut. Règles, éclairage de gameplay, mondes
+et génération inchangés. Les limitations de beta.127 concernant les entités,
+fluides, verre et autres formes non occultantes subsistent.
+
+## Vérifications
+
+`PixelShadows122ClientChecks`, fixture historique étendue, réussit en **1 min
+44 s** dans un monde neuf plat, graine 122, client natif macOS/OpenGL.
+
+- Soleil : 920 échantillons de sol ombrés et 63 412 inchangés ; retrait/repose
+  d'un pilier hors écran restitue puis rétablit son ombre.
+- Lune : ombre localisée mesurée ; arrêt des passes à la nouvelle lune.
+- Midi : ombre atténuée et **zéro échantillon de transition adoucie sur 65 664**
+  dans la scène de contrôle du contour opaque.
+- Caméra : petits déplacements autour de l'ancien ancrage entier et du nouvel
+  ancrage par 16 blocs, retour au point initial, petites rotations en vue
+  oblique, instants avant/après midi et passage de 5999 à 6001 ticks.
+  Comparaisons d'images avec tolérance de trois niveaux par canal et moins
+  de 1 % d'échantillons changés pour ces petits mouvements.
+- Vue oblique : 19 637 échantillons ombrés, 46 027 inchangés sur le sol blanc.
+- Feuillage : assombrissement moyen mesuré d'environ **18,6 %** pour une couche,
+  **31,7 %** pour quatre, contre **36,8 %** sous une couverture solide.
+  Motif fixe dans le temps ; modification des couches invalide le cache actif.
+- Trois finesses/trois portées, désactivation/libération GPU, préférences
+  persistantes, rechargement des ressources, textes FR/EN et captures inspectés.
+
+Commande native : `./gradlew :sanctuary:runClientGameTest
+-PsanctuaryClientTests=true -PsanctuaryPixelShadows122ClientTests=true
+-PsanctuaryClientNoVsync=true -PsanctuaryQuickTests=true` sous Java 25.
+Logs : `build/shader128-client.log` ; captures sous
+`mods/sanctuary/build/run/clientGameTest/screenshots/`.
+
+`./gradlew check build assemblePack assembleTestPack
+-x :sanctuary:runGameTest` réussit en **2 min 24 s**, 126 tâches.
+Les sources archivées correspondent au ticket. **13 entrées de production**
+diffèrent de beta.127, limitées aux classes du shader, GLSL et libellés FR/EN.
+Gemmes, sculptures, découvertes, données et règles de jeu restent identiques.
+Normal et Test embarquent le même JAR ; le template correspond exactement aux
+ressources exportables. Aucun monde ni fixture de test embarqué.
+Le serveur GameTest dédié reste exclu conformément au refus antérieur de son
+EULA. Aucun monde personnel utilisé. Aucun essai Windows/Vulkan revendiqué.
+
+## Artefacts vérifiés
+
+| Artefact | SHA-256 |
+| --- | --- |
+| `Sanctuary-beta.128.mrpack` | `84125b18366afde52c8cba4bc7007257b1c3d8b79d413338abe64d0e0ae8feaf` |
+| `Sanctuary-Test-beta.128.mrpack` | `6bfb10d8d63875bfb84e813d4f0a9faf5db30902cc0400deda0993c08b86e597` |
+| `sanctuary-beta.128.jar` | `c54cbae7efaa7059c8fd4d28801087983379958fe34eedff51682d106d649c6a` |
+
+## Publication et synchronisation
+
+[Release beta.128](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.128)
+publiée depuis `a4e96c0d99c976231d7ca92b1db6bdb6aa7083c6` ; les artefacts immuables ont été
+retéléchargés et vérifiés. Canal packwiz : `eba01726ee132a6e548d129fa7ee04f24c880917`.
+Deux synchronisations isolées puis deux dans l'instance existante
+**Sanctuary Beta** ont réussi. Les **923 fichiers personnels** suivis,
+y compris les réglages de shaders, sont conservés. Aucun monde personnel
+ouvert ; copie préalable dans `sanctuary-backups/before-beta.128/`.
+Packs normal/Test et template copiés et vérifiés dans `sanctuary-beta/build/`.
+
+Reçus locaux : `build/shader128-artifact.json`, `build/shader128-isolated.json`,
+`build/shader128-prism.json` ; journal : `build/shader128-publication.log`.

docs/shader-beta129.md

@@ -0,0 +1,109 @@
+# SHADER-129 — arêtes connectées et portées étendues
+
+Demandes du 17 septembre 2026 : highlight optionnel, puis raccordement CTM de
+tous les blocs coplanaires, portée indépendante 16–256 blocs, ombres à 128/256,
+suppression de l'atténuation au zénith et du réalignement cyclique des ombres.
+Branche `codex/edge-highlights-beta129`, socle beta.128, Minecraft 26.3 / Java 25.
+
+## Résultat
+
+Dans **Options → Shaders → Sanctuary · Vanilla Light**, les reflets sur les
+arêtes sont désactivés par défaut. L'intensité va de 0 à 100 ; la valeur 30
+éclaircit au maximum de 12 %. Leur portée se règle indépendamment des ombres :
+**16, 32, 64, 128 ou 256 blocs**. Les anciens réglages restent conservés.
+
+Le highlight raccorde les surfaces plates, y compris entre matériaux différents,
+sans dessiner les jonctions intérieures. Il suit les contours visibles du relief,
+y compris les dalles et escaliers. Il multiplie la couleur existante pour garder
+les pixels des textures et composer avec les ombres. Ce CTM géométrique utilise
+la profondeur déjà produite par Minecraft : aucune liste de blocs autorisés,
+aucun pack CTM à fournir, aucune exploration CPU du volume de 256 blocs.
+Une cassure/repose modifie le contour dès que le terrain natif est réaffiché.
+
+Le trait proche suit la grille de 1/16 de bloc. À distance, la couverture devient
+partielle pour limiter le scintillement des traits plus petits qu'un pixel.
+La portée choisie s'efface progressivement dans son dernier quart et respecte
+la brume ainsi que la distance de rendu. Une passe plein écran, quatre sondes
+de profondeur et un tampon uniforme de 176 octets ; aucun retour GPU vers CPU
+en production. L'arrêt de l'option ou une intensité nulle libèrent ce tampon.
+
+Ce n'est pas un remplacement des textures par des variantes CTM. Le calcul
+concerne les faces visibles alignées sur la grille : les faces hors écran,
+les surfaces transparentes absentes de la profondeur et les géométries
+arbitrairement inclinées ne sont pas reconstruites. À très grande distance,
+les détails plus petits qu'un pixel peuvent rester imperceptibles. Aucun
+chargement de chunk forcé, aucune promesse de FPS.
+
+Les ombres proposent les cinq mêmes portées. La carte reste plafonnée à
+4096 × 4096 : les grandes distances réduisent sa précision spatiale. Le cache
+garde ses limites de 96 Mio, quatre sections et 3 ms souples de construction
+par image ; la réconciliation des chunks est limitée aux ticks et changements
+de caméra/terrain plutôt qu'à toutes les images.
+
+L'intensité solaire reste pleine au zénith. Les contours opaques restent nets,
+le filtrage du feuillage et les ombres légères de la lune sont conservés.
+Le réalignement de la grille lumineuse a lieu au changement d'ancrage de la
+caméra, avec transfert de phase par texels entiers. La rotation du soleil ne
+réarrondit plus la projection de l'origine mondiale à chaque image, source
+de sauts périodiques amplifiés aux grandes coordonnées. Le soleil continue
+d'avancer ; une ombre pixélisée peut naturellement changer de case. Cette
+correction ne modifie pas l'horloge serveur ni sa cadence native.
+
+Textes FR/EN. Aucun changement de règles, sauvegardes, génération, gemmes,
+sculptures ou découvertes.
+
+## Vérifications et livraison
+
+Le client natif réussit en **2 min 41 s**, dans un monde neuf plat, graine 122,
+sur macOS / Apple M1 / OpenGL :
+
+- CTM : 596 échantillons éclaircis sur le contour et 65 068 conservés ; les
+  20 centres et 20 jonctions coplanaires ciblés restent intacts, y compris
+  au changement de matériau. L'intensité 90 produit environ trois fois le gain.
+- Ouverture d'un trou : 716 échantillons éclaircis ; la fermeture restitue
+  l'image connectée. Au-delà de 16 blocs, le réglage 16 supprime le contour ;
+  le réglage 64 le rétablit (254 échantillons éclaircis).
+- Cinq portées CTM et cinq portées d'ombres, persistance/clamp, migration des
+  anciennes préférences, arrêt/libération, rechargement, caméra et vue oblique
+  avec ombres. Captures françaises/anglaises inspectées ; suppression ensuite
+  d'un préfixe redondant dans le libellé de portée.
+- Soleil, lune, nouvelle lune, ombres opaques nettes à midi et transmission
+  du feuillage restent vérifiés. Casters hors écran et retrait/repose actifs.
+- 2 000 petits pas solaires aux coordonnées ±100 000 vérifient l'absence de
+  saut de translation de la carte ; changement d'ancrage par texels entiers.
+  La séquence du vrai service realtime suit 294 images : angle avancé de
+  0,000694 radian, aucun rebond dans les 65 664 échantillons de sol suivis.
+  Sur cette courte séquence, aucune case opaque n'a changé ; cela ne constitue
+  pas une mesure de mouvement visible sur une journée entière.
+
+La fixture initiale capturait parfois le terrain avant la fin de sa construction
+native : elle attend désormais la réception de toute la plateforme et la fin
+compilée des sections. Aucun changement de gameplay pour contourner ce problème.
+
+Commande : `./gradlew :sanctuary:runClientGameTest -PsanctuaryClientTests=true
+-PsanctuaryPixelShadows122ClientTests=true -PsanctuaryClientNoVsync=true
+-PsanctuaryQuickTests=true`. Log `build/shader129-client.log`, captures sous
+`mods/sanctuary/build/run/clientGameTest/screenshots/`.
+
+`./gradlew check build assemblePack assembleTestPack -x :sanctuary:runGameTest`
+réussit en **2 min 17 s**, 126 tâches. Une dernière passe d’assemblage intègre
+la simplification du libellé de portée (2 min 18 s). Les archives sont vérifiées :
+**17 entrées de production** diffèrent de beta.128, limitées au shader et à ses
+interfaces. Même JAR dans normal/Test, sources archivées conformes, ressources
+du template exactes, assets des gemmes inchangés. Aucun monde ni test embarqué.
+Le serveur GameTest dédié
+reste exclu conformément au refus antérieur de son EULA. Aucun monde personnel
+utilisé pour les essais, aucun résultat Windows/Vulkan revendiqué.
+
+
+Archives vérifiées dans `build/` et recopiées dans le dossier de livraison
+habituel `sanctuary-beta/build/` :
+
+- Normal : 10 353 946 octets, SHA-256
+  `2c7735194faab8a699004e69ad543ce6e8fabdebe297b759bffd31fea2dcc2e8`.
+- Test : 10 372 872 octets, SHA-256
+  `cca572ee313d1d7e66ed745bb48bac62490998760d9b7bbfc7a1f6d60c430dce`.
+- JAR Sanctuary :
+  `ca3e2ff4e0717a3a54c1d57478d43aade39d001b71c4eec745d76f010f7def54`.
+
+Publication et synchronisation à consigner après leur exécution.

docs/shaders-beta040.md

@@ -102,3 +102,8 @@ client natif : témoin `SHADER040_CLIENT_PASS` dans
 `build/operator040-client-final.log`. Captures dans
 `build/operator040-evidence/final/`, reçu dans `build/operator040-artifact.json`.
 Les contrôles ne revendiquent pas un essai avec Iris ou un autre moteur externe.
+
+
+Les ombres portées pixélisées sont livrées dans [beta.127](shader-beta127.md),
+intégrées sur la beta.126. Leur préparation locale portait un numéro beta.122
+non publié ; la release beta.122 existante n'est pas remplacée.

docs/wrench-safety-beta123.md

@@ -0,0 +1,129 @@
+# TOOL-02 — Clé dorée et clé de Steve — beta.123
+
+Contrat du 17 septembre 2026, branche `codex/wrench-safety-beta123`.
+Ce ticket remplace le contrat de la clé dorée de beta.120 : l'édition libre
+reste disponible dans un objet distinct, la **Clé à molette de Steve**.
+Le créateur précise que la clé de Steve reste utilisable en survie dès qu’un
+joueur la récupère, sans condition opérateur. Elle n’a pas de recette.
+
+## Clé dorée : orientations natives
+
+L'identifiant `sanctuary:golden_wrench`, sa recette et sa texture restent stables.
+Clic droit parcourt l'orientation native ; Maj parcourt en sens inverse.
+Clic gauche rappelle les gestes, sans casser le bloc ni sélectionner un état.
+Les familles de propriétés autorisées sont les orientations horizontales,
+les six directions, les trois axes, la rotation native des panneaux et
+l'orientation native des blocs qui la proposent. La règle porte sur les
+propriétés Minecraft, sans catalogue à maintenir pour chaque type de bloc.
+
+L'eau, la moitié d'un escalier, les inventaires, les états de croissance,
+les quantités, la puissance et les autres propriétés ne sont jamais proposées.
+Aucune transformation indépendante des textures n'est créée par la clé dorée.
+Les textures suivent seulement le modèle orienté par Minecraft.
+Les connexions et formes sont recalculées à partir des voisins réels, avec les
+mises à jour natives actives. Une orientation privée de support est refusée
+sans casser le bloc. L'eau déjà contenue dans un bloc est conservée.
+
+Les coffres doubles, portes, lits, étagères reliées, pistons sortis et leurs
+pièces mobiles ne peuvent pas être tournés individuellement. Ils restent dans
+leur état courant et une indication explique le refus. Il faut replacer les
+éléments concernés ou rétracter le piston ; ce ticket ne déplace pas un
+ensemble lié. Les coffres simples conservent leur entité et leur inventaire.
+
+L'assemblage, l'ouverture et la dissociation des Métablis, Fûts, Fourneaux et
+super pistons restent prioritaires avec les deux clés. Les parties techniques
+d'un multibloc Sanctuary assemblé ne sont pas éditées individuellement.
+
+## Clé de Steve
+
+Nouvel identifiant `sanctuary:steve_wrench`, dans la section créative des outils,
+sans recette de survie. La possession de cet objet donne accès à ses pouvoirs,
+y compris en survie sans commandes et sans statut opérateur, dans les deux
+mains. Les restrictions natives de construction, aventure, spectateur, portée,
+protection et verrouillage restent appliquées côté serveur.
+
+Les gestes de beta.120 sont conservés : clic gauche choisit la propriété,
+clic droit la modifie, Maj inverse le parcours. Tous les états natifs et la
+rotation indépendante des textures y restent volontairement accessibles.
+La clé de Steve est donc volontairement capable de produire des états non
+naturels, y compris pour le joueur qui la récupère en survie.
+
+La texture finale est le PNG 16 × 16 bleu fourni par le créateur dans ce ticket,
+copié sans transformation dans `assets/sanctuary/textures/item/steve_wrench.png`.
+SHA-256 : `0084c41e1f46958903075e21866facd97d85e03fb8e06742e25b2ab254956fa3`.
+Le modèle reste un objet Minecraft 2D tenu en main, avec rareté épique et reflet.
+La proposition imagegen intermédiaire n'est pas livrée. Les noms, messages et
+indications des deux outils existent en français et en anglais.
+
+## Sauvegardes et ressources
+
+Aucune migration, modification de génération ni parcours des mondes existants.
+Les transformations de texture précédemment sauvegardées sont conservées ;
+la clé de Steve permet de les modifier. Les états non naturels déjà présents
+ne sont pas automatiquement réécrits. Les clés dorées existantes reçoivent
+immédiatement les nouvelles restrictions par leur identifiant inchangé.
+Le template personnel inclut le nouvel objet à sa prochaine création ; une
+copie personnelle existante n'est jamais écrasée.
+
+## Vérifications
+
+Le parcours `Wrench123ClientChecks` passe en **1 min 12 s**, client macOS et
+serveur intégré, Minecraft 26.3, dans des mondes plats jetables de graines
+123 et 120. Il reprend le parcours avancé de beta.120 sur la clé de Steve :
+
+- Vrais clics dorés répétés sur escalier, coffre et terre : pas de nouvelle eau,
+  pas de sélection libre, pas de faux coffre double ni de rotation de texture.
+- Rotation inverse, eau existante conservée, formes recalculées selon les voisins,
+  trois axes de bûches et six orientations des pistons isolés.
+- Coffre double avec ses deux inventaires intacts ; portes, lits, pistons sortis
+  et pièces mobiles protégés ; torche murale sans support laissée intacte.
+- Vrais clics Steve en survie sans commandes : états et textures accessibles,
+  dans les deux mains. Créatif accessible aussi sans commandes ; restrictions
+  aventure/spectateur/portée conservées.
+- **2 522 propriétés natives** toujours réversibles pour Steve, UV réellement
+  tournés sans déplacer la géométrie, rechargement des ressources, inventaires
+  et sauvegarde/reconnexion conservés.
+- Assemblage et dissociation des quatre familles avec la clé dorée par vrais
+  clics ; le PNG de Steve apparaît en main et dans la barre rapide.
+
+Marqueurs `WRENCH123_SAFE_PASS`, `WRENCH123_PASS`, `WRENCH120_PASS` dans
+`build/wrench123-client.log`. Captures relues dans `build/wrench123-evidence/`.
+Pas de validation Windows, de client distant ou de shader tiers.
+
+`./gradlew check build assemblePack assembleTestPack -x :sanctuary:runGameTest`
+passe en **2 min 19 s**, 126 tâches (103 exécutées, 23 à jour).
+Les sources des JAR correspondent aux sources du dépôt. La comparaison avec
+beta.122 limite les dix entrées de production modifiées aux classes des clés,
+aux libellés et aux ressources du nouvel objet. Les autres ressources,
+notamment les sculptures et la texture dorée, sont identiques.
+Les packs normal/Test contiennent le même JAR Sanctuary, sans sauvegarde ni
+fixture de test. Le template ZIP correspond exactement aux ressources du JAR
+et à ses ressources embarquées, dont le PNG bleu du créateur.
+
+- Pack normal : 10 270 954 octets, SHA-256
+  `a7401dbef1bd1b888da2686368943eddc82d0d43e20449330c4849b4dff93e5f`.
+- Pack Test : 10 289 877 octets, SHA-256
+  `c57cc6fc47f887b90850473e51407b610a6c5639c35fc2b78dc9ddb74f795b80`.
+- JAR Sanctuary : SHA-256
+  `23e1a81c793a048c6375a0da07eb0bbe1a18f833a9ceb61a3c1dc5f1a3e65a30`.
+
+Reçu local : `build/wrench123-artifact.json`.
+
+Le GameTest dédié reste exclu conformément au refus antérieur de son EULA.
+Aucun monde personnel n'est ouvert par les essais.
+
+## Publication et installation
+
+La [release beta.123](https://git.botsu.net/koka/sanctuary-beta/releases/tag/beta.123)
+est publiée depuis `4552cc347b7fded610b1eda7a67ffaad56a5e201`.
+Le tag exact et les artefacts sont immuables ; les téléchargements publics
+ont été vérifiés. Canal packwiz : `f988d01b901f2d3eda0b4ab47a48540dc627d1b5`.
+Le template personnel publié inclut la clé de Steve ; SHA-256
+`f84d3c1c0e38232add90fb943dc39fd3e89138576df86024ceaa311478ed5cb9`.
+
+Deux synchronisations isolées puis deux dans **Sanctuary Beta** réussissent.
+Un seul JAR Sanctuary beta.123 est actif, conforme au hash vérifié ; le second
+passage ne change rien. Les **923 fichiers personnels et réglages suivis**
+restent inchangés, sans ouverture de monde personnel. Copie préalable dans
+`sanctuary-backups/before-beta.123/` de l'instance existante.
+Reçus : `build/wrench123-isolated.json` et `build/wrench123-prism.json`.

gradle.properties

@@ -9,8 +9,8 @@ loom_version=1.17.20
 fabric_api_version=0.160.5+26.3
 
 # Release counter: beta.001, .002, .003, ... (see docs/versioning.md).
-mod_version=beta.112
-pack_version=beta.112
-resource_pack_version=beta.090
+mod_version=beta.129
+pack_version=beta.129
+resource_pack_version=beta.121
 maven_group=fr.koka.sanctuary
 jei_version=30.32.0-sanctuary.3

mods/sanctuary/build.gradle

@@ -93,6 +93,44 @@ tasks.named('runGameTest') {
 }
 
 tasks.named('processGametestResources') {
+    def shadows122Client = providers.gradleProperty('sanctuaryPixelShadows122ClientTests').map { it.toBoolean() }.getOrElse(false)
+    inputs.property('sanctuaryPixelShadows122ClientTests', shadows122Client)
+    if (shadows122Client) filter { line -> line.replace('fr.koka.sanctuary.gametest.SanctuaryClientRenderTests', 'fr.koka.sanctuary.client.shader.PixelShadows122ClientChecks') }
+
+    def gems126Client = providers.gradleProperty('sanctuaryGems126ClientTests').map { it.toBoolean() }.getOrElse(false)
+    inputs.property('sanctuaryGems126ClientTests', gems126Client)
+    if (gems126Client) filter { line -> line.replace('fr.koka.sanctuary.gametest.SanctuaryClientRenderTests', 'fr.koka.sanctuary.client.Gems126ClientChecks') }
+
+    def sculpture125Client = providers.gradleProperty('sanctuarySculpture125ClientTests').map { it.toBoolean() }.getOrElse(false)
+    inputs.property('sanctuarySculpture125ClientTests', sculpture125Client)
+    if (sculpture125Client) filter { line -> line.replace('fr.koka.sanctuary.gametest.SanctuaryClientRenderTests', 'fr.koka.sanctuary.client.Sculpture125ClientChecks') }
+
+    def wrench123Client = providers.gradleProperty('sanctuaryWrench123ClientTests').map { it.toBoolean() }.getOrElse(false)
+    inputs.property('sanctuaryWrench123ClientTests', wrench123Client)
+    if (wrench123Client) filter { line -> line.replace('fr.koka.sanctuary.gametest.SanctuaryClientRenderTests', 'fr.koka.sanctuary.client.Wrench123ClientChecks') }
+
+    def sculpture122Client = providers.gradleProperty('sanctuarySculpture122ClientTests').map { it.toBoolean() }.getOrElse(false)
+    inputs.property('sanctuarySculpture122ClientTests', sculpture122Client)
+    if (sculpture122Client) filter { line -> line.replace('fr.koka.sanctuary.gametest.SanctuaryClientRenderTests', 'fr.koka.sanctuary.client.Sculpture122ClientChecks') }
+
+    def template121Client = providers.gradleProperty('sanctuaryResourceTemplate121ClientTests').map { it.toBoolean() }.getOrElse(false)
+    inputs.property('sanctuaryResourceTemplate121ClientTests', template121Client)
+    if (template121Client) filter { line -> line.replace('fr.koka.sanctuary.gametest.SanctuaryClientRenderTests', 'fr.koka.sanctuary.client.ResourceTemplate121ClientChecks') }
+
+    def wrench120Client = providers.gradleProperty('sanctuaryWrench120ClientTests').map { it.toBoolean() }.getOrElse(false)
+    inputs.property('sanctuaryWrench120ClientTests', wrench120Client)
+    if (wrench120Client) filter { line -> line.replace('fr.koka.sanctuary.gametest.SanctuaryClientRenderTests', 'fr.koka.sanctuary.client.Wrench120ClientChecks') }
+
+    def sculpture116Client = providers.gradleProperty('sanctuarySculpture116ClientTests').map { it.toBoolean() }.getOrElse(false)
+    inputs.property('sanctuarySculpture116ClientTests', sculpture116Client)
+    if (sculpture116Client) filter { line -> line.replace('fr.koka.sanctuary.gametest.SanctuaryClientRenderTests', 'fr.koka.sanctuary.client.Sculpture116ClientChecks') }
+    def furnace115Client = providers.gradleProperty('sanctuaryFurnace115ClientTests').map { it.toBoolean() }.getOrElse(false)
+    inputs.property('sanctuaryFurnace115ClientTests', furnace115Client)
+    if (furnace115Client) filter { line -> line.replace('fr.koka.sanctuary.gametest.SanctuaryClientRenderTests', 'fr.koka.sanctuary.client.Furnace115ClientChecks') }
+    def carryPanic114Client = providers.gradleProperty('sanctuaryCarryPanic114ClientTests').map { it.toBoolean() }.getOrElse(false)
+    inputs.property('sanctuaryCarryPanic114ClientTests', carryPanic114Client)
+    if (carryPanic114Client) filter { line -> line.replace('fr.koka.sanctuary.gametest.SanctuaryClientRenderTests', 'fr.koka.sanctuary.client.CarryPanic114ClientChecks') }
+
     def statuary106Client = providers.gradleProperty('sanctuaryStatuary106ClientTests').map { it.toBoolean() }.getOrElse(false)
     inputs.property('sanctuaryStatuary106ClientTests', statuary106Client)
     if (statuary106Client) filter { line -> line.replace('fr.koka.sanctuary.gametest.SanctuaryClientRenderTests', 'fr.koka.sanctuary.client.Statuary106ClientChecks') }
@@ -430,6 +468,15 @@ tasks.withType(JavaCompile).configureEach {
 }
 
 processResources {
+    from(rootProject.file('ressources-pack/template')) {
+        exclude '**/.DS_Store'
+        into 'resourcepacks/template'
+    }
+    from(rootProject.file('LICENSE')) {
+        rename { 'LICENSE_sanctuary' }
+        into 'resourcepacks/template'
+    }
+    from(rootProject.file('THIRD_PARTY_NOTICES.md')) { into 'resourcepacks/template' }
     from(rootProject.file('ressources-pack/sanctuary')) {
         include 'assets/**', 'pack.mcmeta', 'pack.png'
         exclude '**/.DS_Store'

mods/sanctuary/src/clientGametest/java/fr/koka/sanctuary/client/Bricks102ClientChecks.java

@@ -37,10 +37,10 @@ public final class Bricks102ClientChecks implements FabricClientGameTest {
    c.waitFor(m->ProgressionClient.active()&&m.player!=null&&m.gui.screen()==null&&!IntroSpawnFlash.active(),1200);
    world.getServer().runOnServer(s->{
     var p=s.getPlayerList().getPlayers().getFirst();var level=p.level();var pos=new BlockPos(0,3,0);
-    check(ColoredBricks.families().size()==16,"All colors registered");int index=0;
+    check(ColoredBricks.families().size()==16,"All colors registered");Walls118Checks.server(s);int index=0;
     for(var f:ColoredBricks.families()){
      String color=f.color().getName();
-     for(var block:List.of(f.bricks(),f.slab(),f.stairs(),f.clay()))check(block.asItem()!=Items.AIR,"Block item exists "+block);
+     for(var block:List.of(f.bricks(),f.slab(),f.stairs(),f.wall(),f.clay()))check(block.asItem()!=Items.AIR,"Block item exists "+block);
      check(f.bricks().defaultBlockState().is(BlockTags.MINEABLE_WITH_PICKAXE),"Pickaxe tag "+color);
      check(f.clay().defaultBlockState().is(BlockTags.MINEABLE_WITH_SHOVEL),"Shovel tag "+color);
      var shovel=new ItemStack(Items.DIAMOND_SHOVEL);var silk=shovel.copy();silk.enchant(level.registryAccess().lookupOrThrow(Registries.ENCHANTMENT).getOrThrow(Enchantments.SILK_TOUCH),1);
@@ -52,7 +52,7 @@ public final class Bricks102ClientChecks implements FabricClientGameTest {
      drop(Block.getDrops(f.stairs().defaultBlockState(),level,pos,null),f.stairs().asItem(),1);
      check(f.slab().defaultBlockState().setValue(SlabBlock.WATERLOGGED,true).getFluidState().isSource(),"Slab water "+color);
      check(f.stairs().defaultBlockState().setValue(StairBlock.WATERLOGGED,true).getFluidState().isSource(),"Stair water "+color);
-     for(String suffix:List.of("clay_ball_from_dye","clay_from_dye","brick_from_dye","bricks_from_dye","clay","bricks","brick_slab","brick_stairs","brick_slab_from_stonecutting","brick_stairs_from_stonecutting","clay_ball_smelting","clay_smelting"))check(s.getRecipeManager().byKey(ResourceKey.create(Registries.RECIPE,SanctuaryMod.id(color+"_"+suffix))).isPresent(),"Recipe loaded "+color+"_"+suffix);
+     for(String suffix:List.of("clay_ball_from_dye","clay_from_dye","brick_from_dye","bricks_from_dye","clay","bricks","brick_slab","brick_stairs","brick_slab_from_stonecutting","brick_stairs_from_stonecutting","brick_wall","brick_wall_from_stonecutting","clay_ball_smelting","clay_smelting"))check(s.getRecipeManager().byKey(ResourceKey.create(Registries.RECIPE,SanctuaryMod.id(color+"_"+suffix))).isPresent(),"Recipe loaded "+color+"_"+suffix);
      craft(s,level,2,2,List.of(f.brick(),f.brick(),f.brick(),f.brick()),f.bricks().asItem(),1);
      craft(s,level,2,2,List.of(f.clayBall(),f.clayBall(),f.clayBall(),f.clayBall()),f.clay().asItem(),1);
      craft(s,level,3,1,List.of(f.bricks().asItem(),f.bricks().asItem(),f.bricks().asItem()),f.slab().asItem(),6);
@@ -62,39 +62,40 @@ public final class Bricks102ClientChecks implements FabricClientGameTest {
      var input=new SingleRecipeInput(new ItemStack(f.clayBall()));var cooked=s.getRecipeManager().getRecipeFor(RecipeType.SMELTING,input,level).orElseThrow().value().assemble(input);check(cooked.is(f.brick()),"Smelt brick "+color);
      input=new SingleRecipeInput(new ItemStack(f.clay()));cooked=s.getRecipeManager().getRecipeFor(RecipeType.SMELTING,input,level).orElseThrow().value().assemble(input);check(cooked.is(BuiltInRegistries.ITEM.getValue(net.minecraft.resources.Identifier.withDefaultNamespace(color+"_terracotta"))),"Smelt terracotta "+color);
      var stoneInput=new SingleRecipeInput(new ItemStack(f.bricks()));
-     for(var variant:List.of(new Object[]{"brick_slab",f.slab().asItem(),2},new Object[]{"brick_stairs",f.stairs().asItem(),1})){
+     for(var variant:List.of(new Object[]{"brick_slab",f.slab().asItem(),2},new Object[]{"brick_stairs",f.stairs().asItem(),1},new Object[]{"brick_wall",f.wall().asItem(),1})){
       var recipe=(StonecutterRecipe)s.getRecipeManager().byKey(ResourceKey.create(Registries.RECIPE,SanctuaryMod.id(color+"_"+variant[0]+"_from_stonecutting"))).orElseThrow().value();check(recipe.matches(stoneInput,level),"Stonecutting accepts input");var cut=recipe.assemble(stoneInput);check(cut.is((Item)variant[1])&&cut.getCount()==(int)variant[2],"Stonecutting result");
      }
      int x=(index%8)*3,z=(index/8)*5;level.setBlockAndUpdate(new BlockPos(x,1,z),f.bricks().defaultBlockState());level.setBlockAndUpdate(new BlockPos(x,2,z),f.slab().defaultBlockState().setValue(SlabBlock.TYPE,SlabType.TOP));level.setBlockAndUpdate(new BlockPos(x+1,1,z),f.stairs().defaultBlockState().setValue(StairBlock.FACING,Direction.SOUTH));level.setBlockAndUpdate(new BlockPos(x,1,z+1),f.clay().defaultBlockState());index++;
     }
     fr.koka.sanctuary.recipes.RecipeService.discover(p,Items.CLAY_BALL);fr.koka.sanctuary.recipes.RecipeService.refresh(p);
     var known=fr.koka.sanctuary.recipes.RecipeService.knowledge(p);
-    for(var f:ColoredBricks.families())check(known.recipes.contains("sanctuary:"+f.color().getName()+"_brick_stairs_from_stonecutting"),"Collection unlock "+f.color());
+    check(known.recipes.contains("sanctuary:clay_workshop"),"Existing workshop recipe remains discoverable");
+    for(var f:ColoredBricks.families())check(known.recipes.contains("sanctuary:"+f.color().getName()+"_brick_stairs_from_stonecutting")&&known.recipes.contains("sanctuary:"+f.color().getName()+"_brick_wall")&&known.recipes.contains("sanctuary:"+f.color().getName()+"_brick_wall_from_stonecutting"),"Collection unlock "+f.color());
     s.getCommands().performPrefixedCommand(s.createCommandSourceStack(),"sanctuary time vanilla");s.getCommands().performPrefixedCommand(s.createCommandSourceStack(),"time set noon");
     p.teleportTo(11,8,19);p.setYRot(180);p.setXRot(26);p.getAbilities().flying=true;p.onUpdateAbilities();
    });
    c.runOnClient(m->{
     CreativeModeTabs.tryRebuildTabContents(m.level.enabledFeatures(),true,m.level.registryAccess());
     var blocks=BuiltInRegistries.CREATIVE_MODE_TAB.getOrThrow(CreativeModeTabs.COLORED_BLOCKS).value().getDisplayItems();
-    var ingredients=BuiltInRegistries.CREATIVE_MODE_TAB.getOrThrow(CreativeModeTabs.INGREDIENTS).value().getDisplayItems();
+    var ingredients=BuiltInRegistries.CREATIVE_MODE_TAB.getOrThrow(CreativeModeTabs.INGREDIENTS).value().getDisplayItems();Walls118Checks.creative(new ArrayList<>(blocks));
     for(var f:ColoredBricks.families()){
-     for(var b:List.of(f.bricks(),f.slab(),f.stairs(),f.clay())){
+     for(var b:List.of(f.bricks(),f.slab(),f.stairs(),f.wall(),f.clay())){
       check(blocks.stream().anyMatch(i->i.is(b.asItem())),"Creative color tab "+b);
       for(var state:b.getStateDefinition().getPossibleStates()){
-       var parts=new ArrayList<net.minecraft.client.renderer.block.dispatch.BlockStateModelPart>();m.getModelManager().getBlockStateModelSet().get(state).collectParts(net.minecraft.util.RandomSource.create(0),parts);check(!parts.isEmpty(),"Baked model "+state);
+       var parts=new ArrayList<net.minecraft.client.renderer.block.dispatch.BlockStateModelPart>();m.getModelManager().getBlockStateModelSet().get(state).collectParts(net.minecraft.util.RandomSource.create(0),parts);check(b instanceof WallBlock||!parts.isEmpty(),"Baked model "+state);
        for(var part:parts)for(var direction:new Direction[]{Direction.UP,Direction.DOWN,Direction.NORTH,Direction.SOUTH,Direction.EAST,Direction.WEST,null})for(var quad:part.getQuads(direction))check(!quad.materialInfo().sprite().contents().name().toString().contains("missingno"),"No missing texture "+state);
       }
      }
      for(var item:List.of(f.clayBall(),f.brick()))check(ingredients.stream().anyMatch(i->i.is(item)),"Creative ingredients "+item);
     }
    });
-   c.waitTicks(20);c.runOnClient(m->{m.player.setYRot(180);m.player.setXRot(26);});c.waitTicks(4);c.takeScreenshot("bricks102-gallery");saved=world.getWorldSave();System.out.println("BRICKS102_NATIVE_PASS colors=16 recipes=192 blocks=64 items=96");
+   c.waitTicks(20);c.runOnClient(m->{m.player.setYRot(180);m.player.setXRot(26);});c.waitTicks(4);c.takeScreenshot("bricks102-gallery");saved=world.getWorldSave();System.out.println("BRICKS102_NATIVE_PASS colors=16 recipes=224 blocks=80 items=112");
   }
   try(var world=saved.open()){
    c.waitFor(m->m.player!=null&&m.gui.screen()==null,1200);
-   world.getServer().runOnServer(s->{var level=s.getPlayerList().getPlayers().getFirst().level();int i=0;for(var f:ColoredBricks.families()){var pos=new BlockPos((i%8)*3,1,(i/8)*5);check(level.getBlockState(pos).is(f.bricks()),"Saved bricks "+f.color());check(level.getBlockState(pos.above()).getValue(SlabBlock.TYPE)==SlabType.TOP,"Saved slab state");i++;}});
+   world.getServer().runOnServer(s->{var level=s.getPlayerList().getPlayers().getFirst().level();Walls118Checks.saved(level);int i=0;for(var f:ColoredBricks.families()){var pos=new BlockPos((i%8)*3,1,(i/8)*5);check(level.getBlockState(pos).is(f.bricks()),"Saved bricks "+f.color());check(level.getBlockState(pos.above()).getValue(SlabBlock.TYPE)==SlabType.TOP,"Saved slab state");i++;}});
   }
-  System.out.println("BRICKS102_PASS");
+  System.out.println("BRICKS102_PASS");System.out.println("WALLS118_PASS native placement, mixed connections, tall sides, waterlogging, collision, crafting, stonecutting, loot, collection, creative order, baked models and reconnect");
  }
  private static void craft(net.minecraft.server.MinecraftServer s,net.minecraft.server.level.ServerLevel level,int w,int h,List<Item> items,Item result,int count){var input=CraftingInput.of(w,h,items.stream().map(ItemStack::new).toList());var stack=s.getRecipeManager().getRecipeFor(RecipeType.CRAFTING,input,level).orElseThrow().value().assemble(input);check(stack.is(result)&&stack.getCount()==count,"Craft "+result);}
  private static void drop(List<ItemStack> drops,Item item,int count){check(drops.size()==1&&drops.getFirst().is(item)&&drops.getFirst().getCount()==count,"Loot "+item+" expected "+count+" got "+drops);}

mods/sanctuary/src/clientGametest/java/fr/koka/sanctuary/client/CarryPanic114ClientChecks.java

@@ -0,0 +1,115 @@
+package fr.koka.sanctuary.client;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import fr.koka.sanctuary.cosmetics.*;
+import fr.koka.sanctuary.gametest.Starter039TestSupport;
+import fr.koka.sanctuary.inventory.*;
+import java.util.*;
+import java.util.concurrent.atomic.*;
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
+import net.fabricmc.fabric.api.client.gametest.v1.FabricClientGameTest;
+import net.fabricmc.fabric.api.client.gametest.v1.context.ClientGameTestContext;
+import net.minecraft.client.CameraType;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.screens.worldselection.WorldCreationUiState;
+import net.minecraft.client.input.KeyEvent;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.component.DataComponents;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.contents.TranslatableContents;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.*;
+import net.minecraft.world.item.*;
+import net.minecraft.world.item.component.CustomData;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.phys.*;
+
+/** Real cursor/attack packets, synchronized player travel, interruption and collision regression. */
+public final class CarryPanic114ClientChecks implements FabricClientGameTest {
+    public void runTest(ClientGameTestContext c){
+        var intro=new AtomicBoolean(true);
+        c.runOnClient(m->{m.options.renderDistance().set(6);m.options.simulationDistance().set(5);m.options.pauseOnLostFocus=false;IntroClient.setQuickTestIntro(true);});
+        ClientTickEvents.END_CLIENT_TICK.register(m->{if(intro.get()&&m.gui.screen() instanceof HelloWorldScreen screen){
+            Starter039TestSupport.selectFirst(screen);
+            screen.children().stream().filter(Button.class::isInstance).map(Button.class::cast).filter(b->b.getClass().getSimpleName().equals("ColorButton")).findFirst().orElseThrow().onPress(enter());
+            screen.children().stream().filter(Button.class::isInstance).map(Button.class::cast).filter(b->b.getMessage().getContents() instanceof TranslatableContents t&&t.getKey().equals("sanctuary.progression.enter")).findFirst().orElseThrow().onPress(enter());intro.set(false);
+        }});
+        try(var world=c.worldBuilder().adjustSettings(s->{s.setName("CarryPanic114 "+UUID.randomUUID());s.setSeed("114");s.setAllowCommands(true);s.setGameMode(WorldCreationUiState.SelectedGameMode.SURVIVAL);
+            s.setWorldType(s.getNormalPresetList().stream().filter(e->e.preset()!=null&&e.preset().getRegisteredName().equals("sanctuary_test:flat")).findFirst().orElseThrow());}).create()){
+            c.waitFor(m->ProgressionClient.active()&&m.player!=null&&m.gui.screen()==null&&!IntroSpawnFlash.active(),1200);var server=world.getServer();
+            server.runOnServer(s->{var p=player(s);p.getInventory().clearContent();p.getAbilities().invulnerable=true;p.onUpdateAbilities();reset(p);
+                for(int x=-24;x<=24;x++)for(int z=-24;z<=24;z++)p.level().setBlockAndUpdate(new BlockPos(x,0,z),Blocks.STONE.defaultBlockState());
+                s.getCommands().performPrefixedCommand(s.createCommandSourceStack(),"sanctuary time vanilla");s.getCommands().performPrefixedCommand(s.createCommandSourceStack(),"time set noon");});
+            int parrot=server.computeOnServer(s->carry(player(s),EntityTypes.PARROT).getId());
+            c.waitFor(m->m.level.getEntity(parrot)!=null&&CarryService.carried(m.level.getEntity(parrot)),150);
+            float health=server.computeOnServer(s->((LivingEntity)player(s).level().getEntity(parrot)).getHealth());
+            attack(c,parrot);c.waitFor(m->CarryPanic.active(m.player),100);
+            server.runOnServer(s->{var p=player(s);check(CarryPanic.active(p),"Real native attack triggers server panic");check(((LivingEntity)p.level().getEntity(parrot)).getHealth()<health,"Ordinary carried animal takes native damage");});
+            c.getInput().holdKey(o->o.keyUp);c.getInput().holdKey(o->o.keyRight);c.getInput().holdKey(o->o.keyJump);
+            c.runOnClient(m->{m.player.setYRot(170);m.player.setXRot(15);});c.waitTicks(12);
+            c.runOnClient(m->{check(m.player.getY()>2.5&&m.player.position().subtract(new Vec3(.5,1,.5)).horizontalDistance()>1,"Actual client moves upward and sideways");
+                check(CarryPanic.active(m.player),"Panic remains active through steering keys");
+                var wanted=m.player.getAttached(CarryPanic.FLIGHT).velocity(m.level.getGameTime());
+                // Level time can advance immediately after the player physics tick. Match either exact tick.
+                var previous=m.player.getAttached(CarryPanic.FLIGHT).velocity(m.level.getGameTime()-1);
+                check(Math.min(m.player.getDeltaMovement().distanceTo(wanted),m.player.getDeltaMovement().distanceTo(previous))<.00001,"Movement follows animal, not camera or held keys: actual="+m.player.getDeltaMovement()+", expected="+wanted+", flight="+m.player.getAttached(CarryPanic.FLIGHT)+", time="+m.level.getGameTime());check(m.player.fallDistance<.2,"Flight clears falling distance");
+                m.options.setCameraType(CameraType.THIRD_PERSON_BACK);});c.waitTicks(2);c.takeScreenshot("carry114-chaotic-flight");
+            c.getInput().releaseKey(o->o.keyUp);c.getInput().releaseKey(o->o.keyRight);c.getInput().releaseKey(o->o.keyJump);
+            c.waitTicks(65);c.waitFor(m->!CarryPanic.active(m.player),100);
+            server.runOnServer(s->{var p=player(s);check(!p.hasAttached(CarryPanic.FLIGHT)&&CarryGlide.supported(p),"Timeout removes panic and retains ordinary glider");check(p.connection.isAcceptingMessages(),"Flight is accepted by server");});
+            c.runOnClient(m->{check(m.player.getDeltaMovement().y<=0&&m.player.getDeltaMovement().y>=-CarryGlide.DESCENT-.02,"Normal gentle descent resumes");m.options.setCameraType(CameraType.FIRST_PERSON);});
+            System.out.println("CARRY114_NATIVE_FLIGHT_PASS cursor, real attack, damage, movement, input override, timeout, glide");
+
+            server.runOnServer(s->{var p=player(s);p.getRandom().setSeed(114);var bird=p.level().getEntity(parrot);var quadrants=new HashSet<Integer>();
+                for(int i=0;i<32;i++){
+                    CarryPanic.clear(p);CarryPanic.start(bird);var flight=p.getAttached(CarryPanic.FLIGHT);check(flight.duration()>=40&&flight.duration()<=60,"Duration bounded at 2–3 seconds");quadrants.add((int)(flight.yaw()/(Math.PI/2)));
+                    for(int t=0;t<=flight.duration();t++){var v=flight.velocity(flight.start()+t);check(v.horizontalDistance()<=.331&&v.y>=0&&v.y<=.241,"Velocity bounded without cumulative impulses");}
+                }
+                check(quadrants.size()==4,"Server random headings cover every quadrant");
+            });c.waitFor(m->CarryPanic.active(m.player),100);
+            c.getInput().holdKey(o->o.keyShift);c.waitTicks(2);c.getInput().holdKey(o->o.keyUse);c.waitTicks(1);c.getInput().releaseKey(o->o.keyUse);c.getInput().releaseKey(o->o.keyShift);
+            c.waitFor(m->!CarryService.carrying(m.player)&&!CarryPanic.active(m.player),100);
+            server.runOnServer(s->{check(!player(s).hasAttached(CarryPanic.FLIGHT),"Native drop clears flight immediately");player(s).level().getEntity(parrot).discard();reset(player(s));});
+
+            int cow=server.computeOnServer(s->carry(player(s),EntityTypes.COW).getId());
+            server.runOnServer(s->{var p=player(s);var animal=(LivingEntity)p.level().getEntity(cow);float before=animal.getHealth();p.attack(animal);
+                check(CarryService.blocksAttack(p,animal)&&animal.getHealth()==before&&!animal.hurtServer(p.level(),p.damageSources().playerAttack(p),1)&&!CarryPanic.active(p),"Terrestrial carry pair stays protected");CarryPanic.start(animal);check(!CarryPanic.active(p),"Ground animal cannot launch player");CarryService.release(animal,true);animal.discard();reset(p);});
+
+            // Every supported appearance can trigger the shared flight, including the gliding chicken.
+            server.runOnServer(s->{var p=player(s);for(var type:List.of(EntityTypes.CHICKEN,EntityTypes.BAT,EntityTypes.BEE,EntityTypes.ALLAY,EntityTypes.PARROT,EntityTypes.BLAZE,EntityTypes.BREEZE)){
+                var animal=carry(p,type);check(CarryGlide.flyer(animal)&&CarryPanic.canStrike(p,animal),"Carried flying species can be struck: "+type);
+                check(animal.hurtServer(p.level(),p.damageSources().playerAttack(p),1)&&CarryPanic.active(p),"Accepted damage launches carrier: "+type);CarryService.release(animal,true);animal.discard();check(!p.hasAttached(CarryPanic.FLIGHT),"Release clears each flight");
+            }});
+            int external=server.computeOnServer(s->carry(player(s),EntityTypes.PARROT).getId());
+            server.runOnServer(s->{var p=player(s);var bird=(LivingEntity)p.level().getEntity(external);var zombie=EntityTypes.ZOMBIE.create(p.level(),EntitySpawnReason.COMMAND);
+                check(bird.hurtServer(p.level(),p.damageSources().mobAttack(zombie),1)&&CarryPanic.active(p),"External accepted hit also triggers flight");
+                p.getAbilities().flying=true;CarryGlide.tick(p);check(!p.hasAttached(CarryPanic.FLIGHT),"Creative flying invalidates propulsion");p.getAbilities().flying=false;
+                CarryPanic.start(bird);bird.hurtServer(p.level(),p.damageSources().mobAttack(zombie),100);CarryGlide.tick(p);check(!CarryPanic.active(p),"Death stops propulsion");CarryService.detach(p);bird.discard();reset(p);});
+
+            int ceiling=server.computeOnServer(s->{var p=player(s);var bird=carry(p,EntityTypes.PARROT);for(int x=-3;x<=3;x++)for(int z=-3;z<=3;z++)p.level().setBlockAndUpdate(new BlockPos(x,4,z),Blocks.STONE.defaultBlockState());return bird.getId();});
+            c.waitFor(m->m.level.getEntity(ceiling)!=null&&CarryService.carried(m.level.getEntity(ceiling)),100);
+            server.runOnServer(s->{var p=player(s);((LivingEntity)p.level().getEntity(ceiling)).hurtServer(p.level(),p.damageSources().playerAttack(p),1);});c.waitTicks(12);
+            server.runOnServer(s->{var p=player(s);check(p.getY()<2&&p.level().noBlockCollision(p,p.getBoundingBox().deflate(.02)),"Player cannot fly through low ceiling");check(!CarryService.carrying(p)&&!CarryPanic.active(p),"Blocked carried animal is safely released");
+                p.level().getEntity(ceiling).discard();for(int x=-3;x<=3;x++)for(int z=-3;z<=3;z++)p.level().removeBlock(new BlockPos(x,4,z),false);reset(p);
+                var egg=new ItemStack(Items.PARROT_SPAWN_EGG);var size=new CompoundTag();size.putInt("schema",1);size.putInt("per_mille",1000);CustomData.update(DataComponents.CUSTOM_DATA,egg,t->t.put(FamiliarSize.KEY,size));AccessoryAccess.of(p).setItem(AccessoryContainer.FAMILIAR,egg);p.inventoryMenu.broadcastChanges();});
+            c.waitTicks(25);
+            int familiar=server.computeOnServer(s->{var p=player(s);var pet=FamiliarService.active(p);check(pet!=null,"Familiar spawned");pet.setNoAi(true);pet.setPos(p.position().add(0,0,2));check(CarryService.interact(p,pet),"Flying familiar picked up");return pet.getId();});
+            c.waitFor(m->m.level.getEntity(familiar)!=null&&CarryService.carried(m.level.getEntity(familiar)),100);
+            float petHealth=server.computeOnServer(s->FamiliarService.active(player(s)).getHealth());attack(c,familiar);c.waitFor(m->CarryPanic.active(m.player),100);
+            server.runOnServer(s->{var p=player(s);check(FamiliarService.active(p).getHealth()==petHealth&&CarryPanic.active(p),"Friendly familiar tap launches without hurting it");CarryService.detach(p);check(!p.hasAttached(CarryPanic.FLIGHT),"Lifecycle detach clears synchronized flight");});
+            System.out.println("CARRY114_PASS random flight, native ordinary/familiar strikes, seven species, outside hits, ground protection, drop/death/creative cancellation, ceiling collisions, timeout and normal glide");
+        }finally{intro.set(false);c.getInput().releaseKey(o->o.keyUp);c.getInput().releaseKey(o->o.keyRight);c.getInput().releaseKey(o->o.keyJump);c.getInput().releaseKey(o->o.keyShift);c.getInput().releaseKey(o->o.keyAttack);c.getInput().releaseKey(o->o.keyUse);}
+    }
+    private static void attack(ClientGameTestContext c,int id){
+        c.waitFor(m->m.level.getEntity(id).position().distanceTo(CarryService.head(m.player,m.level.getEntity(id)))<.01,100);
+        c.runOnClient(m->{m.options.setCameraType(CameraType.FIRST_PERSON);m.player.lookAt(net.minecraft.commands.arguments.EntityAnchorArgument.Anchor.EYES,m.level.getEntity(id).getBoundingBox().getCenter());});c.waitTicks(3);
+        c.runOnClient(m->check(m.hitResult instanceof EntityHitResult hit&&hit.getEntity().getId()==id,"Native cursor can pick own carried flyer: hit="+m.hitResult+", target="+m.level.getEntity(id).getBoundingBox()+", eye="+m.player.getEyePosition()+", view="+m.player.getLookAngle()+", eligible="+CarryPanic.canStrike(m.player,m.level.getEntity(id))));
+        c.getInput().holdKey(o->o.keyAttack);c.waitTicks(1);c.getInput().releaseKey(o->o.keyAttack);
+    }
+    private static Mob carry(ServerPlayer p,EntityType<? extends Mob> type){var mob=type.create(p.level(),EntitySpawnReason.COMMAND);mob.setNoAi(true);mob.setPos(p.position().add(0,0,2));p.level().addFreshEntity(mob);check(CarryService.interact(p,mob),"Animal picked up: "+type);return mob;}
+    private static void reset(ServerPlayer p){CarryService.detach(p);p.teleportTo(.5,1,.5);p.setDeltaMovement(Vec3.ZERO);p.resetFallDistance();p.setShiftKeyDown(false);}
+    private static ServerPlayer player(MinecraftServer s){return s.getPlayerList().getPlayers().getFirst();}
+    private static KeyEvent enter(){return new KeyEvent(InputConstants.KEY_RETURN,0,0);}
+    private static void check(boolean ok,String message){if(!ok)throw new AssertionError(message);}
+}

mods/sanctuary/src/clientGametest/java/fr/koka/sanctuary/client/Clay126Checks.java

@@ -0,0 +1,42 @@
+package fr.koka.sanctuary.client;
+
+import fr.koka.sanctuary.companion.CompanionService;
+import fr.koka.sanctuary.plans.*;
+import java.nio.file.*;
+import java.util.*;
+import net.fabricmc.fabric.api.client.gametest.v1.context.*;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.entity.EntityTypes;
+import net.minecraft.world.inventory.ContainerInput;
+import net.minecraft.world.item.*;
+import net.minecraft.world.level.GameType;
+
+/** Native preview, server result and survival payment for the special plain-clay material. */
+final class Clay126Checks {
+    static void exercise(ClientGameTestContext c,TestServerContext server){
+        var pos=new BlockPos(4,1,4);
+        server.runOnServer(s->{var p=s.getPlayerList().getPlayers().getFirst();p.teleportTo(3,1,3);p.setGameMode(GameType.SURVIVAL);p.getAbilities().invulnerable=true;p.onUpdateAbilities();p.level().setBlockAndUpdate(pos,Statuary.WORKSHOP.defaultBlockState());CompanionService.save(p,CompanionService.record(p).note("seen_mobs","cow"));Statuary.open(p,pos);p.containerMenu.getSlot(0).set(new ItemStack(Items.CLAY,2));p.containerMenu.broadcastChanges();});
+        c.waitForScreen(ClayWorkshopScreen.class);c.runOnClient(m->{m.options.guiScale().set(2);m.getWindow().setWindowed(1280,800);m.resizeGui();((ClayWorkshopScreen)m.gui.screen()).load(EntityTypes.COW);});
+        c.waitFor(m->{var screen=(ClayWorkshopScreen)m.gui.screen();return !screen.busy()&&screen.selected()!=null&&screen.selected().equals(StatuaryEntity.sculpture(m.player.containerMenu.getSlot(1).getItem()));},250);
+        var cow=c.computeOnClient(m->((ClayWorkshopScreen)m.gui.screen()).selected());check(cow.cells().stream().map(VoxelSculpture.Cell::color).distinct().count()>3,"Cow source retains texture colors");
+        for(var material:List.of(Items.OAK_PLANKS,fr.koka.sanctuary.building.ColoredBricks.families().getFirst().clay().asItem(),Items.CLAY)){
+            server.runOnServer(s->{var menu=s.getPlayerList().getPlayers().getFirst().containerMenu;menu.getSlot(0).set(new ItemStack(material,2));menu.broadcastChanges();});
+            var expected=c.computeOnClient(m->ClayWorkshopMenu.appearance(cow,material,SculptureMaterialSampler.sample(new ItemStack(material))));
+            check(material==Items.CLAY?expected.equals(cow):!expected.equals(cow),"Only plain clay retains original colors");
+            c.waitFor(m->expected.equals(StatuaryEntity.sculpture(m.player.containerMenu.getSlot(1).getItem())),180);
+            c.runOnClient(m->check(ItemStack.matches(((ClayWorkshopScreen)m.gui.screen()).preview(),m.player.containerMenu.getSlot(1).getItem()),"Preview matches authoritative material switch"));
+        }
+        c.takeScreenshot("clay126-original-cow");
+        c.runOnClient(m->m.gameMode.handleContainerInput(m.player.containerMenu.containerId,1,0,ContainerInput.PICKUP,m.player));
+        server.waitFor(s->{var menu=s.getPlayerList().getPlayers().getFirst().containerMenu;return cow.equals(StatuaryEntity.sculpture(menu.getCarried()))&&menu.getSlot(0).getItem().getCount()==1;},100);
+        c.waitFor(m->cow.equals(StatuaryEntity.sculpture(m.player.containerMenu.getCarried()))&&m.player.containerMenu.getSlot(0).getItem().getCount()==1,100);
+        Path file=PlanClient.directory().resolve("clay126-"+UUID.randomUUID()+".glb");
+        try{Files.createDirectories(file.getParent());Files.write(file,Statuary106ClientChecks.fixture());var id=GlbModel.load(file).id();c.runOnClient(m->((ClayWorkshopScreen)m.gui.screen()).load(file));
+            c.waitFor(m->{var screen=(ClayWorkshopScreen)m.gui.screen();return !screen.busy()&&screen.selected()!=null&&screen.selected().modelId().equals(id)&&screen.selected().equals(StatuaryEntity.sculpture(m.player.containerMenu.getSlot(1).getItem()));},250);
+            c.runOnClient(m->{var screen=(ClayWorkshopScreen)m.gui.screen();check(screen.selected().cells().stream().map(VoxelSculpture.Cell::color).distinct().count()>1,"Imported textured GLB retains its original colors");check(ItemStack.matches(screen.preview(),m.player.containerMenu.getSlot(1).getItem()),"Imported preview equals native result");});
+        }catch(Exception e){throw new AssertionError(e);}finally{try{Files.deleteIfExists(file);}catch(Exception ignored){}}
+        server.runOnServer(s->{var p=s.getPlayerList().getPlayers().getFirst();p.closeContainer();p.setGameMode(GameType.CREATIVE);p.getAbilities().flying=true;p.onUpdateAbilities();});c.waitFor(m->m.gui.screen()==null,100);
+        System.out.println("CLAY126_PASS original animal and GLB colors, oak and colored clay palette transfer, switch back, matching previews and one clay paid in survival");
+    }
+    private static void check(boolean ok,String message){if(!ok)throw new AssertionError(message);}
+}

mods/sanctuary/src/clientGametest/java/fr/koka/sanctuary/client/Discovery126Checks.java

@@ -0,0 +1,47 @@
+package fr.koka.sanctuary.client;
+
+import fr.koka.sanctuary.companion.*;
+import fr.koka.sanctuary.knowledge.*;
+import fr.koka.sanctuary.plans.*;
+import fr.koka.sanctuary.recipes.*;
+import java.util.*;
+import net.fabricmc.fabric.api.client.gametest.v1.context.*;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.stats.Stats;
+import net.minecraft.world.entity.EntityTypes;
+import net.minecraft.world.item.*;
+import net.minecraft.world.level.block.Blocks;
+
+final class Discovery126Checks {
+    static void exercise(ClientGameTestContext c,TestServerContext server){
+        server.runOnServer(s->{var p=s.getPlayerList().getPlayers().getFirst();var dispatcher=s.getCommands().getDispatcher();
+            var source=p.createCommandSourceStack();var root=dispatcher.getRoot().getChild("sanctuary").getChild("discovery");
+            s.getWorldData().setAllowCommands(false);check(!root.canUse(source),"Discovery commands respect native Allow Commands");
+            try{dispatcher.execute("sanctuary discovery all",source);throw new AssertionError("Denied command executed");}catch(com.mojang.brigadier.exceptions.CommandSyntaxException expected){}
+            s.getWorldData().setAllowCommands(true);
+            var before=CompanionService.record(p);var items=new TreeSet<>(RecipeService.knowledge(p).items);int kills=p.getStats().getValue(Stats.ENTITY_KILLED,EntityTypes.WITHER);
+            command(p,"mob minecraft:wither");check(StatueDiscoveries.known(p).contains("minecraft:wither"),"Precise species unlocks sculpture catalogue");check(CompanionService.record(p).notes().get("seen_mobs").contains("wither"),"Same actual seen_mobs record");check(RecipeService.knowledge(p).items.equals(items),"Mob discovery invents no unrelated item discovery");check(p.getStats().getValue(Stats.ENTITY_KILLED,EntityTypes.WITHER)==kills,"No fake kill stat");
+            command(p,"block minecraft:pink_glazed_terracotta");var block=BlockKnowledgeService.knowledge(p,Blocks.GLAZED_TERRACOTTA.pick(DyeColor.PINK));check(block.seen()&&!block.possessed()&&block.mined()==0&&block.placed()==0,"Precise block is seen without fabricated possession or stats");check(RecipeService.knowledge(p).items.contains("minecraft:pink_glazed_terracotta")&&RecipeService.knowledge(p).collections.contains("sanctuary:terracotta"),"Block event unlocks its normal recipe collection");
+            command(p,"item minecraft:amethyst_shard");check(RecipeService.knowledge(p).items.contains("minecraft:amethyst_shard")&&RecipeService.knowledge(p).recipes.contains("minecraft:spyglass"),"Precise item unlocks linked recipes");
+            String old=CompanionService.record(p).json();check(run(p,"mob minecraft:item")==0,"Nonmob type refused");check(CompanionService.record(p).json().equals(old),"Rejected request does not change discoveries");
+            try{dispatcher.execute("sanctuary discovery item sanctuary:missing_item",source);throw new AssertionError("Missing ID accepted");}catch(com.mojang.brigadier.exceptions.CommandSyntaxException expected){}
+            command(p,"mobs all");allSpecies(p);var pos=new BlockPos(4,1,4);Statuary.open(p,pos);check(((ClayWorkshopMenu)p.containerMenu).view.statues().equals(StatueDiscoveries.known(p)),"Workshop sees the shared full catalogue");p.closeContainer();
+            command(p,"all");all(p);String species=CompanionService.record(p).json(),recipes=RecipeService.knowledge(p).json();var blocks=BlockKnowledgeService.snapshot(p);command(p,"all @s");check(species.equals(CompanionService.record(p).json())&&recipes.equals(RecipeService.knowledge(p).json())&&blocks.equals(BlockKnowledgeService.snapshot(p)),"Repeated all with target selector is idempotent");
+            check(CompanionService.record(p).paid()==before.paid()&&CompanionService.record(p).unlocked()==before.unlocked(),"Discoveries do not fabricate paid skills");
+            try{check(dispatcher.execute("sanctuary discovery mob minecraft:cow "+p.getGameProfile().name(),s.createCommandSourceStack())==1,"Console can address an online player");}catch(Exception e){throw new AssertionError(e);}
+            System.out.println("DISCOVERY126_PASS native permissions, precise block/item/species, linked recipes, shared catalogue, all three categories, all, selector, console, idempotence and unchanged combat/ownership counters");
+        });
+        c.waitFor(m->m.gui.screen()==null,100);
+    }
+    static void all(ServerPlayer p){
+        allSpecies(p);check(BlockKnowledgeService.snapshot(p).stream().allMatch(BlockKnowledge::known),"All block discoveries");
+        var knowledge=RecipeService.knowledge(p);for(var item:BuiltInRegistries.ITEM)if(item!=Items.AIR)check(knowledge.items.contains(BuiltInRegistries.ITEM.getKey(item).toString()),"All registered items discovered");
+        check(knowledge.recipes.contains("minecraft:spyglass")&&knowledge.recipes.contains("sanctuary:ruby_block"),"Vanilla and Sanctuary recipes are derived from discoveries");
+    }
+    static void allSpecies(ServerPlayer p){check(StatueDiscoveries.known(p).size()==BuiltInRegistries.ENTITY_TYPE.stream().filter(t->SpawnEggItem.byId(t).isPresent()).count(),"All registered species discovered");}
+    static void command(ServerPlayer p,String args){check(run(p,args)==1,"Discovery command succeeds: "+args);}
+    private static int run(ServerPlayer p,String args){try{return p.level().getServer().getCommands().getDispatcher().execute("sanctuary discovery "+args,p.createCommandSourceStack());}catch(Exception e){throw new AssertionError(e);}}
+    private static void check(boolean ok,String message){if(!ok)throw new AssertionError(message);}
+}

mods/sanctuary/src/clientGametest/java/fr/koka/sanctuary/client/Furnace115ClientChecks.java

@@ -0,0 +1,103 @@
+package fr.koka.sanctuary.client;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import fr.koka.sanctuary.gametest.Starter039TestSupport;
+import fr.koka.sanctuary.multiblock.*;
+import fr.koka.sanctuary.mixin.MultiblockFurnaceAccess;
+import fr.koka.sanctuary.mixin.client.AbstractContainerScreenAccessor;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
+import net.fabricmc.fabric.api.client.gametest.v1.*;
+import net.fabricmc.fabric.api.client.gametest.v1.context.ClientGameTestContext;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.screens.worldselection.WorldCreationUiState;
+import net.minecraft.client.input.*;
+import net.minecraft.core.*;
+import net.minecraft.core.component.DataComponents;
+import net.minecraft.network.chat.Component;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.inventory.ContainerInput;
+import net.minecraft.world.item.*;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.entity.*;
+
+/** Native quick-transfer, arbitrary slot placement, shared cooking and synchronized feedback. */
+public final class Furnace115ClientChecks implements FabricClientGameTest {
+    private static final BlockPos ORIGIN=new BlockPos(2,1,2);
+    private static MultiblockData.Machine oven;
+    public void runTest(ClientGameTestContext c){
+        var intro=new AtomicBoolean(true);
+        c.runOnClient(m->{m.options.renderDistance().set(6);m.options.simulationDistance().set(5);m.options.pauseOnLostFocus=false;IntroClient.setQuickTestIntro(true);});
+        ClientTickEvents.END_CLIENT_TICK.register(m->{if(intro.get()&&m.gui.screen() instanceof HelloWorldScreen screen){
+            Starter039TestSupport.selectFirst(screen);
+            screen.children().stream().filter(Button.class::isInstance).map(Button.class::cast).filter(b->b.getClass().getSimpleName().equals("ColorButton")).findFirst().orElseThrow().onPress(enter());
+            screen.children().stream().filter(Button.class::isInstance).map(Button.class::cast).filter(b->b.getMessage().getContents() instanceof net.minecraft.network.chat.contents.TranslatableContents t&&t.getKey().equals("sanctuary.progression.enter")).findFirst().orElseThrow().onPress(enter());intro.set(false);
+        }});
+        try(var world=c.worldBuilder().adjustSettings(s->{s.setName("Furnace115 "+UUID.randomUUID());s.setSeed("115");s.setAllowCommands(true);s.setGameMode(WorldCreationUiState.SelectedGameMode.SURVIVAL);s.setWorldType(s.getNormalPresetList().stream().filter(e->e.preset()!=null&&e.preset().getRegisteredName().equals("sanctuary_test:flat")).findFirst().orElseThrow());}).create()){
+            c.waitFor(m->ProgressionClient.active()&&m.player!=null&&m.gui.screen()==null&&!IntroSpawnFlash.active(),1200);var server=world.getServer();
+            server.runOnServer(s->{var p=s.getPlayerList().getPlayers().getFirst();p.getAbilities().invulnerable=true;p.onUpdateAbilities();p.getInventory().clearContent();p.teleportTo(1.5,1,1.5);
+                for(int x=-2;x<8;x++)for(int z=-2;z<8;z++)p.level().setBlockAndUpdate(new BlockPos(x,0,z),Blocks.STONE.defaultBlockState());
+                oven=new MultiblockData.Machine(UUID.randomUUID(),ORIGIN,true,Direction.NORTH);for(var pos:oven.members())p.level().setBlockAndUpdate(pos,Blocks.FURNACE.defaultBlockState());check(Multiblocks.assemble(p,oven),"Assemble");
+                for(int i=0;i<9;i++){var stack=new ItemStack(Items.RAW_IRON,8);stack.set(DataComponents.CUSTOM_NAME,Component.literal("Batch "+i));p.getInventory().setItem(i,stack);}Multiblocks.open(p,oven,ORIGIN,0,"",0);
+            });
+            c.waitFor(m->m.gui.screen() instanceof MultiblockScreen&&m.player.containerMenu.getSlot(54).hasItem(),200);
+            // One native Shift-drag crosses nine hotbar stacks, with no mouse release between them.
+            c.getInput().holdKey(o->o.keyShift);move(c,54);c.runOnClient(m->m.mouseHandler.onButton(m.getWindow().handle(),new MouseButtonInfo(InputConstants.MOUSE_BUTTON_LEFT,InputConstants.MOD_SHIFT),1));
+            for(int i=55;i<63;i++)move(c,i);
+            c.runOnClient(m->m.mouseHandler.onButton(m.getWindow().handle(),new MouseButtonInfo(InputConstants.MOUSE_BUTTON_LEFT,InputConstants.MOD_SHIFT),0));c.getInput().releaseKey(o->o.keyShift);
+            c.waitTicks(8);c.takeScreenshot("furnace115-inputs");
+            c.waitFor(m->m.player.containerMenu.getSlot(8).hasItem()&&!m.player.containerMenu.getSlot(62).hasItem(),150);
+            c.runOnClient(m->{for(int i=0;i<9;i++)check(m.player.containerMenu.getSlot(i).getItem().getHoverName().getString().equals("Batch "+i),"Shift-drag fills consecutive UI slots, no three-column gaps");});
+            server.runOnServer(s->{var p=s.getPlayerList().getPlayers().getFirst();var stock=new MultiblockContainer(p.level(),oven);for(int i=0;i<9;i++)check(stock.getItem(i*3).getCount()==8,"Physical inputs correspond to visible slots");});
+            // Move an ingredient to a distant, arbitrary slot using real inventory packets.
+            click(c,1,0,ContainerInput.PICKUP);click(c,23,0,ContainerInput.PICKUP);c.waitTicks(10);
+            c.runOnClient(m->{check(m.player.containerMenu.getSlot(1).getItem().isEmpty()&&m.player.containerMenu.getSlot(23).getItem().getCount()==8,"Manual placement remains in chosen cell: "+m.player.containerMenu.slots.stream().filter(slot->slot.hasItem()).map(slot->slot.index+":"+slot.getItem()).toList()+", cursor="+m.player.containerMenu.getCarried());});
+            click(c,23,0,ContainerInput.PICKUP);
+            click(c,-999,net.minecraft.world.inventory.AbstractContainerMenu.getQuickcraftMask(0,0),ContainerInput.QUICK_CRAFT);
+            for(int i:new int[]{1,9,10,13,14,22})click(c,i,net.minecraft.world.inventory.AbstractContainerMenu.getQuickcraftMask(1,0),ContainerInput.QUICK_CRAFT);
+            click(c,-999,net.minecraft.world.inventory.AbstractContainerMenu.getQuickcraftMask(2,0),ContainerInput.QUICK_CRAFT);click(c,23,0,ContainerInput.PICKUP);c.waitTicks(6);
+            c.runOnClient(m->{for(int i:new int[]{1,9,10,13,14,22})check(m.player.containerMenu.getSlot(i).getItem().getCount()==1,"Native drag distribution keeps every chosen column");check(m.player.containerMenu.getSlot(23).getItem().getCount()==2&&m.player.containerMenu.getCarried().isEmpty(),"Distributed count conserved");});
+            server.runOnServer(s->{var p=s.getPlayerList().getPlayers().getFirst();var stock=new MultiblockContainer(p.level(),oven);check(stock.getItem(69).getCount()==2&&stock.getItem(3).getCount()==1,"Manual distribution matches server");for(int i=0;i<27;i++)check(p.containerMenu.getSlot(i).mayPlace(new ItemStack(Items.RAW_IRON)),"Every visible input validates its physical input slot, not Slot.index");reset(stock);stock.setItem(0,new ItemStack(Items.RAW_IRON,4));stock.setItem(18,new ItemStack(Items.RAW_GOLD,4));
+                var coal=new ItemStack(Items.COAL,5);coal.set(DataComponents.CUSTOM_NAME,Component.literal("Stationary fuel"));stock.setItem(79,coal);
+                for(int tick=0;tick<205;tick++)MultiblockCooking.tick(p.level(),oven);
+                check(stock.getItem(79).getCount()==4&&stock.getItem(79).getHoverName().getString().equals("Stationary fuel"),"Named unburnt fuel stays in original cell");
+                for(int i=1;i<79;i+=3)check(stock.getItem(i).isEmpty(),"No displaced coal in other slots");
+                check(stock.getItem(2).is(Items.IRON_INGOT)&&stock.getItem(20).is(Items.GOLD_INGOT),"Shared heat cooks both arbitrary lanes");
+                Multiblocks.open(p,oven,ORIGIN,0,"",0);
+            });
+            c.waitTicks(6);c.runOnClient(m->{var menu=(MultiblockMenu)m.player.containerMenu;check(menu.cooking==2&&menu.heat>0&&menu.laneState(6)==MultiblockMenu.COOKING,"Real per-lane feedback synchronizes");});c.takeScreenshot("furnace115-cooking");
+            server.runOnServer(s->{var p=s.getPlayerList().getPlayers().getFirst();var stock=new MultiblockContainer(p.level(),oven);reset(stock);
+                stock.setItem(0,new ItemStack(Items.RAW_IRON));stock.setItem(3,new ItemStack(Items.DIAMOND));stock.setItem(6,new ItemStack(Items.RAW_GOLD));stock.setItem(8,new ItemStack(Items.GOLD_INGOT,64));
+                var a=(MultiblockFurnaceAccess)stock.cell(0);a.sanctuary$progress(80);a.sanctuary$total(200);p.containerMenu.broadcastChanges();
+            });c.waitTicks(6);
+            c.runOnClient(m->{var menu=(MultiblockMenu)m.player.containerMenu;check(menu.laneState(0)==MultiblockMenu.NO_FUEL&&menu.laneProgress(0)==40,"Paused progress is visible and preserved");check(menu.laneState(1)==MultiblockMenu.NO_RECIPE,"Invalid recipe explained");check(menu.laneState(2)==MultiblockMenu.BLOCKED,"Blocked output explained");check(menu.cooking==0&&menu.heat==0,"Cold furnace clearly shown");});c.takeScreenshot("furnace115-paused");
+            server.runOnServer(s->{var p=s.getPlayerList().getPlayers().getFirst();cookingRegressions(p);var stock=new MultiblockContainer(p.level(),oven);reset(stock);
+                for(int i=0;i<9;i++){var stack=new ItemStack(Items.COAL,5);stack.set(DataComponents.CUSTOM_NAME,Component.literal("Fuel "+i));p.getInventory().setItem(i,stack);}Multiblocks.open(p,oven,ORIGIN,0,"",1);
+            });c.waitFor(m->m.player.containerMenu instanceof MultiblockMenu menu&&menu.view.section()==1&&menu.getSlot(54).hasItem(),100);
+            // No cooking in this fixture: compare the predicted UI in the same call, before any server reply.
+            c.runOnClient(m->{var menu=m.player.containerMenu;for(int i=0;i<9;i++){
+                m.gameMode.handleContainerInput(menu.containerId,54+i,0,ContainerInput.QUICK_MOVE,m.player);
+                check(menu.getSlot(54+i).getItem().isEmpty()&&menu.getSlot(i).getItem().getCount()==5,"Immediate Shift prediction uses consecutive fuel cells");}
+                check(!menu.getSlot(9).mayPlace(new ItemStack(Items.DIAMOND)),"Client rejects invalid fuel like server");});
+            c.waitTicks(8);server.runOnServer(s->{var p=s.getPlayerList().getPlayers().getFirst();var stock=new MultiblockContainer(p.level(),oven);for(int i=0;i<9;i++)check(stock.getItem(i*3+1).getCount()==5,"Fuel server mapping matches prediction");for(int i=0;i<27;i++){check(p.containerMenu.getSlot(i).mayPlace(new ItemStack(Items.COAL)),"All 27 fuel cells accept fuel");check(!p.containerMenu.getSlot(i).mayPlace(new ItemStack(Items.DIAMOND)),"All 27 fuel cells refuse other items");}});c.takeScreenshot("furnace115-fuel");
+            c.runOnClient(m->{var screen=(MultiblockScreen)m.gui.screen();screen.children().stream().filter(Button.class::isInstance).map(Button.class::cast).filter(b->b.getMessage().getString().equals(Multiblocks.text("how_to_cook").getString())).findFirst().orElseThrow().onPress(enter());check(screen.helpVisible(),"Help button opens its explanation");});c.waitTicks(5);c.takeScreenshot("furnace115-help");
+            var reload=c.computeOnClient(m->{m.getLanguageManager().setSelected("fr_fr");return m.reloadResourcePacks();});c.waitFor(m->reload.isDone()&&m.gui.overlay()==null,1200);reload.join();c.waitTicks(3);c.takeScreenshot("furnace115-help-fr");
+            System.out.println("FURNACE115_PASS native Shift-drag, consecutive input/fuel mapping, immediate prediction, arbitrary placement, stationary named fuel, heat/output/pause/recipe feedback, fuel budget, refuelling, buckets, save and result extraction");
+        }finally{intro.set(false);}
+    }
+    private static void cookingRegressions(ServerPlayer p){
+        var stock=new MultiblockContainer(p.level(),oven);reset(stock);stock.setItem(0,new ItemStack(Items.WET_SPONGE));stock.setItem(79,new ItemStack(Items.LAVA_BUCKET));for(int t=0;t<205;t++)MultiblockCooking.tick(p.level(),oven);
+        check(stock.getItem(2).is(Items.SPONGE)&&stock.getItem(1).is(Items.WATER_BUCKET)&&stock.getItem(79).isEmpty(),"Native lava and wet sponge remainder");
+        reset(stock);for(int i=0;i<81;i+=3)stock.setItem(i,new ItemStack(Items.RAW_IRON));stock.setItem(79,new ItemStack(Items.COAL));for(int t=0;t<90;t++)MultiblockCooking.tick(p.level(),oven);
+        int partial=((MultiblockFurnaceAccess)stock.cell(0)).sanctuary$progress();check(partial>0&&partial<200,"One coal cannot cook all 27 items");for(int t=0;t<30;t++)MultiblockCooking.tick(p.level(),oven);check(((MultiblockFurnaceAccess)stock.cell(0)).sanctuary$progress()==partial,"No lost paid progress when out of fuel");
+        stock.setItem(79,new ItemStack(Items.COAL,4));for(int t=0;t<205;t++)MultiblockCooking.tick(p.level(),oven);int produced=0;for(int i=2;i<81;i+=3)produced+=stock.getItem(i).getCount();check(produced==27,"Refuelling completes all lanes exactly once");
+        var f=(AbstractFurnaceBlockEntity)stock.cell(0);var restored=(AbstractFurnaceBlockEntity)BlockEntity.loadStatic(f.getBlockPos(),f.getBlockState(),f.saveWithFullMetadata(p.level().registryAccess()),p.level().registryAccess());check(((MultiblockFurnaceAccess)restored).sanctuary$heat()==((MultiblockFurnaceAccess)f).sanctuary$heat(),"Native heat survives save");
+        Multiblocks.open(p,oven,ORIGIN,0,"",2);var menu=(MultiblockMenu)p.containerMenu;check(!menu.getSlot(0).mayPlace(new ItemStack(Items.STONE)),"Results refuse input");check(!menu.quickMoveStack(p,0).isEmpty()&&stock.getItem(2).isEmpty(),"Native result slot can extract");
+    }
+    private static void reset(MultiblockContainer stock){stock.clearContent();for(int i=0;i<81;i+=3){var a=(MultiblockFurnaceAccess)stock.cell(i);a.sanctuary$heat(0);a.sanctuary$progress(0);}}
+    private static void click(ClientGameTestContext c,int slot,int button,ContainerInput type){c.runOnClient(m->m.gameMode.handleContainerInput(m.player.containerMenu.containerId,slot,button,type,m.player));}
+    private static void move(ClientGameTestContext c,int index){c.runOnClient(m->{var a=(AbstractContainerScreenAccessor)m.gui.screen();var slot=m.player.containerMenu.getSlot(index);var w=m.getWindow();double x=a.sanctuary$getLeftPos()+slot.x+8,y=a.sanctuary$getTopPos()+slot.y+8;double sx=(double)w.getScreenWidth()/w.getGuiScaledWidth(),sy=(double)w.getScreenHeight()/w.getGuiScaledHeight();m.mouseHandler.onMove(w.handle(),x*sx,y*sy,(x-m.mouseHandler.getScaledXPos(w))*sx,(y-m.mouseHandler.getScaledYPos(w))*sy);m.mouseHandler.handleAccumulatedMovement();});c.waitTick();}
+    private static KeyEvent enter(){return new KeyEvent(InputConstants.KEY_RETURN,0,0);}
+    private static void check(boolean ok,String message){if(!ok)throw new AssertionError(message);}
+}

mods/sanctuary/src/clientGametest/java/fr/koka/sanctuary/client/Gems126ClientChecks.java

@@ -0,0 +1,88 @@
+package fr.koka.sanctuary.client;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import fr.koka.sanctuary.SanctuaryMod;
+import fr.koka.sanctuary.gems.*;
+import fr.koka.sanctuary.gametest.Starter039TestSupport;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
+import net.fabricmc.fabric.api.client.gametest.v1.FabricClientGameTest;
+import net.fabricmc.fabric.api.client.gametest.v1.context.ClientGameTestContext;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.screens.worldselection.WorldCreationUiState;
+import net.minecraft.client.input.KeyEvent;
+import net.minecraft.core.*;
+import net.minecraft.core.registries.*;
+import net.minecraft.network.chat.contents.TranslatableContents;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.tags.*;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.item.*;
+import net.minecraft.world.item.crafting.*;
+import net.minecraft.world.item.enchantment.Enchantments;
+import net.minecraft.world.level.block.*;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.levelgen.GenerationStep;
+
+/** Actual native registration, recipes, drops, tab order and naturally decorated Sanctuary chunks. */
+public final class Gems126ClientChecks implements FabricClientGameTest {
+    public void runTest(ClientGameTestContext c){
+        var intro=new AtomicBoolean(true);
+        c.runOnClient(m->{m.options.renderDistance().set(5);m.options.simulationDistance().set(5);m.options.pauseOnLostFocus=false;IntroClient.setQuickTestIntro(true);});
+        ClientTickEvents.END_CLIENT_TICK.register(m->{if(intro.get()&&m.gui.screen() instanceof HelloWorldScreen screen){
+            IntroClient.setQuickTestIntro(true);Starter039TestSupport.selectFirst(screen);var enter=new KeyEvent(InputConstants.KEY_RETURN,0,0);
+            screen.children().stream().filter(Button.class::isInstance).map(Button.class::cast).filter(b->b.getClass().getSimpleName().equals("ColorButton")).findFirst().orElseThrow().onPress(enter);
+            screen.children().stream().filter(Button.class::isInstance).map(Button.class::cast).filter(b->b.getMessage().getContents() instanceof TranslatableContents t&&t.getKey().equals("sanctuary.progression.enter")).findFirst().orElseThrow().onPress(enter);intro.set(false);
+        }});
+        try(var world=c.worldBuilder().adjustSettings(s->{s.setName("Gems126 registry "+UUID.randomUUID());s.setSeed("126");s.setAllowCommands(true);s.setGameMode(WorldCreationUiState.SelectedGameMode.CREATIVE);s.setWorldType(s.getNormalPresetList().stream().filter(e->e.preset()!=null&&e.preset().getRegisteredName().equals("sanctuary_test:flat")).findFirst().orElseThrow());}).create()){
+            c.waitFor(m->ProgressionClient.active()&&m.player!=null&&m.gui.screen()==null&&!IntroSpawnFlash.active(),1200);
+            world.getServer().runOnServer(s->{
+                var p=s.getPlayerList().getPlayers().getFirst();var l=p.level();var pos=new BlockPos(0,4,0);var iron=new ItemStack(Items.IRON_PICKAXE);var silk=iron.copy();silk.enchant(l.registryAccess().lookupOrThrow(Registries.ENCHANTMENT).getOrThrow(Enchantments.SILK_TOUCH),1);var fortune=iron.copy();fortune.enchant(l.registryAccess().lookupOrThrow(Registries.ENCHANTMENT).getOrThrow(Enchantments.FORTUNE),3);
+                for(var f:Gems.FAMILIES){
+                    for(var b:List.of(f.block(),f.ore(),f.deepslateOre())){var state=b.defaultBlockState();check(state.is(BlockTags.MINEABLE_WITH_PICKAXE)&&state.is(BlockTags.NEEDS_IRON_TOOL),"Native mining tags "+b);check(iron.isCorrectToolForDrops(state)&&!new ItemStack(Items.STONE_PICKAXE).isCorrectToolForDrops(state),"Iron tier enforced "+b);}
+                    drop(Block.getDrops(f.block().defaultBlockState(),l,pos,null,p,iron),f.block().asItem(),1);
+                    for(var ore:List.of(f.ore(),f.deepslateOre())){
+                        drop(Block.getDrops(ore.defaultBlockState(),l,pos,null,p,iron),f.gem(),1);drop(Block.getDrops(ore.defaultBlockState(),l,pos,null,p,silk),ore.asItem(),1);
+                        int max=0;for(int i=0;i<48;i++){var drops=Block.getDrops(ore.defaultBlockState(),l,pos,null,p,fortune);check(drops.size()==1&&drops.getFirst().is(f.gem()),"Fortune gem type");int n=drops.getFirst().getCount();check(n>=1&&n<=4,"Native Fortune III range");max=Math.max(max,n);}check(max>1,"Fortune increases gem yield");
+                        var input=new SingleRecipeInput(new ItemStack(ore));for(var type:List.of(RecipeType.SMELTING,RecipeType.BLASTING)){var recipe=s.getRecipeManager().getRecipeFor(type,input,l).orElseThrow().value();check(recipe.assemble(input).is(f.gem()),"Native furnace recipe");}
+                    }
+                    var input=CraftingInput.of(3,3,Collections.nCopies(9,new ItemStack(f.gem())));drop(List.of(s.getRecipeManager().getRecipeFor(RecipeType.CRAFTING,input,l).orElseThrow().value().assemble(input)),f.block().asItem(),1);
+                    input=CraftingInput.of(1,1,List.of(new ItemStack(f.block())));drop(List.of(s.getRecipeManager().getRecipeFor(RecipeType.CRAFTING,input,l).orElseThrow().value().assemble(input)),f.gem(),9);
+                    check(f.block().defaultBlockState().is(BlockTags.BEACON_BASE_BLOCKS)&&new ItemStack(f.gem()).is(ItemTags.BEACON_PAYMENT_ITEMS),"Native beacon compatibility");
+                    var feature=l.registryAccess().lookupOrThrow(Registries.FEATURE).getOrThrow(ResourceKey.create(Registries.FEATURE,SanctuaryMod.id("ore_"+f.id()))).value();check(feature instanceof GemOreFeature,"Data feature decoded");
+                    check(!feature.place(l,l.getChunkSource().getGenerator(),RandomSource.create(126),pos),"Gem veins do not run in ordinary flat/vanilla worlds");
+                    fr.koka.sanctuary.recipes.RecipeService.discover(p,f.gem());fr.koka.sanctuary.recipes.RecipeService.refresh(p);check(fr.koka.sanctuary.recipes.RecipeService.knowledge(p).recipes.contains("sanctuary:"+f.id()+"_block"),"Native discovery unlocks storage recipe");
+                }
+                int x=0;for(var block:List.of(Blocks.EMERALD_BLOCK,Gems.RUBY.block(),Gems.SAPPHIRE.block(),Blocks.EMERALD_ORE,Gems.RUBY.ore(),Gems.SAPPHIRE.ore(),Blocks.DEEPSLATE_EMERALD_ORE,Gems.RUBY.deepslateOre(),Gems.SAPPHIRE.deepslateOre())){l.setBlockAndUpdate(new BlockPos(x%3,1,x/3),block.defaultBlockState());x++;}
+                p.teleportTo(1.5,3,7);p.getAbilities().flying=true;p.onUpdateAbilities();p.getInventory().setItem(0,new ItemStack(Items.EMERALD));p.getInventory().setItem(1,new ItemStack(Gems.RUBY.gem()));p.getInventory().setItem(2,new ItemStack(Gems.SAPPHIRE.gem()));p.inventoryMenu.broadcastFullState();
+                System.out.println("GEMS126_SERVER_PASS eight registered items, six blocks, native loot/Fortune/Silk Touch, twelve recipes, mining tiers, beacons, discoveries and vanilla generation exclusion");
+            });
+            c.runOnClient(m->{CreativeModeTabs.tryRebuildTabContents(m.level.enabledFeatures(),true,m.level.registryAccess());order(CreativeModeTabs.INGREDIENTS,Items.EMERALD,Gems.RUBY.gem(),Gems.SAPPHIRE.gem());order(CreativeModeTabs.BUILDING_BLOCKS,Items.EMERALD_BLOCK,Gems.RUBY.block().asItem(),Gems.SAPPHIRE.block().asItem());order(CreativeModeTabs.NATURAL_BLOCKS,Items.EMERALD_ORE,Gems.RUBY.ore().asItem(),Gems.SAPPHIRE.ore().asItem());order(CreativeModeTabs.NATURAL_BLOCKS,Items.DEEPSLATE_EMERALD_ORE,Gems.RUBY.deepslateOre().asItem(),Gems.SAPPHIRE.deepslateOre().asItem());
+                for(var f:Gems.FAMILIES)for(var block:List.of(f.block(),f.ore(),f.deepslateOre())){var parts=new ArrayList<net.minecraft.client.renderer.block.dispatch.BlockStateModelPart>();m.getModelManager().getBlockStateModelSet().get(block.defaultBlockState()).collectParts(RandomSource.create(0),parts);check(!parts.isEmpty(),"Baked gem block model");for(var part:parts)for(var face:Direction.values())for(var quad:part.getQuads(face))check(!quad.materialInfo().sprite().contents().name().toString().contains("missingno"),"Native texture atlas resolves supplied gem PNG");}
+                System.out.println("GEMS126_CREATIVE_PASS emerald, ruby, sapphire adjacency in four groups; all six baked block models");
+            });
+            c.waitTicks(10);c.runOnClient(m->m.player.lookAt(net.minecraft.commands.arguments.EntityAnchorArgument.Anchor.EYES,new net.minecraft.world.phys.Vec3(1.5,1.5,1.5)));c.waitTicks(4);c.takeScreenshot("gems126-gallery");
+            Clay126Checks.exercise(c,world.getServer());
+            Discovery126Checks.exercise(c,world.getServer());
+        }
+        intro.set(true);net.fabricmc.fabric.api.client.gametest.v1.world.TestWorldSave saved;var found=new HashMap<BlockPos,BlockState>();
+        try(var world=c.worldBuilder().adjustSettings(s->{s.setName("Gems126 natural "+UUID.randomUUID());s.setSeed("126");s.setAllowCommands(true);s.setGenerateStructures(false);s.setGameMode(WorldCreationUiState.SelectedGameMode.CREATIVE);s.setWorldType(s.getNormalPresetList().stream().filter(e->e.preset()!=null&&e.preset().getRegisteredName().equals("sanctuary:sanctuary")).findFirst().orElseThrow());}).create()){
+            c.waitFor(m->m.player!=null&&m.gui.screen()==null&&ProgressionClient.active()&&!IntroSpawnFlash.active(),2400);
+            world.getServer().runOnServer(s->{var l=s.overworld();check(l.getChunkSource().getGenerator() instanceof fr.koka.sanctuary.worldgen.SanctuaryChunkGenerator,"Actual Sanctuary generator");
+                for(int cx=-4;cx<=4;cx++)for(int cz=-4;cz<=4;cz++){var chunk=l.getChunk(cx,cz);var cursor=new BlockPos.MutableBlockPos();for(int x=0;x<16;x++)for(int z=0;z<16;z++)for(int y=0;y<=256;y++){cursor.set(cx*16+x,y,cz*16+z);var state=chunk.getBlockState(cursor);if(state.is(Gems.RUBY.ore())||state.is(Gems.RUBY.deepslateOre())||state.is(Gems.SAPPHIRE.ore())||state.is(Gems.SAPPHIRE.deepslateOre()))found.put(cursor.immutable(),state);}}
+                for(var f:Gems.FAMILIES){long ordinary=found.values().stream().filter(b->b.is(f.ore())).count(),deep=found.values().stream().filter(b->b.is(f.deepslateOre())).count();System.out.println("GEMS126_NATURAL "+f.id()+" stone="+ordinary+" deepslate="+deep+" seed=126 chunks=81");check(ordinary+deep>0,"Both gems generate naturally without structure placement: "+f.id());}
+                var biome=l.getBiome(found.keySet().iterator().next()).value();var features=biome.getGenerationSettings().features().get(GenerationStep.Decoration.UNDERGROUND_ORES.ordinal());for(var f:Gems.FAMILIES)check(features.stream().anyMatch(h->h.is(ResourceKey.create(Registries.PLACED_FEATURE,SanctuaryMod.id("ore_"+f.id())))),"Native biome includes configurable gem placement");
+                Discovery126Checks.command(s.getPlayerList().getPlayers().getFirst(),"all");
+                var mined=found.keySet().iterator().next();l.setBlockAndUpdate(mined,Blocks.AIR.defaultBlockState());found.put(mined,Blocks.AIR.defaultBlockState());
+            });saved=world.getWorldSave();
+        }
+        try(var world=saved.open()){
+            c.waitFor(m->m.player!=null&&m.gui.screen()==null,2400);world.getServer().runOnServer(s->{Discovery126Checks.all(s.getPlayerList().getPlayers().getFirst());for(var e:found.entrySet())check(s.overworld().getBlockState(e.getKey())==e.getValue(),"Generated ores persist on reload without repopulation");});
+        }
+        System.out.println("GEMS126_PASS registry, recipes, drops, creative order, native models, natural Sanctuary generation seed 126 and save/reconnect");
+    }
+    private static void order(ResourceKey<CreativeModeTab> tab,Item anchor,Item ruby,Item sapphire){var items=new ArrayList<>(BuiltInRegistries.CREATIVE_MODE_TAB.getOrThrow(tab).value().getDisplayItems());int i=0;while(i<items.size()&&!items.get(i).is(anchor))i++;check(i+2<items.size()&&items.get(i+1).is(ruby)&&items.get(i+2).is(sapphire),"Emerald/ruby/sapphire order in "+tab);check(items.stream().filter(v->v.is(ruby)||v.is(sapphire)).count()==2,"No duplicate creative entries");}
+    private static void drop(List<ItemStack> drops,Item item,int n){check(drops.size()==1&&drops.getFirst().is(item)&&drops.getFirst().getCount()==n,"Native loot/craft expected "+n+" "+item+", got "+drops);}
+    private static void check(boolean ok,String message){if(!ok)throw new AssertionError(message);}
+}

mods/sanctuary/src/clientGametest/java/fr/koka/sanctuary/client/ResourceTemplate121ClientChecks.java

@@ -0,0 +1,165 @@
+package fr.koka.sanctuary.client;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.security.MessageDigest;
+import java.util.Arrays;
+import java.util.HexFormat;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import net.fabricmc.fabric.api.client.gametest.v1.FabricClientGameTest;
+import net.fabricmc.fabric.api.client.gametest.v1.context.ClientGameTestContext;
+import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiGraphicsExtractor;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.gui.screens.packs.PackSelectionScreen;
+import net.minecraft.client.input.KeyEvent;
+import net.minecraft.client.renderer.RenderPipelines;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.contents.TranslatableContents;
+import net.minecraft.resources.Identifier;
+import net.minecraft.server.packs.repository.PackCompatibility;
+
+/** Native screen/export, complete snapshot, real resource precedence and preservation of edits. */
+public final class ResourceTemplate121ClientChecks implements FabricClientGameTest {
+    private static final String BUILTIN = "sanctuary:textures";
+    private static final String PERSONAL = "file/" + ResourcePackTemplate.FOLDER;
+    private static final String WRENCH = "sanctuary:textures/item/golden_wrench.png";
+    private static final String WRENCH_PATH = "assets/sanctuary/textures/item/golden_wrench.png";
+    private static final String WRENCH_SHA = "a97570908db75caf8e6fc2f5ecabf12c54fd99bfea7be634df66c4310dca22af";
+
+    public void runTest(ClientGameTestContext c) {
+        try { run(c); } catch (IOException error) { throw new AssertionError(error); }
+    }
+
+    private void run(ClientGameTestContext c) throws IOException {
+        var previous = c.computeOnClient(m -> m.gui.screen());
+        var packDirectory = c.computeOnClient(Minecraft::getResourcePackDirectory);
+        var selected = c.computeOnClient(m -> List.copyOf(m.getResourcePackRepository().getSelectedIds()));
+        var target = packDirectory.resolve(ResourcePackTemplate.FOLDER);
+        check(!Files.exists(target), "Fresh disposable client directory");
+        c.runOnClient(m -> {
+            check(source(m).equals(BUILTIN), "Built-in pack active");
+            check(hash(resource(m, WRENCH)).equals(WRENCH_SHA), "Exact creator PNG active");
+            m.getWindow().setWindowed(1280, 800);
+        });
+        for (int scale : new int[]{2, 3}) for (String language : List.of("fr_fr", "en_us")) {
+            c.runOnClient(m -> {
+                m.options.guiScale().set(scale); m.resizeGui();
+                m.getLanguageManager().setSelected(language);
+                m.getLanguageManager().onResourceManagerReload(m.getResourceManager());
+                screen(m, packDirectory);
+                var button = button(m, "customize");
+                check(button.getX() >= 0 && button.getRight() <= m.gui.screen().width, "Template button fits width");
+                check(button.getY() > 60 && button.getBottom() < m.gui.screen().height, "Template button fits height");
+                var done = m.gui.screen().children().stream().filter(Button.class::isInstance).map(Button.class::cast)
+                        .filter(b -> key(b, "gui.done")).findFirst().orElseThrow();
+                check(done.getY() >= button.getBottom() + 4, "Separate native footer row");
+                check(m.font.width(button.getMessage()) < button.getWidth() - 8, "Localized label fits");
+            });
+            c.waitTicks(3); c.takeScreenshot("template121-create-" + language + "-" + scale);
+        }
+        c.runOnClient(m -> button(m, "customize").onPress(new KeyEvent(InputConstants.KEY_RETURN, 0, 0)));
+        c.waitFor(m -> m.gui.screen().children().stream().filter(Button.class::isInstance).map(Button.class::cast)
+                .anyMatch(b -> b.active && key(b, "sanctuary.resource_pack.open_copy")), 1200);
+        c.waitFor(m -> m.getResourcePackRepository().getAvailableIds().contains(PERSONAL), 1200);
+        c.runOnClient(m -> {
+            check(List.copyOf(m.getResourcePackRepository().getSelectedIds()).equals(selected), "Creating never changes selection");
+            check(m.getResourcePackRepository().getPack(PERSONAL).getCompatibility() == PackCompatibility.COMPATIBLE,
+                    "Template format accepted by exact Minecraft version");
+        });
+        var mod = FabricLoader.getInstance().getModContainer("sanctuary").orElseThrow();
+        Map<String, String> expected = new TreeMap<>();
+        merge(expected, mod.findPath("assets").orElseThrow(), "assets/");
+        merge(expected, mod.findPath("resourcepacks/textures/assets").orElseThrow(), "assets/");
+        merge(expected, mod.findPath("resourcepacks/template").orElseThrow(), "");
+        expected.put("pack.png", hash(Files.readAllBytes(mod.findPath("resourcepacks/textures/pack.png").orElseThrow())));
+        check(snapshot(target).equals(expected), "Complete byte-identical snapshot with built-in precedence");
+        Files.writeString(packDirectory.getParent().resolve("template121-export-sha256.json"),
+                new com.google.gson.GsonBuilder().setPrettyPrinting().create().toJson(expected));
+        check(expected.containsKey("README.md") && expected.containsKey("LICENSE_sanctuary")
+                && expected.containsKey("THIRD_PARTY_NOTICES.md"), "Editable copy includes guide and credits");
+        check(expected.keySet().stream().noneMatch(p -> p.startsWith("data/") || p.endsWith(".class")), "Client assets only");
+        c.waitTicks(4); c.takeScreenshot("template121-copy-ready");
+        c.runOnClient(m -> m.gui.setScreen(new Screen(Component.literal("Golden wrench")) {
+            @Override public void extractRenderState(GuiGraphicsExtractor g, int x, int y, float delta) {
+                g.fill(0, 0, width, height, 0xff292929);
+                g.centeredText(font, Component.translatable("item.sanctuary.golden_wrench"), width / 2, 55, 0xffffffff);
+                g.blit(RenderPipelines.GUI_TEXTURED, Identifier.parse(WRENCH), width / 2 - 48, 85, 0, 0, 96, 96, 16, 16, 16, 16);
+            }
+        }));
+        c.waitTicks(4); c.takeScreenshot("template121-wrench-exact-texture");
+
+        byte[] replacement = c.computeOnClient(m -> resource(m, "minecraft:textures/item/golden_pickaxe.png"));
+        Files.write(target.resolve(WRENCH_PATH), replacement);
+        Files.writeString(target.resolve("my-notes.txt"), "Personal edits must survive all subsequent exports.");
+        var edited = snapshot(target);
+        check(ResourcePackTemplate.create(packDirectory).equals(target.toAbsolutePath().normalize()), "Existing copy returned");
+        check(snapshot(target).equals(edited), "Second export preserves every edited byte and extra file");
+        c.runOnClient(m -> {
+            var repo = m.getResourcePackRepository(); repo.addPack(PERSONAL); m.options.updateResourcePacks(repo);
+        });
+        c.waitFor(m -> source(m).equals(PERSONAL) && m.gui.overlay() == null, 1200);
+        c.runOnClient(m -> {
+            check(Arrays.equals(resource(m, WRENCH), replacement), "Personal edit overrides built-in texture");
+            var repo = m.getResourcePackRepository(); repo.reload(); m.options.loadSelectedResourcePacks(repo);
+            check(repo.getSelectedIds().contains(PERSONAL), "Personal activation persists after rediscovery");
+            screen(m, packDirectory); button(m, "open_copy");
+        });
+        c.waitTicks(3); c.takeScreenshot("template121-personal-active");
+        var reload = c.computeOnClient(Minecraft::reloadResourcePacks);
+        c.waitFor(m -> reload.isDone() && m.gui.overlay() == null, 1200); reload.join();
+        check(snapshot(target).equals(edited), "Reload never writes personal assets");
+        c.runOnClient(m -> {
+            check(Arrays.equals(resource(m, WRENCH), replacement), "Reload still uses personal PNG");
+            var repo = m.getResourcePackRepository(); repo.removePack(PERSONAL); m.options.updateResourcePacks(repo);
+        });
+        c.waitFor(m -> source(m).equals(BUILTIN) && m.gui.overlay() == null, 1200);
+        c.runOnClient(m -> {
+            check(hash(resource(m, WRENCH)).equals(WRENCH_SHA), "Disabling restores creator texture");
+            var repo = m.getResourcePackRepository(); repo.reload(); m.options.loadSelectedResourcePacks(repo);
+            check(!repo.getSelectedIds().contains(PERSONAL), "Explicit opt-out retained");
+        });
+
+        Path collision = Files.createTempDirectory(packDirectory.getParent(), "template121-collision-");
+        Files.writeString(collision.resolve(ResourcePackTemplate.FOLDER), "Do not replace this file");
+        try { ResourcePackTemplate.create(collision); throw new AssertionError("Existing file must be refused"); }
+        catch (IOException expectedError) { check(Files.readString(collision.resolve(ResourcePackTemplate.FOLDER)).equals("Do not replace this file"), "Collision leaves file intact"); }
+        Path datapacks = Files.createTempDirectory(packDirectory.getParent(), "template121-datapacks-");
+        c.runOnClient(m -> {
+            screen(m, datapacks);
+            check(m.gui.screen().children().stream().filter(Button.class::isInstance).map(Button.class::cast)
+                    .noneMatch(b -> key(b, "sanctuary.resource_pack.customize") || key(b, "sanctuary.resource_pack.open_copy")), "No button in datapack selector");
+            m.gui.setScreen(previous);
+        });
+        System.out.println("TEMPLATE121_PASS: " + expected.size() + " exact files; native button FR/EN at scales 2/3; complete copy; edits and selection preserved; actual override, reload and opt-out; collision safe; datapacks untouched");
+    }
+
+    private static void screen(Minecraft m, Path directory) {
+        m.gui.setScreen(new PackSelectionScreen(m.getResourcePackRepository(), repo -> {}, directory, Component.translatable("resourcePack.title")));
+    }
+    private static Button button(Minecraft m, String suffix) {
+        return m.gui.screen().children().stream().filter(Button.class::isInstance).map(Button.class::cast)
+                .filter(b -> key(b, "sanctuary.resource_pack." + suffix)).findFirst().orElseThrow();
+    }
+    private static boolean key(Button b, String key) { return b.getMessage().getContents() instanceof TranslatableContents t && t.getKey().equals(key); }
+    private static String source(Minecraft m) { return m.getResourceManager().getResource(Identifier.parse(WRENCH)).orElseThrow().sourcePackId(); }
+    private static byte[] resource(Minecraft m, String name) {
+        try (var in = m.getResourceManager().getResource(Identifier.parse(name)).orElseThrow().open()) { return in.readAllBytes(); }
+        catch (IOException error) { throw new AssertionError(error); }
+    }
+    private static String hash(byte[] bytes) {
+        try { return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(bytes)); }
+        catch (java.security.NoSuchAlgorithmException error) { throw new AssertionError(error); }
+    }
+    private static Map<String, String> snapshot(Path root) throws IOException { Map<String, String> result = new TreeMap<>(); merge(result, root, ""); return result; }
+    private static void merge(Map<String, String> result, Path root, String prefix) throws IOException {
+        try (var files = Files.walk(root)) { for (Path file : files.filter(Files::isRegularFile).toList()) result.put(prefix + root.relativize(file).toString().replace('\\', '/'), hash(Files.readAllBytes(file))); }
+    }
+    private static void check(boolean value, String message) { if (!value) throw new AssertionError(message); }
+}

mods/sanctuary/src/clientGametest/java/fr/koka/sanctuary/client/Sculpture113ClientChecks.java

@@ -0,0 +1,105 @@
+package fr.koka.sanctuary.client;
+
+import fr.koka.sanctuary.plans.*;
+import java.util.*;
+import net.minecraft.client.Minecraft;
+import net.minecraft.core.*;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.context.BlockPlaceContext;
+import net.minecraft.world.level.block.*;
+import net.minecraft.world.level.storage.TagValueInput;
+import net.minecraft.util.ProblemReporter;
+import net.minecraft.world.phys.*;
+
+/** Checks emitted render geometry, not a duplicate of the placement implementation. */
+final class Sculpture113ClientChecks {
+    static void placementContexts(ServerPlayer player){
+        for(var pos:List.of(new BlockPos(2,0,-2),new BlockPos(-2,0,2))){
+            for(var face:List.of(Direction.UP,Direction.DOWN)){
+                for(double x:new double[]{.25,.5,.75})for(double z:new double[]{.25,.5,.75}){
+                    var hit=new Vec3(pos.getX()+x,pos.getY()+(face==Direction.UP?1:0),pos.getZ()+z);
+                    var context=new BlockPlaceContext(player,InteractionHand.MAIN_HAND,new ItemStack(Statuary.ITEM),new BlockHitResult(hit,face,pos,false));
+                    check(Statuary.BLOCK.getStateForPlacement(context).getValue(Statuary.ANCHOR)==SculptureAnchor.CENTER,"Middle square including boundaries selects center on top/bottom faces");
+                }
+            }
+            for(var edge:Direction.Plane.HORIZONTAL){
+                for(double offset:new double[]{.25-1e-6,.25+1e-6}){
+                    var hit=new Vec3(pos.getX()+.5+edge.getStepX()*offset,pos.getY()+1,pos.getZ()+.5+edge.getStepZ()*offset);
+                    var context=new BlockPlaceContext(player,InteractionHand.MAIN_HAND,new ItemStack(Statuary.ITEM),new BlockHitResult(hit,Direction.UP,pos,false));
+                    var expected=offset<.25?SculptureAnchor.CENTER:SculptureAnchor.of(edge);
+                    check(Statuary.BLOCK.getStateForPlacement(context).getValue(Statuary.ANCHOR)==expected,"Center boundary switches to the aimed edge");
+                }
+                var top=new Vec3(pos.getX()+.5+edge.getStepX()*.4,pos.getY()+1,pos.getZ()+.5+edge.getStepZ()*.4);
+                var context=new BlockPlaceContext(player,InteractionHand.MAIN_HAND,new ItemStack(Statuary.ITEM),new BlockHitResult(top,Direction.UP,pos,false));
+                var state=Statuary.BLOCK.getStateForPlacement(context);
+                check(context.getClickedPos().equals(pos.above())&&state.getValue(Statuary.ANCHOR)==SculptureAnchor.of(edge),"Top hit selects aimed edge at positive/negative coordinates");
+                var side=Vec3.atCenterOf(pos).add(edge.getStepX()*.5,0,edge.getStepZ()*.5);
+                context=new BlockPlaceContext(player,InteractionHand.MAIN_HAND,new ItemStack(Statuary.ITEM),new BlockHitResult(side,edge,pos,false));
+                check(Statuary.BLOCK.getStateForPlacement(context).getValue(Statuary.ANCHOR)==SculptureAnchor.of(edge.getOpposite()),"Side hit anchors against supporting block");
+            }
+        }
+        for(var facing:Direction.Plane.HORIZONTAL)for(var anchor:List.of(SculptureAnchor.CENTER,SculptureAnchor.NORTH,SculptureAnchor.SOUTH,SculptureAnchor.EAST,SculptureAnchor.WEST)){
+            var state=Statuary.BLOCK.defaultBlockState().setValue(Statuary.FACING,facing).setValue(Statuary.ANCHOR,anchor);
+            for(var rotation:Rotation.values()){
+                var actual=state.rotate(rotation);
+                check(actual.getValue(Statuary.ANCHOR)==(anchor==SculptureAnchor.CENTER?anchor:SculptureAnchor.of(rotation.rotate(Direction.valueOf(anchor.name())))),"Structure rotates anchor independently of facing");
+            }
+            for(var mirror:Mirror.values()){
+                var actual=state.mirror(mirror);
+                check(actual.getValue(Statuary.ANCHOR)==(anchor==SculptureAnchor.CENTER?anchor:SculptureAnchor.of(mirror.mirror(Direction.valueOf(anchor.name())))),"Structure mirrors anchor independently of facing");
+            }
+            var legacy=net.minecraft.nbt.NbtUtils.writeBlockState(state);legacy.getCompoundOrEmpty("properties").remove("anchor");
+            var loaded=net.minecraft.nbt.NbtUtils.readBlockState(net.minecraft.core.registries.BuiltInRegistries.BLOCK,legacy);
+            check(loaded.getValue(Statuary.FACING)==facing&&loaded.getValue(Statuary.ANCHOR)==SculptureAnchor.CENTER,"Beta.111/112 state keeps facing and defaults anchor");
+        }
+    }
+    static void geometry(Minecraft client,String model){
+        // Every footprint, odd and even, through all orientations and saved anchor states.
+        for(int w=1;w<=16;w++)for(int d=1;d<=16;d++){
+            var sculpture=new VoxelSculpture(model,"Grid fixture",w,2,d,List.of(new VoxelSculpture.Cell(0,0,0,0xFFFF0000),new VoxelSculpture.Cell(w-1,1,d-1,0xFF0000FF)));
+            for(var facing:Direction.Plane.HORIZONTAL)for(var anchor:SculptureAnchor.values())rendered(entity(client,sculpture,facing,anchor));
+        }
+        // Transparent margins in imported models must not leave a gap at the aimed edge.
+        var padded=new VoxelSculpture(model,"Padded fixture",13,2,15,List.of(new VoxelSculpture.Cell(2,0,3,-1),new VoxelSculpture.Cell(6,1,10,-1)));
+        for(var facing:Direction.Plane.HORIZONTAL)for(var anchor:SculptureAnchor.values())rendered(entity(client,padded,facing,anchor));
+        // Colored markers identify forward motion after rotation, independent of the origin shift.
+        var sculpture=new VoxelSculpture(model,"Direction fixture",3,2,7,List.of(new VoxelSculpture.Cell(0,0,0,0xFFFF0000),new VoxelSculpture.Cell(0,0,6,0xFF0000FF),new VoxelSculpture.Cell(2,1,0,0xFF00FF00)));
+        for(var facing:Direction.Plane.HORIZONTAL){
+            var mesh=mesh(entity(client,sculpture,facing,SculptureAnchor.CENTER));
+            var red=mesh.stream().filter(q->q.color()==0xFFFF0000).findFirst().orElseThrow();var blue=mesh.stream().filter(q->q.color()==0xFF0000FF).findFirst().orElseThrow();
+            check(blue.x()-red.x()==facing.getStepX()*6/16f&&blue.z()-red.z()==facing.getStepZ()*6/16f,"Colored front faces gaze");
+        }
+        var itemMesh=new StatuaryRenderer.ItemRenderer().extractArgument(StatuaryEntity.item(sculpture));
+        check(itemMesh.equals(mesh(entity(client,sculpture,Direction.SOUTH,SculptureAnchor.CENTER))),"Item preview shares exact centered grid geometry");
+        System.out.println("SCULPTURE113_GEOMETRY_PASS 9216 footprints/orientations/anchors and colored direction markers");
+    }
+    private static StatuaryEntity entity(Minecraft client,VoxelSculpture sculpture,Direction facing,SculptureAnchor anchor){
+        var entity=new StatuaryEntity(BlockPos.ZERO,Statuary.BLOCK.defaultBlockState().setValue(Statuary.FACING,facing).setValue(Statuary.ANCHOR,anchor));entity.setLevel(client.level);
+        var data=new CompoundTag();data.put("sculpture",StatuaryEntity.encode(sculpture));entity.loadWithComponents(TagValueInput.create(ProblemReporter.DISCARDING,client.level.registryAccess(),data));return entity;
+    }
+    private static List<StatuaryRenderer.Quad> mesh(StatuaryEntity entity){
+        var renderer=new StatuaryRenderer();var state=renderer.createRenderState();renderer.extractRenderState(entity,state,0,Vec3.ZERO,null);return state.mesh;
+    }
+    static void rendered(StatuaryEntity entity){
+        var mesh=mesh(entity);check(!mesh.isEmpty(),"Sculpture has visible geometry");
+        float minX=1,minZ=1,maxX=0,maxZ=0;
+        for(var q:mesh){
+            check(q.x()*16==Math.rint(q.x()*16)&&q.y()*16==Math.rint(q.y()*16)&&q.z()*16==Math.rint(q.z()*16),"Every rendered voxel is on the exact 1/16 grid");
+            check(q.x()>=0&&q.y()>=0&&q.z()>=0&&q.x()+1/16f<=1&&q.y()+1/16f<=1&&q.z()+1/16f<=1,"No voxel spills out of its block");
+            minX=Math.min(minX,q.x());maxX=Math.max(maxX,q.x()+1/16f);minZ=Math.min(minZ,q.z());maxZ=Math.max(maxZ,q.z()+1/16f);
+        }
+        var anchor=entity.getBlockState().getValue(Statuary.ANCHOR);
+        switch(anchor){
+            case NORTH -> check(minZ==0,"North edge flush");case SOUTH -> check(maxZ==1,"South edge flush");
+            case WEST -> check(minX==0,"West edge flush");case EAST -> check(maxX==1,"East edge flush");
+            case NORTH_WEST -> check(minX==0&&minZ==0,"North-west corner flush");case NORTH_EAST -> check(maxX==1&&minZ==0,"North-east corner flush");
+            case SOUTH_WEST -> check(minX==0&&maxZ==1,"South-west corner flush");case SOUTH_EAST -> check(maxX==1&&maxZ==1,"South-east corner flush");default -> {}
+        }
+        if(anchor==SculptureAnchor.CENTER||anchor==SculptureAnchor.NORTH||anchor==SculptureAnchor.SOUTH)check(Math.abs(minX-(1-maxX))<=1/16f,"Other axis centered to nearest whole voxel");
+        if(anchor==SculptureAnchor.CENTER||anchor==SculptureAnchor.EAST||anchor==SculptureAnchor.WEST)check(Math.abs(minZ-(1-maxZ))<=1/16f,"Other axis centered to nearest whole voxel");
+    }
+    private static void check(boolean ok,String message){if(!ok)throw new AssertionError(message);}
+}

mods/sanctuary/src/clientGametest/java/fr/koka/sanctuary/client/Sculpture116ClientChecks.java

@@ -0,0 +1,84 @@
+package fr.koka.sanctuary.client;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import fr.koka.sanctuary.gametest.Starter039TestSupport;
+import fr.koka.sanctuary.plans.*;
+import java.nio.file.*;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
+import net.fabricmc.fabric.api.client.gametest.v1.*;
+import net.fabricmc.fabric.api.client.gametest.v1.context.ClientGameTestContext;
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.screens.worldselection.WorldCreationUiState;
+import net.minecraft.client.input.KeyEvent;
+import net.minecraft.core.*;
+import net.minecraft.core.component.DataComponents;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.world.inventory.ContainerInput;
+import net.minecraft.world.item.*;
+import net.minecraft.world.item.component.ItemContainerContents;
+import net.minecraft.world.level.block.Blocks;
+
+/** All registered block materials, native paid crafts, stale input rejection and pack reload. */
+public final class Sculpture116ClientChecks implements FabricClientGameTest {
+    private static final BlockPos WORKSHOP=new BlockPos(2,1,2);
+    public void runTest(ClientGameTestContext c){
+        var intro=new AtomicBoolean(true);
+        c.runOnClient(m->{m.options.renderDistance().set(6);m.options.simulationDistance().set(5);m.options.pauseOnLostFocus=false;IntroClient.setQuickTestIntro(true);});
+        ClientTickEvents.END_CLIENT_TICK.register(m->{if(intro.get()&&m.gui.screen() instanceof HelloWorldScreen screen){
+            Starter039TestSupport.selectFirst(screen);screen.children().stream().filter(Button.class::isInstance).map(Button.class::cast).filter(b->b.getClass().getSimpleName().equals("ColorButton")).findFirst().orElseThrow().onPress(enter());screen.children().stream().filter(Button.class::isInstance).map(Button.class::cast).filter(b->b.getMessage().getContents() instanceof net.minecraft.network.chat.contents.TranslatableContents t&&t.getKey().equals("sanctuary.progression.enter")).findFirst().orElseThrow().onPress(enter());intro.set(false);
+        }});
+        Path file=PlanClient.directory().resolve("sculpture116-"+UUID.randomUUID()+".glb");
+        try{
+            Files.createDirectories(file.getParent());Files.write(file,Statuary106ClientChecks.fixture(true));var asset=GlbModel.load(file);var source=VoxelSculpture.of(asset.id(),asset.name(),StatueVoxelizer.miniature(asset.faces()));
+            try{new SculpturePalette(List.of());throw new AssertionError("Empty palette accepted");}catch(IllegalArgumentException expected){}
+            try{new SculpturePalette(Collections.nCopies(257,-1));throw new AssertionError("Oversized palette accepted");}catch(IllegalArgumentException expected){}
+            try{new SculpturePalette(List.of(0));throw new AssertionError("Transparent color accepted");}catch(IllegalArgumentException expected){}
+            net.fabricmc.fabric.api.client.gametest.v1.world.TestWorldSave saved;ItemStack hat;
+            try(var world=c.worldBuilder().adjustSettings(s->{s.setName("Sculpture116 "+UUID.randomUUID());s.setSeed("116");s.setAllowCommands(true);s.setGameMode(WorldCreationUiState.SelectedGameMode.SURVIVAL);s.setWorldType(s.getNormalPresetList().stream().filter(e->e.preset()!=null&&e.preset().getRegisteredName().equals("sanctuary_test:flat")).findFirst().orElseThrow());}).create()){
+                saved=world.getWorldSave();c.waitFor(m->ProgressionClient.active()&&m.player!=null&&m.gui.screen()==null&&!IntroSpawnFlash.active(),1200);var server=world.getServer();
+                server.runOnServer(s->{var p=s.getPlayerList().getPlayers().getFirst();p.getAbilities().invulnerable=true;p.onUpdateAbilities();p.getInventory().clearContent();p.teleportTo(.5,1,.5);for(int x=-4;x<8;x++)for(int z=-4;z<8;z++)p.level().setBlockAndUpdate(new BlockPos(x,0,z),Blocks.STONE.defaultBlockState());p.level().setBlockAndUpdate(WORKSHOP,Statuary.WORKSHOP.defaultBlockState());Statuary.open(p,WORKSHOP);});
+                c.waitForScreen(ClayWorkshopScreen.class);c.runOnClient(m->{m.options.guiScale().set(2);m.getWindow().setWindowed(1280,800);m.resizeGui();((ClayWorkshopScreen)m.gui.screen()).load(file);});
+                c.waitFor(m->!((ClayWorkshopScreen)m.gui.screen()).busy()&&((ClayWorkshopScreen)m.gui.screen()).selected()!=null,200);
+                c.runOnClient(m->{int count=0;for(var item:BuiltInRegistries.ITEM)if(item instanceof BlockItem){var stack=new ItemStack(item);check(ClayWorkshopMenu.material(stack),"Empty registered block accepted: "+item);var palette=SculptureMaterialSampler.sample(stack);check(palette!=null&&palette.colors().size()<=256&&palette.colors().stream().allMatch(v->(v>>>24)==255),"Bounded opaque palette: "+item);count++;}check(count>1000,"Whole block registry sampled");System.out.println("SCULPTURE116_PALETTES "+count+" registered block items");
+                    var dark=new ItemStack(Items.SHULKER_BOX);dark.set(DataComponents.CONTAINER,ItemContainerContents.fromItems(List.of(new ItemStack(Items.DIAMOND))));check(!ClayWorkshopMenu.material(dark),"Filled container cannot lose contents");check(!ClayWorkshopMenu.material(new ItemStack(Items.DIAMOND)),"Non-block item refused");
+                    check(source.cells().stream().map(VoxelSculpture.Cell::color).distinct().count()==1,"Native paid crafts start from a uniform model");Sculpture117Checks.run(source);});
+                var rendered=new HashSet<VoxelSculpture>();
+                for(var item:List.of(Items.STONE,Items.OAK_PLANKS,Items.GOLD_BLOCK,Items.WOOL.pick(DyeColor.RED),Items.GLASS,Items.OAK_LEAVES,Items.CLAY,Items.DEEPSLATE)){
+                    server.runOnServer(s->{var p=s.getPlayerList().getPlayers().getFirst();p.getInventory().clearContent();var menu=(ClayWorkshopMenu)p.containerMenu;menu.getSlot(0).set(new ItemStack(item,2));check(menu.getSlot(1).getItem().isEmpty(),"Previous material result invalidates immediately");menu.broadcastChanges();});
+                    var expected=c.computeOnClient(m->ClayWorkshopMenu.appearance(source,item,SculptureMaterialSampler.sample(new ItemStack(item))));rendered.add(expected);
+                    c.waitFor(m->expected.equals(StatuaryEntity.sculpture(m.player.containerMenu.getSlot(1).getItem())),180);
+                    c.runOnClient(m->check(ItemStack.matches(((ClayWorkshopScreen)m.gui.screen()).preview(),m.player.containerMenu.getSlot(1).getItem()),"Preview equals server-owned result"));
+                    check(StatuaryEntity.decode(StatuaryEntity.encode(expected)).equals(expected),"Palette colors persist in unchanged schema 1");
+                    c.takeScreenshot("sculpture116-"+BuiltInRegistries.ITEM.getKey(item).getPath());
+                    c.runOnClient(m->m.gameMode.handleContainerInput(m.player.containerMenu.containerId,1,0,ContainerInput.PICKUP,m.player));
+                    c.waitFor(m->m.player.containerMenu.getCarried().is(Statuary.ITEM)&&m.player.containerMenu.getSlot(0).getItem().getCount()==1,100);
+                    server.waitFor(s->{var menu=s.getPlayerList().getPlayers().getFirst().containerMenu;return menu.getCarried().is(Statuary.ITEM)&&menu.getSlot(0).getItem().getCount()==1;},100);
+                    server.runOnServer(s->{var menu=(ClayWorkshopMenu)s.getPlayerList().getPlayers().getFirst().containerMenu;check(expected.equals(StatuaryEntity.sculpture(menu.getCarried()))&&menu.getSlot(0).getItem().getCount()==1,"Exactly one actual block consumed per sculpture");});
+                    c.runOnClient(m->m.gameMode.handleContainerInput(m.player.containerMenu.containerId,ClayWorkshopMenu.HOTBAR_START,0,ContainerInput.PICKUP,m.player));c.waitFor(m->m.player.containerMenu.getCarried().isEmpty(),100);server.waitFor(s->s.getPlayerList().getPlayers().getFirst().containerMenu.getCarried().isEmpty(),100);
+                }
+                check(rendered.size()>=7,"Distinct materials produce distinct sculptures");
+                c.waitTicks(6);var stone=c.computeOnClient(m->SculptureMaterialSampler.sample(new ItemStack(Items.STONE)));
+                server.runOnServer(s->{var p=s.getPlayerList().getPlayers().getFirst();var menu=(ClayWorkshopMenu)p.containerMenu;menu.getSlot(0).set(new ItemStack(Items.DIAMOND_BLOCK));menu.select(p,source,Items.STONE,stone);check(menu.getSlot(1).getItem().isEmpty(),"Stale material palette rejected by server");});
+                var diamond=c.computeOnClient(m->SculptureMaterialSampler.sample(new ItemStack(Items.DIAMOND_BLOCK)).apply(source));c.waitFor(m->diamond.equals(StatuaryEntity.sculpture(m.player.containerMenu.getSlot(1).getItem())),180);
+                c.runOnClient(m->{var menu=(ClayWorkshopMenu)m.player.containerMenu;ClientPlayNetworking.send(new ClayWorkshopMenu.Select(menu.containerId,UUID.randomUUID(),source,Items.DIAMOND_BLOCK,stone));});c.waitTicks(6);
+                server.runOnServer(s->{var menu=(ClayWorkshopMenu)s.getPlayerList().getPlayers().getFirst().containerMenu;check(diamond.equals(StatuaryEntity.sculpture(menu.getSlot(1).getItem()))&&menu.getSlot(0).getItem().getCount()==1,"Forged menu token cannot change recipe or spend input");});
+                var before=c.computeOnClient(m->m.getModelManager().getBlockStateModelSet());var reload=c.computeOnClient(m->m.reloadResourcePacks());c.waitFor(m->reload.isDone()&&m.gui.overlay()==null,1200);reload.join();c.waitTicks(8);
+                c.runOnClient(m->{check(before!=m.getModelManager().getBlockStateModelSet(),"Actual resource reload replaces sampling generation");check(diamond.equals(StatuaryEntity.sculpture(((ClayWorkshopScreen)m.gui.screen()).preview())),"Preview refreshes after pack reload");});
+                hat=SculptureHat117Checks.exercise(c,server,diamond);
+                System.out.println("SCULPTURE116_MATERIALS_PASS all block palettes, eight native paid materials, preview equality, shading, stale selections, input identity, token, palette bounds, containers and resource reload");
+            }
+            try(var world=saved.open()){
+                c.waitFor(m->m.player!=null&&m.gui.screen()==null,1200);c.waitTicks(12);
+                SculptureHat117Checks.verifyEquipped(c,world.getServer(),hat);
+                System.out.println("SCULPTURE117_HAT_RECONNECT_PASS equipped sculpture survives native save and fresh client reconnect");
+            }
+        }catch(java.io.IOException e){throw new AssertionError(e);}finally{intro.set(false);try{Files.deleteIfExists(file);}catch(java.io.IOException ignored){}}
+        new Statuary106ClientChecks().runTest(c);
+        System.out.println("SCULPTURE116_PASS materials plus full workshop/hotbar, placement, anchoring, drops, reconnect, FR/EN and Metabli regression");
+    }
+    private static KeyEvent enter(){return new KeyEvent(InputConstants.KEY_RETURN,0,0);}
+    private static void check(boolean ok,String why){if(!ok)throw new AssertionError(why);}
+}

mods/sanctuary/src/clientGametest/java/fr/koka/sanctuary/client/Sculpture117Checks.java

@@ -0,0 +1,59 @@
+package fr.koka.sanctuary.client;
+
+import fr.koka.sanctuary.plans.*;
+import java.util.*;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.block.dispatch.BlockStateModelPart;
+import net.minecraft.core.*;
+import net.minecraft.util.*;
+import net.minecraft.world.item.*;
+import net.minecraft.world.level.block.Blocks;
+
+/** Regression for flat-color models, exact texture colors, deterministic grain and bounded CPU work. */
+final class Sculpture117Checks {
+    static void run(VoxelSculpture source){
+        var cells=new ArrayList<VoxelSculpture.Cell>();
+        for(int z=0;z<16;z++)for(int y=0;y<16;y++)for(int x=0;x<16;x++)cells.add(new VoxelSculpture.Cell(x,y,z,0xFF808080));
+        var flat=new VoxelSculpture(source.modelId(),"Flat",16,16,16,cells);
+        var colors=new ArrayList<Integer>();colors.addAll(Collections.nCopies(64,0xFF223344));colors.addAll(Collections.nCopies(192,0xFFCCBBAA));
+        var weighted=new SculpturePalette(colors);var out=weighted.apply(flat);
+        long dark=out.cells().stream().filter(v->v.color()==0xFF223344).count();
+        check(dark>900&&dark<1150,"Uniform source retains sampled 25% dark / 75% light texture distribution");
+        check(out.cells().stream().allMatch(v->colors.contains(v.color())),"Never invent an averaged color");
+        var reversed=new ArrayList<>(flat.cells());Collections.reverse(reversed);
+        var shuffled=weighted.apply(new VoxelSculpture(flat.modelId(),flat.name(),16,16,16,reversed));
+        check(Arrays.equals(out.packed(),shuffled.cells().reversed().stream().flatMapToInt(v->java.util.stream.IntStream.of(v.key(),v.color())).toArray()),"Sampling is independent of cell iteration order");
+        check(out.equals(weighted.apply(flat))&&out.equals(StatuaryEntity.decode(StatuaryEntity.encode(out))),"Stable pattern and persisted final colors");
+        var gradient=new ArrayList<Integer>();for(int i=0;i<256;i++)gradient.add(0xFF000000|i<<16|i<<8|i);
+        var palette=new SculpturePalette(gradient);
+        var shaded=new VoxelSculpture(flat.modelId(),flat.name(),16,16,16,cells.stream().map(v->new VoxelSculpture.Cell(v.x(),v.y(),v.z(),v.x()<8?0xFF000000:0xFFFFFFFF)).toList());
+        var result=palette.apply(shaded);
+        check(result.cells().stream().filter(v->v.x()<8).allMatch(v->SculpturePalette.lightness(v.color())<.5),"Dark regions sample dark shades");
+        check(result.cells().stream().filter(v->v.x()>=8).allMatch(v->SculpturePalette.lightness(v.color())>=.5),"Light regions sample light shades");
+        check(result.cells().stream().map(VoxelSculpture.Cell::color).distinct().count()>200,"Grain remains inside source shading regions");
+        var single=new SculpturePalette(List.of(0xFF123456));check(single.apply(flat).cells().stream().allMatch(v->v.color()==0xFF123456),"Truly uniform block textures remain uniform");
+        for(var item:List.of(Items.STONE,Items.OAK_PLANKS,Items.COAL_ORE,Items.OAK_LOG)){
+            var sampled=SculptureMaterialSampler.sample(new ItemStack(item));var sculpture=sampled.apply(flat);
+            check(sculpture.cells().stream().map(VoxelSculpture.Cell::color).distinct().count()>2,"Actual texture grain on flat model: "+item);
+            check(sculpture.cells().stream().allMatch(v->sampled.colors().contains(v.color())),"Exact sampled pixels: "+item);
+        }
+        // Log tops and bark are separate native face materials; both must supply exact colors.
+        var mc=Minecraft.getInstance();var state=Blocks.OAK_LOG.defaultBlockState();var parts=new ArrayList<BlockStateModelPart>();
+        mc.getModelManager().getBlockStateModelSet().get(state).collectParts(RandomSource.create(state.getSeed(BlockPos.ZERO)),parts);
+        var bySprite=new HashMap<String,Set<Integer>>();
+        for(var part:parts)for(var face:Direction.values())for(var quad:part.getQuads(face)){
+            var sample=PlanMaterials.faceSample(state,quad.materialInfo());var set=bySprite.computeIfAbsent(quad.materialInfo().sprite().contents().name().toString(),k->new HashSet<>());
+            for(int pixel:sample.pixels().argb()){int color=ARGB.multiply(pixel,sample.tint());if((color>>>24)>=128)set.add(color|0xFF000000);}
+        }
+        check(bySprite.size()>=2,"Native log has distinct face textures");var sampled=SculptureMaterialSampler.sample(new ItemStack(Items.OAK_LOG));
+        var union=new HashSet<Integer>();bySprite.values().forEach(union::addAll);
+        check(sampled.colors().stream().allMatch(union::contains),"All palette colors belong to baked face textures");
+        for(var faceColors:bySprite.values())check(sampled.colors().stream().anyMatch(faceColors::contains),"Each log texture contributes pixels");
+        for(int i=0;i<100;i++)palette.apply(flat);
+        long[] times=new long[101];for(int i=0;i<times.length;i++){long start=System.nanoTime();var measured=palette.apply(flat);times[i]=System.nanoTime()-start;check(measured.cells().size()==4096,"Full bounded model");}
+        Arrays.sort(times);
+        System.out.printf(java.util.Locale.ROOT,"SCULPTURE117_PERF 4096 voxels median %.3f ms, p95 %.3f ms%n",times[50]/1e6,times[95]/1e6);
+        System.out.println("SCULPTURE117_GRAIN_PASS flat model, weighted exact pixels, dark/light regions, deterministic cells, persistence and native face materials");
+    }
+    private static void check(boolean ok,String message){if(!ok)throw new AssertionError(message);}
+}

mods/sanctuary/src/clientGametest/java/fr/koka/sanctuary/client/Sculpture122ClientChecks.java

@@ -0,0 +1,161 @@
+package fr.koka.sanctuary.client;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import fr.koka.sanctuary.gametest.Starter039TestSupport;
+import fr.koka.sanctuary.plans.*;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
+import net.fabricmc.fabric.api.client.gametest.v1.FabricClientGameTest;
+import net.fabricmc.fabric.api.client.gametest.v1.context.ClientGameTestContext;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.screens.worldselection.WorldCreationUiState;
+import net.minecraft.client.input.KeyEvent;
+import net.minecraft.core.*;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.contents.TranslatableContents;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.util.ProblemReporter;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.item.BlockItem;
+import net.minecraft.world.item.context.BlockPlaceContext;
+import net.minecraft.world.level.*;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.storage.TagValueInput;
+import net.minecraft.world.phys.*;
+import net.minecraft.world.phys.shapes.*;
+
+/** Single-box selection/collision bounds and light propagation compared with the real sculpture mesh. */
+public final class Sculpture122ClientChecks implements FabricClientGameTest {
+    private static final String MODEL="sanctuary:model/"+"1".repeat(64);
+    private static final BlockPos TARGET=new BlockPos(0,1,0),SKY=new BlockPos(10,2,2),CONTROL=new BlockPos(18,2,2);
+    private static final VoxelSculpture ARCH=arch();
+
+    public void runTest(ClientGameTestContext c){
+        var intro=new AtomicBoolean(true);
+        c.runOnClient(m->{m.options.renderDistance().set(6);m.options.simulationDistance().set(5);m.options.pauseOnLostFocus=false;IntroClient.setQuickTestIntro(true);});
+        ClientTickEvents.END_CLIENT_TICK.register(m->{if(intro.get()&&m.gui.screen() instanceof HelloWorldScreen screen){
+            Starter039TestSupport.selectFirst(screen);
+            screen.children().stream().filter(Button.class::isInstance).map(Button.class::cast).filter(b->b.getClass().getSimpleName().equals("ColorButton")).findFirst().orElseThrow().onPress(new KeyEvent(InputConstants.KEY_RETURN,0,0));
+            screen.children().stream().filter(Button.class::isInstance).map(Button.class::cast).filter(b->b.getMessage().getContents() instanceof TranslatableContents t&&t.getKey().equals("sanctuary.progression.enter")).findFirst().orElseThrow().onPress(new KeyEvent(InputConstants.KEY_RETURN,0,0));intro.set(false);
+        }});
+        net.fabricmc.fabric.api.client.gametest.v1.world.TestWorldSave saved;
+        try(var world=c.worldBuilder().adjustSettings(s->{s.setName("Sculpture122 "+UUID.randomUUID());s.setSeed("122");s.setAllowCommands(true);s.setGameMode(WorldCreationUiState.SelectedGameMode.CREATIVE);s.setWorldType(s.getNormalPresetList().stream().filter(e->e.preset()!=null&&e.preset().getRegisteredName().equals("sanctuary_test:flat")).findFirst().orElseThrow());}).create()){
+            saved=world.getWorldSave();c.waitFor(m->ProgressionClient.active()&&m.player!=null&&m.gui.screen()==null&&!IntroSpawnFlash.active(),1200);var server=world.getServer();
+            server.runOnServer(s->{var p=player(s);var l=p.level();for(int x=-14;x<=21;x++)for(int z=-6;z<=9;z++)l.setBlockAndUpdate(new BlockPos(x,0,z),Blocks.STONE.defaultBlockState());p.teleportTo(.5,1,3.2);p.setYRot(0);p.getInventory().setItem(p.getInventory().getSelectedSlot(),StatuaryEntity.item(ARCH));p.inventoryMenu.broadcastFullState();
+                s.getCommands().performPrefixedCommand(s.createCommandSourceStack(),"sanctuary time vanilla");s.getCommands().performPrefixedCommand(s.createCommandSourceStack(),"time set noon");
+                s.getCommands().performPrefixedCommand(s.createCommandSourceStack(),"sanctuary weather vanilla");s.getCommands().performPrefixedCommand(s.createCommandSourceStack(),"weather clear");
+            });
+            c.waitFor(m->m.player.distanceToSqr(.5,1,3.2)<.1&&m.player.getMainHandItem().is(Statuary.ITEM)&&m.level.getBlockState(TARGET.below()).is(Blocks.STONE),150);
+            c.runOnClient(m->m.player.lookAt(net.minecraft.commands.arguments.EntityAnchorArgument.Anchor.EYES,new Vec3(.5,.999,.5)));c.waitTicks(3);
+            c.runOnClient(m->check(m.hitResult instanceof BlockHitResult hit&&hit.getBlockPos().equals(TARGET.below())&&hit.getDirection()==Direction.UP,"Cursor aims at placement support"));
+            c.getInput().holdKey(o->o.keyUse);c.waitTicks(1);c.getInput().releaseKey(o->o.keyUse);c.waitTicks(3);
+            server.runOnServer(s->System.out.println("SCULPTURE122_PLACED "+player(s).level().getBlockState(TARGET)+" "+player(s).level().getBlockEntity(TARGET)));
+            c.waitFor(m->m.level.getBlockEntity(TARGET) instanceof StatuaryEntity e&&ARCH.equals(e.sculpture()),150);
+            server.runOnServer(s->{physical(player(s).level(),TARGET);placementOverlap(player(s));});
+            c.runOnClient(m->{physical(m.level,TARGET);geometry(m);Sculpture113ClientChecks.geometry(m,MODEL);});
+            c.runOnClient(m->m.player.lookAt(net.minecraft.commands.arguments.EntityAnchorArgument.Anchor.EYES,new Vec3(.0625,1.5,.5)));c.waitTicks(5);
+            c.runOnClient(m->check(m.hitResult instanceof BlockHitResult hit&&hit.getBlockPos().equals(TARGET),"Native cursor selects an occupied pillar"));
+            c.takeScreenshot("sculpture124-single-outline");
+            server.runOnServer(s->player(s).level().setBlockAndUpdate(TARGET.north(),Blocks.REDSTONE_BLOCK.defaultBlockState()));
+            c.waitFor(m->m.level.getBlockState(TARGET.north()).is(Blocks.REDSTONE_BLOCK),100);
+            c.runOnClient(m->m.player.lookAt(net.minecraft.commands.arguments.EntityAnchorArgument.Anchor.EYES,new Vec3(.5,1.5,.5)));c.waitTicks(5);
+            c.runOnClient(m->check(m.hitResult instanceof BlockHitResult hit&&hit.getBlockPos().equals(TARGET),"Native cursor selects the sculpture bounds even through its visual hole"));
+            c.takeScreenshot("sculpture124-select-volume");
+            // A state edit and fresh entity payload must invalidate geometry on both sides.
+            server.runOnServer(s->{var l=player(s).level();l.setBlockAndUpdate(TARGET,l.getBlockState(TARGET).setValue(Statuary.FACING,Direction.WEST).setValue(Statuary.ANCHOR,SculptureAnchor.EAST));});
+            c.waitFor(m->m.level.getBlockState(TARGET).getValue(Statuary.FACING)==Direction.WEST,100);
+            server.runOnServer(s->{var l=player(s).level();var bounds=l.getBlockState(TARGET).getShape(l,TARGET).bounds();check(bounds.maxX==1&&bounds.getXsize()==.25,"Server shape rotates and moves to aimed edge");});
+            c.runOnClient(m->{var bounds=m.level.getBlockState(TARGET).getShape(m.level,TARGET).bounds();check(bounds.maxX==1&&bounds.getXsize()==.25,"Client shape follows changed blockstate");});
+            var small=new VoxelSculpture(MODEL,"Small",1,1,1,List.of(new VoxelSculpture.Cell(0,0,0,-1)));
+            server.runOnServer(s->place(player(s).level(),TARGET,small,Direction.WEST,SculptureAnchor.EAST));
+            c.waitFor(m->m.level.getBlockEntity(TARGET) instanceof StatuaryEntity e&&small.equals(e.sculpture()),100);
+            c.runOnClient(m->check(m.level.getBlockState(TARGET).getShape(m.level,TARGET).bounds().getYsize()==1/16d,"Changed block entity payload invalidates cached shape"));
+            server.runOnServer(s->{var l=player(s).level();place(l,TARGET,ARCH,Direction.SOUTH,SculptureAnchor.CENTER);l.setBlockAndUpdate(TARGET.north(),Blocks.AIR.defaultBlockState());
+                for(int x=8;x<=12;x++)for(int z=0;z<=4;z++)for(int y=3;y<=5;y++)place(l,new BlockPos(x,y,z),ARCH,Direction.SOUTH,SculptureAnchor.CENTER);
+                for(int x=16;x<=20;x++)for(int z=0;z<=4;z++)l.setBlockAndUpdate(new BlockPos(x,3,z),Blocks.STONE.defaultBlockState());
+                l.setBlockAndUpdate(new BlockPos(-8,2,0),Blocks.GLOWSTONE.defaultBlockState());place(l,new BlockPos(-7,2,0),ARCH,Direction.SOUTH,SculptureAnchor.CENTER);
+            });
+            server.waitFor(s->{var l=player(s).level();return l.getBrightness(LightLayer.SKY,SKY)==15&&l.getBrightness(LightLayer.SKY,CONTROL)<15&&l.getBrightness(LightLayer.BLOCK,new BlockPos(-6,2,0))==13;},200);
+            c.waitFor(m->m.level.getBrightness(LightLayer.SKY,SKY)==15&&m.level.getBrightness(LightLayer.SKY,CONTROL)<15&&m.level.getBrightness(LightLayer.BLOCK,new BlockPos(-6,2,0))==13,200);
+            server.runOnServer(s->{var l=player(s).level();for(int x=8;x<=12;x++)for(int z=0;z<=4;z++)for(int y=3;y<=5;y++)check(l.getBrightness(LightLayer.SKY,new BlockPos(x,y,z))==15,"All 75 sculptures keep full native skylight");});
+            c.runOnClient(m->{var e=(StatuaryEntity)m.level.getBlockEntity(new BlockPos(10,4,2));var renderer=new StatuaryRenderer();var state=renderer.createRenderState();renderer.extractRenderState(e,state,0,Vec3.ZERO,null);check(net.minecraft.util.LightCoordsUtil.sky(state.lightCoords)==15,"Actual renderer receives full skylight inside a group");});
+            // Visual crowd at ground level: no whole-block AO squares between the models.
+            server.runOnServer(s->{var p=player(s);for(int x=-3;x<=3;x++)for(int z=-5;z<=-2;z++)place(p.level(),new BlockPos(x,1,z),ARCH,Direction.from2DDataValue(Math.floorMod(x+z,4)),SculptureAnchor.CENTER);p.teleportTo(.5,3,5.5);p.getAbilities().flying=true;p.onUpdateAbilities();});
+            c.waitFor(m->m.player.distanceToSqr(.5,3,5.5)<.1,100);c.runOnClient(m->m.player.lookAt(net.minecraft.commands.arguments.EntityAnchorArgument.Anchor.EYES,new Vec3(.5,1,-3)));c.waitTicks(12);c.takeScreenshot("sculpture122-crowd-light");
+            // Transparent-to-light is not emissive: in a closed room sculpture faces stay dark.
+            server.runOnServer(s->{var l=player(s).level();for(int x=-13;x<=-9;x++)for(int y=1;y<=5;y++)for(int z=5;z<=9;z++)l.setBlockAndUpdate(new BlockPos(x,y,z),x==-13||x==-9||y==1||y==5||z==5||z==9?Blocks.STONE.defaultBlockState():Blocks.AIR.defaultBlockState());place(l,new BlockPos(-11,2,7),ARCH,Direction.SOUTH,SculptureAnchor.CENTER);});
+            c.waitFor(m->m.level.getBlockEntity(new BlockPos(-11,2,7)) instanceof StatuaryEntity&&m.level.getBrightness(LightLayer.SKY,new BlockPos(-11,2,7))==0&&m.level.getBrightness(LightLayer.BLOCK,new BlockPos(-11,2,7))==0,200);
+            c.runOnClient(m->{var renderer=new StatuaryRenderer();var state=renderer.createRenderState();renderer.extractRenderState((StatuaryEntity)m.level.getBlockEntity(new BlockPos(-11,2,7)),state,0,Vec3.ZERO,null);check(state.lightCoords==0,"No fullbright workaround: a dark room produces dark faces");});
+            System.out.println("SCULPTURE122_LIGHT_PASS: 75 stacked models sky=15; opaque control shadow; block light=13 across sculpture; dark room=0; shade brightness=1");
+        }
+        try(var world=saved.open()){
+            c.waitFor(m->m.player!=null&&m.gui.screen()==null&&m.level.getBlockEntity(TARGET) instanceof StatuaryEntity e&&ARCH.equals(e.sculpture()),1200);
+            world.getServer().runOnServer(s->physical(player(s).level(),TARGET));c.runOnClient(m->physical(m.level,TARGET));
+            c.waitFor(m->m.level.getBrightness(LightLayer.SKY,SKY)==15,200);
+            System.out.println("SCULPTURE122_PASS: native placement, one-box outline including holes, single-box physical collisions, shared render geometry, cache refresh, light propagation and save/reconnect");
+        }
+    }
+    private static void placementOverlap(ServerPlayer player){
+        var pos=new BlockPos(3,1,0);var level=player.level();player.teleportTo(3.75,1,.5);player.setYRot(0);
+        var filled=new ArrayList<VoxelSculpture.Cell>();for(int x=0;x<16;x++)for(int y=0;y<16;y++)for(int z=0;z<16;z++)filled.add(new VoxelSculpture.Cell(x,y,z,-1));
+        var dense=new VoxelSculpture(MODEL,"Solid",16,16,16,filled);var stack=StatuaryEntity.item(dense);player.getInventory().setItem(player.getInventory().getSelectedSlot(),stack);
+        var hit=new BlockHitResult(new Vec3(3.01,1,.5),Direction.UP,pos.below(),false);
+        var blocked=((BlockItem)Statuary.ITEM).place(new BlockPlaceContext(player,InteractionHand.MAIN_HAND,stack,hit));
+        check(!blocked.consumesAction()&&level.getBlockState(pos).isAir()&&stack.getCount()==1,"Native placement refuses occupied voxels inside player without consuming sculpture");
+        player.teleportTo(3.5,1,.5);var pillars=new ArrayList<VoxelSculpture.Cell>();for(int y=0;y<16;y++)for(int x:new int[]{0,15})pillars.add(new VoxelSculpture.Cell(x,y,0,-1));
+        var hollow=new VoxelSculpture(MODEL,"Two pillars",16,16,1,pillars);stack=StatuaryEntity.item(hollow);player.getInventory().setItem(player.getInventory().getSelectedSlot(),stack);
+        var hollowBlocked=((BlockItem)Statuary.ITEM).place(new BlockPlaceContext(player,InteractionHand.MAIN_HAND,stack,hit));
+        check(!hollowBlocked.consumesAction()&&level.getBlockState(pos).isAir(),"Placement also rejects a player inside the enclosing box between separated pillars");player.teleportTo(3.75,1,.5);
+        var postCells=new ArrayList<VoxelSculpture.Cell>();for(int y=0;y<16;y++)for(int x=0;x<2;x++)for(int z=0;z<2;z++)postCells.add(new VoxelSculpture.Cell(x,y,z,-1));
+        var post=new VoxelSculpture(MODEL,"Post",2,16,2,postCells);stack=StatuaryEntity.item(post);player.getInventory().setItem(player.getInventory().getSelectedSlot(),stack);
+        var allowed=((BlockItem)Statuary.ITEM).place(new BlockPlaceContext(player,InteractionHand.MAIN_HAND,stack,hit));
+        check(allowed.consumesAction()&&level.getBlockState(pos).is(Statuary.BLOCK),"Native placement allows empty part of block beside player");
+        check(level.noCollision(player,player.getBoundingBox()),"Accepted sculpture does not intersect player");
+        level.setBlockAndUpdate(pos,Blocks.AIR.defaultBlockState());player.teleportTo(.5,1,3.2);player.getInventory().setItem(player.getInventory().getSelectedSlot(),StatuaryEntity.item(ARCH));player.inventoryMenu.broadcastFullState();
+        System.out.println("SCULPTURE122_PLACEMENT_PASS native item rejects occupied bounds including visual holes, allows space outside the box, preserves stack on rejection");
+    }
+    private static void physical(Level level,BlockPos pos){
+        var state=level.getBlockState(pos);var shape=state.getShape(level,pos);var collision=state.getCollisionShape(level,pos);
+        check(shape==collision&&shape.toAabbs().size()==1,"Selection and collision share one cached bounding box");check(shape==state.getShape(level,pos),"Selection queries reuse the cached box");check(shape.bounds().getZsize()==.25,"No invisible full-block depth");
+        check(level.clip(new ClipContext(new Vec3(.5,1.5,2),new Vec3(.5,1.5,-.1),ClipContext.Block.OUTLINE,ClipContext.Fluid.NONE,CollisionContext.empty())).getType()==HitResult.Type.BLOCK,"Outline ray selects the whole sculpture volume");
+        check(level.clip(new ClipContext(new Vec3(.0625,1.5,2),new Vec3(.0625,1.5,-.1),ClipContext.Block.COLLIDER,ClipContext.Fluid.NONE,CollisionContext.empty())).getType()==HitResult.Type.BLOCK,"Collision ray hits pillar");
+        check(level.clip(new ClipContext(new Vec3(.5,1.5,2),new Vec3(.5,1.5,-.1),ClipContext.Block.COLLIDER,ClipContext.Fluid.NONE,CollisionContext.empty())).getType()==HitResult.Type.BLOCK,"Physical collision uses the enclosing volume, including visual holes");
+        check(!level.noCollision(new AABB(.35,1.2,.35,.65,1.7,.65)),"Native collision query fills the inner volume instead of following tiny details");
+        check(!level.noCollision(new AABB(.02,1.2,.4,.1,1.7,.6)),"Native collision query blocks occupied pillar");
+        check(!state.isCollisionShapeFullBlock(level,pos)&&!state.isSolidRender()&&!state.canOcclude(),"Sculpture is not a solid occluding cube");
+        check(state.getOcclusionShape().isEmpty()&&state.propagatesSkylightDown()&&state.getLightDampening()==0&&state.getShadeBrightness(level,pos)==1,"Light metadata never reintroduces full-block occlusion");
+        check(!state.isSuffocating(level,pos)&&state.getLightEmission()==0,"Decorative shape neither suffocates nor emits light");
+    }
+    private static void geometry(Minecraft m){
+        var padded=new VoxelSculpture(MODEL,"Padded",13,5,15,List.of(new VoxelSculpture.Cell(2,2,3,-1),new VoxelSculpture.Cell(6,4,10,-1)));
+        var dense=new ArrayList<VoxelSculpture.Cell>();for(int x=0;x<16;x++)for(int y=0;y<16;y++)for(int z=0;z<16;z++)dense.add(new VoxelSculpture.Cell(x,y,z,-1));
+        var models=List.of(ARCH,padded,new VoxelSculpture(MODEL,"Dense",16,16,16,dense),new VoxelSculpture(MODEL,"One voxel",1,1,1,List.of(new VoxelSculpture.Cell(0,0,0,-1))));
+        int cases=0;for(var model:models)for(var direction:Direction.Plane.HORIZONTAL)for(var anchor:SculptureAnchor.values())for(var height:SculptureHeight.values()){
+            var state=Statuary.BLOCK.defaultBlockState().setValue(Statuary.FACING,direction).setValue(Statuary.ANCHOR,anchor).setValue(Statuary.HEIGHT,height);var entity=new StatuaryEntity(BlockPos.ZERO,state);entity.setLevel(m.level);load(entity,model,m.level);
+            var shape=entity.shape(state);check(shape==entity.shape(state),"Repeated geometry queries reuse the same shape");var boxes=shape.toAabbs();double volume=boxes.stream().mapToDouble(b->b.getXsize()*b.getYsize()*b.getZsize()).sum();check(boxes.size()==1&&volume>=model.cells().size()/4096d,"One box encloses all occupied cells");
+            var outline=entity.shape(state);check(outline==entity.shape(state),"Repeated outline queries reuse the cached box");
+            check(outline.toAabbs().size()==1&&outline.bounds().equals(shape.bounds()),"One outline box matches exact rendered extents for every orientation and anchor");
+            int[] edges={0};outline.forAllEdges((x1,y1,z1,x2,y2,z2)->edges[0]++);check(edges[0]==12,"Native outline emits only the 12 enclosing edges, independent of voxel count");
+            var renderer=new StatuaryRenderer();var render=renderer.createRenderState();renderer.extractRenderState(entity,render,0,Vec3.ZERO,null);
+            double minX=1,minY=1,minZ=1,maxX=0,maxY=0,maxZ=0;
+            for(var q:render.mesh){minX=Math.min(minX,q.x());minY=Math.min(minY,q.y());minZ=Math.min(minZ,q.z());maxX=Math.max(maxX,q.x()+1/16d);maxY=Math.max(maxY,q.y()+1/16d);maxZ=Math.max(maxZ,q.z()+1/16d);var center=new Vec3(q.x()+1/32d,q.y()+1/32d,q.z()+1/32d);check(boxes.stream().anyMatch(b->b.contains(center)),"Every rendered cell is physically present");
+            }
+            check(shape.bounds().equals(new AABB(minX,minY,minZ,maxX,maxY,maxZ)),"Single collision box exactly matches visible mesh extents");
+            cases++;
+        }
+        System.out.println("SCULPTURE124_BOUNDS_PASS "+cases+" cached single boxes agree with exact renderer extents; 12 outline edges each");
+        System.out.println("SCULPTURE122_GEOMETRY_PASS "+cases+" native bounding boxes agree with emitted mesh extents, plus cached 12-edge selection bounds for holes, padding, dense 4096 cells, single voxel, 4 directions, 9 anchors and 4 vertical modes");
+    }
+    private static void place(ServerLevel level,BlockPos pos,VoxelSculpture model,Direction facing,SculptureAnchor anchor){
+        var state=Statuary.BLOCK.defaultBlockState().setValue(Statuary.FACING,facing).setValue(Statuary.ANCHOR,anchor);level.setBlockAndUpdate(pos,state);var entity=(StatuaryEntity)level.getBlockEntity(pos);load(entity,model,level);entity.setChanged();level.sendBlockUpdated(pos,state,state,3);
+    }
+    private static void load(StatuaryEntity entity,VoxelSculpture model,Level level){var tag=new CompoundTag();tag.put("sculpture",StatuaryEntity.encode(model));entity.loadWithComponents(TagValueInput.create(ProblemReporter.DISCARDING,level.registryAccess(),tag));}
+    private static VoxelSculpture arch(){var cells=new ArrayList<VoxelSculpture.Cell>();for(int x=0;x<16;x++)for(int y=0;y<16;y++)for(int z=0;z<4;z++)if(x<2||x>=14||y>=14)cells.add(new VoxelSculpture.Cell(x,y,z,0xffc99679));return new VoxelSculpture(MODEL,"Arch",16,16,4,cells);}
+    private static ServerPlayer player(MinecraftServer server){return server.getPlayerList().getPlayers().getFirst();}
+    private static void check(boolean value,String reason){if(!value)throw new AssertionError(reason);}
+}

mods/sanctuary/src/clientGametest/java/fr/koka/sanctuary/client/Sculpture125ClientChecks.java

@@ -0,0 +1,118 @@
+package fr.koka.sanctuary.client;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import fr.koka.sanctuary.gametest.Starter039TestSupport;
+import fr.koka.sanctuary.plans.*;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
+import net.fabricmc.fabric.api.client.gametest.v1.FabricClientGameTest;
+import net.fabricmc.fabric.api.client.gametest.v1.context.ClientGameTestContext;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.screens.worldselection.WorldCreationUiState;
+import net.minecraft.client.input.KeyEvent;
+import net.minecraft.core.*;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.nbt.*;
+import net.minecraft.network.chat.contents.TranslatableContents;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.*;
+import net.minecraft.util.ProblemReporter;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.item.context.BlockPlaceContext;
+import net.minecraft.world.level.block.*;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.storage.TagValueInput;
+import net.minecraft.world.phys.*;
+
+/** Native clicks on all six support faces; additive saved-state compatibility and real renderer bounds. */
+public final class Sculpture125ClientChecks implements FabricClientGameTest {
+    private static final BlockPos SUPPORT=new BlockPos(0,4,0);
+    private static final String MODEL="sanctuary:model/"+"2".repeat(64);
+    private static final VoxelSculpture STATUE=statue();
+    private static final SculptureAnchor[][] ANCHORS={{SculptureAnchor.NORTH_WEST,SculptureAnchor.WEST,SculptureAnchor.SOUTH_WEST},{SculptureAnchor.NORTH,SculptureAnchor.CENTER,SculptureAnchor.SOUTH},{SculptureAnchor.NORTH_EAST,SculptureAnchor.EAST,SculptureAnchor.SOUTH_EAST}};
+    private static final SculptureHeight[] HEIGHTS={SculptureHeight.BOTTOM,SculptureHeight.CENTER,SculptureHeight.TOP};
+    private record Spot(Direction face,int u,int v){
+        Vec3 hit(BlockPos p){double a=.1+.4*u,b=.1+.4*v;return switch(face){
+            case UP,DOWN->new Vec3(p.getX()+a,p.getY()+(face==Direction.UP?1:0),p.getZ()+b);
+            case NORTH,SOUTH->new Vec3(p.getX()+a,p.getY()+b,p.getZ()+(face==Direction.SOUTH?1:0));
+            case WEST,EAST->new Vec3(p.getX()+(face==Direction.EAST?1:0),p.getY()+b,p.getZ()+a);
+        };}
+        SculptureAnchor anchor(){return switch(face){case UP,DOWN->ANCHORS[u][v];case NORTH->ANCHORS[u][2];case SOUTH->ANCHORS[u][0];case EAST->ANCHORS[0][u];case WEST->ANCHORS[2][u];};}
+        SculptureHeight height(){return face==Direction.UP?SculptureHeight.BOTTOM:face==Direction.DOWN?SculptureHeight.TOP:HEIGHTS[v];}
+    }
+    public void runTest(ClientGameTestContext c){
+        var intro=new AtomicBoolean(true);
+        c.runOnClient(m->{m.options.renderDistance().set(6);m.options.simulationDistance().set(5);m.options.pauseOnLostFocus=false;IntroClient.setQuickTestIntro(true);});
+        ClientTickEvents.END_CLIENT_TICK.register(m->{if(intro.get()&&m.gui.screen() instanceof HelloWorldScreen screen){
+            Starter039TestSupport.selectFirst(screen);var enter=new KeyEvent(InputConstants.KEY_RETURN,0,0);
+            screen.children().stream().filter(Button.class::isInstance).map(Button.class::cast).filter(b->b.getClass().getSimpleName().equals("ColorButton")).findFirst().orElseThrow().onPress(enter);
+            screen.children().stream().filter(Button.class::isInstance).map(Button.class::cast).filter(b->b.getMessage().getContents() instanceof TranslatableContents t&&t.getKey().equals("sanctuary.progression.enter")).findFirst().orElseThrow().onPress(enter);intro.set(false);
+        }});
+        net.fabricmc.fabric.api.client.gametest.v1.world.TestWorldSave saved;
+        var persistent=new HashMap<BlockPos,BlockState>();
+        try(var world=c.worldBuilder().adjustSettings(s->{s.setName("Sculpture125 "+UUID.randomUUID());s.setSeed("125");s.setAllowCommands(true);s.setGameMode(WorldCreationUiState.SelectedGameMode.CREATIVE);s.setWorldType(s.getNormalPresetList().stream().filter(e->e.preset()!=null&&e.preset().getRegisteredName().equals("sanctuary_test:flat")).findFirst().orElseThrow());}).create()){
+            c.waitFor(m->ProgressionClient.active()&&m.player!=null&&m.gui.screen()==null&&!IntroSpawnFlash.active(),1200);var server=world.getServer();
+            server.runOnServer(s->{var p=player(s);var l=p.level();for(int x=-8;x<=8;x++)for(int z=-8;z<=8;z++)l.setBlockAndUpdate(new BlockPos(x,0,z),Blocks.STONE.defaultBlockState());p.getAbilities().flying=true;p.onUpdateAbilities();p.getInventory().setItem(p.getInventory().getSelectedSlot(),StatuaryEntity.item(STATUE));p.inventoryMenu.broadcastFullState();
+                s.getCommands().performPrefixedCommand(s.createCommandSourceStack(),"sanctuary time vanilla");s.getCommands().performPrefixedCommand(s.createCommandSourceStack(),"time set noon");s.getCommands().performPrefixedCommand(s.createCommandSourceStack(),"sanctuary weather vanilla");s.getCommands().performPrefixedCommand(s.createCommandSourceStack(),"weather clear");contexts(p);legacy(p);Sculpture113ClientChecks.placementContexts(p);l.setBlockAndUpdate(SUPPORT,Blocks.STONE.defaultBlockState());
+            });
+            c.waitFor(m->m.player.getMainHandItem().is(Statuary.ITEM)&&m.level.getBlockState(SUPPORT).is(Blocks.STONE),150);
+            int clicks=0;
+            for(var face:Direction.values()){
+                Vec3 eye= switch(face){case UP->new Vec3(.5,6,3);case DOWN->new Vec3(.5,1.3,2.5);case NORTH->new Vec3(.5,3,-2.2);case SOUTH->new Vec3(.5,3,3.2);case EAST->new Vec3(3.2,3,.5);case WEST->new Vec3(-2.2,3,.5);};
+                server.runOnServer(s->{var p=player(s);p.teleportTo(eye.x,eye.y,eye.z);p.setDeltaMovement(Vec3.ZERO);p.getAbilities().flying=true;p.onUpdateAbilities();});c.waitFor(m->m.player.distanceToSqr(eye)<.05,100);c.runOnClient(m->{m.player.getAbilities().flying=true;m.player.setDeltaMovement(Vec3.ZERO);m.player.onUpdateAbilities();});c.waitTicks(10);
+                for(int u=0;u<3;u++)for(int v=0;v<3;v++){
+                    var spot=new Spot(face,u,v);var target=SUPPORT.relative(face);
+                    server.runOnServer(s->{for(var direction:Direction.values())player(s).level().setBlockAndUpdate(SUPPORT.relative(direction),Blocks.AIR.defaultBlockState());});
+                    c.waitFor(m->m.level.getBlockState(target).isAir(),100);
+                    c.runOnClient(m->m.player.lookAt(net.minecraft.commands.arguments.EntityAnchorArgument.Anchor.EYES,spot.hit(SUPPORT)));c.waitTicks(3);
+                    c.runOnClient(m->check(m.hitResult instanceof BlockHitResult h&&h.getBlockPos().equals(SUPPORT)&&h.getDirection()==face,"Native cursor hits requested support face "+spot+" instead of "+m.hitResult+" at "+m.hitResult.getLocation()+" eye "+m.player.getEyePosition()+" flying "+m.player.getAbilities().flying));
+                    var facing=c.computeOnClient(m->{System.out.println("SCULPTURE125_AIM "+spot+" actual "+m.hitResult.getLocation()+" eye "+m.player.getEyePosition());return m.player.getDirection();});c.getInput().holdKey(o->o.keyUse);c.waitTicks(1);c.getInput().releaseKey(o->o.keyUse);c.waitTicks(3);
+                    c.waitFor(m->m.level.getBlockEntity(target) instanceof StatuaryEntity e&&STATUE.equals(e.sculpture()),100);
+                    server.runOnServer(s->{var l=player(s).level();var state=l.getBlockState(target);check(state.getValue(Statuary.ANCHOR)==spot.anchor()&&state.getValue(Statuary.HEIGHT)==spot.height()&&state.getValue(Statuary.FACING)==facing,"Server uses aimed position and horizontal gaze for "+spot+" got "+state+" expected facing "+facing);});
+                    c.runOnClient(m->{var e=(StatuaryEntity)m.level.getBlockEntity(target);renderBounds(e);});
+                    if(u==0&&v==2)c.takeScreenshot("sculpture125-"+face.getSerializedName());clicks++;
+                }
+            }
+            System.out.println("SCULPTURE125_CLICKS_PASS "+clicks+" real placements: all six faces, every corner/edge/center and supported heights");
+            c.runOnClient(m->Sculpture125ParticleChecks.exercise(m,SUPPORT.relative(Direction.EAST)));
+            Sculpture125WorkshopChecks.exercise(c,server);
+            server.runOnServer(s->{var l=player(s).level();for(var direction:Direction.values())l.setBlockAndUpdate(SUPPORT.relative(direction),Blocks.AIR.defaultBlockState());for(int x=0;x<3;x++)for(int y=0;y<3;y++){
+                var pos=new BlockPos(x*2-2,y+1,0);l.setBlockAndUpdate(pos.north(),Blocks.STONE.defaultBlockState());var state=Statuary.BLOCK.defaultBlockState().setValue(Statuary.FACING,Direction.SOUTH).setValue(Statuary.ANCHOR,ANCHORS[x][0]).setValue(Statuary.HEIGHT,HEIGHTS[y]);place(l,pos,state);persistent.put(pos,state);
+            }player(s).teleportTo(.5,2,5);});
+            c.waitFor(m->m.player.distanceToSqr(.5,2,5)<.05,100);c.runOnClient(m->m.player.lookAt(net.minecraft.commands.arguments.EntityAnchorArgument.Anchor.EYES,new Vec3(.5,2.5,.5)));c.waitTicks(8);c.takeScreenshot("sculpture125-wall-placements");saved=world.getWorldSave();
+        }
+        try(var world=saved.open()){
+            c.waitFor(m->m.player!=null&&m.gui.screen()==null,1200);world.getServer().runOnServer(s->{for(var entry:persistent.entrySet()){var state=player(s).level().getBlockState(entry.getKey());check(state==entry.getValue(),"New anchors and heights persist exactly");check(STATUE.equals(((StatuaryEntity)player(s).level().getBlockEntity(entry.getKey())).sculpture()),"Model data persists unchanged");}});
+            c.waitFor(m->persistent.keySet().stream().allMatch(p->m.level.getBlockEntity(p) instanceof StatuaryEntity e&&STATUE.equals(e.sculpture())),150);c.runOnClient(m->persistent.keySet().forEach(p->renderBounds((StatuaryEntity)m.level.getBlockEntity(p))));
+        }
+        new Sculpture122ClientChecks().runTest(c);
+        System.out.println("SCULPTURE125_PASS new placement gestures, native picking, collision/render agreement, legacy states and saved new positions");
+    }
+    private static void contexts(ServerPlayer p){int count=0;
+        for(var pos:List.of(new BlockPos(5,3,5),new BlockPos(-5,3,-5))){p.level().setBlockAndUpdate(pos,Blocks.STONE.defaultBlockState());
+            for(int turn=0;turn<4;turn++){p.setYRot(turn*90);for(var face:Direction.values())for(int u=0;u<3;u++)for(int v=0;v<3;v++){
+                var spot=new Spot(face,u,v);var context=new BlockPlaceContext(p,InteractionHand.MAIN_HAND,StatuaryEntity.item(STATUE),new BlockHitResult(spot.hit(pos),face,pos,false));var state=Statuary.BLOCK.getStateForPlacement(context);
+                check(context.getClickedPos().equals(pos.relative(face))&&state.getValue(Statuary.ANCHOR)==spot.anchor()&&state.getValue(Statuary.HEIGHT)==spot.height()&&state.getValue(Statuary.FACING)==p.getDirection(),"Native placement context agrees at signed coordinates: "+spot);count++;
+            }}p.level().setBlockAndUpdate(pos,Blocks.AIR.defaultBlockState());
+        }
+        check(Statuary.BLOCK.getStateDefinition().getPossibleStates().size()==144,"108 placement states plus 36 legacy-height states");
+        for(var anchor:SculptureAnchor.values())for(var height:SculptureHeight.values()){
+            var state=Statuary.BLOCK.defaultBlockState().setValue(Statuary.ANCHOR,anchor).setValue(Statuary.HEIGHT,height);var box=SculptureGeometry.shape(STATUE,Direction.SOUTH,anchor,height).bounds();
+            for(var rotation:Rotation.values()){var rotated=state.rotate(rotation);check(rotated.getValue(Statuary.HEIGHT)==height,"Yaw rotation retains height");var b=SculptureGeometry.shape(STATUE,rotated.getValue(Statuary.FACING),rotated.getValue(Statuary.ANCHOR),height).bounds();double ex=box.getCenter().x-.5,ez=box.getCenter().z-.5;double tx=switch(rotation){case NONE->ex;case CLOCKWISE_90->-ez;case CLOCKWISE_180->-ex;case COUNTERCLOCKWISE_90->ez;};double tz=switch(rotation){case NONE->ez;case CLOCKWISE_90->ex;case CLOCKWISE_180->-ez;case COUNTERCLOCKWISE_90->-ex;};check(Math.abs((b.getCenter().x-.5)-tx)<=1/16d&&Math.abs((b.getCenter().z-.5)-tz)<=1/16d&&b.minY==box.minY,"Rotated anchor follows native structure rotation without half voxels");}
+            for(var mirror:Mirror.values()){var mirrored=state.mirror(mirror);var b=SculptureGeometry.shape(STATUE,mirrored.getValue(Statuary.FACING),mirrored.getValue(Statuary.ANCHOR),height).bounds();double x=mirror==Mirror.FRONT_BACK?1-box.getCenter().x:box.getCenter().x,z=mirror==Mirror.LEFT_RIGHT?1-box.getCenter().z:box.getCenter().z;check(Math.abs(b.getCenter().x-x)<=1/16d&&Math.abs(b.getCenter().z-z)<=1/16d&&b.minY==box.minY,"Mirrored corner and vertical placement follow native structure mirror");}
+        }
+        System.out.println("SCULPTURE125_CONTEXT_PASS "+count+" contexts, signed coordinates, four headings, rotations/mirrors and 144 valid states");
+    }
+    private static void legacy(ServerPlayer p){int n=0;
+        for(var facing:Direction.Plane.HORIZONTAL)for(var anchor:List.of(SculptureAnchor.CENTER,SculptureAnchor.NORTH,SculptureAnchor.SOUTH,SculptureAnchor.WEST,SculptureAnchor.EAST)){
+            var state=Statuary.BLOCK.defaultBlockState().setValue(Statuary.FACING,facing).setValue(Statuary.ANCHOR,anchor).setValue(Statuary.HEIGHT,SculptureHeight.TOP);var nbt=NbtUtils.writeBlockState(state);nbt.getCompoundOrEmpty("properties").remove("vertical_anchor");var restored=NbtUtils.readBlockState(BuiltInRegistries.BLOCK,nbt);
+            check(restored.getValue(Statuary.HEIGHT)==SculptureHeight.ORIGINAL&&restored.getValue(Statuary.ANCHOR)==anchor&&restored.getValue(Statuary.FACING)==facing,"Old NBT keeps orientation and anchor and defaults original Y");var b=SculptureGeometry.shape(STATUE,facing,anchor,restored.getValue(Statuary.HEIGHT)).bounds();check(b.minY==2/16d&&b.maxY==10/16d,"Legacy vertical padding is preserved exactly");n++;
+        }System.out.println("SCULPTURE125_LEGACY_PASS "+n+" old blockstates retain exact placements without rewriting payloads");
+    }
+    private static void renderBounds(StatuaryEntity entity){var renderer=new StatuaryRenderer();var render=renderer.createRenderState();renderer.extractRenderState(entity,render,0,Vec3.ZERO,null);double x0=1,y0=1,z0=1,x1=0,y1=0,z1=0;for(var q:render.mesh){x0=Math.min(x0,q.x());y0=Math.min(y0,q.y());z0=Math.min(z0,q.z());x1=Math.max(x1,q.x()+1/16d);y1=Math.max(y1,q.y()+1/16d);z1=Math.max(z1,q.z()+1/16d);}var bounds=entity.shape(entity.getBlockState()).bounds();check(bounds.equals(new AABB(x0,y0,z0,x1,y1,z1)),"Native single box follows actual rendered offsets on all three axes");Sculpture113ClientChecks.rendered(entity);}
+    private static void place(ServerLevel level,BlockPos pos,BlockState state){level.setBlockAndUpdate(pos,state);var e=(StatuaryEntity)level.getBlockEntity(pos);var data=new CompoundTag();data.put("sculpture",StatuaryEntity.encode(STATUE));e.loadWithComponents(TagValueInput.create(ProblemReporter.DISCARDING,level.registryAccess(),data));e.setChanged();level.sendBlockUpdated(pos,state,state,3);}
+    private static VoxelSculpture statue(){var cells=new ArrayList<VoxelSculpture.Cell>();for(int y=2;y<10;y++)for(int x=y<6?2:1;x<=(y<6?4:5);x++)for(int z=y<6?1:0;z<=(y<6?3:4);z++)cells.add(new VoxelSculpture.Cell(x,y,z,y<6?0xff44aabb:0xffddb88b));return new VoxelSculpture(MODEL,"Placement statue",7,10,5,cells);}
+    private static ServerPlayer player(MinecraftServer s){return s.getPlayerList().getPlayers().getFirst();}
+    private static void check(boolean ok,String reason){if(!ok)throw new AssertionError(reason);}
+}

mods/sanctuary/src/clientGametest/java/fr/koka/sanctuary/client/Sculpture125ParticleChecks.java

@@ -0,0 +1,36 @@
+package fr.koka.sanctuary.client;
+
+import fr.koka.sanctuary.plans.*;
+import java.lang.reflect.Field;
+import java.util.*;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.particle.*;
+import net.minecraft.core.*;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.phys.*;
+
+final class Sculpture125ParticleChecks {
+    static void exercise(Minecraft mc,BlockPos pos){
+        var entity=(StatuaryEntity)mc.level.getBlockEntity(pos);var state=entity.getBlockState();
+        var render=new StatuaryRenderer();var rs=render.createRenderState();render.extractRenderState(entity,rs,0,Vec3.ZERO,null);
+        Set<Integer> colors=new HashSet<>();for(var q:rs.mesh)colors.add(q.color());
+        var queue=queue(mc);queue.clear();var q=rs.mesh.getLast();var hit=Vec3.atLowerCornerOf(pos).add(SculptureParticles.center(q));
+        mc.hitResult=new BlockHitResult(hit,Direction.UP,pos,false);mc.level.addBreakingBlockEffects(pos,Direction.UP,false);
+        check(queue.size()==1&&queue.peek() instanceof SculptureParticles.Fragment,"Native hit emits one voxel chip, no clay debris");
+        var chip=(SingleQuadParticle)queue.peek();check(color(chip)==q.color(),"Hit chip uses the exact targeted voxel color");
+        queue.clear();mc.level.addDestroyBlockEffect(pos,state);verify(queue,rs.mesh,colors,pos);int count=queue.size();
+        queue.clear();mc.level.setBlock(pos,Blocks.AIR.defaultBlockState(),3);check(mc.level.getBlockEntity(pos)==null,"Native block update removes sculpture before break effect");
+        mc.level.addDestroyBlockEffect(pos,state);verify(queue,rs.mesh,colors,pos);check(queue.size()==count,"Late break event retains voxel colors and offsets");
+        queue.clear();mc.level.addDestroyBlockEffect(pos,Blocks.STONE.defaultBlockState());check(!queue.isEmpty()&&queue.stream().noneMatch(SculptureParticles.Fragment.class::isInstance),"Other blocks retain native particles");queue.clear();
+        System.out.println("SCULPTURE125_PARTICLES_PASS native hit/destroy hooks, exact voxel colors, real surface origins, 64-chip bound, late removal and ordinary block regression");
+    }
+    private static void verify(Queue<Particle> queue,List<StatuaryRenderer.Quad> mesh,Set<Integer> colors,BlockPos pos){
+        check(!queue.isEmpty()&&queue.size()<=64,"Bounded destruction particles");var observed=new HashSet<Integer>();
+        for(var p:queue){check(p instanceof SculptureParticles.Fragment,"No clay fallback particles");int color=color((SingleQuadParticle)p);observed.add(color);check(colors.contains(color),"Particle retains an actual model color");var point=new Vec3(number(p,"x"),number(p,"y"),number(p,"z")).subtract(Vec3.atLowerCornerOf(pos));check(mesh.stream().anyMatch(q->q.color()==color&&SculptureParticles.center(q).equals(point)),"Particle belongs to an actual colored voxel face after rotation/anchor");check(((SingleQuadParticle)p).getQuadSize(0)==1/32f,"One voxel diameter, no oversized clay chips");}
+        check(observed.size()==colors.size(),"Both fixture material colors occur in destruction chips");
+    }
+    @SuppressWarnings("unchecked") private static Queue<Particle> queue(Minecraft mc){try{var f=ParticleEngine.class.getDeclaredField("particlesToAdd");f.setAccessible(true);return (Queue<Particle>)f.get(mc.particleEngine);}catch(Exception e){throw new AssertionError(e);}}
+    private static double number(Object value,String name){try{Class<?> type=value.getClass();Field f=null;while(type!=null){try{f=type.getDeclaredField(name);break;}catch(NoSuchFieldException ignored){type=type.getSuperclass();}}f.setAccessible(true);return ((Number)f.get(value)).doubleValue();}catch(Exception e){throw new AssertionError(e);}}
+    private static int color(SingleQuadParticle p){return 0xff000000|Math.round((float)number(p,"rCol")*255)<<16|Math.round((float)number(p,"gCol")*255)<<8|Math.round((float)number(p,"bCol")*255);}
+    private static void check(boolean ok,String reason){if(!ok)throw new AssertionError(reason);}
+}

mods/sanctuary/src/clientGametest/java/fr/koka/sanctuary/client/Sculpture125WorkshopChecks.java

@@ -0,0 +1,53 @@
+package fr.koka.sanctuary.client;
+
+import fr.koka.sanctuary.companion.CompanionService;
+import fr.koka.sanctuary.plans.*;
+import java.nio.file.*;
+import java.util.*;
+import net.fabricmc.fabric.api.client.gametest.v1.context.*;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.input.KeyEvent;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.stats.Stats;
+import net.minecraft.world.entity.EntityTypes;
+import net.minecraft.world.inventory.ContainerInput;
+import net.minecraft.world.item.*;
+import net.minecraft.world.level.GameType;
+
+final class Sculpture125WorkshopChecks {
+    static void exercise(ClientGameTestContext c,TestServerContext server){
+        var pos=new BlockPos(4,1,4);
+        server.runOnServer(s->{var p=s.getPlayerList().getPlayers().getFirst();p.teleportTo(3,1,3);p.setGameMode(GameType.SURVIVAL);p.getAbilities().invulnerable=true;p.onUpdateAbilities();p.level().setBlockAndUpdate(pos,Statuary.WORKSHOP.defaultBlockState());
+            CompanionService.save(p,CompanionService.record(p).note("seen_mobs",""));Statuary.open(p,pos);
+        });
+        c.waitForScreen(ClayWorkshopScreen.class);
+        c.runOnClient(m->{var menu=(ClayWorkshopMenu)m.player.containerMenu;check(!menu.view.statues().contains("minecraft:cow"),"Unseen cow is absent without visiting Metabli");var screen=(ClayWorkshopScreen)m.gui.screen();screen.load(EntityTypes.COW);check(screen.selected()==null&&!screen.busy(),"Unseen animal cannot start local generation");});
+        server.runOnServer(s->{var p=s.getPlayerList().getPlayers().getFirst();var menu=(ClayWorkshopMenu)p.containerMenu;menu.getSlot(0).set(new ItemStack(Items.OAK_PLANKS,2));var locked=new VoxelSculpture(StatueDiscoveries.modelId("minecraft:cow"),"Cow",1,1,1,List.of(new VoxelSculpture.Cell(0,0,0,-1)));menu.select(p,locked,Items.OAK_PLANKS,new SculpturePalette(List.of(-1)));check(menu.getSlot(1).getItem().isEmpty(),"Server rejects a locked animal model despite valid material");p.closeContainer();
+            CompanionService.save(p,CompanionService.record(p).note("seen_mobs","cow"));p.awardStat(Stats.ENTITY_KILLED.get(EntityTypes.SHEEP));p.awardStat(Stats.ENTITY_KILLED_BY.get(EntityTypes.PIG));
+        });
+        c.waitFor(m->m.gui.screen()==null,100);
+        server.runOnServer(s->{var p=s.getPlayerList().getPlayers().getFirst();Statuary.open(p,pos);var menu=(ClayWorkshopMenu)p.containerMenu;check(menu.view.statues().equals(StatueDiscoveries.known(p)),"Workshop uses the exact statue catalogue discoveries");menu.getSlot(0).set(new ItemStack(Items.OAK_PLANKS,4));menu.broadcastChanges();});
+        c.waitForScreen(ClayWorkshopScreen.class);
+        c.runOnClient(m->{m.options.guiScale().set(2);m.getWindow().setWindowed(1280,800);m.resizeGui();var menu=(ClayWorkshopMenu)m.player.containerMenu;check(menu.view.statues().containsAll(List.of("minecraft:cow","minecraft:sheep","minecraft:pig")),"Encounter, kill and killed-by unlocks are transmitted");});
+        for(var type:List.of(EntityTypes.COW,EntityTypes.SHEEP,EntityTypes.PIG)){
+            String model=StatueDiscoveries.modelId(BuiltInRegistries.ENTITY_TYPE.getKey(type).toString());
+            c.runOnClient(m->{var screen=(ClayWorkshopScreen)m.gui.screen();screen.children().stream().filter(Button.class::isInstance).map(Button.class::cast).filter(b->b.getMessage().getString().equals(type.getDescription().getString())).findFirst().orElseThrow().onPress(new KeyEvent(257,0,0));});
+            c.waitTicks(10);c.runOnClient(m->{var screen=(ClayWorkshopScreen)m.gui.screen();System.out.println("SCULPTURE125_WORKSHOP_DEBUG "+type+" busy "+screen.busy()+" source "+(screen.selected()==null?"null":screen.selected().modelId())+" input "+m.player.containerMenu.getSlot(0).getItem()+" output "+m.player.containerMenu.getSlot(1).getItem());});
+            c.waitFor(m->{var screen=(ClayWorkshopScreen)m.gui.screen();return !screen.busy()&&screen.selected()!=null&&screen.selected().modelId().equals(model)&&m.player.containerMenu.getSlot(1).getItem().is(Statuary.ITEM)&&StatuaryEntity.sculpture(m.player.containerMenu.getSlot(1).getItem()).modelId().equals(model);},250);
+            c.runOnClient(m->{var screen=(ClayWorkshopScreen)m.gui.screen();var source=screen.selected();check(source.cells().size()>20&&Math.max(source.width(),Math.max(source.height(),source.depth()))==16,"Native animal model voxelized at miniature scale");check(ItemStack.matches(screen.preview(),m.player.containerMenu.getSlot(1).getItem()),"Animal preview equals server-paid palette result");});
+            c.takeScreenshot("sculpture125-workshop-"+BuiltInRegistries.ENTITY_TYPE.getKey(type).getPath());
+        }
+        c.runOnClient(m->m.gameMode.handleContainerInput(m.player.containerMenu.containerId,1,0,ContainerInput.PICKUP,m.player));
+        c.waitFor(m->m.player.containerMenu.getCarried().is(Statuary.ITEM)&&m.player.containerMenu.getSlot(0).getItem().getCount()==3,100);
+        server.waitFor(s->{var menu=s.getPlayerList().getPlayers().getFirst().containerMenu;return menu.getCarried().is(Statuary.ITEM)&&menu.getSlot(0).getItem().getCount()==3;},100);
+        server.runOnServer(s->{var p=s.getPlayerList().getPlayers().getFirst();check(p.containerMenu.getSlot(0).getItem().getCount()==3&&p.containerMenu.getCarried().is(Statuary.ITEM),"Exactly one block consumed for native animal sculpture in survival");});
+        Path file=PlanClient.directory().resolve("sculpture125-"+UUID.randomUUID()+".glb");
+        try{Files.createDirectories(file.getParent());Files.write(file,Statuary106ClientChecks.fixture(true));c.runOnClient(m->{var screen=(ClayWorkshopScreen)m.gui.screen();screen.children().stream().filter(Button.class::isInstance).map(Button.class::cast).filter(b->b.getMessage().getString().equals(ClayWorkshopScreen.text("imports").getString())).findFirst().orElseThrow().onPress(new KeyEvent(257,0,0));screen.load(file);});
+            var id=GlbModel.load(file).id();c.waitFor(m->{var screen=(ClayWorkshopScreen)m.gui.screen();return !screen.busy()&&screen.selected()!=null&&screen.selected().modelId().equals(id)&&id.equals(Optional.ofNullable(StatuaryEntity.sculpture(m.player.containerMenu.getSlot(1).getItem())).map(VoxelSculpture::modelId).orElse(""));},250);c.takeScreenshot("sculpture125-workshop-import");
+        }catch(Exception e){throw new AssertionError(e);}finally{try{Files.deleteIfExists(file);}catch(Exception ignored){}}
+        server.runOnServer(s->{var p=s.getPlayerList().getPlayers().getFirst();p.closeContainer();p.setGameMode(GameType.CREATIVE);p.getAbilities().flying=true;p.onUpdateAbilities();});c.waitFor(m->m.gui.screen()==null,100);
+        System.out.println("SCULPTURE125_WORKSHOP_PASS encounter/kill/death unlocks, native menu sync, locked server rejection, three textured animals, paid survival craft and GLB import");
+    }
+    private static void check(boolean ok,String reason){if(!ok)throw new AssertionError(reason);}
+}

mods/sanctuary/src/clientGametest/java/fr/koka/sanctuary/client/SculptureHat117Checks.java

@@ -0,0 +1,50 @@
+package fr.koka.sanctuary.client;
+
+import fr.koka.sanctuary.cosmetics.*;
+import fr.koka.sanctuary.inventory.*;
+import fr.koka.sanctuary.plans.*;
+import net.fabricmc.fabric.api.client.gametest.v1.context.*;
+import net.minecraft.client.gui.screens.inventory.InventoryScreen;
+import net.minecraft.core.component.DataComponents;
+import net.minecraft.network.chat.Component;
+import net.minecraft.world.inventory.ContainerInput;
+import net.minecraft.world.item.ItemStack;
+
+/** Actual accessory-slot transfers and recovery from a saved beta.116 head session. */
+final class SculptureHat117Checks {
+    static ItemStack exercise(ClientGameTestContext c,TestServerContext server,VoxelSculpture sculpture){
+        var original=StatuaryEntity.item(sculpture);original.set(DataComponents.CUSTOM_NAME,Component.literal("Sculpture chapeau 117"));
+        c.runOnClient(m->m.gui.screen().onClose());
+        server.waitFor(s->{var p=s.getPlayerList().getPlayers().getFirst();return p.containerMenu==p.inventoryMenu;},100);
+        server.runOnServer(s->{var p=s.getPlayerList().getPlayers().getFirst();p.getInventory().clearContent();p.getInventory().setItem(0,original.copy());p.inventoryMenu.broadcastFullState();});
+        c.waitFor(m->ItemStack.matches(m.player.inventoryMenu.getSlot(36).getItem(),original),100);
+        c.runOnClient(m->m.gui.setScreen(new InventoryScreen(m.player)));
+        click(c,36);c.waitFor(m->m.player.inventoryMenu.getCarried().is(Statuary.ITEM),100);
+        click(c,66);c.waitTicks(12);verifyEquipped(c,server,original);
+        c.takeScreenshot("sculpture117-hat-inventory");
+        click(c,66);c.waitFor(m->m.player.inventoryMenu.getCarried().is(Statuary.ITEM),100);
+        click(c,36);
+        server.waitFor(s->{var p=s.getPlayerList().getPlayers().getFirst();return p.inventoryMenu.getCarried().isEmpty()&&HeadEquipment.get(p).isEmpty()&&ItemStack.matches(p.getInventory().getItem(0),original);},100);
+        c.waitFor(m->ItemStack.matches(m.player.inventoryMenu.getSlot(36).getItem(),original)&&m.player.inventoryMenu.getSlot(66).getItem().isEmpty(),100);
+        c.runOnClient(m->check(!new StatuaryRenderer.ItemRenderer().extractArgument(m.player.inventoryMenu.getSlot(36).getItem()).isEmpty(),"Returned sculpture still renders in hotbar"));
+        click(c,36);click(c,66);c.waitTicks(8);verifyEquipped(c,server,original);
+        server.runOnServer(s->{
+            var p=s.getPlayerList().getPlayers().getFirst();var saved=HeadBlockService.save(p);check(saved!=null,"Authoritative worn model is saved");
+            var damaged=original.copy();damaged.remove(DataComponents.BLOCK_ENTITY_DATA);
+            AccessoryAccess.of(p).setItem(AccessoryContainer.HEAD,damaged);HeadEquipment.retainData(p,saved);
+            HeadBlockService.session(p);p.inventoryMenu.broadcastChanges();
+            check(ItemStack.matches(HeadEquipment.get(p),original),"Recover already stripped sculpture from its saved worn model");
+        });
+        c.waitTicks(8);verifyEquipped(c,server,original);
+        c.runOnClient(m->m.gui.screen().onClose());
+        System.out.println("SCULPTURE117_HAT_PASS native equip/remove/re-equip, slot mesh, exact components and old worn-session recovery");
+        return original;
+    }
+    static void verifyEquipped(ClientGameTestContext c,TestServerContext server,ItemStack original){
+        server.runOnServer(s->{var p=s.getPlayerList().getPlayers().getFirst();check(ItemStack.matches(HeadEquipment.get(p),original),"Equipped stack retains its geometry and name");check(p.getInventory().getItem(0).isEmpty()&&p.inventoryMenu.getCarried().isEmpty(),"Exactly one sculpture moved into head slot");});
+        c.waitFor(m->ItemStack.matches(m.player.inventoryMenu.getSlot(66).getItem(),original)&&StatuaryEntity.sculpture(original).equals(StatuaryEntity.sculpture(HeadCosmeticService.appearance(m.player))),150);
+        c.runOnClient(m->check(!new StatuaryRenderer.ItemRenderer().extractArgument(m.player.inventoryMenu.getSlot(66).getItem()).isEmpty(),"Equipped slot retains visible item geometry"));
+    }
+    private static void click(ClientGameTestContext c,int slot){c.runOnClient(m->m.gameMode.handleContainerInput(m.player.inventoryMenu.containerId,slot,0,ContainerInput.PICKUP,m.player));}
+    private static void check(boolean ok,String message){if(!ok)throw new AssertionError(message);}
+}

mods/sanctuary/src/clientGametest/java/fr/koka/sanctuary/client/Statuary106ClientChecks.java

@@ -46,8 +46,8 @@ public final class Statuary106ClientChecks implements FabricClientGameTest {
         net.fabricmc.fabric.api.client.gametest.v1.world.TestWorldSave saved;
         try{
             System.out.println("STATUARY106_LIBRARY "+file);Files.createDirectories(file.getParent());byte[] fixture=fixture();Files.write(file,fixture);
-            var asset=GlbModel.load(file);var pixels=StatueVoxelizer.miniature(asset.faces());var source=VoxelSculpture.of(asset.id(),asset.name(),pixels);
-            MODEL.set(source.modelId());check(source.height()==16&&source.width()<16,"Proportions, 16 voxel longest axis");check(source.cells().stream().map(VoxelSculpture.Cell::color).distinct().count()>1,"Embedded PNG retains multiple colors");
+            var asset=GlbModel.load(file);var pixels=StatueVoxelizer.miniature(asset.faces());var originalSource=VoxelSculpture.of(asset.id(),asset.name(),pixels);
+            MODEL.set(originalSource.modelId());check(originalSource.height()==16&&originalSource.width()<16,"Proportions, 16 voxel longest axis");check(originalSource.cells().stream().map(VoxelSculpture.Cell::color).distinct().count()>1,"Embedded PNG retains multiple colors");
             check(CreationLibrary.files(CreationLibrary.Kind.MODEL).contains(file)&&!CreationLibrary.files(CreationLibrary.Kind.SCHEMATIC).contains(file),"One folder, different filters");
             var invalid=fixture.clone();ByteBuffer.wrap(invalid).order(ByteOrder.LITTLE_ENDIAN).putInt(8,1);reject(invalid,"GLB header length");
             var oversize=new byte[GlbModel.MAX_BYTES+1];reject(oversize,"File bound");
@@ -57,19 +57,22 @@ public final class Statuary106ClientChecks implements FabricClientGameTest {
             reject(edit(fixture,j->{var a=new JsonArray();a.add(0);j.getAsJsonArray("nodes").get(0).getAsJsonObject().add("children",a);}),"Cyclic scene");
             var interop=net.fabricmc.loader.api.FabricLoader.getInstance().getGameDir().resolve("../../../../../build/statuary106-evidence/BoxTextured.glb").normalize();
             if(Files.exists(interop)){var box=GlbModel.read(interop);check(box.size()==12,"Independent Khronos indexed GLB");check(!StatueVoxelizer.miniature(box).isEmpty(),"Independent textured box voxelizes");System.out.println("STATUARY106_INTEROP_PASS Khronos BoxTextured GLB");}
-            check(source.rotate().rotate().rotate().rotate().equals(source),"Four rotations preserve ID and data");
-            try{new VoxelSculpture(source.modelId(),"bad",16,16,16,List.of(new VoxelSculpture.Cell(0,0,0,-1),new VoxelSculpture.Cell(0,0,0,-1)));throw new AssertionError("Duplicate cell accepted");}catch(IllegalArgumentException expected){}
+            check(originalSource.rotate().rotate().rotate().rotate().equals(originalSource),"Four rotations preserve ID and data");
+            try{new VoxelSculpture(originalSource.modelId(),"bad",16,16,16,List.of(new VoxelSculpture.Cell(0,0,0,-1),new VoxelSculpture.Cell(0,0,0,-1)));throw new AssertionError("Duplicate cell accepted");}catch(IllegalArgumentException expected){}
             try(var world=c.worldBuilder().adjustSettings(s->{s.setName("Statuary106 "+UUID.randomUUID());s.setSeed("106");s.setAllowCommands(true);s.setGameMode(WorldCreationUiState.SelectedGameMode.CREATIVE);
                 s.setWorldType(s.getNormalPresetList().stream().filter(e->e.preset()!=null&&e.preset().getRegisteredName().equals("sanctuary_test:flat")).findFirst().orElseThrow());}).create()){
                 saved=world.getWorldSave();c.waitFor(m->ProgressionClient.active()&&m.player!=null&&m.gui.screen()==null&&!IntroSpawnFlash.active(),1200);
+                var source=originalSource;
                 var server=world.getServer();
                 server.runOnServer(s->{var p=player(s);p.teleportTo(.5,1,.5);p.getInventory().clearContent();p.setGameMode(GameType.SURVIVAL);for(int x=-7;x<=9;x++)for(int z=-5;z<=9;z++)p.level().setBlockAndUpdate(new BlockPos(x,0,z),Blocks.STONE.defaultBlockState());p.level().setBlockAndUpdate(WORKSHOP,Statuary.WORKSHOP.defaultBlockState());
                     var legacy=net.minecraft.nbt.NbtUtils.writeBlockState(Statuary.BLOCK.defaultBlockState());legacy.remove("properties");
                     check(net.minecraft.nbt.NbtUtils.readBlockState(net.minecraft.core.registries.BuiltInRegistries.BLOCK,legacy).getValue(Statuary.FACING)==Direction.SOUTH,"Legacy state defaults to unchanged model orientation");
+                    check(net.minecraft.nbt.NbtUtils.readBlockState(net.minecraft.core.registries.BuiltInRegistries.BLOCK,legacy).getValue(Statuary.ANCHOR)==SculptureAnchor.CENTER,"Legacy state keeps centered anchor");
+                    Sculpture113ClientChecks.placementContexts(p);
                     for(var q:Metatable.members(TABLE))p.level().setBlockAndUpdate(q,Blocks.CRAFTING_TABLE.defaultBlockState());check(Metatable.assemble(p,TABLE),"Metabli");
                     s.getCommands().performPrefixedCommand(s.createCommandSourceStack(),"sanctuary time vanilla");s.getCommands().performPrefixedCommand(s.createCommandSourceStack(),"time set noon");});
                 c.waitFor(m->m.level.getBlockState(WORKSHOP).is(Statuary.WORKSHOP)&&!m.player.isCreative(),200);
-                c.runOnClient(m->{m.options.guiScale().set(2);m.getWindow().setWindowed(1280,800);m.resizeGui();});
+                c.runOnClient(m->{m.options.guiScale().set(2);m.getWindow().setWindowed(1280,800);m.resizeGui();Sculpture113ClientChecks.geometry(m,source.modelId());});
                 open(c);c.runOnClient(m->((ClayWorkshopScreen)m.gui.screen()).onFilesDrop(List.of(file)));
                 c.waitFor(m->!((ClayWorkshopScreen)m.gui.screen()).busy()&&((ClayWorkshopScreen)m.gui.screen()).selected()!=null,200);c.waitTicks(10);
                 server.runOnServer(s->{var p=player(s);var menu=(ClayWorkshopMenu)p.containerMenu;check(menu.getSlot(1).getItem().isEmpty(),"No clay, no result");
@@ -79,6 +82,7 @@ public final class Statuary106ClientChecks implements FabricClientGameTest {
                 c.waitFor(m->m.player.containerMenu.getSlot(ClayWorkshopMenu.HOTBAR_START).getItem().getCount()==3,100);
                 c.runOnClient(m->m.gameMode.handleContainerInput(m.player.containerMenu.containerId,ClayWorkshopMenu.HOTBAR_START,0,ContainerInput.QUICK_MOVE,m.player));
                 c.waitFor(m->m.player.containerMenu.getSlot(1).getItem().is(Statuary.ITEM),100);
+                c.runOnClient(m->check(m.player.containerMenu.getSlot(1).getItem().getHoverName().getString().equals("Sculpture"),"Crafted sculpture has translated type name EN"));
                 c.takeScreenshot("statuary106-workshop-en");
                 checkWorkshopLayout(c);
                 c.runOnClient(m->{m.options.guiScale().set(3);m.resizeGui();});c.waitTicks(3);checkWorkshopLayout(c);c.takeScreenshot("statuary111-workshop-en-scale3");
@@ -94,8 +98,9 @@ public final class Statuary106ClientChecks implements FabricClientGameTest {
                     p.getInventory().setItem(18,ItemStack.EMPTY);p.getInventory().setItem(Inventory.SLOT_OFFHAND,ItemStack.EMPTY);fr.koka.sanctuary.inventory.SanctuaryOverflowAccess.of(p).setItem(17,ItemStack.EMPTY);
                 });
                 c.runOnClient(m->{m.options.guiScale().set(2);m.resizeGui();});
-                server.runOnServer(s->{var menu=(ClayWorkshopMenu)player(s).containerMenu;ORIGINAL.set(StatuaryEntity.sculpture(menu.getSlot(1).getItem()));check(ORIGINAL.get().equals(source),"Plain clay keeps exact colors and model ID");
-                    for(var family:ColoredBricks.families()){var colored=ClayWorkshopMenu.material(source,new ItemStack(family.clay()));check(colored.modelId().equals(source.modelId())&&colored.cells().size()==source.cells().size()&&colored.cells().stream().map(VoxelSculpture.Cell::color).distinct().count()==1,"All 16 clays keep geometry and ID, recolor uniformly");}});
+                server.runOnServer(s->{var menu=(ClayWorkshopMenu)player(s).containerMenu;ORIGINAL.set(StatuaryEntity.sculpture(menu.getSlot(1).getItem()));check(ORIGINAL.get().equals(source),"Plain clay applies its sampled palette and preserves model ID");
+                });
+                c.runOnClient(m->{for(var family:ColoredBricks.families()){var palette=SculptureMaterialSampler.sample(new ItemStack(family.clay()));var colored=palette.apply(originalSource);check(colored.modelId().equals(source.modelId())&&colored.cells().size()==source.cells().size()&&colored.cells().stream().allMatch(cell->palette.colors().contains(cell.color())),"All 16 clays keep geometry and use actual texture shades");}});
                 c.runOnClient(m->m.gameMode.handleContainerInput(m.player.containerMenu.containerId,1,0,ContainerInput.PICKUP,m.player));
                 c.waitFor(m->m.player.containerMenu.getCarried().is(Statuary.ITEM),100);
                 c.waitTicks(6);
@@ -116,15 +121,22 @@ public final class Statuary106ClientChecks implements FabricClientGameTest {
                     server.runOnServer(s->{var p=player(s);p.teleportTo(px,1,pz);p.getInventory().setItem(p.getInventory().getSelectedSlot(),StatuaryEntity.item(source));p.inventoryMenu.broadcastFullState();});
                     c.waitFor(m->m.player.distanceToSqr(px,1,pz)<.05&&m.player.getMainHandItem().is(Statuary.ITEM),150);place(c,pos);
                     server.waitFor(s->player(s).level().getBlockState(pos).is(Statuary.BLOCK),100);
+                    server.runOnServer(s->{var state=player(s).level().getBlockState(pos);check(state.getValue(Statuary.FACING)==direction&&state.getValue(Statuary.ANCHOR)==SculptureAnchor.CENTER,"Native center placement follows gaze on server");});
+                    c.waitFor(m->m.level.getBlockEntity(pos) instanceof StatuaryEntity e&&source.equals(e.sculpture())&&e.getBlockState().getValue(Statuary.ANCHOR)==SculptureAnchor.CENTER,100);
+                    c.runOnClient(m->Sculpture113ClientChecks.rendered((StatuaryEntity)m.level.getBlockEntity(pos)));
+                    c.takeScreenshot("sculpture119-center-"+direction.getSerializedName());
+                    server.runOnServer(s->{var p=player(s);p.level().removeBlock(pos,false);p.getInventory().setItem(p.getInventory().getSelectedSlot(),StatuaryEntity.item(source));p.inventoryMenu.broadcastFullState();});
+                    c.waitFor(m->m.level.getBlockState(pos).isAir()&&m.player.getMainHandItem().is(Statuary.ITEM),100);place(c,pos,direction.getOpposite());
+                    server.waitFor(s->player(s).level().getBlockState(pos).is(Statuary.BLOCK),100);
                     server.runOnServer(s->{var state=player(s).level().getBlockState(pos);check(state.getValue(Statuary.FACING)==direction,"Native placement faces gaze: "+direction);
+                        check(state.getValue(Statuary.ANCHOR)==SculptureAnchor.of(direction.getOpposite()),"Aimed edge stored on server");
                         check(state.rotate(net.minecraft.world.level.block.Rotation.CLOCKWISE_90).getValue(Statuary.FACING)==direction.getClockWise(),"Structure rotation follows native directions");
                         check(state.mirror(net.minecraft.world.level.block.Mirror.LEFT_RIGHT).getValue(Statuary.FACING)==(direction.getAxis()==Direction.Axis.Z?direction.getOpposite():direction),"Structure mirror follows native directions");
                         check(((StatuaryEntity)player(s).level().getBlockEntity(pos)).sculpture().equals(source),"Placement never rewrites model voxels");});
                     c.waitFor(m->m.level.getBlockEntity(pos) instanceof StatuaryEntity e&&source.equals(e.sculpture()),100);
                     c.runOnClient(m->{var entity=(StatuaryEntity)m.level.getBlockEntity(pos);check(entity.getBlockState().getValue(Statuary.FACING)==direction,"Client receives direction");
-                        var renderer=new StatuaryRenderer();var state=renderer.createRenderState();renderer.extractRenderState(entity,state,0,Vec3.ZERO,null);
-                        var forward=new org.joml.Vector3f(0,0,1).rotate(com.mojang.math.Axis.YP.rotationDegrees(state.yaw));
-                        check(Math.abs(forward.x()-direction.getStepX())<.001&&Math.abs(forward.z()-direction.getStepZ())<.001,"Rendered model faces gaze: "+direction);});
+                        check(entity.getBlockState().getValue(Statuary.ANCHOR)==SculptureAnchor.of(direction.getOpposite()),"Client receives aimed edge");
+                        Sculpture113ClientChecks.rendered(entity);});
                     c.takeScreenshot("statuary111-facing-"+direction.getSerializedName());
                 }
                 // Re-place a dropped north-facing model while looking west: no baked or cumulative turn.
@@ -133,17 +145,18 @@ public final class Statuary106ClientChecks implements FabricClientGameTest {
                     var drop=p.level().getEntitiesOfClass(ItemEntity.class,new AABB(north).inflate(1)).stream().filter(e->e.getItem().is(Statuary.ITEM)).findFirst().orElseThrow();
                     check(source.equals(StatuaryEntity.sculpture(drop.getItem())),"Direction does not alter dropped item");
                     p.getInventory().setItem(p.getInventory().getSelectedSlot(),drop.getItem().copy());drop.discard();p.teleportTo(west.getX()+2.5,1,west.getZ()+.5);p.inventoryMenu.broadcastFullState();});
-                c.waitFor(m->m.player.distanceToSqr(west.getX()+2.5,1,west.getZ()+.5)<.05&&m.player.getMainHandItem().is(Statuary.ITEM)&&m.level.getBlockState(west).isAir(),100);place(c,west);
+                c.waitFor(m->m.player.distanceToSqr(west.getX()+2.5,1,west.getZ()+.5)<.05&&m.player.getMainHandItem().is(Statuary.ITEM)&&m.level.getBlockState(west).isAir(),100);place(c,west,Direction.EAST);
                 server.waitFor(s->player(s).level().getBlockState(west).is(Statuary.BLOCK),100);
                 server.runOnServer(s->check(player(s).level().getBlockState(west).getValue(Statuary.FACING)==Direction.WEST,"Dropped statue takes new gaze"));
                 server.runOnServer(s->player(s).teleportTo(.5,1,.5));c.waitFor(m->m.player.distanceToSqr(.5,1,.5)<.05,100);
-                // Reuse the same file with colored clay; server, rather than the client, chooses the tint.
+                // Reuse the file with colored clay; server applies the palette bound to that actual material.
                 server.runOnServer(s->player(s).getInventory().setItem(player(s).getInventory().getSelectedSlot(),ItemStack.EMPTY));c.waitTicks(4);open(c);
                 c.runOnClient(m->((ClayWorkshopScreen)m.gui.screen()).load(file));c.waitFor(m->!((ClayWorkshopScreen)m.gui.screen()).busy()&&((ClayWorkshopScreen)m.gui.screen()).selected()!=null,200);c.waitTicks(10);
                 server.runOnServer(s->{var menu=(ClayWorkshopMenu)player(s).containerMenu;var blue=ColoredBricks.families().stream().filter(f->f.color()==DyeColor.BLUE).findFirst().orElseThrow();menu.getSlot(0).set(new ItemStack(blue.clay(),2));menu.broadcastChanges();});
-                c.waitFor(m->m.player.containerMenu.getSlot(1).getItem().is(Statuary.ITEM),100);language(c,"fr_fr");c.takeScreenshot("statuary106-workshop-fr-blue");
+                c.waitFor(m->m.player.containerMenu.getSlot(1).getItem().is(Statuary.ITEM),100);language(c,"fr_fr");c.runOnClient(m->check(m.player.containerMenu.getSlot(1).getItem().getHoverName().getString().equals("Sculpture"),"Crafted sculpture has translated type name FR"));c.takeScreenshot("statuary106-workshop-fr-blue");
                 checkWorkshopLayout(c);
-                server.runOnServer(s->{var menu=(ClayWorkshopMenu)player(s).containerMenu;var blue=StatuaryEntity.sculpture(menu.getSlot(1).getItem());check(blue.modelId().equals(MODEL.get())&&blue.cells().stream().allMatch(v->v.color()==0xFFA0A7BC),"Blue input overrides uploaded model colors");});
+                var expectedBlue=c.computeOnClient(m->SculptureMaterialSampler.sample(new ItemStack(ColoredBricks.families().stream().filter(f->f.color()==DyeColor.BLUE).findFirst().orElseThrow().clay())).apply(originalSource));
+                server.runOnServer(s->{var menu=(ClayWorkshopMenu)player(s).containerMenu;var blue=StatuaryEntity.sculpture(menu.getSlot(1).getItem());check(blue.equals(expectedBlue),"Blue input uses sampled palette and model shading");});
                 c.runOnClient(m->m.gameMode.handleContainerInput(m.player.containerMenu.containerId,1,0,ContainerInput.QUICK_MOVE,m.player));c.waitTicks(10);
                 server.runOnServer(s->{var p=player(s);check(p.containerMenu.getSlot(0).getItem().isEmpty(),"Shift crafting consumes stock");check(count(p,Statuary.ITEM)==2,"Shift crafting produces exactly paid quantity");});close(c);
                 // At the Metabli, the same source creates a full-sized construction plan, with no placement in survival.
@@ -180,13 +193,17 @@ public final class Statuary106ClientChecks implements FabricClientGameTest {
                 for(var direction:List.of(Direction.SOUTH,Direction.EAST,Direction.WEST)){
                     var pos=DIRECTIONS.get(direction);
                     server.runOnServer(s->check(player(s).level().getBlockState(pos).getValue(Statuary.FACING)==direction&&((StatuaryEntity)player(s).level().getBlockEntity(pos)).sculpture().equals(ORIGINAL.get()),"Direction and model survive server save/reload"));
+                    server.runOnServer(s->check(player(s).level().getBlockState(pos).getValue(Statuary.ANCHOR)==SculptureAnchor.of(direction.getOpposite()),"Anchor survives server save/reload"));
                     c.waitFor(m->m.level.getBlockEntity(pos) instanceof StatuaryEntity e&&ORIGINAL.get().equals(e.sculpture())&&e.getBlockState().getValue(Statuary.FACING)==direction,150);
                 }
-                c.waitFor(m->m.level.getBlockEntity(SCULPTURE) instanceof StatuaryEntity e&&e.sculpture()!=null,150);c.runOnClient(m->check(((StatuaryEntity)m.level.getBlockEntity(SCULPTURE)).sculpture().equals(ORIGINAL.get()),"Fresh client receives server model without file"));
+                server.runOnServer(s->check(player(s).level().getBlockState(SCULPTURE).getValue(Statuary.ANCHOR)==SculptureAnchor.CENTER,"Centered placement survives server save/reload"));
+                c.waitFor(m->m.level.getBlockEntity(SCULPTURE) instanceof StatuaryEntity e&&e.sculpture()!=null,150);c.runOnClient(m->{check(((StatuaryEntity)m.level.getBlockEntity(SCULPTURE)).sculpture().equals(ORIGINAL.get()),"Fresh client receives server model without file");check(m.level.getBlockState(SCULPTURE).getValue(Statuary.ANCHOR)==SculptureAnchor.CENTER,"Fresh client receives centered anchor");});
                 c.getInput().lookAt(SCULPTURE);c.takeScreenshot("statuary106-reload-no-source");
             }
             System.out.println("STATUARY106_PASS GLB textured scene, bounded import, shared folder filters, native paid crafting, 16 clay colors, model ID, shift-click, place/drop/re-place, Metabli plan, cancellation, server save/reconnect without source");
             System.out.println("STATUARY111_PASS nine-slice GUI FR/EN scales 2/3, four native gaze placements, renderer directions, structure rotation/mirror, legacy state default, drop/re-place and persisted orientation");
+            System.out.println("STATUARY113_PASS clay sculpture FR/EN, native aimed edges, voxel grid across every footprint/orientation/anchor, side placement, legacy states, rotated/mirrored anchor, save/reconnect");
+            System.out.println("SCULPTURE119_PASS native centered placements in four directions, center/edge boundaries, odd/even voxel grid, side anchoring and center save/reconnect");
             System.out.println("STATUARY112_PASS fixed compact hotbar-only menu, native input transfer, hidden slots/offhand rejected, full hotbar no consumption, partial merge exact cost, closing restitution");
         }catch(IOException e){throw new AssertionError(e);}finally{try{Files.deleteIfExists(file);}catch(IOException ignored){}}
     }
@@ -200,8 +217,9 @@ public final class Statuary106ClientChecks implements FabricClientGameTest {
     });}
     private static void close(ClientGameTestContext c){c.runOnClient(m->m.gui.screen().onClose());c.waitFor(m->m.gui.screen()==null,100);}
     private static void open(ClientGameTestContext c){c.runOnClient(m->m.gameMode.useItemOn(m.player,InteractionHand.MAIN_HAND,new BlockHitResult(Vec3.atCenterOf(WORKSHOP),Direction.UP,WORKSHOP,false)));c.waitForScreen(ClayWorkshopScreen.class);}
-    private static void place(ClientGameTestContext c,BlockPos pos){
-        c.runOnClient(m->m.player.lookAt(net.minecraft.commands.arguments.EntityAnchorArgument.Anchor.EYES,new Vec3(pos.getX()+.5,pos.getY()-.001,pos.getZ()+.5)));c.waitTicks(3);
+    private static void place(ClientGameTestContext c,BlockPos pos){place(c,pos,null);}
+    private static void place(ClientGameTestContext c,BlockPos pos,Direction edge){
+        c.runOnClient(m->m.player.lookAt(net.minecraft.commands.arguments.EntityAnchorArgument.Anchor.EYES,new Vec3(pos.getX()+.5+(edge==null?0:edge.getStepX()*.4),pos.getY()-.001,pos.getZ()+.5+(edge==null?0:edge.getStepZ()*.4))));c.waitTicks(3);
         c.runOnClient(m->check(m.hitResult instanceof BlockHitResult hit&&hit.getBlockPos().equals(pos.below())&&hit.getDirection()==Direction.UP,"Native cursor targets support top face"));
         c.getInput().holdKey(o->o.keyUse);c.waitTicks(1);c.getInput().releaseKey(o->o.keyUse);
     }
@@ -218,14 +236,19 @@ public final class Statuary106ClientChecks implements FabricClientGameTest {
         byte[] text=json.toString().getBytes(java.nio.charset.StandardCharsets.UTF_8);int padded=(text.length+3)/4*4;byte[] binary=Arrays.copyOfRange(file,20+length,file.length);var out=ByteBuffer.allocate(20+padded+binary.length).order(ByteOrder.LITTLE_ENDIAN);out.putInt(0x46546C67).putInt(2).putInt(out.capacity()).putInt(padded).putInt(0x4E4F534A).put(text);while(out.position()<20+padded)out.put((byte)' ');out.put(binary);return out.array();
     }
     /** A tiny authored cat built from triangle boxes, embedded 2×2 texture and a translated scene node. */
-    private static byte[] fixture()throws IOException{
+    static byte[] fixture()throws IOException{
+        return fixture(false);
+    }
+    static byte[] fixture(boolean uniform)throws IOException{
         var xyz=new ArrayList<Float>();var uv=new ArrayList<Float>();
         for(float[] box:List.of(new float[]{.2f,0,.1f,.8f,1,.65f},new float[]{.1f,1,.05f,.9f,1.7f,.7f},new float[]{.1f,1.7f,.1f,.3f,2.1f,.5f},new float[]{.7f,1.7f,.1f,.9f,2.1f,.5f},new float[]{.75f,.1f,.2f,1.1f,.65f,.5f})){
             float x=box[0],y=box[1],z=box[2],X=box[3],Y=box[4],Z=box[5];float[][] v={{x,y,z},{X,y,z},{X,Y,z},{x,Y,z},{x,y,Z},{X,y,Z},{X,Y,Z},{x,Y,Z}};
             int[][] quads={{0,3,2,1},{5,6,7,4},{4,7,3,0},{1,2,6,5},{3,7,6,2},{4,0,1,5}};
             for(var q:quads)for(int i:new int[]{0,1,2,0,2,3}){for(float f:v[q[i]])xyz.add(f);uv.add(i==0||i==1?0f:1f);uv.add(i==0||i==3?1f:0f);}
         }
-        var image=new java.awt.image.BufferedImage(2,2,java.awt.image.BufferedImage.TYPE_INT_ARGB);image.setRGB(0,0,0xFFFF9933);image.setRGB(1,0,0xFF44CCAA);image.setRGB(0,1,0xFF4477EE);image.setRGB(1,1,0xFFFFFFEE);var png=new ByteArrayOutputStream();javax.imageio.ImageIO.write(image,"png",png);
+        var image=new java.awt.image.BufferedImage(2,2,java.awt.image.BufferedImage.TYPE_INT_ARGB);image.setRGB(0,0,0xFFFF9933);image.setRGB(1,0,0xFF44CCAA);image.setRGB(0,1,0xFF4477EE);image.setRGB(1,1,0xFFFFFFEE);
+        if(uniform)for(int y=0;y<2;y++)for(int x=0;x<2;x++)image.setRGB(x,y,0xFF808080);
+        var png=new ByteArrayOutputStream();javax.imageio.ImageIO.write(image,"png",png);
         int pbytes=xyz.size()*4,ubytes=uv.size()*4,ibytes=png.size(),total=pbytes+ubytes+ibytes;var binary=ByteBuffer.allocate((total+3)/4*4).order(ByteOrder.LITTLE_ENDIAN);for(float f:xyz)binary.putFloat(f);for(float f:uv)binary.putFloat(f);binary.put(png.toByteArray());
         String json="""
         {"asset":{"version":"2.0"},"scene":0,"scenes":[{"nodes":[0]}],"nodes":[{"mesh":0,"translation":[3,2,-1]}],

mods/sanctuary/src/clientGametest/java/fr/koka/sanctuary/client/Walls118Checks.java

@@ -0,0 +1,73 @@
+package fr.koka.sanctuary.client;
+
+import fr.koka.sanctuary.building.ColoredBricks;
+import java.util.*;
+import net.minecraft.core.*;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.tags.*;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.item.*;
+import net.minecraft.world.item.context.UseOnContext;
+import net.minecraft.world.item.crafting.*;
+import net.minecraft.world.level.block.*;
+import net.minecraft.world.level.block.state.properties.WallSide;
+import net.minecraft.world.phys.*;
+
+/** Gameplay regressions using native placement, neighbor updates and recipe matching. */
+final class Walls118Checks {
+    static void server(MinecraftServer server){
+        var player=server.getPlayerList().getPlayers().getFirst();var level=player.level();
+        for(int x=-1;x<=17;x++)for(int z=9;z<=13;z++)level.setBlockAndUpdate(new BlockPos(x,0,z),Blocks.STONE.defaultBlockState());
+        int index=0;
+        for(var family:ColoredBricks.families()){
+            var wall=family.wall();var state=wall.defaultBlockState();
+            check(wall instanceof WallBlock&&state.is(BlockTags.WALLS)&&state.is(BlockTags.MINEABLE_WITH_PICKAXE),"Native wall type, connection and mining tags");
+            check(new ItemStack(wall).is(ItemTags.WALLS),"Native wall item tag");
+            var input=CraftingInput.of(3,2,Collections.nCopies(6,new ItemStack(family.bricks())));
+            var recipe=server.getRecipeManager().getRecipeFor(RecipeType.CRAFTING,input,level).orElseThrow().value();var result=recipe.assemble(input);
+            check(result.is(wall.asItem())&&result.getCount()==6,"Six matching bricks craft six walls");
+            var drops=Block.getDrops(state,level,new BlockPos(0,2,0),null,player,new ItemStack(Items.DIAMOND_PICKAXE));
+            check(drops.size()==1&&drops.getFirst().is(wall.asItem())&&drops.getFirst().getCount()==1,"Wall drops its own color");
+            for(int z:new int[]{10,12}){
+                var pos=new BlockPos(index,1,z);
+                player.teleportTo(index+.5,1,z+2.5);
+                if(z==12)level.setBlockAndUpdate(pos,Blocks.WATER.defaultBlockState());
+                player.setItemInHand(InteractionHand.MAIN_HAND,new ItemStack(wall));
+                var hit=new BlockHitResult(Vec3.atBottomCenterOf(pos),Direction.UP,pos.below(),false);
+                var placed=player.getMainHandItem().useOn(new UseOnContext(player,InteractionHand.MAIN_HAND,hit));
+                check(placed.consumesAction(),"Native wall item placement: "+family.color()+" at "+pos+" = "+placed+", existing "+level.getBlockState(pos));
+                check(level.getBlockState(pos).is(wall),"Placed wall keeps its color");
+                check(level.getBlockState(pos).getValue(WallBlock.WATERLOGGED)==(z==12),"Native waterlogging on placement");
+            }
+            index++;
+        }
+        for(int i=1;i<15;i++){
+            var pos=new BlockPos(i,1,10);var state=level.getBlockState(pos);
+            check(state.getValue(WallBlock.EAST)==WallSide.LOW&&state.getValue(WallBlock.WEST)==WallSide.LOW&&!state.getValue(WallBlock.UP),"Mixed-color straight wall removes middle post");
+            level.setBlockAndUpdate(pos.above(),Blocks.STONE.defaultBlockState());
+            state=level.getBlockState(pos);check(state.getValue(WallBlock.EAST)==WallSide.TALL&&state.getValue(WallBlock.WEST)==WallSide.TALL,"Full block above raises connected sides");
+            var vanilla=Blocks.BRICK_WALL.withPropertiesOf(state);
+            check(state.getCollisionShape(level,pos).toAabbs().equals(vanilla.getCollisionShape(level,pos).toAabbs()),"Collision equals native brick wall");
+            level.removeBlock(pos.above(),false);
+        }
+        var end=new BlockPos(16,1,10);level.setBlockAndUpdate(end,Blocks.BRICK_WALL.defaultBlockState());
+        check(level.getBlockState(end.west()).getValue(WallBlock.EAST)==WallSide.LOW,"Connects to vanilla brick wall");
+        saved(level);
+    }
+    static void creative(List<ItemStack> display){
+        var colors=List.of(DyeColor.WHITE,DyeColor.LIGHT_GRAY,DyeColor.GRAY,DyeColor.BLACK,DyeColor.BROWN,DyeColor.RED,DyeColor.ORANGE,DyeColor.YELLOW,DyeColor.LIME,DyeColor.GREEN,DyeColor.CYAN,DyeColor.LIGHT_BLUE,DyeColor.BLUE,DyeColor.PURPLE,DyeColor.MAGENTA,DyeColor.PINK);
+        var families=ColoredBricks.families().stream().sorted(Comparator.comparingInt(f->colors.indexOf(f.color()))).toList();
+        int start=-1;for(int i=0;i<display.size();i++)if(display.get(i).is(families.getFirst().wall().asItem())){start=i;break;}
+        check(start>0,"Wall series is visible in Colored Blocks");
+        for(int i=0;i<16;i++)check(display.get(start+i).is(families.get(i).wall().asItem()),"Contiguous series of sixteen in native color order");
+        check(display.get(start-1).is(families.getLast().slab().asItem())&&display.get(start+16).is(families.getFirst().clay().asItem()),"Wall series follows slabs and precedes clay");
+    }
+    static void saved(ServerLevel level){
+        int i=0;for(var family:ColoredBricks.families()){
+            check(level.getBlockState(new BlockPos(i,1,10)).is(family.wall()),"Persisted wall color");
+            var wet=level.getBlockState(new BlockPos(i++,1,12));check(wet.is(family.wall())&&wet.getValue(WallBlock.WATERLOGGED)&&wet.getFluidState().isSource(),"Persisted waterlogged wall");
+        }
+    }
+    private static void check(boolean ok,String message){if(!ok)throw new AssertionError(message);}
+}

mods/sanctuary/src/clientGametest/java/fr/koka/sanctuary/client/Wrench120ClientChecks.java

@@ -0,0 +1,140 @@
+package fr.koka.sanctuary.client;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import fr.koka.sanctuary.gametest.Starter039TestSupport;
+import fr.koka.sanctuary.multiblock.*;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
+import net.fabricmc.fabric.api.client.gametest.v1.FabricClientGameTest;
+import net.fabricmc.fabric.api.client.gametest.v1.context.ClientGameTestContext;
+import net.fabricmc.fabric.api.client.renderer.v1.Renderer;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.screens.worldselection.WorldCreationUiState;
+import net.minecraft.client.input.KeyEvent;
+import net.minecraft.core.*;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.network.chat.contents.TranslatableContents;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.item.*;
+import net.minecraft.world.level.GameType;
+import net.minecraft.world.level.block.*;
+import net.minecraft.world.level.block.entity.*;
+import net.minecraft.world.level.block.piston.PistonBaseBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.*;
+import net.minecraft.world.phys.*;
+
+/** Real client gestures and persisted server state; rendered UVs must change without moving geometry. */
+public final class Wrench120ClientChecks implements FabricClientGameTest {
+    private static final BlockPos TARGET=new BlockPos(0,1,0),CHEST=new BlockPos(2,1,0),DIRT=new BlockPos(-2,1,0);
+    public void runTest(ClientGameTestContext c){
+        var intro=new AtomicBoolean(true);
+        c.runOnClient(m->{m.options.renderDistance().set(6);m.options.simulationDistance().set(5);m.options.pauseOnLostFocus=false;IntroClient.setQuickTestIntro(true);});
+        ClientTickEvents.END_CLIENT_TICK.register(m->{if(intro.get()&&m.gui.screen() instanceof HelloWorldScreen screen){
+            Starter039TestSupport.selectFirst(screen);
+            screen.children().stream().filter(Button.class::isInstance).map(Button.class::cast).filter(b->b.getClass().getSimpleName().equals("ColorButton")).findFirst().orElseThrow().onPress(enter());
+            screen.children().stream().filter(Button.class::isInstance).map(Button.class::cast).filter(b->b.getMessage().getContents() instanceof TranslatableContents t&&t.getKey().equals("sanctuary.progression.enter")).findFirst().orElseThrow().onPress(enter());intro.set(false);
+        }});
+        net.fabricmc.fabric.api.client.gametest.v1.world.TestWorldSave saved;
+        try(var world=c.worldBuilder().adjustSettings(s->{s.setName("Wrench120 "+UUID.randomUUID());s.setSeed("120");s.setAllowCommands(true);s.setGameMode(WorldCreationUiState.SelectedGameMode.CREATIVE);s.setWorldType(s.getNormalPresetList().stream().filter(e->e.preset()!=null&&e.preset().getRegisteredName().equals("sanctuary_test:flat")).findFirst().orElseThrow());}).create()){
+            c.waitFor(m->ProgressionClient.active()&&m.player!=null&&m.gui.screen()==null&&!IntroSpawnFlash.active(),1200);var server=world.getServer();
+            server.runOnServer(s->{var p=player(s);var l=p.level();p.teleportTo(.5,1,3.2);p.getInventory().setItem(p.getInventory().getSelectedSlot(),new ItemStack(Multiblocks.STEVE_WRENCH));p.inventoryMenu.broadcastFullState();
+                l.setBlockAndUpdate(TARGET,Blocks.OAK_STAIRS.defaultBlockState());l.setBlockAndUpdate(CHEST,Blocks.CHEST.defaultBlockState());((ChestBlockEntity)l.getBlockEntity(CHEST)).setItem(0,new ItemStack(Items.DIAMOND,23));l.setBlockAndUpdate(DIRT,Blocks.DIRT.defaultBlockState());
+                s.getCommands().performPrefixedCommand(s.createCommandSourceStack(),"sanctuary time vanilla");s.getCommands().performPrefixedCommand(s.createCommandSourceStack(),"time set noon");
+                int tested=0;for(var block:BuiltInRegistries.BLOCK)for(var property:block.getStateDefinition().getProperties()){
+                    var before=block.defaultBlockState();var after=GoldenWrench.cycle(before,property,false);
+                    check(after.is(block)&&GoldenWrench.cycle(after,property,true)==before,"Every registered native property has reversible values");tested++;
+                }
+                check(tested>1000,"Broad block property coverage");System.out.println("WRENCH120_PROPERTIES "+tested);
+            });
+            c.waitFor(m->m.player.getMainHandItem().is(Multiblocks.STEVE_WRENCH)&&m.player.distanceToSqr(.5,1,3.2)<.1&&m.level.getBlockState(TARGET).is(Blocks.OAK_STAIRS),150);
+            var stairs=c.computeOnClient(m->m.level.getBlockState(TARGET));click(c,TARGET,false,false);
+            server.waitFor(s->player(s).level().getBlockState(TARGET)!=stairs,100);c.waitFor(m->m.level.getBlockState(TARGET)!=stairs,100);
+            server.runOnServer(s->{var actual=player(s).level().getBlockState(TARGET);check(actual.getValue(StairBlock.FACING)!=stairs.getValue(StairBlock.FACING)&&actual.getValue(StairBlock.HALF)==stairs.getValue(StairBlock.HALF),"Right click changes facing only");});
+            click(c,TARGET,false,true);server.waitFor(s->player(s).level().getBlockState(TARGET)==stairs,100);
+            click(c,TARGET,true,false);server.runOnServer(s->check(GoldenWrench.selected(player(s),stairs).equals("half"),"Left click selects half without breaking creative block: "+GoldenWrench.selected(player(s),stairs)));
+            click(c,TARGET,false,false);server.waitFor(s->player(s).level().getBlockState(TARGET).getValue(StairBlock.HALF)==Half.TOP,100);
+            click(c,TARGET,true,false);server.runOnServer(s->check(GoldenWrench.selected(player(s),stairs).equals("shape"),"Next property is stair shape"));
+            click(c,TARGET,false,false);server.waitFor(s->player(s).level().getBlockState(TARGET).getValue(StairBlock.SHAPE)!=StairsShape.STRAIGHT,100);
+            c.takeScreenshot("wrench120-stairs");
+            // A container rotates in place; inventory and block entity survive the full native interaction.
+            click(c,CHEST,false,false);server.runOnServer(s->{var p=player(s);var chest=(ChestBlockEntity)p.level().getBlockEntity(CHEST);check(chest.getItem(0).is(Items.DIAMOND)&&chest.getItem(0).getCount()==23,"Chest contents retained");check(p.containerMenu==p.inventoryMenu,"Wrench does not open ordinary chest");check(chest.getBlockState().getValue(ChestBlock.FACING)!=Blocks.CHEST.defaultBlockState().getValue(ChestBlock.FACING),"Chest rotates");});
+            // Ordinary survival without commands retains Steve’s full powers; dirt keeps its native ID, shape and loot.
+            server.runOnServer(s->{s.getWorldData().setAllowCommands(false);player(s).setGameMode(GameType.SURVIVAL);});c.waitFor(m->!m.player.isCreative(),100);
+            var original=c.computeOnClient(m->geometry(m,DIRT));c.takeScreenshot("wrench120-dirt-before");
+            click(c,DIRT,false,false);server.waitFor(s->WrenchTextures.rotation(player(s).level().getChunkAt(DIRT),DIRT)==1,100);c.waitFor(m->WrenchTextureModels.rotation(DIRT)==1,100);
+            var rotated=c.computeOnClient(m->geometry(m,DIRT));checkUvs(original,rotated);c.takeScreenshot("wrench120-dirt-90");
+            server.runOnServer(s->check(player(s).level().getBlockState(DIRT)==Blocks.DIRT.defaultBlockState(),"Dirt type and native state unchanged"));
+            click(c,DIRT,true,false);server.runOnServer(s->check(player(s).level().getBlockState(DIRT).is(Blocks.DIRT),"Left click never breaks dirt in survival"));
+            click(c,DIRT,false,true);c.waitFor(m->WrenchTextureModels.rotation(DIRT)==0,100);checkGeometry(original,c.computeOnClient(m->geometry(m,DIRT)),"Reverse restores exact UVs");
+            for(int i=1;i<=4;i++){click(c,DIRT,false,false);int expected=i%4;c.waitFor(m->WrenchTextureModels.rotation(DIRT)==expected,100);}
+            checkGeometry(original,c.computeOnClient(m->geometry(m,DIRT)),"Four turns restore exact original geometry and UVs");
+            click(c,DIRT,false,false);c.waitFor(m->WrenchTextureModels.rotation(DIRT)==1,100);
+            var reload=c.computeOnClient(Minecraft::reloadResourcePacks);c.waitFor(m->reload.isDone()&&m.gui.overlay()==null,1200);reload.join();checkGeometry(rotated,c.computeOnClient(m->geometry(m,DIRT)),"Resource reload retains texture rotation");
+            // Replacing a block clears the visual receipt; blockstate edits retain it.
+            server.runOnServer(s->{var l=player(s).level();var q=new BlockPos(-3,1,0);l.setBlockAndUpdate(q,Blocks.OAK_LOG.defaultBlockState());WrenchTextures.turn(l,q,1);l.setBlock(q,Blocks.OAK_LOG.defaultBlockState().setValue(RotatedPillarBlock.AXIS,Direction.Axis.X),18);check(WrenchTextures.rotation(l.getChunkAt(q),q)==1,"State edit preserves texture rotation");l.removeBlock(q,false);l.setBlockAndUpdate(q,Blocks.OAK_LOG.defaultBlockState());check(WrenchTextures.rotation(l.getChunkAt(q),q)==0,"Break/replacement clears rotation");
+                var p=player(s);p.setGameMode(GameType.ADVENTURE);check(!GoldenWrench.allowed(p,TARGET,InteractionHand.MAIN_HAND,Direction.UP),"Adventure cannot edit");p.setGameMode(GameType.SPECTATOR);check(!GoldenWrench.allowed(p,TARGET,InteractionHand.MAIN_HAND,Direction.UP),"Spectator cannot edit");p.setGameMode(GameType.SURVIVAL);check(!GoldenWrench.allowed(p,TARGET.offset(100,0,0),InteractionHand.MAIN_HAND,Direction.UP),"Out-of-range edit refused");
+            });
+            // A full Metabli still assembles with two normal right clicks, then separates with sneak-use.
+            var table=new BlockPos(6,1,0);server.runOnServer(s->{var p=player(s);p.getInventory().setItem(p.getInventory().getSelectedSlot(),new ItemStack(Multiblocks.WRENCH));p.inventoryMenu.broadcastFullState();for(var q:Metatable.members(table))p.level().setBlockAndUpdate(q,Blocks.CRAFTING_TABLE.defaultBlockState());p.teleportTo(7.5,1,4);});
+            c.waitFor(m->m.player.distanceToSqr(7.5,1,4)<.1&&m.level.getBlockState(table).is(Blocks.CRAFTING_TABLE),100);
+            click(c,table.offset(1,0,2),false,false);click(c,table.offset(1,0,2),false,false);
+            server.waitFor(s->player(s).level().getBlockState(table).is(Metatable.BLOCK),100);c.waitFor(m->m.level.getBlockState(table).is(Metatable.BLOCK),100);
+            click(c,table.offset(1,0,2),true,false);server.runOnServer(s->check(Metatable.state(player(s).level(),table,true)==1,"Left click cannot corrupt a multiblock's part states"));
+            click(c,table.offset(1,0,2),false,true);server.waitFor(s->Metatable.state(player(s).level(),table,false)==1,100);
+            // Both container assemblers and the piston assembler must win over generic state editing.
+            for(var component:List.of(Blocks.BARREL,Blocks.FURNACE)){
+                server.runOnServer(s->{var l=player(s).level();for(int y=0;y<3;y++)for(int z=0;z<3;z++)for(int x=0;x<3;x++)l.setBlockAndUpdate(table.offset(x,y,z),component.defaultBlockState());});
+                c.waitFor(m->m.level.getBlockState(table.offset(1,0,2)).is(component),100);
+                click(c,table.offset(1,0,2),false,false);click(c,table.offset(1,0,2),false,false);
+                server.runOnServer(s->check(MultiblockData.get(player(s).level()).at(table)!=null,"Complete container machine assembles before generic rotation"));
+                click(c,table.offset(1,0,2),false,true);
+                server.runOnServer(s->check(MultiblockData.get(player(s).level()).at(table)==null,"Container machine still separates"));
+            }
+            server.runOnServer(s->{var l=player(s).level();for(int y=2;y>=0;y--)for(int z=0;z<3;z++)for(int x=0;x<3;x++)l.setBlockAndUpdate(table.offset(x,y,z),y==0?Blocks.PISTON.defaultBlockState().setValue(PistonBaseBlock.FACING,Direction.UP):Blocks.AIR.defaultBlockState());});
+            c.waitFor(m->m.level.getBlockState(table.offset(1,0,2)).is(Blocks.PISTON),100);
+            click(c,table.offset(1,0,2),false,false);click(c,table.offset(1,0,2),false,false);
+            server.waitFor(s->SuperPistons.status(player(s).level(),table.offset(1,0,1),Direction.UP,false)==1,100);
+            c.waitFor(m->m.level.getBlockState(table.offset(1,0,2)).is(SuperPistons.NORMAL),100);
+            click(c,table.offset(1,0,2),false,true);
+            server.runOnServer(s->check(player(s).level().getBlockState(table.offset(1,0,2)).is(Blocks.PISTON),"Super piston still separates before editing its parts"));
+            // An isolated barrel and piston now use generic states instead of an incomplete-structure error.
+            server.runOnServer(s->{var p=player(s);p.teleportTo(.5,1,3.2);p.level().setBlockAndUpdate(TARGET,Blocks.BARREL.defaultBlockState());});c.waitFor(m->m.player.distanceToSqr(.5,1,3.2)<.1&&m.level.getBlockState(TARGET).is(Blocks.BARREL),100);
+            click(c,TARGET,false,false);server.runOnServer(s->check(player(s).level().getBlockState(TARGET).getValue(BarrelBlock.FACING)!=Blocks.BARREL.defaultBlockState().getValue(BarrelBlock.FACING),"Isolated barrel rotates"));
+            server.runOnServer(s->player(s).level().setBlockAndUpdate(TARGET,Blocks.PISTON.defaultBlockState()));c.waitFor(m->m.level.getBlockState(TARGET).is(Blocks.PISTON),100);
+            click(c,TARGET,false,false);server.runOnServer(s->check(player(s).level().getBlockState(TARGET).getValue(PistonBaseBlock.FACING)!=Blocks.PISTON.defaultBlockState().getValue(PistonBaseBlock.FACING),"Isolated piston rotates"));
+            server.runOnServer(s->player(s).level().setBlock(TARGET,stairs.setValue(StairBlock.HALF,Half.TOP),18));saved=world.getWorldSave();
+        }
+        try(var world=saved.open()){
+            c.waitFor(m->m.player!=null&&m.gui.screen()==null,1200);world.getServer().runOnServer(s->{var l=player(s).level();check(WrenchTextures.rotation(l.getChunkAt(DIRT),DIRT)==1,"Server persisted dirt texture");check(l.getBlockState(TARGET).getValue(StairBlock.HALF)==Half.TOP,"Server persisted native edited state");check(((ChestBlockEntity)l.getBlockEntity(CHEST)).getItem(0).getCount()==23,"Saved chest keeps inventory");});
+            c.waitFor(m->WrenchTextureModels.rotation(DIRT)==1,150);c.getInput().lookAt(DIRT);c.takeScreenshot("wrench120-reconnect");
+        }
+        System.out.println("WRENCH120_PASS native creative/survival clicks, reverse, properties, textures and resource reload, unchanged geometry, filled chest, multiblock assembly priority, permissions, cleanup and save/reconnect");
+    }
+    static void click(ClientGameTestContext c,BlockPos pos,boolean left,boolean sneak){
+        if(sneak){c.getInput().holdKey(o->o.keyShift);c.waitTicks(3);}
+        c.runOnClient(m->m.player.lookAt(net.minecraft.commands.arguments.EntityAnchorArgument.Anchor.EYES,new Vec3(pos.getX()+.5,pos.getY()+.3,pos.getZ()+.5)));c.waitTicks(3);
+        c.runOnClient(m->check(m.hitResult instanceof BlockHitResult hit&&hit.getBlockPos().equals(pos),"Native cursor hits target "+pos+" instead of "+m.hitResult));
+        if(left){c.getInput().holdKey(o->o.keyAttack);c.waitTicks(1);c.getInput().releaseKey(o->o.keyAttack);}else{c.getInput().holdKey(o->o.keyUse);c.waitTicks(1);c.getInput().releaseKey(o->o.keyUse);}
+        c.waitTicks(5);if(sneak){c.getInput().releaseKey(o->o.keyShift);c.waitTicks(3);}
+    }
+    private static List<float[]> geometry(Minecraft m,BlockPos pos){
+        var result=new ArrayList<float[]>();var state=m.level.getBlockState(pos);
+        var emitter=Renderer.get().quadEmitter(q->{var data=new float[20];for(int i=0;i<4;i++){data[i*5]=q.x(i);data[i*5+1]=q.y(i);data[i*5+2]=q.z(i);data[i*5+3]=q.u(i);data[i*5+4]=q.v(i);}result.add(data);});
+        m.getModelManager().getBlockStateModelSet().get(state).emitQuads(emitter,m.level,pos,state,RandomSource.create(state.getSeed(pos)),face->false);check(!result.isEmpty(),"Native model emits real textured geometry");return result;
+    }
+    private static void checkUvs(List<float[]> before,List<float[]> after){
+        check(before.size()==after.size(),"Same face count");boolean changed=false;
+        for(int q=0;q<before.size();q++)for(int v=0;v<4;v++){for(int axis=0;axis<3;axis++)check(before.get(q)[v*5+axis]==after.get(q)[v*5+axis],"Texture turn never moves geometry");changed|=before.get(q)[v*5+3]!=after.get(q)[v*5+3]||before.get(q)[v*5+4]!=after.get(q)[v*5+4];}
+        check(changed,"Dirt UVs actually change");
+    }
+    private static void checkGeometry(List<float[]> a,List<float[]> b,String message){check(a.size()==b.size(),message);for(int i=0;i<a.size();i++)check(Arrays.equals(a.get(i),b.get(i)),message);}
+    private static ServerPlayer player(MinecraftServer s){return s.getPlayerList().getPlayers().getFirst();}
+    private static KeyEvent enter(){return new KeyEvent(InputConstants.KEY_RETURN,0,0);}
+    private static void check(boolean ok,String message){if(!ok)throw new AssertionError(message);}
+}

mods/sanctuary/src/clientGametest/java/fr/koka/sanctuary/client/Wrench123ClientChecks.java

@@ -0,0 +1,111 @@
+package fr.koka.sanctuary.client;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import fr.koka.sanctuary.gametest.Starter039TestSupport;
+import fr.koka.sanctuary.multiblock.*;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
+import net.fabricmc.fabric.api.client.gametest.v1.FabricClientGameTest;
+import net.fabricmc.fabric.api.client.gametest.v1.context.ClientGameTestContext;
+import net.fabricmc.fabric.api.event.player.*;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.screens.worldselection.WorldCreationUiState;
+import net.minecraft.client.input.KeyEvent;
+import net.minecraft.core.*;
+import net.minecraft.core.component.DataComponents;
+import net.minecraft.network.chat.contents.TranslatableContents;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.*;
+import net.minecraft.world.item.*;
+import net.minecraft.world.level.GameType;
+import net.minecraft.world.level.block.*;
+import net.minecraft.world.level.block.entity.ChestBlockEntity;
+import net.minecraft.world.level.block.piston.PistonBaseBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.*;
+import net.minecraft.world.phys.*;
+
+/** Native golden-wrench clicks cannot create resources or split linked blocks. */
+public final class Wrench123ClientChecks implements FabricClientGameTest {
+    private static final BlockPos TARGET=new BlockPos(0,1,0),CHEST=new BlockPos(2,1,0),DIRT=new BlockPos(-2,1,0);
+    public void runTest(ClientGameTestContext c){
+        var intro=new AtomicBoolean(true);
+        c.runOnClient(m->{m.options.renderDistance().set(6);m.options.simulationDistance().set(5);m.options.pauseOnLostFocus=false;IntroClient.setQuickTestIntro(true);});
+        ClientTickEvents.END_CLIENT_TICK.register(m->{if(intro.get()&&m.gui.screen() instanceof HelloWorldScreen screen){
+            Starter039TestSupport.selectFirst(screen);
+            screen.children().stream().filter(Button.class::isInstance).map(Button.class::cast).filter(b->b.getClass().getSimpleName().equals("ColorButton")).findFirst().orElseThrow().onPress(new KeyEvent(InputConstants.KEY_RETURN,0,0));
+            screen.children().stream().filter(Button.class::isInstance).map(Button.class::cast).filter(b->b.getMessage().getContents() instanceof TranslatableContents t&&t.getKey().equals("sanctuary.progression.enter")).findFirst().orElseThrow().onPress(new KeyEvent(InputConstants.KEY_RETURN,0,0));intro.set(false);
+        }});
+        try(var world=c.worldBuilder().adjustSettings(s->{s.setName("Wrench123 "+UUID.randomUUID());s.setSeed("123");s.setAllowCommands(true);s.setGameMode(WorldCreationUiState.SelectedGameMode.CREATIVE);s.setWorldType(s.getNormalPresetList().stream().filter(e->e.preset()!=null&&e.preset().getRegisteredName().equals("sanctuary_test:flat")).findFirst().orElseThrow());}).create()){
+            c.waitFor(m->ProgressionClient.active()&&m.player!=null&&m.gui.screen()==null&&!IntroSpawnFlash.active(),1200);var server=world.getServer();
+            server.runOnServer(s->{var p=player(s);var l=p.level();for(int x=-5;x<=8;x++)for(int z=-4;z<=6;z++)l.setBlockAndUpdate(new BlockPos(x,0,z),Blocks.STONE.defaultBlockState());p.teleportTo(.5,1,3.2);equip(p,Multiblocks.WRENCH);
+                l.setBlockAndUpdate(TARGET,Blocks.OAK_STAIRS.defaultBlockState());l.setBlockAndUpdate(CHEST,Blocks.CHEST.defaultBlockState());((ChestBlockEntity)l.getBlockEntity(CHEST)).setItem(0,new ItemStack(Items.DIAMOND,23));l.setBlockAndUpdate(DIRT,Blocks.DIRT.defaultBlockState());
+                s.getCommands().performPrefixedCommand(s.createCommandSourceStack(),"sanctuary time vanilla");s.getCommands().performPrefixedCommand(s.createCommandSourceStack(),"time set noon");
+            });
+            c.waitFor(m->m.player.getMainHandItem().is(Multiblocks.WRENCH)&&m.player.distanceToSqr(.5,1,3.2)<.1&&m.level.getBlockState(TARGET).is(Blocks.OAK_STAIRS),150);
+            var stairs=c.computeOnClient(m->m.level.getBlockState(TARGET));
+            Wrench120ClientChecks.click(c,TARGET,false,false);server.runOnServer(s->check(player(s).level().getBlockState(TARGET).getValue(StairBlock.FACING)!=stairs.getValue(StairBlock.FACING),"Golden wrench changes native stair facing"));
+            Wrench120ClientChecks.click(c,TARGET,false,true);server.waitFor(s->player(s).level().getBlockState(TARGET)==stairs,100);
+            for(int i=0;i<5;i++){Wrench120ClientChecks.click(c,TARGET,true,false);Wrench120ClientChecks.click(c,TARGET,false,false);}
+            server.runOnServer(s->{var state=player(s).level().getBlockState(TARGET);check(!state.getValue(StairBlock.WATERLOGGED)&&state.getValue(StairBlock.HALF)==Half.BOTTOM&&state.getValue(StairBlock.SHAPE)==StairsShape.STRAIGHT,"Repeated native clicks never select water, half or fake stair shapes");});
+            for(int i=0;i<4;i++)Wrench120ClientChecks.click(c,CHEST,false,false);
+            server.runOnServer(s->{var p=player(s);var be=(ChestBlockEntity)p.level().getBlockEntity(CHEST);check(be.getItem(0).getCount()==23&&be.getBlockState()==Blocks.CHEST.defaultBlockState(),"Single chest remains single, dry and filled after four rotations");check(p.containerMenu==p.inventoryMenu,"Ordinary rotation does not open chest");});
+            Wrench120ClientChecks.click(c,DIRT,true,false);Wrench120ClientChecks.click(c,DIRT,false,false);
+            server.runOnServer(s->{var l=player(s).level();check(WrenchTextures.rotation(l.getChunkAt(DIRT),DIRT)==0&&l.getBlockState(DIRT).is(Blocks.DIRT),"Golden wrench never adds a texture transform");regressions(player(s));});
+            c.takeScreenshot("wrench123-golden-safe");
+            // Finding Steve's wrench grants its full powers in ordinary survival, without operator status.
+            server.runOnServer(s->{var p=player(s);p.setGameMode(GameType.SURVIVAL);s.getWorldData().setAllowCommands(false);equip(p,Multiblocks.STEVE_WRENCH);});
+            c.waitFor(m->!m.player.isCreative()&&m.player.getMainHandItem().is(Multiblocks.STEVE_WRENCH),100);
+            Wrench120ClientChecks.click(c,DIRT,true,false);Wrench120ClientChecks.click(c,DIRT,false,false);
+            server.waitFor(s->WrenchTextures.rotation(player(s).level().getChunkAt(DIRT),DIRT)==1,100);c.waitFor(m->WrenchTextureModels.rotation(DIRT)==1,100);
+            Wrench120ClientChecks.click(c,TARGET,false,false);Wrench120ClientChecks.click(c,TARGET,true,false);Wrench120ClientChecks.click(c,TARGET,false,false);
+            server.runOnServer(s->{var p=player(s);check(p.level().getBlockState(TARGET).getValue(StairBlock.HALF)==Half.TOP,"Native Steve edit works for ordinary survival without commands");
+                for(var hand:InteractionHand.values()){
+                    p.setItemInHand(hand,new ItemStack(Multiblocks.STEVE_WRENCH));check(GoldenWrench.allowed(p,TARGET,hand,Direction.UP),"Survival use allowed in both hands");
+                    GoldenWrench.change(p,DIRT,hand,Direction.UP);
+                }
+                check(WrenchTextures.rotation(p.level().getChunkAt(DIRT),DIRT)==3,"Both hands can freely edit textures in survival");
+                p.setItemInHand(InteractionHand.OFF_HAND,ItemStack.EMPTY);p.setGameMode(GameType.CREATIVE);check(GoldenWrench.allowed(p,TARGET,InteractionHand.MAIN_HAND,Direction.UP),"Creative access without commands enabled");
+                p.setGameMode(GameType.ADVENTURE);check(!GoldenWrench.allowed(p,TARGET,InteractionHand.MAIN_HAND,Direction.UP),"Adventure restrictions remain");p.setGameMode(GameType.SPECTATOR);check(!GoldenWrench.allowed(p,TARGET,InteractionHand.MAIN_HAND,Direction.UP),"Spectator cannot edit");p.setGameMode(GameType.CREATIVE);
+                var steve=new ItemStack(Multiblocks.STEVE_WRENCH);check(Boolean.TRUE.equals(steve.get(DataComponents.ENCHANTMENT_GLINT_OVERRIDE)),"Distinct enchanted Steve item");
+            });
+            c.waitFor(m->m.player.isCreative(),100);c.takeScreenshot("wrench123-steve-texture");
+            System.out.println("WRENCH123_SAFE_PASS native clicks, water/inventory preservation, linked blocks, real neighbour shapes, support checks, ordinary survival and creative use, adventure/spectator restrictions and both hands");
+        }
+        // Keep the full former debug-stick contract on Steve, including UVs/save/reload, and assembly on gold.
+        new Wrench120ClientChecks().runTest(c);
+        System.out.println("WRENCH123_PASS safe golden wrench and Steve wrench with native regression coverage");
+    }
+    private static void regressions(ServerPlayer p){
+        var l=p.level();
+        // Water stays present when rotating a legitimately waterlogged block.
+        l.setBlock(TARGET,Blocks.OAK_STAIRS.defaultBlockState().setValue(StairBlock.WATERLOGGED,true),18);
+        use(p,TARGET);check(l.getBlockState(TARGET).getValue(StairBlock.WATERLOGGED),"Existing water is preserved");
+        l.setBlock(TARGET,Blocks.OAK_STAIRS.defaultBlockState().setValue(StairBlock.FACING,Direction.WEST).setValue(StairBlock.SHAPE,StairsShape.INNER_LEFT),18);
+        use(p,TARGET);check(l.getBlockState(TARGET).getValue(StairBlock.SHAPE)==StairsShape.STRAIGHT&&!l.getBlockState(TARGET).getValue(StairBlock.WATERLOGGED),"Native shape recomputed against actual empty neighbours");
+        var a=CHEST;var b=CHEST.east();var base=Blocks.CHEST.defaultBlockState().setValue(ChestBlock.FACING,Direction.NORTH);
+        l.setBlock(a,base.setValue(ChestBlock.TYPE,ChestType.LEFT),18);l.setBlock(b,base.setValue(ChestBlock.TYPE,ChestType.RIGHT),18);
+        var first=(ChestBlockEntity)l.getBlockEntity(a);var second=(ChestBlockEntity)l.getBlockEntity(b);first.setItem(0,new ItemStack(Items.DIAMOND,23));second.setItem(0,new ItemStack(Items.EMERALD,17));
+        var left=l.getBlockState(a);var right=l.getBlockState(b);use(p,a);use(p,b);
+        check(l.getBlockState(a)==left&&l.getBlockState(b)==right&&l.getBlockEntity(a)==first&&l.getBlockEntity(b)==second&&first.getItem(0).getCount()==23&&second.getItem(0).getCount()==17,"Double chest remains linked with both original inventories");
+        var q=TARGET;var door=Blocks.OAK_DOOR.defaultBlockState();l.setBlock(q,door.setValue(DoorBlock.HALF,DoubleBlockHalf.LOWER),18);l.setBlock(q.above(),door.setValue(DoorBlock.HALF,DoubleBlockHalf.UPPER),18);
+        var lower=l.getBlockState(q);var upper=l.getBlockState(q.above());use(p,q);use(p,q.above());check(l.getBlockState(q)==lower&&l.getBlockState(q.above())==upper,"Both door halves protected");l.setBlock(q.above(),Blocks.AIR.defaultBlockState(),18);
+        var bed=Blocks.BED.red().defaultBlockState();l.setBlock(q,bed,18);use(p,q);check(l.getBlockState(q)==bed,"Bed half protected even if malformed already");
+        var extended=Blocks.PISTON.defaultBlockState().setValue(PistonBaseBlock.EXTENDED,true);l.setBlock(q,extended,18);use(p,q);check(l.getBlockState(q)==extended,"Extended piston protected");
+        for(var block:List.of(Blocks.PISTON_HEAD,Blocks.MOVING_PISTON)){l.setBlock(q,block.defaultBlockState(),18);use(p,q);check(l.getBlockState(q)==block.defaultBlockState(),"Attached/moving piston part protected");}
+        l.setBlock(q,Blocks.OAK_LOG.defaultBlockState(),18);var axes=EnumSet.noneOf(Direction.Axis.class);for(int i=0;i<3;i++){use(p,q);axes.add(l.getBlockState(q).getValue(RotatedPillarBlock.AXIS));}check(axes.size()==3,"All three native log axes supported");
+        l.setBlock(q,Blocks.PISTON.defaultBlockState(),18);var facings=EnumSet.noneOf(Direction.class);for(int i=0;i<6;i++){use(p,q);facings.add(l.getBlockState(q).getValue(PistonBaseBlock.FACING));}check(facings.size()==6,"Isolated piston supports all six native orientations");
+        // Turning a wall torch toward empty air must not break it or its support.
+        l.setBlock(q.north(),Blocks.STONE.defaultBlockState(),18);var torch=Blocks.WALL_TORCH.defaultBlockState().setValue(WallTorchBlock.FACING,Direction.SOUTH);l.setBlock(q,torch,18);use(p,q);check(l.getBlockState(q)==torch,"Unsupported rotation leaves wall-mounted block intact");l.setBlock(q.north(),Blocks.AIR.defaultBlockState(),18);
+        l.setBlock(q,Blocks.OAK_STAIRS.defaultBlockState(),18);
+        var top=GoldenWrench.cycle(l.getBlockState(q),StairBlock.HALF,false);check(top.getValue(StairBlock.HALF)==Half.TOP,"Steve still has native debug property cycle");
+        // Existing visual edits are preserved; the ordinary key cannot create or reset them.
+        WrenchTextures.turn(l,q,1);use(p,q);check(WrenchTextures.rotation(l.getChunkAt(q),q)==1,"Golden rotation preserves saved Steve texture data");WrenchTextures.turn(l,q,-1);
+    }
+    private static void use(ServerPlayer p,BlockPos pos){UseBlockCallback.EVENT.invoker().interact(p,p.level(),InteractionHand.MAIN_HAND,new BlockHitResult(Vec3.atCenterOf(pos),Direction.UP,pos,false));}
+    private static void equip(ServerPlayer p,Item item){p.getInventory().setItem(p.getInventory().getSelectedSlot(),new ItemStack(item));p.inventoryMenu.broadcastFullState();}
+    private static ServerPlayer player(MinecraftServer s){return s.getPlayerList().getPlayers().getFirst();}
+    private static void check(boolean ok,String message){if(!ok)throw new AssertionError(message);}
+}

mods/sanctuary/src/clientGametest/java/fr/koka/sanctuary/client/shader/EdgeHighlights129ClientChecks.java

@@ -0,0 +1,206 @@
+package fr.koka.sanctuary.client.shader;
+
+import static fr.koka.sanctuary.client.shader.PixelShadows122ClientChecks.*;
+
+import java.nio.file.Files;
+import java.util.ArrayList;
+import net.fabricmc.fabric.api.client.gametest.v1.context.ClientGameTestContext;
+import net.fabricmc.fabric.api.client.gametest.v1.context.TestServerContext;
+import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.block.Blocks;
+import org.joml.Matrix4f;
+import org.joml.Vector4f;
+
+/** Native GPU checks sharing the isolated flat-world fixture and its preference backup. */
+final class EdgeHighlights129ClientChecks {
+    static void run(ClientGameTestContext c, TestServerContext server) {
+        c.runOnClient(m -> preferences());
+        server.runOnServer(s -> {
+            for (int x=10;x<=14;x++) for (int z=6;z<=10;z++) {
+                s.overworld().setBlockAndUpdate(new BlockPos(x,65,z),
+                        (Math.floorMod(x,8)<4 ? Blocks.STONE : Blocks.OAK_PLANKS).defaultBlockState());
+            }
+        });
+        camera(c,server,12.5,72,8.5,60);
+        c.waitTicks(35);
+        shadows(c,false);
+        edge(c,false);
+        var off=capture(c,"edges-flat-off");
+        c.waitTicks(6);
+        unchanged(off,capture(c,null),"Highlight OFF control is stable");
+        edge(c,true);
+        var on=capture(c,"edges-flat-on-30");
+        var low=measure(off,on);
+        check(low.brighter>100 && low.stable>low.samples*.55 && low.darker<low.samples*.005,
+                "Highlight brightens local strips, preserves face interiors: "+low);
+        grid(c,off,on);
+        for (int distance : new int[]{16,32,64,128,256}) {
+            c.runOnClient(m -> VanillaLight.setEdgeDistance(distance));
+            frames(c);
+            check(c.computeOnClient(m -> VanillaLight.edgeDistance())==distance,"All CTM ranges are available");
+            unchanged(on,capture(c,null),"Near CTM contours unchanged at range "+distance);
+        }
+        c.runOnClient(m -> VanillaLight.setEdgeDistance(32));
+        c.runOnClient(m -> {
+            check(PixelShadows.shadowMap()==null,"Highlight works without allocating a cast-shadow map");
+            VanillaLight.setEdgeIntensity(90);
+        });
+        frames(c);
+        var high=measure(off,capture(c,"edges-flat-on-90"));
+        check(high.meanGain>low.meanGain*1.8,"Intensity changes visible brightness: low="+low+" high="+high);
+        c.runOnClient(m -> VanillaLight.setEdgeIntensity(0));
+        c.waitTicks(6);
+        c.runOnClient(m -> check(!EdgeHighlights.applied() && !EdgeHighlights.allocated(),"Zero intensity frees its uniform buffer"));
+        unchanged(off,capture(c,"edges-zero"),"Zero intensity reproduces OFF exactly");
+        c.runOnClient(m -> VanillaLight.setEdgeIntensity(30));
+        frames(c);
+        camera(c,server,11.99999,72,8.5,60);
+        var anchor=capture(c,null);
+        camera(c,server,12.00001,72,8.5,60);
+        unchanged(anchor,capture(c,"edges-anchor-crossing"),"Grid remains stable across an integer camera anchor");
+        camera(c,server,12.5,72,8.5,60);
+        unchanged(on,capture(c,null),"Returning to the camera restores the same grid");
+        var reload=c.computeOnClient(net.minecraft.client.Minecraft::reloadResourcePacks);
+        c.waitFor(m -> reload.isDone() && m.gui.overlay()==null,1200);
+        reload.join();
+        c.runOnClient(m -> {
+            forgetPreferences();
+            check(VanillaLight.edgeHighlights() && VanillaLight.edgeIntensity()==30,"Highlight preferences survive reload and disk reread");
+        });
+        frames(c);
+        unchanged(on,capture(c,"edges-after-reload"),"Resource reload retains the highlight image");
+        edge(c,false);
+        unchanged(off,capture(c,"edges-off-restored"),"Disabling leaves no residual highlight");
+
+        // A new hole creates a connected boundary immediately; filling it removes that boundary.
+        server.runOnServer(s -> s.overworld().setBlockAndUpdate(new BlockPos(12,65,8),Blocks.AIR.defaultBlockState()));
+        c.waitTicks(20);
+        var holeOff=capture(c,null);
+        edge(c,true);
+        var hole=measure(holeOff,capture(c,"edges-ctm-hole"));
+        check(hole.brighter>low.brighter+20,"Removing an interior block creates a new CTM contour");
+        server.runOnServer(s -> s.overworld().setBlockAndUpdate(new BlockPos(12,65,8),Blocks.STONE.defaultBlockState()));
+        c.waitTicks(20);
+        unchanged(on,capture(c,null),"Filling the hole reconnects the flat surface");
+        // The actual radius gates a visible contour, independently of shadow range.
+        camera(c,server,12.5,88,8.5,30);
+        edge(c,false);
+        var farOff=capture(c,null);
+        c.runOnClient(m -> VanillaLight.setEdgeDistance(16));
+        edge(c,true);
+        unchanged(farOff,capture(c,"edges-beyond-16"),"CTM beyond selected 16-block radius is absent");
+        c.runOnClient(m -> {VanillaLight.setEdgeDistance(64);VanillaLight.setEdgeIntensity(90);});
+        frames(c);
+        var far=measure(farOff,capture(c,"edges-inside-64"));
+        check(far.brighter>40,"Extending the CTM radius restores a distant contour: "+far);
+        c.runOnClient(m -> {VanillaLight.setEdgeDistance(32);VanillaLight.setEdgeIntensity(30);});
+        edge(c,false);
+
+        server.runOnServer(s -> {
+            for (int x=9;x<=13;x+=2) for(int y=65;y<=67;y++)
+                s.overworld().setBlockAndUpdate(new BlockPos(x,y,12),
+                        (x==9 ? Blocks.CONCRETE.red() : x==11 ? Blocks.STONE_BRICKS : Blocks.OAK_PLANKS).defaultBlockState());
+            s.overworld().setBlockAndUpdate(new BlockPos(10,65,11),Blocks.STONE_SLAB.defaultBlockState());
+            s.overworld().setBlockAndUpdate(new BlockPos(12,65,11),Blocks.OAK_STAIRS.defaultBlockState());
+        });
+        camera(c,server,12.5,72,7.5,70);
+        look(c,server,15,55);
+        shadows(c,true);
+        var reliefOff=capture(c,"edges-relief-with-shadows-off");
+        edge(c,true);
+        var reliefOn=capture(c,"edges-relief-with-shadows-on");
+        var relief=measure(reliefOff,reliefOn);
+        check(relief.brighter>100 && relief.stable>relief.samples*.5 && relief.darker<relief.samples*.01,
+                "Highlight composes with cast shadows and coloured textured blocks: "+relief);
+        look(c,server,15.00002f,55.00002f);
+        unchanged(reliefOn,capture(c,null),"Tiny oblique camera rotation keeps highlights stable");
+        c.runOnClient(m -> VanillaLight.setEnabled(false));
+        c.waitTicks(6);
+        c.runOnClient(m -> check(!EdgeHighlights.applied() && !EdgeHighlights.allocated(),"Main shader OFF also releases highlight resources"));
+        c.runOnClient(m -> VanillaLight.setEnabled(true));
+        frames(c);
+        edge(c,false);
+        System.out.println("EDGE_HIGHLIGHTS129_PASS connected contours and unchanged flat joins; independent shadows; intensity; zero/OFF release; "
+                +"camera anchors; oblique textured scene; resource reload; legacy preference migration; low="+low+" high="+high+" relief="+relief);
+    }
+
+    private static void preferences() {
+        var path=FabricLoader.getInstance().getConfigDir().resolve("sanctuary-shaders.json");
+        try {
+            // Real prior-version JSON, without either new field. Preserve its existing settings.
+            Files.writeString(path,"{\"enabled\":true,\"saturation\":100,\"pixelShadows\":true,\"shadowPixels\":16,\"shadowDistance\":32}");
+            forgetPreferences();
+            check(!VanillaLight.edgeHighlights() && VanillaLight.edgeIntensity()==30 && VanillaLight.edgeDistance()==32,"Old configuration defaults highlights OFF at intensity 30");
+            check(VanillaLight.pixelShadows() && VanillaLight.saturation()==100,"Migration retains existing shader choices");
+            for(int value:new int[]{-100,0,30,100,1000}) {
+                VanillaLight.setEdgeIntensity(value);forgetPreferences();
+                check(VanillaLight.edgeIntensity()==Math.clamp(value,0,100),"Saved intensity is bounded");
+            }
+            for(int[] pair:new int[][]{{-1,16},{24,32},{48,64},{96,128},{192,256},{9999,256}}) {
+                VanillaLight.setEdgeDistance(pair[0]);forgetPreferences();
+                check(VanillaLight.edgeDistance()==pair[1],"Saved CTM distance is bounded and normalized");
+            }
+            VanillaLight.setEdgeDistance(32);
+            VanillaLight.setEdgeIntensity(30);
+            VanillaLight.setEdgeHighlights(true);forgetPreferences();
+            check(VanillaLight.edgeHighlights(),"Toggle persists independently");
+            VanillaLight.setEdgeHighlights(false);
+        } catch(java.io.IOException e) { throw new AssertionError(e); }
+    }
+
+    private static void edge(ClientGameTestContext c,boolean enabled) {
+        c.runOnClient(m -> VanillaLight.setEdgeHighlights(enabled));
+        if(enabled)frames(c);
+        else {
+            c.waitTicks(6);
+            c.runOnClient(m -> check(!EdgeHighlights.applied() && !EdgeHighlights.allocated(),"OFF frees resources"));
+        }
+    }
+
+    private static void frames(ClientGameTestContext c) {
+        int before=c.computeOnClient(m -> EdgeHighlights.renderedFrames());
+        c.waitFor(m -> EdgeHighlights.applied() && EdgeHighlights.renderedFrames()>before+8,200);
+        c.waitTicks(6);
+    }
+
+    private record Difference(int samples,int brighter,int stable,int darker,double meanGain) { }
+    private static Difference measure(Frame off,Frame on) {
+        int samples=0,brighter=0,stable=0,darker=0;double gain=0;
+        for(int y=off.height()/10;y<off.height()*9/10;y+=2) for(int x=off.width()/10;x<off.width()*9/10;x+=2) {
+            int i=y*off.width()+x,a=off.pixels()[i],b=on.pixels()[i];
+            int delta=brightness(b)-brightness(a);samples++;gain+=delta;
+            if(delta>=4)brighter++;
+            if(delta<=-4)darker++;
+            if(channelDifference(a,b)<=2)stable++;
+        }
+        var result=new Difference(samples,brighter,stable,darker,gain/samples);
+        System.out.println("EDGE_HIGHLIGHTS129_PIXELS "+result);
+        return result;
+    }
+
+    private static void grid(ClientGameTestContext c,Frame off,Frame on) {
+        var samples=c.computeOnClient(m -> {
+            var camera=m.gameRenderer.gameRenderState().levelRenderState.cameraRenderState;
+            var vp=new Matrix4f(camera.projectionMatrix).mul(camera.viewRotationMatrix);
+            var result=new ArrayList<int[]>();
+            for(int x=11;x<=14;x++) for(int z=6;z<=10;z++) for(int edge=0;edge<2;edge++) {
+                var p=vp.transform(new Vector4f((float)(x+(edge==0?.5:1.0/32)-camera.pos.x),
+                        (float)(66-camera.pos.y),(float)(z+.5-camera.pos.z),1));
+                int px=(int)((p.x/p.w*.5+.5)*off.width());
+                int py=(int)((.5-p.y/p.w*.5)*off.height());
+                if(px>=10 && px<off.width()-10 && py>=10 && py<off.height()-10)result.add(new int[]{py*off.width()+px,edge});
+            }
+            return result;
+        });
+        int centers=0,unchanged=0,edges=0,bright=0;
+        for(var sample:samples) {
+            int a=off.pixels()[sample[0]],b=on.pixels()[sample[0]];
+            if(sample[1]==0){centers++;if(channelDifference(a,b)<=2)unchanged++;}
+            else {edges++;if(brightness(b)-brightness(a)>=4)bright++;}
+        }
+        check(centers>=15 && unchanged>centers*.95 && edges>=15 && bright==0,
+                "Connected block centers and coplanar joins remain untouched: centers="+unchanged+"/"+centers+" edges="+bright+"/"+edges);
+        System.out.println("EDGE_HIGHLIGHTS129_GRID centers="+unchanged+"/"+centers+" edges="+bright+"/"+edges);
+    }
+}

mods/sanctuary/src/clientGametest/java/fr/koka/sanctuary/client/shader/PixelShadows122ClientChecks.java

@@ -0,0 +1,642 @@
+package fr.koka.sanctuary.client.shader;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import fr.koka.sanctuary.client.HelloWorldScreen;
+import fr.koka.sanctuary.client.IntroClient;
+import fr.koka.sanctuary.client.IntroSpawnFlash;
+import fr.koka.sanctuary.client.ProgressionClient;
+import fr.koka.sanctuary.gametest.Starter039TestSupport;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
+import net.fabricmc.fabric.api.client.gametest.v1.FabricClientGameTest;
+import net.fabricmc.fabric.api.client.gametest.v1.context.ClientGameTestContext;
+import net.fabricmc.fabric.api.client.gametest.v1.context.TestServerContext;
+import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.client.CameraType;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.Screenshot;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.screens.worldselection.WorldCreationUiState;
+import net.minecraft.client.input.KeyEvent;
+import net.minecraft.client.renderer.culling.Frustum;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.contents.TranslatableContents;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.StairBlock;
+import net.minecraft.world.level.gamerules.GameRules;
+import net.minecraft.world.phys.AABB;
+import net.minecraft.world.phys.Vec3;
+
+/** Real terrain/depth-map checks on a new flat seed 122 world; GPU readback is test-only. */
+public final class PixelShadows122ClientChecks implements FabricClientGameTest {
+    private static final int FLOOR = 64;
+    private static final AABB PILLAR = new AABB(0, FLOOR + 1, 0, 2, FLOOR + 9, 2);
+    private static final BlockPos SLAB = new BlockPos(5, FLOOR + 3, -5);
+    private static final BlockPos STAIR = new BlockPos(5, FLOOR + 3, 5);
+    private static final int DARK_DELTA = 8;
+
+    @Override
+    public void runTest(ClientGameTestContext c) {
+        var path = FabricLoader.getInstance().getConfigDir().resolve("sanctuary-shaders.json");
+        final byte[] originalPreferences;
+        try {
+            originalPreferences = Files.exists(path) ? Files.readAllBytes(path) : null;
+        } catch (IOException e) {
+            throw new AssertionError("Cannot back up shader preferences", e);
+        }
+        var originalOptions = c.computeOnClient(Options::capture);
+        var onboarding = new AtomicBoolean(true);
+        ClientTickEvents.END_CLIENT_TICK.register(m -> {
+            if (onboarding.get() && m.gui.screen() instanceof HelloWorldScreen screen) {
+                // Public test support works across packages; enter through the native widgets.
+                IntroClient.setQuickTestIntro(true);
+                if (!screen.starterChoices().isEmpty()) Starter039TestSupport.selectFirst(screen);
+                screen.children().stream().filter(Button.class::isInstance).map(Button.class::cast)
+                        .filter(b -> b.getClass().getSimpleName().equals("ColorButton"))
+                        .findFirst().orElseThrow().onPress(enter());
+                screen.children().stream().filter(Button.class::isInstance).map(Button.class::cast)
+                        .filter(b -> b.getMessage().getContents() instanceof TranslatableContents t
+                                && t.getKey().equals("sanctuary.progression.enter"))
+                        .findFirst().orElseThrow().onPress(enter());
+                onboarding.set(false);
+            }
+        });
+        try {
+            c.runOnClient(m -> {
+                m.options.renderDistance().set(6);
+                m.options.simulationDistance().set(5);
+                m.options.bobView().set(false);
+                m.options.pauseOnLostFocus = false;
+                m.options.setCameraType(CameraType.FIRST_PERSON);
+                checkPreferences();
+            });
+            try (var world = c.worldBuilder().adjustSettings(s -> {
+                s.setName("PixelShadows122 " + UUID.randomUUID());
+                s.setSeed("122");
+                s.setAllowCommands(true);
+                s.setGameMode(WorldCreationUiState.SelectedGameMode.CREATIVE);
+                s.setWorldType(s.getNormalPresetList().stream().filter(e -> e.preset() != null
+                        && e.preset().getRegisteredName().equals("sanctuary_test:flat"))
+                        .findFirst().orElseThrow());
+            }).create()) {
+                world.getConnection().waitForChunksDownload(2400);
+                c.waitFor(m -> m.player != null && ProgressionClient.active()
+                        && m.gui.screen() == null && !IntroSpawnFlash.active(), 1200);
+                c.getInput().pressKey(InputConstants.KEY_F1);
+                var server = world.getServer();
+                server.runOnServer(s -> {
+                    command(s, "sanctuary time vanilla");
+                    command(s, "sanctuary weather vanilla");
+                    command(s, "weather clear 100000");
+                    if (s.getGlobalGameRules().get(GameRules.ADVANCE_TIME))
+                        command(s, "gamerule " + GameRules.ADVANCE_TIME.id() + " false");
+                    check(!s.getGlobalGameRules().get(GameRules.ADVANCE_TIME), "Native daylight rule is frozen");
+                    command(s, "time set 3000");
+                    command(s, "gamemode spectator @a");
+                    if (s.getGlobalGameRules().get(GameRules.SPAWN_MOBS))
+                        command(s, "gamerule " + GameRules.SPAWN_MOBS.id() + " false");
+                    var level = s.overworld();
+                    var entities = new java.util.ArrayList<net.minecraft.world.entity.Entity>();
+                    level.getAllEntities().forEach(entities::add);
+                    entities.stream().filter(e -> !(e instanceof net.minecraft.server.level.ServerPlayer))
+                            .forEach(net.minecraft.world.entity.Entity::discard);
+                    // The elevated platform isolates the samples from grass, mobs and flat-world lighting.
+                    for (int x = -24; x <= 24; x++) for (int z = -24; z <= 24; z++) {
+                        level.setBlockAndUpdate(new BlockPos(x, FLOOR, z), Blocks.CONCRETE.white().defaultBlockState());
+                    }
+                    pillar(s, true);
+                    // Coloured casters cannot be mistaken for neutral white receiving ground.
+                    level.setBlockAndUpdate(SLAB, Blocks.RED_SANDSTONE_SLAB.defaultBlockState());
+                    level.setBlockAndUpdate(STAIR, Blocks.RED_SANDSTONE_STAIRS.defaultBlockState()
+                            .setValue(StairBlock.FACING, Direction.WEST));
+                });
+                camera(c, server, -2, FLOOR + 18, 1, 70);
+                c.waitFor(m -> m.level.getBlockState(new BlockPos(0, FLOOR + 8, 0)).is(Blocks.CONCRETE.red())
+                        && m.level.getBlockState(SLAB).is(Blocks.RED_SANDSTONE_SLAB)
+                        && m.level.getBlockState(STAIR).is(Blocks.RED_SANDSTONE_STAIRS), 200);
+                c.waitFor(m -> {
+                    for(int x=-24;x<=24;x+=8) for(int z=-24;z<=24;z+=8)
+                        if(!m.level.getBlockState(new BlockPos(x,FLOOR,z)).is(Blocks.CONCRETE.white()))return false;
+                    return m.levelRenderer.hasRenderedAllSections();
+                },1200);
+                c.waitTicks(40);
+                c.runOnClient(m -> check(VanillaLight.active(), "Native Sanctuary shader is active without an external engine"));
+                float morning = c.computeOnClient(m -> m.gameRenderer.gameRenderState().levelRenderState.skyRenderState.sunAngle);
+
+                // Keep VanillaLight enabled for both frames: changing its fog/grade would invalidate this oracle.
+                shadows(c, false);
+                var off = capture(c, "day-off");
+                c.waitTicks(6);
+                unchanged(off, capture(c, null), "Fixed camera/daylight OFF control");
+                shadows(c, true);
+                var on = capture(c, "day-on-pillar-slab-stair");
+                var day = compare(off, on);
+                localShadow(day, "Pillar/slab/stair daylight ground", .70);
+                c.runOnClient(m -> {
+                    check(Float.compare(morning, m.gameRenderer.gameRenderState().levelRenderState.skyRenderState.sunAngle) == 0,
+                            "Native rule actually freezes the rendered sun angle");
+                    check(PixelShadows.shadowMap() != null, "Daylight allocates a real shadow target");
+                    check(PixelShadows.shadowMap().width == PixelShadows.mapSize(32, 16), "Shadow map follows selected quality");
+                });
+                for (int pixels : new int[]{8, 32, 16}) {
+                    c.runOnClient(m -> VanillaLight.setShadowPixels(pixels));
+                    activeFrames(c);
+                    c.runOnClient(m -> check(PixelShadows.shadowMap().width == PixelShadows.mapSize(32, pixels),
+                            "Live pixel density reallocates the correct depth map"));
+                    capture(c, "precision-" + pixels);
+                }
+                for (int distance : new int[]{16, 64, 128, 256, 32}) {
+                    c.runOnClient(m -> VanillaLight.setShadowDistance(distance));
+                    activeFrames(c);
+                    c.runOnClient(m -> check(PixelShadows.shadowMap().width == PixelShadows.mapSize(distance, 16),
+                            "Live distance reallocates the correct depth map"));
+                }
+                shadows(c, false);
+                unchanged(off, capture(c, "day-off-restored"), "Disabling removes the shadow without residual grading");
+
+                // Aim at the shadow's far end, with its entire caster outside the actual camera frustum.
+                shadows(c, true);
+                double shadowX = c.computeOnClient(m -> {
+                    var sun = PixelShadows.sunDirection(m.gameRenderer.gameRenderState().levelRenderState.skyRenderState.sunAngle);
+                    check(sun.y > .2f && Math.abs(sun.x / sun.y) > .5f, "Morning has an oblique sun for offscreen casting");
+                    return 1.0 - 7.0 * sun.x / sun.y;
+                });
+                camera(c, server, shadowX, FLOOR + 5, 1, 30);
+                c.runOnClient(m -> {
+                    var state = m.gameRenderer.gameRenderState().levelRenderState.cameraRenderState;
+                    var frustum = new Frustum(state.viewRotationMatrix, state.projectionMatrix);
+                    frustum.prepare(state.pos.x, state.pos.y, state.pos.z);
+                    check(!frustum.isVisible(PILLAR), "Whole pillar is outside the receiver camera frustum");
+                    check(!frustum.isVisible(new AABB(SLAB)) && !frustum.isVisible(new AABB(STAIR)),
+                            "Slab and stair are also outside the offscreen capture");
+                });
+                shadows(c, false);
+                var offscreenOff = capture(c, "offscreen-off");
+                shadows(c, true);
+                var offscreenOn = capture(c, "offscreen-on");
+                localShadow(compare(offscreenOff, offscreenOn), "Offscreen pillar still casts onto visible ground", .20);
+
+                // Do not toggle/release/rebuild the renderer here: real server edits must invalidate its live cache.
+                server.runOnServer(s -> pillar(s, false));
+                c.waitFor(m -> m.level.getBlockState(new BlockPos(0, FLOOR + 8, 0)).isAir(), 200);
+                activeFrames(c);
+                var removed = capture(c, "offscreen-caster-removed");
+                restoredGround(offscreenOff, offscreenOn, removed);
+                server.runOnServer(s -> pillar(s, true));
+                c.waitFor(m -> m.level.getBlockState(new BlockPos(0, FLOOR + 8, 0)).is(Blocks.CONCRETE.red()), 200);
+                activeFrames(c);
+                var replaced = capture(c, "offscreen-caster-replaced");
+                localShadow(compare(offscreenOff, replaced), "Replacing caster restores its shadow", .20);
+                unchanged(offscreenOn, replaced, "Same caster restores the same ground shadow");
+
+                // beta.128: the moon now casts a weaker shadow using its native celestial angle.
+                server.runOnServer(s -> command(s, "time set 15000"));
+                c.waitFor(m -> PixelShadows.sunDirection(m.gameRenderer.gameRenderState().levelRenderState.skyRenderState.sunAngle).y < 0, 200);
+                camera(c, server, -2, FLOOR + 18, 1, 70);
+                shadows(c, false);
+                var moonOff = capture(c, "moon-off");
+                shadows(c, true);
+                var moonOn = capture(c, "moon-on");
+                var moonStats = opacity(moonOff, moonOn);
+                check(moonStats.dark > 100 && moonStats.maximum > .025 && moonStats.maximum < .14,
+                        "Moon creates localized subtle shadows: " + moonStats);
+                unchanged(moonOn, capture(c, null), "Frozen moon shadow is stable");
+                server.runOnServer(s -> command(s, "time set 111000"));
+                c.waitFor(m -> m.gameRenderer.gameRenderState().levelRenderState.skyRenderState.moonPhase.index() == 4
+                        && !PixelShadows.applied(), 200);
+                c.waitTicks(6);
+                int newMoonFrames = c.computeOnClient(m -> PixelShadows.renderedFrames());
+                c.waitTicks(6);
+                c.runOnClient(m -> check(PixelShadows.renderedFrames() == newMoonFrames, "New moon submits no shadow pass"));
+                noonAndFoliage(c, server);
+
+                c.waitFor(m -> PixelShadows.sunDirection(m.gameRenderer.gameRenderState().levelRenderState.skyRenderState.sunAngle).y > .2f,
+                        200);
+                shadows(c, true);
+                camera(c, server, -2, FLOOR + 18, 1, 70);
+                c.waitTicks(30);
+                var beforeReload = capture(c, "before-reload");
+                var reload = c.computeOnClient(Minecraft::reloadResourcePacks);
+                c.waitFor(m -> reload.isDone() && m.gui.overlay() == null, 1200);
+                reload.join();
+                c.runOnClient(m -> {
+                    forgetPreferences();
+                    check(VanillaLight.enabled() && VanillaLight.pixelShadows()
+                            && VanillaLight.shadowPixels() == 16 && VanillaLight.shadowDistance() == 32,
+                            "Resource reload and disk reread retain enabled shadow preferences");
+                });
+                activeFrames(c);
+                unchanged(beforeReload, capture(c, "after-reload"), "Resource reload preserves the rendered ground shadow");
+                RealtimeShadows129ClientChecks.run(c, server);
+                EdgeHighlights129ClientChecks.run(c, server);
+                c.getInput().pressKey(InputConstants.KEY_F1);
+                for (String locale : new String[]{"fr_fr", "en_us"}) {
+                    c.runOnClient(m -> {
+                        m.getLanguageManager().setSelected(locale);
+                        m.getLanguageManager().onResourceManagerReload(m.getResourceManager());
+                        for (String key : new String[]{"pixel_shadows", "shadow_pixels", "shadow_distance", "edge_highlights", "edge_intensity", "edge_distance"}) {
+                            String fullKey = "sanctuary.shaders." + key;
+                            check(!Component.translatable(fullKey).getString().equals(fullKey), "Translated " + locale + " " + key);
+                        }
+                        m.gui.setScreen(new ShaderOptionsScreen(null));
+                        widgets(m.gui.screen()).filter(net.minecraft.client.gui.components.CycleButton.class::isInstance)
+                                .map(net.minecraft.client.gui.components.AbstractWidget.class::cast).forEach(button -> {
+                                    check(m.font.width(button.getMessage()) < button.getWidth() - 8,
+                                            "Localized shader cycle fits: " + button.getMessage().getString());
+                                });
+                    });
+                    c.waitTicks(3);
+                    c.takeScreenshot("sanctuary-beta129-shadows-options-" + locale);
+                }
+                c.runOnClient(m -> m.gui.setScreen(null));
+            }
+            System.out.println("PIXEL_SHADOWS122_CLIENT_PASS: bounded saved preferences; native GPU ON/OFF ground; "
+                    + "offscreen caster; live removal/replacement; subtle moon; full-strength noon; foliage density; camera stability; resource reload; FR/EN screenshots");
+        } finally {
+            onboarding.set(false);
+            c.runOnClient(m -> {
+                PixelShadows.release();
+                originalOptions.restore(m);
+                IntroClient.setQuickTestIntro(false);
+                try {
+                    if (originalPreferences == null) Files.deleteIfExists(path);
+                    else Files.write(path, originalPreferences);
+                } catch (IOException e) {
+                    throw new AssertionError("Cannot restore shader preferences", e);
+                } finally {
+                    forgetPreferences();
+                }
+            });
+        }
+    }
+
+    private static void noonAndFoliage(ClientGameTestContext c, TestServerContext server) {
+        // Overhead caster keeps a visible noon shadow while the camera sits below it.
+        server.runOnServer(s -> {
+            pillar(s, false);
+            s.overworld().setBlockAndUpdate(SLAB, Blocks.AIR.defaultBlockState());
+            s.overworld().setBlockAndUpdate(STAIR, Blocks.AIR.defaultBlockState());
+            canopy(s, 1, false, 3);
+            command(s, "time set 6000");
+        });
+        camera(c, server, .99999, FLOOR + 5, 1, 70);
+        c.waitTicks(30);
+        shadows(c, false);
+        var noonOff = capture(c, "noon-off");
+        shadows(c, true);
+        var noonOn = capture(c, "noon-on");
+        var noonStats = opacity(noonOff, noonOn);
+        crispEdge(noonOff, noonOn);
+        check(noonStats.dark > 100 && noonStats.maximum > .34 && noonStats.maximum < .42,
+                "Noon shadow keeps its full daytime strength: " + noonStats);
+        camera(c, server, 1.00001, FLOOR + 5, 1, 70);
+        unchanged(noonOn, capture(c, "noon-camera-subpixel"), "Noon tiny motion across former integer anchor");
+        camera(c, server, .99999, FLOOR + 5, 1, 70);
+        unchanged(noonOn, capture(c, null), "Noon camera return");
+        look(c, server, 35, 60);
+        shadows(c, false);
+        var obliqueOff = capture(c, "noon-oblique-off");
+        shadows(c, true);
+        var obliqueNoon = capture(c, "noon-oblique");
+        localShadow(compare(obliqueOff, obliqueNoon), "Oblique noon camera sees actual white receiving ground", .10);
+        look(c, server, 35.00002f, 60.00002f);
+        unchanged(obliqueNoon, capture(c, null), "Subpixel rotation with an oblique receiver");
+        // Both sides of noon, frozen individually: no frame-to-frame edge flicker.
+        for (int time : new int[]{5990, 6010}) {
+            server.runOnServer(s -> command(s, "time set " + time));
+            c.waitTicks(10);
+            var stable = capture(c, "noon-" + time);
+            c.waitTicks(10);
+            unchanged(stable, capture(c, null), "Frozen near-noon " + time);
+        }
+        server.runOnServer(s -> command(s, "time set 5999"));
+        c.waitTicks(10);
+        var beforeNoon = capture(c, null);
+        server.runOnServer(s -> command(s, "time set 6001"));
+        c.waitTicks(10);
+        unchanged(beforeNoon, capture(c, "noon-crossing"), "Continuous passage through noon has no large flip");
+        server.runOnServer(s -> {
+            canopy(s, 1, true, 16);
+            command(s, "time set 3000");
+        });
+        camera(c, server, 0, FLOOR + 5, 0, 60);
+        c.waitTicks(30);
+        shadows(c, false);
+        var thinOff = capture(c, "leaves-thin-off");
+        shadows(c, true);
+        var thinOn = capture(c, "leaves-thin-on");
+        var thin = opacity(thinOff, thinOn);
+        c.waitTicks(8);
+        unchanged(thinOn, capture(c, null), "Leaf noise is independent of frame/time");
+        // Keep the live cache: adding inner leaf layers must invalidate it too.
+        server.runOnServer(s -> canopy(s, 4, true, 16));
+        c.waitTicks(30);
+        activeFrames(c);
+        var thickOn = capture(c, "leaves-thick-on");
+        shadows(c, false);
+        var thickOff = capture(c, "leaves-thick-off");
+        var thick = opacity(thickOff, thickOn);
+        server.runOnServer(s -> canopy(s, 4, false, 16));
+        c.waitTicks(30);
+        var solidOff = capture(c, "canopy-solid-off");
+        shadows(c, true);
+        var solid = opacity(solidOff, capture(c, "canopy-solid-on"));
+        check(thin.mean > .02 && thick.mean > thin.mean + .025 && solid.mean > thick.mean + .01,
+                "Depth increases foliage opacity, bounded by solid: thin=" + thin + " thick=" + thick + " solid=" + solid);
+        check(thin.dark > 100 && thin.lit > 100, "Thin foliage has both light holes and shadows: " + thin);
+        server.runOnServer(s -> {
+            for (int x=-16;x<=16;x++) for(int z=-16;z<=16;z++) for(int y=FLOOR+10;y<FLOOR+13;y++)
+                s.overworld().setBlockAndUpdate(new BlockPos(x,y,z), Blocks.AIR.defaultBlockState());
+            canopy(s, 1, true, 16);
+        });
+        c.waitTicks(30);
+        // Crossing a 16-block origin boundary must preserve the same world shadow.
+        camera(c, server, 7.99999, FLOOR + 5, 0, 60);
+        activeFrames(c);
+        var boundary = capture(c, null);
+        camera(c, server, 8.00001, FLOOR + 5, 0, 60);
+        activeFrames(c);
+        unchanged(boundary, capture(c, "anchor-boundary"), "Subpixel motion across 16-block anchor");
+        System.out.println("SHADOWS128_PASS moon/noon plus stable anchors; foliage thin=" + thin + " thick=" + thick + " solid=" + solid);
+        server.runOnServer(s -> {
+            for (int x=-16;x<=16;x++) for(int z=-16;z<=16;z++) for(int y=FLOOR+9;y<FLOOR+13;y++)
+                s.overworld().setBlockAndUpdate(new BlockPos(x,y,z), Blocks.AIR.defaultBlockState());
+            pillar(s, true);
+        });
+    }
+
+    private static void canopy(MinecraftServer s, int layers, boolean leaves, int radius) {
+        var state = leaves ? Blocks.OAK_LEAVES.defaultBlockState().setValue(net.minecraft.world.level.block.LeavesBlock.PERSISTENT, true)
+                : Blocks.CONCRETE.red().defaultBlockState();
+        for (int x=-radius;x<=radius;x++) for(int z=-radius;z<=radius;z++) for(int y=FLOOR+9;y<FLOOR+9+layers;y++)
+            s.overworld().setBlockAndUpdate(new BlockPos(x,y,z), state);
+    }
+
+    private static void crispEdge(Frame off, Frame on) {
+        int samples = 0, intermediate = 0;
+        for (int y=off.height/10;y<off.height*9/10;y+=2) for (int x=off.width/10;x<off.width*9/10;x+=2) {
+            int i=y*off.width+x;
+            if (!whiteGround(off.pixels[i])) continue;
+            samples++;
+            double ratio=(brightness(off.pixels[i])-brightness(on.pixels[i]))/(double)brightness(off.pixels[i]);
+            if (ratio > .015 && ratio < .32) intermediate++;
+        }
+        check(samples > 1000 && intermediate < samples / 200,
+                "Opaque noon edge stays crisp, no foliage smoothing: " + intermediate + "/" + samples);
+        System.out.println("SHADOWS128_CRISP intermediate=" + intermediate + "/" + samples);
+    }
+
+    private record Opacity(int samples, int dark, int lit, double mean, double maximum) { }
+    private static Opacity opacity(Frame off, Frame on) {
+        sameSize(off,on);
+        int samples=0,dark=0,lit=0;double sum=0,maximum=0;
+        for(int y=off.height/10;y<off.height*9/10;y+=2) for(int x=off.width/10;x<off.width*9/10;x+=2) {
+            int i=y*off.width+x,a=off.pixels[i],b=on.pixels[i];
+            int r=a>>16&255,g=a>>8&255,blue=a&255;
+            if(Math.min(r,Math.min(g,blue))<24 || Math.max(r,Math.max(g,blue))-Math.min(r,Math.min(g,blue))>64)continue;
+            double ratio=(brightness(a)-brightness(b))/(double)brightness(a);
+            samples++;sum+=ratio;maximum=Math.max(maximum,ratio);
+            if(ratio>.02)dark++;else if(Math.abs(ratio)<.01)lit++;
+        }
+        check(samples>1000,"White concrete (including blue moonlight) available for shadow opacity");
+        var result=new Opacity(samples,dark,lit,sum/samples,maximum);
+        System.out.println("SHADOWS128_OPACITY " + result);
+        return result;
+    }
+
+    private static java.util.stream.Stream<net.minecraft.client.gui.components.events.GuiEventListener> widgets(
+            net.minecraft.client.gui.components.events.ContainerEventHandler root) {
+        return root.children().stream().flatMap(widget -> widget instanceof net.minecraft.client.gui.components.events.ContainerEventHandler child
+                ? java.util.stream.Stream.concat(java.util.stream.Stream.of(widget), widgets(child)) : java.util.stream.Stream.of(widget));
+    }
+
+    private static void checkPreferences() {
+        VanillaLight.setEnabled(true);
+        VanillaLight.setEdgeHighlights(false);
+        VanillaLight.setSaturation(100);
+        for (int[] pair : new int[][]{{Integer.MIN_VALUE, 8}, {11, 8}, {12, 16}, {16, 16}, {23, 16}, {24, 32}, {Integer.MAX_VALUE, 32}}) {
+            VanillaLight.setShadowPixels(pair[0]);
+            forgetPreferences();
+            check(VanillaLight.shadowPixels() == pair[1], "Persisted pixel density rounds/clamps " + pair[0]);
+        }
+        for (int[] pair : new int[][]{{Integer.MIN_VALUE, 16}, {23, 16}, {24, 32}, {32, 32}, {47, 32}, {48, 64}, {95,64}, {96,128}, {191,128}, {192,256}, {256,256}, {Integer.MAX_VALUE, 256}}) {
+            VanillaLight.setShadowDistance(pair[0]);
+            forgetPreferences();
+            check(VanillaLight.shadowDistance() == pair[1], "Persisted shadow distance rounds/clamps " + pair[0]);
+        }
+        for (boolean enabled : new boolean[]{true, false}) {
+            VanillaLight.setPixelShadows(enabled);
+            forgetPreferences();
+            check(VanillaLight.pixelShadows() == enabled && VanillaLight.enabled(), "Saved shadow toggle is independent of main shader");
+        }
+        VanillaLight.setShadowPixels(16);
+        VanillaLight.setShadowDistance(32);
+    }
+
+    static void forgetPreferences() {
+        try {
+            var field = VanillaLight.class.getDeclaredField("preferences");
+            field.setAccessible(true);
+            field.set(null, null);
+        } catch (ReflectiveOperationException e) {
+            throw new AssertionError("Cannot reread actual shader preferences", e);
+        }
+    }
+
+    static void camera(ClientGameTestContext c, TestServerContext server, double x, double y, double z, int fov) {
+        server.runOnServer(s -> {
+            var p = s.getPlayerList().getPlayers().getFirst();
+            command(s, "tp @a " + x + " " + y + " " + z + " 0 90");
+            p.setDeltaMovement(Vec3.ZERO);
+        });
+        c.waitFor(m -> m.player.position().distanceToSqr(new Vec3(x, y, z)) < .0001
+                && Math.abs(m.player.getXRot() - 90) < .001, 200);
+        c.runOnClient(m -> {
+            m.options.fov().set(fov);
+            m.player.setYRot(0);
+            m.player.yRotO = 0;
+            m.player.setXRot(90);
+            m.player.xRotO = 90;
+            m.player.setDeltaMovement(Vec3.ZERO);
+        });
+        c.waitTicks(15);
+    }
+
+    static void look(ClientGameTestContext c, TestServerContext server, float yaw, float pitch) {
+        server.runOnServer(s -> {
+            var p = s.getPlayerList().getPlayers().getFirst();
+            command(s, "tp @a " + p.getX() + " " + p.getY() + " " + p.getZ() + " " + yaw + " " + pitch);
+        });
+        c.waitFor(m -> Math.abs(m.player.getXRot() - pitch) < .00001
+                && Math.abs(m.player.getYRot() - yaw) < .00001, 200);
+        c.waitTicks(15);
+    }
+
+    private static void pillar(MinecraftServer s, boolean present) {
+        for (int x = 0; x < 2; x++) for (int z = 0; z < 2; z++) for (int y = FLOOR + 1; y <= FLOOR + 8; y++) {
+            s.overworld().setBlockAndUpdate(new BlockPos(x, y, z),
+                    (present ? Blocks.CONCRETE.red() : Blocks.AIR).defaultBlockState());
+        }
+    }
+
+    static void command(MinecraftServer s, String command) {
+        try {
+            // Dispatcher exceptions fail the fixture instead of leaving an ignored command error in chat.
+            s.getCommands().getDispatcher().execute(command, s.createCommandSourceStack());
+        } catch (com.mojang.brigadier.exceptions.CommandSyntaxException e) {
+            throw new AssertionError("Fixture command failed: " + command, e);
+        }
+    }
+
+    static void shadows(ClientGameTestContext c, boolean enabled) {
+        c.runOnClient(m -> VanillaLight.setPixelShadows(enabled));
+        if (enabled) activeFrames(c);
+        else {
+            c.waitTicks(6);
+            int frames = c.computeOnClient(m -> {
+                check(!PixelShadows.applied() && PixelShadows.shadowMap() == null, "OFF releases the GPU shadow target");
+                return PixelShadows.renderedFrames();
+            });
+            c.waitTicks(3);
+            c.runOnClient(m -> check(PixelShadows.renderedFrames() == frames, "OFF submits no shadow frames"));
+        }
+    }
+
+    static void activeFrames(ClientGameTestContext c) {
+        int before = c.computeOnClient(m -> PixelShadows.renderedFrames());
+        c.waitFor(m -> PixelShadows.applied() && PixelShadows.ready() && PixelShadows.renderedFrames() > before + 12, 200);
+        // Allow the bounded terrain cache and native light/chunk uploads to settle before reading pixels.
+        c.waitTicks(30);
+    }
+
+    static Frame capture(ClientGameTestContext c, String name) {
+        if (name != null) c.takeScreenshot("sanctuary-beta129-shadows-" + name);
+        var result = new CompletableFuture<Frame>();
+        c.runOnClient(m -> Screenshot.takeScreenshot(m.gameRenderer.mainRenderTarget(), image -> {
+            try (image) {
+                result.complete(new Frame(image.getWidth(), image.getHeight(), image.getPixels()));
+            } catch (Throwable e) {
+                result.completeExceptionally(e);
+            }
+        }));
+        c.waitFor(m -> result.isDone(), 200);
+        return result.join();
+    }
+
+    record Frame(int width, int height, int[] pixels) { }
+    private record Difference(int sampled, int ground, int dark, int stable, int brighter) { }
+
+    private static Difference compare(Frame before, Frame after) {
+        sameSize(before, after);
+        int sampled = 0, ground = 0, dark = 0, stable = 0, brighter = 0;
+        // Skip borders and sample every other pixel; no PNG decoding, image libraries or golden screenshot dependency.
+        for (int y = before.height / 10; y < before.height * 9 / 10; y += 2) {
+            for (int x = before.width / 10; x < before.width * 9 / 10; x += 2) {
+                sampled++;
+                int a = before.pixels[y * before.width + x], b = after.pixels[y * after.width + x];
+                if (!whiteGround(a)) continue;
+                ground++;
+                int delta = brightness(a) - brightness(b);
+                if (delta >= DARK_DELTA) dark++;
+                if (delta <= -DARK_DELTA) brighter++;
+                if (channelDifference(a, b) <= 3) stable++;
+            }
+        }
+        return new Difference(sampled, ground, dark, stable, brighter);
+    }
+
+    private static void localShadow(Difference d, String label, double minimumStable) {
+        System.out.println("PIXEL_SHADOWS122_PIXELS " + label + ": " + d);
+        check(d.ground > d.sampled * .50, label + ": a majority of samples must be actual white receiving ground: " + d);
+        check(d.dark >= Math.max(24, d.ground / 1000), label + ": measurable cast-shadow darkening: " + d);
+        check(d.stable > d.ground * minimumStable, label + ": unshadowed ground stays unchanged; reject a global tint: " + d);
+        check(d.brighter < Math.max(12, d.ground / 100), label + ": shadows must not brighten ground: " + d);
+    }
+
+    static void unchanged(Frame before, Frame after, String label) {
+        sameSize(before, after);
+        int sampled = 0, changed = 0;
+        for (int y = before.height / 10; y < before.height * 9 / 10; y += 2) {
+            for (int x = before.width / 10; x < before.width * 9 / 10; x += 2) {
+                sampled++;
+                int i = y * before.width + x;
+                if (channelDifference(before.pixels[i], after.pixels[i]) > 3) changed++;
+            }
+        }
+        check(sampled > 0 && changed <= sampled / 100, label + ": changed=" + changed + "/" + sampled);
+    }
+
+    private static void restoredGround(Frame off, Frame on, Frame removed) {
+        sameSize(off, on);
+        sameSize(off, removed);
+        int shadow = 0, restored = 0, lit = 0, stable = 0;
+        for (int y = off.height / 10; y < off.height * 9 / 10; y += 2) {
+            for (int x = off.width / 10; x < off.width * 9 / 10; x += 2) {
+                int i = y * off.width + x;
+                if (!whiteGround(off.pixels[i])) continue;
+                if (brightness(off.pixels[i]) - brightness(on.pixels[i]) >= DARK_DELTA) {
+                    shadow++;
+                    if (brightness(removed.pixels[i]) - brightness(on.pixels[i]) >= DARK_DELTA
+                            && channelDifference(off.pixels[i], removed.pixels[i]) <= 4) restored++;
+                } else if (channelDifference(off.pixels[i], on.pixels[i]) <= 3) {
+                    lit++;
+                    if (channelDifference(on.pixels[i], removed.pixels[i]) <= 3) stable++;
+                }
+            }
+        }
+        check(shadow >= 24 && restored > shadow * .85,
+                "Removing offscreen caster relights its former shadow: " + restored + "/" + shadow);
+        check(lit >= 24 && stable > lit * .98,
+                "Removing caster preserves already sunlit ground: " + stable + "/" + lit);
+        System.out.println("PIXEL_SHADOWS122_EDIT restored=" + restored + "/" + shadow + " litStable=" + stable + "/" + lit);
+    }
+
+    private static boolean whiteGround(int color) {
+        int r = color >> 16 & 255, g = color >> 8 & 255, b = color & 255;
+        return Math.min(r, Math.min(g, b)) > 100 && Math.max(r, Math.max(g, b)) - Math.min(r, Math.min(g, b)) < 24;
+    }
+
+    static int brightness(int color) {
+        return ((color >> 16 & 255) + (color >> 8 & 255) + (color & 255)) / 3;
+    }
+
+    static int channelDifference(int a, int b) {
+        return Math.max(Math.abs((a >> 16 & 255) - (b >> 16 & 255)),
+                Math.max(Math.abs((a >> 8 & 255) - (b >> 8 & 255)), Math.abs((a & 255) - (b & 255))));
+    }
+
+    private static void sameSize(Frame a, Frame b) {
+        check(a.width == b.width && a.height == b.height && a.pixels.length == b.pixels.length,
+                "GPU comparison requires the same framebuffer dimensions");
+    }
+
+    private record Options(int distance, int simulationDistance, int fov, boolean bob,
+                           boolean pause, CameraType camera, String language) {
+        static Options capture(Minecraft m) {
+            return new Options(m.options.renderDistance().get(), m.options.simulationDistance().get(), m.options.fov().get(),
+                    m.options.bobView().get(), m.options.pauseOnLostFocus,
+                    m.options.getCameraType(), m.getLanguageManager().getSelected());
+        }
+
+        void restore(Minecraft m) {
+            m.options.renderDistance().set(distance);
+            m.options.simulationDistance().set(simulationDistance);
+            m.options.fov().set(fov);
+            m.options.bobView().set(bob);
+            m.options.pauseOnLostFocus = pause;
+            m.options.setCameraType(camera);
+            m.getLanguageManager().setSelected(language);
+            m.getLanguageManager().onResourceManagerReload(m.getResourceManager());
+        }
+    }
+
+    private static KeyEvent enter() { return new KeyEvent(InputConstants.KEY_RETURN, 0, 0); }
+    static void check(boolean ok, String message) { if (!ok) throw new AssertionError(message); }
+}

mods/sanctuary/src/clientGametest/java/fr/koka/sanctuary/client/shader/RealtimeShadows129ClientChecks.java

@@ -0,0 +1,115 @@
+package fr.koka.sanctuary.client.shader;
+
+import static fr.koka.sanctuary.client.shader.PixelShadows122ClientChecks.*;
+
+import fr.koka.sanctuary.realtime.RealtimeService;
+import java.time.Clock;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+import net.fabricmc.fabric.api.client.gametest.v1.context.ClientGameTestContext;
+import net.fabricmc.fabric.api.client.gametest.v1.context.TestServerContext;
+import net.fabricmc.fabric.api.client.rendering.v1.level.LevelRenderEvents;
+
+final class RealtimeShadows129ClientChecks {
+    private static void projectionContinuity() {
+        // Far coordinates amplify the old per-frame rounding failure. Moving the sun must not
+        // add a periodic translation to the shadow raster while the camera remains stationary.
+        var grid=new ShadowProjection();
+        float last=0; int jumps=0; float greatest=0;
+        for(int i=0;i<2000;i++) {
+            var matrix=grid.matrix(PixelShadows.sunDirection(.7f+i*.000001f),32,2048,100000,64,-100000,false);
+            if(i>0){float step=Math.abs(matrix.m31()-last);greatest=Math.max(greatest,step);if(step>1e-6f)jumps++;}
+            last=matrix.m31();
+        }
+        check(jumps==0,"Slow light rotation has no cyclical raster translation far from spawn: "+greatest);
+        // Recentring transfers the phase modulo integral texels, preserving the sampled grid.
+        var sun=PixelShadows.sunDirection(.71f);
+        var before=grid.matrix(sun,32,2048,100000,64,-100000,false);
+        var after=grid.matrix(sun,32,2048,100016,64,-100000,false);
+        var a=before.transform(new org.joml.Vector4f(4,1,2,1));
+        var b=after.transform(new org.joml.Vector4f(-12,1,2,1));
+        for(float value:new float[]{(b.x-a.x)*1024,(b.y-a.y)*1024})
+            check(Math.abs(value-Math.rint(value))<.001,"Camera recentering moves only whole shadow texels");
+    }
+
+    static void run(ClientGameTestContext c, TestServerContext server) {
+        projectionContinuity();
+        var enabled=new AtomicBoolean(false);
+        var trace=Collections.synchronizedList(new ArrayList<double[]>());
+        LevelRenderEvents.END_EXTRACTION.register(context -> {
+            if(enabled.get() && trace.size()<4096)trace.add(new double[]{System.nanoTime()/1e9,context.levelState().skyRenderState.sunAngle});
+        });
+        var original=new AtomicReference<Clock>();
+        try {
+            server.runOnServer(s -> {
+                var session=RealtimeService.session(s);
+                check(session!=null,"Isolated world has the actual real-time service");
+                try {
+                    var field=session.getClass().getDeclaredField("clock");field.setAccessible(true);
+                    original.set((Clock)field.get(session));
+                    var morning=session.sample().day().noon().minusSeconds(3*3600);
+                    field.set(session,Clock.offset(Clock.systemUTC(),Duration.between(Instant.now(),morning)));
+                    check(RealtimeService.setMode(s,true),"Real-time mode enabled through actual server service");
+                } catch(ReflectiveOperationException e) {throw new AssertionError(e);}
+                catch(Exception e) {throw new AssertionError(e);}
+            });
+            c.waitFor(m -> PixelShadows.sunDirection(m.gameRenderer.gameRenderState().levelRenderState.skyRenderState.sunAngle).y>.2,200);
+            c.waitTicks(40);
+            double shadowX=c.computeOnClient(m -> {
+                var sun=PixelShadows.sunDirection(m.gameRenderer.gameRenderState().levelRenderState.skyRenderState.sunAngle);
+                return 1-7*sun.x/sun.y;
+            });
+            camera(c,server,shadowX,69,1,30);
+            shadows(c,false);
+            var off=capture(c,null);
+            shadows(c,true);
+            enabled.set(true);
+            var frames=new ArrayList<Frame>();
+            for(int i=0;i<24;i++) {c.waitTicks(6);frames.add(capture(c,i==0?"realtime-start":i==23?"realtime-end":null));}
+            c.runOnClient(m -> enabled.set(false));
+            double travel=Math.IEEEremainder(trace.getLast()[1]-trace.getFirst()[1],Math.PI*2);
+            int reverse=0;double largest=0;
+            for(int i=1;i<trace.size();i++) {
+                double delta=Math.IEEEremainder(trace.get(i)[1]-trace.get(i-1)[1],Math.PI*2)*Math.signum(travel);
+                if(delta<-.0000001){reverse++;largest=Math.max(largest,-delta);}
+            }
+            int samples=0,changed=0,rebound=0;
+            for(int y=off.height()/10;y<off.height()*9/10;y+=2) for(int x=off.width()/10;x<off.width()*9/10;x+=2) {
+                int index=y*off.width()+x,a=off.pixels()[index];
+                int r=a>>16&255,g=a>>8&255,b=a&255;
+                if(Math.min(r,Math.min(g,b))<100 || Math.max(r,Math.max(g,b))-Math.min(r,Math.min(g,b))>24)continue;
+                samples++;int flips=0;
+                boolean last=brightness(a)-brightness(frames.getFirst().pixels()[index])>=8;
+                for(var frame:frames) {
+                    boolean dark=brightness(a)-brightness(frame.pixels()[index])>=8;
+                    if(last!=dark)flips++;
+                    last=dark;
+                }
+                if(flips>0)changed++;
+                if(flips>1)rebound++;
+            }
+            check(trace.size()>30 && Math.abs(travel)>.00001,"Real-time shadows actually remain dynamic");
+            check(rebound<Math.max(8,samples/1000),"Real-time opaque contours must not repeatedly rebound: "+rebound);
+            System.out.println("REALTIME129_PASS frames="+trace.size()+" rawTravel="+travel+" reversals="+reverse+" largestReverse="+largest
+                    +" pixels="+samples+" changed="+changed+" rebound="+rebound);
+            try {
+                var out=new StringBuilder("seconds,raw_angle\n");
+                for(var sample:trace)out.append(sample[0]).append(',').append(sample[1]).append('\n');
+                java.nio.file.Files.writeString(net.fabricmc.loader.api.FabricLoader.getInstance().getGameDir().resolve("shadow129-clock.csv"),out);
+            }catch(java.io.IOException e){throw new AssertionError(e);}
+        } finally {
+            enabled.set(false);
+            server.runOnServer(s -> {
+                try {
+                    RealtimeService.setMode(s,false);
+                    if(original.get()!=null){var session=RealtimeService.session(s);var field=session.getClass().getDeclaredField("clock");field.setAccessible(true);field.set(session,original.get());}
+                    command(s,"time set 3000");
+                }catch(Exception e){throw new AssertionError(e);}
+            });
+        }
+    }
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/SanctuaryMod.java

@@ -44,6 +44,7 @@ public final class SanctuaryMod implements ModInitializer {
     @Override
     public void onInitialize() {
         fr.koka.sanctuary.building.ColoredBricks.register();
+        fr.koka.sanctuary.gems.Gems.register();
         fr.koka.sanctuary.sky.VortexClouds.register();
         fr.koka.sanctuary.loading.PreloadProgress.register();
         fr.koka.sanctuary.progression.SanctuaryGameplay.register();

mods/sanctuary/src/main/java/fr/koka/sanctuary/building/ColoredBricks.java

@@ -12,7 +12,7 @@ import net.minecraft.world.level.block.state.BlockBehaviour;
 
 /** Native building blocks; no world-generation, ticking entities or custom inventory. */
 public final class ColoredBricks {
-    public record Family(DyeColor color,Block bricks,Block slab,Block stairs,Block clay,Item clayBall,Item brick){}
+    public record Family(DyeColor color,Block bricks,Block slab,Block stairs,Block wall,Block clay,Item clayBall,Item brick){}
     private static final List<Family> FAMILIES=new ArrayList<>();
     // The order used by the native 26.3 Colored Blocks tab, rather than dye numeric IDs.
     private static final List<DyeColor> CREATIVE_COLORS=List.of(
@@ -27,15 +27,17 @@ public final class ColoredBricks {
             var bricks=block(name+"_bricks",new Block(properties(name+"_bricks",Blocks.BRICKS,color)));
             var slab=block(name+"_brick_slab",new SlabBlock(properties(name+"_brick_slab",Blocks.BRICK_SLAB,color)));
             var stairs=block(name+"_brick_stairs",new Stairs(bricks,properties(name+"_brick_stairs",Blocks.BRICK_STAIRS,color)));
+            var wall=block(name+"_brick_wall",new WallBlock(properties(name+"_brick_wall",Blocks.BRICK_WALL,color)));
             var clay=block(name+"_clay",new Block(properties(name+"_clay",Blocks.CLAY,color)));
             var clayBall=item(name+"_clay_ball");var brick=item(name+"_brick");
-            FAMILIES.add(new Family(color,bricks,slab,stairs,clay,clayBall,brick));
+            FAMILIES.add(new Family(color,bricks,slab,stairs,wall,clay,clayBall,brick));
         }
         var display=FAMILIES.stream().sorted(Comparator.comparingInt(f->CREATIVE_COLORS.indexOf(f.color()))).toList();
         CreativeModeTabEvents.modifyOutputEvent(CreativeModeTabs.COLORED_BLOCKS).register(out->{
             for(var f:display)out.accept(f.bricks);
             for(var f:display)out.accept(f.stairs);
             for(var f:display)out.accept(f.slab);
+            for(var f:display)out.accept(f.wall);
             for(var f:display)out.accept(f.clay);
         });
         CreativeModeTabEvents.modifyOutputEvent(CreativeModeTabs.INGREDIENTS).register(out->{

mods/sanctuary/src/main/java/fr/koka/sanctuary/client/ClayWorkshopScreen.java

@@ -14,6 +14,7 @@ import net.minecraft.network.chat.Component;
 import net.minecraft.resources.Identifier;
 import net.minecraft.world.entity.player.Inventory;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
 
 /** File selection is local; the two ordinary inventory slots and every crafted item are server-owned. */
 public final class ClayWorkshopScreen extends AbstractContainerScreen<ClayWorkshopMenu> {
@@ -21,26 +22,37 @@ public final class ClayWorkshopScreen extends AbstractContainerScreen<ClayWorksh
     private static final Identifier SLOT=Identifier.withDefaultNamespace("container/slot");
     private static final Identifier SELECTION=fr.koka.sanctuary.SanctuaryMod.id("hud/hotbar_selection");
     private static final ExecutorService WORKER=Executors.newSingleThreadExecutor(r->{var t=new Thread(r,"Sanctuary clay models");t.setDaemon(true);return t;});
+    private boolean imported;
+    private List<net.minecraft.world.entity.EntityType<?>> animals=List.of();
     private List<Path> files=List.of();private int page,generation,ticks;private boolean busy,pending;
-    private VoxelSculpture source,previewSource;private ItemStack preview=ItemStack.EMPTY,lastClay=ItemStack.EMPTY;
+    private VoxelSculpture source,previewSource;private ItemStack preview=ItemStack.EMPTY,lastMaterial=ItemStack.EMPTY;
+    private SculpturePalette palette;private Object sampledResources;
     private Component status=text("choose_model");private Button rotate;
     public ClayWorkshopScreen(ClayWorkshopMenu menu,Inventory inv,Component title){super(menu,inv,title,310,202);}
     public static Component text(String key,Object...args){return Component.translatable("sanctuary.statuary."+key,args);}
     public static void register(){
         net.minecraft.client.gui.screens.MenuScreens.register(Statuary.MENU,ClayWorkshopScreen::new);StatuaryRenderer.register();
         net.fabricmc.fabric.api.client.item.v1.ItemTooltipCallback.EVENT.register((stack,context,flags,lines)->{
-            if(!stack.is(Statuary.ITEM))return;var sculpture=StatuaryEntity.sculpture(stack);if(sculpture!=null){lines.add(text("model_name",sculpture.name()));if(flags.isAdvanced())lines.add(Component.literal(sculpture.modelId()));}
+            if(!stack.is(Statuary.ITEM))return;var sculpture=StatuaryEntity.sculpture(stack);if(sculpture!=null){
+                if(!stack.getHoverName().getString().equals(Statuary.BLOCK.getName().getString()))lines.add(Statuary.BLOCK.getName());
+                lines.add(text("model_name",sculpture.name()));if(flags.isAdvanced())lines.add(Component.literal(sculpture.modelId()));}
         });
     }
     @Override protected void init(){
         super.init();
         try{files=CreationLibrary.files(CreationLibrary.Kind.MODEL);}catch(Exception e){status=ModelImportErrors.message(e);}
-        page=Math.min(page,Math.max(0,(files.size()-1)/4));
-        for(int i=0;i<4;i++){int at=page*4+i;if(at>=files.size())break;var file=files.get(at);
-            var label=Component.literal(file.getFileName().toString());var b=addRenderableWidget(Button.builder(label,p->load(file)).bounds(leftPos+10,topPos+32+i*18,128,17).build());b.setTooltip(Tooltip.create(label));}
+        animals=menu.view.statues().stream().map(net.minecraft.resources.Identifier::tryParse).filter(Objects::nonNull)
+            .<net.minecraft.world.entity.EntityType<?>>map(id->net.minecraft.core.registries.BuiltInRegistries.ENTITY_TYPE.getValue(id)).filter(Objects::nonNull)
+            .sorted(Comparator.comparing(t->t.getDescription().getString())).toList();
+        int count=imported?files.size():animals.size();page=Math.min(page,Math.max(0,(count-1)/4));
+        addRenderableWidget(Button.builder(text("animals"),b->{imported=false;page=0;rebuildWidgets();}).bounds(leftPos+10,topPos+19,62,16).build()).active=imported;
+        addRenderableWidget(Button.builder(text("imports"),b->{imported=true;page=0;rebuildWidgets();}).bounds(leftPos+74,topPos+19,64,16).build()).active=!imported;
+        for(int i=0;i<4;i++){int at=page*4+i;if(at>=count)break;
+            var label=imported?Component.literal(files.get(at).getFileName().toString()):animals.get(at).getDescription();
+            var b=addRenderableWidget(Button.builder(label,p->{if(imported)load(files.get(at));else load(animals.get(at));}).bounds(leftPos+10,topPos+36+i*17,128,17).build());b.setTooltip(Tooltip.create(label));}
         addRenderableWidget(Button.builder(Component.literal("←"),b->{page--;rebuildWidgets();}).bounds(leftPos+10,topPos+106,22,18).build()).active=page>0;
         addRenderableWidget(Button.builder(text("folder"),b->folder()).bounds(leftPos+35,topPos+106,78,18).build());
-        addRenderableWidget(Button.builder(Component.literal("→"),b->{page++;rebuildWidgets();}).bounds(leftPos+116,topPos+106,22,18).build()).active=(page+1)*4<files.size();
+        addRenderableWidget(Button.builder(Component.literal("→"),b->{page++;rebuildWidgets();}).bounds(leftPos+116,topPos+106,22,18).build()).active=(page+1)*4<count;
         addRenderableWidget(Button.builder(text("refresh"),b->rebuildWidgets()).bounds(leftPos+10,topPos+127,128,18).build());
         rotate=addRenderableWidget(Button.builder(text("rotate"),b->{if(source!=null){source=source.rotate();pending=true;}}).bounds(leftPos+148,topPos+127,152,18).build());rotate.active=source!=null&&!busy;
         rotate.setTooltip(Tooltip.create(text("placement")));
@@ -55,14 +67,43 @@ public final class ClayWorkshopScreen extends AbstractContainerScreen<ClayWorksh
                 source=sculpture;pending=true;status=text("ready",sculpture.name());
             }));
     }
+    public void load(net.minecraft.world.entity.EntityType<?> type){
+        var id=net.minecraft.core.registries.BuiltInRegistries.ENTITY_TYPE.getKey(type).toString();
+        if(busy||!menu.view.statues().contains(id))return;
+        try{
+            var entity=type.create(minecraft.level,net.minecraft.world.entity.EntitySpawnReason.MOB_SUMMONED);
+            if(entity==null)throw new IllegalArgumentException("unsupported_model");
+            entity.setId(Integer.MIN_VALUE+125);entity.setPos(minecraft.player.position());
+            // Native renderers and textures are read on the client thread; only voxelization runs in the worker.
+            var faces=StatueModels.capture(entity);String name=type.getDescription().getString();
+            busy=true;status=text("working");int token=++generation;
+            CompletableFuture.supplyAsync(()->VoxelSculpture.of(StatueDiscoveries.modelId(id),name,StatueVoxelizer.miniature(faces)),WORKER)
+                .whenComplete((sculpture,error)->minecraft.execute(()->{
+                    if(token!=generation||minecraft.gui.screen()!=this||minecraft.player==null||minecraft.player.containerMenu!=menu)return;
+                    busy=false;if(error!=null){fr.koka.sanctuary.SanctuaryMod.LOGGER.warn("Unable to sculpt creature {}",id,error);status=text("animal_error");return;}
+                    source=sculpture;pending=true;status=text("ready",name);
+                }));
+        }catch(Exception e){fr.koka.sanctuary.SanctuaryMod.LOGGER.warn("Unable to capture creature {}",id,e);status=text("animal_error");}
+    }
     @Override protected void containerTick(){
         super.containerTick();rotate.active=source!=null&&!busy;
-        if(pending&&++ticks>=5){ticks=0;pending=false;ClientPlayNetworking.send(new ClayWorkshopMenu.Select(menu.containerId,menu.view.token(),source));}
-        var clay=menu.getSlot(0).getItem();
-        if(previewSource!=source||!ItemStack.matches(lastClay,clay)){
-            previewSource=source;lastClay=clay.copy();var colored=ClayWorkshopMenu.material(source,clay);
-            preview=source==null?ItemStack.EMPTY:StatuaryEntity.item(colored==null?source:colored);
+        var material=menu.getSlot(0).getItem();var resources=minecraft.getModelManager().getBlockStateModelSet();
+        boolean changedMaterial=!ItemStack.isSameItemSameComponents(lastMaterial,material)||sampledResources!=resources;
+        if(previewSource!=source||changedMaterial){
+            previewSource=source;lastMaterial=material.copy();sampledResources=resources;
+            if(changedMaterial)palette=SculptureMaterialSampler.sample(material);
+            var colored=source==null?null:palette==null?source:ClayWorkshopMenu.appearance(source,material.getItem(),palette);
+            preview=colored==null?ItemStack.EMPTY:StatuaryEntity.item(colored);pending=true;
+            if(source!=null&&!busy)status=palette==null?text("choose_material"):material.is(Items.CLAY)?text("clay_ready"):text("material_ready",material.getHoverName());
         }
+        // Retry a selection that raced the input packet or server rate limit. The result is the
+        // acknowledgement; never predict consumption or manufacture an item on the client.
+        boolean needsResult=source!=null&&palette!=null&&!ItemStack.matches(preview,menu.getSlot(1).getItem());
+        if(++ticks>=5&&(pending||needsResult)){
+            ticks=0;pending=false;
+            if(source!=null&&palette!=null)ClientPlayNetworking.send(new ClayWorkshopMenu.Select(menu.containerId,menu.view.token(),source,material.getItem(),palette));
+        }
+
     }
     @Override public void onFilesDrop(List<Path> files){if(!files.isEmpty())load(files.getFirst());}
     @Override public void removed(){generation++;super.removed();}
@@ -80,12 +121,13 @@ public final class ClayWorkshopScreen extends AbstractContainerScreen<ClayWorksh
         g.text(font,Component.literal("→"),leftPos+254,topPos+111,0xFF404040,false);
         var detail=font.split(status,290);for(int i=0;i<Math.min(2,detail.size());i++)g.text(font,detail.get(i),leftPos+10,topPos+150+i*font.lineHeight,0xFF404040,false);
         if(detail.size()>2&&mx>=leftPos+10&&mx<leftPos+300&&my>=topPos+148&&my<topPos+174)g.setTooltipForNextFrame(font,status,mx,my);
-        if(files.isEmpty())g.text(font,text("empty"),leftPos+10,topPos+32,0xFF404040,false);
+        if(imported?files.isEmpty():animals.isEmpty()){var lines=font.split(text(imported?"empty":"no_animals"),128);for(int i=0;i<Math.min(6,lines.size());i++)g.text(font,lines.get(i),leftPos+10,topPos+38+i*font.lineHeight,0xFF404040,false);}
     }
     @Override protected void extractLabels(GuiGraphicsExtractor g,int mx,int my){
-        g.text(font,title,10,8,0xFF303030,false);g.text(font,text("models"),10,22,0xFF404040,false);
+        g.text(font,title,10,8,0xFF303030,false);
         g.text(font,text("input"),230-font.width(text("input"))/2,95,0xFF303030,false);g.text(font,text("output"),imageWidth-10-font.width(text("output")),95,0xFF303030,false);
     }
+    ItemStack preview(){return preview;}
     public boolean busy(){return busy;}
     public VoxelSculpture selected(){return source;}
 }

mods/sanctuary/src/main/java/fr/koka/sanctuary/client/MultiblockScreen.java

@@ -11,6 +11,7 @@ public final class MultiblockScreen extends ContainerScreen {
     private EditBox search;
     private Button previous,next,apply;
     private double wheel;
+    private boolean showHelp;
     private final java.util.List<Button> sections=new java.util.ArrayList<>();
     public MultiblockScreen(MultiblockMenu menu,Inventory inv,Component title){super(menu,inv,title);}
     private MultiblockMenu machine(){return (MultiblockMenu)menu;}
@@ -26,7 +27,10 @@ public final class MultiblockScreen extends ContainerScreen {
         apply=addRenderableWidget(Button.builder(Multiblocks.text("search"),b->change(0,v.section())).bounds(x,topPos+20,w,20).build());
         previous=addRenderableWidget(Button.builder(Component.literal("<"),b->change(v.page()-1,v.section())).bounds(x,topPos+44,w/2-1,20).build());
         next=addRenderableWidget(Button.builder(Component.literal(">"),b->change(v.page()+1,v.section())).bounds(x+w/2+1,topPos+44,w/2-1,20).build());
-        if(v.furnace())for(int n=0;n<3;n++){int section=n;var b=addRenderableWidget(Button.builder(Multiblocks.text(new String[]{"inputs","fuel","outputs"}[n]),button->change(0,section)).bounds(x,topPos+84+n*22,w,20).build());sections.add(b);}
+        if(v.furnace())for(int n=0;n<3;n++){int section=n;var b=addRenderableWidget(Button.builder(Multiblocks.text(new String[]{"inputs","fuel","outputs"}[n]),button->change(0,section)).bounds(x,topPos+44+n*22,w,20).build());sections.add(b);}
+        if(v.furnace())addRenderableWidget(Button.builder(Multiblocks.text("how_to_cook"),b->showHelp=!showHelp).bounds(x,topPos+142,w,20)
+            .tooltip(Tooltip.create(Multiblocks.text("cooking_help"))).build());
+        if(v.furnace()){previous.visible=false;next.visible=false;}
         controls();
     }
     @Override public boolean mouseScrolled(double x,double y,double horizontal,double vertical){
@@ -41,14 +45,46 @@ public final class MultiblockScreen extends ContainerScreen {
     @Override protected void containerTick(){super.containerTick();controls();}
     @Override protected void extractLabels(net.minecraft.client.gui.GuiGraphicsExtractor g,int mouseX,int mouseY){
         super.extractLabels(g,mouseX,mouseY);var m=machine();int x=imageWidth+4;
-        g.text(font,Multiblocks.text("page",m.view.page()+1,m.view.pages()),x,68,0xFFFFFFFF,false);
+        if(!m.view.furnace())g.text(font,Multiblocks.text("page",m.view.page()+1,m.view.pages()),x,68,0xFFFFFFFF,false);
         if(m.view.furnace()){
-            g.text(font,Multiblocks.text("heat",m.heat),x,154,0xFFFFFFFF,false);
-            g.text(font,Multiblocks.text("progress",m.progress),x,166,0xFFFFFFFF,false);
+            g.text(font,Multiblocks.text("heat",m.heat),x,116,0xFFFFFFFF,false);
+            g.text(font,Multiblocks.text("cooking_count",m.cooking),x,128,0xFFFFFFFF,false);
         }
         for(int i=m.view.indices().length;i<m.displaySlots();i++){var s=menu.getSlot(i);g.fill(s.x,s.y,s.x+16,s.y+16,0xB0181818);}
     }
-    public java.util.List<net.minecraft.client.renderer.Rect2i> extraAreas(){return search==null?java.util.List.of():java.util.List.of(new net.minecraft.client.renderer.Rect2i(search.getX()-2,search.getY()-2,search.getWidth()+4,machine().view.furnace()?182:82));}
+    @Override protected void extractSlot(net.minecraft.client.gui.GuiGraphicsExtractor g,net.minecraft.world.inventory.Slot slot,int x,int y){
+        super.extractSlot(g,slot,x,y);var m=machine();
+        if(!m.view.furnace()||m.view.section()!=0||slot.index>=m.view.indices().length)return;
+        int lane=m.view.indices()[slot.index]/3,state=m.laneState(lane);if(state==MultiblockMenu.IDLE)return;
+        int color=switch(state){case MultiblockMenu.COOKING->0xFFFFB23F;case MultiblockMenu.NO_FUEL->0xFFE1CE62;default->0xFFE06B5F;};
+        g.fill(slot.x,slot.y+14,slot.x+16,slot.y+16,0xFF343434);
+        g.fill(slot.x,slot.y+14,slot.x+Math.max(1,16*m.laneProgress(lane)/100),slot.y+16,color);
+    }
+    @Override protected java.util.List<Component> getTooltipFromContainerItem(net.minecraft.world.item.ItemStack stack){
+        var lines=new java.util.ArrayList<>(super.getTooltipFromContainerItem(stack));var m=machine();
+        if(m.view.furnace()&&hoveredSlot!=null&&hoveredSlot.index<m.view.indices().length){
+            int lane=m.view.indices()[hoveredSlot.index]/3;
+            if(m.view.section()==1)lines.add(Multiblocks.text("shared_fuel").copy().withStyle(net.minecraft.ChatFormatting.GRAY));
+            else {lines.add(Multiblocks.text("lane",lane+1).copy().withStyle(net.minecraft.ChatFormatting.GRAY));
+                lines.add(Multiblocks.text("state."+new String[]{"idle","cooking","no_fuel","blocked","no_recipe"}[m.laneState(lane)],m.laneProgress(lane)));}
+        }
+        return lines;
+    }
+    @Override public void extractRenderState(net.minecraft.client.gui.GuiGraphicsExtractor g,int x,int y,float partial){
+        super.extractRenderState(g,x,y,partial);
+        if(showHelp){
+            g.nextStratum();
+            g.tooltip(font,font.split(Multiblocks.text("cooking_help"),Math.min(260,width-32)).stream()
+                .map(net.minecraft.client.gui.screens.inventory.tooltip.ClientTooltipComponent::create).toList(),
+                8,24,net.minecraft.client.gui.screens.inventory.tooltip.DefaultTooltipPositioner.INSTANCE,null,false);
+        }
+    }
+    @Override public boolean mouseClicked(net.minecraft.client.input.MouseButtonEvent event,boolean doubleClick){
+        if(showHelp){showHelp=false;return true;}
+        return super.mouseClicked(event,doubleClick);
+    }
+    boolean helpVisible(){return showHelp;}
+    public java.util.List<net.minecraft.client.renderer.Rect2i> extraAreas(){return search==null?java.util.List.of():java.util.List.of(new net.minecraft.client.renderer.Rect2i(search.getX()-2,search.getY()-2,search.getWidth()+4,machine().view.furnace()?166:82));}
     public static void register(){
         net.minecraft.client.gui.screens.MenuScreens.<net.minecraft.world.inventory.ChestMenu,MultiblockScreen>register(Multiblocks.MENU,(m,i,t)->new MultiblockScreen((MultiblockMenu)m,i,t));
         net.fabricmc.fabric.api.client.item.v1.ItemTooltipCallback.EVENT.register((stack,context,flags,lines)->{if(stack.is(Multiblocks.WRENCH))lines.add(Multiblocks.text("hint").copy().withStyle(net.minecraft.ChatFormatting.GRAY));});

mods/sanctuary/src/main/java/fr/koka/sanctuary/client/ResourcePackTemplate.java

@@ -0,0 +1,107 @@
+package fr.koka.sanctuary.client;
+
+import com.mojang.blaze3d.Blaze3D;
+import fr.koka.sanctuary.SanctuaryMod;
+import java.io.IOException;
+import java.nio.file.FileAlreadyExistsException;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.Comparator;
+import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.components.Tooltip;
+import net.minecraft.network.chat.Component;
+import net.minecraft.util.Util;
+
+/** Explicit, one-time export. The player's copy is never a managed mod resource. */
+public final class ResourcePackTemplate {
+    public static final String FOLDER = "Sanctuary-Custom";
+
+    private ResourcePackTemplate() {}
+
+    public static Button button(Path packDirectory) {
+        Path target = packDirectory.resolve(FOLDER);
+        return Button.builder(label(Files.isDirectory(target, LinkOption.NOFOLLOW_LINKS)
+                        ? "open_copy" : "customize"), button -> {
+            if (Files.isDirectory(target, LinkOption.NOFOLLOW_LINKS)) {
+                Blaze3D.openPath(target);
+                return;
+            }
+            button.active = false;
+            button.setMessage(label("creating"));
+            Util.ioPool().execute(() -> {
+                try {
+                    create(packDirectory);
+                    Minecraft.getInstance().execute(() -> {
+                        button.active = true;
+                        button.setMessage(label("open_copy"));
+                        button.setTooltip(Tooltip.create(label("copy_ready")));
+                    });
+                } catch (IOException | RuntimeException error) {
+                    SanctuaryMod.LOGGER.error("Could not create personal Sanctuary resource pack", error);
+                    Minecraft.getInstance().execute(() -> {
+                        button.active = true;
+                        button.setMessage(label("copy_failed"));
+                        button.setTooltip(Tooltip.create(label("copy_failed_help")));
+                    });
+                }
+            });
+        }).width(308).tooltip(Tooltip.create(label("customize_help"))).build();
+    }
+
+    /** Returns an existing personal directory untouched, including after mod upgrades. */
+    public static synchronized Path create(Path packDirectory) throws IOException {
+        Path directory = packDirectory.toAbsolutePath().normalize();
+        Files.createDirectories(directory);
+        Path target = directory.resolve(FOLDER);
+        if (Files.exists(target, LinkOption.NOFOLLOW_LINKS)) return existing(target);
+        var mod = FabricLoader.getInstance().getModContainer(SanctuaryMod.ID).orElseThrow();
+        // Keep incomplete packs outside the directory watched by the native pack screen.
+        Path staging = Files.createTempDirectory(directory.getParent(), ".sanctuary-template-");
+        try {
+            copyTree(mod.findPath("assets").orElseThrow(), staging.resolve("assets"));
+            copyTree(mod.findPath("resourcepacks/textures/assets").orElseThrow(), staging.resolve("assets"));
+            copyTree(mod.findPath("resourcepacks/template").orElseThrow(), staging);
+            Files.copy(mod.findPath("resourcepacks/textures/pack.png").orElseThrow(), staging.resolve("pack.png"));
+            try {
+                Files.move(staging, target);
+            } catch (FileAlreadyExistsException race) {
+                return existing(target);
+            }
+            return target;
+        } finally {
+            if (Files.exists(staging)) {
+                try (var files = Files.walk(staging)) {
+                    for (Path file : files.sorted(Comparator.reverseOrder()).toList()) Files.delete(file);
+                }
+            }
+        }
+    }
+
+    private static Path existing(Path target) throws IOException {
+        if (!Files.isDirectory(target, LinkOption.NOFOLLOW_LINKS)) {
+            throw new IOException("Personal pack path already exists and is not a directory: " + target);
+        }
+        return target;
+    }
+
+    private static void copyTree(Path source, Path destination) throws IOException {
+        try (var files = Files.walk(source)) {
+            for (Path file : files.toList()) {
+                if (Files.isSymbolicLink(file)) throw new IOException("Unexpected asset symlink: " + file);
+                // String paths also work when the mod is loaded from a ZIP filesystem.
+                Path output = destination.resolve(source.relativize(file).toString()).normalize();
+                if (!output.startsWith(destination)) throw new IOException("Invalid asset path: " + file);
+                if (Files.isDirectory(file)) Files.createDirectories(output);
+                else Files.copy(file, output, StandardCopyOption.REPLACE_EXISTING);
+            }
+        }
+    }
+
+    private static Component label(String key) {
+        return Component.translatable("sanctuary.resource_pack." + key);
+    }
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/client/SanctuaryKnowledgeClient.java

@@ -19,6 +19,8 @@ public final class SanctuaryKnowledgeClient implements ClientModInitializer {
     public static void registerClient() {
         SanctuaryResourcePack.register();
         VortexCloudRenderer.register();
+        fr.koka.sanctuary.client.shader.PixelShadows.register();
+        fr.koka.sanctuary.client.shader.EdgeHighlights.register();
         ProgressionClient.register();
         StarClient.register();
         WeatherClient.register();
@@ -35,6 +37,7 @@ public final class SanctuaryKnowledgeClient implements ClientModInitializer {
         FoodKnowledgeClient.register();
         MultiblockScreen.register();
         FourneauModels.register();
+        WrenchTextureModels.register();
         MetatableClient.register();
         ClayWorkshopScreen.register();
         GraveScreen.register();

mods/sanctuary/src/main/java/fr/koka/sanctuary/client/SculptureMaterialSampler.java

@@ -0,0 +1,47 @@
+package fr.koka.sanctuary.client;
+
+import fr.koka.sanctuary.plans.*;
+import java.util.*;
+import net.minecraft.client.renderer.block.dispatch.BlockStateModelPart;
+import net.minecraft.client.resources.model.geometry.BakedQuad;
+import net.minecraft.core.*;
+import net.minecraft.util.ARGB;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.item.*;
+
+/** Bounded samples of the baked faces' actual textures, with their own tint from the active pack. */
+final class SculptureMaterialSampler {
+    private static final int MAX_MATERIALS=32,SAMPLE_EDGE=16;
+    static SculpturePalette sample(ItemStack stack){
+        if(!ClayWorkshopMenu.material(stack))return null;
+        var state=((BlockItem)stack.getItem()).getBlock().defaultBlockState();var sample=PlanMaterials.sample(state);
+        var mc=net.minecraft.client.Minecraft.getInstance();
+        var parts=new ArrayList<BlockStateModelPart>();
+        mc.getModelManager().getBlockStateModelSet().get(state).collectParts(RandomSource.create(state.getSeed(BlockPos.ZERO)),parts);
+        var materials=new LinkedHashSet<BakedQuad.MaterialInfo>();
+        for(var part:parts)for(int face=0;face<=6;face++)for(var quad:part.getQuads(face==6?null:Direction.values()[face])){
+            if(materials.size()<MAX_MATERIALS)materials.add(quad.materialInfo());
+        }
+        var pixels=new ArrayList<Integer>();
+        for(var material:materials)add(pixels,PlanMaterials.faceSample(state,material));
+        if(pixels.isEmpty()){
+            var tints=mc.getBlockColors().getTintSources(state);
+            int tint=tints.isEmpty()?0xFFFFFFFF:tints.getFirst().colorInWorld(state,mc.level,mc.player.blockPosition());
+            add(pixels,new PlanMaterials.Sample(sample.pixels(),tint,sample.average()));
+        }
+        if(pixels.isEmpty())pixels.add(sample.average()|0xFF000000);
+        // Keep repeated pixels: they retain the sampled frequency of each shade.
+        pixels.sort(Comparator.comparingDouble(SculpturePalette::lightness).thenComparingInt(Integer::intValue));
+        var palette=new ArrayList<Integer>();int count=Math.min(SculpturePalette.MAX_COLORS,pixels.size());
+        for(int i=0;i<count;i++)palette.add(pixels.get((int)((i+.5)*pixels.size()/count)));
+        return new SculpturePalette(palette);
+    }
+    private static void add(List<Integer> pixels,PlanMaterials.Sample sample){
+        var texture=sample.pixels();int width=Math.min(SAMPLE_EDGE,texture.width()),height=Math.min(SAMPLE_EDGE,texture.height());
+        for(int y=0;y<height;y++)for(int x=0;x<width;x++){
+            int sx=(2*x+1)*texture.width()/(2*width),sy=(2*y+1)*texture.height()/(2*height);
+            int color=ARGB.multiply(texture.argb()[sy*texture.width()+sx],sample.tint());
+            if((color>>>24)>=128)pixels.add(color|0xFF000000);
+        }
+    }
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/client/SculptureParticles.java

@@ -0,0 +1,70 @@
+package fr.koka.sanctuary.client;
+
+import fr.koka.sanctuary.SanctuaryMod;
+import fr.koka.sanctuary.plans.*;
+import java.util.*;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.client.particle.SingleQuadParticle;
+import net.minecraft.core.*;
+import net.minecraft.data.AtlasIds;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.*;
+
+/** Chips use the already-colored surface voxels, not the technical block's clay particle material. */
+public final class SculptureParticles {
+    private record Removed(long tick,BlockState state,List<StatuaryRenderer.Quad> mesh){}
+    // A break event can arrive after the block update. Keep a short, bounded snapshot in that world only.
+    private static final Map<ClientLevel,LinkedHashMap<BlockPos,Removed>> REMOVED=new WeakHashMap<>();
+    public static void remember(ClientLevel level,BlockPos pos){
+        if(!(level.getBlockEntity(pos) instanceof StatuaryEntity e)||e.sculpture()==null)return;
+        var cache=REMOVED.computeIfAbsent(level,l->new LinkedHashMap<>());
+        var quads=mesh(e);var sample=new ArrayList<StatuaryRenderer.Quad>();int n=Math.min(64,quads.size());
+        for(int i=0;i<n;i++)sample.add(quads.get((int)((i+.5)*quads.size()/n)));
+        cache.put(pos.immutable(),new Removed(level.getGameTime(),e.getBlockState(),List.copyOf(sample)));
+        while(cache.size()>128)cache.remove(cache.keySet().iterator().next());
+    }
+    private static List<StatuaryRenderer.Quad> mesh(StatuaryEntity e){var s=e.getBlockState();return StatuaryRenderer.mesh(e.sculpture(),s.getValue(Statuary.FACING),s.getValue(Statuary.ANCHOR),s.getValue(Statuary.HEIGHT));}
+    public static boolean destroy(ClientLevel level,BlockPos pos,BlockState state){
+        if(!state.is(Statuary.BLOCK))return false;
+        List<StatuaryRenderer.Quad> quads=List.of();
+        if(level.getBlockEntity(pos) instanceof StatuaryEntity e)quads=mesh(e);
+        var cache=REMOVED.get(level);var old=cache==null?null:cache.remove(pos);
+        if(quads.isEmpty()&&old!=null&&old.state==state&&level.getGameTime()-old.tick<=40)quads=old.mesh;
+        int count=Math.min(64,quads.size());var random=level.getRandom();
+        for(int i=0;i<count;i++){
+            // Stratified surface sampling covers colors across the sculpture without 4096 particles.
+            int start=i*quads.size()/count,end=(i+1)*quads.size()/count;
+            var q=quads.get(start+random.nextInt(end-start));var point=center(q);
+            spawn(level,pos,point,q.color(),(random.nextDouble()-.5)*.12,random.nextDouble()*.12,(random.nextDouble()-.5)*.12);
+        }
+        return true;
+    }
+    public static boolean hit(ClientLevel level,BlockPos pos,Direction side,BlockState state){
+        if(!state.is(Statuary.BLOCK))return false;
+        if(!(level.getBlockEntity(pos) instanceof StatuaryEntity entity))return true;
+        var quads=mesh(entity);if(quads.isEmpty())return true;
+        var mc=Minecraft.getInstance();Vec3 aim=mc.hitResult instanceof BlockHitResult h&&h.getBlockPos().equals(pos)?h.getLocation().subtract(Vec3.atLowerCornerOf(pos)):new Vec3(.5,.5,.5);
+        StatuaryRenderer.Quad nearest=null;double distance=Double.POSITIVE_INFINITY;
+        // The selection box can cover a hole: use the nearest actual surface, never empty space.
+        for(var q:quads){double d=center(q).distanceToSqr(aim);if(d<distance){distance=d;nearest=q;}}
+        if(nearest!=null)spawn(level,pos,center(nearest),nearest.color(),side.getStepX()*.035,.03+side.getStepY()*.035,side.getStepZ()*.035);
+        return true;
+    }
+    static Vec3 center(StatuaryRenderer.Quad q){
+        double x=q.x()+1/32d,y=q.y()+1/32d,z=q.z()+1/32d;
+        return switch(q.side()){case 0->new Vec3(x,y,q.z());case 1->new Vec3(x,y,q.z()+1/16d);case 2->new Vec3(q.x(),y,z);case 3->new Vec3(q.x()+1/16d,y,z);case 4->new Vec3(x,q.y()+1/16d,z);default->new Vec3(x,q.y(),z);};
+    }
+    private static void spawn(ClientLevel level,BlockPos pos,Vec3 point,int color,double dx,double dy,double dz){
+        Minecraft.getInstance().particleEngine.add(new Fragment(level,Vec3.atLowerCornerOf(pos).add(point),color,dx,dy,dz));
+    }
+    static final class Fragment extends SingleQuadParticle {
+        Fragment(ClientLevel level,Vec3 pos,int color,double dx,double dy,double dz){
+            super(level,pos.x,pos.y,pos.z,Minecraft.getInstance().getAtlasManager().getAtlasOrThrow(AtlasIds.BLOCKS).getSprite(SanctuaryMod.id("sculpture_particle")));
+            setColor(((color>>16)&255)/255f,((color>>8)&255)/255f,(color&255)/255f);
+            quadSize=1/32f;gravity=1;friction=.96f;lifetime=12+random.nextInt(12);setParticleSpeed(dx,dy,dz);
+        }
+        @Override protected Layer getLayer(){return Layer.OPAQUE_TERRAIN;}
+    }
+    private SculptureParticles(){}
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/client/StatuaryRenderer.java

@@ -4,7 +4,6 @@ import fr.koka.sanctuary.SanctuaryMod;
 import fr.koka.sanctuary.plans.*;
 import java.util.*;
 import com.mojang.blaze3d.vertex.PoseStack;
-import com.mojang.math.Axis;
 import com.mojang.serialization.MapCodec;
 import net.minecraft.client.renderer.*;
 import net.minecraft.client.renderer.blockentity.*;
@@ -15,6 +14,7 @@ import net.minecraft.client.renderer.special.SpecialModelRenderer;
 import net.minecraft.client.renderer.state.level.CameraRenderState;
 import net.minecraft.client.renderer.texture.OverlayTexture;
 import net.minecraft.core.component.DataComponents;
+import net.minecraft.core.Direction;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.component.TypedEntityData;
 import net.minecraft.world.phys.Vec3;
@@ -23,8 +23,9 @@ import org.joml.Vector3fc;
 
 /** Shared block/item render geometry: opaque visible faces, generated once per cached sculpture. */
 public final class StatuaryRenderer implements BlockEntityRenderer<StatuaryEntity,StatuaryRenderer.State> {
-    private record Quad(float x,float y,float z,int side,int color){}
-    private static final Map<VoxelSculpture,List<Quad>> MESHES=new LinkedHashMap<>(32,.75f,true);
+    record Quad(float x,float y,float z,int side,int color){}
+    private record Placement(VoxelSculpture sculpture,Direction facing,SculptureAnchor anchor,SculptureHeight height){}
+    private static final Map<Placement,List<Quad>> MESHES=new LinkedHashMap<>(32,.75f,true);
     private static final Map<TypedEntityData<?>,VoxelSculpture> ITEMS=new LinkedHashMap<>(32,.75f,true);
     private static final float[][] FACES={
         {0,0,0, 0,1,0, 1,1,0, 1,0,0, 0,0,-1},
@@ -35,26 +36,26 @@ public final class StatuaryRenderer implements BlockEntityRenderer<StatuaryEntit
         {0,0,1, 0,0,0, 1,0,0, 1,0,1, 0,-1,0}
     };
     private static final int[][] STEP={{0,0,-1},{0,0,1},{-1,0,0},{1,0,0},{0,1,0},{0,-1,0}};
-    public static final class State extends BlockEntityRenderState {List<Quad> mesh=List.of();float yaw;}
+    public static final class State extends BlockEntityRenderState {List<Quad> mesh=List.of();}
     public State createRenderState(){return new State();}
     @Override public void extractRenderState(StatuaryEntity entity,State state,float delta,Vec3 camera,ModelFeatureRenderer.CrumblingOverlay breakProgress){
-        BlockEntityRenderer.super.extractRenderState(entity,state,delta,camera,breakProgress);state.mesh=mesh(entity.sculpture());
-        state.yaw=-entity.getBlockState().getValue(Statuary.FACING).toYRot();
+        BlockEntityRenderer.super.extractRenderState(entity,state,delta,camera,breakProgress);
+        state.mesh=mesh(entity.sculpture(),entity.getBlockState().getValue(Statuary.FACING),entity.getBlockState().getValue(Statuary.ANCHOR),entity.getBlockState().getValue(Statuary.HEIGHT));
     }
     public void submit(State state,PoseStack pose,SubmitNodeCollector collector,CameraRenderState camera){
-        pose.pushPose();pose.translate(.5,0,.5);pose.rotateDegrees(Axis.YP,state.yaw);pose.translate(-.5,0,-.5);
-        draw(state.mesh,pose,collector,state.lightCoords,OverlayTexture.NO_OVERLAY);pose.popPose();
+        draw(state.mesh,pose,collector,state.lightCoords,OverlayTexture.NO_OVERLAY);
     }
-    private static List<Quad> mesh(VoxelSculpture sculpture){
-        if(sculpture==null)return List.of();var cached=MESHES.get(sculpture);if(cached!=null)return cached;
+    static List<Quad> mesh(VoxelSculpture sculpture,Direction facing,SculptureAnchor anchor,SculptureHeight height){
+        if(sculpture==null)return List.of();var key=new Placement(sculpture,facing,anchor,height);var cached=MESHES.get(key);if(cached!=null)return cached;
+        var placed=SculptureGeometry.place(sculpture,facing,anchor,height);sculpture=placed.sculpture();
         var occupied=new BitSet(4096);for(var cell:sculpture.cells())occupied.set(cell.key());var quads=new ArrayList<Quad>();
-        float ox=(16-sculpture.width())/32f,oz=(16-sculpture.depth())/32f;
+        float ox=placed.offsetX()/16f,oy=placed.offsetY()/16f,oz=placed.offsetZ()/16f;
         for(var cell:sculpture.cells())for(int side=0;side<6;side++){
             var s=STEP[side];int x=cell.x()+s[0],y=cell.y()+s[1],z=cell.z()+s[2];
             if(x>=0&&x<16&&y>=0&&y<16&&z>=0&&z<16&&occupied.get(x|y<<4|z<<8))continue;
-            quads.add(new Quad(ox+cell.x()/16f,cell.y()/16f,oz+cell.z()/16f,side,cell.color()));
+            quads.add(new Quad(ox+cell.x()/16f,oy+cell.y()/16f,oz+cell.z()/16f,side,cell.color()));
         }
-        cached=List.copyOf(quads);MESHES.put(sculpture,cached);if(MESHES.size()>32)MESHES.remove(MESHES.keySet().iterator().next());return cached;
+        cached=List.copyOf(quads);MESHES.put(key,cached);if(MESHES.size()>32)MESHES.remove(MESHES.keySet().iterator().next());return cached;
     }
     private static void draw(List<Quad> mesh,PoseStack pose,SubmitNodeCollector collector,int light,int overlay){
         if(mesh.isEmpty())return;
@@ -68,7 +69,7 @@ public final class StatuaryRenderer implements BlockEntityRenderer<StatuaryEntit
             var data=stack.get(DataComponents.BLOCK_ENTITY_DATA);if(data==null)return List.of();
             var sculpture=ITEMS.get(data);
             if(sculpture==null){sculpture=StatuaryEntity.sculpture(stack);if(sculpture==null)return List.of();ITEMS.put(data,sculpture);if(ITEMS.size()>64)ITEMS.remove(ITEMS.keySet().iterator().next());}
-            return mesh(sculpture);
+            return mesh(sculpture,Direction.SOUTH,SculptureAnchor.CENTER,SculptureHeight.ORIGINAL);
         }
         public void submit(List<Quad> mesh,PoseStack pose,SubmitNodeCollector collector,int light,int overlay,boolean foil,int outline){draw(mesh,pose,collector,light,overlay);}
         public void getExtents(java.util.function.Consumer<Vector3fc> out){out.accept(new Vector3f(0,0,0));out.accept(new Vector3f(1,1,1));}

mods/sanctuary/src/main/java/fr/koka/sanctuary/client/WrenchTextureModels.java

@@ -0,0 +1,65 @@
+package fr.koka.sanctuary.client;
+
+import fr.koka.sanctuary.multiblock.WrenchTextures;
+import java.util.*;
+import java.util.function.Predicate;
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.*;
+import net.fabricmc.fabric.api.client.model.loading.v1.ModelLoadingPlugin;
+import net.fabricmc.fabric.api.client.model.loading.v1.wrapper.WrapperBlockStateModel;
+import net.fabricmc.fabric.api.client.networking.v1.*;
+import net.fabricmc.fabric.api.client.renderer.v1.mesh.*;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.block.BlockAndTintGetter;
+import net.minecraft.client.renderer.block.dispatch.BlockStateModel;
+import net.minecraft.core.*;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.block.state.BlockState;
+
+/** Immutable visual snapshots, usable from mesh workers and rebuilt after resource reloads. */
+public final class WrenchTextureModels {
+    private static volatile Map<Long,Map<BlockPos,Integer>> chunks=Map.of();
+    public static int rotation(BlockPos pos){return chunks.getOrDefault(ChunkPos.pack(pos),Map.of()).getOrDefault(pos,0);}
+    public static void register(){
+        ClientPlayNetworking.registerGlobalReceiver(WrenchTextures.Update.TYPE,(packet,context)->context.client().execute(()->apply(packet)));
+        ClientPlayConnectionEvents.DISCONNECT.register((handler,client)->chunks=Map.of());
+        ClientLevelEvents.AFTER_CLIENT_LEVEL_CHANGE.register((client,level)->chunks=Map.of());
+        ClientChunkEvents.CHUNK_UNLOAD.register((level,chunk)->{var next=new HashMap<>(chunks);next.remove(chunk.getPos().pack());chunks=Map.copyOf(next);});
+        ModelLoadingPlugin.register(context->context.modifyBlockModelAfterBake().register((model,bake)->new Rotated(model)));
+    }
+    private static void apply(WrenchTextures.Update packet){
+        var client=Minecraft.getInstance();if(client.level==null||!client.level.dimension().identifier().equals(packet.dimension()))return;
+        long key=packet.chunk().pack();var old=chunks.getOrDefault(key,Map.of());var dirty=new HashSet<BlockPos>();
+        var entries=packet.clear()?new HashMap<BlockPos,Integer>():new HashMap<>(old);if(packet.clear())dirty.addAll(old.keySet());
+        for(var entry:packet.entries()){
+            var before=entry.rotation()==0?entries.remove(entry.pos()):entries.put(entry.pos(),entry.rotation());
+            if(!Objects.equals(before,entry.rotation()))dirty.add(entry.pos());
+        }
+        var next=new HashMap<>(chunks);if(entries.isEmpty())next.remove(key);else next.put(key,Map.copyOf(entries));chunks=Map.copyOf(next);
+        var sections=new HashSet<SectionPos>();for(var pos:dirty)sections.add(SectionPos.of(pos));
+        for(var section:sections)client.levelExtractor.setSectionDirty(section.x(),section.y(),section.z());
+    }
+    static boolean rotate(MutableQuadView quad,int turns){
+        // Rotate texture coordinates only: geometry, light, tints and materials stay native.
+        for(int turn=0;turn<turns;turn++){
+            float u=quad.u(0),v=quad.v(0);
+            for(int vertex=0;vertex<3;vertex++)quad.uv(vertex,quad.u(vertex+1),quad.v(vertex+1));
+            quad.uv(3,u,v);
+        }
+        return true;
+    }
+    private record Geometry(Object original,int rotation){}
+    private static final class Rotated extends WrapperBlockStateModel {
+        Rotated(BlockStateModel original){super(original);}
+        @Override public void emitQuads(QuadEmitter emitter,BlockAndTintGetter view,BlockPos pos,BlockState state,RandomSource random,Predicate<Direction> cull){
+            int turns=rotation(pos);if(turns==0){wrapped.emitQuads(emitter,view,pos,state,random,cull);return;}
+            emitter.pushTransform(quad->rotate(quad,turns));
+            try{wrapped.emitQuads(emitter,view,pos,state,random,cull);}finally{emitter.popTransform();}
+        }
+        @Override public Object createGeometryKey(BlockAndTintGetter view,BlockPos pos,BlockState state,RandomSource random){
+            var key=wrapped.createGeometryKey(view,pos,state,random);int turns=rotation(pos);
+            return turns==0||key==null?key:new Geometry(key,turns);
+        }
+    }
+    private WrenchTextureModels(){}
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/client/shader/EdgeHighlights.java

@@ -0,0 +1,99 @@
+package fr.koka.sanctuary.client.shader;
+
+import com.mojang.blaze3d.buffers.Std140Builder;
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.renderpearl.api.GpuFormat;
+import com.mojang.renderpearl.api.buffers.GpuBuffer;
+import com.mojang.renderpearl.api.pipeline.*;
+import com.mojang.renderpearl.api.textures.FilterMode;
+import fr.koka.sanctuary.client.panorama.PanoramaCapture;
+import java.util.Optional;
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientLifecycleEvents;
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayConnectionEvents;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.MappableRingBuffer;
+import net.minecraft.client.renderer.RenderPipelines;
+import net.minecraft.resources.Identifier;
+import net.minecraft.world.level.material.FogType;
+import org.joml.Matrix4f;
+
+/** Optional, texture-preserving highlights on visible voxel edges. No gameplay light changes. */
+public final class EdgeHighlights {
+    // Destination * (1 + highlight): retain the block's existing colour and texture, including shadows.
+    private static final RenderPipeline APPLY = RenderPipelines.register(RenderPipeline.builder()
+            .withLocation(Identifier.parse("sanctuary:pipeline/edge_highlights"))
+            .withVertexShader("core/screenquad")
+            .withFragmentShader(Identifier.parse("sanctuary:core/edge_highlights"))
+            .withBindGroupLayout(BindGroupLayout.builder()
+                    .withUniform("EdgeHighlights", UniformType.UNIFORM_BUFFER)
+                    .withUniform("WorldDepth", UniformType.COMBINED_IMAGE_SAMPLER).build())
+            .withPrimitiveTopology(PrimitiveTopology.TRIANGLES).withCull(false)
+            .withColorTargetState(new ColorTargetState(Optional.of(new BlendFunction(
+                    BlendFactor.DST_COLOR, BlendFactor.ONE, BlendFactor.ZERO, BlendFactor.ONE)),
+                    GpuFormat.RGBA8_UNORM, ColorTargetState.WRITE_COLOR))
+            .withDepthStencilState(Optional.empty()).build());
+    private static final Matrix4f projection = new Matrix4f();
+    private static MappableRingBuffer uniforms;
+    private static boolean applied;
+    private static int renderedFrames;
+
+    private EdgeHighlights() { }
+
+    public static void register() {
+        ClientPlayConnectionEvents.DISCONNECT.register((handler, client) -> release());
+        ClientLifecycleEvents.CLIENT_STOPPING.register(client -> release());
+    }
+
+    public static void captureProjection(Matrix4f matrix) { projection.set(matrix); }
+
+    /** Runs after cast shadows and before the hand and HUD; works without the shadow depth map. */
+    public static void render() {
+        applied = false;
+        var client = Minecraft.getInstance();
+        if (!VanillaLight.active() || !VanillaLight.edgeHighlights() || VanillaLight.edgeIntensity() == 0
+                || client.level == null) {
+            release();
+            return;
+        }
+        if (PanoramaCapture.rendering()) return;
+        var camera = client.gameRenderer.gameRenderState().levelRenderState.cameraRenderState;
+        if (camera.fogType != FogType.NONE) return;
+        if (uniforms == null) uniforms = new MappableRingBuffer(() -> "Sanctuary edge highlights",
+                GpuBuffer.USAGE_UNIFORM | GpuBuffer.USAGE_MAP_WRITE, 176);
+        var viewProjection = new Matrix4f(projection).mul(camera.viewRotationMatrix);
+        var inverse = new Matrix4f(viewProjection).invert();
+        var fog = camera.fogData;
+        uniforms.rotate();
+        try (var mapped = uniforms.currentBuffer().map(false, true)) {
+            Std140Builder.intoBuffer(mapped.data()).putMat4f(inverse).putMat4f(viewProjection)
+                    .putVec4((float)(camera.pos.x - Math.floor(camera.pos.x)),
+                            (float)(camera.pos.y - Math.floor(camera.pos.y)),
+                            (float)(camera.pos.z - Math.floor(camera.pos.z)), 16)
+                    .putVec4(VanillaLight.edgeIntensity() * .004f,
+                            RenderSystem.getDevice().getDeviceInfo().isZZeroToOne() ? 1 : 0,
+                            fog.renderDistanceStart, fog.renderDistanceEnd)
+                    .putVec4(fog.environmentalStart, fog.environmentalEnd, fog.color.w, VanillaLight.edgeDistance());
+        }
+        var main = client.gameRenderer.mainRenderTarget();
+        var encoder = RenderSystem.getDevice().createCommandEncoder();
+        try (var pass = encoder.createRenderPass(() -> "Sanctuary edge highlights",
+                main.getColorTextureView(), Optional.empty())) {
+            pass.setPipeline(RenderSystem.getCompiledPipeline(APPLY));
+            pass.setUniform("EdgeHighlights", uniforms.currentBuffer());
+            pass.setUniform("WorldDepth", main.getDepthTextureView(),
+                    RenderSystem.getSamplerCache().getClampToEdge(FilterMode.NEAREST));
+            pass.draw(3, 1, 0, 0);
+        }
+        renderedFrames++;
+        applied = true;
+    }
+
+    public static void release() {
+        if (uniforms != null) { uniforms.close(); uniforms = null; }
+        applied = false;
+    }
+
+    static boolean applied() { return applied; }
+    static boolean allocated() { return uniforms != null; }
+    static int renderedFrames() { return renderedFrames; }
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/client/shader/PixelShadows.java

@@ -0,0 +1,174 @@
+package fr.koka.sanctuary.client.shader;
+
+import com.mojang.blaze3d.buffers.Std140Builder;
+import com.mojang.blaze3d.pipeline.TextureTarget;
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.DefaultVertexFormat;
+import com.mojang.renderpearl.api.GpuFormat;
+import com.mojang.renderpearl.api.buffers.GpuBuffer;
+import com.mojang.renderpearl.api.buffers.GpuBufferSlice;
+import com.mojang.renderpearl.api.pipeline.*;
+import com.mojang.renderpearl.api.textures.FilterMode;
+import fr.koka.sanctuary.client.panorama.PanoramaCapture;
+import java.util.*;
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientLifecycleEvents;
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayConnectionEvents;
+import net.minecraft.client.Minecraft;
+import net.minecraft.resources.Identifier;
+import net.minecraft.core.BlockPos;
+import net.minecraft.client.renderer.BindGroupLayouts;
+import net.minecraft.client.renderer.MappableRingBuffer;
+import net.minecraft.client.renderer.RenderPipelines;
+import net.minecraft.client.renderer.state.level.CameraRenderState;
+import net.minecraft.world.level.dimension.DimensionType;
+import net.minecraft.world.level.material.FogType;
+import org.joml.Matrix4f;
+import org.joml.Vector3f;
+import org.joml.Vector4f;
+
+/** Native sun/moon depth map and world-grid receivers. Never reads GPU pixels or changes gameplay light. */
+public final class PixelShadows {
+    private static final RenderPipeline DEPTH = RenderPipelines.register(RenderPipeline.builder()
+            .withLocation(Identifier.parse("sanctuary:pipeline/pixel_shadow_depth"))
+            .withVertexShader(Identifier.parse("sanctuary:core/pixel_shadow_depth"))
+            .withFragmentShader(Identifier.parse("sanctuary:core/pixel_shadow_depth"))
+            .withBindGroupLayout(BindGroupLayouts.DYNAMIC_TRANSFORMS)
+            .withVertexBinding(0, DefaultVertexFormat.POSITION_COLOR)
+            .withPrimitiveTopology(PrimitiveTopology.QUADS).withCull(false)
+            .withColorTargetState(new ColorTargetState(Optional.empty(), GpuFormat.R8_UNORM, ColorTargetState.WRITE_COLOR))
+            .withDepthStencilState(new DepthStencilState(CompareOp.LESS_THAN, true)).build());
+    private static final RenderPipeline APPLY = RenderPipelines.register(RenderPipeline.builder()
+            .withLocation(Identifier.parse("sanctuary:pipeline/pixel_shadows"))
+            .withVertexShader("core/screenquad")
+            .withFragmentShader(Identifier.parse("sanctuary:core/pixel_shadows"))
+            .withBindGroupLayout(BindGroupLayout.builder()
+                    .withUniform("PixelShadows", UniformType.UNIFORM_BUFFER)
+                    .withUniform("WorldDepth", UniformType.COMBINED_IMAGE_SAMPLER)
+                    .withUniform("SunDepth", UniformType.COMBINED_IMAGE_SAMPLER)
+                    .withUniform("SunMaterial", UniformType.COMBINED_IMAGE_SAMPLER).build())
+            .withPrimitiveTopology(PrimitiveTopology.TRIANGLES).withCull(false)
+            .withColorTargetState(new ColorTargetState(Optional.of(BlendFunction.TRANSLUCENT), GpuFormat.RGBA8_UNORM, ColorTargetState.WRITE_COLOR))
+            .withDepthStencilState(Optional.empty()).build());
+    private static final ShadowTerrain TERRAIN = new ShadowTerrain();
+    private static final Matrix4f projection = new Matrix4f();
+    private static final ShadowProjection lightGrid = new ShadowProjection();
+    private static TextureTarget shadowMap;
+    private static MappableRingBuffer uniforms;
+    private static int renderedFrames;
+    private static boolean applied;
+
+    private PixelShadows() { }
+    public static void register() {
+        ClientPlayConnectionEvents.DISCONNECT.register((handler, client) -> release());
+        ClientLifecycleEvents.CLIENT_STOPPING.register(client -> release());
+    }
+    public static void captureProjection(Matrix4f matrix) { projection.set(matrix); }
+    public static void dirtyBlock(BlockPos pos) {
+        for (int x = (pos.getX()-1)>>4; x <= (pos.getX()+1)>>4; x++)
+            for (int y = (pos.getY()-1)>>4; y <= (pos.getY()+1)>>4; y++)
+                for (int z = (pos.getZ()-1)>>4; z <= (pos.getZ()+1)>>4; z++) TERRAIN.dirtySection(x,y,z);
+    }
+    public static void dirtyChunk(int x, int z) { TERRAIN.dirtyChunk(x, z); }
+
+    /** Called after the world's depth is resolved and before the first-person hand and GUI. */
+    public static void render() {
+        applied = false;
+        var client = Minecraft.getInstance();
+        if (!VanillaLight.active() || !VanillaLight.pixelShadows() || client.level == null) {
+            release();
+            return;
+        }
+        if (PanoramaCapture.rendering()) return;
+        var state = client.gameRenderer.gameRenderState().levelRenderState;
+        var sky = state.skyRenderState;
+        CameraRenderState camera = state.cameraRenderState;
+        var sun = sunDirection(sky.sunAngle);
+        boolean lunar = sun.y <= .08f;
+        if (lunar) sun = sunDirection(sky.moonAngle);
+        if (sky.skybox != DimensionType.Skybox.OVERWORLD || camera.fogType != FogType.NONE || sun.y <= .08f) return;
+        float moon = sky.moonPhase == null ? 1 : (float)(.5 + .5 * Math.cos(sky.moonPhase.index() * Math.PI / 4));
+        float strength = (lunar ? .10f * moon : .38f)
+                * Math.clamp((sun.y - .08f) / .16f, 0, 1) * sky.rainBrightness;
+        if (strength <= .001f) return;
+        int distance = VanillaLight.shadowDistance(), pixels = VanillaLight.shadowPixels();
+        TERRAIN.update(client.level, camera.pos, distance, sun);
+        int size = mapSize(distance, pixels);
+        if (shadowMap == null || shadowMap.width != size) {
+            if (shadowMap != null) shadowMap.destroyBuffers();
+            shadowMap = new TextureTarget("Sanctuary celestial shadows", size, size, GpuFormat.R8_UNORM, GpuFormat.D32_FLOAT);
+        }
+        if (uniforms == null) uniforms = new MappableRingBuffer(() -> "Sanctuary pixel shadows",
+                GpuBuffer.USAGE_UNIFORM | GpuBuffer.USAGE_MAP_WRITE, 192);
+        double ox = anchor(camera.pos.x), oy = anchor(camera.pos.y), oz = anchor(camera.pos.z);
+        boolean zeroToOne = RenderSystem.getDevice().getDeviceInfo().isZZeroToOne();
+        var light = lightGrid.matrix(sun, distance, size, ox, oy, oz, zeroToOne);
+        var inverse = new Matrix4f(projection).mul(camera.viewRotationMatrix).invert();
+        uniforms.rotate();
+        var fog = camera.fogData;
+        try (var mapped = uniforms.currentBuffer().map(false, true)) {
+            Std140Builder.intoBuffer(mapped.data()).putMat4f(inverse).putMat4f(light)
+                    .putVec4((float)(camera.pos.x - ox), (float)(camera.pos.y - oy), (float)(camera.pos.z - oz), pixels)
+                    .putVec4(sun.x, sun.y, sun.z, strength)
+                    .putVec4(distance, zeroToOne ? 1 : 0, fog.renderDistanceStart, fog.renderDistanceEnd)
+                    .putVec4(fog.environmentalStart, fog.environmentalEnd, fog.color.w, 0);
+        }
+        var entries = TERRAIN.entries();
+        var transforms = new ArrayList<GpuBufferSlice>(entries.size());
+        int maxIndices = 0;
+        for (var entry : entries) {
+            transforms.add(RenderSystem.getDynamicUniforms().writeTransform(new Matrix4f(light)
+                    .translate((float)(entry.x() - ox), (float)(entry.y() - oy), (float)(entry.z() - oz)),
+                    new Vector4f(1, 1, 1, 1),
+                    // Bounded world coordinates keep foliage noise precise far from spawn.
+                    new Vector3f(Math.floorMod(entry.x(), 4096), Math.floorMod(entry.y(), 4096),
+                            Math.floorMod(entry.z(), 4096)), new Matrix4f()));
+            maxIndices = Math.max(maxIndices, entry.indexCount());
+        }
+        var indices = RenderSystem.getSequentialBuffer(PrimitiveTopology.QUADS);
+        indices.requestIndexCount(maxIndices);
+        var encoder = RenderSystem.getDevice().createCommandEncoder();
+        try (var pass = encoder.createRenderPass(com.mojang.renderpearl.api.commands.RenderPassDescriptor.builder(() -> "Sanctuary celestial depth")
+                .withColorAttachment(shadowMap.getColorTextureView(), Optional.of(new Vector4f(0, 0, 0, 0)))
+                .withDepthAttachment(shadowMap.getDepthTextureView(), OptionalDouble.of(1)).build())) {
+            pass.setPipeline(RenderSystem.getCompiledPipeline(DEPTH));
+            if (maxIndices > 0) pass.setIndexBuffer(indices.getBuffer(), indices.type());
+            for (int i = 0; i < entries.size(); i++) {
+                var entry = entries.get(i);
+                pass.setUniform("DynamicTransforms", transforms.get(i));
+                pass.setVertexBuffer(0, entry.vertices().slice());
+                pass.drawIndexed(entry.indexCount(), 1, 0, 0, 0);
+            }
+        }
+        var main = client.gameRenderer.mainRenderTarget();
+        var nearest = RenderSystem.getSamplerCache().getClampToEdge(FilterMode.NEAREST);
+        try (var pass = encoder.createRenderPass(() -> "Sanctuary pixel shadows", main.getColorTextureView(), Optional.empty())) {
+            pass.setPipeline(RenderSystem.getCompiledPipeline(APPLY));
+            pass.setUniform("PixelShadows", uniforms.currentBuffer());
+            pass.setUniform("WorldDepth", main.getDepthTextureView(), nearest);
+            pass.setUniform("SunDepth", shadowMap.getDepthTextureView(), nearest);
+            pass.setUniform("SunMaterial", shadowMap.getColorTextureView(), nearest);
+            pass.draw(3, 1, 0, 0);
+        }
+        renderedFrames++;
+        applied = true;
+    }
+
+    static double anchor(double coordinate) { return Math.floor(coordinate / 16.0 + .5) * 16.0; }
+    static Vector3f sunDirection(float angle) { return new Vector3f(-(float)Math.sin(angle), (float)Math.cos(angle), 0); }
+    static int mapSize(int distance, int pixels) {
+        int size = 512;
+        while (size < 2 * (distance + 16) * pixels && size < 4096) size *= 2;
+        return size;
+    }
+    public static void release() {
+        TERRAIN.close();
+        lightGrid.reset();
+        if (shadowMap != null) { shadowMap.destroyBuffers(); shadowMap = null; }
+        if (uniforms != null) { uniforms.close(); uniforms = null; }
+        applied = false;
+    }
+    static int renderedFrames() { return renderedFrames; }
+    static boolean applied() { return applied; }
+    static boolean ready() { return TERRAIN.settled(); }
+    static TextureTarget shadowMap() { return shadowMap; }
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/client/shader/ShaderOptionsScreen.java

@@ -1,5 +1,7 @@
 package fr.koka.sanctuary.client.shader;
 
+import com.mojang.serialization.Codec;
+import java.util.List;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.OptionInstance;
 import net.minecraft.client.gui.screens.Screen;
@@ -15,5 +17,23 @@ public final class ShaderOptionsScreen extends OptionsSubScreen {
         list.addBig(new OptionInstance<Integer>("sanctuary.shaders.saturation",OptionInstance.cachedConstantTooltip(
                 Component.translatable("sanctuary.shaders.saturation_help")),(caption,value)->Component.translatable("sanctuary.shaders.saturation_value",value),
                 new OptionInstance.IntRange(0,200),VanillaLight.saturation(),VanillaLight::setSaturation));
+        list.addBig(OptionInstance.createBoolean("sanctuary.shaders.edge_highlights",OptionInstance.cachedConstantTooltip(
+                Component.translatable("sanctuary.shaders.edge_highlights_help")),
+                VanillaLight.edgeHighlights(),VanillaLight::setEdgeHighlights));
+        list.addBig(new OptionInstance<Integer>("sanctuary.shaders.edge_intensity",OptionInstance.cachedConstantTooltip(
+                Component.translatable("sanctuary.shaders.edge_intensity_help")),(caption,value)->Component.translatable("sanctuary.shaders.edge_intensity_value",value),
+                new OptionInstance.IntRange(0,100),VanillaLight.edgeIntensity(),VanillaLight::setEdgeIntensity));
+        list.addBig(new OptionInstance<Integer>("sanctuary.shaders.edge_distance",OptionInstance.cachedConstantTooltip(
+                Component.translatable("sanctuary.shaders.edge_distance_help")),(caption,value)->Component.translatable("sanctuary.shaders.edge_distance_value",value),
+                new OptionInstance.Enum<>(List.of(16,32,64,128,256),Codec.INT),VanillaLight.edgeDistance(),VanillaLight::setEdgeDistance));
+        list.addBig(OptionInstance.createBoolean("sanctuary.shaders.pixel_shadows",OptionInstance.cachedConstantTooltip(
+                Component.translatable("sanctuary.shaders.pixel_shadows_help")),
+                VanillaLight.pixelShadows(),VanillaLight::setPixelShadows));
+        list.addBig(new OptionInstance<Integer>("sanctuary.shaders.shadow_pixels",OptionInstance.cachedConstantTooltip(
+                Component.translatable("sanctuary.shaders.shadow_pixels_help")),(caption,value)->Component.translatable("sanctuary.shaders.shadow_pixels_value",value),
+                new OptionInstance.Enum<>(List.of(8,16,32),Codec.INT),VanillaLight.shadowPixels(),VanillaLight::setShadowPixels));
+        list.addBig(new OptionInstance<Integer>("sanctuary.shaders.shadow_distance",OptionInstance.cachedConstantTooltip(
+                Component.translatable("sanctuary.shaders.shadow_distance_help")),(caption,value)->Component.translatable("sanctuary.shaders.shadow_distance_value",value),
+                new OptionInstance.Enum<>(List.of(16,32,64,128,256),Codec.INT),VanillaLight.shadowDistance(),VanillaLight::setShadowDistance));
     }
 }

mods/sanctuary/src/main/java/fr/koka/sanctuary/client/shader/ShadowProjection.java

@@ -0,0 +1,37 @@
+package fr.koka.sanctuary.client.shader;
+
+import org.joml.Matrix4f;
+import org.joml.Vector3f;
+
+/** Keeps the raster grid continuous as the sun moves; only camera recentering snaps to texels. */
+final class ShadowProjection {
+    private boolean initialized;
+    private int distance, size;
+    private double x, y, z, phaseX, phaseY;
+
+    Matrix4f matrix(Vector3f sun, int distance, int size, double x, double y, double z, boolean zeroToOne) {
+        float extent = distance + 16, reach = 4 * (distance + 16);
+        var view = new Matrix4f().lookAt(sun.x * reach, sun.y * reach, sun.z * reach,
+                0, 0, 0, 0, 0, 1);
+        double texel = 2.0 * extent / size;
+        if (!initialized || this.distance != distance || this.size != size) {
+            phaseX = phaseY = 0;
+        } else if (this.x != x || this.y != y || this.z != z) {
+            double dx = x - this.x, dy = y - this.y, dz = z - this.z;
+            phaseX = Math.IEEEremainder(phaseX + view.m00() * dx + view.m10() * dy + view.m20() * dz, texel);
+            phaseY = Math.IEEEremainder(phaseY + view.m01() * dx + view.m11() * dy + view.m21() * dz, texel);
+        }
+        // Re-rounding the projected WORLD origin every frame made a slowly rotating light jump
+        // a raster texel periodically, particularly far from spawn. Retain this phase in between
+        // camera anchor changes: the light can rotate continuously without moving the raster origin.
+        initialized = true;
+        this.distance = distance; this.size = size;
+        this.x = x; this.y = y; this.z = z;
+        var result = new Matrix4f().setOrtho(-extent, extent, -extent, extent, .1f, reach * 2, zeroToOne).mul(view);
+        result.m30(result.m30() + (float)(phaseX / extent));
+        result.m31(result.m31() + (float)(phaseY / extent));
+        return result;
+    }
+
+    void reset() { initialized = false; }
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/client/shader/ShadowTerrain.java

@@ -0,0 +1,528 @@
+package fr.koka.sanctuary.client.shader;
+
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.BufferBuilder;
+import com.mojang.blaze3d.vertex.ByteBufferBuilder;
+import com.mojang.blaze3d.vertex.DefaultVertexFormat;
+import com.mojang.renderpearl.api.buffers.GpuBuffer;
+import com.mojang.renderpearl.api.pipeline.PrimitiveTopology;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.IdentityHashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import net.minecraft.core.Direction;
+import net.minecraft.tags.BlockTags;
+import net.minecraft.core.SectionPos;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.LevelChunk;
+import net.minecraft.world.level.chunk.LevelChunkSection;
+import net.minecraft.world.level.chunk.status.ChunkStatus;
+import net.minecraft.world.phys.AABB;
+import net.minecraft.world.phys.Vec3;
+import org.joml.Vector3fc;
+
+/**
+ * Render-thread-only, read-only terrain casters. Call update BEFORE opening any render pass.
+ * Positions use POSITION_COLOR (three floats plus a foliage flag), relative to the entry's block
+ * origin; add that origin in the draw transform. Indices belong to RenderSystem's shared
+ * QUADS sequential buffer, which update grows before drawing. This cache never owns it.
+ *
+ * <p>Call dirtySection for edits (including affected neighbors), or dirtyChunk for a chunk
+ * packet that mutates an existing chunk. Identity changes/unloads are detected automatically.
+ * Call close on disable/disconnect/resource teardown; it is idempotent and the cache is reusable.
+ * A different ClientLevel, or update(null, ...), also releases all owned resources.
+ */
+public final class ShadowTerrain implements AutoCloseable {
+    /** Bounds metadata/work as well as geometry; shader options reach 256 blocks. */
+    public static final int MAX_DISTANCE = 256;
+    private static final int MAX_SECTIONS_PER_UPDATE = 4;
+    private static final long BUILD_NANOS = 3_000_000L;
+    private static final long MAX_GPU_BYTES = 96L * 1024 * 1024;
+    private static final int MAX_SECTION_QUADS = 65_536;
+    private static final int MAX_SHAPES = 1024;
+    private static final int MAX_BOXES = 256;
+    private static final Direction[] DIRECTIONS = Direction.values();
+
+    /** Borrowed buffer: owned exclusively by this cache, valid until its next update/close. */
+    public record Entry(int x, int y, int z, GpuBuffer vertices, int indexCount) { }
+
+    private final Map<Long, LevelChunk> chunks = new HashMap<>();
+    private final Map<Long, Section> sections = new HashMap<>();
+    private final Map<BlockState, Shape> shapes = new IdentityHashMap<>();
+    private ClientLevel level;
+    private Bounds bounds;
+    private Build building;
+    private long gpuBytes;
+    private List<Entry> entries = List.of();
+    private boolean entriesChanged;
+    private long reconciledTick = Long.MIN_VALUE;
+    private boolean metadataDirty = true;
+    private int cameraSectionX, cameraSectionY, cameraSectionZ;
+
+    /**
+     * Refreshes loaded section metadata, then meshes at most four sections within a soft 3 ms
+     * budget. A large section resumes next call; a single shape lookup or GPU upload cannot be
+     * preempted. distance is in blocks, 0..MAX_DISTANCE. The receiver volume plus an eight-block guard
+     * is extruded by twice that distance toward the sun, rounded to sections and clipped
+     * to the level's build height. This includes loaded casters outside the camera frustum.
+     *
+     * <p>The 96 MiB vertex budget favors nearer sections. Evicted/deferred meshes are retried
+     * when room becomes available or the camera enters another section. Pathological geometry
+     * exceeding 256 boxes per state or 65,536 quads per section is omitted, never approximated
+     * by a full cube or uploaded partially. It can be retried after invalidation.
+     */
+    public List<Entry> update(ClientLevel level, Vec3 camera, int distance, Vector3fc sun) {
+        RenderSystem.assertOnRenderThread();
+        if (level == null) {
+            close();
+            return entries;
+        }
+        Objects.requireNonNull(camera, "camera");
+        if (distance < 0 || distance > MAX_DISTANCE || !Double.isFinite(camera.x)
+                || !Double.isFinite(camera.y) || !Double.isFinite(camera.z)) {
+            throw new IllegalArgumentException("Finite camera and shadow distance 0.." + MAX_DISTANCE + " required");
+        }
+        if (this.level != level) {
+            close();
+            this.level = level;
+        }
+        int radius = distance + 8;
+        double dx = sun.x() * distance * 2, dy = sun.y() * distance * 2, dz = sun.z() * distance * 2;
+        Bounds next = new Bounds(section(camera.x - radius + Math.min(0, dx)), section(camera.x + radius + Math.max(0, dx)),
+                Math.max(level.getMinSectionY(), section(camera.y - radius + Math.min(0, dy))),
+                Math.min(level.getMaxSectionY() - 1, section(camera.y + radius + Math.max(0, dy))),
+                section(camera.z - radius + Math.min(0, dz)), section(camera.z + radius + Math.max(0, dz)));
+        int cx = section(camera.x), cy = section(camera.y), cz = section(camera.z);
+        boolean moved = !next.equals(bounds) || cx != cameraSectionX || cy != cameraSectionY || cz != cameraSectionZ;
+        if (bounds != null && !next.equals(bounds)) {
+            // Changing the caster boundary changes which neighboring faces may be culled.
+            for (Section section : sections.values()) {
+                if (bounds.onBoundary(section) || next.onBoundary(section)) dirty(section);
+            }
+        }
+        bounds = next;
+        cameraSectionX = cx;
+        cameraSectionY = cy;
+        cameraSectionZ = cz;
+        // Large ranges must not rescan loaded chunk metadata at the display's frame rate.
+        if (moved || metadataDirty || reconciledTick != level.getGameTime()) {
+            reconcile();
+            reconciledTick = level.getGameTime();
+            metadataDirty = false;
+        }
+        if (moved) {
+            retryDeferred();
+        }
+
+        long deadline = System.nanoTime() + BUILD_NANOS;
+        int started = building == null ? 0 : 1;
+        try {
+            while (System.nanoTime() < deadline) {
+                if (building == null) {
+                    if (started == MAX_SECTIONS_PER_UPDATE) break;
+                    Section nearest = nearestDirty(camera);
+                    if (nearest == null) break;
+                    building = new Build(nearest);
+                    started++;
+                }
+                if (!advance(building, deadline)) break;
+                Build finished = building;
+                building = null;
+                try (finished) {
+                    upload(finished, camera);
+                }
+            }
+        } catch (RuntimeException | Error failure) {
+            cancelBuild();
+            throw failure;
+        }
+        return entries();
+    }
+
+    /** Immutable snapshot; consume after update and before another update or close. */
+    public List<Entry> entries() {
+        RenderSystem.assertOnRenderThread();
+        if (entriesChanged) {
+            var result = new ArrayList<Entry>();
+            for (Section section : sections.values()) {
+                if (section.entry != null) result.add(section.entry);
+            }
+            entries = List.copyOf(result);
+            entriesChanged = false;
+        }
+        return entries;
+    }
+
+    /** Outstanding rebuilds, including the in-progress section; excludes memory-deferred work. */
+    public int pendingSections() {
+        RenderSystem.assertOnRenderThread();
+        int pending = 0;
+        for (Section section : sections.values()) {
+            if (section.dirty && !section.deferred) pending++;
+        }
+        return pending;
+    }
+
+    /** No runnable mesh work after the last update; may still omit memory/complexity-limited sections. */
+    public boolean settled() {
+        return pendingSections() == 0;
+    }
+
+    /** Coordinates are section coordinates, not block origins. Caller also invalidates neighbors. */
+    public void dirtySection(int sx, int sy, int sz) {
+        RenderSystem.assertOnRenderThread();
+        Section section = sections.get(SectionPos.asLong(sx, sy, sz));
+        if (section != null) dirty(section);
+        else metadataDirty = true;
+    }
+
+    /** Coordinates are chunk coordinates. Caller also invalidates adjacent chunks as needed. */
+    public void dirtyChunk(int cx, int cz) {
+        RenderSystem.assertOnRenderThread();
+        metadataDirty = true;
+        for (Section section : sections.values()) {
+            if (section.x == cx && section.z == cz) dirty(section);
+        }
+    }
+
+    private void dirty(Section section) {
+        section.dirty = true;
+        section.deferred = false;
+        if (building != null && building.section == section) cancelBuild();
+    }
+
+    /** Poll only chunk identities and section emptiness; never scan unchanged block storage. */
+    private void reconcile() {
+        var loaded = new HashMap<Long, LevelChunk>();
+        if (bounds.minY <= bounds.maxY) {
+            for (int x = bounds.minX; x <= bounds.maxX; x++) {
+                for (int z = bounds.minZ; z <= bounds.maxZ; z++) {
+                    LevelChunk chunk = level.getChunkSource().getChunk(x, z, ChunkStatus.FULL, false);
+                    long key = ChunkPos.pack(x, z);
+                    if (chunk != null) loaded.put(key, chunk);
+                    if (chunks.get(key) != chunk) dirtyChunkAndNeighbors(x, z);
+                }
+            }
+        }
+        for (long key : chunks.keySet()) {
+            if (!loaded.containsKey(key)) dirtyChunkAndNeighbors(ChunkPos.getX(key), ChunkPos.getZ(key));
+        }
+        chunks.clear();
+        chunks.putAll(loaded);
+
+        boolean freed = false;
+        for (Iterator<Section> iterator = sections.values().iterator(); iterator.hasNext();) {
+            Section section = iterator.next();
+            LevelChunk chunk = chunks.get(ChunkPos.pack(section.x, section.z));
+            if (!bounds.contains(section.x, section.y, section.z) || chunk != section.chunk
+                    || chunk.getSection(level.getSectionIndexFromSectionY(section.y)) != section.storage
+                    || section.storage.hasOnlyAir()) {
+                if (building != null && building.section == section) cancelBuild();
+                freed |= section.entry != null;
+                release(section);
+                iterator.remove();
+            }
+        }
+        for (LevelChunk chunk : chunks.values()) {
+            int x = chunk.getPos().x(), z = chunk.getPos().z();
+            for (int y = bounds.minY; y <= bounds.maxY; y++) {
+                LevelChunkSection storage = chunk.getSection(level.getSectionIndexFromSectionY(y));
+                long key = SectionPos.asLong(x, y, z);
+                if (!storage.hasOnlyAir() && !sections.containsKey(key)) {
+                    sections.put(key, new Section(x, y, z, chunk, storage));
+                }
+            }
+        }
+        if (freed) retryDeferred();
+    }
+
+    private void dirtyChunkAndNeighbors(int x, int z) {
+        dirtyChunk(x, z);
+        dirtyChunk(x - 1, z);
+        dirtyChunk(x + 1, z);
+        dirtyChunk(x, z - 1);
+        dirtyChunk(x, z + 1);
+    }
+
+    private void retryDeferred() {
+        for (Section section : sections.values()) {
+            if (section.deferred) {
+                section.deferred = false;
+                section.dirty = true;
+            }
+        }
+    }
+
+    private Section nearestDirty(Vec3 camera) {
+        Section nearest = null;
+        double best = Double.POSITIVE_INFINITY;
+        for (Section section : sections.values()) {
+            if (section.dirty && !section.deferred) {
+                double distance = section.distanceSquared(camera);
+                if (distance < best) {
+                    best = distance;
+                    nearest = section;
+                }
+            }
+        }
+        return nearest;
+    }
+
+    private boolean advance(Build build, long deadline) {
+        while (build.cursor < 4096) {
+            int index = build.cursor++;
+            int x = index & 15, z = (index >> 4) & 15, y = index >> 8;
+            var state = build.section.storage.getBlockState(x, y, z);
+            boolean foliage = state.is(BlockTags.LEAVES);
+            Shape shape = foliage ? LEAVES : shape(state);
+            if (shape != null) {
+                if (shape.boxes == null) {
+                    build.oversized = true;
+                    return true;
+                }
+                int hidden = 0;
+                for (Direction direction : DIRECTIONS) {
+                    if (foliage) break; // Retain internal leaf faces: each layer contributes transmission.
+                    BlockState neighbor = neighbor(build.section, x + direction.getStepX(),
+                            y + direction.getStepY(), z + direction.getStepZ());
+                    Shape other = neighbor == null ? null : shape(neighbor);
+                    if (other != null && (other.fullFaces & (1 << direction.getOpposite().ordinal())) != 0) {
+                        hidden |= 1 << direction.ordinal();
+                    }
+                }
+                for (AABB box : shape.boxes) {
+                    for (Direction direction : DIRECTIONS) {
+                        if ((hidden & (1 << direction.ordinal())) != 0 && atBoundary(box, direction)) continue;
+                        if (build.quads == MAX_SECTION_QUADS) {
+                            build.oversized = true;
+                            return true;
+                        }
+                        face(build.vertices, box, x, y, z, direction, foliage ? 0xFFFFFFFF : 0xFF000000);
+                        build.quads++;
+                    }
+                }
+            }
+            if ((build.cursor & 31) == 0 && System.nanoTime() >= deadline) return build.cursor == 4096;
+        }
+        return true;
+    }
+
+    private BlockState neighbor(Section section, int x, int y, int z) {
+        if ((x | y | z) >= 0 && x < 16 && y < 16 && z < 16) {
+            return section.storage.getBlockState(x, y, z);
+        }
+        int sx = section.x + (x >> 4), sy = section.y + (y >> 4), sz = section.z + (z >> 4);
+        // Keep the exterior faces of the caster volume; no dependency on chunks outside it.
+        if (!bounds.contains(sx, sy, sz)) return null;
+        LevelChunk chunk = chunks.get(ChunkPos.pack(sx, sz));
+        if (chunk == null) return null;
+        return chunk.getSection(level.getSectionIndexFromSectionY(sy)).getBlockState(x & 15, y & 15, z & 15);
+    }
+
+    private Shape shape(BlockState state) {
+        // Retain the solid part of waterlogged slabs/stairs, but never mesh the fluid itself.
+        if (state.isAir() || state.is(BlockTags.LEAVES) || !state.canOcclude() || state.liquid()) return null;
+        Shape cached = shapes.get(state);
+        if (cached != null) return cached;
+        // In 26.3 occlusion shapes are cached on BlockState and take no level/position argument.
+        var voxel = state.getOcclusionShape();
+        var boxes = new ArrayList<AABB>();
+        voxel.forAllBoxes((x0, y0, z0, x1, y1, z1) -> {
+            if (boxes.size() <= MAX_BOXES) boxes.add(new AABB(x0, y0, z0, x1, y1, z1));
+        });
+        int fullFaces = 0;
+        for (Direction direction : DIRECTIONS) {
+            if (Block.isFaceFull(voxel, direction)) fullFaces |= 1 << direction.ordinal();
+        }
+        // An omitted shape must not hide the faces of the surrounding geometry.
+        Shape result = boxes.size() > MAX_BOXES ? new Shape(null, 0) : new Shape(boxes.toArray(AABB[]::new), fullFaces);
+        if (shapes.size() == MAX_SHAPES) shapes.clear();
+        shapes.put(state, result);
+        return result;
+    }
+
+    private void upload(Build build, Vec3 camera) {
+        Section section = build.section;
+        if (build.oversized || build.quads == 0) {
+            release(section);
+            section.dirty = false;
+            retryDeferred();
+            return;
+        }
+        try (var mesh = build.vertices.buildOrThrow()) {
+            long bytes = mesh.vertexBuffer().remaining();
+            long previous = section.entry == null ? 0 : section.entry.vertices.size();
+            // Release the old buffer before replacement, so even transient owned GPU memory is bounded.
+            release(section);
+            while (gpuBytes + bytes > MAX_GPU_BYTES) {
+                Section farthest = null;
+                double far = section.distanceSquared(camera);
+                for (Section candidate : sections.values()) {
+                    double distance = candidate.distanceSquared(camera);
+                    if (candidate.entry != null && distance > far) {
+                        farthest = candidate;
+                        far = distance;
+                    }
+                }
+                if (farthest == null) {
+                    section.deferred = true;
+                    return;
+                }
+                release(farthest);
+                farthest.dirty = true;
+                farthest.deferred = true;
+            }
+            int indexCount = mesh.drawState().indexCount();
+            RenderSystem.getSequentialBuffer(PrimitiveTopology.QUADS).getBuffer(indexCount);
+            GpuBuffer buffer = RenderSystem.getDevice().createBuffer(() -> "Sanctuary shadow terrain "
+                            + section.x + "," + section.y + "," + section.z,
+                    GpuBuffer.USAGE_VERTEX | GpuBuffer.USAGE_COPY_DST, mesh.vertexBuffer());
+            section.entry = new Entry(section.x << 4, section.y << 4, section.z << 4, buffer, indexCount);
+            gpuBytes += buffer.size();
+            section.dirty = false;
+            entriesChanged = true;
+            if (bytes < previous) retryDeferred();
+        }
+    }
+
+    private void release(Section section) {
+        if (section.entry != null) {
+            GpuBuffer buffer = section.entry.vertices;
+            gpuBytes -= buffer.size();
+            buffer.close();
+            section.entry = null;
+            entriesChanged = true;
+        }
+    }
+
+    private void cancelBuild() {
+        if (building != null) {
+            building.close();
+            building = null;
+        }
+    }
+
+    @Override
+    public void close() {
+        RenderSystem.assertOnRenderThread();
+        cancelBuild();
+        for (Section section : sections.values()) release(section);
+        sections.clear();
+        chunks.clear();
+        reconciledTick = Long.MIN_VALUE;
+        metadataDirty = true;
+        shapes.clear();
+        entries = List.of();
+        entriesChanged = false;
+        gpuBytes = 0;
+        bounds = null;
+        level = null;
+    }
+
+    private static int section(double coordinate) {
+        return (int) Math.floor(coordinate / 16.0);
+    }
+
+    private static boolean atBoundary(AABB box, Direction direction) {
+        return switch (direction) {
+            case DOWN -> box.minY == 0;
+            case UP -> box.maxY == 1;
+            case NORTH -> box.minZ == 0;
+            case SOUTH -> box.maxZ == 1;
+            case WEST -> box.minX == 0;
+            case EAST -> box.maxX == 1;
+        };
+    }
+
+    /** Counterclockwise exterior faces, matching the native sequential QUADS index order. */
+    private static void face(BufferBuilder out, AABB box, int x, int y, int z, Direction direction, int color) {
+        float x0 = x + (float) box.minX, x1 = x + (float) box.maxX;
+        float y0 = y + (float) box.minY, y1 = y + (float) box.maxY;
+        float z0 = z + (float) box.minZ, z1 = z + (float) box.maxZ;
+        switch (direction) {
+            case DOWN -> {
+                out.addVertex(x0, y0, z0).setColor(color); out.addVertex(x1, y0, z0).setColor(color);
+                out.addVertex(x1, y0, z1).setColor(color); out.addVertex(x0, y0, z1).setColor(color);
+            }
+            case UP -> {
+                out.addVertex(x0, y1, z0).setColor(color); out.addVertex(x0, y1, z1).setColor(color);
+                out.addVertex(x1, y1, z1).setColor(color); out.addVertex(x1, y1, z0).setColor(color);
+            }
+            case NORTH -> {
+                out.addVertex(x0, y0, z0).setColor(color); out.addVertex(x0, y1, z0).setColor(color);
+                out.addVertex(x1, y1, z0).setColor(color); out.addVertex(x1, y0, z0).setColor(color);
+            }
+            case SOUTH -> {
+                out.addVertex(x0, y0, z1).setColor(color); out.addVertex(x1, y0, z1).setColor(color);
+                out.addVertex(x1, y1, z1).setColor(color); out.addVertex(x0, y1, z1).setColor(color);
+            }
+            case WEST -> {
+                out.addVertex(x0, y0, z0).setColor(color); out.addVertex(x0, y0, z1).setColor(color);
+                out.addVertex(x0, y1, z1).setColor(color); out.addVertex(x0, y1, z0).setColor(color);
+            }
+            case EAST -> {
+                out.addVertex(x1, y0, z0).setColor(color); out.addVertex(x1, y1, z0).setColor(color);
+                out.addVertex(x1, y1, z1).setColor(color); out.addVertex(x1, y0, z1).setColor(color);
+            }
+        }
+    }
+
+    private record Bounds(int minX, int maxX, int minY, int maxY, int minZ, int maxZ) {
+        boolean contains(int x, int y, int z) {
+            return x >= minX && x <= maxX && y >= minY && y <= maxY && z >= minZ && z <= maxZ;
+        }
+
+        boolean onBoundary(Section section) {
+            return section.x == minX || section.x == maxX || section.y == minY || section.y == maxY
+                    || section.z == minZ || section.z == maxZ;
+        }
+    }
+
+    private record Shape(AABB[] boxes, int fullFaces) { }
+    private static final Shape LEAVES = new Shape(new AABB[]{new AABB(0, 0, 0, 1, 1, 1)}, 0);
+
+    private static final class Section {
+        final int x, y, z;
+        final LevelChunk chunk;
+        final LevelChunkSection storage;
+        Entry entry;
+        boolean dirty = true;
+        boolean deferred;
+
+        Section(int x, int y, int z, LevelChunk chunk, LevelChunkSection storage) {
+            this.x = x;
+            this.y = y;
+            this.z = z;
+            this.chunk = chunk;
+            this.storage = storage;
+        }
+
+        double distanceSquared(Vec3 camera) {
+            double dx = x * 16.0 + 8 - camera.x, dy = y * 16.0 + 8 - camera.y, dz = z * 16.0 + 8 - camera.z;
+            return dx * dx + dy * dy + dz * dz;
+        }
+    }
+
+    private static final class Build implements AutoCloseable {
+        final Section section;
+        final ByteBufferBuilder bytes = new ByteBufferBuilder(64 * 1024);
+        final BufferBuilder vertices = new BufferBuilder(bytes, PrimitiveTopology.QUADS, DefaultVertexFormat.POSITION_COLOR);
+        int cursor, quads;
+        boolean oversized;
+
+        Build(Section section) {
+            this.section = section;
+        }
+
+        @Override
+        public void close() {
+            bytes.close();
+        }
+    }
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/client/shader/VanillaLight.java

@@ -14,25 +14,61 @@ public final class VanillaLight {
             ||FabricLoader.getInstance().isModLoaded("oculus")||FabricLoader.getInstance().isModLoaded("canvas");
     private static Preferences preferences;
     private VanillaLight() { }
-    private static final class Preferences { boolean enabled=true;int saturation=142; }
+    private static final class Preferences {
+        boolean enabled=true;
+        int saturation=142;
+        boolean pixelShadows=false;
+        boolean edgeHighlights=false;
+        int edgeIntensity=30;
+        int edgeDistance=32;
+        int shadowPixels=16;
+        int shadowDistance=32;
+    }
     private static Path path(){return FabricLoader.getInstance().getConfigDir().resolve("sanctuary-shaders.json");}
     public static boolean enabled(){
         if(preferences==null){
             try{if(Files.isRegularFile(path()))preferences=new GsonBuilder().create().fromJson(Files.readString(path()),Preferences.class);}
             catch(Exception e){SanctuaryMod.LOGGER.warn("Cannot read Sanctuary shader preference",e);}
             if(preferences==null)preferences=new Preferences();
+            preferences.edgeIntensity=Math.clamp(preferences.edgeIntensity,0,100);
+            preferences.edgeDistance=normalizeShadowDistance(preferences.edgeDistance);
             preferences.saturation=Math.clamp(preferences.saturation,0,200);
+            preferences.shadowPixels=normalizeShadowValue(preferences.shadowPixels,8,16,32);
+            preferences.shadowDistance=normalizeShadowDistance(preferences.shadowDistance);
         }
         return preferences.enabled;
     }
     public static boolean externalEngine(){return EXTERNAL_ENGINE;}
     public static boolean active(){return ProgressionClient.active()&&!EXTERNAL_ENGINE&&enabled();}
     public static int saturation(){enabled();return preferences.saturation;}
+    public static boolean edgeHighlights(){enabled();return preferences.edgeHighlights;}
+    public static int edgeDistance(){enabled();return preferences.edgeDistance;}
+    public static void setEdgeDistance(int value){enabled();preferences.edgeDistance=normalizeShadowDistance(value);save();}
+    public static int edgeIntensity(){enabled();return preferences.edgeIntensity;}
+    public static void setEdgeHighlights(boolean value){enabled();preferences.edgeHighlights=value;save();}
+    public static void setEdgeIntensity(int value){enabled();preferences.edgeIntensity=Math.clamp(value,0,100);save();}
+    public static boolean pixelShadows(){enabled();return preferences.pixelShadows;}
+    public static int shadowPixels(){enabled();return preferences.shadowPixels;}
+    public static int shadowDistance(){enabled();return preferences.shadowDistance;}
     public static void setSaturation(int value){enabled();preferences.saturation=Math.clamp(value,0,200);save();}
+    public static void setPixelShadows(boolean value){enabled();preferences.pixelShadows=value;save();}
+    public static void setShadowPixels(int value){enabled();preferences.shadowPixels=normalizeShadowValue(value,8,16,32);save();}
+    public static void setShadowDistance(int value){enabled();preferences.shadowDistance=normalizeShadowDistance(value);save();}
     public static void setEnabled(boolean value){
         enabled();preferences.enabled=value;
         save();
     }
+    /** Nearest supported value, clamped at either end; midpoint ties round up. */
+    private static int normalizeShadowValue(int value,int low,int middle,int high){
+        if(value<(low+middle)/2)return low;
+        return value<(middle+high)/2?middle:high;
+    }
+    private static int normalizeShadowDistance(int value){
+        if(value<24)return 16;
+        if(value<48)return 32;
+        if(value<96)return 64;
+        return value<192?128:256;
+    }
     private static void save(){
         try{
             Files.createDirectories(path().getParent());var temporary=path().resolveSibling(path().getFileName()+".tmp");

mods/sanctuary/src/main/java/fr/koka/sanctuary/companion/CompanionQueries.java

@@ -34,13 +34,17 @@ public final class CompanionQueries {
             &&familiar.egg().getItem() instanceof net.minecraft.world.item.SpawnEggItem?net.minecraft.world.item.SpawnEggItem.getType(familiar.egg()):entity.getType();
         var id=BuiltInRegistries.ENTITY_TYPE.getKey(type).getPath();
         if(CompanionType.find(id)==null)return;
-        var seen=new TreeSet<>(Arrays.asList(record.notes().getOrDefault("seen_mobs","").split(",")));seen.remove("");
-        if(seen.add(id))record=record.note("seen_mobs",String.join(",",seen));
+        record=discoverSpecies(record,List.of(id));
         if(entity instanceof net.minecraft.world.entity.animal.fish.TropicalFish fish){
             var variants=fishVariants(record);variants.set(fishVariant(fish));record=record.note("seen_fish_v1",Base64.getEncoder().encodeToString(variants.toByteArray()));
         }
         if(!record.equals(CompanionService.record(p)))CompanionService.save(p,record);
     }
+    /** The same encounter record is used by natural observation and administrative discoveries. */
+    public static CompanionRecord discoverSpecies(CompanionRecord record,Collection<String> ids){
+        var seen=new TreeSet<>(Arrays.asList(record.notes().getOrDefault("seen_mobs","").split(",")));seen.remove("");
+        return seen.addAll(ids)?record.note("seen_mobs",String.join(",",seen)):record;
+    }
     private static int fishVariant(net.minecraft.world.entity.animal.fish.TropicalFish fish){
         int packed=fish.getPattern().getPackedId();return ((packed>>>8)*2+(packed&1))*256+fish.getBaseColor().getId()*16+fish.getPatternColor().getId();
     }

mods/sanctuary/src/main/java/fr/koka/sanctuary/cosmetics/CarryGlide.java

@@ -31,6 +31,7 @@ public final class CarryGlide {
     }
     public static boolean active(Player p){return supported(p)&&!p.onGround()&&(p.getDeltaMovement().y<=0||lifting(p));}
     public static void tick(Player p){
+        if(CarryPanic.apply(p))return;
         boolean lift=lifting(p);
         if(!lift&&!active(p))return;
         var velocity=p.getDeltaMovement();

mods/sanctuary/src/main/java/fr/koka/sanctuary/cosmetics/CarryPanic.java

@@ -0,0 +1,62 @@
+package fr.koka.sanctuary.cosmetics;
+
+import fr.koka.sanctuary.SanctuaryMod;
+import net.fabricmc.fabric.api.attachment.v1.*;
+import net.fabricmc.fabric.api.entity.event.v1.ServerLivingEntityEvents;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.network.chat.Component;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.*;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.phys.Vec3;
+
+/** Server-chosen, temporary flight; both sides use the same bounded native movement. */
+public final class CarryPanic {
+    public record Flight(int animal,long start,int duration,float yaw,float phase){
+        static final StreamCodec<RegistryFriendlyByteBuf,Flight> CODEC=StreamCodec.of(
+            (b,f)->{b.writeVarInt(f.animal);b.writeLong(f.start);b.writeVarInt(f.duration);b.writeFloat(f.yaw);b.writeFloat(f.phase);},
+            b->new Flight(b.readVarInt(),b.readLong(),b.readVarInt(),b.readFloat(),b.readFloat()));
+        public Vec3 velocity(long now){
+            double t=Math.clamp(now-start,0,duration),angle=yaw+Math.sin(t*.27+phase)*.65+Math.sin(t*.61)*.18;
+            double speed=.28+.05*Math.sin(t*.23+phase);
+            double rise=t<5?.24:.12+.045*Math.sin(t*.32+phase);
+            double fade=Math.min(1,(duration-t)/8.0);
+            return new Vec3(-Math.sin(angle)*speed*fade,rise*fade,Math.cos(angle)*speed*fade);
+        }
+    }
+    public static final AttachmentType<Flight> FLIGHT=AttachmentRegistry.create(SanctuaryMod.id("carry_panic"),
+        b->b.syncWith(Flight.CODEC,AttachmentSyncPredicate.all()));
+    private CarryPanic(){}
+    public static void register(){
+        ServerLivingEntityEvents.AFTER_DAMAGE.register((entity,source,base,taken,blocked)->{
+            if(taken>0&&!blocked)start(entity);
+        });
+    }
+    public static boolean canStrike(Entity actor,Entity target){
+        return actor instanceof Player p&&!p.isSpectator()&&p.isAlive()&&target instanceof Mob
+            &&target.getVehicle()==p&&CarryService.carried(target)&&CarryGlide.flyer(target);
+    }
+    public static void start(Entity animal){
+        if(!(animal.getVehicle() instanceof ServerPlayer p)||!CarryService.carried(animal)||!CarryGlide.flyer(animal)||!CarryGlide.supported(p))return;
+        long now=p.level().getGameTime();var previous=p.getAttached(FLIGHT);
+        if(previous!=null&&now-previous.start()<10)return;
+        var random=p.getRandom();
+        var flight=new Flight(animal.getId(),now,40+random.nextInt(21),random.nextFloat()*(float)(Math.PI*2),random.nextFloat()*(float)(Math.PI*2));
+        p.setAttached(FLIGHT,flight);apply(p);p.syncVelocity=true;
+        p.sendOverlayMessage(Component.translatable("sanctuary.carry.panic"));
+    }
+    public static boolean active(Player p){
+        var flight=p.getAttached(FLIGHT);if(flight==null||!CarryGlide.supported(p))return false;
+        long elapsed=p.level().getGameTime()-flight.start();
+        return elapsed>=0&&elapsed<flight.duration()&&p.getPassengers().stream().anyMatch(e->e.getId()==flight.animal()&&CarryService.carried(e)&&CarryGlide.flyer(e));
+    }
+    public static boolean apply(Player p){
+        if(!active(p)){
+            if(!p.level().isClientSide()&&p.hasAttached(FLIGHT))p.removeAttached(FLIGHT);
+            return false;
+        }
+        p.setDeltaMovement(p.getAttached(FLIGHT).velocity(p.level().getGameTime()));p.resetFallDistance();return true;
+    }
+    public static void clear(Player p){if(p.hasAttached(FLIGHT))p.removeAttached(FLIGHT);}
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/cosmetics/CarryService.java

@@ -46,6 +46,7 @@ public final class CarryService {
             &&!fr.koka.sanctuary.boats.BoatPassengerInteractions.aboardTogether(a,b)
             &&!fr.koka.sanctuary.boats.BoatPassengerInteractions.aboardTogether(b,a));}
     private static Entity root(Entity e){while(carried(e))e=e.getVehicle();return e;}
+    public static boolean blocksAttack(Entity attacker,Entity target){return pair(attacker,target)&&!CarryPanic.canStrike(attacker,target);}
     /** One seat per head; the chain includes babies even though they add no carrying penalty. */
     private static Entity passenger(Entity e){
         return e instanceof Player&&e.getPassengers().size()==1&&carried(e.getFirstPassenger())?e.getFirstPassenger():null;
@@ -60,6 +61,7 @@ public final class CarryService {
         };
     }
     public static void register(){
+        CarryPanic.register();
         net.fabricmc.fabric.api.networking.v1.PayloadTypeRegistry.serverboundPlay().register(Drop.TYPE,Drop.CODEC);
         net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking.registerGlobalReceiver(Drop.TYPE,(request,context)->context.server().execute(()->{
             if(active(context.player()))for(var passenger:List.copyOf(context.player().getPassengers()))if(carried(passenger))release(passenger,true);
@@ -72,7 +74,7 @@ public final class CarryService {
             if(!success)player.sendOverlayMessage(Component.translatable("sanctuary.carry.unavailable"));
             return InteractionResult.SUCCESS;
         });
-        AttackEntityCallback.EVENT.register((p,level,hand,target,hit)->pair(p,target)?InteractionResult.FAIL:InteractionResult.PASS);
+        AttackEntityCallback.EVENT.register((p,level,hand,target,hit)->blocksAttack(p,target)?InteractionResult.FAIL:InteractionResult.PASS);
         ServerTickEvents.END_SERVER_TICK.register(s->{
             for(var rider:new ArrayList<>(RIDES.keySet())){
                 var ride=RIDES.get(rider);if(ride==null||ride.carrier.level().getServer()!=s)continue;
@@ -187,7 +189,7 @@ public final class CarryService {
     public static boolean mayDismount(Player p){var ride=RIDES.get(p);return ride==null||ride.releasedShift;}
     public static void removed(Entity rider){
         var ride=RIDES.remove(rider);rider.removeAttached(CARRIED);
-        if(ride!=null){refreshBelow(ride.carrier);ride.carrier.connection.send(new net.minecraft.network.protocol.game.ClientboundSetPassengersPacket(ride.carrier));}
+        if(ride!=null){CarryPanic.clear(ride.carrier);refreshBelow(ride.carrier);ride.carrier.connection.send(new net.minecraft.network.protocol.game.ClientboundSetPassengersPacket(ride.carrier));}
     }
     public static boolean release(Entity rider,boolean place){
         var ride=RIDES.get(rider);if(ride==null){rider.removeAttached(CARRIED);return false;}
@@ -209,6 +211,7 @@ public final class CarryService {
         return true;
     }
     public static void detach(ServerPlayer p){
+        CarryPanic.clear(p);
         // Put down the upper group before removing its support, without orphaning its riders.
         for(var e:List.copyOf(p.getPassengers()))if(carried(e))release(e,true);
         if(RIDES.containsKey(p))release(p,true);

mods/sanctuary/src/main/java/fr/koka/sanctuary/cosmetics/FamiliarEntity.java

@@ -245,7 +245,7 @@ public final class FamiliarEntity extends PathfinderMob {
         return super.causeFallDamage(distance,multiplier,source);
     }
     @Override public boolean hurtServer(ServerLevel level,DamageSource source,float amount) {
-        boolean hurt=fr.koka.sanctuary.familiar.FamiliarBattle.hurt(this,source,amount);if(hurt)playTapSound(source);return hurt;
+        boolean hurt=fr.koka.sanctuary.familiar.FamiliarBattle.hurt(this,source,amount);if(hurt){playTapSound(source);CarryPanic.start(this);}return hurt;
     }
     @Override public boolean isIgnoringBlockTriggers() {return true;}
     @Override public boolean canBeHitByProjectile() {return true;}
@@ -316,11 +316,12 @@ public final class FamiliarEntity extends PathfinderMob {
     }
     /** Native feedback without damage callbacks, enchantments, aggro or durability. */
     public void tap(ServerPlayer player) {
-        if(hurtTime>0||!isAlive()||player.level()!=level()||player.isSpectator()||CarryService.pair(player,this))return;
+        if(hurtTime>0||!isAlive()||player.level()!=level()||player.isSpectator()||CarryService.blocksAttack(player,this))return;
         var source=damageSources().playerAttack(player);
         if(!HeadEquipment.get(this).isEmpty()){MobHeadActions.activate(this,source,true);}
         animateHurt(player.getYRot());
         ((ServerLevel)level()).broadcastDamageEvent(this,source);
+        if(CarryPanic.canStrike(player,this)){CarryPanic.start(this);playTapSound(source);return;}
         double dx=player.getX()-getX(),dz=player.getZ()-getZ();
         if(dx*dx+dz*dz<1.0E-5){var look=player.getLookAngle();dx=-look.x;dz=-look.z;}
         knockback(.4,dx,dz,source,0);

mods/sanctuary/src/main/java/fr/koka/sanctuary/cosmetics/FamiliarService.java

@@ -29,7 +29,7 @@ public final class FamiliarService {
         net.fabricmc.fabric.api.event.player.AttackEntityCallback.EVENT.register((player,level,hand,target,hit)->{
             if(!(target instanceof FamiliarEntity pet)||player.isSpectator())return net.minecraft.world.InteractionResult.PASS;
             if(pet.owner()!=null&&fr.koka.sanctuary.familiar.FamiliarDuels.fighting(pet.owner()))return net.minecraft.world.InteractionResult.FAIL;
-            if(CarryService.pair(player,pet))return net.minecraft.world.InteractionResult.FAIL;
+            if(CarryService.blocksAttack(player,pet))return net.minecraft.world.InteractionResult.FAIL;
             if(player instanceof ServerPlayer attacker&&fr.koka.sanctuary.familiar.FamiliarBattle.enemy(attacker,pet))return net.minecraft.world.InteractionResult.PASS;
             if(player instanceof ServerPlayer p&&p.isWithinEntityInteractionRange(pet,0)&&p.hasLineOfSight(pet))pet.tap(p);
             return net.minecraft.world.InteractionResult.SUCCESS;

mods/sanctuary/src/main/java/fr/koka/sanctuary/cosmetics/HeadBlockService.java

@@ -264,8 +264,13 @@ public final class HeadBlockService {
                         var data=stack.get(DataComponents.BLOCK_ENTITY_DATA);
                         if(data!=null)data.loadInto(entity,level().registryAccess());
                     }
-                    // Ordinary inventory data belongs to the equipped session, not its transferable item.
-                    if(!keepsContents()){stack.remove(DataComponents.CONTAINER);stack.remove(DataComponents.BLOCK_ENTITY_DATA);}
+                    // Storage belongs to the equipped session. A sculpture's block-entity data is
+                    // its actual geometry, not inventory: keep it on the transferable item.
+                    if(!keepsContents()){
+                        stack.remove(DataComponents.CONTAINER);
+                        if(!(entity instanceof fr.koka.sanctuary.plans.StatuaryEntity))stack.remove(DataComponents.BLOCK_ENTITY_DATA);
+                    }
+                    restoreSculptureData();
                 }
             }
         }
@@ -321,6 +326,15 @@ public final class HeadBlockService {
         }
         public void flushItem(){
             if((keepsContents()||entity instanceof BeehiveBlockEntity)&&entity!=null)stack.applyComponents(entity.collectComponents());
+            restoreSculptureData();
+        }
+        private void restoreSculptureData(){
+            // Older equipped sessions may still hold the model after the stack lost it.
+            // Repair only from that authoritative data, and only once; never invent geometry.
+            if(entity instanceof fr.koka.sanctuary.plans.StatuaryEntity sculpture&&!stack.has(DataComponents.BLOCK_ENTITY_DATA)){
+                var data=sculpture.item().get(DataComponents.BLOCK_ENTITY_DATA);
+                if(data!=null)stack.set(DataComponents.BLOCK_ENTITY_DATA,data);
+            }
         }
         public CompoundTag save(){
             flushItem();var tag=new CompoundTag();tag.putInt("schema",1);

mods/sanctuary/src/main/java/fr/koka/sanctuary/gems/GemOreFeature.java

@@ -0,0 +1,19 @@
+package fr.koka.sanctuary.gems;
+
+import com.mojang.serialization.MapCodec;
+import fr.koka.sanctuary.worldgen.SanctuaryChunkGenerator;
+import net.minecraft.core.BlockPos;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.WorldGenLevel;
+import net.minecraft.world.level.chunk.ChunkGenerator;
+import net.minecraft.world.level.levelgen.feature.*;
+
+/** Native seeded ore veins, scoped to Sanctuary even when its biomes are shared with vanilla. */
+public record GemOreFeature(OreFeature ore) implements Feature {
+    public static final MapCodec<GemOreFeature> CODEC=OreFeature.CODEC.xmap(GemOreFeature::new,GemOreFeature::ore);
+    @Override public MapCodec<GemOreFeature> codec(){return CODEC;}
+    @Override public boolean place(WorldGenLevel level,ChunkGenerator generator,RandomSource random,BlockPos origin){
+        if(!(level.getLevel().getChunkSource().getGenerator() instanceof SanctuaryChunkGenerator))return false;
+        return ore.place(level,generator,random,origin);
+    }
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/gems/Gems.java

@@ -0,0 +1,50 @@
+package fr.koka.sanctuary.gems;
+
+import fr.koka.sanctuary.SanctuaryMod;
+import java.util.List;
+import net.fabricmc.fabric.api.biome.v1.BiomeModifications;
+import net.fabricmc.fabric.api.creativetab.v1.CreativeModeTabEvents;
+import net.minecraft.core.Registry;
+import net.minecraft.core.registries.*;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.tags.TagKey;
+import net.minecraft.util.valueproviders.UniformInt;
+import net.minecraft.world.item.*;
+import net.minecraft.world.level.block.*;
+import net.minecraft.world.level.block.state.BlockBehaviour;
+import net.minecraft.world.level.levelgen.GenerationStep;
+
+/** Ordinary gem items and blocks; their distribution lives in data, not this registry. */
+public final class Gems {
+    public record Family(String id,Item gem,Block block,Block ore,Block deepslateOre){}
+    public static final Family RUBY=family("ruby",DyeColor.RED);
+    public static final Family SAPPHIRE=family("sapphire",DyeColor.BLUE);
+    public static final List<Family> FAMILIES=List.of(RUBY,SAPPHIRE);
+    public static void register(){
+        Registry.register(BuiltInRegistries.FEATURE_TYPE,SanctuaryMod.id("gem_ore"),GemOreFeature.CODEC);
+        for(var f:FAMILIES){
+            var biomes=TagKey.create(Registries.BIOME,SanctuaryMod.id("has_ore/"+f.id));
+            BiomeModifications.addFeature(c->c.hasTag(biomes),GenerationStep.Decoration.UNDERGROUND_ORES,
+                ResourceKey.create(Registries.PLACED_FEATURE,SanctuaryMod.id("ore_"+f.id)));
+        }
+        CreativeModeTabEvents.modifyOutputEvent(CreativeModeTabs.INGREDIENTS).register(out->out.insertAfter(Items.EMERALD,RUBY.gem,SAPPHIRE.gem));
+        CreativeModeTabEvents.modifyOutputEvent(CreativeModeTabs.BUILDING_BLOCKS).register(out->out.insertAfter(Blocks.EMERALD_BLOCK,RUBY.block,SAPPHIRE.block));
+        CreativeModeTabEvents.modifyOutputEvent(CreativeModeTabs.NATURAL_BLOCKS).register(out->{
+            out.insertAfter(Blocks.EMERALD_ORE,RUBY.ore,SAPPHIRE.ore);
+            out.insertAfter(Blocks.DEEPSLATE_EMERALD_ORE,RUBY.deepslateOre,SAPPHIRE.deepslateOre);
+        });
+    }
+    private static Family family(String id,DyeColor color){
+        var key=SanctuaryMod.id(id);var item=Registry.register(BuiltInRegistries.ITEM,key,new Item(new Item.Properties().setId(ResourceKey.create(Registries.ITEM,key))));
+        var block=block(id+"_block",new Block(properties(id+"_block",Blocks.EMERALD_BLOCK).mapColor(color.getMapColor())));
+        var ore=block(id+"_ore",new DropExperienceBlock(UniformInt.of(3,7),properties(id+"_ore",Blocks.EMERALD_ORE)));
+        var deep=block("deepslate_"+id+"_ore",new DropExperienceBlock(UniformInt.of(3,7),properties("deepslate_"+id+"_ore",Blocks.DEEPSLATE_EMERALD_ORE)));
+        return new Family(id,item,block,ore,deep);
+    }
+    private static BlockBehaviour.Properties properties(String id,Block source){return BlockBehaviour.Properties.ofFullCopy(source).setId(ResourceKey.create(Registries.BLOCK,SanctuaryMod.id(id)));}
+    private static Block block(String id,Block block){
+        var key=SanctuaryMod.id(id);Registry.register(BuiltInRegistries.BLOCK,key,block);
+        Registry.register(BuiltInRegistries.ITEM,key,new BlockItem(block,new Item.Properties().setId(ResourceKey.create(Registries.ITEM,key)).useBlockDescriptionPrefix()));return block;
+    }
+    private Gems(){}
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/knowledge/BlockKnowledgeService.java

@@ -47,6 +47,7 @@ public final class BlockKnowledgeService {
     private BlockKnowledgeService() {}
 
     public static void register() {
+        DiscoveryCommands.register();
         ServerPlayConnectionEvents.JOIN.register((handler, sender, server) -> observeInventory(handler.player));
         // Fabric also reaches DISCONNECT through Netty's channelInactive callback.
         ServerPlayConnectionEvents.DISCONNECT.register((handler, server) -> server.execute(() -> {
@@ -97,6 +98,12 @@ public final class BlockKnowledgeService {
 
     public static void recordSeen(ServerPlayer player, Block block) {
         if (block.defaultBlockState().isAir() || player.isSpectator()) return;
+        discover(player,block);
+    }
+
+    /** Explicit discoveries use the same record and events, including for a spectator command target. */
+    public static void discover(ServerPlayer player,Block block) {
+        if(block.defaultBlockState().isAir())return;
         Session session = session(player);
         if (session.failed || !session.memory.recordSeen(id(block))) return;
         session.dirty = true;

mods/sanctuary/src/main/java/fr/koka/sanctuary/knowledge/DiscoveryCommands.java

@@ -0,0 +1,75 @@
+package fr.koka.sanctuary.knowledge;
+
+import com.mojang.brigadier.builder.ArgumentBuilder;
+import com.mojang.brigadier.context.CommandContext;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import fr.koka.sanctuary.companion.*;
+import fr.koka.sanctuary.operator.OperatorService;
+import fr.koka.sanctuary.progression.ProgressEffects;
+import fr.koka.sanctuary.recipes.*;
+import java.util.*;
+import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback;
+import net.minecraft.commands.*;
+import net.minecraft.commands.arguments.*;
+import net.minecraft.core.registries.*;
+import net.minecraft.network.chat.Component;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.item.*;
+import net.minecraft.world.level.block.Block;
+
+/** One command routes through the existing discovery services and their dependent recipe/catalogue rules. */
+public final class DiscoveryCommands {
+    private record Selection(List<Block> blocks,List<Item> items,List<EntityType<?>> mobs){}
+    @FunctionalInterface private interface SelectionArgument {Selection get(CommandContext<CommandSourceStack> context)throws CommandSyntaxException;}
+    public static void register(){
+        CommandRegistrationCallback.EVENT.register((dispatcher,registries,environment)->{
+            var root=Commands.literal("discovery").requires(OperatorService::canCommand);
+            root.then(targets(Commands.literal("all"),c->all(true,true,true)));
+            root.then(Commands.literal("blocks").then(targets(Commands.literal("all"),c->all(true,false,false))));
+            root.then(Commands.literal("items").then(targets(Commands.literal("all"),c->all(false,true,false))));
+            root.then(Commands.literal("mobs").then(targets(Commands.literal("all"),c->all(false,false,true))));
+            root.then(Commands.literal("block").then(targets(Commands.argument("block",ResourceArgument.resource(registries,Registries.BLOCK)),c->new Selection(List.of(ResourceArgument.getResource(c,"block",Registries.BLOCK).value()),List.of(),List.of()))));
+            root.then(Commands.literal("item").then(targets(Commands.argument("item",ResourceArgument.resource(registries,Registries.ITEM)),c->new Selection(List.of(),List.of(ResourceArgument.getResource(c,"item",Registries.ITEM).value()),List.of()))));
+            root.then(Commands.literal("mob").then(targets(Commands.argument("mob",ResourceArgument.resource(registries,Registries.ENTITY_TYPE)),c->new Selection(List.of(),List.of(),List.of(ResourceArgument.getResource(c,"mob",Registries.ENTITY_TYPE).value())))));
+            dispatcher.register(Commands.literal("sanctuary").then(root));
+        });
+    }
+    private static <T extends ArgumentBuilder<CommandSourceStack,T>> T targets(T node,SelectionArgument selection){
+        return node.executes(c->discover(c,selection.get(c),List.of(c.getSource().getPlayerOrException())))
+            .then(Commands.argument("players",EntityArgument.players()).executes(c->discover(c,selection.get(c),EntityArgument.getPlayers(c,"players"))));
+    }
+    private static Selection all(boolean blocks,boolean items,boolean mobs){
+        return new Selection(blocks?BuiltInRegistries.BLOCK.stream().filter(b->!b.defaultBlockState().isAir()).toList():List.of(),
+            items?BuiltInRegistries.ITEM.stream().filter(i->i!=Items.AIR).toList():List.of(),
+            mobs?BuiltInRegistries.ENTITY_TYPE.stream().filter(t->SpawnEggItem.byId(t).isPresent()).toList():List.of());
+    }
+    private static int discover(CommandContext<CommandSourceStack> context,Selection selection,Collection<ServerPlayer> players){
+        var source=context.getSource();
+        if(selection.blocks.stream().anyMatch(b->b.defaultBlockState().isAir())||selection.items.contains(Items.AIR)||selection.mobs.stream().anyMatch(t->SpawnEggItem.byId(t).isEmpty())){
+            source.sendFailure(Component.translatable("sanctuary.discovery.invalid"));return 0;
+        }
+        var species=selection.mobs.stream().map(BuiltInRegistries.ENTITY_TYPE::getKey).map(id->id.getNamespace().equals("minecraft")?id.getPath():id.toString()).toList();
+        int changed=0;
+        for(var player:players){
+            var record=CompanionService.record(player);
+            if(ProgressEffects.get(player)==null||record==null||!BlockKnowledgeService.healthy(player)||!RecipeService.healthy(player)){
+                source.sendFailure(Component.translatable("sanctuary.discovery.unavailable",player.getDisplayName()));continue;
+            }
+            // Validate bounded records before any write; no new save schema or unlock flag.
+            CompanionRecord next;
+            var discoveredItems=new HashSet<String>(RecipeService.knowledge(player).items);
+            for(var item:selection.items)discoveredItems.add(BuiltInRegistries.ITEM.getKey(item).toString());
+            for(var block:selection.blocks)if(block.asItem()!=Items.AIR)discoveredItems.add(BuiltInRegistries.ITEM.getKey(block.asItem()).toString());
+            try{next=CompanionQueries.discoverSpecies(record,species);if(discoveredItems.size()>RecipeKnowledge.MAX_IDS)throw new IllegalArgumentException("Discovery capacity");}
+            catch(IllegalArgumentException invalid){source.sendFailure(Component.translatable("sanctuary.discovery.unavailable",player.getDisplayName()));continue;}
+            CompanionService.save(player,next);
+            for(var block:selection.blocks)BlockKnowledgeService.discover(player,block);
+            for(var item:selection.items){if(item instanceof BlockItem b)BlockKnowledgeService.discover(player,b.getBlock());RecipeService.discover(player,item);}
+            RecipeService.refresh(player);
+            source.sendSuccess(()->Component.translatable("sanctuary.discovery.granted",player.getDisplayName(),selection.blocks.size(),selection.items.size(),selection.mobs.size()),true);changed++;
+        }
+        return changed;
+    }
+    private DiscoveryCommands(){}
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/mixin/CarryFlightConnectionMixin.java

@@ -7,13 +7,13 @@ import org.spongepowered.asm.mixin.*;
 import org.spongepowered.asm.mixin.injection.*;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
-/** Sustained lift is legitimate only while the server sees the equipped, carried large dragon. */
+/** Flight exemption is limited to server-validated dragon lift or a carried flyer's brief panic. */
 @Mixin(ServerGamePacketListenerImpl.class)
 public abstract class CarryFlightConnectionMixin {
     @Shadow public ServerPlayer player;
     @Shadow private boolean clientIsFloating;
     @Inject(method="tick",at=@At("HEAD"))
     private void sanctuary$carriedFlight(CallbackInfo ci){
-        if(CarryGlide.lifting(player))clientIsFloating=false;
+        if(CarryGlide.lifting(player)||fr.koka.sanctuary.cosmetics.CarryPanic.active(player))clientIsFloating=false;
     }
 }

mods/sanctuary/src/main/java/fr/koka/sanctuary/mixin/CarryGlideMixin.java

@@ -8,6 +8,8 @@ import org.spongepowered.asm.mixin.injection.*;
 import org.spongepowered.asm.mixin.injection.callback.*;
 @Mixin(LivingEntity.class)
 public abstract class CarryGlideMixin {
+    @ModifyVariable(method="travelInAir",at=@At("HEAD"),argsOnly=true)
+    private Vec3 sanctuary$panicSteering(Vec3 input){return (Object)this instanceof Player p&&fr.koka.sanctuary.cosmetics.CarryPanic.active(p)?Vec3.ZERO:input;}
     @Inject(method="travelInAir",at={@At("HEAD"),@At("TAIL")})
     private void sanctuary$glide(Vec3 input,CallbackInfo ci){if((Object)this instanceof Player p)CarryGlide.tick(p);}
     @Inject(method="getEffectiveGravity",at=@At("RETURN"),cancellable=true)

mods/sanctuary/src/main/java/fr/koka/sanctuary/mixin/CarryLivingMixin.java

@@ -16,6 +16,6 @@ public abstract class CarryLivingMixin {
     }
     @Inject(method="hurtServer",at=@At("HEAD"),cancellable=true)
     private void sanctuary$protectPair(ServerLevel level,DamageSource source,float damage,CallbackInfoReturnable<Boolean> ci){
-        if(CarryService.pair((Entity)(Object)this,source.getEntity()))ci.setReturnValue(false);
+        if(CarryService.blocksAttack(source.getEntity(),(Entity)(Object)this))ci.setReturnValue(false);
     }
 }

mods/sanctuary/src/main/java/fr/koka/sanctuary/mixin/CarryPlayerMixin.java

@@ -16,5 +16,5 @@ public abstract class CarryPlayerMixin {
         if(p.getVehicle() instanceof fr.koka.sanctuary.cosmetics.FamiliarEntity pet&&!pet.mayDismount())ci.setReturnValue(false);
     }
     @Inject(method="attack",at=@At("HEAD"),cancellable=true)
-    private void sanctuary$noPassengerAttack(Entity target,CallbackInfo ci){if(CarryService.pair((Entity)(Object)this,target))ci.cancel();}
+    private void sanctuary$noPassengerAttack(Entity target,CallbackInfo ci){if(CarryService.blocksAttack((Entity)(Object)this,target))ci.cancel();}
 }

mods/sanctuary/src/main/java/fr/koka/sanctuary/mixin/WrenchTextureEditMixin.java

@@ -0,0 +1,20 @@
+package fr.koka.sanctuary.mixin;
+
+import fr.koka.sanctuary.multiblock.WrenchTextures;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.LevelChunk;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.*;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(LevelChunk.class)
+public abstract class WrenchTextureEditMixin {
+    @Inject(method="setBlockState(Lnet/minecraft/core/BlockPos;Lnet/minecraft/world/level/block/state/BlockState;I)Lnet/minecraft/world/level/block/state/BlockState;",at=@At("RETURN"))
+    private void sanctuary$clearTexture(BlockPos pos,BlockState state,int flags,CallbackInfoReturnable<BlockState> ci){
+        var before=ci.getReturnValue();
+        if(before!=null&&!before.is(state.getBlock())&&((LevelChunk)(Object)this).getLevel() instanceof ServerLevel)
+            WrenchTextures.forget((LevelChunk)(Object)this,pos);
+    }
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/mixin/WrenchTextureSyncMixin.java

@@ -0,0 +1,17 @@
+package fr.koka.sanctuary.mixin;
+
+import fr.koka.sanctuary.multiblock.WrenchTextures;
+import net.minecraft.server.network.*;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.chunk.LevelChunk;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.*;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(PlayerChunkSender.class)
+public abstract class WrenchTextureSyncMixin {
+    @Inject(method="sendChunk",at=@At("RETURN"))
+    private static void sanctuary$textures(ServerGamePacketListenerImpl connection,ServerLevel level,LevelChunk chunk,CallbackInfo ci){
+        WrenchTextures.sendChunk(connection.player,chunk);
+    }
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/mixin/client/BoatPassengerPickMixin.java

@@ -15,7 +15,8 @@ public abstract class BoatPassengerPickMixin {
         at=@At(value="INVOKE",target="Lnet/minecraft/world/entity/Entity;getRootVehicle()Lnet/minecraft/world/entity/Entity;"))
     private static Entity sanctuary$pickSeatedMob(Entity candidate, Operation<Entity> original, Entity source) {
         // Only the player's cursor: projectile collisions and native range/occlusion stay unchanged.
-        return source instanceof LocalPlayer && BoatPassengerInteractions.aboardTogether(source,candidate)
+        return source instanceof LocalPlayer && (BoatPassengerInteractions.aboardTogether(source,candidate)
+            ||fr.koka.sanctuary.cosmetics.CarryPanic.canStrike(source,candidate))
             ? candidate : original.call(candidate);
     }
 }

mods/sanctuary/src/main/java/fr/koka/sanctuary/mixin/client/PackSelectionScreenMixin.java

@@ -0,0 +1,38 @@
+package fr.koka.sanctuary.mixin.client;
+
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import fr.koka.sanctuary.client.ResourcePackTemplate;
+import java.nio.file.Path;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.layouts.HeaderAndFooterLayout;
+import net.minecraft.client.gui.layouts.LayoutElement;
+import net.minecraft.client.gui.layouts.LinearLayout;
+import net.minecraft.client.gui.screens.packs.PackSelectionScreen;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+
+/** Extra footer row only in resource packs, never in the world datapack selector. */
+@Mixin(PackSelectionScreen.class)
+public abstract class PackSelectionScreenMixin {
+    @Shadow @Final private Path packDir;
+
+    @WrapOperation(method = "init", at = @At(value = "INVOKE", target =
+            "Lnet/minecraft/client/gui/layouts/HeaderAndFooterLayout;addToFooter(Lnet/minecraft/client/gui/layouts/LayoutElement;)Lnet/minecraft/client/gui/layouts/LayoutElement;"))
+    private LayoutElement sanctuary$personalPack(HeaderAndFooterLayout layout, LayoutElement nativeButtons,
+                                                 Operation<LayoutElement> original) {
+        if (!packDir.toAbsolutePath().normalize().equals(
+                Minecraft.getInstance().getResourcePackDirectory().toAbsolutePath().normalize())) {
+            return original.call(layout, nativeButtons);
+        }
+        layout.setFooterHeight(56);
+        LinearLayout rows = LinearLayout.vertical().spacing(4);
+        rows.addChild(ResourcePackTemplate.button(packDir));
+        rows.addChild(nativeButtons);
+        original.call(layout, rows);
+        // Vanilla still adds its Open folder / Done buttons to the original horizontal row.
+        return nativeButtons;
+    }
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/mixin/client/PixelShadowDirtyMixin.java

@@ -0,0 +1,20 @@
+package fr.koka.sanctuary.mixin.client;
+
+import fr.koka.sanctuary.client.shader.PixelShadows;
+import net.minecraft.client.renderer.extract.LevelExtractor;
+import net.minecraft.core.BlockPos;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+/** Geometry changes only: lighting-only section invalidations do not rebuild shadow casters. */
+@Mixin(LevelExtractor.class)
+abstract class PixelShadowDirtyMixin {
+    @Inject(method="blockChanged", at=@At("HEAD"))
+    private void sanctuary$dirty(BlockPos pos, int flags, CallbackInfo ci) {
+        PixelShadows.dirtyBlock(pos);
+    }
+    @Inject(method="allChanged", at=@At("HEAD"))
+    private void sanctuary$reload(CallbackInfo ci) { PixelShadows.release(); }
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/mixin/client/PixelShadowLevelMixin.java

@@ -0,0 +1,25 @@
+package fr.koka.sanctuary.mixin.client;
+
+import fr.koka.sanctuary.client.shader.PixelShadows;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.chunk.LevelChunk;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(ClientLevel.class)
+abstract class PixelShadowLevelMixin {
+    @Inject(method="setBlocksDirty", at=@At("HEAD"))
+    private void sanctuary$block(BlockPos pos, BlockState before, BlockState after, CallbackInfo ci) {
+        if (before != after) PixelShadows.dirtyBlock(pos);
+    }
+
+    @Inject(method="onChunkLoaded", at=@At("TAIL"))
+    private void sanctuary$loaded(ChunkPos pos, CallbackInfo ci) { PixelShadows.dirtyChunk(pos.x(), pos.z()); }
+    @Inject(method="unload", at=@At("HEAD"))
+    private void sanctuary$unload(LevelChunk chunk, CallbackInfo ci) { PixelShadows.dirtyChunk(chunk.getPos().x(), chunk.getPos().z()); }
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/mixin/client/PixelShadowRendererMixin.java

@@ -0,0 +1,28 @@
+package fr.koka.sanctuary.mixin.client;
+
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import com.mojang.renderpearl.api.buffers.GpuBufferSlice;
+import fr.koka.sanctuary.client.shader.PixelShadows;
+import fr.koka.sanctuary.client.shader.EdgeHighlights;
+import net.minecraft.client.renderer.GameRenderer;
+import net.minecraft.client.renderer.ProjectionMatrixBuffer;
+import org.joml.Matrix4f;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(GameRenderer.class)
+abstract class PixelShadowRendererMixin {
+    @WrapOperation(method="renderLevel", at=@At(value="INVOKE", target="Lnet/minecraft/client/renderer/ProjectionMatrixBuffer;getBuffer(Lorg/joml/Matrix4f;)Lcom/mojang/renderpearl/api/buffers/GpuBufferSlice;"))
+    private GpuBufferSlice sanctuary$projection(ProjectionMatrixBuffer buffer, Matrix4f matrix, Operation<GpuBufferSlice> original) {
+        PixelShadows.captureProjection(matrix);
+        EdgeHighlights.captureProjection(matrix);
+        return original.call(buffer, matrix);
+    }
+    @Inject(method="renderLevel", at=@At(value="INVOKE", target="Lnet/minecraft/client/renderer/GameRenderer;render3dHud(Lnet/minecraft/client/renderer/state/level/CameraRenderState;Lnet/minecraft/client/renderer/state/level/PlayerRenderState;Lnet/minecraft/client/renderer/state/OptionsRenderState;Z)V"))
+    private void sanctuary$shadows(CallbackInfo ci) { PixelShadows.render(); EdgeHighlights.render(); }
+    @Inject(method={"close", "setLevel"}, at=@At("HEAD"))
+    private void sanctuary$close(CallbackInfo ci) { PixelShadows.release(); EdgeHighlights.release(); }
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/mixin/client/SculptureParticlesMixin.java

@@ -0,0 +1,26 @@
+package fr.koka.sanctuary.mixin.client;
+
+import fr.koka.sanctuary.client.SculptureParticles;
+import fr.koka.sanctuary.plans.Statuary;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.core.*;
+import net.minecraft.world.level.block.state.BlockState;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.*;
+import org.spongepowered.asm.mixin.injection.callback.*;
+
+@Mixin(ClientLevel.class)
+public abstract class SculptureParticlesMixin {
+    @Inject(method="setBlock",at=@At("HEAD"))
+    private void sanctuary$remember(BlockPos pos,BlockState state,int flags,int recursion,CallbackInfoReturnable<Boolean> cir){
+        if(!state.is(Statuary.BLOCK))SculptureParticles.remember((ClientLevel)(Object)this,pos);
+    }
+    @Inject(method="addDestroyBlockEffect",at=@At("HEAD"),cancellable=true)
+    private void sanctuary$chips(BlockPos pos,BlockState state,CallbackInfo ci){
+        if(SculptureParticles.destroy((ClientLevel)(Object)this,pos,state))ci.cancel();
+    }
+    @Inject(method="addBreakingParticles",at=@At("HEAD"),cancellable=true)
+    private void sanctuary$chip(BlockPos pos,Direction side,BlockState state,CallbackInfo ci){
+        if(SculptureParticles.hit((ClientLevel)(Object)this,pos,side,state))ci.cancel();
+    }
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/multiblock/GoldenWrench.java

@@ -0,0 +1,100 @@
+package fr.koka.sanctuary.multiblock;
+
+import java.util.*;
+import net.fabricmc.fabric.api.event.player.AttackBlockCallback;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents;
+import net.minecraft.core.*;
+import net.minecraft.network.chat.Component;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.*;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.item.*;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.entity.BaseContainerBlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.Property;
+
+/** Ordinary rotations and Steve debug gestures, both owned by the server. */
+public final class GoldenWrench {
+    public static final String TEXTURE="sanctuary_texture";
+    private static final Map<ServerPlayer,Map<Block,String>> SELECTED=new WeakHashMap<>();
+    private static final Map<ServerPlayer,Integer> LAST_SELECTION=new WeakHashMap<>();
+    public static final class Tool extends Item {
+        public Tool(Properties properties){super(properties);}
+        @Override public boolean canDestroyBlock(ItemStack stack,BlockState state,Level level,BlockPos pos,LivingEntity entity){return false;}
+    }
+    public static void register(){
+        WrenchTextures.register();
+        AttackBlockCallback.EVENT.register((player,level,hand,pos,face)->{
+            if(!isWrench(player.getItemInHand(hand)))return InteractionResult.PASS;
+            if(player.isSpectator())return InteractionResult.FAIL;
+            if(player instanceof ServerPlayer p){if(!allowed(p,pos,hand,face))return InteractionResult.FAIL;
+                if(p.getItemInHand(hand).is(Multiblocks.STEVE_WRENCH))select(p,pos);
+                else p.sendSystemMessage(text("rotate_help"),true);}
+            return InteractionResult.SUCCESS;
+        });
+        ServerPlayConnectionEvents.DISCONNECT.register((handler,server)->{SELECTED.remove(handler.player);LAST_SELECTION.remove(handler.player);});
+    }
+    public static boolean isWrench(ItemStack stack){return stack.is(Multiblocks.WRENCH)||stack.is(Multiblocks.STEVE_WRENCH);}
+    public static boolean allowed(ServerPlayer p,BlockPos pos,InteractionHand hand,Direction face){
+        var tool=p.getItemInHand(hand);
+        if(!isWrench(tool))return false;
+        return p.isAlive()&&!p.isSpectator()&&p.getAbilities().mayBuild&&p.level().hasChunkAt(pos)
+            &&p.isWithinBlockInteractionRange(pos,0)&&p.level().mayInteract(p,pos)
+            &&p.mayUseItemAt(pos,face,p.getItemInHand(hand))
+            &&!p.blockActionRestricted(p.level(),pos,p.gameMode.getGameModeForPlayer())
+            &&(!(p.level().getBlockEntity(pos) instanceof BaseContainerBlockEntity container)||container.canOpen(p));
+    }
+    private static boolean assembled(ServerPlayer p,BlockPos pos,BlockState state){
+        return state.is(Metatable.BLOCK)||state.getBlock() instanceof SuperPistonBlocks.Base
+            ||state.getBlock() instanceof SuperPistonBlocks.Part||MultiblockData.get(p.level()).at(pos)!=null;
+    }
+    public static List<String> properties(BlockState state){
+        var result=new ArrayList<>(state.getProperties().stream().map(Property::getName).sorted(Comparator.comparingInt(GoldenWrench::priority).thenComparing(s->s)).toList());
+        result.add(TEXTURE);return List.copyOf(result);
+    }
+    private static int priority(String name){return switch(name){case "facing","axis","rotation","orientation"->0;case "half","type","shape"->1;default->2;};}
+    public static String selected(ServerPlayer p,BlockState state){
+        var choices=properties(state);var value=SELECTED.getOrDefault(p,Map.of()).get(state.getBlock());
+        return value!=null&&choices.contains(value)?value:choices.getFirst();
+    }
+    private static void select(ServerPlayer p,BlockPos pos){
+        var state=p.level().getBlockState(pos);if(state.isAir())return;
+        if(assembled(p,pos,state)){p.sendSystemMessage(text("assembled"),true);return;}
+        // Creative start/continue callbacks can describe the same click twice. Match its native 5-tick repeat cadence.
+        int tick=p.level().getServer().getTickCount();var last=LAST_SELECTION.get(p);
+        if(last!=null&&tick-last<5)return;LAST_SELECTION.put(p,tick);
+        var choices=properties(state);var selected=SELECTED.computeIfAbsent(p,key->new HashMap<>());
+        var before=selected.get(state.getBlock());int previous=before==null?-1:choices.indexOf(before);
+        int next=previous<0?0:Math.floorMod(previous+(p.isShiftKeyDown()?-1:1),choices.size());
+        var property=choices.get(next);selected.put(state.getBlock(),property);
+        p.sendSystemMessage(text("selected",label(property),value(p,pos,state,property)),true);
+    }
+    public static void change(ServerPlayer p,BlockPos pos,InteractionHand hand,Direction face){
+        if(!allowed(p,pos,hand,face))return;
+        var state=p.level().getBlockState(pos);if(state.isAir()||assembled(p,pos,state))return;
+        if(p.getItemInHand(hand).is(Multiblocks.WRENCH)){
+            p.sendSystemMessage(text(WrenchRotation.turn(p.level(),pos,p.isShiftKeyDown())),true);return;
+        }
+        var name=selected(p,state);SELECTED.computeIfAbsent(p,key->new HashMap<>()).put(state.getBlock(),name);
+        if(name.equals(TEXTURE))WrenchTextures.turn(p.level(),pos,p.isShiftKeyDown()?-1:1);
+        else {
+            var property=state.getBlock().getStateDefinition().getProperty(name);
+            // Same flags as the vanilla debug stick: synchronize, preserve deliberately chosen shapes.
+            p.level().setBlock(pos,cycle(state,property,p.isShiftKeyDown()),Block.UPDATE_CLIENTS|Block.UPDATE_KNOWN_SHAPE);
+        }
+        p.sendSystemMessage(text("changed",label(name),value(p,pos,p.level().getBlockState(pos),name)),true);
+    }
+    public static <T extends Comparable<T>> BlockState cycle(BlockState state,Property<T> property,boolean reverse){
+        var values=new ArrayList<>(property.getPossibleValues());int index=values.indexOf(state.getValue(property));
+        return state.setValue(property,values.get(Math.floorMod(index+(reverse?-1:1),values.size())));
+    }
+    private static Object value(ServerPlayer p,BlockPos pos,BlockState state,String name){
+        return name.equals(TEXTURE)?(WrenchTextures.rotation(p.level().getChunkAt(pos),pos)*90)+"°":propertyValue(state,state.getBlock().getStateDefinition().getProperty(name));
+    }
+    private static <T extends Comparable<T>> String propertyValue(BlockState state,Property<T> property){return property.getName(state.getValue(property));}
+    private static Component label(String name){return name.equals(TEXTURE)?text("texture"):Component.literal(name);}
+    private static Component text(String name,Object...args){return Component.translatable("sanctuary.wrench."+name,args);}
+    private GoldenWrench(){}
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/multiblock/Metatable.java

@@ -80,10 +80,11 @@ public final class Metatable {
             if(p.isShiftKeyDown()){dissolve(level,origin);p.sendSystemMessage(Multiblocks.text("separated"),true);}else open(p,origin);
             return true;
         }
-        if(!s.is(Blocks.CRAFTING_TABLE))return false;
+        if(!s.is(Blocks.CRAFTING_TABLE)||p.isShiftKeyDown())return false;
         var candidates=new ArrayList<BlockPos>();
         for(int z=0;z<3;z++)for(int x=0;x<3;x++){var o=pos.offset(-x,0,-z);if(state(level,o,false)==1)candidates.add(o);}
-        if(candidates.size()!=1){previews.remove(p);p.sendSystemMessage(Multiblocks.text(candidates.isEmpty()?"incomplete":"ambiguous"),true);return true;}
+        if(candidates.isEmpty()){previews.remove(p);return false;}
+        if(candidates.size()!=1){previews.remove(p);p.sendSystemMessage(Multiblocks.text("ambiguous"),true);return true;}
         var origin=candidates.getFirst();var before=previews.remove(p);
         if(before!=null&&before.level==level&&before.origin.equals(origin)&&before.until>=level.getGameTime()){
             p.sendSystemMessage(Multiblocks.text(assemble(p,origin)?"assembled":"unavailable"),true);return true;

mods/sanctuary/src/main/java/fr/koka/sanctuary/multiblock/MultiblockCooking.java

@@ -12,6 +12,9 @@ public final class MultiblockCooking {
     private static final ThreadLocal<Boolean> NATIVE=ThreadLocal.withInitial(()->false);
     public static boolean nativeTick(){return NATIVE.get();}
     private static MultiblockFurnaceAccess access(AbstractFurnaceBlockEntity f){return (MultiblockFurnaceAccess)f;}
+    public static boolean hasRecipe(ServerLevel level,AbstractFurnaceBlockEntity f){
+        return !f.getItem(0).isEmpty()&&access(f).sanctuary$recipes().getRecipeFor(new SingleRecipeInput(f.getItem(0)),level).isPresent();
+    }
     public static boolean canCook(ServerLevel level,AbstractFurnaceBlockEntity f){
         if(f.getItem(0).isEmpty())return false;
         var input=new SingleRecipeInput(f.getItem(0));var recipe=access(f).sanctuary$recipes().getRecipeFor(input,level).orElse(null);
@@ -40,17 +43,27 @@ public final class MultiblockCooking {
                     f.setChanged();donor.setChanged();break;
                 }
             }
+            AbstractFurnaceBlockEntity fuelSource=null;ItemStack borrowed=ItemStack.EMPTY;
             if(a.sanctuary$heat()<=1&&a.sanctuary$fuel(level,f.getItem(1))<=0){
                 for(var donor:furnaces)if(donor!=f&&a.sanctuary$fuel(level,donor.getItem(1))>0){
-                    // Exchange physical fuel slots, retaining buckets and every component exactly once.
+                    // Lend the stack only for this native tick, then return its unburnt contents
+                    // to the chosen slot. Never leave whole piles wandering through the fuel tab.
+                    fuelSource=donor;borrowed=donor.getItem(1).copy();
                     var old=f.getItem(1);f.setItem(1,donor.getItem(1));donor.setItem(1,old);donor.setChanged();f.setChanged();break;
                 }
             }
             // A batch can be refuelled gradually: do not erase partially paid work when heat runs out.
-            if(a.sanctuary$heat()<=1&&a.sanctuary$fuel(level,f.getItem(1))<=0)continue;
+            if(fuelSource==null&&a.sanctuary$heat()<=1&&a.sanctuary$fuel(level,f.getItem(1))<=0)continue;
             NATIVE.set(true);
             try{AbstractFurnaceBlockEntity.serverTick(level,f.getBlockPos(),f.getBlockState(),f);}
-            finally{NATIVE.remove();}
+            finally{
+                NATIVE.remove();
+                if(fuelSource!=null&&(f.getItem(1).isEmpty()||ItemStack.isSameItemSameComponents(f.getItem(1),borrowed))){
+                    var remaining=f.getItem(1);f.setItem(1,fuelSource.getItem(1));fuelSource.setItem(1,remaining);fuelSource.setChanged();
+                }
+                // A native remainder (e.g. a lava bucket) stays with the cooking lane, so
+                // wet sponges still fill that bucket and no item is copied or discarded.
+            }
             f.setChanged();used.add(f);
         }
         // Idle heat still decays. A blocked output never starts a new fuel item.

mods/sanctuary/src/main/java/fr/koka/sanctuary/multiblock/MultiblockMenu.java

@@ -11,6 +11,8 @@ import net.minecraft.world.*;
 import net.minecraft.world.entity.player.*;
 import net.minecraft.world.inventory.*;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.core.component.DataComponents;
 import net.minecraft.world.phys.Vec3;
 import java.util.*;
 
@@ -30,26 +32,35 @@ public final class MultiblockMenu extends ChestMenu {
     public final MultiblockContainer stock;
     public final BlockPos anchor;
     public int displaySlots(){return view.furnace?27:54;}
-    public int heat,progress;
+    public int heat,progress,cooking;
+    public static final int IDLE=0,COOKING=1,NO_FUEL=2,BLOCKED=3,NO_RECIPE=4;
+    private final int[] lanes=new int[27];
+    public int laneState(int lane){return lanes[lane]/101;}
+    public int laneProgress(int lane){return lanes[lane]%101;}
     public MultiblockMenu(int id,Inventory inv,View view){this(id,inv,view,null,BlockPos.ZERO);}
     public MultiblockMenu(int id,Inventory inv,View view,MultiblockContainer stock,BlockPos anchor){
         super(Multiblocks.MENU,id,inv,new SimpleContainer(54),view.furnace?3:6);this.view=view;this.stock=stock;this.anchor=anchor.immutable();
         for(int i=0;i<displaySlots();i++){
-            var old=slots.get(i);boolean enabled=i<view.indices.length;int index=enabled?view.indices[i]:-1;
+            var old=slots.get(i);boolean enabled=i<view.indices.length;int physicalIndex=enabled?view.indices[i]:-1;
             Slot slot;
             if(enabled&&stock!=null){
-                var cell=stock.cell(index);
-                slot=view.furnace&&view.section==2?new FurnaceResultSlot(inv.player,cell,stock.local(index),old.x,old.y):new Slot(stock,index,old.x,old.y){
-                    @Override public boolean mayPlace(ItemStack s){return stock.canPlaceItem(index,s);}
+                var cell=stock.cell(physicalIndex);
+                slot=view.furnace&&view.section==2?new FurnaceResultSlot(inv.player,cell,stock.local(physicalIndex),old.x,old.y):new Slot(stock,physicalIndex,old.x,old.y){
+                    // Slot.index is the displayed menu ID, not the physical furnace slot.
+                    @Override public boolean mayPlace(ItemStack s){return stock.canPlaceItem(physicalIndex,s);}
                 };
             }else slot=new Slot(getContainer(),i,old.x,old.y){
-                @Override public boolean mayPlace(ItemStack s){return enabled&&(!view.furnace||view.section!=2)&&super.mayPlace(s);}
+                @Override public boolean mayPlace(ItemStack s){return enabled&&(!view.furnace||view.section==0||view.section==1&&(s.has(DataComponents.COOKING_FUEL)||s.is(Items.BUCKET)&&!getItem().is(Items.BUCKET)))&&super.mayPlace(s);}
                 @Override public boolean mayPickup(Player p){return enabled;}
             };
             slot.index=i;slots.set(i,slot);
         }
         addDataSlot(new DataSlot(){public int get(){return heat;}public void set(int n){heat=n;}});
         addDataSlot(new DataSlot(){public int get(){return progress;}public void set(int n){progress=n;}});
+        if(view.furnace){
+            addDataSlot(new DataSlot(){public int get(){return cooking;}public void set(int n){cooking=n;}});
+            for(int i=0;i<27;i++){int lane=i;addDataSlot(new DataSlot(){public int get(){return lanes[lane];}public void set(int n){lanes[lane]=n;}});}
+        }
     }
     public static View view(MultiblockContainer stock,int wanted,String query,int section){
         return view(stock,wanted,query,section,new int[0]);
@@ -78,20 +89,32 @@ public final class MultiblockMenu extends ChestMenu {
     }
     @Override public void broadcastChanges(){
         if(stock!=null&&stock.machine.furnace()&&Multiblocks.ready(stock.level,stock.machine)){
-            int total=0,max=0;
-            for(int i=0;i<81;i+=3){var a=(fr.koka.sanctuary.mixin.MultiblockFurnaceAccess)stock.cell(i);total+=a.sanctuary$heat();max=Math.max(max,a.sanctuary$progress()*100/Math.max(1,a.sanctuary$total()));}
-            heat=Math.min(32767,total);progress=max;
+            long total=0;boolean fuel=false;cooking=0;progress=0;
+            for(int i=0;i<81;i+=3){var a=(fr.koka.sanctuary.mixin.MultiblockFurnaceAccess)stock.cell(i);total+=a.sanctuary$heat();fuel|=a.sanctuary$fuel(stock.level,stock.getItem(i+1))>0;}
+            heat=(int)Math.min(32767,(total+19)/20); // Seconds of combined burning fuel, not wall-clock time.
+            for(int i=0;i<27;i++){
+                var f=(net.minecraft.world.level.block.entity.AbstractFurnaceBlockEntity)stock.cell(i*3);var a=(fr.koka.sanctuary.mixin.MultiblockFurnaceAccess)f;
+                int percent=Math.clamp(a.sanctuary$progress()*100/Math.max(1,a.sanctuary$total()),0,100);
+                int state=f.getItem(0).isEmpty()?IDLE:!MultiblockCooking.hasRecipe(stock.level,f)?NO_RECIPE:!MultiblockCooking.canCook(stock.level,f)?BLOCKED:total>1||fuel?COOKING:NO_FUEL;
+                lanes[i]=state*101+percent;if(state==COOKING)cooking++;progress=Math.max(progress,percent);
+            }
         }
         super.broadcastChanges();
     }
     @Override public boolean stillValid(Player p){return p.isAlive()&&(stock==null||p.level()==stock.level&&p.distanceToSqr(Vec3.atCenterOf(anchor))<=64&&stock.stillValid(p)&&p instanceof ServerPlayer server&&Multiblocks.accessible(server,stock.machine));}
     @Override public void clicked(int slot,int button,ContainerInput input,Player p){if(stillValid(p))super.clicked(slot,button,input,p);}
     @Override public ItemStack quickMoveStack(Player p,int index){
-        if(index<0||index>=slots.size()||!stillValid(p)||stock==null)return ItemStack.EMPTY;
+        if(index<0||index>=slots.size()||!stillValid(p))return ItemStack.EMPTY;
         var slot=slots.get(index);if(!slot.mayPickup(p))return ItemStack.EMPTY;
         var source=slot.getItem();if(source.isEmpty())return ItemStack.EMPTY;var original=source.copy();boolean moved;
         if(index<displaySlots())moved=SanctuaryInventoryTransfer.move(source,slots.subList(displaySlots(),slots.size()));
-        else{
+        else if(stock==null){
+            // The complete furnace tab has the same destinations on both sides. Predict the
+            // native transfer immediately, so rapid gestures do not keep selecting stale stacks.
+            // Filtered views and barrel pages omit destinations: wait for the authoritative reply.
+            if(!view.furnace||!view.query.isEmpty())return ItemStack.EMPTY;
+            moved=SanctuaryInventoryTransfer.move(source,slots.subList(0,displaySlots()));
+        }else{
             var targets=new ArrayList<Slot>();
             for(int i=0;i<stock.getContainerSize();i++){
                 if(stock.machine.furnace()&&i%3!=view.section)continue;

mods/sanctuary/src/main/java/fr/koka/sanctuary/multiblock/Multiblocks.java

@@ -17,14 +17,21 @@ import net.minecraft.world.inventory.*;
 import net.minecraft.world.item.*;
 import net.minecraft.world.level.block.*;
 import net.minecraft.world.level.block.entity.*;
-import net.minecraft.world.level.block.state.properties.BlockStateProperties;
 import net.minecraft.world.phys.Vec3;
 import java.util.*;
 import static fr.koka.sanctuary.multiblock.MultiblockData.Machine;
 
 public final class Multiblocks {
     public static final Item WRENCH=Registry.register(BuiltInRegistries.ITEM,SanctuaryMod.id("golden_wrench"),
-        new Item(new Item.Properties().stacksTo(1).setId(ResourceKey.create(Registries.ITEM,SanctuaryMod.id("golden_wrench")))));
+        new GoldenWrench.Tool(new Item.Properties().stacksTo(1)
+            .component(net.minecraft.core.component.DataComponents.LORE,new net.minecraft.world.item.component.ItemLore(List.of(Component.translatable("sanctuary.wrench.rotate_help"))))
+            .setId(ResourceKey.create(Registries.ITEM,SanctuaryMod.id("golden_wrench")))));
+    public static final Item STEVE_WRENCH=Registry.register(BuiltInRegistries.ITEM,SanctuaryMod.id("steve_wrench"),
+        new GoldenWrench.Tool(new Item.Properties().stacksTo(1).rarity(Rarity.EPIC)
+            .component(net.minecraft.core.component.DataComponents.ENCHANTMENT_GLINT_OVERRIDE,true)
+            .component(net.minecraft.core.component.DataComponents.LORE,new net.minecraft.world.item.component.ItemLore(List.of(
+                Component.translatable("sanctuary.wrench.steve_power"),Component.translatable("sanctuary.wrench.steve_help"))))
+            .setId(ResourceKey.create(Registries.ITEM,SanctuaryMod.id("steve_wrench")))));
     public static final MenuType<MultiblockMenu> MENU=Registry.register(BuiltInRegistries.MENU,SanctuaryMod.id("multiblock"),
         new ExtendedMenuType<>(MultiblockMenu::new,MultiblockMenu.View.CODEC));
     private record Preview(ServerLevel level,BlockPos origin,boolean furnace,long until){}
@@ -32,11 +39,12 @@ public final class Multiblocks {
     public static Component text(String key,Object...args){return Component.translatable("sanctuary.multiblock."+key,args);}
     public static void register(){
         FourneauAppearance.register();
+        GoldenWrench.register();
         SuperPistons.register();
         Metatable.register();
-        net.fabricmc.fabric.api.creativetab.v1.CreativeModeTabEvents.modifyOutputEvent(CreativeModeTabs.TOOLS_AND_UTILITIES).register(out->out.accept(WRENCH));
+        net.fabricmc.fabric.api.creativetab.v1.CreativeModeTabEvents.modifyOutputEvent(CreativeModeTabs.TOOLS_AND_UTILITIES).register(out->{out.accept(WRENCH);out.accept(STEVE_WRENCH);});
         UseBlockCallback.EVENT.register((player,world,hand,hit)->{
-            boolean wrench=player.getItemInHand(hand).is(WRENCH);
+            boolean wrench=GoldenWrench.isWrench(player.getItemInHand(hand));
             if(world.isClientSide())return wrench?InteractionResult.SUCCESS:InteractionResult.PASS;
             if(!(player instanceof ServerPlayer p)||p.isSpectator())return InteractionResult.PASS;
             var level=p.level();var pos=hit.getBlockPos();var machine=MultiblockData.get(level).at(pos);
@@ -44,7 +52,9 @@ public final class Multiblocks {
             // Preserve vanilla sneak-placement (for example, attaching a hopper to the facade).
             if(!wrench&&p.isShiftKeyDown()&&(!p.getMainHandItem().isEmpty()||!p.getOffhandItem().isEmpty()))return InteractionResult.PASS;
             if(!level.mayInteract(p,pos)||!p.mayUseItemAt(pos,hit.getDirection(),p.getItemInHand(hand)))return InteractionResult.FAIL;
-            if(wrench){if(!Metatable.wrench(p,pos)&&!SuperPistons.wrench(p,pos,hit.getDirection()))useWrench(p,pos,hit.getDirection());return InteractionResult.SUCCESS;}
+            if(wrench){if(!GoldenWrench.allowed(p,pos,hand,hit.getDirection()))return InteractionResult.FAIL;
+                if(!Metatable.wrench(p,pos)&&!SuperPistons.wrench(p,pos,hit.getDirection())&&!useWrench(p,pos,hit.getDirection()))GoldenWrench.change(p,pos,hand,hit.getDirection());
+                return InteractionResult.SUCCESS;}
             if(ready(level,machine)&&accessible(p,machine))open(p,machine,pos,0,"",0);
             else p.sendSystemMessage(text("unavailable"),true);
             return InteractionResult.SUCCESS;
@@ -102,31 +112,28 @@ public final class Multiblocks {
         if(!MultiblockData.get(p.level()).add(m))return false;
         closeViewers(p.level(),m);FourneauAppearance.changed(p.level(),m,true);return true;
     }
-    private static void useWrench(ServerPlayer p,BlockPos pos,Direction face){
+    private static boolean useWrench(ServerPlayer p,BlockPos pos,Direction face){
         var level=p.level();var data=MultiblockData.get(level);var m=data.at(pos);
         if(m!=null){
-            if(!ready(level,m)||!accessible(p,m)){p.sendSystemMessage(text("unavailable"),true);return;}
+            if(!ready(level,m)||!accessible(p,m)){p.sendSystemMessage(text("unavailable"),true);return true;}
             if(p.isShiftKeyDown()){dissolve(level,m);p.sendSystemMessage(text("separated"),true);}
             else open(p,m,pos,0,"",0);
-            return;
+            return true;
         }
         var state=level.getBlockState(pos);
-        if(!state.is(Blocks.BARREL)&&!state.is(Blocks.FURNACE)){p.sendSystemMessage(text("hint"),true);return;}
-        if(!(level.getBlockEntity(pos) instanceof BaseContainerBlockEntity be)||!be.canOpen(p))return;
-        if(p.isShiftKeyDown()){
-            var property=state.hasProperty(BlockStateProperties.HORIZONTAL_FACING)?BlockStateProperties.HORIZONTAL_FACING:BlockStateProperties.FACING;
-            var current=state.getValue(property);var next=current.getAxis().isVertical()?p.getDirection():current.getClockWise();
-            level.setBlockAndUpdate(pos,state.setValue(property,next));p.sendSystemMessage(text("rotated"),true);return;
-        }
+        if(!state.is(Blocks.BARREL)&&!state.is(Blocks.FURNACE))return false;
+        if(!(level.getBlockEntity(pos) instanceof BaseContainerBlockEntity be)||!be.canOpen(p))return true;
+        if(p.isShiftKeyDown())return false;
         boolean furnace=state.is(Blocks.FURNACE);var candidates=new ArrayList<Machine>();
         for(int y=0;y<3;y++)for(int z=0;z<3;z++)for(int x=0;x<3;x++){
             var candidate=new Machine(UUID.randomUUID(),pos.offset(-x,-y,-z),furnace,p.getDirection().getOpposite());
             if(state(level,candidate)==1&&candidate.members().stream().noneMatch(q->data.at(q)!=null))candidates.add(candidate);
         }
-        if(candidates.size()!=1){PREVIEWS.remove(p);p.sendSystemMessage(text(candidates.isEmpty()?"incomplete":"ambiguous"),true);return;}
+        if(candidates.isEmpty()){PREVIEWS.remove(p);return false;}
+        if(candidates.size()!=1){PREVIEWS.remove(p);p.sendSystemMessage(text("ambiguous"),true);return true;}
         var candidate=candidates.getFirst();var previous=PREVIEWS.remove(p);
         if(previous!=null&&previous.level()==level&&previous.origin().equals(candidate.origin())&&previous.furnace()==furnace&&previous.until()>=level.getGameTime()){
-            p.sendSystemMessage(text(assemble(p,candidate)?"assembled":"unavailable"),true);return;
+            p.sendSystemMessage(text(assemble(p,candidate)?"assembled":"unavailable"),true);return true;
         }
         PREVIEWS.put(p,new Preview(level,candidate.origin(),furnace,level.getGameTime()+200));
         for(int axis=0;axis<3;axis++)for(int a=0;a<=3;a+=3)for(int b=0;b<=3;b+=3)for(int t=0;t<=6;t++){
@@ -134,6 +141,7 @@ public final class Multiblocks {
             level.sendParticles(p,ParticleTypes.END_ROD,false,false,candidate.origin().getX()+px,candidate.origin().getY()+py,candidate.origin().getZ()+pz,1,0,0,0,0);
         }
         p.sendSystemMessage(text("confirm",text(furnace?"furnace":"barrel")),false);
+        return true;
     }
     public static void open(ServerPlayer p,Machine m,BlockPos anchor,int page,String query,int section){
         open(p,m,anchor,page,query,section,new int[0]);

mods/sanctuary/src/main/java/fr/koka/sanctuary/multiblock/SuperPistons.java

@@ -79,11 +79,10 @@ public final class SuperPistons {
         }
         if(!s.is(Blocks.PISTON)&&!s.is(Blocks.STICKY_PISTON))return false;
         var f=s.getValue(FACING);boolean sticky=s.is(Blocks.STICKY_PISTON);
-        if(p.isShiftKeyDown()){
-            if(!s.getValue(EXTENDED)&&!l.hasNeighborSignal(clicked))l.setBlockAndUpdate(clicked,s.setValue(FACING,face));return true;
-        }
+        if(p.isShiftKeyDown())return false;
         var found=new ArrayList<BlockPos>();for(int a=-1;a<=1;a++)for(int b=-1;b<=1;b++){var c=clicked.relative(u(f),a).relative(v(f),b);if(candidates(l,c,f,sticky))found.add(c);}
-        if(found.size()!=1){previews.remove(p);message(p,found.isEmpty()?"incomplete":"ambiguous");return true;}
+        if(found.isEmpty()){previews.remove(p);return false;}
+        if(found.size()!=1){previews.remove(p);message(p,"ambiguous");return true;}
         var c=found.getFirst();for(var pos:tiles(c,f,0))if(!l.mayInteract(p,pos)||!p.mayUseItemAt(pos,face,p.getMainHandItem())){previews.remove(p);return true;}
         var old=previews.remove(p);
         if(old!=null&&old.level()==l&&old.center().equals(c)&&old.facing()==f&&old.sticky()==sticky&&old.until()>=l.getGameTime()){

mods/sanctuary/src/main/java/fr/koka/sanctuary/multiblock/WrenchRotation.java

@@ -0,0 +1,36 @@
+package fr.koka.sanctuary.multiblock;
+
+import java.util.List;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.*;
+import static net.minecraft.world.level.block.state.properties.BlockStateProperties.*;
+
+/** Only native orientation properties; fluid, contents and gameplay state are never selectable. */
+public final class WrenchRotation {
+    private static final List<Property<?>> ORIENTATIONS=List.of(HORIZONTAL_FACING,FACING,FACING_HOPPER,AXIS,HORIZONTAL_AXIS,ROTATION_16,ORIENTATION);
+
+    public static String turn(ServerLevel level,BlockPos pos,boolean reverse){
+        var before=level.getBlockState(pos);
+        if(linked(before))return "linked";
+        var property=ORIENTATIONS.stream().filter(before::hasProperty).findFirst().orElse(null);
+        if(property==null)return "no_rotation";
+        var oriented=GoldenWrench.cycle(before,property,reverse);
+        if(!oriented.canSurvive(level,pos))return "unsupported";
+        // Stairs and connections must reflect their real neighbours, not a debug-stick shape.
+        var after=Block.updateFromNeighbourShapes(oriented,level,pos);
+        if(!after.is(before.getBlock())||linked(after)||after.getFluidState()!=before.getFluidState()
+            ||!after.canSurvive(level,pos))return "unsupported";
+        level.setBlock(pos,after,Block.UPDATE_ALL);
+        return "rotated";
+    }
+    private static boolean linked(BlockState state){
+        // A single-block operation cannot rotate another half, an attached head or a joined inventory.
+        return state.hasProperty(DOUBLE_BLOCK_HALF)||state.hasProperty(BED_PART)||state.hasProperty(SIDE_CHAIN_PART)&&state.getValue(SIDE_CHAIN_PART).isConnected()
+            ||state.hasProperty(PISTON_TYPE)||state.hasProperty(EXTENDED)&&state.getValue(EXTENDED)
+            ||state.hasProperty(CHEST_TYPE)&&state.getValue(CHEST_TYPE)!=ChestType.SINGLE;
+    }
+    private WrenchRotation(){}
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/multiblock/WrenchTextures.java

@@ -0,0 +1,63 @@
+package fr.koka.sanctuary.multiblock;
+
+import com.mojang.serialization.Codec;
+import fr.koka.sanctuary.SanctuaryMod;
+import java.util.*;
+import net.fabricmc.fabric.api.attachment.v1.*;
+import net.fabricmc.fabric.api.networking.v1.*;
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.Identifier;
+import net.minecraft.server.level.*;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.chunk.LevelChunk;
+
+/** Optional per-chunk presentation data. Absent means original vanilla textures. */
+public final class WrenchTextures {
+    public static final AttachmentType<Map<String,Integer>> ROTATIONS=AttachmentRegistry.createPersistent(
+        SanctuaryMod.id("wrench_textures_v1"),Codec.unboundedMap(Codec.STRING,Codec.intRange(1,3)).xmap(Map::copyOf,map->map));
+    public record Entry(BlockPos pos,int rotation){}
+    public record Update(Identifier dimension,ChunkPos chunk,boolean clear,List<Entry> entries) implements CustomPacketPayload {
+        public Update{entries=List.copyOf(entries);if(entries.size()>1024)throw new IllegalArgumentException("Texture batch too large");}
+        public static final Type<Update> TYPE=new Type<>(SanctuaryMod.id("wrench_textures_v1"));
+        public static final StreamCodec<RegistryFriendlyByteBuf,Update> CODEC=StreamCodec.of((b,p)->{
+            b.writeIdentifier(p.dimension);b.writeChunkPos(p.chunk);b.writeBoolean(p.clear);b.writeVarInt(p.entries.size());
+            for(var entry:p.entries){b.writeBlockPos(entry.pos);b.writeByte(entry.rotation);}
+        },b->{
+            var dimension=b.readIdentifier();var chunk=b.readChunkPos();boolean clear=b.readBoolean();int n=b.readVarInt();
+            if(n<0||n>1024)throw new IllegalArgumentException("Texture batch size");var entries=new ArrayList<Entry>(n);
+            for(int i=0;i<n;i++){var pos=b.readBlockPos();int rotation=b.readUnsignedByte();
+                if(rotation>3||ChunkPos.pack(pos)!=chunk.pack())throw new IllegalArgumentException("Invalid texture entry");entries.add(new Entry(pos,rotation));}
+            return new Update(dimension,chunk,clear,entries);
+        });
+        @Override public Type<? extends CustomPacketPayload> type(){return TYPE;}
+    }
+    public static void register(){PayloadTypeRegistry.clientboundPlay().register(Update.TYPE,Update.CODEC);}
+    public static int rotation(LevelChunk chunk,BlockPos pos){var map=chunk.getAttached(ROTATIONS);return map==null?0:map.getOrDefault(Long.toString(pos.asLong()),0);}
+    public static void turn(ServerLevel level,BlockPos pos,int delta){
+        var chunk=level.getChunkAt(pos);set(chunk,pos,Math.floorMod(rotation(chunk,pos)+delta,4));
+    }
+    public static void forget(LevelChunk chunk,BlockPos pos){if(rotation(chunk,pos)!=0)set(chunk,pos,0);}
+    private static void set(LevelChunk chunk,BlockPos pos,int value){
+        if(!(chunk.getLevel() instanceof ServerLevel level))return;
+        var old=chunk.getAttached(ROTATIONS);var next=old==null?new HashMap<String,Integer>():new HashMap<>(old);
+        if(value==0)next.remove(Long.toString(pos.asLong()));else next.put(Long.toString(pos.asLong()),value);
+        if(next.isEmpty())chunk.removeAttached(ROTATIONS);else chunk.setAttached(ROTATIONS,Map.copyOf(next));chunk.markUnsaved();
+        var packet=new Update(level.dimension().identifier(),chunk.getPos(),false,List.of(new Entry(pos.immutable(),value)));
+        for(var player:PlayerLookup.tracking(level,chunk.getPos()))send(player,packet);
+    }
+    public static void sendChunk(ServerPlayer player,LevelChunk chunk){
+        var entries=chunk.getAttached(ROTATIONS);var batch=new ArrayList<Entry>(1024);boolean clear=true;
+        if(entries!=null)for(var entry:entries.entrySet()){
+            BlockPos pos;try{pos=BlockPos.of(Long.parseLong(entry.getKey()));}catch(NumberFormatException ignored){continue;}
+            if(ChunkPos.pack(pos)!=chunk.getPos().pack()||chunk.getBlockState(pos).isAir())continue;
+            batch.add(new Entry(pos,entry.getValue()));
+            if(batch.size()==1024){send(player,new Update(player.level().dimension().identifier(),chunk.getPos(),clear,batch));clear=false;batch.clear();}
+        }
+        if(clear||!batch.isEmpty())send(player,new Update(player.level().dimension().identifier(),chunk.getPos(),clear,batch));
+    }
+    private static void send(ServerPlayer p,Update packet){if(ServerPlayNetworking.canSend(p,Update.TYPE))ServerPlayNetworking.send(p,packet);}
+    private WrenchTextures(){}
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/plans/ClayWorkshopMenu.java

@@ -1,7 +1,8 @@
 package fr.koka.sanctuary.plans;
 
 import fr.koka.sanctuary.SanctuaryMod;
-import fr.koka.sanctuary.building.ColoredBricks;
+import net.minecraft.core.component.DataComponents;
+import net.minecraft.core.registries.BuiltInRegistries;
 import java.util.*;
 import net.fabricmc.fabric.api.event.player.UseBlockCallback;
 import net.minecraft.core.*;
@@ -16,23 +17,30 @@ import net.minecraft.world.item.*;
 import net.minecraft.world.level.Level;
 import net.minecraft.world.phys.*;
 
-/** Native input/result slots. Server recomputes the color from the actual clay and charges each take. */
+/** Native input/result slots. Server validates the material, applies the bounded palette and charges each take. */
 public final class ClayWorkshopMenu extends AbstractContainerMenu {
     public static final int HOTBAR_START=2,HOTBAR_END=HOTBAR_START+Inventory.SELECTION_SIZE,HOTBAR_X=75,HOTBAR_Y=176;
-    public record View(BlockPos pos,UUID token){
-        public static final StreamCodec<RegistryFriendlyByteBuf,View> CODEC=StreamCodec.of((b,p)->{b.writeBlockPos(p.pos);b.writeUUID(p.token);},b->new View(b.readBlockPos(),b.readUUID()));
+    public record View(BlockPos pos,UUID token,List<String> statues){
+        public View { statues=List.copyOf(statues); }
+        public static final StreamCodec<RegistryFriendlyByteBuf,View> CODEC=StreamCodec.of((b,p)->{
+            b.writeBlockPos(p.pos);b.writeUUID(p.token);b.writeVarInt(p.statues.size());for(var id:p.statues)b.writeUtf(id,128);
+        },b->{var pos=b.readBlockPos();var token=b.readUUID();int n=b.readVarInt();if(n<0||n>1024)throw new IllegalArgumentException("statue_discoveries");var ids=new ArrayList<String>(n);for(int i=0;i<n;i++)ids.add(b.readUtf(128));return new View(pos,token,ids);});
     }
-    /** At most 24 KiB of cells in one atomic, bounded selection, scoped to one open menu. */
-    public record Select(int menu,UUID token,VoxelSculpture sculpture) implements CustomPacketPayload {
+    /** At most 24 KiB of cells plus 256 palette colors in one atomic, bounded selection, scoped to one open menu. */
+    public record Select(int menu,UUID token,VoxelSculpture sculpture,Item material,SculpturePalette palette) implements CustomPacketPayload {
         public static final Type<Select> TYPE=new Type<>(SanctuaryMod.id("clay_model"));
         public static final StreamCodec<RegistryFriendlyByteBuf,Select> CODEC=StreamCodec.of((b,p)->{
-            b.writeVarInt(p.menu);b.writeUUID(p.token);b.writeBoolean(p.sculpture!=null);
+            b.writeVarInt(p.menu);b.writeUUID(p.token);b.writeVarInt(BuiltInRegistries.ITEM.getId(p.material));b.writeVarIntArray(p.palette==null?new int[0]:p.palette.colors().stream().mapToInt(Integer::intValue).toArray());b.writeBoolean(p.sculpture!=null);
             if(p.sculpture!=null){var s=p.sculpture;b.writeUtf(s.modelId(),128);b.writeUtf(s.name(),128);b.writeByte(s.width());b.writeByte(s.height());b.writeByte(s.depth());b.writeVarInt(s.cells().size());for(var c:s.cells()){b.writeShort(c.key());b.writeInt(c.color());}}
         },b->{
-            int menu=b.readVarInt();var token=b.readUUID();if(!b.readBoolean())return new Select(menu,token,null);
+            int menu=b.readVarInt();var token=b.readUUID();int itemId=b.readVarInt();
+            if(itemId<0||itemId>=BuiltInRegistries.ITEM.size())throw new IllegalArgumentException("sculpture_material");
+            var material=BuiltInRegistries.ITEM.byId(itemId);var colors=b.readVarIntArray(SculpturePalette.MAX_COLORS);
+            var palette=colors.length==0?null:new SculpturePalette(Arrays.stream(colors).boxed().toList());
+            if(!b.readBoolean())return new Select(menu,token,null,material,palette);
             String model=b.readUtf(128),name=b.readUtf(128);int w=b.readUnsignedByte(),h=b.readUnsignedByte(),d=b.readUnsignedByte(),n=b.readVarInt();
             if(n<1||n>VoxelSculpture.MAX_CELLS)throw new IllegalArgumentException("sculpture_limit");int[] packed=new int[n*2];for(int i=0;i<n;i++){packed[i*2]=b.readUnsignedShort();packed[i*2+1]=b.readInt();}
-            return new Select(menu,token,VoxelSculpture.unpack(model,name,w,h,d,packed));
+            return new Select(menu,token,VoxelSculpture.unpack(model,name,w,h,d,packed),material,palette);
         });
         public Type<? extends CustomPacketPayload> type(){return TYPE;}
     }
@@ -41,41 +49,49 @@ public final class ClayWorkshopMenu extends AbstractContainerMenu {
     private final SimpleContainer input=new SimpleContainer(1){@Override public void setChanged(){super.setChanged();ClayWorkshopMenu.this.slotsChanged(this);}};
     private final SimpleContainer result=new SimpleContainer(1);
     private VoxelSculpture selected;
-    private ItemStack lastClay=ItemStack.EMPTY;
+    private VoxelSculpture selectedResult;
+    private ItemStack lastMaterial=ItemStack.EMPTY;
+    private Item selectedMaterial=Items.AIR;
+    private SculpturePalette selectedPalette;
     private long lastSelection=-100;
     public ClayWorkshopMenu(int id,Inventory inv,View view){this(id,inv,view,null);}
     public ClayWorkshopMenu(int id,Inventory inv,View view,Level level){
         super(Statuary.MENU,id);this.view=view;this.level=level;
-        addSlot(new Slot(input,0,222,106){@Override public boolean mayPlace(ItemStack stack){return clay(stack);}});
+        addSlot(new Slot(input,0,222,106){@Override public boolean mayPlace(ItemStack stack){return material(stack);}});
         addSlot(new Slot(result,0,282,106){
             @Override public boolean mayPlace(ItemStack stack){return false;}
-            @Override public boolean mayPickup(Player p){return mayCraft(p)&&clay(input.getItem(0))&&!getItem().isEmpty();}
+            @Override public boolean mayPickup(Player p){return mayCraft(p)&&material(input.getItem(0))&&(level==null||input.getItem(0).is(selectedMaterial))&&!getItem().isEmpty();}
             @Override public void onTake(Player p,ItemStack stack){input.removeItem(0,1);input.setChanged();super.onTake(p,stack);}
         });
         // Use the nine carried slots without registering a full inventory/overflow range.
         addInventoryHotbarSlots(inv,HOTBAR_X,HOTBAR_Y);
     }
-    // Colors match the published clay palette (tools/colored-bricks-palette.json), in native dye order.
-    private static final int[] CLAY_COLORS={0xC6C4C8,0xD3AA8D,0xD39FD0,0x91B0CA,0xC8BF98,0xA2C69A,0xDAC4DD,0x74767D,0xA9A8AC,0xA8C5C1,0xBE91E3,0xA0A7BC,0xA49A91,0xA0B499,0xB49A99,0x444541};
-    public static boolean clay(ItemStack item){return item.is(Items.CLAY)||ColoredBricks.families().stream().anyMatch(f->item.is(f.clay().asItem()));}
-    public static VoxelSculpture material(VoxelSculpture model,ItemStack clay){
-        if(model==null||!clay(clay))return null;
-        if(clay.is(Items.CLAY))return model;
-        for(var family:ColoredBricks.families())if(clay.is(family.clay().asItem()))return model.color(0xFF000000|CLAY_COLORS[family.color().getId()]);
-        return null;
+    public static boolean material(ItemStack item){
+        if(item.isEmpty()||!(item.getItem() instanceof BlockItem))return false;
+        var contents=item.get(DataComponents.CONTAINER);
+        return contents==null||!contents.nonEmptyItems().iterator().hasNext();
     }
-    public void select(ServerPlayer p,VoxelSculpture sculpture){
+    /** Plain clay retains the model's sampled colors; other blocks transfer their texture palette. */
+    public static VoxelSculpture appearance(VoxelSculpture source,Item material,SculpturePalette palette){
+        return material==Items.CLAY?source:palette.apply(source);
+    }
+    public void select(ServerPlayer p,VoxelSculpture sculpture,Item material,SculpturePalette palette){
         if(level==null||!stillValid(p)||level.getGameTime()-lastSelection<4)return;
         var hit=new BlockHitResult(Vec3.atCenterOf(view.pos),Direction.UP,view.pos,false);
         if(UseBlockCallback.EVENT.invoker().interact(p,level,InteractionHand.MAIN_HAND,hit)!=InteractionResult.PASS||!stillValid(p))return;
-        lastSelection=level.getGameTime();selected=sculpture;refresh();broadcastChanges();
+        lastSelection=level.getGameTime();
+        if(sculpture!=null&&(!StatueDiscoveries.allowedModel(sculpture.modelId(),view.statues())||!material(input.getItem(0))||!input.getItem(0).is(material)||palette==null))return;
+        if(!Objects.equals(selected,sculpture)||selectedMaterial!=material||!Objects.equals(selectedPalette,palette))
+            selectedResult=sculpture==null||palette==null?null:appearance(sculpture,material,palette);
+        selected=sculpture;selectedMaterial=material;selectedPalette=palette;refresh();broadcastChanges();
     }
     private void refresh(){
-        if(level==null)return;var sculpture=material(selected,input.getItem(0));lastClay=input.getItem(0).copy();
+        if(level==null)return;var item=input.getItem(0);
+        var sculpture=material(item)&&item.is(selectedMaterial)?selectedResult:null;lastMaterial=item.copy();
         result.setItem(0,sculpture==null?ItemStack.EMPTY:StatuaryEntity.item(sculpture));
     }
     @Override public void slotsChanged(Container container){if(container==input)refresh();super.slotsChanged(container);}
-    @Override public void broadcastChanges(){if(level!=null&&!ItemStack.matches(lastClay,input.getItem(0)))refresh();super.broadcastChanges();}
+    @Override public void broadcastChanges(){if(level!=null&&!ItemStack.matches(lastMaterial,input.getItem(0)))refresh();super.broadcastChanges();}
     @Override public boolean stillValid(Player p){return level==null?p.isAlive():Statuary.allowed(p,level,view.pos);}
     private boolean mayCraft(Player p){
         if(!stillValid(p))return false;
@@ -94,7 +110,7 @@ public final class ClayWorkshopMenu extends AbstractContainerMenu {
         if(index<0||index>=slots.size()||!stillValid(p))return ItemStack.EMPTY;var slot=slots.get(index);if(!slot.mayPickup(p)||!slot.hasItem())return ItemStack.EMPTY;
         var stack=slot.getItem();var copy=stack.copy();
         if(index<HOTBAR_START){if(!moveItemStackTo(stack,HOTBAR_START,HOTBAR_END,true))return ItemStack.EMPTY;}
-        else if(clay(stack)){if(!moveItemStackTo(stack,0,1,false))return ItemStack.EMPTY;}
+        else if(material(stack)){if(!moveItemStackTo(stack,0,1,false))return ItemStack.EMPTY;}
         else return ItemStack.EMPTY;
         if(stack.isEmpty())slot.set(ItemStack.EMPTY);else slot.setChanged();
         if(index==1)slot.onTake(p,copy);return copy;

mods/sanctuary/src/main/java/fr/koka/sanctuary/plans/SculptureAnchor.java

@@ -0,0 +1,35 @@
+package fr.koka.sanctuary.plans;
+
+import java.util.Locale;
+import net.minecraft.core.Direction;
+import net.minecraft.util.StringRepresentable;
+import net.minecraft.world.item.context.BlockPlaceContext;
+import net.minecraft.world.level.block.Mirror;
+import net.minecraft.world.level.block.Rotation;
+
+/** World-space horizontal anchor; old names remain valid in saved blockstates. */
+public enum SculptureAnchor implements StringRepresentable {
+    CENTER(0,0), NORTH(0,-1), SOUTH(0,1), EAST(1,0), WEST(-1,0),
+    NORTH_WEST(-1,-1), NORTH_EAST(1,-1), SOUTH_WEST(-1,1), SOUTH_EAST(1,1);
+
+    private final int x,z;
+    SculptureAnchor(int x,int z){this.x=x;this.z=z;}
+    public String getSerializedName(){return name().toLowerCase(Locale.ROOT);}
+    public SculptureAnchor rotate(Rotation rotation){return switch(rotation){
+        case NONE -> this;case CLOCKWISE_90 -> of(-z,x);case CLOCKWISE_180 -> of(-x,-z);case COUNTERCLOCKWISE_90 -> of(z,-x);
+    };}
+    public SculptureAnchor mirror(Mirror mirror){return switch(mirror){case NONE->this;case LEFT_RIGHT->of(x,-z);case FRONT_BACK->of(-x,z);};}
+    public static SculptureAnchor of(Direction direction){return switch(direction){
+        case NORTH -> NORTH;case SOUTH -> SOUTH;case EAST -> EAST;case WEST -> WEST;
+        default -> throw new IllegalArgumentException("Horizontal anchor required");
+    };}
+    private static SculptureAnchor of(int x,int z){for(var anchor:values())if(anchor.x==x&&anchor.z==z)return anchor;throw new IllegalArgumentException("Anchor outside grid");}
+    public static SculptureAnchor placement(BlockPlaceContext context){
+        var pos=context.getClickedPos();var hit=context.getClickLocation();
+        return of(band(hit.x-pos.getX()),band(hit.z-pos.getZ()));
+    }
+    // The middle eight pixels, including the boundaries, keep the grid-aligned center.
+    static int band(double value){return value<.25?-1:value>.75?1:0;}
+    public int originX(int width){return x<0?0:x>0?VoxelSculpture.EDGE-width:(VoxelSculpture.EDGE-width)/2;}
+    public int originZ(int depth){return z<0?0:z>0?VoxelSculpture.EDGE-depth:(VoxelSculpture.EDGE-depth)/2;}
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/plans/SculptureGeometry.java

@@ -0,0 +1,38 @@
+package fr.koka.sanctuary.plans;
+
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.phys.shapes.VoxelShape;
+
+/** Integer placement shared by rendering and tight, single-box selection/collision bounds. */
+public final class SculptureGeometry {
+    public record Placement(VoxelSculpture sculpture, int offsetX, int offsetY, int offsetZ) {}
+
+    private SculptureGeometry() {}
+
+    public static Placement place(VoxelSculpture sculpture, Direction facing, SculptureAnchor anchor, SculptureHeight height) {
+        int turns = switch (facing) { case WEST -> 1; case NORTH -> 2; case EAST -> 3; default -> 0; };
+        for (int i = 0; i < turns; i++) sculpture = sculpture.rotate();
+        int minX = 16, minY = 16, minZ = 16, maxX = 0, maxY = 0, maxZ = 0;
+        for (var cell : sculpture.cells()) {
+            minX = Math.min(minX, cell.x()); minZ = Math.min(minZ, cell.z()); minY = Math.min(minY, cell.y());
+            maxX = Math.max(maxX, cell.x() + 1); maxZ = Math.max(maxZ, cell.z() + 1); maxY = Math.max(maxY, cell.y() + 1);
+        }
+        return new Placement(sculpture, anchor.originX(maxX - minX) - minX, height.originY(minY,maxY) - minY,
+                anchor.originZ(maxZ - minZ) - minZ);
+    }
+
+    /** Tight integer bounds, without rotating/copying cells or constructing a voxel grid. */
+    public static VoxelShape shape(VoxelSculpture sculpture, Direction facing, SculptureAnchor anchor, SculptureHeight height) {
+        int minX=16,minY=16,minZ=16,maxX=0,maxY=0,maxZ=0;
+        for(var cell:sculpture.cells()) {
+            minX=Math.min(minX,cell.x()); minY=Math.min(minY,cell.y()); minZ=Math.min(minZ,cell.z());
+            maxX=Math.max(maxX,cell.x()+1); maxY=Math.max(maxY,cell.y()+1); maxZ=Math.max(maxZ,cell.z()+1);
+        }
+        int width=maxX-minX,depth=maxZ-minZ;
+        if(facing.getAxis()==Direction.Axis.X){int swap=width;width=depth;depth=swap;}
+        int x=anchor.originX(width),z=anchor.originZ(depth);
+        int y=height.originY(minY,maxY);
+        return Block.box(x,y,z,x+width,y+maxY-minY,z+depth);
+    }
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/plans/SculptureHeight.java

@@ -0,0 +1,19 @@
+package fr.koka.sanctuary.plans;
+
+import java.util.Locale;
+import net.minecraft.util.StringRepresentable;
+import net.minecraft.world.item.context.BlockPlaceContext;
+
+/** ORIGINAL is the missing-property default: pre-beta.125 sculptures retain their exact Y offsets. */
+public enum SculptureHeight implements StringRepresentable {
+    ORIGINAL, BOTTOM, CENTER, TOP;
+    public String getSerializedName(){return name().toLowerCase(Locale.ROOT);}
+    public int originY(int minY,int maxY){return switch(this){
+        case ORIGINAL -> minY;case BOTTOM -> 0;case CENTER -> (VoxelSculpture.EDGE-(maxY-minY))/2;case TOP -> VoxelSculpture.EDGE-(maxY-minY);
+    };}
+    public static SculptureHeight placement(BlockPlaceContext context){
+        return switch(SculptureAnchor.band(context.getClickLocation().y-context.getClickedPos().getY())){
+            case -1 -> BOTTOM;case 1 -> TOP;default -> CENTER;
+        };
+    }
+}

mods/sanctuary/src/main/java/fr/koka/sanctuary/plans/SculpturePalette.java

@@ -0,0 +1,31 @@
+package fr.koka.sanctuary.plans;
+
+import java.util.*;
+
+/** Bounded appearance data, applied identically by preview and authoritative crafting. */
+public record SculpturePalette(List<Integer> colors) {
+    public static final int MAX_COLORS=256;
+    public SculpturePalette {
+        if(colors==null||colors.isEmpty()||colors.size()>MAX_COLORS||colors.stream().anyMatch(c->c==null||(c>>>24)!=255))
+            throw new IllegalArgumentException("sculpture_palette");
+        colors=colors.stream().sorted(Comparator.comparingInt(SculpturePalette::luminance).thenComparingInt(Integer::intValue)).toList();
+    }
+    // Integer Rec.709 weights: no color-space arrays or transcendental math per voxel.
+    private static int luminance(int color){return 54*(color>>16&255)+183*(color>>8&255)+19*(color&255);}
+    public static double lightness(int color){return luminance(color)/65280.;}
+    public VoxelSculpture apply(VoxelSculpture source){
+        if(source==null)return null;
+        int min=65280,max=0;for(var cell:source.cells()){int l=luminance(cell.color());min=Math.min(min,l);max=Math.max(max,l);}
+        // Flat models sample the entire texture distribution. Shaded models use overlapping
+        // half-palette bands: retain large light/dark regions while giving each region grain.
+        int span=max==min?colors.size():(colors.size()+1)/2;
+        var cells=new ArrayList<VoxelSculpture.Cell>(source.cells().size());
+        for(var cell:source.cells()){
+            int start=max==min?0:(luminance(cell.color())-min)*(colors.size()-span)/(max-min);
+            int hash=cell.key()+0x9E3779B9;hash=(hash^(hash>>>16))*0x7FEB352D;hash=(hash^(hash>>>15))*0x846CA68B;hash^=hash>>>16;
+            int offset=(int)((Integer.toUnsignedLong(hash)*span)>>>32);
+            cells.add(new VoxelSculpture.Cell(cell.x(),cell.y(),cell.z(),colors.get(start+offset)));
+        }
+        return new VoxelSculpture(source.modelId(),source.name(),source.width(),source.height(),source.depth(),cells);
+    }
+}