feat(redstoner): add storage terminal

Merge pull request 'Fix white disc audio cadence and release alpha.216' (#89 ) from fix/white-disc-audio-quality into main
Reviewed-on: #89
2026-08-30 03:13:48 +02:00 · 2026-08-29 23:26:10 +00:00 · 2026-08-30 01:19:02 +02:00 · 2026-08-29 22:54:40 +00:00 · 2026-08-30 00:52:59 +02:00 · 2026-08-29 22:46:44 +00:00
161 changed files with 5766 additions and 338 deletions
@@ -32,9 +32,11 @@ Ambiance possède les trois payloads historiques canaplia:hemp_visual_sync, cana

 ## Codex

-Les monstres tués par un joueur peuvent laisser une `canaplia:codex_page` et, très rarement, le `canaplia:codex` complet. Quatre pages récupérées permettent aussi de relier le Codex autour d'un livre. L'objet utilise la texture du livre Minecraft et son écran repose sur les pages vanilla. Il distingue les découvertes personnelles des silhouettes connues par la communauté ; les origines génériques et les conditions détaillées se révèlent progressivement sans envoyer de payload de découverte client-vers-serveur.
+Les monstres tués par un joueur peuvent laisser une `canaplia:codex_page` et, très rarement, le `canaplia:codex` complet. Quatre pages récupérées permettent aussi d'assembler le Livre interdit autour d'un livre vanilla. Un clic droit sur une page découvre au hasard une entrée encore inconnue et ne consomme la page qu'en cas de nouvelle découverte.

-Les données canaplia:codex sont versionnées. Les clés futures syntaxiquement valides restent conservées lors d'un aller-retour afin qu'une migration ne perde pas les découvertes ajoutées par une version ultérieure.
+L'ID historique `canaplia:codex` est conservé, mais l'objet s'affiche désormais comme le « Livre interdit » : il utilise la couleur du livre enchanté, ouvre directement les seize entrées et les présente sur les pages claires du livre vanilla. En main, son contenu est strictement personnel. Posé sur un pupitre, il est temporairement inscrit au nom du joueur qui le pose et partage ses découvertes avec tous les lecteurs ; le récupérer en s'accroupissant ou casser le pupitre efface cette inscription.
+
+Les données `canaplia:codex` restent en version 1. Les clés futures syntaxiquement valides et l'ancien champ partagé restent conservés lors d'un aller-retour afin qu'une migration ne perde aucune découverte, mais les nouvelles découvertes ne sont plus publiées globalement. Aucun payload de découverte n'est accepté du client vers le serveur et le protocole It's Alive reste en version 4.

 ## Tickets livrés

@@ -55,4 +57,4 @@ Les IDs historiques, les clés et le namespace sont inchangés. L'ancien format

 La source historique 2.0.0 demeure **All Rights Reserved**, copyright KOKA99CAB. À la demande explicite du détenteur des droits, ses 224 textures 16×16 ont été restaurées dans l'alpha.209 ; leur provenance est documentée avec les ressources. Aucun fichier Java, modèle, son ou JSON historique n'est copié. Le code d'intégration reste sous GPL-3.0-or-later.

-Les inventaires machine sont dans `pack/migrations/canaplia-foundation-alpha32.json` et `pack/migrations/canaplia-gameplay-alpha33.json`. La release `26.2.0-alpha.209` décrit la correction de gameplay et l'import autorisé dans `pack/migrations/26.2.0-alpha.208-canaplia-fixes-to-alpha.209.json`.
+Les inventaires machine sont dans `pack/migrations/canaplia-foundation-alpha32.json` et `pack/migrations/canaplia-gameplay-alpha33.json`. La release `26.2.0-alpha.209` décrit la correction de gameplay et l'import autorisé dans `pack/migrations/26.2.0-alpha.208-canaplia-fixes-to-alpha.209.json`; l’alpha.210 décrit le Livre interdit et les autres changements distribués dans `pack/migrations/26.2.0-alpha.209-forbidden-book-and-polish-to-alpha.210.json`.
@@ -6,6 +6,105 @@ Ce journal suit les **versions du modpack**. Lorsqu'un seul module change, sa ve
 - Depuis `26.2.0-alpha.6`, le pack et les modules ont des versions indépendantes. I Like To Move It et Only Fun deviennent les cinquième et sixième modules actifs dans l'alpha 46.
 - Les versions ci-dessous ont été reconstituées à partir des JAR archivés, des packs locaux et du code source actuel. Les dates n'étant pas enregistrées de manière fiable, elles ne sont pas inventées.

+## `26.2.0-alpha.217`
+
+Modules modifiés : **Red-Stoner `0.0.0-alpha.11`**, **Only Fun `0.0.0-alpha.25`** et **Sanctuary `0.0.0-alpha.121`**. Les sept autres modules conservent leur version issue de l'alpha.216.
+
+- ajoute `redstoner:storage_terminal`, une demi-dalle verticale de huit pixels qui se pose uniquement sur la face horizontale d’un coffre, coffre piégé ou baril ;
+- découvre sans charger de chunk les conteneurs adjacents par face, verticalement compris, et refuse clairement tout réseau qui dépasse 128 blocs physiques ;
+- agrège uniquement les piles dont l’item et tous les composants sont strictement identiques, puis les affiche sur des pages défilantes de 54 entrées ;
+- valide côté serveur la distance, le terminal, la topologie, la page et l’identité de chaque pile avant un retrait par pile, un retrait unitaire ou un dépôt par shift-clic ;
+- fabrique le terminal avec quatre plaques d’argent, trois verres teintés, un Controller et un lingot de titane, sans entrée Shop, Black Market ni récompense de lootbox ;
+- ajoute les traductions FR/EN/RU, les ressources bloc/item/loot/recette et des tests déterministes de topologie, pagination, agrégation et transferts ;
+- conserve les données Red-Stoner v3, Only Fun v2 et Sanctuary v11 ; seul le protocole réseau Red-Stoner passe de 5 à 6, sans nouveau monde ni réinitialisation des sauvegardes.
+
+## `26.2.0-alpha.216`
+
+Module modifié : **Ambiance `0.0.0-alpha.19`**. Les neuf autres modules conservent leur version issue de l'alpha.215.
+
+- corrige le disque blanc ralenti et dégradé en remplissant continûment les tampons PCM d’une seconde demandés par Minecraft au lieu de les compléter prématurément avec du silence ;
+- conserve une fréquence réelle de 48 kHz, un flux mono 16 bits little-endian et force la vitesse OpenAL normale à `1.0` ;
+- borne chaque attente de trame à 250 ms après le démarrage afin de garder un flux continu sans bloquer indéfiniment le thread audio ;
+- ajoute un test déterministe des tampons Minecraft et renforce le test YouTube réel sur quatre secondes complètes ;
+- conserve les données Ambiance v2, le protocole réseau 6, les IDs et les sauvegardes existantes ;
+- distribue Ambiance `0.0.0-alpha.19` dans Packwiz et le `.mrpack` partagé client/serveur, sans exiger de nouveau monde ni réinitialiser les sauvegardes.
+
+## `26.2.0-alpha.215`
+
+Module modifié : **Ambiance `0.0.0-alpha.18`**. Les neuf autres modules conservent leur version issue de l'alpha.214.
+
+- corrige le crash natif déclenché par l’insertion ou l’arrêt du disque blanc en laissant Minecraft libérer le canal OpenAL sur son thread audio ;
+- rétablit le décodage audible du lien YouTube signalé grâce au profil iOS corrigé et à une révision épinglée de `youtube-source` ;
+- borne uniquement l’attente initiale du flux puis poursuit la lecture sans blocage, avec silence de compensation lorsque les données arrivent en retard ;
+- transforme les erreurs et blocages de lecture en arrêt propre accompagné d’un message au joueur ;
+- conserve les données Ambiance v2, le protocole réseau 6, les IDs et les sauvegardes existantes ;
+- distribue Ambiance `0.0.0-alpha.18` dans Packwiz et le `.mrpack` partagé client/serveur, sans exiger de nouveau monde ni réinitialiser les sauvegardes.
+
+## `26.2.0-alpha.214`
+
+Module modifié : **Ambiance `0.0.0-alpha.17`**. Les neuf autres modules conservent leur version issue de l'alpha.213.
+
+- attend de façon bornée la synchronisation client du jukebox avant de charger un disque blanc, ce qui rétablit sa lecture en solo ;
+- affiche immédiatement le chargement puis un échec explicite si le jukebox n'est toujours pas synchronisé après cinq secondes ;
+- accepte toujours les liens de partage YouTube avec paramètres, notamment `https://youtu.be/Ue5ZBe-GzSM?si=…` ;
+- conserve les données Ambiance v2 et le protocole réseau 6, sans migration de sauvegarde ;
+- distribue Ambiance `0.0.0-alpha.17` dans Packwiz et le `.mrpack` partagé client/serveur, sans exiger de nouveau monde ni réinitialiser les sauvegardes.
+
+## `26.2.0-alpha.213`
+
+Module modifié : **Ambiance `0.0.0-alpha.16`**. Les neuf autres modules conservent leur version issue de l'alpha.212.
+
+- corrige le crash client au démarrage d'Ambiance sous Minecraft 26.2 en ciblant le nouveau gestionnaire vanilla `LevelEventHandler` pour l'arrêt du disque blanc ;
+- conserve les données Ambiance v2 et le protocole réseau 6, sans migration de sauvegarde ;
+- remplace le JAR Ambiance cassé dans Packwiz et le `.mrpack` partagé client/serveur, sans exiger de nouveau monde ni réinitialiser les sauvegardes.
+
+## `26.2.0-alpha.212`
+
+Module modifié : **Sanctuary `0.0.0-alpha.120`**. Les neuf autres modules conservent leur version issue de l'alpha.211.
+
+- corrige le crash client au démarrage provoqué par le mixin du clic molette du Black Market sous Minecraft 26.2 ;
+- cible désormais la méthode vanilla `pickBlockOrEntity`, sans modifier les données Sanctuary v11 ni le protocole réseau 22.
+- remplace le JAR Sanctuary cassé dans Packwiz et le `.mrpack` partagé client/serveur, sans exiger de nouveau monde ni réinitialiser les sauvegardes.
+
+## `26.2.0-alpha.211`
+
+Modules modifiés : **Ambiance `0.0.0-alpha.15`**, **It's Alive `0.0.0-alpha.36`**, **Only Fun `0.0.0-alpha.24`**, **Ouch `0.0.0-alpha.10`** et **Sanctuary `0.0.0-alpha.119`**. Les cinq autres modules conservent leur version issue de l’alpha.210.
+
+- remplace les pages noires du Livre interdit par l’affichage clair du livre vanilla ;
+- conserve les seize entrées, les découvertes personnelles, le partage sur pupitre, les IDs, les données v3 et le protocole réseau 4.
+- rétablit l'accès au Black Market par clic molette sur un panneau, avec une intention vide et une nouvelle validation complète de la cible côté serveur ;
+- conserve les données Sanctuary v11 et porte son protocole réseau de 21 à 22, sans nouvel ID persistant.
+- ajoute le disque blanc, à fabriquer puis renommer avec une URL YouTube HTTPS avant de l’insérer dans un jukebox ;
+- valide strictement l’hôte et l’identifiant vidéo côté serveur, ne transmet qu’un identifiant borné de onze caractères et limite chaque client à quatre lectures de trente minutes maximum ;
+- diffuse le son en mono positionnel dans le canal des disques, sans nouvelle donnée persistante ; Ambiance conserve ses données v2 et passe son protocole réseau de 5 à 6.
+- importe le cœur GPL historique d’Abjection dans Only Fun, sans onzième JAR : `/piss`, `/vomit`, `/shit` et `/smoke` retrouvent leurs durées, jets, impacts et messages ;
+- restaure `abjection:shit_ball` ainsi que le bloc boueux `abjection:shit_cube`, sa recette, son butin et ses ressources originales en FR/EN/RU ;
+- expose une API serveur unique pour les commandes et le futur raccourci, nettoie les actions temporaires à la mort, en spectateur ou à la déconnexion, et conserve les données v2 ainsi que le protocole réseau 2 d’Only Fun.
+- rend `abjection:shit_ball` lançable à la main et par dispenser grâce à une fabrique publique installée par Ouch, sans réenregistrer l’objet possédé par Only Fun ;
+- restaure le projectile historique de 0,25 bloc, sa consommation unique hors créatif, son rendu d’objet, son impact boueux et ses sept secondes de nausée ajoutées à la durée existante ;
+- déclare la dépendance sans cycle `ouch -> onlyfun` ; les données et protocoles réseau d’Ouch et d’Only Fun restent inchangés.
+- ajoute la touche configurable « Chier » dans les contrôles Only Fun, assignée à `J` par défaut et sans répétition lorsque la touche reste maintenue ;
+- transmet une demande C2S vide, déduplique le spam d’un même tick et revalide côté serveur la connexion, la vie et le mode spectateur avant de réutiliser exactement l’action `/shit` ;
+- conserve les données Only Fun v2 et porte son protocole réseau de 2 à 3, sans nouveau cooldown, besoin ni donnée persistante.
+- distribue les cinq JAR mis à jour dans Packwiz et le `.mrpack` partagé client/serveur, sans exiger de nouveau monde ni réinitialiser les sauvegardes.
+
+## `26.2.0-alpha.210`
+
+Modules modifiés : **Sanctuary `0.0.0-alpha.118`**, **Only Fun `0.0.0-alpha.21`**, **I Like To Move It `0.0.0-alpha.15`** et **It's Alive `0.0.0-alpha.35`**. Les six autres modules conservent leur version issue de l’alpha.209.
+
+- sépare le compteur quotidien et le statut de déblocage du Shop pour empêcher leur chevauchement ;
+- retire du Shop Only Fun les raccourcis qui contournaient la progression normale ;
+- attribue à tous les Zombies vanilla des gamertags déterministes inspirés de la Xbox 360 ;
+- resynchronise les capes après une reconnexion avec des tentatives retardées et bornées ;
+- réserve les requêtes communautaires aux panneaux dédiés au lieu d’intercepter les panneaux ordinaires ;
+- double la vitesse de croisière du Happy Ghast lorsqu’un joueur le pilote, sans accélérer ses déplacements autonomes ;
+- conserve les données v3 et le protocole réseau 5, sans migration de sauvegarde ni nouvel ID.
+- transforme le Codex Canaplia en « Livre interdit » aux pages noires, sans page d'accueil, et fait découvrir une entrée aléatoire encore inconnue à chaque page consommée ;
+- garde les découvertes du Livre interdit personnelles en main et partage temporairement celles du propriétaire uniquement lorsque le livre est posé sur un pupitre ;
+- conserve les IDs et les anciennes données partagées, ainsi que les données v3 et le protocole réseau 4 d'It's Alive, sans migration de sauvegarde.
+- actualise JEI de `30.28.0.191` à la bêta compatible `30.28.0.193` dans Packwiz et le manifeste Prism/Modrinth ;
+- distribue les quatre JAR mis à jour dans Packwiz, Prism et le `.mrpack` partagé client/serveur, sans exiger de nouveau monde.
+
 ## `26.2.0-alpha.209`

 Module modifié : **It's Alive `0.0.0-alpha.34`**. Les neuf autres modules conservent leur version issue de l’alpha.208.
@@ -1,6 +1,6 @@
 # Sanctuary 26.2

-Workspace Fabric multi-projet de Sanctuary 2.0. Il construit dix JAR indépendants sur Minecraft 26.2, Fabric Loader 0.19.3, Fabric API 0.155.0+26.2, Loom 1.17, Gradle 9.5.1 et Java 25.
+Workspace Fabric multi-projet de Sanctuary 2.0. Il construit dix JAR indépendants sur Minecraft 26.2, Fabric Loader 0.19.3, Fabric API 0.158.0+26.2, Loom 1.17, Gradle 9.5.1 et Java 25.

 Auteur : **KOKA99CAB**  
 Licence : **GNU GPL 3.0 or Later** (`GPL-3.0-or-later`)
@@ -11,8 +11,8 @@ Licence : **GNU GPL 3.0 or Later** (`GPL-3.0-or-later`)
 |---|---|---|---|
 | `anotherworld` | Another World | choses matérielles | matière, photographie, instruments météo et 108 biomes natifs |
 | `itsalive` | It's Alive ! | vivant | Creepers, créatures, agriculture et gameplay serveur complet de Canaplia |
-| `ambiance` | Ambiance | perception | atmosphère, météo, lumières dynamiques, calendrier et composition visuelle accessible |
-| `redstoner` | Red-Stoner | calcul et signaux | ordinateurs, identité serveur, Drawer et Particuleur |
+| `ambiance` | Ambiance | perception | atmosphère, météo, lumières dynamiques, audio positionnel, calendrier et composition visuelle accessible |
+| `redstoner` | Red-Stoner | calcul et signaux | ordinateurs, identité serveur, terminal de stockage, Drawer et Particuleur |
 | `iliketomoveit` | I Like To Move It | déplacement | portails, véhicules, grappin, poulies et waystones locaux |
 | `ouch` | Ouch | combat et destruction | arsenal actif (6 armes) et TNT météo |
 | `onlyfun` | Only Fun | règles ludiques absurdes | lootboxes, Lucky Block, raretés et règles absurdes |
@@ -22,11 +22,13 @@ Licence : **GNU GPL 3.0 or Later** (`GPL-3.0-or-later`)

 Les descriptions FR/EN/RU sont déclarées dans chaque `fabric.mod.json` et dans les fichiers de langue. Les images fournies servent d'icônes Fabric de leur module.

-Version courante du pack distribué : **`26.2.0-alpha.208`**. Cette release distribue Canaplia complet avec It's Alive **`0.0.0-alpha.33`**, Ambiance **`0.0.0-alpha.14`** et Only Fun **`0.0.0-alpha.20`**.
+Version courante du pack distribué : **`26.2.0-alpha.217`**. Cette release distribue Red-Stoner **`0.0.0-alpha.11`**, Only Fun **`0.0.0-alpha.25`** et Sanctuary **`0.0.0-alpha.121`** ; les sept autres modules conservent leur version issue de l'alpha.216.

-La migration [CANA-01 à CANA-09](CANAPLIA.md) porte Canaplia vers Minecraft 26.2. It's Alive **`0.0.0-alpha.33`** enregistre les seize familles, les découvertes, hybridations, résines, effets serveur et le Codex. Ambiance **`0.0.0-alpha.14`** compose les profils visuels bornés avec ses réglages d'accessibilité, et Only Fun **`0.0.0-alpha.20`** exclut explicitement Canaplia du Shop et des récompenses ordinaires. Ces trois modules sont inclus dans l'alpha.208 pour les clients et les serveurs.
+La migration [CANA-01 à CANA-09](CANAPLIA.md) porte Canaplia vers Minecraft 26.2. It's Alive **`0.0.0-alpha.35`** enregistre les seize familles, les découvertes, hybridations, résines, effets serveur et le Livre interdit personnel, partageable temporairement sur un pupitre. Ambiance **`0.0.0-alpha.14`** compose les profils visuels bornés avec ses réglages d'accessibilité, et Only Fun **`0.0.0-alpha.21`** exclut explicitement Canaplia et les raccourcis de progression du Shop.

-L’alpha.208 ajoute Canaplia aux packs Modrinth, Prism et Packwiz sans exiger de nouveau monde. Les sources sauvages fonctionnent dans les chunks existants, tandis que les nouvelles données de compostage et de Codex sont créées ou migrées automatiquement à leur première utilisation.
+L’alpha.217 ajoute le terminal de stockage Red-Stoner : cette demi-dalle verticale se fixe sur un coffre, un coffre piégé ou un baril et donne accès, par pages défilantes de 54 types, à un réseau contigu borné à 128 conteneurs chargés. Les retraits et dépôts sont validés par le serveur, les composants d’items restent strictement séparés et le terminal endgame est exclu du Shop, du Black Market et des récompenses Only Fun.
+
+L’alpha.216 corrige la lecture lente et dégradée du disque blanc : les quatre tampons PCM initiaux de Minecraft sont maintenant remplis continûment à 48 kHz, avec une vitesse OpenAL normale, au lieu d’être majoritairement complétés par du silence. Les packs Modrinth, Prism et Packwiz sont mis à jour sans exiger de nouveau monde ni réinitialiser les sauvegardes.

 L’alpha.207 rend le stockage du coffre-fort pratiquement illimité : rubis, saphirs et émeraudes utilisent chacun un solde 64 bits. Les 27 anciennes piles sont additionnées automatiquement lors du chargement, le Shop continue de consommer directement ces soldes et les 20 % pillés sont crédités dans le coffre-fort de l’attaquant sans créer des millions d’entités ou de piles d’objets.

@@ -0,0 +1,33 @@
+# Disque blanc YouTube
+
+Le disque blanc appartient à **Ambiance**, propriétaire de l’audio positionnel. Il conserve l’ID
+`ambiance:white_disc` et se fabrique avec un disque 13 entouré de huit colorants blancs. Pour le
+lire, il faut le renommer dans une enclume avec une URL YouTube HTTPS puis l’insérer dans un
+jukebox vanilla.
+
+## Contrat réseau et sécurité
+
+- le serveur reste l’autorité de l’insertion et refuse les noms qui ne correspondent pas à une URL
+  HTTPS exacte de `youtube.com`, `www.youtube.com`, `m.youtube.com`, `music.youtube.com` ou
+  `youtu.be` ;
+- les formats `watch`, `shorts`, `embed`, `live` et le lien court sont acceptés, mais l’identifiant
+  doit contenir exactement onze caractères ASCII autorisés ;
+- le payload S2C ne contient que la position du jukebox et cet identifiant borné, jamais une URL
+  libre ; il est envoyé uniquement aux clients qui suivent le chunk et annoncent le canal ;
+- chaque client ouvre lui-même la source YouTube, refuse les directs et les vidéos de plus de
+  trente minutes, et limite les lectures simultanées à quatre ;
+- la lecture utilise le canal `RECORDS`, un flux PCM mono positionnel et une atténuation à
+  64 blocs. Elle s’arrête lorsque le disque est éjecté, le chunk disparaît ou la session se ferme.
+
+Le disque ne crée aucune donnée persistante et ne demande aucune migration de sauvegarde.
+Ambiance conserve ses données v2 ; son protocole passe de 5 à 6.
+
+## Dépendances clientes embarquées
+
+Le décodage repose sur Lavaplayer `2.2.7` (Apache-2.0) et sur le commit youtube-source
+`f45bbb7aebfcbc1c553769e04af6cd43afa8b7c3` (MIT), épinglé pour intégrer les correctifs de lecture
+YouTube publiés après `1.18.2`. Le profil iOS corrigé est utilisé sans compte, OAuth, jeton privé ou
+service de chiffrement tiers. Les dépendances sont placées en JAR imbriqués par Loom et leurs avis
+de licence restent dans les archives d’origine. L’accès YouTube est effectué uniquement par le
+client et peut cesser de fonctionner si YouTube modifie ses mécanismes de lecture ; aucune clé ou
+URL arbitraire n’est acceptée par le serveur.
@@ -1,8 +1,45 @@
 import groovy.json.JsonSlurper

+def youtubeSourceVersion = "f45bbb7aebfcbc1c553769e04af6cd43afa8b7c3-SNAPSHOT"
+
+configurations {
+	whiteDiscLibraries
+	implementation.extendsFrom whiteDiscLibraries
+	include.extendsFrom whiteDiscLibraries
+}
+
 dependencies {
 	implementation project(':sanctuary')
 	compileOnly "maven.modrinth:YL57xq9U:oaD6KQls"
+	whiteDiscLibraries("dev.arbjerg:lavaplayer:2.2.7") {
+		exclude group: "org.slf4j", module: "slf4j-api"
+		exclude group: "org.jetbrains", module: "annotations"
+	}
+	whiteDiscLibraries("dev.lavalink.youtube:v2:${youtubeSourceVersion}") {
+		exclude group: "org.slf4j", module: "slf4j-api"
+		exclude group: "org.jetbrains", module: "annotations"
+	}
+	[
+		"dev.arbjerg:lavaplayer-natives:2.2.7",
+		"dev.arbjerg:lava-common:2.2.7",
+		"dev.lavalink.youtube:common:${youtubeSourceVersion}",
+		"org.mozilla:rhino-engine:1.7.15",
+		"org.mozilla:rhino:1.7.15",
+		"commons-io:commons-io:2.13.0",
+		"org.jsoup:jsoup:1.16.1",
+		"net.iharder:base64:2.3.9",
+		"org.json:json:20240303",
+		"org.apache.httpcomponents:httpclient:4.5.14",
+		"org.apache.httpcomponents:httpcore:4.4.16",
+		"commons-logging:commons-logging:1.2",
+		"commons-codec:commons-codec:1.11",
+		"com.fasterxml.jackson.core:jackson-core:2.15.2",
+		"com.fasterxml.jackson.core:jackson-databind:2.15.2",
+		"com.fasterxml.jackson.core:jackson-annotations:2.15.2",
+		"com.grack:nanojson:1.7"
+	].each { coordinates ->
+		whiteDiscLibraries(coordinates) { transitive = false }
+	}
 }

 tasks.register("ambianceVisualApiSmoke", JavaExec) {
@@ -21,15 +58,41 @@ tasks.register("ambianceScheduleSmoke", JavaExec) {
 	mainClass = "fr.koka99cab.sanctuary26.ambiance.environment.AmbianceScheduleSmoke"
 }

+tasks.register("whiteDiscUrlSmoke", JavaExec) {
+	group = "verification"
+	description = "Checks strict and bounded YouTube URL parsing for the white disc."
+	dependsOn tasks.named("testClasses")
+	classpath = sourceSets.test.runtimeClasspath
+	mainClass = "fr.koka99cab.sanctuary26.ambiance.white_disc.WhiteDiscUrlSmoke"
+}
+
+tasks.register("whiteDiscPlaybackSmoke", JavaExec) {
+	group = "verification"
+	description = "Manually checks live YouTube loading and PCM decoding for the white disc."
+	dependsOn tasks.named("testClasses")
+	classpath = sourceSets.test.runtimeClasspath
+	mainClass = "fr.koka99cab.sanctuary26.ambiance.client.audio.WhiteDiscPlaybackSmoke"
+}
+
+tasks.register("whiteDiscStreamSmoke", JavaExec) {
+	group = "verification"
+	description = "Checks continuous 48 kHz PCM buffering for Minecraft's white-disc channel."
+	dependsOn tasks.named("testClasses")
+	classpath = sourceSets.test.runtimeClasspath
+	mainClass = "fr.koka99cab.sanctuary26.ambiance.client.audio.LavaplayerAudioStreamSmoke"
+}
+
 tasks.named("test") {
 	failOnNoDiscoveredTests = false
 }

 tasks.register("verifyAmbiance") {
 	group = "verification"
-	description = "Checks Ambiance alpha.12, including timed weather overrides, playable night fog and weather/lunar controls."
+	description = "Checks Ambiance alpha.19, including continuous white-disc PCM playback."
 	inputs.files(fileTree("src/main/java"))
 	inputs.files(fileTree("src/main/resources"))
+	inputs.file(file("src/test/java/fr/koka99cab/sanctuary26/ambiance/client/audio/WhiteDiscPlaybackSmoke.java"))
+	inputs.file(file("src/test/java/fr/koka99cab/sanctuary26/ambiance/client/audio/LavaplayerAudioStreamSmoke.java"))
 	inputs.file(rootProject.file("pack/migrations/26.2.0-alpha.125-realtime-calendar-to-alpha.126.json"))
 	inputs.file(rootProject.file("pack/migrations/26.2.0-alpha.127-daily-ambiance-sodium-iris-to-alpha.128.json"))
 	inputs.file(rootProject.file("pack/migrations/26.2.0-alpha.128-ambiance-visuals-canon-iris-to-alpha.129.json"))
@@ -68,8 +131,23 @@ tasks.register("verifyAmbiance") {
 		def languages = ["fr_fr", "en_us", "ru_ru"].collectEntries { language ->
 			[(language): new JsonSlurper().parse(file("src/main/resources/assets/realtime/lang/${language}.json"))]
 		}
+		def ambianceLanguages = ["fr_fr", "en_us", "ru_ru"].collectEntries { language ->
+			[(language): new JsonSlurper().parse(file("src/main/resources/assets/ambiance/lang/${language}.json"))]
+		}
+		def whiteDiscTexture = javax.imageio.ImageIO.read(
+			file("src/main/resources/assets/ambiance/textures/item/white_disc.png"))
+		def whiteDiscRecipe = new JsonSlurper().parse(
+			file("src/main/resources/data/ambiance/recipe/white_disc.json"))
+		def whiteDiscSong = new JsonSlurper().parse(
+			file("src/main/resources/data/ambiance/jukebox_song/white_disc.json"))
+		def levelEventMixin = file(
+			"src/main/java/fr/koka99cab/sanctuary26/ambiance/mixin/client/LevelEventHandlerMixin.java").text
+		def whiteDiscAudioPlayer = file(
+			"src/main/java/fr/koka99cab/sanctuary26/ambiance/client/audio/WhiteDiscAudioPlayer.java").text
+		def whiteDiscPlaybackSmoke = file(
+			"src/test/java/fr/koka99cab/sanctuary26/ambiance/client/audio/WhiteDiscPlaybackSmoke.java").text

-		if (project.version.toString() != "0.0.0-alpha.14"
+		if (project.version.toString() != "0.0.0-alpha.19"
 			|| migration.source?.pack_version != "26.2.0-alpha.125"
 			|| migration.target?.pack_version != "26.2.0-alpha.126"
 			|| migration.target?.modules?.ambiance != "0.0.0-alpha.1"
@@ -84,7 +162,7 @@ tasks.register("verifyAmbiance") {
 			|| migration.compatibility?.ambiance_data_version != 1
 			|| migration.compatibility?.ambiance_network_protocol != 2
 			|| manifest.custom?.sanctuary26?.data_version != 2
-			|| manifest.custom?.sanctuary26?.network_protocol != 5
+			|| manifest.custom?.sanctuary26?.network_protocol != 6
 			|| dailyMigration.target?.pack_version != "26.2.0-alpha.128"
 			|| dailyMigration.target?.modules?.ambiance != "0.0.0-alpha.2"
 			|| dailyMigration.lunar_schedule?.cycle != "minecraft_native_eight_days"
@@ -262,6 +340,54 @@ tasks.register("verifyAmbiance") {
 			|| !javaText.contains("Mth.lerp(night, 1.0F, 0.98F)")) {
 			throw new GradleException("Ambiance alpha.11 playable-night fog contract is incomplete")
 		}
+		if (!javaText.contains('id("white_disc_playback")')
+			|| !javaText.contains('readUtf(WhiteDiscUrl.VIDEO_ID_LENGTH)')
+			|| !javaText.contains('PlayerLookup.tracking(level, pos)')
+			|| !javaText.contains('ServerPlayNetworking.canSend(receiver, WhiteDiscPlaybackPayload.ID)')
+			|| !javaText.contains('MAXIMUM_SIMULTANEOUS_DISCS = 4')
+			|| !javaText.contains('PENDING_STARTS.size() + REQUESTS.size() + PLAYBACKS.size()')
+			|| !javaText.contains('MAXIMUM_START_WAIT_TICKS = 100')
+			|| !javaText.contains('tickPendingStarts(client)')
+			|| !javaText.contains('client.level.dimension().equals(playback.dimension())')
+			|| !javaText.contains('MAXIMUM_TRACK_MILLIS = 30L * 60L * 1_000L')
+			|| !javaText.contains('new Pcm16AudioDataFormat(1, LavaplayerAudioStream.SAMPLE_RATE')
+			|| !javaText.contains('new YoutubeAudioSourceManager(false, new Ios())')
+			|| !javaText.contains('player.addListener(new AudioEventAdapter()')
+			|| !javaText.contains('failPlayback(client, key, failedPlayer)')
+			|| !javaText.contains('initialWaitAttempted')
+			|| !javaText.contains('CONTINUATION_FRAME_WAIT_MILLIS = 250L')
+			|| !javaText.contains('player.provide(waitMillis, TimeUnit.MILLISECONDS)')
+			|| !whiteDiscAudioPlayer.contains('channel.setPitch(1.0F)')
+			|| !whiteDiscAudioPlayer.contains('handle.execute(channel -> channel.stop())')
+			|| whiteDiscAudioPlayer.contains('.release()')
+			|| !whiteDiscPlaybackSmoke.contains('https://www.youtube.com/watch?v=Ue5ZBe-GzSM')
+			|| !whiteDiscPlaybackSmoke.contains('Decoded audible PCM data')
+			|| !javaText.contains('SoundSource.RECORDS')
+			|| !javaText.contains('channel.linearAttenuation(ATTENUATION_DISTANCE)')
+			|| !javaText.contains('LONG_HOSTS = Set.of(')
+			|| !javaText.contains('"https".equalsIgnoreCase(uri.getScheme())')
+			|| !file("src/main/resources/assets/ambiance/items/white_disc.json").isFile()
+			|| !file("src/main/resources/assets/ambiance/models/item/white_disc.json").isFile()
+			|| whiteDiscTexture == null || whiteDiscTexture.width != 16 || whiteDiscTexture.height != 16
+			|| whiteDiscRecipe.result?.id != "ambiance:white_disc"
+			|| whiteDiscRecipe.key?.W != "minecraft:white_dye"
+			|| whiteDiscSong.sound_event != "minecraft:intentionally_empty"
+			|| whiteDiscSong.length_in_seconds != 1800
+			|| !levelEventMixin.contains('@Mixin(LevelEventHandler.class)')
+			|| !levelEventMixin.contains('@Inject(method = "levelEvent"')
+			|| !levelEventMixin.contains('ambiance$stopWhiteDisc(int type, BlockPos pos, int data,')
+			|| ambianceLanguages.any { locale, translations ->
+				!["item.ambiance.white_disc", "tooltip.ambiance.white_disc",
+					"message.ambiance.white_disc.invalid_url", "message.ambiance.white_disc.failed"].every {
+						translations.containsKey(it)
+				}
+			}
+			|| !file("build.gradle").text.contains('dev.arbjerg:lavaplayer:2.2.7')
+			|| !file("build.gradle").text.contains(
+				'def youtubeSourceVersion = "f45bbb7aebfcbc1c553769e04af6cd43afa8b7c3-SNAPSHOT"')
+			|| !file("build.gradle").text.contains('dev.lavalink.youtube:v2:${youtubeSourceVersion}')) {
+			throw new GradleException("Ambiance white-disc playback contract is incomplete")
+		}

 		[
 			'class RealtimeMod', 'class RealtimeConfig', 'class MinecraftChronology',
@@ -313,4 +439,6 @@ tasks.named("check") {
 	dependsOn tasks.named("verifyAmbiance")
 	dependsOn tasks.named("ambianceScheduleSmoke")
 	dependsOn tasks.named("ambianceVisualApiSmoke")
+	dependsOn tasks.named("whiteDiscUrlSmoke")
+	dependsOn tasks.named("whiteDiscStreamSmoke")
 }
@@ -7,6 +7,7 @@ import fr.koka99cab.sanctuary26.ambiance.environment.AmbianceBloodNightAssault;
 import fr.koka99cab.sanctuary26.ambiance.environment.AmbianceWeatherCommands;
 import fr.koka99cab.sanctuary26.ambiance.network.AmbianceNetworking;
 import fr.koka99cab.sanctuary26.ambiance.registry.AmbianceRegistries;
+import fr.koka99cab.sanctuary26.ambiance.white_disc.WhiteDiscService;
 import net.fabricmc.api.ModInitializer;
 import net.minecraft.resources.Identifier;
 import org.slf4j.Logger;
@@ -29,6 +30,7 @@ public final class AmbianceMod implements ModInitializer {
 	public void onInitialize() {
 		AmbianceRegistries.initialize();
 		AmbianceNetworking.initialize();
+		WhiteDiscService.initialize();
 		RealtimeMod.initialize();
 		AmbianceEnvironmentController.initialize();
 		AmbianceFirstSpawnVision.initialize();
@@ -4,7 +4,10 @@ import fr.koka99cab.realtime.client.RealtimeClient;
 import fr.koka99cab.sanctuary26.ambiance.AmbianceMod;
 import fr.koka99cab.sanctuary26.ambiance.network.AmbianceEnvironmentPayload;
 import fr.koka99cab.sanctuary26.ambiance.network.AmbianceCanapliaVisualPayloads;
+import fr.koka99cab.sanctuary26.ambiance.network.WhiteDiscPlaybackPayload;
+import fr.koka99cab.sanctuary26.ambiance.client.audio.WhiteDiscAudioPlayer;
 import net.fabricmc.api.ClientModInitializer;
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientLifecycleEvents;
 import net.fabricmc.fabric.api.client.networking.v1.ClientPlayConnectionEvents;
 import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
 import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
@@ -41,11 +44,15 @@ public final class AmbianceClient implements ClientModInitializer {
 			context.client().execute(() -> AmbianceClientVisualEffects.apply(payload)));
 		ClientPlayNetworking.registerGlobalReceiver(AmbianceCanapliaVisualPayloads.Clear.ID, (payload, context) ->
 			context.client().execute(AmbianceClientVisualEffects::clear));
+		ClientPlayNetworking.registerGlobalReceiver(WhiteDiscPlaybackPayload.ID, (payload, context) ->
+			context.client().execute(() -> WhiteDiscAudioPlayer.play(
+				context.client(), payload.pos(), payload.videoId())));
 		visualSettingsKey = KeyMappingHelper.registerKeyMapping(new KeyMapping(
 			"key.ambiance.visual_settings", InputConstants.Type.KEYSYM,
 			GLFW.GLFW_KEY_UNKNOWN, AMBIANCE_CATEGORY));
 		ClientTickEvents.END_CLIENT_TICK.register(client -> {
 			AmbianceClientVisualEffects.tick();
+			WhiteDiscAudioPlayer.tick(client);
 			while (visualSettingsKey.consumeClick()) {
 				if (client.gui.screen() == null) client.gui.setScreen(new AmbianceVisualSettingsScreen(null));
 			}
@@ -54,7 +61,9 @@ public final class AmbianceClient implements ClientModInitializer {
 			AmbianceClientEnvironment.reset();
 			DynamicTorchLights.reset();
 			AmbianceClientVisualEffects.clear();
+			WhiteDiscAudioPlayer.clear();
 		});
+		ClientLifecycleEvents.CLIENT_STOPPING.register(client -> WhiteDiscAudioPlayer.shutdown());
 		AmbianceVisualOverlay.register();
 		AmbianceBiomeTints.registerColorResolvers();
 		registerWaterFluidTint();
@@ -0,0 +1,95 @@
+package fr.koka99cab.sanctuary26.ambiance.client.audio;
+
+import com.sedmelluq.discord.lavaplayer.player.AudioPlayer;
+import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import javax.sound.sampled.AudioFormat;
+import net.minecraft.client.sounds.AudioStream;
+
+/** Adapts bounded mono PCM frames from Lavaplayer to Minecraft's streaming OpenAL channel. */
+final class LavaplayerAudioStream implements AudioStream {
+	static final int SAMPLE_RATE = 48_000;
+	private static final long INITIAL_FRAME_WAIT_MILLIS = 2_000L;
+	private static final long CONTINUATION_FRAME_WAIT_MILLIS = 250L;
+	private static final AudioFormat FORMAT =
+		new AudioFormat(SAMPLE_RATE, 16, 1, true, false);
+	private final AudioPlayer player;
+	private byte[] pending = new byte[0];
+	private int pendingOffset;
+	private boolean initialWaitAttempted;
+	private volatile boolean closed;
+	private volatile boolean ended;
+
+	LavaplayerAudioStream(AudioPlayer player) {
+		this.player = player;
+	}
+
+	@Override
+	public AudioFormat getFormat() {
+		return FORMAT;
+	}
+
+	@Override
+	public ByteBuffer read(int maximumBytes) throws IOException {
+		if (closed || maximumBytes <= 0) return null;
+		ByteBuffer output = ByteBuffer.allocateDirect(maximumBytes);
+		while (output.hasRemaining() && !closed) {
+			if (pendingOffset < pending.length) {
+				int length = Math.min(output.remaining(), pending.length - pendingOffset);
+				output.put(pending, pendingOffset, length);
+				pendingOffset += length;
+				continue;
+			}
+			AudioFrame frame = nextFrame();
+			if (frame == null) {
+				if (ended) break;
+				while (output.hasRemaining()) output.put((byte) 0);
+				break;
+			}
+			if (frame.isTerminator()) {
+				ended = true;
+				break;
+			}
+			pending = frame.getData();
+			pendingOffset = 0;
+		}
+		if (output.position() == 0 && ended) return null;
+		output.flip();
+		return output;
+	}
+
+	private AudioFrame nextFrame() throws IOException {
+		try {
+			long waitMillis = initialWaitAttempted
+				? CONTINUATION_FRAME_WAIT_MILLIS
+				: INITIAL_FRAME_WAIT_MILLIS;
+			initialWaitAttempted = true;
+			AudioFrame frame = player.provide(waitMillis, TimeUnit.MILLISECONDS);
+			if (frame == null && player.getPlayingTrack() == null) ended = true;
+			return frame;
+		} catch (TimeoutException ignored) {
+			return null;
+		} catch (InterruptedException interrupted) {
+			Thread.currentThread().interrupt();
+			throw new IOException("Interrupted while buffering the white disc", interrupted);
+		}
+	}
+
+	boolean ended() {
+		return ended;
+	}
+
+	boolean uses(AudioPlayer expectedPlayer) {
+		return player == expectedPlayer;
+	}
+
+	@Override
+	public void close() {
+		if (closed) return;
+		closed = true;
+		player.destroy();
+	}
+}
@@ -0,0 +1,299 @@
+package fr.koka99cab.sanctuary26.ambiance.client.audio;
+
+import com.mojang.blaze3d.audio.Library;
+import com.sedmelluq.discord.lavaplayer.format.Pcm16AudioDataFormat;
+import com.sedmelluq.discord.lavaplayer.player.AudioLoadResultHandler;
+import com.sedmelluq.discord.lavaplayer.player.AudioPlayer;
+import com.sedmelluq.discord.lavaplayer.player.DefaultAudioPlayerManager;
+import com.sedmelluq.discord.lavaplayer.player.event.AudioEventAdapter;
+import com.sedmelluq.discord.lavaplayer.tools.FriendlyException;
+import com.sedmelluq.discord.lavaplayer.track.AudioPlaylist;
+import com.sedmelluq.discord.lavaplayer.track.AudioTrack;
+import dev.lavalink.youtube.YoutubeAudioSourceManager;
+import dev.lavalink.youtube.clients.Ios;
+import fr.koka99cab.sanctuary26.ambiance.AmbianceMod;
+import fr.koka99cab.sanctuary26.ambiance.mixin.client.SoundEngineAccessor;
+import fr.koka99cab.sanctuary26.ambiance.mixin.client.SoundManagerAccessor;
+import fr.koka99cab.sanctuary26.ambiance.white_disc.WhiteDiscUrl;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.sounds.ChannelAccess;
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.JukeboxBlock;
+import net.minecraft.world.phys.Vec3;
+
+/** Client-only, positional and resource-bounded YouTube playback for white discs. */
+public final class WhiteDiscAudioPlayer {
+	private static final int MAXIMUM_SIMULTANEOUS_DISCS = 4;
+	private static final int MAXIMUM_START_WAIT_TICKS = 100;
+	private static final long MAXIMUM_TRACK_MILLIS = 30L * 60L * 1_000L;
+	private static final long FINISHED_GRACE_NANOS = 5_000_000_000L;
+	private static final float ATTENUATION_DISTANCE = 64.0F;
+	private static final DefaultAudioPlayerManager MANAGER = createManager();
+	private static final Map<Long, PendingStart> PENDING_STARTS = new HashMap<>();
+	private static final Map<Long, Long> REQUESTS = new HashMap<>();
+	private static final LinkedHashMap<Long, Playback> PLAYBACKS = new LinkedHashMap<>();
+	private static long requestSequence;
+	private static boolean shutdown;
+
+	private WhiteDiscAudioPlayer() {
+	}
+
+	public static void play(Minecraft client, BlockPos pos, String videoId) {
+		if (shutdown || !WhiteDiscUrl.validVideoId(videoId) || !validJukeboxTarget(client, pos)) return;
+		long key = pos.asLong();
+		if (PENDING_STARTS.containsKey(key) || REQUESTS.containsKey(key)) return;
+		boolean replacingPlayback = PLAYBACKS.containsKey(key);
+		if (!replacingPlayback
+			&& PENDING_STARTS.size() + REQUESTS.size() + PLAYBACKS.size()
+				>= MAXIMUM_SIMULTANEOUS_DISCS) return;
+		stop(key);
+		client.player.sendOverlayMessage(Component.translatable("message.ambiance.white_disc.loading"));
+		if (!validTarget(client, pos)) {
+			PENDING_STARTS.put(key, new PendingStart(pos.immutable(), client.level.dimension(), videoId,
+				MAXIMUM_START_WAIT_TICKS));
+			return;
+		}
+		startLoading(client, pos, videoId);
+	}
+
+	private static void startLoading(Minecraft client, BlockPos pos, String videoId) {
+		long key = pos.asLong();
+		long request = ++requestSequence;
+		REQUESTS.put(key, request);
+		MANAGER.loadItemOrdered(key, WhiteDiscUrl.canonicalUrl(videoId), new AudioLoadResultHandler() {
+			@Override
+			public void trackLoaded(AudioTrack track) {
+				client.execute(() -> acceptTrack(client, pos, request, track));
+			}
+
+			@Override
+			public void playlistLoaded(AudioPlaylist playlist) {
+				AudioTrack selected = playlist.getSelectedTrack();
+				if (selected == null && !playlist.getTracks().isEmpty()) selected = playlist.getTracks().getFirst();
+				if (selected == null) noMatches();
+				else trackLoaded(selected);
+			}
+
+			@Override
+			public void noMatches() {
+				client.execute(() -> fail(client, key, request));
+			}
+
+			@Override
+			public void loadFailed(FriendlyException exception) {
+				AmbianceMod.LOGGER.warn("Unable to load white-disc YouTube video {}: {}", videoId,
+					exception.getMessage());
+				client.execute(() -> fail(client, key, request));
+			}
+		});
+	}
+
+	private static void acceptTrack(Minecraft client, BlockPos pos, long request, AudioTrack track) {
+		long key = pos.asLong();
+		if (REQUESTS.getOrDefault(key, -1L) != request) return;
+		if (!validTarget(client, pos)) {
+			REQUESTS.remove(key);
+			return;
+		}
+		if (track.getInfo().isStream || track.getDuration() <= 0L
+			|| track.getDuration() > MAXIMUM_TRACK_MILLIS) {
+			REQUESTS.remove(key);
+			if (client.player != null) client.player.sendOverlayMessage(
+				Component.translatable("message.ambiance.white_disc.too_long"));
+			return;
+		}
+		while (PLAYBACKS.size() >= MAXIMUM_SIMULTANEOUS_DISCS) {
+			stop(PLAYBACKS.keySet().iterator().next());
+		}
+		ChannelAccess channels = ((SoundEngineAccessor) ((SoundManagerAccessor) client.getSoundManager())
+			.ambiance$getSoundEngine()).ambiance$getChannelAccess();
+		channels.createHandle(Library.Pool.STREAMING).thenAccept(handle -> client.execute(() -> {
+			if (handle == null || REQUESTS.getOrDefault(key, -1L) != request
+				|| !validTarget(client, pos)) {
+				if (handle != null) handle.execute(channel -> channel.stop());
+				if (REQUESTS.getOrDefault(key, -1L) == request) REQUESTS.remove(key);
+				return;
+			}
+			AudioPlayer player = MANAGER.createPlayer();
+			LavaplayerAudioStream stream = new LavaplayerAudioStream(player);
+			Playback playback = new Playback(pos.immutable(), client.level.dimension(), handle, stream);
+			PLAYBACKS.put(key, playback);
+			REQUESTS.remove(key);
+			player.addListener(new AudioEventAdapter() {
+				@Override
+				public void onTrackException(AudioPlayer failedPlayer, AudioTrack failedTrack,
+					FriendlyException exception) {
+					AmbianceMod.LOGGER.warn("White-disc playback failed for YouTube video {}: {}",
+						failedTrack.getIdentifier(), exception.getMessage());
+					client.execute(() -> failPlayback(client, key, failedPlayer));
+				}
+
+				@Override
+				public void onTrackStuck(AudioPlayer stuckPlayer, AudioTrack stuckTrack,
+					long thresholdMs) {
+					AmbianceMod.LOGGER.warn("White-disc playback stalled for YouTube video {} after {} ms",
+						stuckTrack.getIdentifier(), thresholdMs);
+					client.execute(() -> failPlayback(client, key, stuckPlayer));
+				}
+			});
+			player.playTrack(track);
+			float volume = client.options.getFinalSoundSourceVolume(SoundSource.RECORDS);
+			handle.execute(channel -> {
+				try {
+					channel.setSelfPosition(Vec3.atCenterOf(pos));
+					channel.setRelative(false);
+					channel.setPitch(1.0F);
+					channel.linearAttenuation(ATTENUATION_DISTANCE);
+					channel.setVolume(volume);
+					channel.attachBufferStream(stream);
+					channel.play();
+				} catch (RuntimeException | LinkageError exception) {
+					AmbianceMod.LOGGER.error("Unable to attach white-disc audio to Minecraft's sound engine",
+						exception);
+					client.execute(() -> failPlayback(client, key, player));
+				}
+			});
+			if (client.player != null) client.player.sendOverlayMessage(
+				Component.translatable("message.ambiance.white_disc.playing", track.getInfo().title));
+		}));
+	}
+
+	private static void fail(Minecraft client, long key, long request) {
+		if (REQUESTS.getOrDefault(key, -1L) != request) return;
+		REQUESTS.remove(key);
+		if (client.player != null) client.player.sendOverlayMessage(
+			Component.translatable("message.ambiance.white_disc.failed"));
+	}
+
+	private static void failPlayback(Minecraft client, long key, AudioPlayer player) {
+		Playback playback = PLAYBACKS.get(key);
+		if (playback == null || !playback.stream().uses(player)) return;
+		stop(key);
+		if (client.player != null) client.player.sendOverlayMessage(
+			Component.translatable("message.ambiance.white_disc.failed"));
+	}
+
+	public static void stop(BlockPos pos) {
+		stop(pos.asLong());
+	}
+
+	private static void stop(long key) {
+		PENDING_STARTS.remove(key);
+		REQUESTS.remove(key);
+		Playback playback = PLAYBACKS.remove(key);
+		if (playback == null) return;
+		playback.stream().close();
+		playback.handle().execute(channel -> channel.stop());
+	}
+
+	public static void tick(Minecraft client) {
+		if (client.level == null) {
+			clear();
+			return;
+		}
+		tickPendingStarts(client);
+		long now = System.nanoTime();
+		for (Map.Entry<Long, Playback> entry : Map.copyOf(PLAYBACKS).entrySet()) {
+			Playback playback = entry.getValue();
+			boolean missing = !client.level.dimension().equals(playback.dimension())
+				|| !client.level.hasChunkAt(playback.pos())
+				|| !client.level.getBlockState(playback.pos()).is(Blocks.JUKEBOX)
+				|| !client.level.getBlockState(playback.pos()).getValue(JukeboxBlock.HAS_RECORD);
+			if (missing || playback.finishedFor(now) >= FINISHED_GRACE_NANOS) {
+				stop(entry.getKey());
+				continue;
+			}
+			float volume = client.options.getFinalSoundSourceVolume(SoundSource.RECORDS);
+			playback.handle().execute(channel -> channel.setVolume(volume));
+		}
+	}
+
+	public static void clear() {
+		PENDING_STARTS.clear();
+		REQUESTS.clear();
+		for (long key : PLAYBACKS.keySet().stream().mapToLong(Long::longValue).toArray()) stop(key);
+	}
+
+	public static void shutdown() {
+		if (shutdown) return;
+		shutdown = true;
+		clear();
+		MANAGER.shutdown();
+	}
+
+	private static DefaultAudioPlayerManager createManager() {
+		DefaultAudioPlayerManager manager = new DefaultAudioPlayerManager();
+		manager.getConfiguration().setOutputFormat(
+			new Pcm16AudioDataFormat(1, LavaplayerAudioStream.SAMPLE_RATE, 960, false));
+		manager.setFrameBufferDuration(5_000);
+		manager.setItemLoaderThreadPoolSize(2);
+		manager.registerSourceManager(new YoutubeAudioSourceManager(false, new Ios()));
+		return manager;
+	}
+
+	private static boolean validTarget(Minecraft client, BlockPos pos) {
+		return validJukeboxTarget(client, pos)
+			&& client.level.getBlockState(pos).getValue(JukeboxBlock.HAS_RECORD);
+	}
+
+	private static boolean validJukeboxTarget(Minecraft client, BlockPos pos) {
+		return client.player != null && client.level != null
+			&& client.player.distanceToSqr(Vec3.atCenterOf(pos))
+				<= ATTENUATION_DISTANCE * ATTENUATION_DISTANCE * 4.0D
+			&& client.level.getBlockState(pos).is(Blocks.JUKEBOX);
+	}
+
+	private static void tickPendingStarts(Minecraft client) {
+		for (Map.Entry<Long, PendingStart> entry : Map.copyOf(PENDING_STARTS).entrySet()) {
+			long key = entry.getKey();
+			PendingStart pending = entry.getValue();
+			if (!client.level.dimension().equals(pending.dimension())
+				|| !validJukeboxTarget(client, pending.pos())) {
+				PENDING_STARTS.remove(key);
+				continue;
+			}
+			if (validTarget(client, pending.pos())) {
+				PENDING_STARTS.remove(key);
+				startLoading(client, pending.pos(), pending.videoId());
+				continue;
+			}
+			if (pending.ticksRemaining() <= 1) {
+				PENDING_STARTS.remove(key);
+				if (client.player != null) client.player.sendOverlayMessage(
+					Component.translatable("message.ambiance.white_disc.failed"));
+				continue;
+			}
+			PENDING_STARTS.put(key, pending.waitOneTick());
+		}
+	}
+
+	private record PendingStart(BlockPos pos, ResourceKey<Level> dimension, String videoId,
+		int ticksRemaining) {
+		private PendingStart waitOneTick() {
+			return new PendingStart(pos, dimension, videoId, ticksRemaining - 1);
+		}
+	}
+
+	private record Playback(BlockPos pos, ResourceKey<Level> dimension,
+		ChannelAccess.ChannelHandle handle,
+		LavaplayerAudioStream stream, long[] finishedAt) {
+		private Playback(BlockPos pos, ResourceKey<Level> dimension,
+			ChannelAccess.ChannelHandle handle, LavaplayerAudioStream stream) {
+			this(pos, dimension, handle, stream, new long[1]);
+		}
+
+		private long finishedFor(long now) {
+			if (!stream.ended()) return 0L;
+			if (finishedAt[0] == 0L) finishedAt[0] = now;
+			return now - finishedAt[0];
+		}
+	}
+}
@@ -0,0 +1,23 @@
+package fr.koka99cab.sanctuary26.ambiance.item;
+
+import java.util.function.Consumer;
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.chat.Component;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.item.component.TooltipDisplay;
+
+/** Blank disc whose custom name may hold a validated YouTube URL. */
+public final class WhiteDiscItem extends Item {
+	public WhiteDiscItem(Properties properties) {
+		super(properties);
+	}
+
+	@Override
+	public void appendHoverText(ItemStack stack, TooltipContext context, TooltipDisplay display,
+		Consumer<Component> tooltip, TooltipFlag flag) {
+		tooltip.accept(Component.translatable("tooltip.ambiance.white_disc")
+			.withStyle(ChatFormatting.GRAY));
+	}
+}
@@ -0,0 +1,17 @@
+package fr.koka99cab.sanctuary26.ambiance.mixin.client;
+
+import fr.koka99cab.sanctuary26.ambiance.client.audio.WhiteDiscAudioPlayer;
+import net.minecraft.client.renderer.LevelEventHandler;
+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;
+
+@Mixin(LevelEventHandler.class)
+public abstract class LevelEventHandlerMixin {
+	@Inject(method = "levelEvent", at = @At("HEAD"))
+	private void ambiance$stopWhiteDisc(int type, BlockPos pos, int data, CallbackInfo callback) {
+		if (type == 1011) WhiteDiscAudioPlayer.stop(pos);
+	}
+}
@@ -0,0 +1,12 @@
+package fr.koka99cab.sanctuary26.ambiance.mixin.client;
+
+import net.minecraft.client.sounds.ChannelAccess;
+import net.minecraft.client.sounds.SoundEngine;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(SoundEngine.class)
+public interface SoundEngineAccessor {
+	@Accessor("channelAccess")
+	ChannelAccess ambiance$getChannelAccess();
+}
@@ -0,0 +1,12 @@
+package fr.koka99cab.sanctuary26.ambiance.mixin.client;
+
+import net.minecraft.client.sounds.SoundEngine;
+import net.minecraft.client.sounds.SoundManager;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(SoundManager.class)
+public interface SoundManagerAccessor {
+	@Accessor("soundEngine")
+	SoundEngine ambiance$getSoundEngine();
+}
@@ -13,7 +13,7 @@ import net.minecraft.server.level.ServerPlayer;
 * Networking contract for Ambiance. Payload IDs must use the module namespace.
 */
 public final class AmbianceNetworking {
-	public static final int PROTOCOL_VERSION = 5;
+	public static final int PROTOCOL_VERSION = 6;
 	private static boolean initialized;

 	private AmbianceNetworking() {
@@ -34,6 +34,8 @@ public final class AmbianceNetworking {
 			AmbianceCanapliaVisualPayloads.BadTrip.ID, AmbianceCanapliaVisualPayloads.BadTrip.CODEC);
 		PayloadTypeRegistry.clientboundPlay().register(
 			AmbianceCanapliaVisualPayloads.Clear.ID, AmbianceCanapliaVisualPayloads.Clear.CODEC);
+		PayloadTypeRegistry.clientboundPlay().register(
+			WhiteDiscPlaybackPayload.ID, WhiteDiscPlaybackPayload.CODEC);
 		ServerPlayConnectionEvents.JOIN.register((handler, sender, server) ->
 			send(handler.player, AmbianceEnvironmentController.snapshot(server))
 		);
@@ -0,0 +1,34 @@
+package fr.koka99cab.sanctuary26.ambiance.network;
+
+import fr.koka99cab.sanctuary26.ambiance.AmbianceMod;
+import fr.koka99cab.sanctuary26.ambiance.white_disc.WhiteDiscUrl;
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+
+/** Bounded clientbound intent: a server-resolved jukebox position and an 11-character video ID. */
+public record WhiteDiscPlaybackPayload(BlockPos pos, String videoId) implements CustomPacketPayload {
+	public static final Type<WhiteDiscPlaybackPayload> ID =
+		new Type<>(AmbianceMod.id("white_disc_playback"));
+	public static final StreamCodec<RegistryFriendlyByteBuf, WhiteDiscPlaybackPayload> CODEC =
+		CustomPacketPayload.codec(WhiteDiscPlaybackPayload::write, WhiteDiscPlaybackPayload::new);
+
+	public WhiteDiscPlaybackPayload {
+		if (!WhiteDiscUrl.validVideoId(videoId)) videoId = "";
+	}
+
+	private WhiteDiscPlaybackPayload(RegistryFriendlyByteBuf buffer) {
+		this(buffer.readBlockPos(), buffer.readUtf(WhiteDiscUrl.VIDEO_ID_LENGTH));
+	}
+
+	private void write(RegistryFriendlyByteBuf buffer) {
+		buffer.writeBlockPos(pos);
+		buffer.writeUtf(videoId, WhiteDiscUrl.VIDEO_ID_LENGTH);
+	}
+
+	@Override
+	public Type<? extends CustomPacketPayload> type() {
+		return ID;
+	}
+}
@@ -1,12 +1,32 @@
 package fr.koka99cab.sanctuary26.ambiance.registry;

 import fr.koka99cab.sanctuary26.ambiance.AmbianceMod;
+import fr.koka99cab.sanctuary26.ambiance.item.WhiteDiscItem;
+import net.fabricmc.fabric.api.creativetab.v1.CreativeModeTabEvents;
+import net.minecraft.core.Registry;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.Identifier;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.world.item.CreativeModeTab;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.JukeboxSong;
+import net.minecraft.world.item.Rarity;

 /**
 * Single registration entry point for the Ambiance namespace.
 * Feature registries must be called from here to keep initialization ordering explicit.
 */
 public final class AmbianceRegistries {
+	public static final ResourceKey<JukeboxSong> WHITE_DISC_SONG = ResourceKey.create(
+		Registries.JUKEBOX_SONG, AmbianceMod.id("white_disc"));
+	private static final ResourceKey<Item> WHITE_DISC_KEY = ResourceKey.create(
+		Registries.ITEM, AmbianceMod.id("white_disc"));
+	private static final ResourceKey<CreativeModeTab> TOOLS_TAB = ResourceKey.create(
+		Registries.CREATIVE_MODE_TAB, Identifier.withDefaultNamespace("tools_and_utilities"));
+	public static final Item WHITE_DISC = Registry.register(BuiltInRegistries.ITEM, WHITE_DISC_KEY,
+		new WhiteDiscItem(new Item.Properties().stacksTo(1).rarity(Rarity.UNCOMMON)
+			.jukeboxPlayable(WHITE_DISC_SONG).setId(WHITE_DISC_KEY)));
 	private static boolean initialized;

 	private AmbianceRegistries() {
@@ -17,7 +37,8 @@ public final class AmbianceRegistries {
 			return;
 		}
 		initialized = true;
-		AmbianceMod.LOGGER.debug("[{}] Empty registry hub initialized.", AmbianceMod.DISPLAY_NAME);
+		CreativeModeTabEvents.modifyOutputEvent(TOOLS_TAB).register(entries -> entries.accept(WHITE_DISC));
+		AmbianceMod.LOGGER.debug("[{}] Registry hub initialized with the white disc.",
+			AmbianceMod.DISPLAY_NAME);
 	}
 }
-
@@ -0,0 +1,70 @@
+package fr.koka99cab.sanctuary26.ambiance.white_disc;
+
+import fr.koka99cab.sanctuary26.ambiance.network.WhiteDiscPlaybackPayload;
+import fr.koka99cab.sanctuary26.ambiance.registry.AmbianceRegistries;
+import java.util.LinkedHashSet;
+import java.util.Optional;
+import java.util.Set;
+import net.fabricmc.fabric.api.event.player.UseBlockCallback;
+import net.fabricmc.fabric.api.networking.v1.PlayerLookup;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.component.DataComponents;
+import net.minecraft.network.chat.Component;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.JukeboxPlayable;
+import net.minecraft.world.level.block.JukeboxBlock;
+import net.minecraft.world.level.block.entity.JukeboxBlockEntity;
+
+/** Server-authoritative insertion and bounded playback dispatch for the white disc. */
+public final class WhiteDiscService {
+	private static boolean initialized;
+
+	private WhiteDiscService() {
+	}
+
+	public static void initialize() {
+		if (initialized) return;
+		initialized = true;
+		UseBlockCallback.EVENT.register((player, level, hand, hit) -> {
+			BlockPos pos = hit.getBlockPos();
+			if (!(level.getBlockEntity(pos) instanceof JukeboxBlockEntity jukebox)
+				|| jukebox.getBlockState().getValue(JukeboxBlock.HAS_RECORD)) return InteractionResult.PASS;
+			ItemStack held = player.getItemInHand(hand);
+			if (!held.is(AmbianceRegistries.WHITE_DISC)) return InteractionResult.PASS;
+
+			Optional<String> videoId = videoId(held);
+			if (videoId.isEmpty()) {
+				if (!level.isClientSide()) player.sendOverlayMessage(
+					Component.translatable("message.ambiance.white_disc.invalid_url"));
+				return InteractionResult.FAIL;
+			}
+			if (level.isClientSide()) return InteractionResult.SUCCESS;
+			InteractionResult result = JukeboxPlayable.tryInsertIntoJukebox(level, pos, held, player);
+			if (result.consumesAction() && level instanceof ServerLevel serverLevel) {
+				broadcast(serverLevel, pos, videoId.get(), player instanceof ServerPlayer serverPlayer
+					? serverPlayer : null);
+			}
+			return result;
+		});
+	}
+
+	public static Optional<String> videoId(ItemStack stack) {
+		Component name = stack.get(DataComponents.CUSTOM_NAME);
+		return name == null ? Optional.empty() : WhiteDiscUrl.videoId(name.getString());
+	}
+
+	private static void broadcast(ServerLevel level, BlockPos pos, String videoId, ServerPlayer inserter) {
+		WhiteDiscPlaybackPayload payload = new WhiteDiscPlaybackPayload(pos, videoId);
+		Set<ServerPlayer> receivers = new LinkedHashSet<>(PlayerLookup.tracking(level, pos));
+		if (inserter != null) receivers.add(inserter);
+		for (ServerPlayer receiver : receivers) {
+			if (ServerPlayNetworking.canSend(receiver, WhiteDiscPlaybackPayload.ID)) {
+				ServerPlayNetworking.send(receiver, payload);
+			}
+		}
+	}
+}
@@ -0,0 +1,74 @@
+package fr.koka99cab.sanctuary26.ambiance.white_disc;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.Locale;
+import java.util.Optional;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+/** Strict, side-effect-free YouTube URL parser used before any client network request. */
+public final class WhiteDiscUrl {
+	public static final int MAXIMUM_URL_LENGTH = 256;
+	public static final int VIDEO_ID_LENGTH = 11;
+	private static final Pattern VIDEO_ID = Pattern.compile("[A-Za-z0-9_-]{11}");
+	private static final Set<String> LONG_HOSTS = Set.of(
+		"youtube.com", "www.youtube.com", "m.youtube.com", "music.youtube.com");
+
+	private WhiteDiscUrl() {
+	}
+
+	public static Optional<String> videoId(String value) {
+		if (value == null || value.isBlank() || value.length() > MAXIMUM_URL_LENGTH) return Optional.empty();
+		try {
+			URI uri = new URI(value.strip());
+			if (!"https".equalsIgnoreCase(uri.getScheme()) || uri.getUserInfo() != null
+				|| (uri.getPort() != -1 && uri.getPort() != 443)) return Optional.empty();
+			String host = uri.getHost();
+			if (host == null) return Optional.empty();
+			host = host.toLowerCase(Locale.ROOT);
+			if ("youtu.be".equals(host)) return valid(singlePathSegment(uri.getRawPath()));
+			if (!LONG_HOSTS.contains(host)) return Optional.empty();
+
+			String path = uri.getRawPath();
+			if ("/watch".equals(path)) return valid(queryParameter(uri.getRawQuery(), "v"));
+			for (String prefix : new String[] {"/shorts/", "/embed/", "/live/"}) {
+				if (path != null && path.startsWith(prefix)) return valid(singlePathSegment(path.substring(prefix.length())));
+			}
+		} catch (URISyntaxException ignored) {
+			// Invalid user text is rejected without network access.
+		}
+		return Optional.empty();
+	}
+
+	public static boolean validVideoId(String value) {
+		return value != null && VIDEO_ID.matcher(value).matches();
+	}
+
+	public static String canonicalUrl(String videoId) {
+		if (!validVideoId(videoId)) throw new IllegalArgumentException("Invalid YouTube video ID");
+		return "https://www.youtube.com/watch?v=" + videoId;
+	}
+
+	private static String singlePathSegment(String path) {
+		if (path == null || path.isEmpty()) return "";
+		String segment = path.startsWith("/") ? path.substring(1) : path;
+		return segment.contains("/") ? "" : segment;
+	}
+
+	private static String queryParameter(String query, String name) {
+		if (query == null) return "";
+		String found = null;
+		for (String parameter : query.split("&", -1)) {
+			int equals = parameter.indexOf('=');
+			if (equals <= 0 || !name.equals(parameter.substring(0, equals))) continue;
+			if (found != null) return "";
+			found = parameter.substring(equals + 1);
+		}
+		return found == null ? "" : found;
+	}
+
+	private static Optional<String> valid(String candidate) {
+		return validVideoId(candidate) ? Optional.of(candidate) : Optional.empty();
+	}
+}
@@ -11,6 +11,9 @@
 		"GameRendererMixin",
 		"LightCoordsUtilMixin",
 		"LightmapRenderStateExtractorMixin",
+		"LevelEventHandlerMixin",
+		"SoundEngineAccessor",
+		"SoundManagerAccessor",
 		"SkyRendererMixin"
 	],
 	"injectors": {
@@ -0,0 +1,6 @@
+{
+  "model": {
+    "type": "minecraft:model",
+    "model": "ambiance:item/white_disc"
+  }
+}
@@ -24,5 +24,13 @@
 	"options.ambiance.visual.wobble": "Camera wobble",
 	"options.ambiance.visual.ghosting": "Edge ghosting",
 	"key.categories.ambiance.ambiance": "Ambiance",
-	"key.ambiance.visual_settings": "Visual accessibility settings"
+	"key.ambiance.visual_settings": "Visual accessibility settings",
+	"item.ambiance.white_disc": "White Disc",
+	"jukebox_song.ambiance.white_disc": "White Disc",
+	"tooltip.ambiance.white_disc": "Rename it to an HTTPS YouTube URL, then insert it into a jukebox.",
+	"message.ambiance.white_disc.invalid_url": "Rename the white disc to a valid HTTPS YouTube URL.",
+	"message.ambiance.white_disc.loading": "Loading YouTube video…",
+	"message.ambiance.white_disc.playing": "Now playing: %s",
+	"message.ambiance.white_disc.failed": "This YouTube video could not be played.",
+	"message.ambiance.white_disc.too_long": "This video is live or longer than 30 minutes."
 }
@@ -24,5 +24,13 @@
 	"options.ambiance.visual.wobble": "Oscillation de la caméra",
 	"options.ambiance.visual.ghosting": "Rémanence sur les bords",
 	"key.categories.ambiance.ambiance": "Ambiance",
-	"key.ambiance.visual_settings": "Réglages d’accessibilité visuelle"
+	"key.ambiance.visual_settings": "Réglages d’accessibilité visuelle",
+	"item.ambiance.white_disc": "Disque blanc",
+	"jukebox_song.ambiance.white_disc": "Disque blanc",
+	"tooltip.ambiance.white_disc": "Renommez-le avec une URL YouTube HTTPS, puis insérez-le dans un jukebox.",
+	"message.ambiance.white_disc.invalid_url": "Renommez le disque blanc avec une URL YouTube HTTPS valide.",
+	"message.ambiance.white_disc.loading": "Chargement de la vidéo YouTube…",
+	"message.ambiance.white_disc.playing": "Lecture : %s",
+	"message.ambiance.white_disc.failed": "Impossible de lire cette vidéo YouTube.",
+	"message.ambiance.white_disc.too_long": "Cette vidéo est en direct ou dépasse 30 minutes."
 }
@@ -24,5 +24,13 @@
 	"options.ambiance.visual.wobble": "Покачивание камеры",
 	"options.ambiance.visual.ghosting": "Шлейф по краям",
 	"key.categories.ambiance.ambiance": "Ambiance",
-	"key.ambiance.visual_settings": "Настройки визуальной доступности"
+	"key.ambiance.visual_settings": "Настройки визуальной доступности",
+	"item.ambiance.white_disc": "Белая пластинка",
+	"jukebox_song.ambiance.white_disc": "Белая пластинка",
+	"tooltip.ambiance.white_disc": "Переименуйте её в HTTPS-ссылку YouTube и вставьте в проигрыватель.",
+	"message.ambiance.white_disc.invalid_url": "Переименуйте белую пластинку в допустимую HTTPS-ссылку YouTube.",
+	"message.ambiance.white_disc.loading": "Загрузка видео YouTube…",
+	"message.ambiance.white_disc.playing": "Сейчас играет: %s",
+	"message.ambiance.white_disc.failed": "Не удалось воспроизвести это видео YouTube.",
+	"message.ambiance.white_disc.too_long": "Это прямая трансляция или видео длиннее 30 минут."
 }
@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/template_music_disc",
+  "textures": {
+    "layer0": "ambiance:item/white_disc"
+  }
+}
@@ -0,0 +1,8 @@
+{
+  "comparator_output": 15,
+  "description": {
+    "translate": "jukebox_song.ambiance.white_disc"
+  },
+  "length_in_seconds": 1800.0,
+  "sound_event": "minecraft:intentionally_empty"
+}
@@ -0,0 +1,16 @@
+{
+  "type": "minecraft:crafting_shaped",
+  "category": "misc",
+  "pattern": [
+    "WWW",
+    "WDW",
+    "WWW"
+  ],
+  "key": {
+    "D": "minecraft:music_disc_13",
+    "W": "minecraft:white_dye"
+  },
+  "result": {
+    "id": "ambiance:white_disc"
+  }
+}
@@ -3,7 +3,7 @@
 	"id": "ambiance",
 	"version": "${version}",
 	"name": "Ambiance",
-	"description": "Owns world atmosphere, dynamic lights, the calendar and composable accessible visual effects, including Canaplia.",
+	"description": "Owns world atmosphere, dynamic lights, positional audio, the calendar and composable accessible visual effects, including Canaplia.",
 	"authors": [
 		"KOKA99CAB"
 	],
@@ -36,13 +36,13 @@
 			"system_type": "gameplay-system",
 			"namespace": "ambiance",
 			"data_version": 2,
-			"network_protocol": 5,
+			"network_protocol": 6,
 			"lifecycle": "${lifecycle}",
 			"pack_version": "${pack_version}",
 			"descriptions": {
-				"fr_fr": "Gère l'atmosphère, les lumières dynamiques, le calendrier et les effets visuels accessibles et composables, dont Canaplia.",
-				"en_us": "Owns world atmosphere, dynamic lights, the calendar and composable accessible visual effects, including Canaplia.",
-				"ru_ru": "Управляет атмосферой, динамическим освещением, календарём и доступными составными визуальными эффектами, включая Canaplia."
+				"fr_fr": "Gère l'atmosphère, les lumières dynamiques, l'audio positionnel, le calendrier et les effets visuels accessibles et composables, dont Canaplia.",
+				"en_us": "Owns world atmosphere, dynamic lights, positional audio, the calendar and composable accessible visual effects, including Canaplia.",
+				"ru_ru": "Управляет атмосферой, динамическим освещением, позиционным звуком, календарём и доступными составными визуальными эффектами, включая Canaplia."
 			}
 		}
 	}
@@ -0,0 +1,80 @@
+package fr.koka99cab.sanctuary26.ambiance.client.audio;
+
+import com.sedmelluq.discord.lavaplayer.format.Pcm16AudioDataFormat;
+import com.sedmelluq.discord.lavaplayer.player.AudioPlayer;
+import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame;
+import com.sedmelluq.discord.lavaplayer.track.playback.ImmutableAudioFrame;
+import java.lang.reflect.Proxy;
+import java.nio.ByteBuffer;
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Queue;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/** Deterministic check for Minecraft's four one-second streaming buffers. */
+public final class LavaplayerAudioStreamSmoke {
+	private static final int FRAME_SAMPLES = 960;
+	private static final int FRAME_BYTES = FRAME_SAMPLES * 2;
+	private static final int FRAMES_PER_SECOND = LavaplayerAudioStream.SAMPLE_RATE / FRAME_SAMPLES;
+
+	private LavaplayerAudioStreamSmoke() {
+	}
+
+	public static void main(String[] args) throws Exception {
+		Queue<AudioFrame> frames = new ArrayDeque<>();
+		Pcm16AudioDataFormat format = new Pcm16AudioDataFormat(
+			1, LavaplayerAudioStream.SAMPLE_RATE, FRAME_SAMPLES, false);
+		for (int index = 0; index < FRAMES_PER_SECOND; index++) {
+			byte[] data = new byte[FRAME_BYTES];
+			Arrays.fill(data, (byte) (index + 1));
+			frames.add(new ImmutableAudioFrame(index * 20L, data, 100, format));
+		}
+
+		AtomicInteger timedProvides = new AtomicInteger();
+		AtomicInteger nonBlockingProvides = new AtomicInteger();
+		AtomicBoolean destroyed = new AtomicBoolean();
+		AudioPlayer player = (AudioPlayer) Proxy.newProxyInstance(
+			AudioPlayer.class.getClassLoader(), new Class<?>[] {AudioPlayer.class},
+			(proxy, method, arguments) -> switch (method.getName()) {
+				case "provide" -> {
+					if (method.getParameterCount() == 2) {
+						timedProvides.incrementAndGet();
+						yield frames.poll();
+					}
+					nonBlockingProvides.incrementAndGet();
+					yield null;
+				}
+				case "destroy" -> {
+					destroyed.set(true);
+					yield null;
+				}
+				case "getPlayingTrack" -> null;
+				case "getVolume" -> 100;
+				case "isPaused", "startTrack" -> false;
+				default -> null;
+			});
+
+		LavaplayerAudioStream stream = new LavaplayerAudioStream(player);
+		ByteBuffer pcm = stream.read(LavaplayerAudioStream.SAMPLE_RATE * 2);
+		if (pcm == null || pcm.remaining() != LavaplayerAudioStream.SAMPLE_RATE * 2) {
+			throw new IllegalStateException("The stream did not fill Minecraft's one-second buffer");
+		}
+		while (pcm.hasRemaining()) {
+			if (pcm.get() == 0) {
+				throw new IllegalStateException("The stream padded available PCM with silence");
+			}
+		}
+		if (timedProvides.get() != FRAMES_PER_SECOND || nonBlockingProvides.get() != 0) {
+			throw new IllegalStateException("PCM frames were not read with bounded waits");
+		}
+		if (stream.getFormat().getSampleRate() != LavaplayerAudioStream.SAMPLE_RATE
+			|| stream.getFormat().isBigEndian()) {
+			throw new IllegalStateException("The OpenAL PCM format is not 48 kHz little-endian");
+		}
+		stream.close();
+		if (!destroyed.get()) {
+			throw new IllegalStateException("Closing the stream did not destroy its player");
+		}
+	}
+}
@@ -0,0 +1,93 @@
+package fr.koka99cab.sanctuary26.ambiance.client.audio;
+
+import com.sedmelluq.discord.lavaplayer.format.Pcm16AudioDataFormat;
+import com.sedmelluq.discord.lavaplayer.player.AudioLoadResultHandler;
+import com.sedmelluq.discord.lavaplayer.player.AudioPlayer;
+import com.sedmelluq.discord.lavaplayer.player.DefaultAudioPlayerManager;
+import com.sedmelluq.discord.lavaplayer.tools.FriendlyException;
+import com.sedmelluq.discord.lavaplayer.track.AudioPlaylist;
+import com.sedmelluq.discord.lavaplayer.track.AudioTrack;
+import dev.lavalink.youtube.YoutubeAudioSourceManager;
+import dev.lavalink.youtube.clients.Ios;
+import java.nio.ByteBuffer;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
+
+/** Manual network smoke test for the exact YouTube playback path used by white discs. */
+public final class WhiteDiscPlaybackSmoke {
+	private static final String VIDEO_URL = "https://www.youtube.com/watch?v=Ue5ZBe-GzSM";
+
+	private WhiteDiscPlaybackSmoke() {
+	}
+
+	public static void main(String[] args) throws Exception {
+		DefaultAudioPlayerManager manager = new DefaultAudioPlayerManager();
+		manager.getConfiguration().setOutputFormat(
+			new Pcm16AudioDataFormat(1, LavaplayerAudioStream.SAMPLE_RATE, 960, false));
+		manager.registerSourceManager(new YoutubeAudioSourceManager(false, new Ios()));
+		try {
+			AudioTrack track = load(manager).get(30, TimeUnit.SECONDS);
+			AudioPlayer player = manager.createPlayer();
+			player.playTrack(track);
+			LavaplayerAudioStream stream = new LavaplayerAudioStream(player);
+			int decodedBytes = 0;
+			int totalBytes = 0;
+			for (int index = 0; index < 4; index++) {
+				ByteBuffer pcm = stream.read(LavaplayerAudioStream.SAMPLE_RATE * 2);
+				if (pcm == null) break;
+				while (pcm.hasRemaining()) {
+					totalBytes++;
+					if (pcm.get() != 0) decodedBytes++;
+				}
+			}
+			if (decodedBytes == 0) {
+				throw new IllegalStateException("YouTube playback produced no audible PCM data");
+			}
+			double audibleRatio = (double) decodedBytes / totalBytes;
+			if (totalBytes != LavaplayerAudioStream.SAMPLE_RATE * 2 * 4) {
+				throw new IllegalStateException("YouTube playback did not fill four PCM seconds");
+			}
+			if (audibleRatio < 0.75) {
+				throw new IllegalStateException("YouTube PCM stream was mostly silence: "
+					+ Math.round(audibleRatio * 100.0) + "% audible bytes");
+			}
+			System.out.printf("Decoded audible PCM data: %.1f%% at %.0f Hz from %s%n",
+				audibleRatio * 100.0, stream.getFormat().getSampleRate(), track.getInfo().title);
+			stream.close();
+		} finally {
+			manager.shutdown();
+		}
+	}
+
+	private static CompletableFuture<AudioTrack> load(DefaultAudioPlayerManager manager) {
+		CompletableFuture<AudioTrack> result = new CompletableFuture<>();
+		manager.loadItem(VIDEO_URL, new AudioLoadResultHandler() {
+			@Override
+			public void trackLoaded(AudioTrack track) {
+				result.complete(track);
+			}
+
+			@Override
+			public void playlistLoaded(AudioPlaylist playlist) {
+				AudioTrack selected = playlist.getSelectedTrack();
+				if (selected == null && !playlist.getTracks().isEmpty()) {
+					selected = playlist.getTracks().getFirst();
+				}
+				if (selected == null) result.completeExceptionally(
+					new IllegalStateException("YouTube playlist contained no track"));
+				else result.complete(selected);
+			}
+
+			@Override
+			public void noMatches() {
+				result.completeExceptionally(new IllegalStateException("YouTube returned no match"));
+			}
+
+			@Override
+			public void loadFailed(FriendlyException exception) {
+				result.completeExceptionally(exception);
+			}
+		});
+		return result;
+	}
+}
@@ -0,0 +1,42 @@
+package fr.koka99cab.sanctuary26.ambiance.white_disc;
+
+/** Executable URL-policy regression test, intentionally independent from a running game. */
+public final class WhiteDiscUrlSmoke {
+	private static final String VIDEO_ID = "dQw4w9WgXcQ";
+
+	private WhiteDiscUrlSmoke() {
+	}
+
+	public static void main(String[] args) {
+		require(VIDEO_ID.equals(id("https://www.youtube.com/watch?v=" + VIDEO_ID)), "watch URL rejected");
+		require(VIDEO_ID.equals(id("https://youtu.be/" + VIDEO_ID + "?si=abc")), "short URL rejected");
+		require("Ue5ZBe-GzSM".equals(id("https://youtu.be/Ue5ZBe-GzSM?si=78LSbtBQzUYzhA2Y")),
+			"reported white-disc URL rejected");
+		require(VIDEO_ID.equals(id("https://music.youtube.com/watch?v=" + VIDEO_ID)), "music URL rejected");
+		require(VIDEO_ID.equals(id("https://www.youtube.com/shorts/" + VIDEO_ID)), "shorts URL rejected");
+		require(VIDEO_ID.equals(id("https://www.youtube.com/embed/" + VIDEO_ID)), "embed URL rejected");
+
+		reject("http://www.youtube.com/watch?v=" + VIDEO_ID);
+		reject("https://youtube.example/watch?v=" + VIDEO_ID);
+		reject("https://youtube.com.evil.example/watch?v=" + VIDEO_ID);
+		reject("https://user@www.youtube.com/watch?v=" + VIDEO_ID);
+		reject("https://www.youtube.com:8443/watch?v=" + VIDEO_ID);
+		reject("https://www.youtube.com/watch?v=too_short");
+		reject("https://www.youtube.com/watch?v=" + VIDEO_ID + "&v=" + VIDEO_ID);
+		reject("https://youtu.be/" + VIDEO_ID + "/extra");
+		reject("https://www.youtube.com/watch?v=dQw4w9WgX%63Q");
+		reject("x".repeat(WhiteDiscUrl.MAXIMUM_URL_LENGTH + 1));
+	}
+
+	private static String id(String url) {
+		return WhiteDiscUrl.videoId(url).orElseThrow();
+	}
+
+	private static void reject(String url) {
+		require(WhiteDiscUrl.videoId(url).isEmpty(), "Unsafe URL accepted: " + url);
+	}
+
+	private static void require(boolean condition, String message) {
+		if (!condition) throw new AssertionError(message);
+	}
+}
@@ -12,23 +12,23 @@ fabric_api_version=0.158.0+26.2
 # Standby modules stay at zero until their migration really begins.
 mod_version=0.0.0-alpha.0
 module_lifecycle=standby
-ambiance_version=0.0.0-alpha.14
+ambiance_version=0.0.0-alpha.19
 ambiance_lifecycle=active
-redstoner_version=0.0.0-alpha.10
+redstoner_version=0.0.0-alpha.11
 redstoner_lifecycle=active
 anotherworld_version=0.0.0-alpha.55
 anotherworld_lifecycle=active
-itsalive_version=0.0.0-alpha.34
+itsalive_version=0.0.0-alpha.36
 itsalive_lifecycle=active
-ouch_version=0.0.0-alpha.9
+ouch_version=0.0.0-alpha.10
 ouch_lifecycle=active
 masterkey_version=0.0.0-alpha.8
 masterkey_lifecycle=active
-iliketomoveit_version=0.0.0-alpha.14
+iliketomoveit_version=0.0.0-alpha.15
 iliketomoveit_lifecycle=active
-onlyfun_version=0.0.0-alpha.20
+onlyfun_version=0.0.0-alpha.25
 onlyfun_lifecycle=active
-sanctuary_version=0.0.0-alpha.117
+sanctuary_version=0.0.0-alpha.121
 sanctuary_lifecycle=active
-pack_version=26.2.0-alpha.209
+pack_version=26.2.0-alpha.217
 maven_group=fr.koka99cab.sanctuary26
@@ -16,6 +16,14 @@ tasks.register("waystoneElevatorRulesSmoke", JavaExec) {
 	dependsOn tasks.named("testClasses")
 }

+tasks.register("happyGhastCruiseSpeedSmoke", JavaExec) {
+	group = "verification"
+	description = "Checks the rider-only Happy Ghast cruise-speed multiplier."
+	classpath = sourceSets.test.runtimeClasspath
+	mainClass = "fr.koka99cab.sanctuary26.iliketomoveit.transport.HappyGhastCruiseSpeedSmoke"
+	dependsOn tasks.named("testClasses")
+}
+
 tasks.named("test") {
 	// Runtime contracts are executable smoke tasks, not JUnit engine tests.
 	failOnNoDiscoveredTests = false
@@ -168,6 +176,7 @@ tasks.register("verifyGrappling") {
 			"data/iliketomoveit/loot_table/blocks/pulley_head.json",
 			"data/spiderman/loot_table/blocks/pulley_head.json",
 			"data/minecraft/tags/block/needs_stone_tool.json",
+			"iliketomoveit.mixins.json",
 			"iliketomoveit.client.mixins.json"
 		]
 		def missingResources = requiredResources.findAll { !file("src/main/resources/${it}").isFile() }
@@ -184,10 +193,11 @@ tasks.register("verifyGrappling") {
 		}

 		def manifest = new JsonSlurper().parse(file("src/main/resources/fabric.mod.json"))
-		if (!manifest.mixins?.any { it.config == "iliketomoveit.client.mixins.json" && it.environment == "client" }
+		if (!manifest.mixins?.any { it.config == "iliketomoveit.mixins.json" }
+			|| !manifest.mixins?.any { it.config == "iliketomoveit.client.mixins.json" && it.environment == "client" }
 			|| manifest.custom?.sanctuary26?.data_version != 3
 			|| manifest.custom?.sanctuary26?.network_protocol != 5) {
-			throw new GradleException("Grappling must keep I Like To Move It aggregate data v3/protocol 5 and register its client mixin")
+			throw new GradleException("I Like To Move It must keep aggregate data v3/protocol 5 and register its common/client mixins")
 		}
 		["fr_fr", "en_us", "ru_ru"].each { language ->
 			def translations = new JsonSlurper().parse(file("src/main/resources/assets/iliketomoveit/lang/${language}.json"))
@@ -295,7 +305,7 @@ tasks.register("verifyPortals") {
 		}
 		def atlasCavernsMigration = new JsonSlurper().parse(rootProject.file(
 			"pack/migrations/26.2.0-alpha.149-atlas-caverns-to-alpha.150.json"))
-		if (project.version.toString() != "0.0.0-alpha.14"
+		if (project.version.toString() != "0.0.0-alpha.15"
 			|| atlasCavernsMigration.target?.pack_version != "26.2.0-alpha.150"
 			|| atlasCavernsMigration.target?.modules?.iliketomoveit != "0.0.0-alpha.9"
 			|| atlasCavernsMigration.portals?.active_routes != [
@@ -331,7 +341,7 @@ tasks.register("verifySilverAircraft") {
 		def manifest = new JsonSlurper().parse(file("src/main/resources/fabric.mod.json"))
 		def migration = new JsonSlurper().parse(rootProject.file(
 			"pack/migrations/26.2.0-alpha.184-silver-engineering-to-alpha.185.json"))
-		if (project.version.toString() != "0.0.0-alpha.14"
+		if (project.version.toString() != "0.0.0-alpha.15"
 			|| recipe.pattern != ["PGP", "GCG", "PBP"]
 			|| recipe.key != [B: "anotherworld:silver_block", C: "anotherworld:aircraft_cockpit",
 				G: "anotherworld:silver_gear", P: "anotherworld:silver_plate"]
@@ -360,7 +370,7 @@ tasks.register("verifyGrapplePrediction") {
 		def payload = file("src/main/java/fr/koka99cab/sanctuary26/iliketomoveit/network/GrappleStatePayload.java").text
 		def controller = file("src/main/java/fr/koka99cab/sanctuary26/iliketomoveit/grapple/GrappleController.java").text
 		def prediction = file("src/main/java/fr/koka99cab/sanctuary26/iliketomoveit/client/grapple/ClientGrapplePrediction.java").text
-		if (project.version.toString() != "0.0.0-alpha.14"
+		if (project.version.toString() != "0.0.0-alpha.15"
 			|| migration.target?.modules?.iliketomoveit != "0.0.0-alpha.13"
 			|| migration.grappling?.owner_prediction_payload != "iliketomoveit:s2c/grapple_state"
 			|| migration.compatibility?.iliketomoveit_source_network_protocol != 4
@@ -392,7 +402,7 @@ tasks.register("verifyWaystoneDescendingRelease") {
 			"src/main/java/fr/koka99cab/sanctuary26/iliketomoveit/waystone/WaystoneElevatorRules.java").text
 		def teleportation = file(
 			"src/main/java/fr/koka99cab/sanctuary26/iliketomoveit/network/WaystoneTeleportation.java").text
-		if (project.version.toString() != "0.0.0-alpha.14"
+		if (project.version.toString() != "0.0.0-alpha.15"
 			|| migration.target?.modules?.iliketomoveit != "0.0.0-alpha.14"
 			|| migration.waystone_elevator?.undiscovered_downward_destination_allowed != true
 			|| migration.waystone_elevator?.destination_discovered_after_arrival != true
@@ -411,6 +421,7 @@ tasks.register("verifyWaystoneDescendingRelease") {
 tasks.named("check") {
 	dependsOn tasks.named("grapplePhysicsSmoke")
 	dependsOn tasks.named("waystoneElevatorRulesSmoke")
+	dependsOn tasks.named("happyGhastCruiseSpeedSmoke")
 	dependsOn tasks.named("verifyWaystones")
 	dependsOn tasks.named("verifyGrappling")
 	dependsOn tasks.named("verifyGrapplePrediction")
@@ -0,0 +1,19 @@
+package fr.koka99cab.sanctuary26.iliketomoveit.mixin;
+
+import fr.koka99cab.sanctuary26.iliketomoveit.transport.HappyGhastCruiseSpeed;
+import net.minecraft.world.entity.animal.happyghast.HappyGhast;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.phys.Vec3;
+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.CallbackInfoReturnable;
+
+@Mixin(HappyGhast.class)
+public abstract class HappyGhastMixin {
+	@Inject(method = "getRiddenInput", at = @At("RETURN"), cancellable = true)
+	private void iliketomoveit$boostCruiseSpeed(Player rider, Vec3 input,
+		CallbackInfoReturnable<Vec3> callback) {
+		callback.setReturnValue(HappyGhastCruiseSpeed.boost(callback.getReturnValue()));
+	}
+}
@@ -0,0 +1,15 @@
+package fr.koka99cab.sanctuary26.iliketomoveit.transport;
+
+import net.minecraft.world.phys.Vec3;
+
+/** Keeps the Happy Ghast ride practical without changing its autonomous movement. */
+public final class HappyGhastCruiseSpeed {
+	public static final double RIDER_INPUT_MULTIPLIER = 2.0D;
+
+	private HappyGhastCruiseSpeed() {
+	}
+
+	public static Vec3 boost(Vec3 vanillaInput) {
+		return vanillaInput.scale(RIDER_INPUT_MULTIPLIER);
+	}
+}
@@ -19,6 +19,9 @@
 		]
 	},
 	"mixins": [
+		{
+			"config": "iliketomoveit.mixins.json"
+		},
 		{
 			"config": "iliketomoveit.client.mixins.json",
 			"environment": "client"
@@ -0,0 +1,11 @@
+{
+	"required": true,
+	"package": "fr.koka99cab.sanctuary26.iliketomoveit.mixin",
+	"compatibilityLevel": "JAVA_25",
+	"mixins": [
+		"HappyGhastMixin"
+	],
+	"injectors": {
+		"defaultRequire": 1
+	}
+}
@@ -0,0 +1,27 @@
+package fr.koka99cab.sanctuary26.iliketomoveit.transport;
+
+import net.minecraft.world.phys.Vec3;
+
+/** Regression checks for the rider-only Happy Ghast cruise multiplier. */
+public final class HappyGhastCruiseSpeedSmoke {
+	private HappyGhastCruiseSpeedSmoke() {
+	}
+
+	public static void main(String[] args) {
+		Vec3 vanillaInput = new Vec3(-0.195D, 0.0975D, 0.195D);
+		Vec3 boosted = HappyGhastCruiseSpeed.boost(vanillaInput);
+
+		assertNear(boosted.x, -0.39D, "sideways input");
+		assertNear(boosted.y, 0.195D, "vertical input");
+		assertNear(boosted.z, 0.39D, "forward input");
+		if (!HappyGhastCruiseSpeed.boost(Vec3.ZERO).equals(Vec3.ZERO)) {
+			throw new IllegalStateException("Idle Happy Ghasts must remain idle");
+		}
+	}
+
+	private static void assertNear(double actual, double expected, String label) {
+		if (Math.abs(actual - expected) > 1.0E-12D) {
+			throw new IllegalStateException(label + ": expected " + expected + ", got " + actual);
+		}
+	}
+}
@@ -2,7 +2,7 @@

 It's Alive possède le vivant de Sanctuary. Il enrichit directement le Creeper vanilla et accueille désormais les papillons de Pipallon, les Mooblooms fleuries et les créatures de Real Ghost — baleine volante comprise — sous un référencement unifié `itsalive:*`.

-## Version courante — `0.0.0-alpha.20`
+## Version courante — `0.0.0-alpha.36`

 ## Creepers

@@ -153,7 +153,7 @@ tasks.register("generateCanapliaResources") {
 		writeJson("data/c/tags/item/seeds.json", [replace: false, values: seedIds])
 		writeJson("data/canaplia/tags/item/hemp_buds.json", [replace: false, values: budIds])

-		itemDefinition("codex", "minecraft:item/book")
+		itemDefinition("codex", "minecraft:item/enchanted_book")
 		itemDefinition("codex_page", "minecraft:item/paper")
 		writeJson("data/canaplia/recipe/codex.json", [
 			type: "minecraft:crafting_shaped", category: "misc",
@@ -556,7 +556,7 @@ tasks.register("verifyItsAlive") {
 		def climateSource = file("src/main/java/fr/koka99cab/sanctuary26/itsalive/agriculture/ClimateCropForaging.java").text
 		def pineappleSource = file("src/main/java/fr/koka99cab/sanctuary26/itsalive/agriculture/PineappleItem.java").text
 		def worldgenSource = file("src/main/java/fr/koka99cab/sanctuary26/itsalive/agriculture/ItsAliveAgricultureWorldGeneration.java").text
-		if (project.version.toString() != "0.0.0-alpha.34"
+		if (project.version.toString() != "0.0.0-alpha.36"
 			|| climateMigration.target?.pack_version != "26.2.0-alpha.157"
 			|| climateMigration.target?.modules?.itsalive != "0.0.0-alpha.24"
 			|| !climateSource.contains("PlayerBlockBreakEvents.AFTER.register")
@@ -1313,7 +1313,7 @@ tasks.register("verifyCulinaryReliability") {
 				}
 			}
 		}
-		if (project.version.toString() != "0.0.0-alpha.34"
+		if (project.version.toString() != "0.0.0-alpha.36"
 			|| migration.target?.modules?.itsalive != "0.0.0-alpha.28"
 			|| migration.culinary_fixes?.food_press_contents_destroyed_on_break != true
 			|| migration.culinary_fixes?.comparator_contract?.blocks?.size() != 6
@@ -1351,7 +1351,7 @@ tasks.register("verifyCauldronBatching") {
 		def recipe = file("src/main/java/fr/koka99cab/sanctuary26/itsalive/culinary/recipe/CulinaryProcessRecipe.java").text
 		def cauldron = file("src/main/java/fr/koka99cab/sanctuary26/itsalive/culinary/block/entity/CookingCauldronBlockEntity.java").text
 		def timed = file("src/main/java/fr/koka99cab/sanctuary26/itsalive/culinary/block/entity/AbstractTimedCulinaryBlockEntity.java").text
-		if (project.version.toString() != "0.0.0-alpha.34"
+		if (project.version.toString() != "0.0.0-alpha.36"
 			|| migration.target?.modules?.itsalive != "0.0.0-alpha.29"
 			|| migration.cauldron_batches?.logical_stack_limit != 64
 			|| migration.cauldron_batches?.identity != "same_item_same_components"
@@ -1389,7 +1389,7 @@ tasks.register("verifyFermentationBarrelAutomation") {
 		def partialMatching = file("src/main/java/fr/koka99cab/sanctuary26/itsalive/culinary/recipe/CulinaryPartialMatching.java").text
 		def blockstate = new JsonSlurper().parse(
 			file("src/main/resources/assets/itsalive/blockstates/fermentation_barrel.json"))
-		if (project.version.toString() != "0.0.0-alpha.34"
+		if (project.version.toString() != "0.0.0-alpha.36"
 			|| migration.source?.modules?.itsalive != "0.0.0-alpha.29"
 			|| migration.target?.modules?.itsalive != "0.0.0-alpha.30"
 			|| migration.fermentation_barrel?.maximum_units_per_input_slot != 1
@@ -1437,7 +1437,7 @@ tasks.register("verifyCulinaryLecternRelease") {
 			[(locale): new JsonSlurper().parse(file(
 				"src/main/resources/assets/itsalive/lang/${locale}.json"))]
 		}
-		if (project.version.toString() != "0.0.0-alpha.34"
+		if (project.version.toString() != "0.0.0-alpha.36"
 			|| migration.target?.modules?.itsalive != "0.0.0-alpha.31"
 			|| migration.culinary_lectern?.book_tag != "minecraft:lectern_books"
 			|| migration.culinary_lectern?.owner_catalog_shared_while_placed != true
@@ -1461,9 +1461,79 @@ tasks.register("verifyCulinaryLecternRelease") {
 	}
 }

+tasks.register("verifyCanapliaForbiddenBook") {
+	group = "verification"
+	description = "Checks personal Forbidden Books, random page learning and lectern sharing."
+	dependsOn tasks.named("generateCanapliaResources")
+	inputs.file(file("src/main/java/fr/koka99cab/sanctuary26/itsalive/canaplia/CanapliaKnowledge.java"))
+	inputs.file(file("src/main/java/fr/koka99cab/sanctuary26/itsalive/canaplia/CanapliaKnowledgeData.java"))
+	inputs.file(file("src/main/java/fr/koka99cab/sanctuary26/itsalive/canaplia/CanapliaLectern.java"))
+	inputs.file(file("src/main/java/fr/koka99cab/sanctuary26/itsalive/canaplia/item/CanapliaCodexPageItem.java"))
+	inputs.file(file("src/main/java/fr/koka99cab/sanctuary26/itsalive/canaplia/client/CanapliaCodexScreen.java"))
+	inputs.file(file("src/main/java/fr/koka99cab/sanctuary26/itsalive/registry/ItsAliveDataComponents.java"))
+	inputs.file(file("src/main/resources/data/minecraft/tags/item/lectern_books.json"))
+	inputs.files(fileTree("src/main/resources/assets/canaplia/lang") { include "*.json" })
+	inputs.file(rootProject.file("CANAPLIA.md"))
+
+	doLast {
+		def knowledge = file(
+			"src/main/java/fr/koka99cab/sanctuary26/itsalive/canaplia/CanapliaKnowledge.java").text
+		def knowledgeData = file(
+			"src/main/java/fr/koka99cab/sanctuary26/itsalive/canaplia/CanapliaKnowledgeData.java").text
+		def lectern = file(
+			"src/main/java/fr/koka99cab/sanctuary26/itsalive/canaplia/CanapliaLectern.java").text
+		def pageItem = file(
+			"src/main/java/fr/koka99cab/sanctuary26/itsalive/canaplia/item/CanapliaCodexPageItem.java").text
+		def screen = file(
+			"src/main/java/fr/koka99cab/sanctuary26/itsalive/canaplia/client/CanapliaCodexScreen.java").text
+		def components = file(
+			"src/main/java/fr/koka99cab/sanctuary26/itsalive/registry/ItsAliveDataComponents.java").text
+		def lecternBooks = new JsonSlurper().parse(file(
+			"src/main/resources/data/minecraft/tags/item/lectern_books.json"))
+		def generatedCodex = new JsonSlurper().parse(new File(
+			generatedCanapliaResources.get().asFile, "assets/canaplia/items/codex.json"))
+		def locales = ["fr_fr", "en_us", "ru_ru"].collectEntries { locale ->
+			[(locale): new JsonSlurper().parse(file(
+				"src/main/resources/assets/canaplia/lang/${locale}.json"))]
+		}
+		def expectedNames = [
+			fr_fr: "Livre interdit",
+			en_us: "Forbidden Book",
+			ru_ru: "Запретная книга"]
+		if (project.version.toString() != "0.0.0-alpha.36"
+			|| !pageItem.contains("CanapliaKnowledge.learnRandomUnknown(serverPlayer)")
+			|| !knowledge.contains("unknownVariants(data.personal(player.getUUID()))")
+			|| !knowledge.contains("data.personal(inscription.ownerId())")
+			|| knowledge.contains("data.shared()")
+			|| !knowledgeData.contains("the legacy shared field is preserved")
+			|| !lectern.contains("UseBlockCallback.EVENT.register")
+			|| !lectern.contains("PlayerBlockBreakEvents.BEFORE.register")
+			|| !lectern.contains("CanapliaKnowledge.open(serverPlayer, book)")
+			|| !lectern.contains("CanapliaKnowledge.forgetInscription(taken)")
+			|| screen.contains("PAGE_BACKGROUND")
+			|| screen.contains("extractBackground(GuiGraphicsExtractor")
+			|| screen.contains("extractRenderState(GuiGraphicsExtractor")
+			|| !screen.contains("ChatFormatting.DARK_GRAY")
+			|| !screen.contains("ChatFormatting.DARK_GREEN")
+			|| screen.contains("screen.canaplia.codex.introduction")
+			|| !components.contains('ItsAliveMod.id("canaplia_codex")')
+			|| lecternBooks["values"] != ["itsalive:culinary_recipe_book", "canaplia:codex"]
+			|| generatedCodex.model?.model != "minecraft:item/enchanted_book"
+			|| locales.any { locale, values ->
+				values["item.canaplia.codex"] != expectedNames[locale]
+					|| values["screen.canaplia.codex.title"] != expectedNames[locale]
+					|| !values.containsKey("message.canaplia.codex_page.complete")
+					|| !values.containsKey("tooltip.canaplia.codex.personal")
+			}) {
+			throw new GradleException("The Canaplia Forbidden Book contract is incomplete")
+		}
+	}
+}
+
 tasks.named("check") {
 	dependsOn tasks.named("verifyItsAlive")
 	dependsOn tasks.named("canapliaFoundationSmoke")
+	dependsOn tasks.named("verifyCanapliaForbiddenBook")
 	dependsOn tasks.named("verifyCulinaryReliability")
 	dependsOn tasks.named("verifyCauldronBatching")
 	dependsOn tasks.named("culinaryBatchingSmoke")
@@ -0,0 +1,43 @@
+package fr.koka99cab.sanctuary26.itsalive.canaplia;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import java.util.UUID;
+import net.minecraft.core.UUIDUtil;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+
+/** Binds a placed Forbidden Book to the player whose knowledge it shares. */
+public record CanapliaCodexInscription(UUID ownerId, String ownerName) {
+	private static final int MAX_NAME_LENGTH = 32;
+	public static final Codec<CanapliaCodexInscription> CODEC = RecordCodecBuilder.create(instance ->
+		instance.group(
+			UUIDUtil.CODEC.fieldOf("owner_id").forGetter(CanapliaCodexInscription::ownerId),
+			Codec.STRING.fieldOf("owner_name").forGetter(CanapliaCodexInscription::ownerName)
+		).apply(instance, CanapliaCodexInscription::new)
+	);
+	public static final StreamCodec<RegistryFriendlyByteBuf, CanapliaCodexInscription> STREAM_CODEC =
+		StreamCodec.composite(
+			UUIDUtil.STREAM_CODEC,
+			CanapliaCodexInscription::ownerId,
+			ByteBufCodecs.STRING_UTF8,
+			CanapliaCodexInscription::ownerName,
+			CanapliaCodexInscription::new
+		);
+
+	public CanapliaCodexInscription {
+		if (ownerId == null) throw new IllegalArgumentException("Forbidden Book owner is required");
+		ownerName = sanitizeName(ownerName);
+	}
+
+	public static CanapliaCodexInscription of(UUID ownerId, String ownerName) {
+		return new CanapliaCodexInscription(ownerId, ownerName);
+	}
+
+	private static String sanitizeName(String ownerName) {
+		String cleaned = ownerName == null ? "" : ownerName.replaceAll("\\p{Cntrl}", "").trim();
+		if (cleaned.length() > MAX_NAME_LENGTH) cleaned = cleaned.substring(0, MAX_NAME_LENGTH);
+		return cleaned.isEmpty() ? "?" : cleaned;
+	}
+}
@@ -6,6 +6,7 @@ import fr.koka99cab.sanctuary26.itsalive.canaplia.block.CanapliaHempTopBlock;
 import fr.koka99cab.sanctuary26.itsalive.canaplia.block.CanapliaResinBlock;
 import fr.koka99cab.sanctuary26.itsalive.canaplia.block.CanapliaResinBlockEntity;
 import fr.koka99cab.sanctuary26.itsalive.canaplia.item.CanapliaCodexItem;
+import fr.koka99cab.sanctuary26.itsalive.canaplia.item.CanapliaCodexPageItem;
 import fr.koka99cab.sanctuary26.itsalive.canaplia.item.CanapliaJointItem;
 import fr.koka99cab.sanctuary26.itsalive.canaplia.item.CanapliaVariantBlockItem;
 import java.util.ArrayList;
@@ -37,7 +38,7 @@ public final class CanapliaContent {
 	public static final BlockEntityType<CanapliaResinBlockEntity> RESIN_BLOCK_ENTITY_TYPE = registerResinBlockEntity();
 	private static final Map<CanapliaVariantKey, Family> FAMILIES = registerFamilies();
 	public static final Item CODEX_PAGE = registerItem("codex_page", key ->
-		new Item(new Item.Properties().setId(key)));
+		new CanapliaCodexPageItem(new Item.Properties().setId(key)));
 	public static final Item CODEX = registerItem("codex", key ->
 		new CanapliaCodexItem(new Item.Properties().stacksTo(1).setId(key)));
 	private static final List<Item> CREATIVE_ITEMS = createCreativeItems();
@@ -21,6 +21,7 @@ public final class CanapliaFoundation {
 			throw new IllegalStateException("Unsupported Ambiance visual contract");
 		}
 		CanapliaContent.register();
+		CanapliaLectern.initialize();
 		CanapliaCodexDrops.initialize();
 		CanapliaDiscoverySources.register();
 		CanapliaDiscovery.initialize();
@@ -1,11 +1,16 @@
 package fr.koka99cab.sanctuary26.itsalive.canaplia;

 import fr.koka99cab.sanctuary26.itsalive.network.CanapliaCodexPayload;
+import fr.koka99cab.sanctuary26.itsalive.registry.ItsAliveDataComponents;
 import fr.koka99cab.sanctuary26.sanctuary.progression.SanctuaryProgressionService;
+import java.util.Arrays;
+import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
 import net.minecraft.network.chat.Component;
 import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.item.ItemStack;

 /** Trusted discovery service and compact Codex snapshot builder. */
 public final class CanapliaKnowledge {
@@ -22,10 +27,50 @@ public final class CanapliaKnowledge {
 	}

 	public static void open(ServerPlayer player) {
+		open(player, player.getUUID(), Set.of());
+	}
+
+	public static void open(ServerPlayer player, ItemStack book) {
+		CanapliaCodexInscription inscription = book.get(ItsAliveDataComponents.CANAPLIA_CODEX);
+		if (inscription == null) {
+			open(player);
+			return;
+		}
+		CanapliaKnowledgeData data = CanapliaKnowledgeData.get(player.level().getServer());
+		open(player, player.getUUID(), data.personal(inscription.ownerId()));
+	}
+
+	public static boolean learnRandomUnknown(ServerPlayer player) {
+		CanapliaKnowledgeData data = CanapliaKnowledgeData.get(player.level().getServer());
+		List<CanapliaVariantKey> unknown = unknownVariants(data.personal(player.getUUID()));
+		if (unknown.isEmpty()) {
+			player.sendSystemMessage(Component.translatable("message.canaplia.codex_page.complete"));
+			return false;
+		}
+		CanapliaVariantKey selected = unknown.get(player.getRandom().nextInt(unknown.size()));
+		return discover(player, selected, "codex_page");
+	}
+
+	public static void inscribe(ItemStack stack, ServerPlayer player) {
+		if (!stack.is(CanapliaContent.CODEX)) return;
+		stack.set(ItsAliveDataComponents.CANAPLIA_CODEX, CanapliaCodexInscription.of(
+			player.getUUID(), player.getGameProfile().name()));
+	}
+
+	public static void forgetInscription(ItemStack stack) {
+		if (stack.is(CanapliaContent.CODEX)) stack.remove(ItsAliveDataComponents.CANAPLIA_CODEX);
+	}
+
+	static List<CanapliaVariantKey> unknownVariants(Set<String> learned) {
+		return Arrays.stream(CanapliaVariantKey.values())
+			.filter(variant -> !learned.contains(variant.key()))
+			.toList();
+	}
+
+	private static void open(ServerPlayer player, UUID personalOwner, Set<String> shared) {
 		if (!ServerPlayNetworking.canSend(player, CanapliaCodexPayload.ID)) return;
 		CanapliaKnowledgeData data = CanapliaKnowledgeData.get(player.level().getServer());
-		Set<String> personal = data.personal(player.getUUID());
-		Set<String> shared = data.shared();
+		Set<String> personal = data.personal(personalOwner);
 		int personalMask = mask(personal);
 		int sharedMask = mask(shared);
 		int originHints = 0;
@@ -15,7 +15,7 @@ import net.minecraft.world.level.Level;
 import net.minecraft.world.level.saveddata.SavedData;
 import net.minecraft.world.level.saveddata.SavedDataType;

-/** Versioned personal and shared discoveries; unknown future keys survive round-trips. */
+/** Versioned personal discoveries; the legacy shared field is preserved but no longer exposed globally. */
 public final class CanapliaKnowledgeData extends SavedData {
 	public static final int DATA_VERSION = 1;
 	private static final Codec<CanapliaKnowledgeData> CODEC = RecordCodecBuilder.create(instance -> instance.group(
@@ -57,8 +57,7 @@ public final class CanapliaKnowledgeData extends SavedData {
 	public boolean discover(UUID player, String key) {
 		if (!validKey(key)) return false;
 		boolean personal = players.computeIfAbsent(player.toString(), ignored -> new LinkedHashSet<>()).add(key);
-		boolean community = shared.add(key);
-		if (personal || community) setDirty();
+		if (personal) setDirty();
 		return personal;
 	}

@@ -0,0 +1,77 @@
+package fr.koka99cab.sanctuary26.itsalive.canaplia;
+
+import net.fabricmc.fabric.api.event.player.PlayerBlockBreakEvents;
+import net.fabricmc.fabric.api.event.player.UseBlockCallback;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.sounds.SoundEvents;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.LecternBlock;
+import net.minecraft.world.level.block.entity.LecternBlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.BlockHitResult;
+
+/** Shares only the placer's Canaplia knowledge while the Forbidden Book remains on a lectern. */
+public final class CanapliaLectern {
+	private CanapliaLectern() {
+	}
+
+	public static void initialize() {
+		UseBlockCallback.EVENT.register(CanapliaLectern::use);
+		PlayerBlockBreakEvents.BEFORE.register((level, player, pos, state, blockEntity) -> {
+			if (blockEntity instanceof LecternBlockEntity lectern) {
+				CanapliaKnowledge.forgetInscription(lectern.getBook());
+			}
+			return true;
+		});
+	}
+
+	private static InteractionResult use(Player player, Level level, InteractionHand hand, BlockHitResult hit) {
+		if (hand != InteractionHand.MAIN_HAND || player.isSpectator()) return InteractionResult.PASS;
+		BlockPos pos = hit.getBlockPos();
+		BlockState state = level.getBlockState(pos);
+		if (!state.is(Blocks.LECTERN)) return InteractionResult.PASS;
+
+		ItemStack held = player.getItemInHand(hand);
+		if (!state.getValue(LecternBlock.HAS_BOOK)) {
+			if (held.is(CanapliaContent.CODEX)
+				&& !level.isClientSide()
+				&& player instanceof ServerPlayer serverPlayer) {
+				CanapliaKnowledge.inscribe(held, serverPlayer);
+			}
+			return InteractionResult.PASS;
+		}
+		if (!(level.getBlockEntity(pos) instanceof LecternBlockEntity lectern)) {
+			return InteractionResult.PASS;
+		}
+		ItemStack book = lectern.getBook();
+		if (!book.is(CanapliaContent.CODEX)) return InteractionResult.PASS;
+		if (level.isClientSide()) return InteractionResult.SUCCESS;
+		if (!(player instanceof ServerPlayer serverPlayer) || !level.mayInteract(serverPlayer, pos)) {
+			return InteractionResult.FAIL;
+		}
+		if (serverPlayer.isSecondaryUseActive()) {
+			return takeBook(serverPlayer, level, pos, state, lectern);
+		}
+		CanapliaKnowledge.open(serverPlayer, book);
+		return InteractionResult.SUCCESS;
+	}
+
+	private static InteractionResult takeBook(ServerPlayer player, Level level, BlockPos pos,
+		BlockState state, LecternBlockEntity lectern) {
+		ItemStack taken = lectern.getBook().copy();
+		if (taken.isEmpty()) return InteractionResult.PASS;
+		CanapliaKnowledge.forgetInscription(taken);
+		lectern.setBook(ItemStack.EMPTY);
+		LecternBlock.resetBookState(player, level, pos, state, false);
+		player.getInventory().placeItemBackInInventory(taken);
+		level.playSound(null, pos, SoundEvents.ITEM_FRAME_REMOVE_ITEM, SoundSource.BLOCKS, 1.0F, 1.0F);
+		return InteractionResult.SUCCESS;
+	}
+}
@@ -16,8 +16,7 @@ public final class CanapliaCodexScreen extends BookViewScreen {
 	}

 	private static List<Component> pages(CanapliaCodexPayload snapshot) {
-		List<Component> pages = new ArrayList<>(CanapliaVariantKey.values().length + 1);
-		pages.add(Component.translatable("screen.canaplia.codex.introduction"));
+		List<Component> pages = new ArrayList<>(CanapliaVariantKey.values().length);
 		CanapliaVariantKey[] variants = CanapliaVariantKey.values();
 		for (int index = 0; index < variants.length; index++) {
 			pages.add(variantPage(snapshot, variants[index], index));
@@ -39,16 +38,16 @@ public final class CanapliaCodexScreen extends BookViewScreen {
 				.withStyle(ChatFormatting.GRAY));
 		}

-		page.append((personal
-			? Component.translatable("variant.canaplia." + variant.key())
-			: Component.translatable("screen.canaplia.codex.silhouette"))
-			.withStyle(personal ? ChatFormatting.DARK_GREEN : ChatFormatting.GRAY));
-		if (personal || originHint) {
+		page.append(Component.translatable("variant.canaplia." + variant.key())
+			.withStyle(personal ? ChatFormatting.DARK_GREEN : ChatFormatting.DARK_PURPLE));
+		if (personal || shared || originHint) {
 			page.append("\n\n").append(Component.translatable("screen.canaplia.codex.origin",
-				Component.translatable("origin.canaplia." + variant.key())));
+				Component.translatable("origin.canaplia." + variant.key()))
+				.withStyle(ChatFormatting.DARK_GRAY));
 		}
-		if (personal || conditionHint) {
-			page.append("\n\n").append(Component.translatable("hint.canaplia." + variant.key()));
+		if (personal || shared || conditionHint) {
+			page.append("\n\n").append(Component.translatable("hint.canaplia." + variant.key())
+				.withStyle(ChatFormatting.DARK_GRAY));
 		}
 		return page;
 	}
@@ -1,11 +1,17 @@
 package fr.koka99cab.sanctuary26.itsalive.canaplia.item;

 import fr.koka99cab.sanctuary26.itsalive.canaplia.CanapliaKnowledge;
+import java.util.function.Consumer;
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.chat.Component;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.InteractionResult;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.item.component.TooltipDisplay;
 import net.minecraft.world.level.Level;

 /** Opens the server-authored personal/shared Canaplia collection snapshot. */
@@ -20,4 +26,11 @@ public final class CanapliaCodexItem extends Item {
 		if (player instanceof ServerPlayer serverPlayer) CanapliaKnowledge.open(serverPlayer);
 		return InteractionResult.SUCCESS_SERVER;
 	}
+
+	@Override
+	public void appendHoverText(ItemStack stack, TooltipContext context, TooltipDisplay display,
+		Consumer<Component> tooltip, TooltipFlag flag) {
+		tooltip.accept(Component.translatable("tooltip.canaplia.codex.personal")
+			.withStyle(ChatFormatting.DARK_PURPLE));
+	}
 }
@@ -0,0 +1,28 @@
+package fr.koka99cab.sanctuary26.itsalive.canaplia.item;
+
+import fr.koka99cab.sanctuary26.itsalive.canaplia.CanapliaKnowledge;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+
+/** Consumable unidentified page which discovers one random unknown Canaplia entry. */
+public final class CanapliaCodexPageItem extends Item {
+	public CanapliaCodexPageItem(Properties properties) {
+		super(properties);
+	}
+
+	@Override
+	public InteractionResult use(Level level, Player player, InteractionHand hand) {
+		if (level.isClientSide()) return InteractionResult.SUCCESS;
+		if (!(player instanceof ServerPlayer serverPlayer)) return InteractionResult.PASS;
+		if (CanapliaKnowledge.learnRandomUnknown(serverPlayer)) {
+			ItemStack held = player.getItemInHand(hand);
+			if (!player.getAbilities().instabuild) held.shrink(1);
+		}
+		return InteractionResult.SUCCESS_SERVER;
+	}
+}
@@ -1,6 +1,7 @@
 package fr.koka99cab.sanctuary26.itsalive.registry;

 import fr.koka99cab.sanctuary26.itsalive.ItsAliveMod;
+import fr.koka99cab.sanctuary26.itsalive.canaplia.CanapliaCodexInscription;
 import fr.koka99cab.sanctuary26.itsalive.culinary.knowledge.CulinaryBookInscription;
 import net.minecraft.core.Registry;
 import net.minecraft.core.component.DataComponentType;
@@ -8,6 +9,15 @@ import net.minecraft.core.registries.BuiltInRegistries;

 /** Persistent item components owned by It's Alive. */
 public final class ItsAliveDataComponents {
+	public static final DataComponentType<CanapliaCodexInscription> CANAPLIA_CODEX = Registry.register(
+		BuiltInRegistries.DATA_COMPONENT_TYPE,
+		ItsAliveMod.id("canaplia_codex"),
+		DataComponentType.<CanapliaCodexInscription>builder()
+			.persistent(CanapliaCodexInscription.CODEC)
+			.networkSynchronized(CanapliaCodexInscription.STREAM_CODEC)
+			.cacheEncoding()
+			.build()
+	);
 	public static final DataComponentType<CulinaryBookInscription> CULINARY_BOOK = Registry.register(
 		BuiltInRegistries.DATA_COMPONENT_TYPE,
 		ItsAliveMod.id("culinary_book"),
@@ -1,18 +1,18 @@
 {
 	"description.canaplia": "Complete Canaplia gameplay: sixteen plants, server-authoritative discovery, hybrids, effects and an Ambiance-owned visual layer.",
-	"screen.canaplia.codex.title": "Canaplia Codex",
+	"screen.canaplia.codex.title": "Forbidden Book",
 	"screen.canaplia.codex.page": "Page %s / %s",
-	"screen.canaplia.codex.introduction": "CANAPLIA CODEX\n\nSlay monsters to recover scattered pages and, very rarely, a complete Codex.\n\nGrow and discover varieties to fill its pages.",
 	"screen.canaplia.codex.entry_number": "Entry %s",
 	"screen.canaplia.codex.origin": "Origin: %s",
 	"screen.canaplia.codex.hidden": "Undiscovered",
-	"screen.canaplia.codex.silhouette": "Known silhouette",
 	"message.canaplia.discovered": "Canaplia discovered: %s",
+	"message.canaplia.codex_page.complete": "You already know every entry in the Forbidden Book.",
 	"message.canaplia.composter.mixed": "This composter already contains another Canaplia variant.",
+	"tooltip.canaplia.codex.personal": "Personal in hand; shares its owner's knowledge on a lectern",
 	"block.canaplia.hemp_crop": "Canaplia Plant",
 	"block.canaplia.hemp_top": "Canaplia Plant Top",
 	"block.canaplia.resin_block": "Canaplia Resin Block",
-	"item.canaplia.codex": "Canaplia Codex",
+	"item.canaplia.codex": "Forbidden Book",
 	"item.canaplia.codex_page": "Canaplia Page",
 	"variant.canaplia.common": "Common",
 	"origin.canaplia.common": "Wild",
@@ -1,18 +1,18 @@
 {
 	"description.canaplia": "Gameplay Canaplia complet : seize plantes, découvertes, hybrides et effets autoritaires côté serveur, avec une couche visuelle gérée par Ambiance.",
-	"screen.canaplia.codex.title": "Codex Canaplia",
+	"screen.canaplia.codex.title": "Livre interdit",
 	"screen.canaplia.codex.page": "Page %s / %s",
-	"screen.canaplia.codex.introduction": "CODEX CANAPLIA\n\nTuez des monstres pour retrouver des pages éparses et, très rarement, un Codex complet.\n\nCultivez et découvrez les variétés pour remplir ses pages.",
 	"screen.canaplia.codex.entry_number": "Entrée %s",
 	"screen.canaplia.codex.origin": "Origine : %s",
 	"screen.canaplia.codex.hidden": "Non découverte",
-	"screen.canaplia.codex.silhouette": "Silhouette connue",
 	"message.canaplia.discovered": "Canaplia découverte : %s",
+	"message.canaplia.codex_page.complete": "Tu connais déjà toutes les entrées du Livre interdit.",
 	"message.canaplia.composter.mixed": "Ce composteur contient déjà une autre variante de Canaplia.",
+	"tooltip.canaplia.codex.personal": "Personnel en main ; partage le savoir du propriétaire sur un pupitre",
 	"block.canaplia.hemp_crop": "Plant de Canaplia",
 	"block.canaplia.hemp_top": "Sommet de Canaplia",
 	"block.canaplia.resin_block": "Bloc de résine Canaplia",
-	"item.canaplia.codex": "Codex Canaplia",
+	"item.canaplia.codex": "Livre interdit",
 	"item.canaplia.codex_page": "Page de Canaplia",
 	"variant.canaplia.common": "Commune",
 	"origin.canaplia.common": "Sauvage",
@@ -1,18 +1,18 @@
 {
 	"description.canaplia": "Полная механика Canaplia: шестнадцать растений, серверные открытия, гибриды и эффекты с визуальным слоем Ambiance.",
-	"screen.canaplia.codex.title": "Кодекс Canaplia",
+	"screen.canaplia.codex.title": "Запретная книга",
 	"screen.canaplia.codex.page": "Страница %s / %s",
-	"screen.canaplia.codex.introduction": "КОДЕКС CANAPLIA\n\nУбивайте монстров, чтобы находить отдельные страницы и, очень редко, полный Кодекс.\n\nВыращивайте и открывайте сорта, чтобы заполнить его.",
 	"screen.canaplia.codex.entry_number": "Запись %s",
 	"screen.canaplia.codex.origin": "Происхождение: %s",
 	"screen.canaplia.codex.hidden": "Не открыто",
-	"screen.canaplia.codex.silhouette": "Известный силуэт",
 	"message.canaplia.discovered": "Открыта Canaplia: %s",
+	"message.canaplia.codex_page.complete": "Вы уже знаете все записи Запретной книги.",
 	"message.canaplia.composter.mixed": "В этом компостере уже находится другой вариант Canaplia.",
+	"tooltip.canaplia.codex.personal": "Личная в руке; на кафедре делится знаниями владельца",
 	"block.canaplia.hemp_crop": "Растение Canaplia",
 	"block.canaplia.hemp_top": "Верхушка Canaplia",
 	"block.canaplia.resin_block": "Блок смолы Canaplia",
-	"item.canaplia.codex": "Кодекс Canaplia",
+	"item.canaplia.codex": "Запретная книга",
 	"item.canaplia.codex_page": "Страница Canaplia",
 	"variant.canaplia.common": "Обычная",
 	"origin.canaplia.common": "Дикая",
@@ -1,6 +1,7 @@
 {
 	"replace": false,
 	"values": [
-		"itsalive:culinary_recipe_book"
+		"itsalive:culinary_recipe_book",
+		"canaplia:codex"
 	]
 }
@@ -97,6 +97,28 @@ public final class CanapliaGameplaySmoke {
 			"unknown future personal discovery preserved");
 		assertTrue(futureKnowledge.shared().contains("future_variant_17"),
 			"unknown future shared discovery preserved");
+		assertTrue(futureKnowledge.discover(owner, CanapliaVariantKey.COMMON.key()),
+			"new personal discovery recorded");
+		assertTrue(futureKnowledge.personal(owner).contains(CanapliaVariantKey.COMMON.key()),
+			"new discovery remains personal");
+		assertTrue(!futureKnowledge.shared().contains(CanapliaVariantKey.COMMON.key()),
+			"new discovery is not published globally");
+
+		assertEquals(16, CanapliaKnowledge.unknownVariants(Set.of()).size(),
+			"blank Codex page can select every variant");
+		Set<String> almostComplete = new HashSet<>(CanapliaVariants.all().stream()
+			.map(definition -> definition.key().key()).toList());
+		almostComplete.remove(CanapliaVariantKey.EMBER.key());
+		assertEquals(java.util.List.of(CanapliaVariantKey.EMBER),
+			CanapliaKnowledge.unknownVariants(almostComplete), "last unknown Codex entry");
+		assertTrue(CanapliaKnowledge.unknownVariants(
+			CanapliaVariants.all().stream().map(definition -> definition.key().key()).collect(
+				java.util.stream.Collectors.toSet())).isEmpty(), "complete Codex has no unknown entry");
+
+		CanapliaCodexInscription inscription = CanapliaCodexInscription.of(owner,
+			"  Can\u0000aplia owner with a deliberately long name  ");
+		assertTrue(inscription.ownerName().length() <= 32, "Codex owner name bound");
+		assertTrue(!inscription.ownerName().contains("\u0000"), "Codex owner control characters removed");

 		CanapliaCodexPayload payload = new CanapliaCodexPayload(99, -1, 0x1FFFF, -2, Integer.MAX_VALUE);
 		assertEquals(CanapliaCodexPayload.PROTOCOL_VERSION, payload.protocol(), "codex protocol bound");
@@ -0,0 +1,39 @@
+# Abjection dans Only Fun
+
+Le runtime historique GPL-3.0-or-later de `Fun/abjection` est intégré au JAR **Only Fun**. Le
+namespace `abjection` et les IDs `abjection:shit_ball` et `abjection:shit_cube` sont conservés ; le
+manifeste Only Fun fournit l’alias Fabric `abjection`, sans créer un onzième module.
+
+## ABJ-01 — actions serveur
+
+- `/piss` émet son jet pendant 15 secondes et peut activer un bouton touché ;
+- `/vomit` émet son jet pendant 8 secondes ;
+- `/shit` émet son jet pendant 6 secondes et crée régulièrement la même
+  `abjection:shit_ball` que les lots suivants ;
+- `/smoke` émet de la fumée pendant 10 secondes.
+
+`AbjectionActions.start` est l’unique API publique de déclenchement. Chaque nouvelle demande
+redémarre seulement l’action correspondante, sans dupliquer la boule initiale de `/shit`. L’état
+reste en mémoire serveur, n’est jamais sauvegardé et est supprimé à la mort, au passage spectateur
+ou à la déconnexion.
+
+Le bloc `abjection:shit_cube` reprend les propriétés de la boue, l’apparence 16×16, la recette
+neuf boules, le butin et l’outil pelle historiques. Les textes sont disponibles en français,
+anglais et russe. Only Fun reste en données v2 et protocole réseau 2 pour ABJ-01.
+
+## ABJ-02 — projectile Ouch
+
+Only Fun expose l’objet et le point d’installation `AbjectionProjectileApi`. Ouch, qui dépend
+explicitement d’Only Fun sans cycle inverse, enregistre le type d’entité sous le même ID historique
+`abjection:shit_ball` et installe la fabrique commune au lancer manuel et au dispenser. Le
+projectile mesure 0,25 bloc, consomme une unité hors créatif, joue le son de boue à l’impact et
+ajoute sept secondes à la nausée déjà présente sans dupliquer d’objet.
+
+## ABJ-03 — raccourci configurable
+
+La catégorie de contrôles Only Fun expose « Chier », assigné à `J` par défaut. Le client utilise
+`consumeClick`, puis envoie un payload vide `onlyfun:c2s/shit_action`. Le serveur accepte au plus
+une demande par joueur et par tick, revalide que le joueur est toujours connecté, vivant et non
+spectateur, puis appelle le même `AbjectionActions.start(SHIT)` que `/shit`. Maintenir la touche
+ne produit donc pas de répétition par tick et la commande reste disponible. Only Fun conserve ses
+données v2 et passe son protocole réseau de 2 à 3.
@@ -63,6 +63,12 @@ reçoivent la bande neutre de 96 rubis jusqu’à leur override explicite.
 - blocs techniques ou créateurs directs de récompenses/farms : spawners, trial spawners, vault,
  command blocks, structure/test blocks, barrier, light, bedrock et assimilés ;
 - équipements uniques en titane et les deux monnaies elles-mêmes.
+- tout le namespace `itsalive:*` afin que cultures, machines, recettes, plats et créatures restent
+  obtenus par le gameplay d’It's Alive ;
+- les plats vanilla déjà préparés : aliments cuits, soupes et ragoûts, pain, gâteaux, biscuits et
+  tartes ;
+- `minecraft:enchanted_golden_apple`, qui reste une récompense d'exploration exceptionnelle.

-La même politique bloque ces identifiants à la sortie du générateur de loot, même si un futur
-résultat aléatoire tente de les sélectionner.
+Les identifiants économiques, techniques et de lootbox restent également bloqués à la sortie du
+générateur de loot. Les exclusions culinaires sont propres au Shop : elles empêchent l’achat et
+la sauvegarde d’une nouvelle offre sans supprimer un colis déjà payé ni les autres sources de jeu.
@@ -1,6 +1,9 @@
 package fr.koka99cab.sanctuary26.onlyfun;

 import fr.koka99cab.sanctuary26.onlyfun.chickencarry.ChickenCarryController;
+import fr.koka99cab.sanctuary26.onlyfun.abjection.AbjectionRegistries;
+import fr.koka99cab.sanctuary26.onlyfun.api.abjection.AbjectionActions;
+import fr.koka99cab.sanctuary26.onlyfun.command.AbjectionCommands;
 import fr.koka99cab.sanctuary26.onlyfun.network.OnlyFunNetworking;
 import fr.koka99cab.sanctuary26.onlyfun.registry.OnlyFunRegistries;
 import fr.koka99cab.sanctuary26.onlyfun.registry.OnlyFunCreativeTab;
@@ -31,6 +34,7 @@ public final class OnlyFunMod implements ModInitializer {

 	@Override
 	public void onInitialize() {
+		AbjectionRegistries.initialize();
 		OnlyFunRegistries.initialize();
 		OnlyFunCreativeTab.initialize();
 		OnlyFunGenerator.initialize();
@@ -42,6 +46,8 @@ public final class OnlyFunMod implements ModInitializer {
 		OnlyFunNetworking.initialize();
 		ChickenCarryController.register();
 		OnlyFunCommands.register();
+		AbjectionActions.initialize();
+		AbjectionCommands.register();
 		LOGGER.info("[{}] Loot generator, natural Lucky Blocks, mob lootboxes and chicken rules ready (data v{}, network v{}).",
 			DISPLAY_NAME, CURRENT_DATA_VERSION, OnlyFunNetworking.PROTOCOL_VERSION);
 	}
@@ -0,0 +1,52 @@
+package fr.koka99cab.sanctuary26.onlyfun.abjection;
+
+import java.util.function.Function;
+import net.minecraft.core.Registry;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.Identifier;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.world.item.BlockItem;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.state.BlockBehaviour;
+
+/** Historical Abjection registry IDs, owned and distributed by Only Fun. */
+public final class AbjectionRegistries {
+	public static final String NAMESPACE = "abjection";
+	public static final Block SHIT_CUBE = registerBlock("shit_cube", Block::new,
+		BlockBehaviour.Properties.ofFullCopy(Blocks.MUD));
+	public static final Item SHIT_BALL = registerItem("shit_ball",
+		properties -> new ShitBallItem(properties.stacksTo(16).useItemDescriptionPrefix()));
+	public static final Item SHIT_CUBE_ITEM = registerBlockItem("shit_cube", SHIT_CUBE);
+
+	private AbjectionRegistries() {
+	}
+
+	public static Identifier id(String path) {
+		return Identifier.fromNamespaceAndPath(NAMESPACE, path);
+	}
+
+	public static void initialize() {
+		// Class initialization owns registration; this method makes the startup order explicit.
+	}
+
+	private static Item registerItem(String path, Function<Item.Properties, Item> factory) {
+		ResourceKey<Item> key = ResourceKey.create(Registries.ITEM, id(path));
+		return Registry.register(BuiltInRegistries.ITEM, key,
+			factory.apply(new Item.Properties().setId(key)));
+	}
+
+	private static Block registerBlock(String path, Function<BlockBehaviour.Properties, Block> factory,
+		BlockBehaviour.Properties properties) {
+		ResourceKey<Block> key = ResourceKey.create(Registries.BLOCK, id(path));
+		return Registry.register(BuiltInRegistries.BLOCK, key, factory.apply(properties.setId(key)));
+	}
+
+	private static Item registerBlockItem(String path, Block block) {
+		ResourceKey<Item> key = ResourceKey.create(Registries.ITEM, id(path));
+		return Registry.register(BuiltInRegistries.ITEM, key,
+			new BlockItem(block, new Item.Properties().setId(key).useBlockDescriptionPrefix()));
+	}
+}
@@ -0,0 +1,43 @@
+package fr.koka99cab.sanctuary26.onlyfun.abjection;
+
+import fr.koka99cab.sanctuary26.onlyfun.api.abjection.AbjectionActions;
+import fr.koka99cab.sanctuary26.onlyfun.network.ShitActionRequestPayload;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerPlayer;
+
+/** Validates connection/player state and deduplicates malicious same-tick key requests. */
+public final class ShitActionRequestHandler {
+	private static final Map<UUID, Integer> LAST_REQUEST_TICK = new HashMap<>();
+
+	private ShitActionRequestHandler() {
+	}
+
+	public static void register() {
+		ServerPlayNetworking.registerGlobalReceiver(ShitActionRequestPayload.ID,
+			(payload, context) -> handle(context.player()));
+		ServerPlayConnectionEvents.DISCONNECT.register((handler, server) ->
+			clear(handler.player.getUUID()));
+	}
+
+	private static void handle(ServerPlayer player) {
+		MinecraftServer server = player.level().getServer();
+		if (server == null || server.getPlayerList().getPlayer(player.getUUID()) != player
+			|| !player.isAlive() || player.isSpectator()
+			|| !acceptTick(player.getUUID(), server.getTickCount())) return;
+		AbjectionActions.start(player, AbjectionActions.Action.SHIT);
+	}
+
+	static boolean acceptTick(UUID playerId, int tick) {
+		Integer previous = LAST_REQUEST_TICK.put(playerId, tick);
+		return previous == null || previous != tick;
+	}
+
+	static void clear(UUID playerId) {
+		LAST_REQUEST_TICK.remove(playerId);
+	}
+}
@@ -0,0 +1,22 @@
+package fr.koka99cab.sanctuary26.onlyfun.abjection;
+
+import fr.koka99cab.sanctuary26.onlyfun.api.abjection.AbjectionProjectileApi;
+import net.minecraft.core.Direction;
+import net.minecraft.core.Position;
+import net.minecraft.world.entity.projectile.Projectile;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.ProjectileItem;
+import net.minecraft.world.level.Level;
+
+/** Historical item identity with a projectile contract implemented by the owning Ouch module. */
+public final class ShitBallItem extends Item implements ProjectileItem {
+	public ShitBallItem(Properties properties) {
+		super(properties);
+	}
+
+	@Override
+	public Projectile asProjectile(Level level, Position position, ItemStack stack, Direction direction) {
+		return AbjectionProjectileApi.create(level, position, stack, direction);
+	}
+}
@@ -0,0 +1,383 @@
+package fr.koka99cab.sanctuary26.onlyfun.api.abjection;
+
+import fr.koka99cab.sanctuary26.onlyfun.abjection.AbjectionRegistries;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.UUID;
+import net.fabricmc.fabric.api.event.lifecycle.v1.ServerTickEvents;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.particles.ColorParticleOption;
+import net.minecraft.core.particles.DustParticleOptions;
+import net.minecraft.core.particles.ItemParticleOption;
+import net.minecraft.core.particles.ParticleTypes;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.util.Mth;
+import net.minecraft.world.entity.HumanoidArm;
+import net.minecraft.world.entity.item.ItemEntity;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.level.ClipContext;
+import net.minecraft.world.level.block.ButtonBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.BlockHitResult;
+import net.minecraft.world.phys.HitResult;
+import net.minecraft.world.phys.Vec3;
+
+/** Public server API shared by Abjection commands and bounded client requests. */
+public final class AbjectionActions {
+	public enum Action {
+		PISS(15 * 20, "piss"),
+		VOMIT(8 * 20, "vomit"),
+		SHIT(6 * 20, "shit"),
+		SMOKE(10 * 20, "smoke");
+
+		private final int durationTicks;
+		private final String id;
+
+		Action(int durationTicks, String id) {
+			this.durationTicks = durationTicks;
+			this.id = id;
+		}
+
+		public int durationTicks() {
+			return durationTicks;
+		}
+
+		public String id() {
+			return id;
+		}
+	}
+
+	public enum StartResult {
+		STARTED,
+		RESTARTED,
+		REJECTED
+	}
+
+	private static final Map<UUID, EnumMap<Action, Integer>> ACTIVE = new HashMap<>();
+	private static final int STREAM_SEGMENTS = 64;
+	private static final double STREAM_STEP_LENGTH = 0.05D;
+	private static final double STREAM_STEP_SCALE = STREAM_STEP_LENGTH / 0.28D;
+	private static final DustParticleOptions PISS_BRIGHT = new DustParticleOptions(0xEDD62E, 0.24F);
+	private static final DustParticleOptions PISS_GOLD = new DustParticleOptions(0xD8B825, 0.2F);
+	private static final DustParticleOptions PISS_AMBER = new DustParticleOptions(0xC6941A, 0.19F);
+	private static final DustParticleOptions PISS_DEEP_GOLD = new DustParticleOptions(0xB88714, 0.17F);
+	private static final DustParticleOptions VOMIT_GREEN = new DustParticleOptions(0x88A436, 0.24F);
+	private static final DustParticleOptions VOMIT_YELLOW = new DustParticleOptions(0xB6B342, 0.2F);
+	private static final DustParticleOptions VOMIT_ORANGE = new DustParticleOptions(0xA96A32, 0.19F);
+	private static final DustParticleOptions VOMIT_BROWN = new DustParticleOptions(0x6E5828, 0.17F);
+	private static final DustParticleOptions SHIT_SPLAT = new DustParticleOptions(0x4A2B14, 1.4F);
+	private static final DustParticleOptions SHIT_MUD = new DustParticleOptions(0x6A4521, 0.22F);
+	private static final ColorParticleOption PISS_BRIGHT_MIST =
+		ColorParticleOption.create(ParticleTypes.ENTITY_EFFECT, 0xF0E35A);
+	private static final ColorParticleOption PISS_GOLD_MIST =
+		ColorParticleOption.create(ParticleTypes.ENTITY_EFFECT, 0xD8C43A);
+	private static final ColorParticleOption PISS_AMBER_MIST =
+		ColorParticleOption.create(ParticleTypes.ENTITY_EFFECT, 0xCDA128);
+	private static final ColorParticleOption VOMIT_GREEN_MIST =
+		ColorParticleOption.create(ParticleTypes.ENTITY_EFFECT, 0x95B33F);
+	private static final ColorParticleOption VOMIT_YELLOW_MIST =
+		ColorParticleOption.create(ParticleTypes.ENTITY_EFFECT, 0xC4C35B);
+	private static final ColorParticleOption VOMIT_ORANGE_MIST =
+		ColorParticleOption.create(ParticleTypes.ENTITY_EFFECT, 0xB97A3D);
+	private static final ItemParticleOption VOMIT_FLESH =
+		new ItemParticleOption(ParticleTypes.ITEM, Items.ROTTEN_FLESH);
+	private static final ItemParticleOption VOMIT_EYE =
+		new ItemParticleOption(ParticleTypes.ITEM, Items.SPIDER_EYE);
+	private static final ItemParticleOption VOMIT_POTATO =
+		new ItemParticleOption(ParticleTypes.ITEM, Items.POISONOUS_POTATO);
+	private static boolean initialized;
+
+	private AbjectionActions() {
+	}
+
+	public static void initialize() {
+		if (initialized) return;
+		initialized = true;
+		ServerTickEvents.END_SERVER_TICK.register(AbjectionActions::tick);
+		ServerPlayConnectionEvents.DISCONNECT.register((handler, server) -> clear(handler.player.getUUID()));
+	}
+
+	public static StartResult start(ServerPlayer player, Action action) {
+		if (player == null || action == null || !player.isAlive() || player.isSpectator()
+			|| player.level().getServer() == null) return StartResult.REJECTED;
+		boolean restarted = restart(player.getUUID(), action);
+		if (action == Action.SHIT && !restarted) spawnShitDrop(player.level(), player);
+		return restarted ? StartResult.RESTARTED : StartResult.STARTED;
+	}
+
+	static boolean restart(UUID playerId, Action action) {
+		EnumMap<Action, Integer> actions = ACTIVE.computeIfAbsent(playerId, ignored ->
+			new EnumMap<>(Action.class));
+		return actions.put(action, action.durationTicks()) != null;
+	}
+
+	public static void clear(UUID playerId) {
+		ACTIVE.remove(playerId);
+	}
+
+	static int remaining(UUID playerId, Action action) {
+		return ACTIVE.getOrDefault(playerId, new EnumMap<>(Action.class)).getOrDefault(action, 0);
+	}
+
+	private static void tick(MinecraftServer server) {
+		Iterator<Map.Entry<UUID, EnumMap<Action, Integer>>> players = ACTIVE.entrySet().iterator();
+		while (players.hasNext()) {
+			Map.Entry<UUID, EnumMap<Action, Integer>> entry = players.next();
+			ServerPlayer player = server.getPlayerList().getPlayer(entry.getKey());
+			if (player == null || !player.isAlive() || player.isSpectator()) {
+				players.remove();
+				continue;
+			}
+			Iterator<Map.Entry<Action, Integer>> actions = entry.getValue().entrySet().iterator();
+			while (actions.hasNext()) {
+				Map.Entry<Action, Integer> action = actions.next();
+				emit(player, action.getKey(), action.getValue());
+				int remaining = action.getValue() - 1;
+				if (remaining <= 0) actions.remove();
+				else action.setValue(remaining);
+			}
+			if (entry.getValue().isEmpty()) players.remove();
+		}
+	}
+
+	private static void emit(ServerPlayer player, Action action, int remaining) {
+		switch (action) {
+			case PISS -> spawnPissStream(player);
+			case VOMIT -> spawnVomitStream(player);
+			case SHIT -> spawnShitStream(player, remaining);
+			case SMOKE -> spawnSmoke(player);
+		}
+	}
+
+	private static void spawnPissStream(ServerPlayer player) {
+		ServerLevel level = player.level();
+		Vec3 position = pissOrigin(player);
+		Vec3 velocity = pissVelocity(player);
+		for (int step = 0; step < STREAM_SEGMENTS; step++) {
+			Vec3 next = position.add(velocity.scale(STREAM_STEP_LENGTH));
+			Vec3 midpoint = position.lerp(next, 0.5D);
+			level.sendParticles(pissCore(step), midpoint.x, midpoint.y, midpoint.z, 2,
+				0.012D, 0.012D, 0.012D, 0.0D);
+			if ((step & 1) == 0) level.sendParticles(step % 4 == 0 ? PISS_DEEP_GOLD : PISS_BRIGHT,
+				midpoint.x, midpoint.y, midpoint.z, 2, 0.01D, 0.01D, 0.01D, 0.0D);
+			if (step % 3 == 0) level.sendParticles(pissMist(step), midpoint.x, midpoint.y, midpoint.z,
+				2, 0.012D, 0.012D, 0.012D, 0.0D);
+			HitResult hit = clip(level, player, position, next);
+			if (hit.getType() != HitResult.Type.MISS) {
+				activateButton(level, player, hit);
+				pissImpact(level, hit.getLocation());
+				return;
+			}
+			position = next;
+			velocity = velocity.add(0.0D, -0.03D * STREAM_STEP_SCALE, 0.0D)
+				.scale(Math.pow(0.985D, STREAM_STEP_SCALE));
+			if (position.y < level.getMinY()) return;
+		}
+	}
+
+	private static void spawnVomitStream(ServerPlayer player) {
+		ServerLevel level = player.level();
+		Vec3 position = vomitOrigin(player);
+		Vec3 velocity = vomitVelocity(player);
+		level.sendParticles(ParticleTypes.WHITE_SMOKE, position.x, position.y, position.z,
+			2, 0.012D, 0.01D, 0.012D, 0.002D);
+		for (int step = 0; step < STREAM_SEGMENTS; step++) {
+			Vec3 next = position.add(velocity.scale(STREAM_STEP_LENGTH));
+			Vec3 midpoint = position.lerp(next, 0.5D);
+			level.sendParticles(vomitCore(step), midpoint.x, midpoint.y, midpoint.z, 2,
+				0.012D, 0.012D, 0.012D, 0.0D);
+			if ((step & 1) == 0) level.sendParticles(step % 4 == 0 ? VOMIT_BROWN : VOMIT_GREEN,
+				midpoint.x, midpoint.y, midpoint.z, 2, 0.01D, 0.01D, 0.01D, 0.0D);
+			HitResult hit = clip(level, player, position, next);
+			if (hit.getType() != HitResult.Type.MISS) {
+				vomitImpact(level, hit.getLocation());
+				return;
+			}
+			position = next;
+			velocity = velocity.add(0.0D, -0.038D * STREAM_STEP_SCALE, 0.0D)
+				.scale(Math.pow(0.982D, STREAM_STEP_SCALE));
+			if (position.y < level.getMinY()) return;
+		}
+	}
+
+	private static void spawnShitStream(ServerPlayer player, int remaining) {
+		ServerLevel level = player.level();
+		Vec3 position = shitOrigin(player);
+		Vec3 velocity = shitVelocity(player);
+		if (remaining < Action.SHIT.durationTicks() && remaining % 20 == 0) spawnShitDrop(level, player);
+		for (int step = 0; step < STREAM_SEGMENTS; step++) {
+			Vec3 next = position.add(velocity.scale(STREAM_STEP_LENGTH));
+			Vec3 midpoint = position.lerp(next, 0.5D);
+			float progress = step / (float) (STREAM_SEGMENTS - 1);
+			float spread = 0.002F + progress * 0.018F;
+			level.sendParticles(new DustParticleOptions(0x5B3417,
+				Mth.lerp(progress * progress, 0.05F, 1.55F)), midpoint.x, midpoint.y, midpoint.z,
+				1, spread, spread, spread, 0.0D);
+			if ((step & 1) == 0) level.sendParticles(new DustParticleOptions(0x75461F,
+				Mth.lerp(progress * progress, 0.04F, 0.85F)), midpoint.x, midpoint.y, midpoint.z,
+				1, spread, spread, spread, 0.0D);
+			HitResult hit = clip(level, player, position, next);
+			if (hit.getType() != HitResult.Type.MISS) {
+				level.sendParticles(SHIT_SPLAT, hit.getLocation().x, hit.getLocation().y,
+					hit.getLocation().z, 2, 0.03D, 0.02D, 0.03D, 0.0D);
+				level.sendParticles(SHIT_MUD, hit.getLocation().x, hit.getLocation().y,
+					hit.getLocation().z, 4, 0.04D, 0.025D, 0.04D, 0.0D);
+				return;
+			}
+			position = next;
+			velocity = velocity.add(0.0D, -0.032D * STREAM_STEP_SCALE, 0.0D)
+				.scale(Math.pow(0.986D, STREAM_STEP_SCALE));
+			if (position.y < level.getMinY()) return;
+		}
+	}
+
+	private static void spawnSmoke(ServerPlayer player) {
+		ServerLevel level = player.level();
+		Vec3 mouth = mouthOrigin(player);
+		level.sendParticles(ParticleTypes.SMOKE, mouth.x, mouth.y, mouth.z,
+			2, 0.015D, 0.01D, 0.015D, 0.003D);
+		if (level.getRandom().nextInt(3) == 0) level.sendParticles(ParticleTypes.WHITE_SMOKE,
+			mouth.x, mouth.y, mouth.z, 1, 0.01D, 0.008D, 0.01D, 0.002D);
+	}
+
+	private static HitResult clip(ServerLevel level, ServerPlayer player, Vec3 from, Vec3 to) {
+		return level.clip(new ClipContext(from, to, ClipContext.Block.COLLIDER, ClipContext.Fluid.ANY, player));
+	}
+
+	private static Vec3 pissOrigin(ServerPlayer player) {
+		Vec3 forward = Vec3.directionFromRotation(0.0F, player.getYRot()).normalize();
+		Vec3 right = new Vec3(-forward.z, 0.0D, forward.x);
+		double side = player.getMainArm() == HumanoidArm.RIGHT ? -0.12D : 0.12D;
+		return player.position().add(0.0D, player.getBbHeight() * 0.55D, 0.0D)
+			.add(forward.scale(0.24D)).add(right.scale(side));
+	}
+
+	private static Vec3 pissVelocity(ServerPlayer player) {
+		float pitch = Mth.clamp(player.getXRot() + 22.0F, 6.0F, 55.0F);
+		return Vec3.directionFromRotation(pitch, player.getYRot()).normalize().scale(1.05D)
+			.add(player.getDeltaMovement().multiply(0.18D, 0.0D, 0.18D));
+	}
+
+	private static Vec3 vomitOrigin(ServerPlayer player) {
+		Vec3 forward = Vec3.directionFromRotation(player.getXRot(), player.getYRot()).normalize();
+		return player.position().add(0.0D, player.getBbHeight() * 0.82D, 0.0D)
+			.add(forward.scale(0.18D));
+	}
+
+	private static Vec3 vomitVelocity(ServerPlayer player) {
+		float pitch = Mth.clamp(player.getXRot() + 8.0F, -18.0F, 42.0F);
+		return Vec3.directionFromRotation(pitch, player.getYRot()).normalize().scale(0.8D)
+			.add(player.getDeltaMovement().multiply(0.15D, 0.0D, 0.15D));
+	}
+
+	private static Vec3 shitOrigin(ServerPlayer player) {
+		Vec3 backward = Vec3.directionFromRotation(0.0F, player.getYRot()).normalize().scale(-1.0D);
+		return player.position().add(0.0D, player.getBbHeight() * 0.44D, 0.0D)
+			.add(backward.scale(0.16D));
+	}
+
+	private static Vec3 shitVelocity(ServerPlayer player) {
+		Vec3 backward = Vec3.directionFromRotation(0.0F, player.getYRot()).normalize().scale(-1.0D);
+		return backward.scale(0.68D).add(0.0D, 0.08D, 0.0D)
+			.add(player.getDeltaMovement().multiply(0.1D, 0.0D, 0.1D));
+	}
+
+	private static Vec3 mouthOrigin(ServerPlayer player) {
+		Vec3 forward = Vec3.directionFromRotation(player.getXRot(), player.getYRot()).normalize();
+		return player.position().add(0.0D, player.getBbHeight() * 0.82D, 0.0D)
+			.add(forward.scale(0.12D));
+	}
+
+	private static void spawnShitDrop(ServerLevel level, ServerPlayer player) {
+		Vec3 backward = Vec3.directionFromRotation(0.0F, player.getYRot()).normalize().scale(-1.0D);
+		Vec3 position = shitOrigin(player).add(backward.scale(0.08D)).add(0.0D, -0.08D, 0.0D);
+		Vec3 velocity = backward.scale(0.05D).add(0.0D, 0.02D, 0.0D);
+		ItemEntity item = new ItemEntity(level, position.x, position.y, position.z,
+			new ItemStack(AbjectionRegistries.SHIT_BALL), velocity.x, velocity.y, velocity.z);
+		item.setPickUpDelay(10);
+		item.setThrower(player);
+		level.addFreshEntity(item);
+	}
+
+	private static DustParticleOptions pissCore(int step) {
+		return switch (step % 3) {
+			case 0 -> PISS_BRIGHT;
+			case 1 -> PISS_GOLD;
+			default -> PISS_AMBER;
+		};
+	}
+
+	private static ColorParticleOption pissMist(int step) {
+		return switch (step % 3) {
+			case 0 -> PISS_BRIGHT_MIST;
+			case 1 -> PISS_GOLD_MIST;
+			default -> PISS_AMBER_MIST;
+		};
+	}
+
+	private static DustParticleOptions vomitCore(int step) {
+		return switch (step % 3) {
+			case 0 -> VOMIT_GREEN;
+			case 1 -> VOMIT_YELLOW;
+			default -> VOMIT_ORANGE;
+		};
+	}
+
+	private static ItemParticleOption vomitChunk(ServerLevel level) {
+		return switch (level.getRandom().nextInt(3)) {
+			case 0 -> VOMIT_FLESH;
+			case 1 -> VOMIT_EYE;
+			default -> VOMIT_POTATO;
+		};
+	}
+
+	private static void activateButton(ServerLevel level, ServerPlayer player, HitResult hit) {
+		if (!(hit instanceof BlockHitResult blockHit)) return;
+		BlockPos pos = blockHit.getBlockPos();
+		BlockState state = level.getBlockState(pos);
+		if (state.getBlock() instanceof ButtonBlock button && !state.getValue(ButtonBlock.POWERED)) {
+			button.press(state, level, pos, player);
+		}
+	}
+
+	private static void pissImpact(ServerLevel level, Vec3 position) {
+		for (DustParticleOptions particle : new DustParticleOptions[] {PISS_BRIGHT, PISS_GOLD, PISS_AMBER}) {
+			level.sendParticles(particle, position.x, position.y, position.z, 3,
+				0.02D, 0.02D, 0.02D, 0.0D);
+		}
+		for (ColorParticleOption particle : new ColorParticleOption[] {
+			PISS_BRIGHT_MIST, PISS_GOLD_MIST, PISS_AMBER_MIST}) {
+			level.sendParticles(particle, position.x, position.y, position.z, 2,
+				0.03D, 0.022D, 0.03D, 0.0D);
+		}
+		level.sendParticles(ParticleTypes.BUBBLE_POP, position.x, position.y, position.z,
+			8, 0.05D, 0.03D, 0.05D, 0.01D);
+	}
+
+	private static void vomitImpact(ServerLevel level, Vec3 position) {
+		for (DustParticleOptions particle : new DustParticleOptions[] {
+			VOMIT_GREEN, VOMIT_YELLOW, VOMIT_ORANGE, VOMIT_BROWN}) {
+			level.sendParticles(particle, position.x, position.y, position.z, 3,
+				0.02D, 0.02D, 0.02D, 0.0D);
+		}
+		for (ColorParticleOption particle : new ColorParticleOption[] {
+			VOMIT_GREEN_MIST, VOMIT_YELLOW_MIST, VOMIT_ORANGE_MIST}) {
+			level.sendParticles(particle, position.x, position.y, position.z, 2,
+				0.03D, 0.022D, 0.03D, 0.0D);
+		}
+		level.sendParticles(ParticleTypes.SPLASH, position.x, position.y, position.z,
+			4, 0.035D, 0.015D, 0.035D, 0.01D);
+		level.sendParticles(ParticleTypes.SNEEZE, position.x, position.y, position.z,
+			2, 0.03D, 0.02D, 0.03D, 0.0D);
+		level.sendParticles(ParticleTypes.ITEM_SLIME, position.x, position.y, position.z,
+			3, 0.03D, 0.02D, 0.03D, 0.0D);
+		for (int index = 0; index < 2; index++) level.sendParticles(vomitChunk(level),
+			position.x, position.y, position.z, 1, 0.03D, 0.02D, 0.03D, 0.0D);
+	}
+}
@@ -0,0 +1,24 @@
+package fr.koka99cab.sanctuary26.onlyfun.api.abjection;
+
+import fr.koka99cab.sanctuary26.onlyfun.abjection.AbjectionRegistries;
+import net.minecraft.resources.Identifier;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+
+/** Minimal public object contract consumed by Ouch's Abjection projectile implementation. */
+public final class AbjectionItems {
+	private AbjectionItems() {
+	}
+
+	public static Item shitBall() {
+		return AbjectionRegistries.SHIT_BALL;
+	}
+
+	public static Identifier shitBallId() {
+		return Identifier.fromNamespaceAndPath("abjection", "shit_ball");
+	}
+
+	public static boolean isShitBall(ItemStack stack) {
+		return stack.is(AbjectionRegistries.SHIT_BALL);
+	}
+}
@@ -0,0 +1,39 @@
+package fr.koka99cab.sanctuary26.onlyfun.api.abjection;
+
+import java.util.Objects;
+import net.minecraft.core.Direction;
+import net.minecraft.core.Position;
+import net.minecraft.world.entity.projectile.Projectile;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+
+/**
+ * Owner-neutral projectile factory contract: Only Fun owns the item, while Ouch installs its
+ * combat implementation without creating a reverse dependency.
+ */
+public final class AbjectionProjectileApi {
+	@FunctionalInterface
+	public interface Factory {
+		Projectile create(Level level, Position position, ItemStack stack, Direction direction);
+	}
+
+	private static Factory factory;
+
+	private AbjectionProjectileApi() {
+	}
+
+	public static void registerFactory(Factory implementation) {
+		Objects.requireNonNull(implementation, "implementation");
+		if (factory != null) throw new IllegalStateException("Abjection projectile factory already registered");
+		factory = implementation;
+	}
+
+	public static Projectile create(Level level, Position position, ItemStack stack, Direction direction) {
+		if (factory == null) throw new IllegalStateException("Ouch has not registered the Abjection projectile factory");
+		return factory.create(level, position, stack, direction);
+	}
+
+	public static boolean isReady() {
+		return factory != null;
+	}
+}
@@ -3,17 +3,34 @@ package fr.koka99cab.sanctuary26.onlyfun.client;
 import fr.koka99cab.sanctuary26.iliketomoveit.physics.VehicleFlightPhysics;
 import fr.koka99cab.sanctuary26.onlyfun.chickenboat.ChickenBoatControlPayload;
 import fr.koka99cab.sanctuary26.onlyfun.chickenboat.ChickenBoatUtil;
+import fr.koka99cab.sanctuary26.onlyfun.OnlyFunMod;
+import fr.koka99cab.sanctuary26.onlyfun.network.ShitActionRequestPayload;
+import com.mojang.blaze3d.platform.InputConstants;
 import net.fabricmc.api.ClientModInitializer;
 import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
+import net.fabricmc.fabric.api.client.keymapping.v1.KeyMappingHelper;
 import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
+import net.minecraft.client.KeyMapping;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.entity.vehicle.boat.AbstractBoat;
+import org.lwjgl.glfw.GLFW;

 public final class OnlyFunClient implements ClientModInitializer {
+	private static final KeyMapping.Category ONLY_FUN_CATEGORY =
+		KeyMapping.Category.register(OnlyFunMod.id("onlyfun"));
+	private static KeyMapping shitKey;
+
 	@Override
 	public void onInitializeClient() {
+		shitKey = KeyMappingHelper.registerKeyMapping(new KeyMapping(
+			"key.onlyfun.shit", InputConstants.Type.KEYSYM, GLFW.GLFW_KEY_J, ONLY_FUN_CATEGORY));
 		ClientTickEvents.END_CLIENT_TICK.register(client -> {
 			if (client.player == null || client.level == null) return;
+			while (shitKey.consumeClick()) {
+				if (ClientPlayNetworking.canSend(ShitActionRequestPayload.ID)) {
+					ClientPlayNetworking.send(new ShitActionRequestPayload());
+				}
+			}
 			Entity vehicle = client.player.getVehicle();
 			if (!(vehicle instanceof AbstractBoat boat) || !ChickenBoatUtil.hasChickenPassenger(boat)) return;
 			if (!ClientPlayNetworking.canSend(ChickenBoatControlPayload.ID)) return;
@@ -0,0 +1,36 @@
+package fr.koka99cab.sanctuary26.onlyfun.command;
+
+import com.mojang.brigadier.Command;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import fr.koka99cab.sanctuary26.onlyfun.api.abjection.AbjectionActions;
+import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.Commands;
+import net.minecraft.network.chat.Component;
+import net.minecraft.server.level.ServerPlayer;
+
+/** Historical root commands, routed through the shared server action API. */
+public final class AbjectionCommands {
+	private AbjectionCommands() {
+	}
+
+	public static void register() {
+		CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> {
+			for (AbjectionActions.Action action : AbjectionActions.Action.values()) {
+				dispatcher.register(Commands.literal(action.id())
+					.executes(context -> start(context.getSource(), action)));
+			}
+		});
+	}
+
+	private static int start(CommandSourceStack source, AbjectionActions.Action action)
+		throws CommandSyntaxException {
+		ServerPlayer player = source.getPlayerOrException();
+		AbjectionActions.StartResult result = AbjectionActions.start(player, action);
+		if (result == AbjectionActions.StartResult.REJECTED) return 0;
+		String suffix = result == AbjectionActions.StartResult.RESTARTED ? "restarted" : "started";
+		source.sendSuccess(() -> Component.translatable(
+			"command.abjection." + action.id() + "." + suffix), false);
+		return Command.SINGLE_SUCCESS;
+	}
+}
@@ -9,7 +9,7 @@ import net.fabricmc.fabric.api.networking.v1.PayloadTypeRegistry;
 * Networking contract for Only Fun. Payload IDs must use the module namespace.
 */
 public final class OnlyFunNetworking {
-	public static final int PROTOCOL_VERSION = 2;
+	public static final int PROTOCOL_VERSION = 3;
 	private static boolean initialized;

 	private OnlyFunNetworking() {
@@ -21,7 +21,9 @@ public final class OnlyFunNetworking {
 		}
 		initialized = true;
 		PayloadTypeRegistry.serverboundPlay().register(ChickenBoatControlPayload.ID, ChickenBoatControlPayload.CODEC);
+		PayloadTypeRegistry.serverboundPlay().register(ShitActionRequestPayload.ID, ShitActionRequestPayload.CODEC);
 		ChickenBoatServerController.register();
+		fr.koka99cab.sanctuary26.onlyfun.abjection.ShitActionRequestHandler.register();
 		OnlyFunMod.LOGGER.debug("[{}] Networking contract v{} ready; chicken boat controls registered.",
 			OnlyFunMod.DISPLAY_NAME, PROTOCOL_VERSION);
 	}
@@ -0,0 +1,19 @@
+package fr.koka99cab.sanctuary26.onlyfun.network;
+
+import fr.koka99cab.sanctuary26.onlyfun.OnlyFunMod;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+
+/** Empty and therefore strictly bounded request to start the existing server-owned action. */
+public record ShitActionRequestPayload() implements CustomPacketPayload {
+	public static final Type<ShitActionRequestPayload> ID =
+		new Type<>(OnlyFunMod.id("c2s/shit_action"));
+	public static final StreamCodec<RegistryFriendlyByteBuf, ShitActionRequestPayload> CODEC =
+		CustomPacketPayload.codec((payload, buffer) -> {}, buffer -> new ShitActionRequestPayload());
+
+	@Override
+	public Type<? extends CustomPacketPayload> type() {
+		return ID;
+	}
+}
@@ -23,6 +23,12 @@ public final class OnlyFunItemPolicy {
 		"nether_portal", "end_portal", "end_gateway", "frosted_ice", "farmland", "dirt_path",
 		"dragon_egg", "filled_map", "written_book", "enchanted_book"
 	);
+	private static final Set<String> VANILLA_SHOP_GAMEPLAY_BYPASSES = Set.of(
+		"baked_potato", "beetroot_soup", "bread", "cake",
+		"cooked_beef", "cooked_chicken", "cooked_cod", "cooked_mutton",
+		"cooked_porkchop", "cooked_rabbit", "cooked_salmon", "cookie", "dried_kelp",
+		"enchanted_golden_apple", "mushroom_stew", "pumpkin_pie", "rabbit_stew", "suspicious_stew"
+	);

 	private OnlyFunItemPolicy() {}

@@ -35,8 +41,10 @@ public final class OnlyFunItemPolicy {
 		if (id == null || isCurrencyOre(id)) return true;
 		String namespace = id.getNamespace().toLowerCase(Locale.ROOT);
 		String path = normalizedPath(id);
-		if (namespace.equals("canaplia")) return true;
+		if (namespace.equals("canaplia") || namespace.equals("itsalive")) return true;
+		if (namespace.equals("minecraft") && VANILLA_SHOP_GAMEPLAY_BYPASSES.contains(path)) return true;
 		if (namespace.equals("anotherworld") && isProtectedAnotherWorldItem(path)) return true;
+		if (isStorageTerminal(namespace, path)) return true;
 		if (TECHNICAL_OR_REWARD_BLOCKS.contains(path) || path.startsWith("infested_")
 			|| path.contains("command_block")) return true;
 		if (path.contains("lootbox") || path.contains("loot_box")) return true;
@@ -54,6 +62,7 @@ public final class OnlyFunItemPolicy {
 		String namespace = id.getNamespace().toLowerCase(Locale.ROOT);
 		String path = normalizedPath(id);
 		return namespace.equals("canaplia") || path.contains("lootbox") || path.contains("loot_box")
+			|| isStorageTerminal(namespace, path)
 			|| (namespace.equals("onlyfun") && path.equals("lucky_block"))
 			|| (namespace.equals("sanctuary") && path.equals("delivery_box"))
 			|| TECHNICAL_OR_REWARD_BLOCKS.contains(path) || path.startsWith("infested_")
@@ -70,6 +79,10 @@ public final class OnlyFunItemPolicy {
 			|| path.contains("titanium") || path.contains("rainbow_block");
 	}

+	private static boolean isStorageTerminal(String namespace, String path) {
+		return namespace.equals("redstoner") && path.equals("storage_terminal");
+	}
+
 	private static String normalizedPath(Identifier id) {
 		return id.getPath().toLowerCase(Locale.ROOT);
 	}
@@ -1,6 +1,7 @@
 package fr.koka99cab.sanctuary26.onlyfun.registry;

 import fr.koka99cab.sanctuary26.onlyfun.OnlyFunMod;
+import fr.koka99cab.sanctuary26.onlyfun.abjection.AbjectionRegistries;
 import net.minecraft.core.Registry;
 import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.core.registries.Registries;
@@ -27,6 +28,8 @@ public final class OnlyFunCreativeTab {
 				output.accept(OnlyFunRegistries.CAPE_LOOTBOX);
 				output.accept(OnlyFunRegistries.SPAWN_EGG_LOOTBOX);
 				output.accept(OnlyFunRegistries.ANOMALY_LOOTBOX);
+				output.accept(AbjectionRegistries.SHIT_BALL);
+				output.accept(AbjectionRegistries.SHIT_CUBE_ITEM);
 			})
 			.build()
 	);
@@ -39,7 +39,9 @@ public final class OnlyFunShopCatalog implements ShopCatalogProvider {
 	}

 	@Override public boolean isAvailable(MinecraftServer server, String itemId) {
-		return OnlyFunBossShopGate.isAvailable(server, itemId);
+		Identifier id = Identifier.tryParse(itemId);
+		return id != null && !OnlyFunItemPolicy.excludedFromShop(id)
+			&& OnlyFunBossShopGate.isAvailable(server, itemId);
 	}

 	/** Registry-derived, deterministic and duplicate-free view of the enabled CSV rows. */
@@ -0,0 +1,7 @@
+{
+	"variants": {
+		"": {
+			"model": "abjection:block/shit_cube"
+		}
+	}
+}
@@ -0,0 +1,6 @@
+{
+	"model": {
+		"type": "minecraft:model",
+		"model": "abjection:item/shit_ball"
+	}
+}
@@ -0,0 +1,6 @@
+{
+	"model": {
+		"type": "minecraft:model",
+		"model": "abjection:item/shit_cube"
+	}
+}
@@ -0,0 +1,12 @@
+{
+	"item.abjection.shit_ball": "Shit Ball",
+	"block.abjection.shit_cube": "Shit Cube",
+	"command.abjection.piss.started": "Here we go for 15 seconds.",
+	"command.abjection.piss.restarted": "The timer restarts for 15 seconds.",
+	"command.abjection.vomit.started": "Yuck. You vomit for 8 seconds.",
+	"command.abjection.vomit.restarted": "You vomit again for 8 seconds.",
+	"command.abjection.shit.started": "You shit in a stream for 6 seconds.",
+	"command.abjection.shit.restarted": "The shit stream restarts for 6 seconds.",
+	"command.abjection.smoke.started": "You blow smoke for 10 seconds.",
+	"command.abjection.smoke.restarted": "You keep smoking for 10 seconds."
+}
@@ -0,0 +1,12 @@
+{
+	"item.abjection.shit_ball": "Boule de merde",
+	"block.abjection.shit_cube": "Cube de merde",
+	"command.abjection.piss.started": "C'est parti pour 15 secondes.",
+	"command.abjection.piss.restarted": "Le timer repart pour 15 secondes.",
+	"command.abjection.vomit.started": "Beurk. Tu vomis pendant 8 secondes.",
+	"command.abjection.vomit.restarted": "Tu revomis pour 8 secondes.",
+	"command.abjection.shit.started": "Tu chies en jet pendant 6 secondes.",
+	"command.abjection.shit.restarted": "Le jet de merde repart pour 6 secondes.",
+	"command.abjection.smoke.started": "Tu souffles de la fumée pendant 10 secondes.",
+	"command.abjection.smoke.restarted": "Tu continues de fumer pendant 10 secondes."
+}
@@ -0,0 +1,12 @@
+{
+	"item.abjection.shit_ball": "Шарик дерьма",
+	"block.abjection.shit_cube": "Куб дерьма",
+	"command.abjection.piss.started": "Струя запущена на 15 секунд.",
+	"command.abjection.piss.restarted": "Таймер струи перезапущен на 15 секунд.",
+	"command.abjection.vomit.started": "Фу. Тебя рвёт 8 секунд.",
+	"command.abjection.vomit.restarted": "Тебя снова рвёт 8 секунд.",
+	"command.abjection.shit.started": "Ты испражняешься струёй 6 секунд.",
+	"command.abjection.shit.restarted": "Струя дерьма перезапущена на 6 секунд.",
+	"command.abjection.smoke.started": "Ты выпускаешь дым 10 секунд.",
+	"command.abjection.smoke.restarted": "Ты продолжаешь курить ещё 10 секунд."
+}
@@ -0,0 +1,6 @@
+{
+	"parent": "minecraft:block/cube_all",
+	"textures": {
+		"all": "abjection:block/shit_cube"
+	}
+}
@@ -0,0 +1,6 @@
+{
+	"parent": "minecraft:item/generated",
+	"textures": {
+		"layer0": "abjection:item/shit_ball"
+	}
+}
@@ -0,0 +1,3 @@
+{
+	"parent": "abjection:block/shit_cube"
+}
@@ -41,5 +41,7 @@
 	"command.onlyfun.history": "Rolls: %s | dry streak: %s | anomalies: %s | last: %s",
 	"command.onlyfun.give": "Granted Only Fun source: %s",
 	"command.onlyfun.roll": "Outcome: %s (%s)",
-	"command.onlyfun.simulate": "Simulation %s × %s: %s"
+	"command.onlyfun.simulate": "Simulation %s × %s: %s",
+	"key.categories.onlyfun.onlyfun": "Only Fun",
+	"key.onlyfun.shit": "Shit"
 }
@@ -41,5 +41,7 @@
 	"command.onlyfun.history": "Tirages : %s | série sèche : %s | anomalies : %s | dernier : %s",
 	"command.onlyfun.give": "Source Only Fun donnée : %s",
 	"command.onlyfun.roll": "Résultat : %s (%s)",
-	"command.onlyfun.simulate": "Simulation %s × %s : %s"
+	"command.onlyfun.simulate": "Simulation %s × %s : %s",
+	"key.categories.onlyfun.onlyfun": "Only Fun",
+	"key.onlyfun.shit": "Chier"
 }
@@ -41,5 +41,7 @@
 	"command.onlyfun.history": "Розыгрыши: %s | серия: %s | аномалии: %s | последнее: %s",
 	"command.onlyfun.give": "Выдан источник Only Fun: %s",
 	"command.onlyfun.roll": "Результат: %s (%s)",
-	"command.onlyfun.simulate": "Симуляция %s × %s: %s"
+	"command.onlyfun.simulate": "Симуляция %s × %s: %s",
+	"key.categories.onlyfun.onlyfun": "Only Fun",
+	"key.onlyfun.shit": "Испражниться"
 }
@@ -0,0 +1,21 @@
+{
+	"type": "minecraft:block",
+	"pools": [
+		{
+			"bonus_rolls": 0.0,
+			"conditions": [
+				{
+					"condition": "minecraft:survives_explosion"
+				}
+			],
+			"entries": [
+				{
+					"type": "minecraft:item",
+					"name": "abjection:shit_cube"
+				}
+			],
+			"rolls": 1.0
+		}
+	],
+	"random_sequence": "abjection:blocks/shit_cube"
+}
@@ -0,0 +1,16 @@
+{
+	"type": "minecraft:crafting_shaped",
+	"category": "building",
+	"key": {
+		"#": "abjection:shit_ball"
+	},
+	"pattern": [
+		"###",
+		"###",
+		"###"
+	],
+	"result": {
+		"count": 1,
+		"id": "abjection:shit_cube"
+	}
+}
@@ -0,0 +1,6 @@
+{
+	"replace": false,
+	"values": [
+		"abjection:shit_cube"
+	]
+}
@@ -8,6 +8,9 @@
 		"KOKA99CAB"
 	],
 	"license": "GPL-3.0-or-later",
+	"provides": [
+		"abjection"
+	],
 	"icon": "assets/onlyfun/icon.png",
 	"environment": "*",
 	"entrypoints": {
@@ -31,7 +34,7 @@
 			"system_type": "gameplay-system",
 			"namespace": "onlyfun",
 			"data_version": 2,
-			"network_protocol": 2,
+			"network_protocol": 3,
 			"lifecycle": "${lifecycle}",
 			"pack_version": "${pack_version}",
 			"descriptions": {
@@ -0,0 +1,23 @@
+package fr.koka99cab.sanctuary26.onlyfun.abjection;
+
+import java.util.UUID;
+
+/** Executable check for one physical press and same-tick spam deduplication. */
+public final class ShitActionRequestSmoke {
+	private ShitActionRequestSmoke() {
+	}
+
+	public static void main(String[] args) {
+		UUID playerId = UUID.fromString("00000000-0000-0000-0000-000000000059");
+		require(ShitActionRequestHandler.acceptTick(playerId, 100), "first press was rejected");
+		require(!ShitActionRequestHandler.acceptTick(playerId, 100), "same-tick spam was accepted");
+		require(ShitActionRequestHandler.acceptTick(playerId, 101), "next physical press was rejected");
+		ShitActionRequestHandler.clear(playerId);
+		require(ShitActionRequestHandler.acceptTick(playerId, 101), "disconnect cleanup retained input state");
+		ShitActionRequestHandler.clear(playerId);
+	}
+
+	private static void require(boolean condition, String message) {
+		if (!condition) throw new AssertionError(message);
+	}
+}
@@ -0,0 +1,42 @@
+package fr.koka99cab.sanctuary26.onlyfun.api.abjection;
+
+import java.util.Set;
+import java.util.UUID;
+import net.minecraft.SharedConstants;
+import net.minecraft.server.Bootstrap;
+
+/** Executable regression check for the bounded historical action contract. */
+public final class AbjectionActionContractSmoke {
+	private AbjectionActionContractSmoke() {
+	}
+
+	public static void main(String[] args) {
+		SharedConstants.tryDetectVersion();
+		Bootstrap.bootStrap();
+		require(AbjectionActions.Action.PISS.durationTicks() == 300, "piss duration changed");
+		require(AbjectionActions.Action.VOMIT.durationTicks() == 160, "vomit duration changed");
+		require(AbjectionActions.Action.SHIT.durationTicks() == 120, "shit duration changed");
+		require(AbjectionActions.Action.SMOKE.durationTicks() == 200, "smoke duration changed");
+		require(Set.of("piss", "vomit", "shit", "smoke").equals(Set.of(
+			AbjectionActions.Action.PISS.id(), AbjectionActions.Action.VOMIT.id(),
+			AbjectionActions.Action.SHIT.id(), AbjectionActions.Action.SMOKE.id())),
+			"historical command surface changed");
+
+		UUID playerId = UUID.fromString("00000000-0000-0000-0000-000000000057");
+		require(!AbjectionActions.restart(playerId, AbjectionActions.Action.SHIT),
+			"first action incorrectly marked as a restart");
+		require(AbjectionActions.remaining(playerId, AbjectionActions.Action.SHIT) == 120,
+			"initial duration was not installed");
+		require(AbjectionActions.restart(playerId, AbjectionActions.Action.SHIT),
+			"second action was not marked as a restart");
+		require(AbjectionActions.remaining(playerId, AbjectionActions.Action.SHIT) == 120,
+			"restart did not reset the full duration");
+		AbjectionActions.clear(playerId);
+		require(AbjectionActions.remaining(playerId, AbjectionActions.Action.SHIT) == 0,
+			"cleanup left a temporary action behind");
+	}
+
+	private static void require(boolean condition, String message) {
+		if (!condition) throw new AssertionError(message);
+	}
+}
@@ -2,6 +2,7 @@ package fr.koka99cab.sanctuary26.onlyfun.shop;

 import fr.koka99cab.sanctuary26.onlyfun.policy.OnlyFunItemPolicy;
 import fr.koka99cab.sanctuary26.sanctuary.shop.ShopOffer;
+import fr.koka99cab.sanctuary26.sanctuary.shop.ShopOfferCatalog;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -60,6 +61,33 @@ public final class OnlyFunShopCatalogSmoke {
 		assertConfigured("anotherworld:golden_egg", 1, 2048, 192);
 		assertConfigured("iliketomoveit:magic_carpet", 1, 1536, 128);
 		assertConfigured("iliketomoveit:magic_cloud", 1, 3072, 192);
+		OnlyFunShopCatalog.initialize();
+		for (String excludedId : List.of(
+			"itsalive:apple_pie", "itsalive:basil", "itsalive:culinary_recipe_book",
+			"itsalive:fermentation_barrel", "itsalive:infected_spawn_egg",
+			"minecraft:baked_potato", "minecraft:beetroot_soup", "minecraft:bread",
+			"minecraft:cake", "minecraft:cooked_beef", "minecraft:cooked_chicken",
+			"minecraft:cooked_cod", "minecraft:cooked_mutton", "minecraft:cooked_porkchop",
+			"minecraft:cooked_rabbit", "minecraft:cooked_salmon", "minecraft:cookie",
+			"minecraft:dried_kelp", "minecraft:enchanted_golden_apple", "minecraft:mushroom_stew",
+			"minecraft:pumpkin_pie", "minecraft:rabbit_stew", "minecraft:suspicious_stew")) {
+			Identifier id = Identifier.parse(excludedId);
+			require(OnlyFunItemPolicy.excludedFromShop(id), "Gameplay bypass reached Shop policy: " + id);
+			require(find(all, excludedId) == null, "Gameplay bypass reached Shop catalogue: " + id);
+			require(ShopOfferCatalog.find(null, excludedId) == null,
+				"Server lookup accepted a forbidden saved offer: " + id);
+		}
+		for (String rawFoodId : List.of("minecraft:apple", "minecraft:carrot", "minecraft:potato")) {
+			require(!OnlyFunItemPolicy.excludedFromShop(Identifier.parse(rawFoodId)),
+				"Raw ingredient was removed with finished food: " + rawFoodId);
+		}
+		Identifier storageTerminal = Identifier.parse("redstoner:storage_terminal");
+		require(OnlyFunItemPolicy.excludedFromShop(storageTerminal),
+			"Storage Terminal reached the Shop policy");
+		require(OnlyFunItemPolicy.excludedFromRewards(storageTerminal),
+			"Storage Terminal reached lootbox rewards");
+		require(find(all, storageTerminal.toString()) == null,
+			"Storage Terminal reached the generated Shop catalogue");
 		require(OnlyFunBossShopGate.requiresBoss("iliketomoveit:magic_carpet"),
 			"Magic Carpet must remain boss-gated");
 		require(OnlyFunBossShopGate.requiresBoss("iliketomoveit:magic_cloud"),
@@ -12,9 +12,10 @@ def miningRifleTextureHash = "4e4295c5c8a8f71d03307809448ff64363eec2d2aefdc538c4

 tasks.register("verifyOuch") {
 	group = "verification"
-	description = "Checks Ouch alpha.9, including the Ambiance-backed Weather TNT and migrated Gunz arsenal."
+	description = "Checks Ouch alpha.10, including the shared Abjection projectile implementation."
 	inputs.files(fileTree("src/main/java"))
 	inputs.files(fileTree("src/main/resources"))
+	inputs.files(rootProject.fileTree("onlyfun/src/main/java"))
 	inputs.file(rootProject.file("pack/migrations/26.1.2-gunz-to-26.2.0-alpha.41.json"))
 	inputs.file(rootProject.file("pack/migrations/26.2.0-alpha.99-canon-weather-ownership-to-alpha.100.json"))
 	inputs.file(rootProject.file("pack/migrations/26.2.0-alpha.184-silver-engineering-to-alpha.185.json"))
@@ -25,6 +26,34 @@ tasks.register("verifyOuch") {
 		def weatherRegistry = file("src/main/java/fr/koka99cab/sanctuary26/ouch/registry/OuchWeatherTnt.java").text
 		def weatherEntity = file("src/main/java/fr/koka99cab/sanctuary26/ouch/entity/WeatherTntEntity.java").text
 		def manifest = new JsonSlurper().parse(file("src/main/resources/fabric.mod.json"))
+		def abjectionRegistry = file(
+			"src/main/java/fr/koka99cab/sanctuary26/ouch/registry/OuchAbjectionProjectiles.java").text
+		def abjectionEntity = file(
+			"src/main/java/fr/koka99cab/sanctuary26/ouch/entity/ShitBallEntity.java").text
+		def abjectionClient = file(
+			"src/main/java/fr/koka99cab/sanctuary26/ouch/client/OuchClient.java").text
+		def onlyFunProjectileApi = rootProject.file(
+			"onlyfun/src/main/java/fr/koka99cab/sanctuary26/onlyfun/api/abjection/AbjectionProjectileApi.java").text
+		if (manifest.depends?.onlyfun != ">=0.0.0-alpha.23"
+			|| manifest.custom?.sanctuary26?.data_version != 1
+			|| manifest.custom?.sanctuary26?.network_protocol != 1
+			|| !rootProject.file("build.gradle").text.contains('implementation project(":onlyfun")')
+			|| !onlyFunProjectileApi.contains("public interface Factory")
+			|| !abjectionRegistry.contains('AbjectionProjectileApi.registerFactory(')
+			|| !abjectionRegistry.contains('AbjectionItems.shitBallId()')
+			|| abjectionRegistry.contains('AbjectionRegistries')
+			|| !abjectionRegistry.contains('DispenserBlock.registerProjectileBehavior(AbjectionItems.shitBall())')
+			|| !abjectionRegistry.contains('UseItemCallback.EVENT.register')
+			|| !abjectionRegistry.contains('stack.consume(1, player)')
+			|| !abjectionRegistry.contains('Projectile.spawnProjectileFromRotation(')
+			|| !abjectionRegistry.contains('.sized(0.25F, 0.25F)')
+			|| !abjectionEntity.contains('NAUSEA_DURATION_TICKS = 7 * 20')
+			|| !abjectionEntity.contains('current == null ? 0 : current.getDuration()')
+			|| !abjectionEntity.contains('SoundEvents.MUD_PLACE')
+			|| !abjectionEntity.contains('discard()')
+			|| !abjectionClient.contains('new ThrownItemRenderer<>(context)')) {
+			throw new GradleException("Ouch alpha.10 Abjection projectile contract is incomplete")
+		}
 		if (!itemRegistry.contains("MIGRATED_WEAPONS = List.of(CREEPERLOCK, MITRAILLETTE, EXPULSEUR, ASPIRATEUR)")
 			|| !itemRegistry.contains("WEAPONS = List.of(CREEPERLOCK, MITRAILLETTE, EXPULSEUR, ASPIRATEUR, MINING_RIFLE, BETA_BOW)")
 			|| !creativeTab.contains('OuchMod.id("arsenal")')
@@ -89,7 +118,7 @@ tasks.register("verifyOuch") {
 		def creeperlockRecipe = new JsonSlurper().parse(file("src/main/resources/data/ouch/recipe/creeperlock.json"))
 		def silverEngineeringMigration = new JsonSlurper().parse(rootProject.file(
 			"pack/migrations/26.2.0-alpha.184-silver-engineering-to-alpha.185.json"))
-		if (project.version.toString() != "0.0.0-alpha.9"
+		if (project.version.toString() != "0.0.0-alpha.10"
 			|| mitrailletteRecipe.pattern != ["RRP", "IGI", " B "]
 			|| mitrailletteRecipe.key != [B: "minecraft:stone_button", G: "minecraft:redstone",
 				I: "anotherworld:silver_ingot", P: "anotherworld:silver_plate", R: "anotherworld:silver_rod"]
@@ -317,10 +346,23 @@ tasks.register("verifyOuch") {
 			throw new GradleException("Runtime Ouch resources must not re-register the legacy gunz namespace: ${forbiddenNamespaceReferences}")
 		}

-		logger.lifecycle("Ouch verified: 6 enchantable items, 4 custom enchantments, debuffed bases, shared headshots, 6 recipes and FR/EN/RU translations.")
+		logger.lifecycle("Ouch verified: arsenal, Weather TNT and shared Abjection projectile contract.")
 	}
 }

+tasks.named("test") {
+	failOnNoDiscoveredTests = false
+}
+
+tasks.register("shitBallContractSmoke", JavaExec) {
+	group = "verification"
+	description = "Checks additive and overflow-safe Shit Ball nausea."
+	dependsOn tasks.named("testClasses")
+	classpath = sourceSets.test.runtimeClasspath
+	mainClass = "fr.koka99cab.sanctuary26.ouch.entity.ShitBallContractSmoke"
+}
+
 tasks.named("check") {
+	dependsOn tasks.named("shitBallContractSmoke")
 	dependsOn tasks.named("verifyOuch")
 }
@@ -2,16 +2,20 @@ package fr.koka99cab.sanctuary26.ouch.client;

 import fr.koka99cab.sanctuary26.ouch.OuchMod;
 import fr.koka99cab.sanctuary26.ouch.entity.WeatherTntEntity;
+import fr.koka99cab.sanctuary26.ouch.registry.OuchAbjectionProjectiles;
 import fr.koka99cab.sanctuary26.ouch.registry.OuchWeatherTnt;
 import net.fabricmc.api.ClientModInitializer;
 import net.fabricmc.fabric.api.client.rendering.v1.EntityRendererRegistry;
 import net.minecraft.client.renderer.entity.EntityRenderer;
 import net.minecraft.client.renderer.entity.TntRenderer;
+import net.minecraft.client.renderer.entity.ThrownItemRenderer;
 import net.minecraft.world.entity.EntityType;

 public final class OuchClient implements ClientModInitializer {
 	@Override
 	public void onInitializeClient() {
+		EntityRendererRegistry.register(OuchAbjectionProjectiles.ENTITY,
+			context -> new ThrownItemRenderer<>(context));
 		registerWeatherRenderer(OuchWeatherTnt.ENTITY);
 		registerWeatherRenderer(OuchWeatherTnt.REDSTONER_COMPAT_ENTITY);
 		registerWeatherRenderer(OuchWeatherTnt.LEGACY_ENTITY);
@@ -0,0 +1,62 @@
+package fr.koka99cab.sanctuary26.ouch.entity;
+
+import fr.koka99cab.sanctuary26.onlyfun.api.abjection.AbjectionItems;
+import fr.koka99cab.sanctuary26.ouch.registry.OuchAbjectionProjectiles;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.sounds.SoundEvents;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.world.effect.MobEffectInstance;
+import net.minecraft.world.effect.MobEffects;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.projectile.throwableitemprojectile.ThrowableItemProjectile;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.phys.EntityHitResult;
+import net.minecraft.world.phys.HitResult;
+
+/** Server-authoritative historical Abjection projectile, owned by Ouch. */
+public final class ShitBallEntity extends ThrowableItemProjectile {
+	public static final int NAUSEA_DURATION_TICKS = 7 * 20;
+
+	public ShitBallEntity(EntityType<? extends ShitBallEntity> type, Level level) {
+		super(type, level);
+	}
+
+	public ShitBallEntity(Level level, LivingEntity owner, ItemStack stack) {
+		super(OuchAbjectionProjectiles.ENTITY, owner, level, stack.copyWithCount(1));
+	}
+
+	public ShitBallEntity(Level level, double x, double y, double z, ItemStack stack) {
+		super(OuchAbjectionProjectiles.ENTITY, x, y, z, level, stack.copyWithCount(1));
+	}
+
+	@Override
+	protected Item getDefaultItem() {
+		return AbjectionItems.shitBall();
+	}
+
+	@Override
+	protected void onHitEntity(EntityHitResult hit) {
+		super.onHitEntity(hit);
+		if (!(level() instanceof ServerLevel) || !(hit.getEntity() instanceof LivingEntity target)) return;
+		MobEffectInstance current = target.getEffect(MobEffects.NAUSEA);
+		int duration = extendedNauseaDuration(current == null ? 0 : current.getDuration());
+		target.addEffect(new MobEffectInstance(MobEffects.NAUSEA, duration), getOwner());
+	}
+
+	@Override
+	protected void onHit(HitResult hit) {
+		super.onHit(hit);
+		if (level() instanceof ServerLevel level) {
+			level.playSound(null, getX(), getY(), getZ(), SoundEvents.MUD_PLACE,
+				SoundSource.PLAYERS, 1.0F, 0.75F);
+			discard();
+		}
+	}
+
+	static int extendedNauseaDuration(int currentDuration) {
+		return (int) Math.min(Integer.MAX_VALUE, Math.max(0L, currentDuration) + NAUSEA_DURATION_TICKS);
+	}
+}
@@ -0,0 +1,69 @@
+package fr.koka99cab.sanctuary26.ouch.registry;
+
+import fr.koka99cab.sanctuary26.onlyfun.api.abjection.AbjectionItems;
+import fr.koka99cab.sanctuary26.onlyfun.api.abjection.AbjectionProjectileApi;
+import fr.koka99cab.sanctuary26.ouch.entity.ShitBallEntity;
+import net.fabricmc.fabric.api.event.player.UseItemCallback;
+import net.minecraft.core.Direction;
+import net.minecraft.core.Position;
+import net.minecraft.core.Registry;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.sounds.SoundEvents;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.stats.Stats;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.MobCategory;
+import net.minecraft.world.entity.projectile.Projectile;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.DispenserBlock;
+
+/** Shared manual/dispenser creation path for {@code abjection:shit_ball}. */
+public final class OuchAbjectionProjectiles {
+	private static final float SHOOT_POWER = 1.5F;
+	private static final ResourceKey<EntityType<?>> KEY = ResourceKey.create(
+		Registries.ENTITY_TYPE, AbjectionItems.shitBallId());
+	public static final EntityType<ShitBallEntity> ENTITY = Registry.register(
+		BuiltInRegistries.ENTITY_TYPE, KEY,
+		EntityType.Builder.<ShitBallEntity>of(ShitBallEntity::new, MobCategory.MISC)
+			.sized(0.25F, 0.25F).clientTrackingRange(4).updateInterval(10).build(KEY));
+	private static boolean initialized;
+
+	private OuchAbjectionProjectiles() {
+	}
+
+	public static void initialize() {
+		if (initialized) return;
+		initialized = true;
+		AbjectionProjectileApi.registerFactory(OuchAbjectionProjectiles::createFromDispenser);
+		DispenserBlock.registerProjectileBehavior(AbjectionItems.shitBall());
+		UseItemCallback.EVENT.register((player, level, hand) -> {
+			ItemStack stack = player.getItemInHand(hand);
+			if (!AbjectionItems.isShitBall(stack) || player.isSpectator()) return InteractionResult.PASS;
+			if (level.isClientSide()) return InteractionResult.SUCCESS;
+			if (!(level instanceof ServerLevel serverLevel)) return InteractionResult.FAIL;
+			serverLevel.playSound(null, player.getX(), player.getY(), player.getZ(),
+				SoundEvents.SNOWBALL_THROW, SoundSource.NEUTRAL, 0.5F,
+				0.4F / (serverLevel.getRandom().nextFloat() * 0.4F + 0.8F));
+			Projectile.spawnProjectileFromRotation(OuchAbjectionProjectiles::createFromPlayer,
+				serverLevel, stack, player, 0.0F, SHOOT_POWER, 1.0F);
+			player.awardStat(Stats.ITEM_USED.get(AbjectionItems.shitBall()));
+			stack.consume(1, player);
+			return InteractionResult.SUCCESS_SERVER;
+		});
+	}
+
+	public static ShitBallEntity createFromPlayer(ServerLevel level, LivingEntity owner, ItemStack stack) {
+		return new ShitBallEntity(level, owner, stack);
+	}
+
+	public static Projectile createFromDispenser(Level level, Position position, ItemStack stack,
+		Direction direction) {
+		return new ShitBallEntity(level, position.x(), position.y(), position.z(), stack);
+	}
+}
@@ -19,6 +19,7 @@ public final class OuchRegistries {
 		initialized = true;
 		OuchItems.initialize();
 		OuchWeatherTnt.initialize();
+		OuchAbjectionProjectiles.initialize();
 		OuchCreativeTab.initialize();
 		OuchMod.LOGGER.debug("[{}] Weapon registry hub initialized.", OuchMod.DISPLAY_NAME);
 	}
@@ -25,6 +25,7 @@
 		"fabric-api": ">=0.154.2+26.2",
 		"anotherworld": ">=0.0.0-alpha.46",
 		"ambiance": ">=0.0.0-alpha.12",
+		"onlyfun": ">=0.0.0-alpha.23",
 		"sanctuary": ">=0.0.0-alpha.110"
 	},
 	"custom": {
@@ -0,0 +1,27 @@
+package fr.koka99cab.sanctuary26.ouch.entity;
+
+import net.minecraft.SharedConstants;
+import net.minecraft.server.Bootstrap;
+
+/** Executable regression test for additive and overflow-safe nausea duration. */
+public final class ShitBallContractSmoke {
+	private ShitBallContractSmoke() {
+	}
+
+	public static void main(String[] args) {
+		SharedConstants.tryDetectVersion();
+		Bootstrap.bootStrap();
+		require(ShitBallEntity.NAUSEA_DURATION_TICKS == 140, "historical duration changed");
+		require(ShitBallEntity.extendedNauseaDuration(0) == 140, "first hit duration is wrong");
+		require(ShitBallEntity.extendedNauseaDuration(60) == 200,
+			"a new impact did not add seven seconds");
+		require(ShitBallEntity.extendedNauseaDuration(-10) == 140,
+			"negative input was not normalized");
+		require(ShitBallEntity.extendedNauseaDuration(Integer.MAX_VALUE) == Integer.MAX_VALUE,
+			"duration overflow was not saturated");
+	}
+
+	private static void require(boolean condition, String message) {
+		if (!condition) throw new AssertionError(message);
+	}
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
koka	1b1f3a791d	feat(redstoner): add storage terminal Verification 26.2 / check (pull_request) Canceled after 0s Details	2026-08-30 03:13:48 +02:00
koka	10b1cd9c5e	Merge pull request 'Fix white disc audio cadence and release alpha.216' (#89 ) from fix/white-disc-audio-quality into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #89	2026-08-29 23:26:10 +00:00
koka	ef18e0ae32	Fix white disc audio cadence and release alpha.216 Verification 26.2 / check (pull_request) Canceled after 0s Details	2026-08-30 01:19:02 +02:00
koka	1c2e000da3	Merge pull request 'release: Sanctuary 26.2.0-alpha.215 — disque blanc stabilisé' (#88 ) from release/26.2.0-alpha.215 into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #88	2026-08-29 22:54:40 +00:00
koka	9e35c244ec	release: prepare 26.2.0-alpha.215 Verification 26.2 / check (pull_request) Canceled after 0s Details	2026-08-30 00:52:59 +02:00
koka	e82cb33407	Merge pull request 'fix(ambiance): stabiliser la lecture du disque blanc' (#87 ) from fix/white-disc-playback-crash into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #87	2026-08-29 22:46:44 +00:00
koka	e126ec9eea	fix(ambiance): stabilize white disc playback Verification 26.2 / check (pull_request) Canceled after 0s Details	2026-08-29 21:36:04 +02:00
koka	13a74ddbd2	Merge pull request 'release: Sanctuary 26.2.0-alpha.214 — disque blanc solo' (#85 ) from release/26.2.0-alpha.214 into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #85	2026-08-29 18:44:13 +00:00
koka	b221ca1b52	release: prepare 26.2.0-alpha.214 Verification 26.2 / check (pull_request) Canceled after 0s Details	2026-08-29 20:40:54 +02:00
koka	05505279f8	Merge pull request 'fix(ambiance): attendre la synchronisation du disque blanc' (#84 ) from fix/white-disc-solo-sync into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #84	2026-08-29 18:35:33 +00:00
koka	61e66d3a11	fix(ambiance): attendre la synchronisation du disque blanc Verification 26.2 / check (pull_request) Canceled after 0s Details	2026-08-29 20:30:41 +02:00
koka	3aa36ed129	Merge pull request 'release: Sanctuary 26.2.0-alpha.213 — correctif Ambiance' (#83 ) from release/26.2.0-alpha.213 into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #83	2026-08-29 18:03:43 +00:00
koka	90b9eee27e	release: prepare 26.2.0-alpha.213 Verification 26.2 / check (pull_request) Canceled after 0s Details	2026-08-29 20:02:22 +02:00
koka	7d800d8932	Merge pull request 'fix(ambiance): corriger le crash des événements de niveau' (#82 ) from fix/ambiance-level-event-crash into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #82	2026-08-29 17:57:58 +00:00
koka	913a754f20	fix(ambiance): corriger le crash des événements de niveau Verification 26.2 / check (pull_request) Canceled after 0s Details	2026-08-29 19:54:46 +02:00
koka	73d32999e5	Merge pull request 'release: Sanctuary 26.2.0-alpha.212 — correctif de démarrage' (#81 ) from release/26.2.0-alpha.212 into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #81	2026-08-29 17:43:40 +00:00
koka	86034ca71f	release: prepare 26.2.0-alpha.212 Verification 26.2 / check (pull_request) Canceled after 0s Details	2026-08-29 19:41:04 +02:00
koka	db91698c09	Merge pull request 'fix(sanctuary): corriger le crash du clic molette' (#80 ) from fix/black-market-middle-click-crash into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #80	2026-08-29 17:35:20 +00:00
koka	7f74114d31	fix(sanctuary): corriger le crash du clic molette Verification 26.2 / check (pull_request) Canceled after 0s Details	2026-08-29 19:32:54 +02:00
koka	53db634ec2	Merge pull request 'release: Sanctuary 26.2.0-alpha.211 — Abjection et correctifs' (#79 ) from release/26.2.0-alpha.211 into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #79	2026-08-29 17:04:04 +00:00
koka	400f1f6289	release: prepare 26.2.0-alpha.211 Verification 26.2 / check (pull_request) Canceled after 0s Details	2026-08-29 18:57:52 +02:00
koka	596432f3f7	Merge pull request 'feat(onlyfun): ajouter la touche Abjection' (#78 ) from feature/abjection-keybind into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #78	2026-08-29 16:51:17 +00:00
koka	14980c993f	Merge branch 'main' into feature/abjection-keybind Verification 26.2 / check (pull_request) Canceled after 0s Details # Conflicts: # CHANGELOG.md # build.gradle	2026-08-29 18:49:57 +02:00
koka	e17433f28f	Merge pull request 'feat(ouch): restaurer le projectile Abjection' (#77 ) from feature/abjection-projectile into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #77	2026-08-29 16:41:13 +00:00
koka	0833d4e44f	Merge branch 'main' into feature/abjection-projectile Verification 26.2 / check (pull_request) Canceled after 0s Details # Conflicts: # CHANGELOG.md # build.gradle	2026-08-29 18:40:16 +02:00
koka	07b2eba5c5	Merge pull request 'feat(onlyfun): intégrer les actions Abjection' (#76 ) from feature/abjection-actions into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #76	2026-08-29 16:36:59 +00:00
koka	0f95a5cfc7	Merge branch 'main' into feature/abjection-actions Verification 26.2 / check (pull_request) Canceled after 0s Details # Conflicts: # CHANGELOG.md # build.gradle	2026-08-29 18:35:00 +02:00
koka	028d63b64a	Merge pull request 'feat(ambiance): ajouter le disque blanc YouTube (#62 )' (#75 ) from feature/white-disc-youtube into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #75	2026-08-29 16:30:44 +00:00
koka	61ba842206	Merge branch 'main' into feature/white-disc-youtube Verification 26.2 / check (pull_request) Canceled after 0s Details # Conflicts: # CHANGELOG.md # build.gradle	2026-08-29 18:29:42 +02:00
koka	0476a74d43	Merge pull request 'feat(sanctuary): rétablir le Black Market au clic molette (#68 )' (#74 ) from feature/black-market-middle-click into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #74	2026-08-29 16:17:00 +00:00
koka	d5fe55ddcc	Merge branch 'main' into feature/black-market-middle-click Verification 26.2 / check (pull_request) Canceled after 0s Details # Conflicts: # CHANGELOG.md # build.gradle	2026-08-29 18:12:40 +02:00
koka	4a9f50e488	Merge pull request 'fix(canaplia): restaurer les pages vanilla du Livre interdit (#72 )' (#73 ) from fix/canaplia-normal-pages into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #73	2026-08-29 16:08:49 +00:00
koka	b9aabae914	fix(canaplia): restaurer les pages vanilla Verification 26.2 / check (pull_request) Canceled after 0s Details	2026-08-29 18:07:31 +02:00
koka	b121606b4e	Merge pull request 'release: Sanctuary 26.2.0-alpha.210 — Livre interdit et correctifs' (#71 ) from release/26.2.0-alpha.210 into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #71	2026-08-29 15:44:14 +00:00
koka	fa40548db7	release: prepare 26.2.0-alpha.210 Verification 26.2 / check (pull_request) Canceled after 0s Details	2026-08-29 17:39:01 +02:00
koka	7ee1e5f094	fix(ambiance): reprendre la texture vanilla du disque blanc	2026-08-29 17:09:48 +02:00
koka	91b4def490	feat(onlyfun): ajouter la touche Abjection	2026-08-29 15:21:38 +02:00
koka	122ff939aa	feat(ouch): restaurer le projectile Abjection	2026-08-29 15:17:37 +02:00
koka	3fef2d5437	feat(onlyfun): importer les actions Abjection	2026-08-29 15:10:14 +02:00
koka	75ddc5b682	feat(ambiance): ajouter le disque blanc YouTube	2026-08-29 14:59:38 +02:00
koka	bf09bdfa78	feat(sanctuary): ouvrir le Black Market au clic molette	2026-08-29 14:31:20 +02:00
koka	2df4f35e48	Merge pull request 'feat(itsalive): transformer le Codex en Livre interdit (#65 )' (#70 ) from feature/canaplia-forbidden-book into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #70	2026-08-29 12:19:25 +00:00
koka	4b4881d922	feat(itsalive): transformer le Codex en Livre interdit Verification 26.2 / check (pull_request) Canceled after 0s Details	2026-08-29 14:16:34 +02:00
koka	66cd185983	Merge pull request 'feat(iliketomoveit): accélérer le Happy Ghast monté (#61 )' (#69 ) from feature/happy-ghast-cruise-speed into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #69	2026-08-29 12:02:52 +00:00
koka	bd93dc1cd6	feat(iliketomoveit): accélérer le Happy Ghast monté Verification 26.2 / check (pull_request) Canceled after 0s Details	2026-08-29 13:17:50 +02:00
koka	2838bf0767	Merge pull request 'fix(sanctuary): réserver les requêtes aux panneaux dédiés (#25 )' (#67 ) from fix/request-sign-block-only into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #67	2026-08-29 11:11:41 +00:00
koka	e6740ff891	fix(sanctuary): réserver les requêtes aux panneaux dédiés Verification 26.2 / check (pull_request) Canceled after 0s Details	2026-08-29 12:59:08 +02:00
koka	054c8e4ad4	Merge pull request 'fix(sanctuary): resynchroniser les capes à la reconnexion (#13 )' (#66 ) from fix/cape-reconnect-sync into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #66	2026-08-29 10:54:41 +00:00
koka	4b11d217c2	fix(sanctuary): resynchroniser les capes à la reconnexion Verification 26.2 / check (pull_request) Canceled after 0s Details	2026-08-29 12:43:32 +02:00
koka	3923b8547c	Merge pull request 'feat(sanctuary): nommer tous les zombies façon Xbox 360 (#33 )' (#64 ) from feature/zombie-xbox-gamertags into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #64	2026-08-29 10:37:23 +00:00
koka	76915e2f44	feat(sanctuary): nommer les zombies façon Xbox 360 Verification 26.2 / check (pull_request) Canceled after 0s Details	2026-08-29 12:30:11 +02:00
koka	5aaaf3831c	Merge pull request 'fix(onlyfun): retirer les raccourcis de gameplay du Shop (#34 )' (#63 ) from fix/shop-gameplay-bypasses into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #63	2026-08-29 10:27:03 +00:00
koka	37beda56ec	fix(onlyfun): retirer les raccourcis du Shop Verification 26.2 / check (pull_request) Canceled after 0s Details	2026-08-29 12:13:15 +02:00
koka	5d48917cf4	Merge pull request 'fix(sanctuary): séparer les statuts du Shop (#32 )' (#60 ) from fix/shop-timer-overlap into main Verification 26.2 / check (push) Canceled after 0s Details Reviewed-on: #60	2026-08-29 10:09:04 +00:00