From 28d7718764ad1e7b58848b5c81c83fd783fa2820 Mon Sep 17 00:00:00 2001
From: Emerald-Railroad <axelmenges84@gmail.com>
Date: Mon, 31 Aug 2026 20:57:33 -0500
Subject: [PATCH] Add custom theater screens and Screenwriter automation

Add custom theater screens and Screenwriter automation
---
 CHANGELOG.md                                  |  136 +++
 README.md                                     |   30 +-
 build-mod.bat                                 |    2 +-
 gradle.properties                             |    2 +-
 run-client.bat                                |    2 +-
 settings.gradle                               |    2 +-
 .../pixelreel/client/ClientNetworking.java    |   29 +
 .../com/pixelreel/client/PixelReelClient.java |   15 +
 .../gui/CustomScreenPlacementScreen.java      |  144 +++
 .../client/gui/MediaSourceScreen.java         |    8 +-
 .../client/gui/PlaybackControlScreen.java     |    5 +
 .../client/gui/ScreenwriterLinkScreen.java    |   99 ++
 .../client/playback/ChannelPlayer.java        |   54 +-
 .../client/playback/DirectAudioSink.java      |  196 +++
 .../client/playback/PlaybackManager.java      |  190 ++-
 .../client/playback/video/VlcRuntime.java     |    2 +-
 .../render/DisplayBlockEntityRenderer.java    |   82 +-
 .../client/render/DisplayRenderState.java     |    2 +
 src/main/java/com/pixelreel/ClientBridge.java |   19 +
 src/main/java/com/pixelreel/PixelReel.java    |    7 +
 .../blockentities/DisplayBlockEntity.java     |  104 +-
 .../blockentities/ScreenPanelBlockEntity.java |    6 +-
 .../com/pixelreel/blocks/DisplayBlock.java    |   60 +-
 .../com/pixelreel/blocks/DisplayGeometry.java |  162 +++
 .../com/pixelreel/blocks/DisplayType.java     |   12 +-
 .../pixelreel/blocks/ScreenPanelBlock.java    |   17 +
 .../com/pixelreel/blocks/ScreenShapes.java    |   80 +-
 .../blocks/ScreenwriterConsoleBlock.java      |   33 +
 .../commands/ScreenwriterCommand.java         |  179 +++
 .../com/pixelreel/commands/TvCommand.java     |    2 +-
 .../items/CustomScreenBlockItem.java          |   32 +
 .../pixelreel/items/RemoteControlItem.java    |   54 +
 .../networking/ModNetworkPayloads.java        |   56 +
 .../networking/ServerNetworking.java          |  123 ++
 .../pixelreel/ondemand/OnDemandCatalog.java   |    9 +
 .../com/pixelreel/registry/ModBlocks.java     |   14 +-
 .../pixelreel/registry/ModCreativeTabs.java   |    2 +-
 .../java/com/pixelreel/registry/ModItems.java |   29 +-
 .../pixelreel/server/ScreenwriterManager.java | 1067 +++++++++++++++++
 .../blockstates/screenwriter_console.json     |    5 +
 .../assets/pixelreel/items/cinema_screen.json |    2 +-
 .../pixelreel/items/curved_cinema_screen.json |    2 +-
 .../pixelreel/items/remote_control.json       |    1 +
 .../pixelreel/items/screenwriter_console.json |    6 +
 .../assets/pixelreel/lang/en_us.json          |  102 +-
 .../models/block/screenwriter_console.json    |    6 +
 .../pixelreel/models/item/remote_control.json |    1 +
 .../models/item/screenwriter_console.json     |    3 +
 .../textures/block/screenwriter_console.png   |  Bin 0 -> 28764 bytes
 .../textures/item/remote_control.png          |  Bin 0 -> 127 bytes
 .../blocks/screenwriter_console.json          |   20 +
 .../data/pixelreel/recipe/cinema_screen.json  |    3 +-
 .../recipe/curved_cinema_screen.json          |    3 +-
 .../data/pixelreel/recipe/remote_control.json |   18 +
 .../recipe/screenwriter_console.json          |   18 +
 src/main/resources/fabric.mod.json            |    7 +-
 56 files changed, 3023 insertions(+), 241 deletions(-)
 create mode 100644 CHANGELOG.md
 create mode 100644 src/client/java/com/pixelreel/client/gui/CustomScreenPlacementScreen.java
 create mode 100644 src/client/java/com/pixelreel/client/gui/ScreenwriterLinkScreen.java
 create mode 100644 src/client/java/com/pixelreel/client/playback/DirectAudioSink.java
 create mode 100644 src/main/java/com/pixelreel/blocks/DisplayGeometry.java
 create mode 100644 src/main/java/com/pixelreel/blocks/ScreenwriterConsoleBlock.java
 create mode 100644 src/main/java/com/pixelreel/commands/ScreenwriterCommand.java
 create mode 100644 src/main/java/com/pixelreel/items/CustomScreenBlockItem.java
 create mode 100644 src/main/java/com/pixelreel/items/RemoteControlItem.java
 create mode 100644 src/main/java/com/pixelreel/server/ScreenwriterManager.java
 create mode 100644 src/main/resources/assets/pixelreel/blockstates/screenwriter_console.json
 create mode 100644 src/main/resources/assets/pixelreel/items/remote_control.json
 create mode 100644 src/main/resources/assets/pixelreel/items/screenwriter_console.json
 create mode 100644 src/main/resources/assets/pixelreel/models/block/screenwriter_console.json
 create mode 100644 src/main/resources/assets/pixelreel/models/item/remote_control.json
 create mode 100644 src/main/resources/assets/pixelreel/models/item/screenwriter_console.json
 create mode 100644 src/main/resources/assets/pixelreel/textures/block/screenwriter_console.png
 create mode 100644 src/main/resources/assets/pixelreel/textures/item/remote_control.png
 create mode 100644 src/main/resources/data/pixelreel/loot_table/blocks/screenwriter_console.json
 create mode 100644 src/main/resources/data/pixelreel/recipe/remote_control.json
 create mode 100644 src/main/resources/data/pixelreel/recipe/screenwriter_console.json

diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..b1ed177
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,136 @@
+# PixelReel Custom Fork Changelog
+
+## v1.1.0
+
+Screenwriter media-server load controls.
+
+- Screenwriter now starts **OFF by default** in fresh worlds. Existing worlds keep their saved ON/OFF state.
+- Added `/screenwriter maxstreams <0-30>` to cap the number of **simultaneous scheduled auditorium shows**.
+- Default simultaneous-show limit is **4**. A value of `0` means unlimited.
+- Daily schedule generation now respects that cap for the complete duration of every movie, not just the start time.
+- Scheduling is built chronologically across all linked auditoriums so higher auditorium numbers still receive shows as capacity becomes available.
+- Changing the limit preserves the already-generated day; `/screenwriter regenerate` applies the new setting to today's schedule.
+- `/screenwriter status` now reports the configured simultaneous-show limit.
+
+## v1.0.0
+
+First formal release of the theater-focused PixelReel Custom Fork.
+
+### Custom cinema screens
+
+- Replaced the normal screen lineup with two user-facing theater screens:
+  - **Custom Cinema Screen** — flat.
+  - **Custom Curved Cinema Screen** — dynamically curved using the original PixelReel curved-screen profile.
+- Both screens open a placement menu for custom width, height, audio depth, and side range.
+- Supported custom dimensions: **1–64 blocks wide** and **1–36 blocks tall**.
+- Default custom dimensions: **27 × 11**.
+- Screen placement validates that all required panel cells are available before consuming the item.
+- Custom screen geometry, size, and audio-zone settings persist in the block entity and sync to clients.
+- Flat screens render/collide against the back face of their occupied cells so they can sit flush against a wall.
+- Breaking any generated screen panel removes the complete bound display. Survival drops the controller item normally; creative does not duplicate it.
+- Legacy preset display registrations remain internally for world compatibility, but the old preset TV/monitor items are no longer part of the normal creative/crafting lineup.
+
+### Auditorium audio
+
+- Custom screens use a hard auditorium-shaped audio zone rather than circular distance attenuation.
+- Default audio zone: **40 blocks forward**, **2 blocks beyond each screen edge**, and **1 block behind the screen**.
+- Audio remains at the screen's configured volume anywhere inside the zone and becomes silent outside it.
+- The client chooses at most one audible screen when zones overlap.
+- Replaced shared LibVLC native volume output with per-screen decoded PCM callbacks and independent JavaSound output.
+- Each physical screen has its own playback/audio session, preventing simultaneous auditorium tracks from mixing.
+
+### Remote Control
+
+- Added a Remote Control that can target screens from a longer distance and open normal screen controls.
+- Added **Reset Connection** to rebuild only the local client's media/audio session for the selected screen and reconnect at the current synchronized playback position.
+- The remote is also used to link custom cinema screens to Screenwriter.
+- Recipe:
+
+```text
+II
+RB
+II
+```
+
+- `I` = Iron Ingot
+- `R` = Redstone
+- `B` = any Button
+
+### Screenwriter theater automation
+
+- Added the **Screenwriter Console** for centralized real-world theater scheduling.
+- Supports up to **30 linked custom cinema screens**.
+- Auditorium numbers are user-selected and unique from **1–30**; link order does not determine auditorium number.
+- Re-linking can change an auditorium number without deleting that auditorium's current generated schedule.
+- Right-click the console to arm linking; sneak + right-click a custom screen with the Remote Control to open the auditorium link/update menu.
+- Shift + right-click the console toggles Screenwriter on/off.
+- Screenwriter can also be enabled/disabled through commands.
+- Generates a new schedule for the current real-world day from configured **Jellyfin or Plex** movie libraries.
+- Provider mode can be `AUTO`, `JELLYFIN`, or `PLEX`; AUTO prefers Jellyfin when available and otherwise uses Plex.
+- Only movies with runtime metadata are scheduled.
+- Uses runtime metadata to calculate exact end times.
+- Supports configurable theater opening/closing times, turnaround gaps, and first-show staggering.
+- Default settings:
+  - open: **11:00 AM**
+  - close: **11:30 PM**
+  - turnaround: **20 minutes**
+  - first-show stagger window: **30 minutes**
+  - later-show rounding: **10 minutes**
+- The first show in each auditorium is distributed through the stagger window rather than starting every auditorium at opening time.
+- A movie used in the previous **3 calendar days** is excluded from the current day's random schedule.
+- A movie is used at most once in the same generated day.
+- Schedules are saved to `pixelreel-screenwriter.json` in the world folder and are not rerolled by server restarts.
+- If the server starts during an active scheduled movie, Screenwriter resumes that movie at the elapsed real-world position.
+- Screenwriter powers linked displays off between shows.
+- Turning Screenwriter off stops its controlled playback and prevents automatic generation until re-enabled.
+
+### Screenwriter commands
+
+```text
+/screenwriter
+/screenwriter status
+/screenwriter on
+/screenwriter off
+/screenwriter schedule
+/screenwriter book
+/screenwriter generate
+/screenwriter regenerate
+/screenwriter source <auto|jellyfin|plex>
+/screenwriter open <time>
+/screenwriter close <time>
+/screenwriter turnaround <minutes>
+/screenwriter stagger <minutes>
+```
+
+Opening/closing times accept compact 24-hour input such as `930`, `1100`, `1830`, and `2330`; colon-formatted input is also accepted internally.
+
+### Schedule book and chat output
+
+- `/screenwriter schedule` prints the complete current schedule in chat.
+- `/screenwriter book` gives the player a written book titled **Today's Movie Schedule**.
+- Book pages wrap long movie titles and automatically continue an auditorium onto additional pages rather than cutting off shows.
+
+### Screenwriter Console recipe and texture
+
+Recipe:
+
+```text
+III
+IRI
+DDD
+```
+
+- `I` = Iron Ingot
+- `R` = Redstone
+- `D` = Polished Deepslate
+
+The Screenwriter Console uses a custom pixel-art theater scheduling/control texture.
+
+### Compatibility and release identity
+
+- Display name: **PixelReel Custom Fork**.
+- Release version: **1.1.0**.
+- Build artifact: `pixelreel-custom-fork-1.1.0.jar`.
+- Internal Fabric mod id intentionally remains `pixelreel` to preserve existing registry IDs and world compatibility.
+- Target: Minecraft `26.3-snapshot-5`, Fabric Loader `>=0.19.3`, Java 25+.
+- VLC/libVLC remains required on clients for playback.
diff --git a/README.md b/README.md
index 1decc2e..6cb0cc9 100644
--- a/README.md
+++ b/README.md
@@ -1,9 +1,27 @@
-# pixelReel
+# PixelReel Custom Fork
 
 Fabric mod for **Minecraft Java Edition 26.3-snapshot-5** that lets you place televisions and cinema screens in your world and watch **live TV** and **on-demand media** together with friends.
 
 Live channels come from a Tunarr (or any M3U + XMLTV) playlist. Movies and shows can come from **Jellyfin**, **Emby**, or **Plex**. Each display keeps its own channel or title, multiple screens can play at once, and audio is positional.
 
+
+## Custom Fork v1.1.0
+
+This is **PixelReel Custom Fork v1.1.0**, a theater-focused fork of PixelReel for Minecraft Java Edition `26.3-snapshot-5`. The internal mod id remains `pixelreel` so existing worlds keep their registered blocks/items. The build artifact is `pixelreel-custom-fork-1.1.0.jar`.
+
+Version 1 adds:
+
+- configurable **Custom Cinema Screen** and **Custom Curved Cinema Screen** sizes;
+- flush wall mounting and whole-screen removal from any panel;
+- independent auditorium-shaped audio with true per-screen PCM output;
+- a long-range **Remote Control** with connection reset and Screenwriter linking;
+- **Screenwriter**, a central theater automation console for up to 30 auditoriums;
+- Screenwriter starts **OFF by default** in fresh worlds and defaults to a **4-show simultaneous scheduling cap** to reduce media-server load;
+- automatic daily Jellyfin/Plex movie schedules with runtimes, turnaround time, opening/closing hours, first-show staggering, a three-day no-repeat rule, and configurable simultaneous-show limiting;
+- persistent schedules, restart/resume synchronization, chat schedules, and written schedule books.
+
+See `CHANGELOG.md` for the v1 feature list and `GITHUB_PULL_REQUEST_DESCRIPTION.md` for a detailed implementation overview.
+
 ## Requirements
 
 
@@ -41,7 +59,7 @@ gradlew.bat clean build
 The installable JAR is:
 
 ```text
-build\libs\pixelreel-1.0.0.jar
+build\libs\pixelreel-custom-fork-1.1.0.jar
 ```
 
 Use the JAR **without** `-sources`.
@@ -56,7 +74,7 @@ run-client.bat
 
 1. Install Fabric Loader for Minecraft **26.3-snapshot-5**.
 2. Put **Fabric API** in your `mods` folder.
-3. Put `pixelreel-1.0.0.jar` in `mods`.
+3. Put `pixelreel-custom-fork-1.1.0.jar` in `mods`.
 4. Install **64-bit VLC** on every client that should see video.
 
 The mod runs on clients and servers (`environment: *`). For multiplayer, **both sides** need the mod. VLC is only required on clients.
@@ -218,7 +236,6 @@ What already works in this snapshot build — crossed out as complete:
 - [x] ~~Subtitles, letterboxing, and HDR tone mapping~~
 - [x] ~~Pixel Glasses fullscreen overlay~~
 - [x] ~~Craftable displays + creative tab~~
-- [x] Fabric mod targeting Minecraft **1.21.1**
 
 ### Upcoming
 
@@ -229,13 +246,10 @@ What already works in this snapshot build — crossed out as complete:
 | **Movie scheduler** | Planned | Medium | Queue showtimes (date/time + title or channel). Auto power-on, start playback, and optional lobby announcements for cinema nights. |
 | **YouTube / streaming integration** | Planned | Medium | Play YouTube (and possibly other stream sources) on displays alongside Tunarr and media servers. Exact providers TBD. |
 | **Posters as paintings** | Planned | Medium | Place movie/show posters in the world as painting-style decor (from library artwork), not only inside the browse menus. |
-| **Fabric on stable versions** | Planned | High | Port from `26.3-snapshot-5` to older/stable Fabric target **1.20.1**. |
+| **Fabric on stable versions** | Planned | High | Port from `26.3-snapshot-5` to older/stable Fabric targets such as **1.21.1** and **1.20.1**. |
 | **NeoForge support** | Planned | High | First-class NeoForge build so servers/clients on NeoForge can run pixelReel. |
 | **Forge support** | Planned | Medium | Forge port after (or alongside) NeoForge, depending on version demand. |
 
-DISCORD: https://discord.gg/RSWQuEnMj
-Mincraft Mod 1.21.1: https://github.com/Samarth-programming/PixelReel_1.21.1
-
 Ideas and PRs welcome — especially for loaders, version ports, and the admin remote.
 
 
diff --git a/build-mod.bat b/build-mod.bat
index c4056aa..d19f153 100644
--- a/build-mod.bat
+++ b/build-mod.bat
@@ -1,5 +1,5 @@
 @echo off
-rem Builds the pixelReel mod JAR into build\libs\
+rem Builds the PixelReel Custom Fork JAR into build\libs\
 setlocal
 cd /d "%~dp0"
 call gradlew.bat clean build
diff --git a/gradle.properties b/gradle.properties
index 16bf15a..a3d0cea 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -12,7 +12,7 @@ loader_version=0.19.3
 loom_version=1.17-SNAPSHOT
 
 # Mod Properties
-mod_version=1.0.0
+mod_version=1.1.0
 maven_group=com.pixelreel
 
 # Dependencies
diff --git a/run-client.bat b/run-client.bat
index 0821c2e..add3425 100644
--- a/run-client.bat
+++ b/run-client.bat
@@ -1,5 +1,5 @@
 @echo off
-rem Launches a Minecraft 26.3-snapshot-5 development client with the pixelReel mod.
+rem Launches a Minecraft 26.3-snapshot-5 development client with the PixelReel Custom Fork.
 rem Requires 64-bit VLC to be installed for video playback (https://www.videolan.org).
 setlocal
 cd /d "%~dp0"
diff --git a/settings.gradle b/settings.gradle
index b333a76..7fbb120 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -10,4 +10,4 @@ pluginManagement {
 }
 
 // Should match your modid
-rootProject.name = 'pixelreel'
+rootProject.name = 'pixelreel-custom-fork'
diff --git a/src/client/java/com/pixelreel/client/ClientNetworking.java b/src/client/java/com/pixelreel/client/ClientNetworking.java
index 03718e9..31a1c61 100644
--- a/src/client/java/com/pixelreel/client/ClientNetworking.java
+++ b/src/client/java/com/pixelreel/client/ClientNetworking.java
@@ -22,6 +22,7 @@
 import net.minecraft.client.Minecraft;
 import net.minecraft.core.BlockPos;
 import net.minecraft.network.chat.Component;
+import net.minecraft.world.InteractionHand;
 
 public final class ClientNetworking {
 	private static OnDemandProvider pendingBrowseProvider = OnDemandProvider.JELLYFIN;
@@ -258,6 +259,34 @@ public static void unequipPixelGlasses() {
 		}
 	}
 
+	public static void placeCustomScreen(
+		BlockPos pos, int width, int height, int audioDepth, int audioSide, InteractionHand hand
+	) {
+		if (ClientPlayNetworking.canSend(ModNetworkPayloads.PlaceCustomScreen.TYPE)) {
+			ClientPlayNetworking.send(new ModNetworkPayloads.PlaceCustomScreen(
+				pos, width, height, ModNetworkPayloads.PlaceCustomScreen.packAudioSettings(audioDepth, audioSide),
+				hand == InteractionHand.OFF_HAND
+			));
+		}
+	}
+
+	public static void configureScreenwriterLink(BlockPos pos, int auditorium, boolean unlink) {
+		if (ClientPlayNetworking.canSend(ModNetworkPayloads.ScreenwriterLink.TYPE)) {
+			ClientPlayNetworking.send(new ModNetworkPayloads.ScreenwriterLink(pos, auditorium, unlink));
+		}
+	}
+
+
+	public static void resetLocalPlaybackConnection(BlockPos pos) {
+		Minecraft minecraft = Minecraft.getInstance();
+		boolean reset = PlaybackManager.INSTANCE.resetConnection(pos);
+		if (minecraft.player != null) {
+			minecraft.player.sendOverlayMessage(Component.translatable(
+				reset ? "message.pixelreel.playback.connection_reset" : "message.pixelreel.playback.no_connection"
+			));
+		}
+	}
+
 	public static void sendControl(BlockPos pos, ScreenAction action, float value) {
 		if (ClientPlayNetworking.canSend(ModNetworkPayloads.ScreenControl.TYPE)) {
 			ClientPlayNetworking.send(new ModNetworkPayloads.ScreenControl(pos, action, value));
diff --git a/src/client/java/com/pixelreel/client/PixelReelClient.java b/src/client/java/com/pixelreel/client/PixelReelClient.java
index 80f0a8d..2ef3f53 100644
--- a/src/client/java/com/pixelreel/client/PixelReelClient.java
+++ b/src/client/java/com/pixelreel/client/PixelReelClient.java
@@ -4,6 +4,8 @@
 import com.pixelreel.blockentities.DisplayBlockEntity;
 import com.pixelreel.blocks.DisplayBlock;
 import com.pixelreel.PixelReel;
+import com.pixelreel.client.gui.CustomScreenPlacementScreen;
+import com.pixelreel.client.gui.ScreenwriterLinkScreen;
 import com.pixelreel.client.playback.PlaybackManager;
 import com.pixelreel.client.playback.video.VlcRuntime;
 import com.pixelreel.client.render.DisplayBlockEntityRenderer;
@@ -19,6 +21,7 @@
 import net.minecraft.client.renderer.blockentity.BlockEntityRenderers;
 import net.minecraft.core.BlockPos;
 import net.minecraft.network.chat.Component;
+import net.minecraft.world.InteractionHand;
 import net.minecraft.world.phys.BlockHitResult;
 import net.minecraft.world.phys.HitResult;
 
@@ -42,6 +45,18 @@ public void openChannelMenu(BlockPos controllerPos) {
 			public void releasePlayback(BlockPos controllerPos) {
 				PlaybackManager.INSTANCE.release(controllerPos);
 			}
+
+			@Override
+			public void openCustomScreenPlacement(BlockPos controllerPos, InteractionHand hand, boolean curved) {
+				Minecraft minecraft = Minecraft.getInstance();
+				minecraft.execute(() -> minecraft.gui.setScreen(new CustomScreenPlacementScreen(controllerPos, hand, curved)));
+			}
+
+			@Override
+			public void openScreenwriterLink(BlockPos controllerPos) {
+				Minecraft minecraft = Minecraft.getInstance();
+				minecraft.execute(() -> minecraft.gui.setScreen(new ScreenwriterLinkScreen(controllerPos)));
+			}
 		});
 
 		ClientTickEvents.END_CLIENT_TICK.register(minecraft -> {
diff --git a/src/client/java/com/pixelreel/client/gui/CustomScreenPlacementScreen.java b/src/client/java/com/pixelreel/client/gui/CustomScreenPlacementScreen.java
new file mode 100644
index 0000000..13ac83c
--- /dev/null
+++ b/src/client/java/com/pixelreel/client/gui/CustomScreenPlacementScreen.java
@@ -0,0 +1,144 @@
+package com.pixelreel.client.gui;
+
+import com.pixelreel.blockentities.DisplayBlockEntity;
+import com.pixelreel.blocks.DisplayGeometry;
+import com.pixelreel.client.ClientNetworking;
+import net.minecraft.client.gui.GuiGraphicsExtractor;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.components.EditBox;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.chat.Component;
+import net.minecraft.world.InteractionHand;
+
+/** Width/height prompt shown when placing the custom cinema screen item. */
+public class CustomScreenPlacementScreen extends Screen {
+	private final BlockPos controllerPos;
+	private final InteractionHand hand;
+	private final boolean curved;
+	private EditBox widthBox;
+	private EditBox heightBox;
+	private EditBox audioDepthBox;
+	private EditBox audioSideBox;
+	private Component validationMessage = Component.empty();
+
+	public CustomScreenPlacementScreen(BlockPos controllerPos, InteractionHand hand, boolean curved) {
+		super(Component.translatable(curved
+			? "gui.pixelreel.custom_curved_screen.title"
+			: "gui.pixelreel.custom_screen.title"));
+		this.controllerPos = controllerPos.immutable();
+		this.hand = hand;
+		this.curved = curved;
+	}
+
+	@Override
+	protected void init() {
+		int left = this.width / 2 - 90;
+		int top = this.height / 2 - 92;
+
+		this.widthBox = new EditBox(
+			this.font, left, top, 180, 20, Component.translatable("gui.pixelreel.custom_screen.width")
+		);
+		this.widthBox.setMaxLength(2);
+		this.widthBox.setValue("27");
+		this.addRenderableWidget(this.widthBox);
+
+		this.heightBox = new EditBox(
+			this.font, left, top + 34, 180, 20, Component.translatable("gui.pixelreel.custom_screen.height")
+		);
+		this.heightBox.setMaxLength(2);
+		this.heightBox.setValue("11");
+		this.addRenderableWidget(this.heightBox);
+
+		this.audioDepthBox = new EditBox(
+			this.font, left, top + 68, 180, 20, Component.translatable("gui.pixelreel.custom_screen.audio_depth")
+		);
+		this.audioDepthBox.setMaxLength(3);
+		this.audioDepthBox.setValue(Integer.toString(DisplayBlockEntity.DEFAULT_CUSTOM_AUDIO_DEPTH));
+		this.addRenderableWidget(this.audioDepthBox);
+
+		this.audioSideBox = new EditBox(
+			this.font, left, top + 102, 180, 20, Component.translatable("gui.pixelreel.custom_screen.audio_side")
+		);
+		this.audioSideBox.setMaxLength(2);
+		this.audioSideBox.setValue(Integer.toString(DisplayBlockEntity.DEFAULT_CUSTOM_AUDIO_SIDE));
+		this.addRenderableWidget(this.audioSideBox);
+
+		this.addRenderableWidget(
+			Button.builder(Component.translatable("gui.pixelreel.custom_screen.place"), button -> this.place())
+				.bounds(left, top + 140, 86, 20)
+				.build()
+		);
+		this.addRenderableWidget(
+			Button.builder(Component.translatable("gui.pixelreel.custom_screen.cancel"), button -> this.onClose())
+				.bounds(left + 94, top + 140, 86, 20)
+				.build()
+		);
+		this.setInitialFocus(this.widthBox);
+	}
+
+	private void place() {
+		int width = parse(this.widthBox.getValue());
+		int height = parse(this.heightBox.getValue());
+		int audioDepth = parse(this.audioDepthBox.getValue());
+		int audioSide = parse(this.audioSideBox.getValue());
+		if (width < DisplayGeometry.MIN_WIDTH || width > DisplayGeometry.MAX_WIDTH
+			|| height < DisplayGeometry.MIN_HEIGHT || height > DisplayGeometry.MAX_HEIGHT) {
+			this.validationMessage = Component.translatable(
+				"gui.pixelreel.custom_screen.invalid",
+				DisplayGeometry.MIN_WIDTH,
+				DisplayGeometry.MAX_WIDTH,
+				DisplayGeometry.MIN_HEIGHT,
+				DisplayGeometry.MAX_HEIGHT
+			);
+			return;
+		}
+		if (audioDepth < DisplayBlockEntity.MIN_CUSTOM_AUDIO_DEPTH || audioDepth > DisplayBlockEntity.MAX_CUSTOM_AUDIO_DEPTH
+			|| audioSide < DisplayBlockEntity.MIN_CUSTOM_AUDIO_SIDE || audioSide > DisplayBlockEntity.MAX_CUSTOM_AUDIO_SIDE) {
+			this.validationMessage = Component.translatable(
+				"gui.pixelreel.custom_screen.audio_invalid",
+				DisplayBlockEntity.MIN_CUSTOM_AUDIO_DEPTH,
+				DisplayBlockEntity.MAX_CUSTOM_AUDIO_DEPTH,
+				DisplayBlockEntity.MIN_CUSTOM_AUDIO_SIDE,
+				DisplayBlockEntity.MAX_CUSTOM_AUDIO_SIDE
+			);
+			return;
+		}
+		ClientNetworking.placeCustomScreen(this.controllerPos, width, height, audioDepth, audioSide, this.hand);
+		this.onClose();
+	}
+
+	private static int parse(String value) {
+		try {
+			return Integer.parseInt(value);
+		} catch (NumberFormatException ignored) {
+			return -1;
+		}
+	}
+
+	@Override
+	public void extractRenderState(GuiGraphicsExtractor graphics, int mouseX, int mouseY, float partialTicks) {
+		super.extractRenderState(graphics, mouseX, mouseY, partialTicks);
+		int left = this.width / 2 - 90;
+		int top = this.height / 2 - 92;
+		graphics.centeredText(this.font, this.title, this.width / 2, top - 28, GuiColors.TEXT);
+		graphics.centeredText(
+			this.font, Component.translatable("gui.pixelreel.custom_screen.subtitle"), this.width / 2, top - 15, GuiColors.TEXT_DIM
+		);
+		graphics.text(this.font, Component.translatable("gui.pixelreel.custom_screen.width"), left, top - 10, GuiColors.TEXT_DIM);
+		graphics.text(this.font, Component.translatable("gui.pixelreel.custom_screen.height"), left, top + 24, GuiColors.TEXT_DIM);
+		graphics.text(this.font, Component.translatable("gui.pixelreel.custom_screen.audio_depth"), left, top + 58, GuiColors.TEXT_DIM);
+		graphics.text(this.font, Component.translatable("gui.pixelreel.custom_screen.audio_side"), left, top + 92, GuiColors.TEXT_DIM);
+		graphics.centeredText(
+			this.font, Component.translatable("gui.pixelreel.custom_screen.audio_hint"), this.width / 2, top + 126, GuiColors.TEXT_DIM
+		);
+		if (!this.validationMessage.getString().isEmpty()) {
+			graphics.centeredText(this.font, this.validationMessage, this.width / 2, top + 166, GuiColors.ERROR);
+		}
+	}
+
+	@Override
+	public boolean isPauseScreen() {
+		return false;
+	}
+}
diff --git a/src/client/java/com/pixelreel/client/gui/MediaSourceScreen.java b/src/client/java/com/pixelreel/client/gui/MediaSourceScreen.java
index 5a113fb..2312e77 100644
--- a/src/client/java/com/pixelreel/client/gui/MediaSourceScreen.java
+++ b/src/client/java/com/pixelreel/client/gui/MediaSourceScreen.java
@@ -105,12 +105,18 @@ protected void init() {
 		y += smallH + gap;
 
 		if (showPlayback) {
+			int playbackHalf = (PANEL_WIDTH - gap) / 2;
 			this.addRenderableWidget(
 				Button.builder(Component.translatable("gui.pixelreel.playback.open"), button -> {
 					if (this.minecraft != null) {
 						this.minecraft.gui.setScreen(new PlaybackControlScreen(this.display));
 					}
-				}).bounds(centreX - PANEL_WIDTH / 2, y, PANEL_WIDTH, smallH).build()
+				}).bounds(centreX - PANEL_WIDTH / 2, y, playbackHalf, smallH).build()
+			);
+			this.addRenderableWidget(
+				Button.builder(Component.translatable("gui.pixelreel.playback.reset_connection"), button ->
+					ClientNetworking.resetLocalPlaybackConnection(this.display.getBlockPos())
+				).bounds(centreX - PANEL_WIDTH / 2 + playbackHalf + gap, y, playbackHalf, smallH).build()
 			);
 			y += smallH + gap;
 		}
diff --git a/src/client/java/com/pixelreel/client/gui/PlaybackControlScreen.java b/src/client/java/com/pixelreel/client/gui/PlaybackControlScreen.java
index 46b7b09..b5da690 100644
--- a/src/client/java/com/pixelreel/client/gui/PlaybackControlScreen.java
+++ b/src/client/java/com/pixelreel/client/gui/PlaybackControlScreen.java
@@ -54,6 +54,11 @@ protected void init() {
 				ClientNetworking.sendControl(this.display.getBlockPos(), ScreenAction.STOP, 0.0F)
 			).bounds(centre + 110, y, 50, 20).build()
 		);
+		this.addRenderableWidget(
+			Button.builder(Component.translatable("gui.pixelreel.playback.reset_connection"), button ->
+				ClientNetworking.resetLocalPlaybackConnection(this.display.getBlockPos())
+			).bounds(centre - 140, y - 56, 280, 20).build()
+		);
 		this.subtitleButton = this.addRenderableWidget(
 			Button.builder(this.subtitleLabel(), button -> {
 				if (this.minecraft != null) {
diff --git a/src/client/java/com/pixelreel/client/gui/ScreenwriterLinkScreen.java b/src/client/java/com/pixelreel/client/gui/ScreenwriterLinkScreen.java
new file mode 100644
index 0000000..cfc30b2
--- /dev/null
+++ b/src/client/java/com/pixelreel/client/gui/ScreenwriterLinkScreen.java
@@ -0,0 +1,99 @@
+package com.pixelreel.client.gui;
+
+import com.pixelreel.client.ClientNetworking;
+import com.pixelreel.server.ScreenwriterManager;
+import net.minecraft.client.gui.GuiGraphicsExtractor;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.components.EditBox;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.chat.Component;
+
+/** Auditorium-number prompt used when linking a custom screen to Screenwriter. */
+public class ScreenwriterLinkScreen extends Screen {
+	private final BlockPos controllerPos;
+	private EditBox auditoriumBox;
+	private Component validationMessage = Component.empty();
+
+	public ScreenwriterLinkScreen(BlockPos controllerPos) {
+		super(Component.translatable("gui.pixelreel.screenwriter_link.title"));
+		this.controllerPos = controllerPos.immutable();
+	}
+
+	@Override
+	protected void init() {
+		int left = this.width / 2 - 90;
+		int top = this.height / 2 - 52;
+
+		this.auditoriumBox = new EditBox(
+			this.font, left, top, 180, 20, Component.translatable("gui.pixelreel.screenwriter_link.auditorium")
+		);
+		this.auditoriumBox.setMaxLength(2);
+		this.addRenderableWidget(this.auditoriumBox);
+
+		this.addRenderableWidget(
+			Button.builder(Component.translatable("gui.pixelreel.screenwriter_link.link"), button -> this.link())
+				.bounds(left, top + 38, 86, 20)
+				.build()
+		);
+		this.addRenderableWidget(
+			Button.builder(Component.translatable("gui.pixelreel.screenwriter_link.unlink"), button -> this.unlink())
+				.bounds(left + 94, top + 38, 86, 20)
+				.build()
+		);
+		this.addRenderableWidget(
+			Button.builder(Component.translatable("gui.pixelreel.screenwriter_link.cancel"), button -> this.onClose())
+				.bounds(left + 47, top + 66, 86, 20)
+				.build()
+		);
+		this.setInitialFocus(this.auditoriumBox);
+	}
+
+	private void link() {
+		int auditorium = parse(this.auditoriumBox.getValue());
+		if (auditorium < 1 || auditorium > ScreenwriterManager.MAX_SCREENS) {
+			this.validationMessage = Component.translatable(
+				"gui.pixelreel.screenwriter_link.invalid", 1, ScreenwriterManager.MAX_SCREENS
+			);
+			return;
+		}
+		ClientNetworking.configureScreenwriterLink(this.controllerPos, auditorium, false);
+		this.onClose();
+	}
+
+	private void unlink() {
+		ClientNetworking.configureScreenwriterLink(this.controllerPos, 0, true);
+		this.onClose();
+	}
+
+	private static int parse(String value) {
+		try {
+			return Integer.parseInt(value.trim());
+		} catch (NumberFormatException ignored) {
+			return -1;
+		}
+	}
+
+	@Override
+	public void extractRenderState(GuiGraphicsExtractor graphics, int mouseX, int mouseY, float partialTicks) {
+		super.extractRenderState(graphics, mouseX, mouseY, partialTicks);
+		int left = this.width / 2 - 90;
+		int top = this.height / 2 - 52;
+		graphics.centeredText(this.font, this.title, this.width / 2, top - 32, GuiColors.TEXT);
+		graphics.centeredText(
+			this.font, Component.translatable("gui.pixelreel.screenwriter_link.subtitle", ScreenwriterManager.MAX_SCREENS),
+			this.width / 2, top - 18, GuiColors.TEXT_DIM
+		);
+		graphics.text(
+			this.font, Component.translatable("gui.pixelreel.screenwriter_link.auditorium"), left, top - 10, GuiColors.TEXT_DIM
+		);
+		if (!this.validationMessage.getString().isEmpty()) {
+			graphics.centeredText(this.font, this.validationMessage, this.width / 2, top + 94, GuiColors.ERROR);
+		}
+	}
+
+	@Override
+	public boolean isPauseScreen() {
+		return false;
+	}
+}
diff --git a/src/client/java/com/pixelreel/client/playback/ChannelPlayer.java b/src/client/java/com/pixelreel/client/playback/ChannelPlayer.java
index c51e6c7..f3f344f 100644
--- a/src/client/java/com/pixelreel/client/playback/ChannelPlayer.java
+++ b/src/client/java/com/pixelreel/client/playback/ChannelPlayer.java
@@ -9,7 +9,6 @@
 import java.nio.ByteBuffer;
 import java.util.concurrent.atomic.AtomicBoolean;
 import net.minecraft.client.Minecraft;
-import net.minecraft.sounds.SoundSource;
 import org.jspecify.annotations.Nullable;
 import uk.co.caprica.vlcj.factory.MediaPlayerFactory;
 import uk.co.caprica.vlcj.player.base.MediaPlayer;
@@ -22,8 +21,6 @@
 /** this is how media gets handled using VLC becuase vlc is the goat */
 public final class ChannelPlayer implements AutoCloseable {
 	private static final long RECONNECT_DELAY_MILLIS = 2000L;
-	private static final long VOLUME_UPDATE_INTERVAL_MS = 250L;
-	private static final int VOLUME_CHANGE_THRESHOLD = 3;
 	private static final long SEEK_TOLERANCE_MS = 1500L;
 
 	private final String url;
@@ -42,10 +39,8 @@ public final class ChannelPlayer implements AutoCloseable {
 	private int reconnectAttempts;
 	private long reconnectAt;
 	private boolean closed;
-	private long lastVolumeUpdateAt;
-	private int lastAppliedVolume = Integer.MIN_VALUE;
-	private volatile float desiredGain = 1.0F;
-	private final AtomicBoolean volumeDirty = new AtomicBoolean(true);
+	private volatile float desiredGain;
+	private final DirectAudioSink audioSink = new DirectAudioSink();
 	private volatile boolean desiredPaused;
 	private volatile long desiredSeekMs = -1L;
 	private volatile long reportedLengthMs;
@@ -238,36 +233,9 @@ public void retry() {
 
 	public void tickAudio(float linearGain) {
 		this.desiredGain = Math.clamp(linearGain, 0.0F, 1.0F);
-		EmbeddedMediaPlayer current = this.player;
-		if (current == null || this.closed) {
-			return;
-		}
-
-		long now = System.currentTimeMillis();
-		boolean dirty = this.volumeDirty.getAndSet(false);
-		if (!dirty
-			&& now - this.lastVolumeUpdateAt < VOLUME_UPDATE_INTERVAL_MS
-			&& this.lastAppliedVolume != Integer.MIN_VALUE) {
-			return;
-		}
-
-		float master = Minecraft.getInstance().options.getSoundSourceVolume(SoundSource.MASTER);
-		float records = Minecraft.getInstance().options.getSoundSourceVolume(SoundSource.RECORDS);
-		int volume = (int)Math.round(Math.clamp(this.desiredGain * master * records, 0.0F, 2.0F) * 100.0);
-		if (!dirty
-			&& this.lastAppliedVolume != Integer.MIN_VALUE
-			&& Math.abs(volume - this.lastAppliedVolume) < VOLUME_CHANGE_THRESHOLD) {
-			return;
-		}
-
-		this.lastVolumeUpdateAt = now;
-		this.lastAppliedVolume = volume;
-		try {
-			current.audio().setMute(false);
-			current.audio().setVolume(volume);
-		} catch (Throwable t) {
-			PixelReel.LOGGER.debug("Could not set VLC volume for {}: {}", ChannelService.hostOnly(this.url), t.toString());
-		}
+		float master = Minecraft.getInstance().options.getSoundSourceVolume(net.minecraft.sounds.SoundSource.MASTER);
+		float records = Minecraft.getInstance().options.getSoundSourceVolume(net.minecraft.sounds.SoundSource.RECORDS);
+		this.audioSink.setGain(Math.clamp(this.desiredGain * master * records, 0.0F, 1.0F));
 	}
 
 	public boolean uploadFrame() {
@@ -284,8 +252,6 @@ private void openStream() {
 		this.streamEnded.set(false);
 		this.errorDetail = "";
 		this.status = PlaybackStatus.CONNECTING;
-		this.lastAppliedVolume = Integer.MIN_VALUE;
-		this.volumeDirty.set(true);
 		this.startSeekApplied = this.initialStartMs <= 0L;
 		try {
 			int caching = Math.clamp(ConfigManager.get().streamCachingMillis, 0, 20000);
@@ -320,6 +286,10 @@ private void openStream() {
 		try {
 			EmbeddedMediaPlayer created = factory.mediaPlayers().newEmbeddedMediaPlayer();
 			created.videoSurface().set(factory.videoSurfaces().newVideoSurface(new FrameFormatCallback(), new FrameRenderCallback(), true));
+			// Use decoded-audio callbacks instead of LibVLC native audio output.
+			// Native volume/mute is shared across in-process LibVLC players; callbacks
+			// give every physical screen a genuinely independent audio stream.
+			created.audio().callback(DirectAudioSink.VLC_FORMAT, this.audioSink.rate(), DirectAudioSink.CHANNELS, this.audioSink, true);
 			created.events().addMediaPlayerEventListener(new StreamEventListener());
 			this.player = created;
 			return created;
@@ -340,10 +310,9 @@ public void close() {
 		this.status = PlaybackStatus.IDLE;
 		EmbeddedMediaPlayer current = this.player;
 		this.player = null;
+		this.audioSink.setGain(0.0F);
 		if (current != null) {
 			try {
-				current.audio().setMute(true);
-				current.audio().setVolume(0);
 				current.controls().stop();
 			} catch (Throwable ignored) {
 			}
@@ -355,6 +324,7 @@ public void close() {
 				}
 			});
 		}
+		this.audioSink.close();
 		this.subtitleOverlay.clear();
 		this.videoTexture.close();
 	}
@@ -428,12 +398,10 @@ private final class StreamEventListener extends MediaPlayerEventAdapter {
 		public void buffering(MediaPlayer mediaPlayer, float newCache) {
 			ChannelPlayer.this.bufferingProgress = newCache;
 			ChannelPlayer.this.buffering.set(newCache < 100.0F);
-			ChannelPlayer.this.volumeDirty.set(true);
 		}
 
 		@Override
 		public void playing(MediaPlayer mediaPlayer) {
-			ChannelPlayer.this.volumeDirty.set(true);
 		}
 
 		@Override
diff --git a/src/client/java/com/pixelreel/client/playback/DirectAudioSink.java b/src/client/java/com/pixelreel/client/playback/DirectAudioSink.java
new file mode 100644
index 0000000..cd94a87
--- /dev/null
+++ b/src/client/java/com/pixelreel/client/playback/DirectAudioSink.java
@@ -0,0 +1,196 @@
+package com.pixelreel.client.playback;
+
+import com.pixelreel.PixelReel;
+import com.sun.jna.Pointer;
+import java.nio.ByteOrder;
+import javax.sound.sampled.AudioFormat;
+import javax.sound.sampled.AudioSystem;
+import javax.sound.sampled.DataLine;
+import javax.sound.sampled.LineUnavailableException;
+import javax.sound.sampled.SourceDataLine;
+import uk.co.caprica.vlcj.player.base.MediaPlayer;
+import uk.co.caprica.vlcj.player.base.callback.AudioCallbackAdapter;
+
+/**
+ * Per-screen decoded-audio output.
+ *
+ * <p>LibVLC native volume/mute controls are shared by multiple in-process media
+ * players on common VLC 3.x setups, so they cannot isolate auditorium audio.
+ * PixelReel instead asks LibVLC for decoded PCM samples and sends each screen to
+ * its own JavaSound line. Only the screen selected by PlaybackManager receives a
+ * non-zero gain; all other screens discard their PCM samples.</p>
+ */
+final class DirectAudioSink extends AudioCallbackAdapter implements AutoCloseable {
+	static final String VLC_FORMAT = "S16N";
+	static final int CHANNELS = 2;
+	private static final int SAMPLE_BITS = 16;
+	private static final int BYTES_PER_SAMPLE = SAMPLE_BITS / 8;
+	private static final int FRAME_BYTES = CHANNELS * BYTES_PER_SAMPLE;
+	private static final int PRIMARY_RATE = 48_000;
+	private static final int FALLBACK_RATE = 44_100;
+
+	private final Object lineLock = new Object();
+	private final int rate;
+	private final SourceDataLine line;
+	private volatile float gain;
+	private volatile boolean paused;
+	private volatile boolean closed;
+
+	DirectAudioSink() {
+		SourceDataLine opened = null;
+		int openedRate = PRIMARY_RATE;
+		try {
+			opened = openLine(PRIMARY_RATE);
+		} catch (LineUnavailableException | IllegalArgumentException first) {
+			try {
+				openedRate = FALLBACK_RATE;
+				opened = openLine(FALLBACK_RATE);
+			} catch (LineUnavailableException | IllegalArgumentException second) {
+				PixelReel.LOGGER.warn("pixelReel: JavaSound audio output unavailable; screen audio will be silent", second);
+			}
+		}
+		this.rate = openedRate;
+		this.line = opened;
+	}
+
+	int rate() {
+		return this.rate;
+	}
+
+	void setGain(float gain) {
+		float clamped = Math.clamp(gain, 0.0F, 1.0F);
+		float previous = this.gain;
+		this.gain = clamped;
+
+		SourceDataLine current = this.line;
+		if (current == null || this.closed) {
+			return;
+		}
+
+		// Drop already-buffered samples immediately when leaving an auditorium so
+		// audio from the previous screen cannot bleed into the next zone.
+		if (previous > 0.0F && clamped <= 0.0F) {
+			synchronized (this.lineLock) {
+				if (!this.closed) {
+					current.flush();
+				}
+			}
+		}
+	}
+
+	@Override
+	public void play(MediaPlayer mediaPlayer, Pointer samples, int sampleCount, long pts) {
+		SourceDataLine current = this.line;
+		float currentGain = this.gain;
+		if (current == null || this.closed || this.paused || currentGain <= 0.0F || sampleCount <= 0) {
+			return;
+		}
+
+		int byteCount = sampleCount * FRAME_BYTES;
+		byte[] data = samples.getByteArray(0, byteCount);
+		if (currentGain < 0.999F) {
+			applyGain(data, currentGain);
+		}
+
+		synchronized (this.lineLock) {
+			if (this.closed || this.paused || this.gain <= 0.0F) {
+				return;
+			}
+			current.write(data, 0, data.length);
+		}
+	}
+
+	@Override
+	public void pause(MediaPlayer mediaPlayer, long pts) {
+		this.paused = true;
+		flushLine();
+	}
+
+	@Override
+	public void resume(MediaPlayer mediaPlayer, long pts) {
+		this.paused = false;
+	}
+
+	@Override
+	public void flush(MediaPlayer mediaPlayer, long pts) {
+		flushLine();
+	}
+
+	@Override
+	public void drain(MediaPlayer mediaPlayer) {
+		// Do not block the LibVLC callback thread waiting for JavaSound to drain.
+	}
+
+	@Override
+	public void setVolume(float volume, boolean mute) {
+		// PixelReel owns the per-screen gain. This callback is intentionally not
+		// allowed to re-introduce LibVLC's shared native volume state.
+	}
+
+	private void flushLine() {
+		SourceDataLine current = this.line;
+		if (current == null || this.closed) {
+			return;
+		}
+		synchronized (this.lineLock) {
+			if (!this.closed) {
+				current.flush();
+			}
+		}
+	}
+
+	private static SourceDataLine openLine(int rate) throws LineUnavailableException {
+		boolean bigEndian = ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN;
+		AudioFormat format = new AudioFormat(rate, SAMPLE_BITS, CHANNELS, true, bigEndian);
+		DataLine.Info info = new DataLine.Info(SourceDataLine.class, format);
+		SourceDataLine dataLine = (SourceDataLine)AudioSystem.getLine(info);
+		// Roughly 100 ms of buffering: enough to avoid crackle while keeping zone
+		// transitions responsive.
+		int bufferBytes = Math.max(FRAME_BYTES * 256, rate * FRAME_BYTES / 10);
+		dataLine.open(format, bufferBytes);
+		dataLine.start();
+		return dataLine;
+	}
+
+	private static void applyGain(byte[] data, float gain) {
+		boolean bigEndian = ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN;
+		for (int i = 0; i + 1 < data.length; i += 2) {
+			int raw;
+			if (bigEndian) {
+				raw = (data[i] << 8) | (data[i + 1] & 0xFF);
+			} else {
+				raw = (data[i + 1] << 8) | (data[i] & 0xFF);
+			}
+			short sample = (short)raw;
+			int scaled = Math.round(sample * gain);
+			scaled = Math.clamp(scaled, Short.MIN_VALUE, Short.MAX_VALUE);
+			if (bigEndian) {
+				data[i] = (byte)(scaled >> 8);
+				data[i + 1] = (byte)scaled;
+			} else {
+				data[i] = (byte)scaled;
+				data[i + 1] = (byte)(scaled >> 8);
+			}
+		}
+	}
+
+	@Override
+	public void close() {
+		if (this.closed) {
+			return;
+		}
+		this.closed = true;
+		this.gain = 0.0F;
+		SourceDataLine current = this.line;
+		if (current != null) {
+			synchronized (this.lineLock) {
+				try {
+					current.stop();
+					current.flush();
+				} finally {
+					current.close();
+				}
+			}
+		}
+	}
+}
diff --git a/src/client/java/com/pixelreel/client/playback/PlaybackManager.java b/src/client/java/com/pixelreel/client/playback/PlaybackManager.java
index c329d2a..9eaaf22 100644
--- a/src/client/java/com/pixelreel/client/playback/PlaybackManager.java
+++ b/src/client/java/com/pixelreel/client/playback/PlaybackManager.java
@@ -41,11 +41,29 @@ public final class PlaybackManager {
 	private final Set<String> durationReports = new HashSet<>();
 	private int tickCounter;
 
+	private record Binding(DisplayBlockEntity display, Vec3 centre, double distanceSqr) {
+	}
+
 	private PlaybackManager() {
 	}
 
 	public @Nullable ChannelPlayer player(String url) {
-		return url == null || url.isEmpty() ? null : this.players.get(url);
+		if (url == null || url.isEmpty()) {
+			return null;
+		}
+		for (ChannelPlayer channelPlayer : this.players.values()) {
+			if (url.equals(channelPlayer.url())) {
+				return channelPlayer;
+			}
+		}
+		return null;
+	}
+
+	private static String sessionKey(DisplayBlockEntity display) {
+		// Audio and playback must be isolated per physical screen. Using only the
+		// stream URL merges two screens that happen to play the same media into one
+		// VLC player, which also merges their auditorium audio zones.
+		return display.getBlockPos().asLong() + "|" + display.getStreamUrl();
 	}
 
 	public int activePlayerCount() {
@@ -58,13 +76,43 @@ public void prewarm(List<String> urls) {
 	public void retry(BlockPos controllerPos) {
 		Minecraft minecraft = Minecraft.getInstance();
 		if (minecraft.level != null && minecraft.level.getBlockEntity(controllerPos) instanceof DisplayBlockEntity display) {
-			ChannelPlayer player = this.players.get(display.getStreamUrl());
+			ChannelPlayer player = this.players.get(sessionKey(display));
 			if (player != null) {
 				player.retry();
+				if (display.isOnDemand()) {
+					player.requestSeek(display.currentPlaybackPositionMs());
+				}
 			}
 		}
 	}
 
+	/**
+	 * Fully tears down one screen's local VLC/audio session so the next client
+	 * tick creates a fresh decoder at the screen's current synchronized position.
+	 * This affects only this Minecraft client; it does not stop or restart the
+	 * movie for other viewers or alter Screenwriter's server-side schedule.
+	 */
+	public boolean resetConnection(BlockPos controllerPos) {
+		Minecraft minecraft = Minecraft.getInstance();
+		if (minecraft.level == null
+			|| !(minecraft.level.getBlockEntity(controllerPos) instanceof DisplayBlockEntity display)
+			|| !display.shouldPlay()) {
+			return false;
+		}
+		String key = sessionKey(display);
+		ChannelPlayer old = this.players.remove(key);
+		this.playerEpochs.remove(key);
+		this.endedReports.remove(key);
+		this.durationReports.remove(key);
+		if (old != null) {
+			old.close();
+		}
+		// Make sure the controller remains eligible immediately instead of waiting
+		// for the next periodic nearby-screen rescan.
+		this.nearbyControllers.add(controllerPos.immutable());
+		return true;
+	}
+
 	public void clientTick() {
 		Minecraft minecraft = Minecraft.getInstance();
 		ClientLevel level = minecraft.level;
@@ -112,8 +160,6 @@ private void driveSessions(ClientLevel level, Player player) {
 		double keepAliveDistance = startDistance * KEEP_ALIVE_MULTIPLIER;
 		double keepAliveDistanceSqr = keepAliveDistance * keepAliveDistance;
 
-		record Binding(DisplayBlockEntity display, Vec3 centre, double distanceSqr) {
-		}
 		Map<String, List<Binding>> desired = new HashMap<>();
 
 		for (BlockPos pos : this.nearbyControllers) {
@@ -129,12 +175,13 @@ record Binding(DisplayBlockEntity display, Vec3 centre, double distanceSqr) {
 			}
 			Vec3 centre = display.screenCentre();
 			double distanceSqr = player.distanceToSqr(centre);
-			boolean alreadyPlaying = this.players.containsKey(url);
+			String key = sessionKey(display);
+			boolean alreadyPlaying = this.players.containsKey(key);
 			double limitSqr = alreadyPlaying ? keepAliveDistanceSqr : startDistanceSqr;
 			if (distanceSqr > limitSqr) {
 				continue;
 			}
-			desired.computeIfAbsent(url, key -> new ArrayList<>()).add(new Binding(display, centre, distanceSqr));
+			desired.computeIfAbsent(key, ignored -> new ArrayList<>()).add(new Binding(display, centre, distanceSqr));
 		}
 
 		LinkedHashSet<String> ranked = desired.entrySet().stream()
@@ -144,15 +191,15 @@ record Binding(DisplayBlockEntity display, Vec3 centre, double distanceSqr) {
 
 		int budget = config.maxSimultaneousChannels;
 		Set<String> allowed = new HashSet<>();
-		for (String url : ranked) {
+		for (String key : ranked) {
 			if (allowed.size() >= budget) {
 				break;
 			}
-			allowed.add(url);
+			allowed.add(key);
 		}
 
-		for (String url : allowed) {
-			List<Binding> bindings = desired.get(url);
+		for (String key : allowed) {
+			List<Binding> bindings = desired.get(key);
 			Binding nearest = bindings == null || bindings.isEmpty()
 				? null
 				: bindings.stream().min(Comparator.comparingDouble(Binding::distanceSqr)).orElse(null);
@@ -160,32 +207,39 @@ record Binding(DisplayBlockEntity display, Vec3 centre, double distanceSqr) {
 				continue;
 			}
 			DisplayBlockEntity display = nearest.display();
+			String url = display.getStreamUrl();
 			boolean onDemand = display.isOnDemand();
 			int epoch = display.getChannelEpoch();
-			ChannelPlayer channelPlayer = this.players.get(url);
-			Integer previousEpoch = this.playerEpochs.get(url);
+			ChannelPlayer channelPlayer = this.players.get(key);
+			Integer previousEpoch = this.playerEpochs.get(key);
 			if (channelPlayer == null) {
 				channelPlayer = new ChannelPlayer(
 					url,
 					onDemand,
-					onDemand ? display.getStartPositionMs() : 0L,
+					onDemand ? display.currentPlaybackPositionMs() : 0L,
 					onDemand && display.isHdrContent()
 				);
-				this.players.put(url, channelPlayer);
-				this.playerEpochs.put(url, epoch);
-				this.endedReports.remove(url);
-				this.durationReports.remove(url);
+				this.players.put(key, channelPlayer);
+				this.playerEpochs.put(key, epoch);
+				this.endedReports.remove(key);
+				this.durationReports.remove(key);
 				PixelReel.LOGGER.info("Playing {} stream ({}) — {} active", onDemand ? "on-demand" : "channel", host(url), this.players.size());
 			} else if (previousEpoch == null || previousEpoch != epoch) {
-				this.playerEpochs.put(url, epoch);
-				this.endedReports.remove(url);
-				this.durationReports.remove(url);
+				this.playerEpochs.put(key, epoch);
+				this.endedReports.remove(key);
+				this.durationReports.remove(key);
 				if (onDemand) {
 					channelPlayer.requestSeek(display.currentPlaybackPositionMs());
 				}
 			}
 		}
 
+		// Choose exactly one audible screen for this client. This is intentionally
+		// independent from the video/playback budget: many screens may continue
+		// rendering at once, but only the one whose listening zone contains the
+		// player (and is nearest if zones overlap) is allowed to output audio.
+		String audibleSessionKey = selectAudibleSession(player, desired, allowed);
+
 		float globalVolume = (float)config.globalTvVolume;
 		Iterator<Map.Entry<String, ChannelPlayer>> iterator = this.players.entrySet().iterator();
 		while (iterator.hasNext()) {
@@ -194,7 +248,7 @@ record Binding(DisplayBlockEntity display, Vec3 centre, double distanceSqr) {
 			List<Binding> bindings = desired.get(entry.getKey());
 			boolean active = allowed.contains(entry.getKey()) && bindings != null && !bindings.isEmpty();
 			if (!active) {
-				PixelReel.LOGGER.info("Stopping channel stream ({}) — out of range or switched away", host(entry.getKey()));
+				PixelReel.LOGGER.info("Stopping channel stream ({}) — out of range or switched away", host(channelPlayer.url()));
 				iterator.remove();
 				this.playerEpochs.remove(entry.getKey());
 				this.endedReports.remove(entry.getKey());
@@ -228,18 +282,23 @@ record Binding(DisplayBlockEntity display, Vec3 centre, double distanceSqr) {
 				&& this.endedReports.add(entry.getKey())) {
 				ClientNetworking.reportMediaEnded(display.getBlockPos(), display.getChannelEpoch());
 			}
-			float volume = 0.0F;
-			float audioRange = 8.0F;
-			for (Binding binding : bindings) {
-				volume = Math.max(volume, binding.display().getVolume());
-				audioRange = Math.max(audioRange, binding.display().type().audioRange());
+			double audibleGain = 0.0;
+			if (entry.getKey().equals(audibleSessionKey)) {
+				boolean glasses = PixelGlassesItem.isWearing(player);
+				for (Binding binding : bindings) {
+					DisplayBlockEntity boundDisplay = binding.display();
+					double spatialGain;
+					if (glasses) {
+						spatialGain = 1.0;
+					} else if (boundDisplay.isCustomScreen()) {
+						spatialGain = customScreenAudioGain(player, boundDisplay);
+					} else {
+						spatialGain = softDistanceGain(Math.sqrt(binding.distanceSqr()), boundDisplay.type().audioRange());
+					}
+					audibleGain = Math.max(audibleGain, boundDisplay.getVolume() * spatialGain);
+				}
 			}
-			boolean glasses = PixelGlassesItem.isWearing(player);
-			double distance = Math.sqrt(nearest.distanceSqr());
-			// Soft knee near the edge so gain does not slam to zero and mute-thrash.
-			// Cinema glasses listen at full screen volume (no distance falloff).
-			double normalized = glasses ? 1.0 : softDistanceGain(distance, audioRange);
-			float gain = (float)(volume * globalVolume * normalized);
+			float gain = (float)(globalVolume * audibleGain);
 			if (display.isOnDemand() && display.isPlaybackPaused()) {
 				gain = 0.0F;
 			}
@@ -247,6 +306,68 @@ record Binding(DisplayBlockEntity display, Vec3 centre, double distanceSqr) {
 		}
 	}
 
+	private static @Nullable String selectAudibleSession(
+		Player player, Map<String, List<Binding>> desired, Set<String> allowed
+	) {
+		boolean glasses = PixelGlassesItem.isWearing(player);
+		String bestKey = null;
+		double bestDistanceSqr = Double.MAX_VALUE;
+
+		for (String key : allowed) {
+			List<Binding> bindings = desired.get(key);
+			if (bindings == null) {
+				continue;
+			}
+
+			for (Binding binding : bindings) {
+				DisplayBlockEntity display = binding.display();
+				boolean audible = glasses;
+				if (!audible) {
+					if (display.isCustomScreen()) {
+						audible = customScreenAudioGain(player, display) > 0.0;
+					} else {
+						audible = softDistanceGain(Math.sqrt(binding.distanceSqr()), display.type().audioRange()) > 0.0;
+					}
+				}
+
+				if (audible && binding.distanceSqr() < bestDistanceSqr) {
+					bestDistanceSqr = binding.distanceSqr();
+					bestKey = key;
+				}
+			}
+		}
+
+		return bestKey;
+	}
+
+	private static double customScreenAudioGain(Player player, DisplayBlockEntity display) {
+		Vec3 offset = player.position().subtract(display.screenCentre());
+		var facing = display.facing();
+		var sideAxis = facing.getCounterClockWise();
+
+		// Custom-screen audio uses a hard auditorium-shaped zone rather than
+		// distance attenuation. Inside the zone the screen plays at its configured
+		// volume; outside the zone it is completely silent.
+		//
+		// Allow a small 1-block buffer behind the screen because custom screens are
+		// rendered against the back side of their occupied block space. Without this,
+		// a player walking right up to the screen can end up just behind the screen
+		// plane and have the audio cut out immediately.
+		double forward = offset.x * facing.getStepX() + offset.z * facing.getStepZ();
+		if (forward < -1.0 || forward > display.customAudioDepthBlocks()) {
+			return 0.0;
+		}
+
+		double lateral = Math.abs(offset.x * sideAxis.getStepX() + offset.z * sideAxis.getStepZ());
+		double halfScreenWidth = display.geometry().widthBlocks() * 0.5;
+		double maximumLateral = halfScreenWidth + display.customAudioSideBlocks();
+		if (lateral > maximumLateral) {
+			return 0.0;
+		}
+
+		return 1.0;
+	}
+
 	private static double softDistanceGain(double distance, double audioRange) {
 		if (distance <= 0.0 || audioRange <= 0.0) {
 			return 1.0;
@@ -266,8 +387,7 @@ private static String host(String url) {
 	}
 
 	public @Nullable PictureHandle pictureFor(DisplayBlockEntity display) {
-		String url = display.getStreamUrl();
-		ChannelPlayer current = this.players.get(url);
+		ChannelPlayer current = this.players.get(sessionKey(display));
 		if (current != null && current.hasPicture() && current.uploadFrame()) {
 			VideoTexture texture = current.videoTexture();
 			return new PictureHandle(
@@ -283,7 +403,7 @@ private static String host(String url) {
 	}
 
 	public @Nullable PlaybackStatus statusFor(DisplayBlockEntity display) {
-		ChannelPlayer player = this.players.get(display.getStreamUrl());
+		ChannelPlayer player = this.players.get(sessionKey(display));
 		return player == null ? null : player.status();
 	}
 
diff --git a/src/client/java/com/pixelreel/client/playback/video/VlcRuntime.java b/src/client/java/com/pixelreel/client/playback/video/VlcRuntime.java
index 2aaa5d9..1ef8f6c 100644
--- a/src/client/java/com/pixelreel/client/playback/video/VlcRuntime.java
+++ b/src/client/java/com/pixelreel/client/playback/video/VlcRuntime.java
@@ -63,7 +63,7 @@ public static void ensureInitialised() {
 				"--no-audio-time-stretch"
 			);
 			factory = new MediaPlayerFactory(args);
-			PixelReel.LOGGER.info("pixelReel: libVLC initialised (native audio, {} ms cache)", caching);
+			PixelReel.LOGGER.info("pixelReel: libVLC initialised (per-screen callback audio, {} ms cache)", caching);
 		} catch (Throwable t) {
 			unavailableReason = "libVLC failed to load: " + t;
 			PixelReel.LOGGER.error("pixelReel: could not initialise libVLC", t);
diff --git a/src/client/java/com/pixelreel/client/render/DisplayBlockEntityRenderer.java b/src/client/java/com/pixelreel/client/render/DisplayBlockEntityRenderer.java
index 9f5fcb9..bd59d94 100644
--- a/src/client/java/com/pixelreel/client/render/DisplayBlockEntityRenderer.java
+++ b/src/client/java/com/pixelreel/client/render/DisplayBlockEntityRenderer.java
@@ -6,6 +6,7 @@
 import com.pixelreel.PixelReel;
 import com.pixelreel.blockentities.DisplayBlockEntity;
 import com.pixelreel.blocks.DisplayBlock;
+import com.pixelreel.blocks.DisplayGeometry;
 import com.pixelreel.blocks.DisplayType;
 import com.pixelreel.client.playback.PlaybackManager;
 import com.pixelreel.client.playback.PlaybackStatus;
@@ -21,7 +22,6 @@
 import org.jspecify.annotations.Nullable;
 
 /** this is the what the screen looks like this is pretty cool i know */
-
 public class DisplayBlockEntityRenderer implements BlockEntityRenderer<DisplayBlockEntity, DisplayRenderState> {
 	private static final net.minecraft.resources.Identifier SCREEN_OFF = PixelReel.id("textures/block/screen_off.png");
 	private static final net.minecraft.resources.Identifier CONNECTING = PixelReel.id("textures/block/screen_connecting.png");
@@ -57,6 +57,7 @@ public void extractRenderState(
 		BlockEntityRenderer.super.extractRenderState(blockEntity, state, partialTicks, cameraPosition, breakProgress);
 		DisplayBlock block = blockEntity.displayBlock();
 		state.type = block == null ? null : block.type();
+		state.geometry = state.type == null ? null : blockEntity.geometry();
 		state.facing = blockEntity.facing();
 		state.pictureTexture = null;
 		state.pictureAspect = 0.0F;
@@ -64,7 +65,7 @@ public void extractRenderState(
 		state.contentV0 = 0.0F;
 		state.contentU1 = 1.0F;
 		state.contentV1 = 1.0F;
-		if (state.type == null || !blockEntity.isPowered() || blockEntity.isSuspended()) {
+		if (state.type == null || state.geometry == null || !blockEntity.isPowered() || blockEntity.isSuspended()) {
 			return;
 		}
 		if (!blockEntity.hasChannel()) {
@@ -87,15 +88,15 @@ public void extractRenderState(
 		state.pictureTexture = switch (status == null ? PlaybackStatus.CONNECTING : status) {
 			case UNAVAILABLE -> NO_PLAYER;
 			case ERROR, ENDED -> ERROR;
-			case CONNECTING, BUFFERING, PLAYING -> CONNECTING;
-			case IDLE -> CONNECTING;
+			case CONNECTING, BUFFERING, PLAYING, IDLE -> CONNECTING;
 		};
 	}
 
 	@Override
 	public void submit(DisplayRenderState state, PoseStack poseStack, SubmitNodeCollector collector, CameraRenderState camera) {
 		DisplayType type = state.type;
-		if (type == null) {
+		DisplayGeometry geometry = state.geometry;
+		if (type == null || geometry == null) {
 			return;
 		}
 		poseStack.pushPose();
@@ -103,23 +104,23 @@ public void submit(DisplayRenderState state, PoseStack poseStack, SubmitNodeColl
 		poseStack.mulPose(Axis.YP.rotationDegrees(180.0F - state.facing.toYRot()));
 		poseStack.translate(-0.5F, -0.5F, -0.5F);
 
-		Sheet screen = new Sheet(type.screenLeft(), type.screenBottom(), type.screenRight(), type.screenTop());
+		Sheet screen = new Sheet(geometry.screenLeft(), geometry.screenBottom(), geometry.screenRight(), geometry.screenTop());
 		int bodyLight = state.lightCoords;
-		submitSheet(type, screen, BACKING, BACKING_BIAS, false, bodyLight, poseStack, collector);
-		submitSheet(type, screen, BACKING, BACK_FACE_BIAS, true, bodyLight, poseStack, collector);
-		submitSheet(type, screen, SCREEN_OFF, SCREEN_BIAS, false, bodyLight, poseStack, collector);
+		submitSheet(geometry, screen, BACKING, BACKING_BIAS, false, bodyLight, poseStack, collector);
+		submitSheet(geometry, screen, BACKING, BACK_FACE_BIAS, true, bodyLight, poseStack, collector);
+		submitSheet(geometry, screen, SCREEN_OFF, SCREEN_BIAS, false, bodyLight, poseStack, collector);
 
 		if (state.pictureTexture != null) {
 			boolean statusGraphic = Math.abs(state.pictureAspect - STATUS_ASPECT) < 0.001F;
 			FittedPicture fitted = statusGraphic
 				? FittedPicture.full(screen)
-				: containContent(type, screen, state.pictureAspect);
+				: fitContent(type, geometry, screen, state.pictureAspect);
 			float u0 = lerp(state.contentU0, state.contentU1, fitted.uMin());
 			float u1 = lerp(state.contentU0, state.contentU1, fitted.uMax());
 			float v0 = lerp(state.contentV0, state.contentV1, fitted.vMin());
 			float v1 = lerp(state.contentV0, state.contentV1, fitted.vMax());
 			submitSheet(
-				type,
+				geometry,
 				fitted.sheet(),
 				state.pictureTexture,
 				PICTURE_BIAS,
@@ -137,11 +138,19 @@ public void submit(DisplayRenderState state, PoseStack poseStack, SubmitNodeColl
 		poseStack.popPose();
 	}
 
-	private static FittedPicture containContent(DisplayType type, Sheet screen, float pictureAspect) {
+	private static FittedPicture fitContent(DisplayType type, DisplayGeometry geometry, Sheet screen, float pictureAspect) {
+		// The repurposed Wall Television is the 27x13 crop-to-fill preset.
+		if (type == DisplayType.WALL_TELEVISION) {
+			return coverContent(geometry, screen, pictureAspect);
+		}
+		return containContent(geometry, screen, pictureAspect);
+	}
+
+	private static FittedPicture containContent(DisplayGeometry geometry, Sheet screen, float pictureAspect) {
 		if (pictureAspect <= 0.05F || screen.height() <= 0.0F) {
 			return FittedPicture.full(screen);
 		}
-		float screenWidth = type.isCurved() ? type.arcLengthPx(screen.left(), screen.right()) : screen.width();
+		float screenWidth = geometry.isCurved() ? geometry.arcLengthPx(screen.left(), screen.right()) : screen.width();
 		float screenAspect = screenWidth / screen.height();
 		if (Math.abs(screenAspect - pictureAspect) < 0.001F) {
 			return FittedPicture.full(screen);
@@ -151,12 +160,31 @@ private static FittedPicture containContent(DisplayType type, Sheet screen, floa
 			float inset = (screen.height() - fittedHeight) * 0.5F;
 			return FittedPicture.full(new Sheet(screen.left(), screen.bottom() + inset, screen.right(), screen.top() - inset));
 		}
-		float inset = type.isCurved()
-			? type.pillarboxInsetForAspect(screen.left(), screen.right(), screen.height(), pictureAspect)
+		float inset = geometry.isCurved()
+			? geometry.pillarboxInsetForAspect(screen.left(), screen.right(), screen.height(), pictureAspect)
 			: (screen.width() - screen.height() * pictureAspect) * 0.5F;
 		return FittedPicture.full(new Sheet(screen.left() + inset, screen.bottom(), screen.right() - inset, screen.top()));
 	}
 
+	private static FittedPicture coverContent(DisplayGeometry geometry, Sheet screen, float pictureAspect) {
+		if (pictureAspect <= 0.05F || screen.height() <= 0.0F) {
+			return FittedPicture.full(screen);
+		}
+		float screenWidth = geometry.isCurved() ? geometry.arcLengthPx(screen.left(), screen.right()) : screen.width();
+		float screenAspect = screenWidth / screen.height();
+		if (Math.abs(screenAspect - pictureAspect) < 0.001F) {
+			return FittedPicture.full(screen);
+		}
+		if (pictureAspect > screenAspect) {
+			float keptWidth = screenAspect / pictureAspect;
+			float inset = (1.0F - keptWidth) * 0.5F;
+			return new FittedPicture(screen, inset, 1.0F - inset, 0.0F, 1.0F);
+		}
+		float keptHeight = pictureAspect / screenAspect;
+		float inset = (1.0F - keptHeight) * 0.5F;
+		return new FittedPicture(screen, 0.0F, 1.0F, inset, 1.0F - inset);
+	}
+
 	private record FittedPicture(Sheet sheet, float uMin, float uMax, float vMin, float vMax) {
 		static FittedPicture full(Sheet sheet) {
 			return new FittedPicture(sheet, 0.0F, 1.0F, 0.0F, 1.0F);
@@ -164,7 +192,7 @@ static FittedPicture full(Sheet sheet) {
 	}
 
 	private static void submitSheet(
-		DisplayType type,
+		DisplayGeometry geometry,
 		Sheet sheet,
 		net.minecraft.resources.Identifier texture,
 		float bias,
@@ -173,11 +201,11 @@ private static void submitSheet(
 		PoseStack poseStack,
 		SubmitNodeCollector collector
 	) {
-		submitSheet(type, sheet, texture, bias, backFace, packedLight, poseStack, collector, 0.0F, 1.0F, 0.0F, 1.0F);
+		submitSheet(geometry, sheet, texture, bias, backFace, packedLight, poseStack, collector, 0.0F, 1.0F, 0.0F, 1.0F);
 	}
 
 	private static void submitSheet(
-		DisplayType type,
+		DisplayGeometry geometry,
 		Sheet sheet,
 		net.minecraft.resources.Identifier texture,
 		float bias,
@@ -197,14 +225,14 @@ private static void submitSheet(
 		collector.submitCustomGeometry(
 			poseStack,
 			renderType,
-			(pose, buffer) -> emit(pose, buffer, type, sheet, bias, backFace, packedLight, uMin, uMax, vMin, vMax)
+			(pose, buffer) -> emit(pose, buffer, geometry, sheet, bias, backFace, packedLight, uMin, uMax, vMin, vMax)
 		);
 	}
 
 	private static void emit(
 		PoseStack.Pose pose,
 		VertexConsumer buffer,
-		DisplayType type,
+		DisplayGeometry geometry,
 		Sheet sheet,
 		float bias,
 		boolean backFace,
@@ -214,9 +242,11 @@ private static void emit(
 		float vMin,
 		float vMax
 	) {
-		float displayWidth = type.displayWidthPx();
-		float controllerRight = (type.controllerColumn() + 1) * 16.0F;
-		int segments = type.isCurved() ? Math.max(1, Math.round((float)type.curveSegments() * sheet.width() / displayWidth)) : 1;
+		float displayWidth = geometry.displayWidthPx();
+		float controllerRight = (geometry.controllerColumn() + 1) * 16.0F;
+		int segments = geometry.isCurved()
+			? Math.max(1, Math.round((float)geometry.curveSegments() * sheet.width() / displayWidth))
+			: 1;
 		float vTop = vMin;
 		float vBottom = vMax;
 		float yBottom = sheet.bottom();
@@ -227,7 +257,7 @@ private static void emit(
 		for (int i = 1; i <= segments; i++) {
 			float d0 = lerp(sheet.left(), sheet.right(), (float)(i - 1) / segments);
 			float d1 = lerp(sheet.left(), sheet.right(), (float)i / segments);
-			arcAt[i] = arcAt[i - 1] + type.arcLengthPx(d0, d1);
+			arcAt[i] = arcAt[i - 1] + geometry.arcLengthPx(d0, d1);
 		}
 		float totalArc = Math.max(arcAt[segments], 1.0E-4F);
 
@@ -236,8 +266,8 @@ private static void emit(
 			float d1 = lerp(sheet.left(), sheet.right(), (float)(i + 1) / segments);
 			float x0 = controllerRight - d0;
 			float x1 = controllerRight - d1;
-			float z0 = type.depthAt(d0 / displayWidth) - bias;
-			float z1 = type.depthAt(d1 / displayWidth) - bias;
+			float z0 = geometry.depthAt(d0 / displayWidth) - bias;
+			float z1 = geometry.depthAt(d1 / displayWidth) - bias;
 			float u0 = uMin + (uMax - uMin) * (arcAt[i] / totalArc);
 			float u1 = uMin + (uMax - uMin) * (arcAt[i + 1] / totalArc);
 			float slope = Math.abs(x1 - x0) < 1.0E-5F ? 0.0F : (z1 - z0) / (x1 - x0);
diff --git a/src/client/java/com/pixelreel/client/render/DisplayRenderState.java b/src/client/java/com/pixelreel/client/render/DisplayRenderState.java
index d119f1b..2d1aa21 100644
--- a/src/client/java/com/pixelreel/client/render/DisplayRenderState.java
+++ b/src/client/java/com/pixelreel/client/render/DisplayRenderState.java
@@ -1,5 +1,6 @@
 package com.pixelreel.client.render;
 
+import com.pixelreel.blocks.DisplayGeometry;
 import com.pixelreel.blocks.DisplayType;
 import net.minecraft.client.renderer.blockentity.state.BlockEntityRenderState;
 import net.minecraft.core.Direction;
@@ -8,6 +9,7 @@
 
 public class DisplayRenderState extends BlockEntityRenderState {
 	public @Nullable DisplayType type;
+	public @Nullable DisplayGeometry geometry;
 	public Direction facing = Direction.NORTH;
 	public @Nullable Identifier pictureTexture;
 	public float pictureAspect;
diff --git a/src/main/java/com/pixelreel/ClientBridge.java b/src/main/java/com/pixelreel/ClientBridge.java
index e1013de..ff51198 100644
--- a/src/main/java/com/pixelreel/ClientBridge.java
+++ b/src/main/java/com/pixelreel/ClientBridge.java
@@ -1,6 +1,7 @@
 package com.pixelreel;
 
 import net.minecraft.core.BlockPos;
+import net.minecraft.world.InteractionHand;
 import org.jspecify.annotations.Nullable;
 
 public final class ClientBridge {
@@ -27,9 +28,27 @@ public static void releasePlayback(BlockPos controllerPos) {
 		}
 	}
 
+	public static void openCustomScreenPlacement(BlockPos controllerPos, InteractionHand hand, boolean curved) {
+		Handler current = handler;
+		if (current != null) {
+			current.openCustomScreenPlacement(controllerPos, hand, curved);
+		}
+	}
+
+	public static void openScreenwriterLink(BlockPos controllerPos) {
+		Handler current = handler;
+		if (current != null) {
+			current.openScreenwriterLink(controllerPos);
+		}
+	}
+
 	public interface Handler {
 		void openChannelMenu(BlockPos controllerPos);
 
 		void releasePlayback(BlockPos controllerPos);
+
+		void openCustomScreenPlacement(BlockPos controllerPos, InteractionHand hand, boolean curved);
+
+		void openScreenwriterLink(BlockPos controllerPos);
 	}
 }
diff --git a/src/main/java/com/pixelreel/PixelReel.java b/src/main/java/com/pixelreel/PixelReel.java
index 0fb7d78..87226de 100644
--- a/src/main/java/com/pixelreel/PixelReel.java
+++ b/src/main/java/com/pixelreel/PixelReel.java
@@ -2,6 +2,7 @@
 
 import com.pixelreel.channels.ChannelService;
 import com.pixelreel.commands.TvCommand;
+import com.pixelreel.commands.ScreenwriterCommand;
 import com.pixelreel.config.ConfigManager;
 import com.pixelreel.networking.ModNetworkPayloads;
 import com.pixelreel.networking.ServerNetworking;
@@ -10,8 +11,10 @@
 import com.pixelreel.registry.ModBlocks;
 import com.pixelreel.registry.ModCreativeTabs;
 import com.pixelreel.registry.ModItems;
+import com.pixelreel.server.ScreenwriterManager;
 import net.fabricmc.api.ModInitializer;
 import net.fabricmc.fabric.api.event.lifecycle.v1.ServerLifecycleEvents;
+import net.fabricmc.fabric.api.event.lifecycle.v1.ServerTickEvents;
 import net.minecraft.resources.Identifier;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -30,12 +33,16 @@ public void onInitialize() {
 		ModNetworkPayloads.register();
 		ServerNetworking.register();
 		TvCommand.register();
+		ScreenwriterCommand.register();
+		ServerTickEvents.END_SERVER_TICK.register(ScreenwriterManager::tick);
 		ServerLifecycleEvents.SERVER_STARTED.register(server -> {
+			ScreenwriterManager.start(server);
 			LOGGER.info("pixelReel configuration file: {}", ConfigManager.path());
 			ChannelService.INSTANCE.channels(false);
 			OnDemandCatalog.refreshConfigured(false);
 		});
 		ServerLifecycleEvents.SERVER_STOPPED.register(server -> {
+			ScreenwriterManager.stop(server);
 			ChannelService.INSTANCE.invalidateCache();
 			OnDemandCatalog.invalidateAll();
 		});
diff --git a/src/main/java/com/pixelreel/blockentities/DisplayBlockEntity.java b/src/main/java/com/pixelreel/blockentities/DisplayBlockEntity.java
index f4a2aa0..97c56f8 100644
--- a/src/main/java/com/pixelreel/blockentities/DisplayBlockEntity.java
+++ b/src/main/java/com/pixelreel/blockentities/DisplayBlockEntity.java
@@ -2,6 +2,7 @@
 
 import com.pixelreel.ClientBridge;
 import com.pixelreel.blocks.DisplayBlock;
+import com.pixelreel.blocks.DisplayGeometry;
 import com.pixelreel.blocks.DisplayType;
 import com.pixelreel.channels.Channel;
 import com.pixelreel.config.ConfigManager;
@@ -64,9 +65,19 @@ public class DisplayBlockEntity extends BlockEntity {
 	private static final String KEY_PLEX_MEDIA = "PlexMediaIdx";
 	private static final String KEY_PLEX_PART = "PlexPartIdx";
 	private static final String KEY_PLEX_PART_KEY = "PlexPartKey";
+	private static final String KEY_CUSTOM_WIDTH = "CustomWidth";
+	private static final String KEY_CUSTOM_HEIGHT = "CustomHeight";
+	private static final String KEY_CUSTOM_AUDIO_DEPTH = "CustomAudioDepth";
+	private static final String KEY_CUSTOM_AUDIO_SIDE = "CustomAudioSide";
 
 	public static final int MAX_STREAM_URL = 2048;
 	public static final int MAX_OVERVIEW = 1024;
+	public static final int DEFAULT_CUSTOM_AUDIO_DEPTH = 40;
+	public static final int DEFAULT_CUSTOM_AUDIO_SIDE = 2;
+	public static final int MIN_CUSTOM_AUDIO_DEPTH = 1;
+	public static final int MAX_CUSTOM_AUDIO_DEPTH = 256;
+	public static final int MIN_CUSTOM_AUDIO_SIDE = 0;
+	public static final int MAX_CUSTOM_AUDIO_SIDE = 64;
 
 	private boolean powered;
 	private boolean suspended;
@@ -110,6 +121,10 @@ public class DisplayBlockEntity extends BlockEntity {
 	private int plexMediaIndex;
 	private int plexPartIndex;
 	private String plexPartKey = "";
+	private int customWidthBlocks;
+	private int customHeightBlocks;
+	private int customAudioDepthBlocks = DEFAULT_CUSTOM_AUDIO_DEPTH;
+	private int customAudioSideBlocks = DEFAULT_CUSTOM_AUDIO_SIDE;
 
 	public DisplayBlockEntity(BlockPos pos, BlockState state) {
 		super(ModBlockEntities.DISPLAY, pos, state);
@@ -125,6 +140,59 @@ public DisplayType type() {
 		return block == null ? DisplayType.COMPACT_TELEVISION : block.type();
 	}
 
+	public boolean isCustomScreen() {
+		DisplayType type = this.type();
+		return type == DisplayType.CURVED_CINEMA_SCREEN || type == DisplayType.CINEMA_SCREEN;
+	}
+
+	public int customWidthBlocks() {
+		return this.geometry().widthBlocks();
+	}
+
+	public int customHeightBlocks() {
+		return this.geometry().heightBlocks();
+	}
+
+	public void setCustomSize(int widthBlocks, int heightBlocks) {
+		if (!this.isCustomScreen()) {
+			return;
+		}
+		this.customWidthBlocks = Math.clamp(widthBlocks, DisplayGeometry.MIN_WIDTH, DisplayGeometry.MAX_WIDTH);
+		this.customHeightBlocks = Math.clamp(heightBlocks, DisplayGeometry.MIN_HEIGHT, DisplayGeometry.MAX_HEIGHT);
+		this.panelsValidated = true;
+		this.markDirtyAndSync();
+	}
+
+	public int customAudioDepthBlocks() {
+		return this.customAudioDepthBlocks;
+	}
+
+	public int customAudioSideBlocks() {
+		return this.customAudioSideBlocks;
+	}
+
+	public void setCustomAudioZone(int depthBlocks, int sideBlocks) {
+		if (!this.isCustomScreen()) {
+			return;
+		}
+		this.customAudioDepthBlocks = Math.clamp(depthBlocks, MIN_CUSTOM_AUDIO_DEPTH, MAX_CUSTOM_AUDIO_DEPTH);
+		this.customAudioSideBlocks = Math.clamp(sideBlocks, MIN_CUSTOM_AUDIO_SIDE, MAX_CUSTOM_AUDIO_SIDE);
+		this.markDirtyAndSync();
+	}
+
+	public DisplayGeometry geometry() {
+		DisplayType type = this.type();
+		if (type == DisplayType.CURVED_CINEMA_SCREEN || type == DisplayType.CINEMA_SCREEN) {
+			int width = this.customWidthBlocks > 0 ? this.customWidthBlocks : type.widthBlocks();
+			int height = this.customHeightBlocks > 0 ? this.customHeightBlocks : type.heightBlocks();
+			if (type == DisplayType.CINEMA_SCREEN) {
+				return DisplayGeometry.customCurved(width, height, type.audioRange());
+			}
+			return DisplayGeometry.customFlat(width, height, type.audioRange());
+		}
+		return DisplayGeometry.fromType(type);
+	}
+
 	public Direction facing() {
 		BlockState state = this.getBlockState();
 		return state.hasProperty(DisplayBlock.FACING) ? state.getValue(DisplayBlock.FACING) : Direction.NORTH;
@@ -329,14 +397,14 @@ private long clampPos(long positionMs) {
 	}
 
 	public Vec3 screenCentre() {
-		DisplayType type = this.type();
+		DisplayGeometry geometry = this.geometry();
 		Direction facing = this.facing();
 		Direction axis = facing.getCounterClockWise();
-		double halfWidthOffset = (type.widthBlocks() - 1) / 2.0 - type.controllerColumn();
+		double halfWidthOffset = (geometry.widthBlocks() - 1) / 2.0 - geometry.controllerColumn();
 		Vec3 base = Vec3.atCenterOf(this.worldPosition);
 		return base.add(
 			axis.getStepX() * halfWidthOffset,
-			type.heightBlocks() / 2.0 - 0.5,
+			geometry.heightBlocks() / 2.0 - 0.5,
 			axis.getStepZ() * halfWidthOffset
 		);
 	}
@@ -624,7 +692,7 @@ public void serverTick() {
 				this.panelsValidated = true;
 				DisplayBlock block = this.displayBlock();
 				if (block != null) {
-					DisplayBlock.placePanels(this.level, this.worldPosition, block.type(), this.facing(), true);
+					DisplayBlock.placePanels(this.level, this.worldPosition, this.geometry(), this.facing(), true);
 				}
 			}
 		}
@@ -720,6 +788,16 @@ protected void saveAdditional(ValueOutput output) {
 		output.putInt(KEY_PLEX_MEDIA, this.plexMediaIndex);
 		output.putInt(KEY_PLEX_PART, this.plexPartIndex);
 		output.putString(KEY_PLEX_PART_KEY, this.plexPartKey);
+		if (this.customWidthBlocks > 0) {
+			output.putInt(KEY_CUSTOM_WIDTH, this.customWidthBlocks);
+		}
+		if (this.customHeightBlocks > 0) {
+			output.putInt(KEY_CUSTOM_HEIGHT, this.customHeightBlocks);
+		}
+		if (this.isCustomScreen()) {
+			output.putInt(KEY_CUSTOM_AUDIO_DEPTH, this.customAudioDepthBlocks);
+			output.putInt(KEY_CUSTOM_AUDIO_SIDE, this.customAudioSideBlocks);
+		}
 	}
 
 	@Override
@@ -762,6 +840,24 @@ protected void loadAdditional(ValueInput input) {
 		this.plexMediaIndex = Math.max(0, input.getIntOr(KEY_PLEX_MEDIA, 0));
 		this.plexPartIndex = Math.max(0, input.getIntOr(KEY_PLEX_PART, 0));
 		this.plexPartKey = clampLength(input.getStringOr(KEY_PLEX_PART_KEY, ""), MAX_STREAM_URL);
+		int storedCustomWidth = input.getIntOr(KEY_CUSTOM_WIDTH, 0);
+		int storedCustomHeight = input.getIntOr(KEY_CUSTOM_HEIGHT, 0);
+		this.customWidthBlocks = storedCustomWidth > 0
+			? Math.clamp(storedCustomWidth, DisplayGeometry.MIN_WIDTH, DisplayGeometry.MAX_WIDTH)
+			: 0;
+		this.customHeightBlocks = storedCustomHeight > 0
+			? Math.clamp(storedCustomHeight, DisplayGeometry.MIN_HEIGHT, DisplayGeometry.MAX_HEIGHT)
+			: 0;
+		this.customAudioDepthBlocks = Math.clamp(
+			input.getIntOr(KEY_CUSTOM_AUDIO_DEPTH, DEFAULT_CUSTOM_AUDIO_DEPTH),
+			MIN_CUSTOM_AUDIO_DEPTH,
+			MAX_CUSTOM_AUDIO_DEPTH
+		);
+		this.customAudioSideBlocks = Math.clamp(
+			input.getIntOr(KEY_CUSTOM_AUDIO_SIDE, DEFAULT_CUSTOM_AUDIO_SIDE),
+			MIN_CUSTOM_AUDIO_SIDE,
+			MAX_CUSTOM_AUDIO_SIDE
+		);
 	}
 
 	private static JellyfinItemKind parseKind(String raw) {
diff --git a/src/main/java/com/pixelreel/blockentities/ScreenPanelBlockEntity.java b/src/main/java/com/pixelreel/blockentities/ScreenPanelBlockEntity.java
index 9ddcdb8..160db0f 100644
--- a/src/main/java/com/pixelreel/blockentities/ScreenPanelBlockEntity.java
+++ b/src/main/java/com/pixelreel/blockentities/ScreenPanelBlockEntity.java
@@ -1,6 +1,7 @@
 package com.pixelreel.blockentities;
 
 import com.pixelreel.blocks.DisplayBlock;
+import com.pixelreel.blocks.DisplayGeometry;
 import com.pixelreel.blocks.ScreenShapes;
 import com.pixelreel.registry.ModBlockEntities;
 import net.minecraft.core.BlockPos;
@@ -59,11 +60,12 @@ public void bindTo(BlockPos pos) {
 			return null;
 		}
 		Direction facing = controller.facing();
-		ScreenShapes.Cell cell = ScreenShapes.cellOf(controller.getBlockPos(), block.type(), facing, this.worldPosition);
+		DisplayGeometry geometry = controller.geometry();
+		ScreenShapes.Cell cell = ScreenShapes.cellOf(controller.getBlockPos(), geometry, facing, this.worldPosition);
 		if (cell == null) {
 			return null;
 		}
-		VoxelShape shape = ScreenShapes.cellShapeForRow(block.type(), facing, cell.column(), cell.row(), cell.depthCell());
+		VoxelShape shape = ScreenShapes.cellShapeForRow(geometry, facing, cell.column(), cell.row(), cell.depthCell());
 		this.cachedShape = shape;
 		return shape;
 	}
diff --git a/src/main/java/com/pixelreel/blocks/DisplayBlock.java b/src/main/java/com/pixelreel/blocks/DisplayBlock.java
index 510977a..832f61a 100644
--- a/src/main/java/com/pixelreel/blocks/DisplayBlock.java
+++ b/src/main/java/com/pixelreel/blocks/DisplayBlock.java
@@ -75,8 +75,9 @@ protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockSt
 		Direction facing = context.getHorizontalDirection().getOpposite();
 		BlockPos controllerPos = context.getClickedPos();
 		Level level = context.getLevel();
-		for (ScreenShapes.Cell cell : ScreenShapes.cells(this.type)) {
-			BlockPos cellPos = ScreenShapes.cellPos(controllerPos, this.type, facing, cell);
+		DisplayGeometry geometry = DisplayGeometry.fromType(this.type);
+		for (ScreenShapes.Cell cell : ScreenShapes.cells(geometry)) {
+			BlockPos cellPos = ScreenShapes.cellPos(controllerPos, geometry, facing, cell);
 			if (cellPos.equals(controllerPos)) {
 				continue;
 			}
@@ -95,20 +96,25 @@ protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockSt
 	public void setPlacedBy(Level level, BlockPos pos, BlockState state, @Nullable LivingEntity by, ItemStack itemStack) {
 		super.setPlacedBy(level, pos, state, by, itemStack);
 		if (!level.isClientSide()) {
-			placePanels(level, pos, this.type, state.getValue(FACING), false);
+			DisplayGeometry geometry = level.getBlockEntity(pos) instanceof DisplayBlockEntity display
+				? display.geometry()
+				: DisplayGeometry.fromType(this.type);
+			placePanels(level, pos, geometry, state.getValue(FACING), false);
 		}
 	}
 
 	@Override
 	protected void affectNeighborsAfterRemoval(BlockState state, ServerLevel level, BlockPos pos, boolean movedByPiston) {
-		removePanels(level, pos, this.type, state.getValue(FACING));
+		// The custom screen can be larger than its enum fallback size. Remove every
+		// panel bound to this controller within the supported custom-screen bounds.
+		removeBoundPanels(level, pos, state.getValue(FACING));
 		super.affectNeighborsAfterRemoval(state, level, pos, movedByPiston);
 	}
 
-	public static int placePanels(Level level, BlockPos controllerPos, DisplayType type, Direction facing, boolean onlyReplaceable) {
+	public static int placePanels(Level level, BlockPos controllerPos, DisplayGeometry geometry, Direction facing, boolean onlyReplaceable) {
 		int placed = 0;
-		for (ScreenShapes.Cell cell : ScreenShapes.cells(type)) {
-			BlockPos cellPos = ScreenShapes.cellPos(controllerPos, type, facing, cell);
+		for (ScreenShapes.Cell cell : ScreenShapes.cells(geometry)) {
+			BlockPos cellPos = ScreenShapes.cellPos(controllerPos, geometry, facing, cell);
 			if (cellPos.equals(controllerPos) || cell.depthCell() > 0) {
 				continue;
 			}
@@ -129,9 +135,9 @@ public static int placePanels(Level level, BlockPos controllerPos, DisplayType t
 		return placed;
 	}
 
-	public static void removePanels(Level level, BlockPos controllerPos, DisplayType type, Direction facing) {
-		for (ScreenShapes.Cell cell : ScreenShapes.cells(type)) {
-			BlockPos cellPos = ScreenShapes.cellPos(controllerPos, type, facing, cell);
+	public static void removePanels(Level level, BlockPos controllerPos, DisplayGeometry geometry, Direction facing) {
+		for (ScreenShapes.Cell cell : ScreenShapes.cells(geometry)) {
+			BlockPos cellPos = ScreenShapes.cellPos(controllerPos, geometry, facing, cell);
 			if (cellPos.equals(controllerPos)) {
 				continue;
 			}
@@ -143,28 +149,50 @@ public static void removePanels(Level level, BlockPos controllerPos, DisplayType
 		}
 	}
 
+	private static void removeBoundPanels(Level level, BlockPos controllerPos, Direction facing) {
+		Direction columnAxis = facing.getCounterClockWise();
+		Direction back = facing.getOpposite();
+		int horizontalRadius = DisplayGeometry.MAX_WIDTH / 2 + 1;
+		for (int offset = -horizontalRadius; offset <= horizontalRadius; offset++) {
+			for (int row = 0; row < DisplayGeometry.MAX_HEIGHT; row++) {
+				for (int depth = -1; depth <= 1; depth++) {
+					BlockPos panelPos = controllerPos.relative(columnAxis, offset).above(row).relative(back, depth);
+					if (panelPos.equals(controllerPos)) {
+						continue;
+					}
+					if (level.getBlockEntity(panelPos) instanceof ScreenPanelBlockEntity panel && panel.isBoundTo(controllerPos)) {
+						level.removeBlock(panelPos, false);
+					}
+				}
+			}
+		}
+	}
+
 	@Override
 	protected VoxelShape getShape(BlockState state, BlockGetter level, BlockPos pos, CollisionContext context) {
-		return controllerShape(state);
+		return controllerShape(state, level, pos);
 	}
 
 	@Override
 	protected VoxelShape getCollisionShape(BlockState state, BlockGetter level, BlockPos pos, CollisionContext context) {
-		return controllerShape(state);
+		return controllerShape(state, level, pos);
 	}
 
 	@Override
 	protected VoxelShape getInteractionShape(BlockState state, BlockGetter level, BlockPos pos) {
-		return controllerShape(state);
+		return controllerShape(state, level, pos);
 	}
 
-	private VoxelShape controllerShape(BlockState state) {
+	private VoxelShape controllerShape(BlockState state, BlockGetter level, BlockPos pos) {
 		Direction facing = state.getValue(FACING);
-		VoxelShape screen = ScreenShapes.cellShapeForRow(this.type, facing, this.type.controllerColumn(), 0, 0);
+		DisplayGeometry geometry = level.getBlockEntity(pos) instanceof DisplayBlockEntity display
+			? display.geometry()
+			: DisplayGeometry.fromType(this.type);
+		VoxelShape screen = ScreenShapes.cellShapeForRow(geometry, facing, geometry.controllerColumn(), 0, 0);
 		if (!screen.isEmpty()) {
 			return screen;
 		}
-		return ScreenShapes.controllerStandShape(this.type, facing);
+		return ScreenShapes.controllerStandShape(geometry, facing);
 	}
 
 	@Override
diff --git a/src/main/java/com/pixelreel/blocks/DisplayGeometry.java b/src/main/java/com/pixelreel/blocks/DisplayGeometry.java
new file mode 100644
index 0000000..66f4ed0
--- /dev/null
+++ b/src/main/java/com/pixelreel/blocks/DisplayGeometry.java
@@ -0,0 +1,162 @@
+package com.pixelreel.blocks;
+
+/**
+ * Runtime display geometry. Legacy fixed displays copy values from DisplayType;
+ * the custom flat and curved cinema screens override geometry per placed screen.
+ */
+public record DisplayGeometry(
+	int widthBlocks,
+	int heightBlocks,
+	int controllerColumn,
+	float screenLeft,
+	float screenBottom,
+	float screenRight,
+	float screenTop,
+	float baseZ,
+	float curveDepth,
+	int curveSegments,
+	float audioRange
+) {
+	public static final int MIN_WIDTH = 1;
+	public static final int MIN_HEIGHT = 1;
+	public static final int MAX_WIDTH = 64;
+	public static final int MAX_HEIGHT = 36;
+
+	public static DisplayGeometry fromType(DisplayType type) {
+		return new DisplayGeometry(
+			type.widthBlocks(),
+			type.heightBlocks(),
+			type.controllerColumn(),
+			type.screenLeft(),
+			type.screenBottom(),
+			type.screenRight(),
+			type.screenTop(),
+			type.baseZ(),
+			type.curveDepth(),
+			type.curveSegments(),
+			type.audioRange()
+		);
+	}
+
+	public static DisplayGeometry customFlat(int widthBlocks, int heightBlocks, float audioRange) {
+		int width = Math.clamp(widthBlocks, MIN_WIDTH, MAX_WIDTH);
+		int height = Math.clamp(heightBlocks, MIN_HEIGHT, MAX_HEIGHT);
+		int controller = (width - 1) / 2;
+		return new DisplayGeometry(
+			width,
+			height,
+			controller,
+			0.0F,
+			0.0F,
+			width * 16.0F,
+			height * 16.0F,
+			15.0F,
+			0.0F,
+			1,
+			audioRange
+		);
+	}
+
+	/** Configurable curved cinema screen using the original PixelReel curved-screen profile. */
+	public static DisplayGeometry customCurved(int widthBlocks, int heightBlocks, float audioRange) {
+		int width = Math.clamp(widthBlocks, MIN_WIDTH, MAX_WIDTH);
+		int height = Math.clamp(heightBlocks, MIN_HEIGHT, MAX_HEIGHT);
+		int controller = (width - 1) / 2;
+		// Keep the centre against the back of the occupied block space, then bow
+		// the left/right edges toward the viewer. Cap the depth at the original
+		// curved cinema screen's 22-pixel profile so even very wide custom screens
+		// remain within the renderer/panel depth budget.
+		float curveDepth = Math.min(22.0F, width * 16.0F * (22.0F / 256.0F));
+		int curveSegments = Math.clamp(width * 2, 8, 64);
+		return new DisplayGeometry(
+			width,
+			height,
+			controller,
+			0.0F,
+			0.0F,
+			width * 16.0F,
+			height * 16.0F,
+			15.0F,
+			curveDepth,
+			curveSegments,
+			audioRange
+		);
+	}
+
+	public float displayWidthPx() {
+		return this.widthBlocks * 16.0F;
+	}
+
+	public float displayHeightPx() {
+		return this.heightBlocks * 16.0F;
+	}
+
+	public boolean isCurved() {
+		return this.curveDepth > 0.0F;
+	}
+
+	public float screenAspect() {
+		float height = this.screenTop - this.screenBottom;
+		if (height <= 0.0F) {
+			return 1.0F;
+		}
+		return this.arcLengthPx(this.screenLeft, this.screenRight) / height;
+	}
+
+	public float depthAt(float u) {
+		if (!this.isCurved()) {
+			return this.baseZ;
+		}
+		float t = u * 2.0F - 1.0F;
+		return this.baseZ - this.curveDepth * t * t;
+	}
+
+	public float arcLengthPx(float fromD, float toD) {
+		float start = Math.min(fromD, toD);
+		float end = Math.max(fromD, toD);
+		if (end <= start) {
+			return 0.0F;
+		}
+		if (!this.isCurved()) {
+			return end - start;
+		}
+		int samples = Math.max(8, Math.round((end - start) / 2.0F));
+		float width = this.displayWidthPx();
+		float length = 0.0F;
+		float prevD = start;
+		float prevZ = this.depthAt(start / width);
+		for (int i = 1; i <= samples; i++) {
+			float d = start + (end - start) * i / samples;
+			float z = this.depthAt(d / width);
+			float dx = d - prevD;
+			float dz = z - prevZ;
+			length += (float)Math.sqrt(dx * dx + dz * dz);
+			prevD = d;
+			prevZ = z;
+		}
+		return length;
+	}
+
+	public float pillarboxInsetForAspect(float left, float right, float height, float targetAspect) {
+		if (height <= 0.0F || targetAspect <= 0.0F || right <= left) {
+			return 0.0F;
+		}
+		float fullArc = this.arcLengthPx(left, right);
+		float targetWidth = height * targetAspect;
+		if (targetWidth >= fullArc) {
+			return 0.0F;
+		}
+		float lo = 0.0F;
+		float hi = (right - left) * 0.5F;
+		for (int i = 0; i < 24; i++) {
+			float mid = (lo + hi) * 0.5F;
+			float arc = this.arcLengthPx(left + mid, right - mid);
+			if (arc > targetWidth) {
+				lo = mid;
+			} else {
+				hi = mid;
+			}
+		}
+		return (lo + hi) * 0.5F;
+	}
+}
diff --git a/src/main/java/com/pixelreel/blocks/DisplayType.java b/src/main/java/com/pixelreel/blocks/DisplayType.java
index faa8941..9122b14 100644
--- a/src/main/java/com/pixelreel/blocks/DisplayType.java
+++ b/src/main/java/com/pixelreel/blocks/DisplayType.java
@@ -2,11 +2,13 @@
 
 /** each display */
 public enum DisplayType {
-	COMPACT_TELEVISION("compact_television", 3, 2, 1, 0.0F, 0.0F, 48.0F, 32.0F, 1.0F, 0.0F, 1, 16.0F),
-	WALL_TELEVISION("wall_television", 6, 4, 2, 0.0F, 0.0F, 96.0F, 64.0F, 1.0F, 0.0F, 1, 24.0F),
-	ULTRAWIDE_MONITOR("ultrawide_monitor", 8, 4, 3, 0.0F, 0.0F, 128.0F, 64.0F, 1.0F, 0.0F, 1, 24.0F),
-	CINEMA_SCREEN("cinema_screen", 14, 8, 6, 0.0F, 0.0F, 224.0F, 128.0F, 1.0F, 0.0F, 1, 80.0F),
-	CURVED_CINEMA_SCREEN("curved_cinema_screen", 16, 7, 7, 0.0F, 0.0F, 256.0F, 112.0F, 15.2F, 22.0F, 32, 80.0F);
+	COMPACT_TELEVISION("compact_television", 23, 13, 11, 0.0F, 0.0F, 368.0F, 208.0F, 1.0F, 0.0F, 1, 80.0F),
+	WALL_TELEVISION("wall_television", 27, 13, 13, 0.0F, 0.0F, 432.0F, 208.0F, 1.0F, 0.0F, 1, 80.0F),
+	ULTRAWIDE_MONITOR("ultrawide_monitor", 27, 13, 13, 0.0F, 0.0F, 432.0F, 208.0F, 1.0F, 0.0F, 1, 80.0F),
+	// The cinema_screen registry slot is now the configurable curved cinema screen.
+	CINEMA_SCREEN("cinema_screen", 27, 11, 13, 0.0F, 0.0F, 432.0F, 176.0F, 1.0F, 0.0F, 1, 80.0F),
+	// The curved_cinema_screen registry slot remains the configurable flat cinema screen.
+	CURVED_CINEMA_SCREEN("curved_cinema_screen", 27, 11, 13, 0.0F, 0.0F, 432.0F, 176.0F, 1.0F, 0.0F, 1, 80.0F);
 
 	private final String id;
 	private final int widthBlocks;
diff --git a/src/main/java/com/pixelreel/blocks/ScreenPanelBlock.java b/src/main/java/com/pixelreel/blocks/ScreenPanelBlock.java
index 05e97ff..0f65012 100644
--- a/src/main/java/com/pixelreel/blocks/ScreenPanelBlock.java
+++ b/src/main/java/com/pixelreel/blocks/ScreenPanelBlock.java
@@ -85,6 +85,23 @@ private static VoxelShape shapeAt(BlockGetter level, BlockPos pos) {
 		return FALLBACK;
 	}
 
+	@Override
+	public BlockState playerWillDestroy(Level level, BlockPos pos, BlockState state, Player player) {
+		BlockPos controllerPos = null;
+		if (level.getBlockEntity(pos) instanceof ScreenPanelBlockEntity panel) {
+			controllerPos = panel.controllerPos();
+		}
+
+		BlockState result = super.playerWillDestroy(level, pos, state, player);
+		if (!level.isClientSide() && controllerPos != null && DisplayBlock.displayAt(level, controllerPos) != null) {
+			// Destroying the controller triggers DisplayBlock's existing cleanup, which
+			// removes every panel bound to the same display. Only the controller drops
+			// an item, so breaking a panel still behaves like breaking the whole screen.
+			level.destroyBlock(controllerPos, !player.hasInfiniteMaterials(), player);
+		}
+		return result;
+	}
+
 	@Override
 	protected InteractionResult useWithoutItem(BlockState state, Level level, BlockPos pos, Player player, BlockHitResult hitResult) {
 		if (level.getBlockEntity(pos) instanceof ScreenPanelBlockEntity panel) {
diff --git a/src/main/java/com/pixelreel/blocks/ScreenShapes.java b/src/main/java/com/pixelreel/blocks/ScreenShapes.java
index 5afe106..6614cd2 100644
--- a/src/main/java/com/pixelreel/blocks/ScreenShapes.java
+++ b/src/main/java/com/pixelreel/blocks/ScreenShapes.java
@@ -20,89 +20,89 @@ private ScreenShapes() {
 	public record Cell(int column, int row, int depthCell) {
 	}
 
-	public static List<Cell> cells(DisplayType type) {
+	public static List<Cell> cells(DisplayGeometry geometry) {
 		List<Cell> cells = new ArrayList<>();
 		boolean controllerAdded = false;
-		int colStart = Math.max(0, (int)Math.floor(type.screenLeft() / 16.0F));
-		int colEnd = Math.min(type.widthBlocks() - 1, (int)Math.floor((type.screenRight() - 0.001F) / 16.0F));
-		int rowStart = Math.max(0, (int)Math.floor(type.screenBottom() / 16.0F));
-		int rowEnd = Math.min(type.heightBlocks() - 1, (int)Math.floor((type.screenTop() - 0.001F) / 16.0F));
+		int colStart = Math.max(0, (int)Math.floor(geometry.screenLeft() / 16.0F));
+		int colEnd = Math.min(geometry.widthBlocks() - 1, (int)Math.floor((geometry.screenRight() - 0.001F) / 16.0F));
+		int rowStart = Math.max(0, (int)Math.floor(geometry.screenBottom() / 16.0F));
+		int rowEnd = Math.min(geometry.heightBlocks() - 1, (int)Math.floor((geometry.screenTop() - 0.001F) / 16.0F));
 
 		for (int column = colStart; column <= colEnd; column++) {
-			float[] range = columnDepthRange(type, column);
+			float[] range = columnDepthRange(geometry, column);
 			int kMin = Math.floorDiv((int)Math.floor(range[0] - HALF_THICKNESS), 16);
 			int kMax = Math.floorDiv((int)Math.floor(range[1] + HALF_THICKNESS), 16);
 			kMin = Math.max(-1, kMin);
 			kMax = Math.min(1, kMax);
 			for (int k = kMin; k <= kMax; k++) {
 				for (int row = rowStart; row <= rowEnd; row++) {
-					if (!cellIntersectsScreen(type, column, row)) {
+					if (!cellIntersectsScreen(geometry, column, row)) {
 						continue;
 					}
 					cells.add(new Cell(column, row, k));
-					if (column == type.controllerColumn() && row == 0 && k == 0) {
+					if (column == geometry.controllerColumn() && row == 0 && k == 0) {
 						controllerAdded = true;
 					}
 				}
 			}
 		}
 		if (!controllerAdded) {
-			cells.add(new Cell(type.controllerColumn(), 0, 0));
+			cells.add(new Cell(geometry.controllerColumn(), 0, 0));
 		}
 		return cells;
 	}
 
-	private static boolean cellIntersectsScreen(DisplayType type, int column, int row) {
+	private static boolean cellIntersectsScreen(DisplayGeometry geometry, int column, int row) {
 		float cellLeft = column * 16.0F;
 		float cellRight = cellLeft + 16.0F;
 		float cellBottom = row * 16.0F;
 		float cellTop = cellBottom + 16.0F;
-		return cellRight > type.screenLeft()
-			&& cellLeft < type.screenRight()
-			&& cellTop > type.screenBottom()
-			&& cellBottom < type.screenTop();
+		return cellRight > geometry.screenLeft()
+			&& cellLeft < geometry.screenRight()
+			&& cellTop > geometry.screenBottom()
+			&& cellBottom < geometry.screenTop();
 	}
 
-	public static BlockPos cellPos(BlockPos controllerPos, DisplayType type, Direction facing, Cell cell) {
+	public static BlockPos cellPos(BlockPos controllerPos, DisplayGeometry geometry, Direction facing, Cell cell) {
 		Direction columnAxis = facing.getCounterClockWise();
 		Direction back = facing.getOpposite();
-		return controllerPos.relative(columnAxis, cell.column() - type.controllerColumn())
+		return controllerPos.relative(columnAxis, cell.column() - geometry.controllerColumn())
 			.above(cell.row())
 			.relative(back, cell.depthCell());
 	}
 
-	public static @Nullable Cell cellOf(BlockPos controllerPos, DisplayType type, Direction facing, BlockPos pos) {
+	public static @Nullable Cell cellOf(BlockPos controllerPos, DisplayGeometry geometry, Direction facing, BlockPos pos) {
 		Direction columnAxis = facing.getCounterClockWise();
 		Direction back = facing.getOpposite();
 		BlockPos delta = pos.subtract(controllerPos);
-		int column = type.controllerColumn()
+		int column = geometry.controllerColumn()
 			+ delta.getX() * columnAxis.getStepX() + delta.getY() * columnAxis.getStepY() + delta.getZ() * columnAxis.getStepZ();
 		int row = delta.getY();
 		int depthCell = delta.getX() * back.getStepX() + delta.getZ() * back.getStepZ();
-		if (column < 0 || column >= type.widthBlocks() || row < 0 || row >= type.heightBlocks()) {
+		if (column < 0 || column >= geometry.widthBlocks() || row < 0 || row >= geometry.heightBlocks()) {
 			return null;
 		}
 		return new Cell(column, row, depthCell);
 	}
 
-	public static VoxelShape cellShape(DisplayType type, Direction facing, int column, int depthCell) {
-		return cellShapeForRow(type, facing, column, 0, depthCell);
+	public static VoxelShape cellShape(DisplayGeometry geometry, Direction facing, int column, int depthCell) {
+		return cellShapeForRow(geometry, facing, column, 0, depthCell);
 	}
 
-	public static VoxelShape controllerStandShape(DisplayType type, Direction facing) {
-		float z = Math.clamp(type.baseZ() - 1.0F, 1.0F, 14.0F);
+	public static VoxelShape controllerStandShape(DisplayGeometry geometry, Direction facing) {
+		float z = Math.clamp(geometry.baseZ() - 1.0F, 1.0F, 14.0F);
 		VoxelShape north = Block.box(4.0, 0.0, z - 2.0F, 12.0, 8.0, z + 2.0F);
 		return Shapes.rotateHorizontal(north).get(facing);
 	}
 
-	private static VoxelShape northCellShape(DisplayType type, int column, int depthCell) {
-		return northCellShape(type, column, 0, depthCell);
+	private static VoxelShape northCellShape(DisplayGeometry geometry, int column, int depthCell) {
+		return northCellShape(geometry, column, 0, depthCell);
 	}
 
-	private static VoxelShape northCellShape(DisplayType type, int column, int row, int depthCell) {
-		float width = type.displayWidthPx();
-		float localBottom = Math.max(0.0F, type.screenBottom() - row * 16.0F);
-		float localTop = Math.min(16.0F, type.screenTop() - row * 16.0F);
+	private static VoxelShape northCellShape(DisplayGeometry geometry, int column, int row, int depthCell) {
+		float width = geometry.displayWidthPx();
+		float localBottom = Math.max(0.0F, geometry.screenBottom() - row * 16.0F);
+		float localTop = Math.min(16.0F, geometry.screenTop() - row * 16.0F);
 		if (localTop - localBottom < 0.01F) {
 			return Shapes.empty();
 		}
@@ -110,10 +110,10 @@ private static VoxelShape northCellShape(DisplayType type, int column, int row,
 		for (int i = 0; i < SUB_BOXES_PER_CELL; i++) {
 			float dLo = column * 16.0F + i * (16.0F / SUB_BOXES_PER_CELL);
 			float dHi = dLo + 16.0F / SUB_BOXES_PER_CELL;
-			if (dHi <= type.screenLeft() || dLo >= type.screenRight()) {
+			if (dHi <= geometry.screenLeft() || dLo >= geometry.screenRight()) {
 				continue;
 			}
-			float[] range = depthRange(type, dLo / width, dHi / width);
+			float[] range = depthRange(geometry, dLo / width, dHi / width);
 			float zMin = range[0] - HALF_THICKNESS - depthCell * 16.0F;
 			float zMax = range[1] + HALF_THICKNESS - depthCell * 16.0F;
 			zMin = Math.max(0.0F, zMin);
@@ -128,26 +128,26 @@ private static VoxelShape northCellShape(DisplayType type, int column, int row,
 		return shape;
 	}
 
-	public static VoxelShape cellShapeForRow(DisplayType type, Direction facing, int column, int row, int depthCell) {
-		VoxelShape north = northCellShape(type, column, row, depthCell);
+	public static VoxelShape cellShapeForRow(DisplayGeometry geometry, Direction facing, int column, int row, int depthCell) {
+		VoxelShape north = northCellShape(geometry, column, row, depthCell);
 		if (north.isEmpty()) {
 			return north;
 		}
 		return Shapes.rotateHorizontal(north).get(facing);
 	}
 
-	private static float[] columnDepthRange(DisplayType type, int column) {
-		float width = type.displayWidthPx();
-		return depthRange(type, column * 16.0F / width, (column + 1) * 16.0F / width);
+	private static float[] columnDepthRange(DisplayGeometry geometry, int column) {
+		float width = geometry.displayWidthPx();
+		return depthRange(geometry, column * 16.0F / width, (column + 1) * 16.0F / width);
 	}
 
-	private static float[] depthRange(DisplayType type, float u0, float u1) {
-		float a = type.depthAt(u0);
-		float b = type.depthAt(u1);
+	private static float[] depthRange(DisplayGeometry geometry, float u0, float u1) {
+		float a = geometry.depthAt(u0);
+		float b = geometry.depthAt(u1);
 		float min = Math.min(a, b);
 		float max = Math.max(a, b);
 		if (u0 < 0.5F && u1 > 0.5F) {
-			max = Math.max(max, type.depthAt(0.5F));
+			max = Math.max(max, geometry.depthAt(0.5F));
 		}
 		return new float[]{min, max};
 	}
diff --git a/src/main/java/com/pixelreel/blocks/ScreenwriterConsoleBlock.java b/src/main/java/com/pixelreel/blocks/ScreenwriterConsoleBlock.java
new file mode 100644
index 0000000..a8ba36e
--- /dev/null
+++ b/src/main/java/com/pixelreel/blocks/ScreenwriterConsoleBlock.java
@@ -0,0 +1,33 @@
+package com.pixelreel.blocks;
+
+import com.pixelreel.server.ScreenwriterManager;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockBehaviour;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.BlockHitResult;
+
+/** Central console for Screenwriter theatre automation. */
+public class ScreenwriterConsoleBlock extends Block {
+	public ScreenwriterConsoleBlock(BlockBehaviour.Properties properties) {
+		super(properties);
+	}
+
+	@Override
+	protected InteractionResult useWithoutItem(
+		BlockState state, Level level, BlockPos pos, Player player, BlockHitResult hitResult
+	) {
+		if (!level.isClientSide() && player instanceof ServerPlayer serverPlayer && level.getServer() != null) {
+			if (player.isShiftKeyDown()) {
+				ScreenwriterManager.toggleEnabled(level.getServer(), serverPlayer);
+			} else {
+				ScreenwriterManager.selectConsole(serverPlayer, pos);
+			}
+		}
+		return InteractionResult.SUCCESS;
+	}
+}
diff --git a/src/main/java/com/pixelreel/commands/ScreenwriterCommand.java b/src/main/java/com/pixelreel/commands/ScreenwriterCommand.java
new file mode 100644
index 0000000..993d7ce
--- /dev/null
+++ b/src/main/java/com/pixelreel/commands/ScreenwriterCommand.java
@@ -0,0 +1,179 @@
+package com.pixelreel.commands;
+
+import com.mojang.brigadier.CommandDispatcher;
+import com.mojang.brigadier.arguments.IntegerArgumentType;
+import com.mojang.brigadier.arguments.StringArgumentType;
+import com.pixelreel.server.ScreenwriterManager;
+import java.util.ArrayList;
+import java.util.List;
+import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback;
+import net.minecraft.ChatFormatting;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.Commands;
+import net.minecraft.core.component.DataComponents;
+import net.minecraft.network.chat.Component;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.network.Filterable;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.item.component.WrittenBookContent;
+
+/** /screenwriter commands for theatre automation and schedule output. */
+public final class ScreenwriterCommand {
+	private ScreenwriterCommand() {
+	}
+
+	public static void register() {
+		CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> build(dispatcher));
+	}
+
+	private static void build(CommandDispatcher<CommandSourceStack> dispatcher) {
+		dispatcher.register(
+			Commands.literal("screenwriter")
+				.executes(context -> status(context.getSource()))
+				.then(Commands.literal("status").executes(context -> status(context.getSource())))
+				.then(Commands.literal("on").executes(context -> setEnabled(context.getSource(), true)))
+				.then(Commands.literal("off").executes(context -> setEnabled(context.getSource(), false)))
+				.then(Commands.literal("schedule").executes(context -> schedule(context.getSource())))
+				.then(Commands.literal("book").executes(context -> book(context.getSource())))
+				.then(Commands.literal("generate").executes(context -> generate(context.getSource(), false)))
+				.then(Commands.literal("regenerate").executes(context -> generate(context.getSource(), true)))
+				.then(Commands.literal("source")
+					.then(Commands.argument("provider", StringArgumentType.word())
+						.executes(context -> source(context.getSource(), StringArgumentType.getString(context, "provider")))))
+				.then(Commands.literal("open")
+					.then(Commands.argument("time", StringArgumentType.word())
+						.executes(context -> open(context.getSource(), StringArgumentType.getString(context, "time")))))
+				.then(Commands.literal("close")
+					.then(Commands.argument("time", StringArgumentType.word())
+						.executes(context -> close(context.getSource(), StringArgumentType.getString(context, "time")))))
+				.then(Commands.literal("turnaround")
+					.then(Commands.argument("minutes", IntegerArgumentType.integer(0, 120))
+						.executes(context -> turnaround(context.getSource(), IntegerArgumentType.getInteger(context, "minutes")))))
+				.then(Commands.literal("stagger")
+					.then(Commands.argument("minutes", IntegerArgumentType.integer(0, 180))
+						.executes(context -> stagger(context.getSource(), IntegerArgumentType.getInteger(context, "minutes")))))
+				.then(Commands.literal("maxstreams")
+					.then(Commands.argument("shows", IntegerArgumentType.integer(0, ScreenwriterManager.MAX_SCREENS))
+						.executes(context -> maxStreams(context.getSource(), IntegerArgumentType.getInteger(context, "shows")))))
+		);
+	}
+
+	private static int status(CommandSourceStack source) {
+		source.sendSuccess(ScreenwriterManager::statusComponent, false);
+		source.sendSuccess(
+			() -> Component.literal("Console: right-click to arm linking; Shift + right-click to toggle automation.")
+				.withStyle(ChatFormatting.GRAY),
+			false
+		);
+		source.sendSuccess(
+			() -> Component.literal("Linking: after selecting the console, sneak + right-click a custom screen with the Remote Control.")
+				.withStyle(ChatFormatting.GRAY),
+			false
+		);
+		return 1;
+	}
+
+	private static int setEnabled(CommandSourceStack source, boolean enabled) {
+		ScreenwriterManager.setEnabled(source.getServer(), enabled, source.getPlayer());
+		if (source.getPlayer() == null) {
+			source.sendSuccess(() -> Component.literal("Screenwriter automation " + (enabled ? "ON" : "OFF") + "."), false);
+		}
+		return 1;
+	}
+
+	private static int schedule(CommandSourceStack source) {
+		for (Component line : ScreenwriterManager.scheduleChatLines()) {
+			source.sendSuccess(() -> line, false);
+		}
+		return 1;
+	}
+
+	private static int book(CommandSourceStack source) {
+		ServerPlayer player = source.getPlayer();
+		if (player == null) {
+			source.sendFailure(Component.literal("Only a player can receive the Screenwriter schedule book."));
+			return 0;
+		}
+		List<String> pageText = ScreenwriterManager.scheduleBookPages();
+		List<Filterable<Component>> pages = new ArrayList<>();
+		for (String page : pageText) {
+			pages.add(Filterable.passThrough(Component.literal(page)));
+		}
+		WrittenBookContent content = new WrittenBookContent(
+			Filterable.passThrough("Today's Movie Schedule"),
+			"Screenwriter",
+			0,
+			pages,
+			true
+		);
+		ItemStack stack = new ItemStack(Items.WRITTEN_BOOK);
+		stack.set(DataComponents.WRITTEN_BOOK_CONTENT, content);
+		if (!player.getInventory().add(stack)) {
+			player.drop(stack, false);
+		}
+		player.sendSystemMessage(Component.literal("Received today's Screenwriter schedule book.").withStyle(ChatFormatting.GREEN), false);
+		return 1;
+	}
+
+	private static int generate(CommandSourceStack source, boolean force) {
+		ScreenwriterManager.generateToday(
+			source.getServer(),
+			force,
+			component -> source.sendSuccess(() -> component, false)
+		);
+		return 1;
+	}
+
+	private static int source(CommandSourceStack source, String provider) {
+		ScreenwriterManager.setProviderPreference(
+			source.getServer(),
+			provider,
+			component -> source.sendSuccess(() -> component, false)
+		);
+		return 1;
+	}
+
+	private static int open(CommandSourceStack source, String time) {
+		return ScreenwriterManager.setOpenTime(
+			source.getServer(),
+			time,
+			component -> source.sendSuccess(() -> component, false)
+		) ? 1 : 0;
+	}
+
+	private static int close(CommandSourceStack source, String time) {
+		return ScreenwriterManager.setCloseTime(
+			source.getServer(),
+			time,
+			component -> source.sendSuccess(() -> component, false)
+		) ? 1 : 0;
+	}
+
+	private static int turnaround(CommandSourceStack source, int minutes) {
+		ScreenwriterManager.setTurnaroundMinutes(
+			source.getServer(),
+			minutes,
+			component -> source.sendSuccess(() -> component, false)
+		);
+		return 1;
+	}
+
+	private static int stagger(CommandSourceStack source, int minutes) {
+		ScreenwriterManager.setStaggerMinutes(
+			source.getServer(),
+			minutes,
+			component -> source.sendSuccess(() -> component, false)
+		);
+		return 1;
+	}
+
+	private static int maxStreams(CommandSourceStack source, int shows) {
+		ScreenwriterManager.setMaxConcurrentShows(
+			source.getServer(),
+			shows,
+			component -> source.sendSuccess(() -> component, false)
+		);
+		return 1;
+	}
+}
diff --git a/src/main/java/com/pixelreel/commands/TvCommand.java b/src/main/java/com/pixelreel/commands/TvCommand.java
index c0f7b09..67b8245 100644
--- a/src/main/java/com/pixelreel/commands/TvCommand.java
+++ b/src/main/java/com/pixelreel/commands/TvCommand.java
@@ -424,7 +424,7 @@ private static int rebuild(CommandContext<CommandSourceStack> context) {
 			source.sendFailure(Component.translatable("command.pixelreel.no_screen_in_sight"));
 			return 0;
 		}
-		int placed = DisplayBlock.placePanels(display.getLevel(), display.getBlockPos(), block.type(), display.facing(), false);
+		int placed = DisplayBlock.placePanels(display.getLevel(), display.getBlockPos(), display.geometry(), display.facing(), false);
 		source.sendSuccess(() -> Component.translatable("command.pixelreel.rebuild.done", placed).withStyle(ChatFormatting.GREEN), false);
 		return 1;
 	}
diff --git a/src/main/java/com/pixelreel/items/CustomScreenBlockItem.java b/src/main/java/com/pixelreel/items/CustomScreenBlockItem.java
new file mode 100644
index 0000000..31180a1
--- /dev/null
+++ b/src/main/java/com/pixelreel/items/CustomScreenBlockItem.java
@@ -0,0 +1,32 @@
+package com.pixelreel.items;
+
+import com.pixelreel.ClientBridge;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.context.BlockPlaceContext;
+import net.minecraft.world.item.context.UseOnContext;
+import net.minecraft.world.level.block.Block;
+
+/**
+ * Configurable cinema-screen item. Both flat and curved custom screens use the
+ * same size/audio placement dialog; the server selects geometry from the held item.
+ */
+public class CustomScreenBlockItem extends DisplayBlockItem {
+	private final boolean curved;
+
+	public CustomScreenBlockItem(Block block, Item.Properties properties, String tooltipKey, boolean curved) {
+		super(block, properties, tooltipKey);
+		this.curved = curved;
+	}
+
+	@Override
+	public InteractionResult useOn(UseOnContext context) {
+		BlockPlaceContext placement = new BlockPlaceContext(context);
+		BlockPos controllerPos = placement.getClickedPos();
+		if (context.getLevel().isClientSide()) {
+			ClientBridge.openCustomScreenPlacement(controllerPos, context.getHand(), this.curved);
+		}
+		return InteractionResult.SUCCESS;
+	}
+}
diff --git a/src/main/java/com/pixelreel/items/RemoteControlItem.java b/src/main/java/com/pixelreel/items/RemoteControlItem.java
new file mode 100644
index 0000000..70cb138
--- /dev/null
+++ b/src/main/java/com/pixelreel/items/RemoteControlItem.java
@@ -0,0 +1,54 @@
+package com.pixelreel.items;
+
+import com.pixelreel.ClientBridge;
+import com.pixelreel.blockentities.DisplayBlockEntity;
+import com.pixelreel.blocks.DisplayBlock;
+import java.util.function.Consumer;
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.chat.Component;
+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;
+import net.minecraft.world.phys.BlockHitResult;
+import net.minecraft.world.phys.HitResult;
+
+/** Opens the normal PixelReel menu for the screen the player is aiming at. */
+public class RemoteControlItem extends Item {
+	private static final double RANGE = 48.0D;
+
+	public RemoteControlItem(Properties properties) {
+		super(properties);
+	}
+
+	@Override
+	public InteractionResult use(Level level, Player player, InteractionHand hand) {
+		HitResult hit = player.pick(RANGE, 1.0F, false);
+		if (hit instanceof BlockHitResult blockHit && hit.getType() == HitResult.Type.BLOCK) {
+			DisplayBlockEntity display = DisplayBlock.controllerAt(level, blockHit.getBlockPos());
+			if (display != null) {
+				if (level.isClientSide()) {
+					if (player.isShiftKeyDown() && display.isCustomScreen()) {
+						ClientBridge.openScreenwriterLink(display.getBlockPos());
+					} else if (!player.isShiftKeyDown()) {
+						ClientBridge.openChannelMenu(display.getBlockPos());
+					}
+				}
+				return InteractionResult.SUCCESS;
+			}
+		}
+		return InteractionResult.SUCCESS;
+	}
+
+	@Override
+	public void appendHoverText(
+		ItemStack stack, TooltipContext context, TooltipDisplay display, Consumer<Component> adder, TooltipFlag flag
+	) {
+		super.appendHoverText(stack, context, display, adder, flag);
+		adder.accept(Component.translatable("item.pixelreel.remote_control.tooltip").withStyle(ChatFormatting.GRAY));
+	}
+}
diff --git a/src/main/java/com/pixelreel/networking/ModNetworkPayloads.java b/src/main/java/com/pixelreel/networking/ModNetworkPayloads.java
index fd9b399..184624d 100644
--- a/src/main/java/com/pixelreel/networking/ModNetworkPayloads.java
+++ b/src/main/java/com/pixelreel/networking/ModNetworkPayloads.java
@@ -29,6 +29,8 @@ private ModNetworkPayloads() {
 	public static void register() {
 		PayloadTypeRegistry<RegistryFriendlyByteBuf> serverbound = PayloadTypeRegistry.serverboundPlay();
 		serverbound.register(ScreenControl.TYPE, ScreenControl.CODEC);
+		serverbound.register(PlaceCustomScreen.TYPE, PlaceCustomScreen.CODEC);
+		serverbound.register(ScreenwriterLink.TYPE, ScreenwriterLink.CODEC);
 		serverbound.register(ScreenTune.TYPE, ScreenTune.CODEC);
 		serverbound.register(RequestChannels.TYPE, RequestChannels.CODEC);
 		serverbound.register(RequestMediaFeatures.TYPE, RequestMediaFeatures.CODEC);
@@ -90,6 +92,60 @@ public Type<? extends CustomPacketPayload> type() {
 		}
 	}
 
+	public record PlaceCustomScreen(
+		BlockPos pos, int width, int height, int audioSettings, boolean offHand
+	) implements CustomPacketPayload {
+		public static final Type<PlaceCustomScreen> TYPE = new Type<>(PixelReel.id("place_custom_screen"));
+		public static final StreamCodec<RegistryFriendlyByteBuf, PlaceCustomScreen> CODEC = StreamCodec.composite(
+			BlockPos.STREAM_CODEC,
+			PlaceCustomScreen::pos,
+			ByteBufCodecs.VAR_INT,
+			PlaceCustomScreen::width,
+			ByteBufCodecs.VAR_INT,
+			PlaceCustomScreen::height,
+			ByteBufCodecs.VAR_INT,
+			PlaceCustomScreen::audioSettings,
+			ByteBufCodecs.BOOL,
+			PlaceCustomScreen::offHand,
+			PlaceCustomScreen::new
+		);
+
+		public static int packAudioSettings(int depth, int side) {
+			return (Math.max(0, depth) << 7) | (Math.max(0, side) & 0x7F);
+		}
+
+		public int audioDepth() {
+			return this.audioSettings >>> 7;
+		}
+
+		public int audioSide() {
+			return this.audioSettings & 0x7F;
+		}
+
+		@Override
+		public Type<? extends CustomPacketPayload> type() {
+			return TYPE;
+		}
+	}
+
+	public record ScreenwriterLink(BlockPos pos, int auditorium, boolean unlink) implements CustomPacketPayload {
+		public static final Type<ScreenwriterLink> TYPE = new Type<>(PixelReel.id("screenwriter_link"));
+		public static final StreamCodec<RegistryFriendlyByteBuf, ScreenwriterLink> CODEC = StreamCodec.composite(
+			BlockPos.STREAM_CODEC,
+			ScreenwriterLink::pos,
+			ByteBufCodecs.VAR_INT,
+			ScreenwriterLink::auditorium,
+			ByteBufCodecs.BOOL,
+			ScreenwriterLink::unlink,
+			ScreenwriterLink::new
+		);
+
+		@Override
+		public Type<? extends CustomPacketPayload> type() {
+			return TYPE;
+		}
+	}
+
 	public record ScreenControl(BlockPos pos, ScreenAction action, float value) implements CustomPacketPayload {
 		public static final Type<ScreenControl> TYPE = new Type<>(PixelReel.id("screen_control"));
 		public static final StreamCodec<RegistryFriendlyByteBuf, ScreenControl> CODEC = StreamCodec.composite(
diff --git a/src/main/java/com/pixelreel/networking/ServerNetworking.java b/src/main/java/com/pixelreel/networking/ServerNetworking.java
index c4b948c..49a405f 100644
--- a/src/main/java/com/pixelreel/networking/ServerNetworking.java
+++ b/src/main/java/com/pixelreel/networking/ServerNetworking.java
@@ -2,6 +2,10 @@
 
 import com.pixelreel.PixelReel;
 import com.pixelreel.blockentities.DisplayBlockEntity;
+import com.pixelreel.blocks.DisplayBlock;
+import com.pixelreel.blocks.DisplayGeometry;
+import com.pixelreel.blocks.DisplayType;
+import com.pixelreel.blocks.ScreenShapes;
 import com.pixelreel.channels.ChannelEntry;
 import com.pixelreel.channels.ChannelService;
 import com.pixelreel.channels.LiveStatus;
@@ -17,14 +21,24 @@
 import com.pixelreel.ondemand.OnDemandProvider;
 import com.pixelreel.permissions.CinemaPermissions;
 import com.pixelreel.plex.PlexService;
+import com.pixelreel.registry.ModBlocks;
+import com.pixelreel.registry.ModItems;
 import com.pixelreel.server.ScreenControllerLogic;
+import com.pixelreel.server.ScreenwriterManager;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
 import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.network.chat.Component;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.Vec3;
 
 public final class ServerNetworking {
 	private ServerNetworking() {
@@ -34,6 +48,12 @@ public static void register() {
 		ServerPlayNetworking.registerGlobalReceiver(
 			ModNetworkPayloads.ScreenControl.TYPE, (payload, context) -> handleControl(payload, context.player())
 		);
+		ServerPlayNetworking.registerGlobalReceiver(
+			ModNetworkPayloads.PlaceCustomScreen.TYPE, (payload, context) -> handlePlaceCustomScreen(payload, context.player())
+		);
+		ServerPlayNetworking.registerGlobalReceiver(
+			ModNetworkPayloads.ScreenwriterLink.TYPE, (payload, context) -> handleScreenwriterLink(payload, context.player())
+		);
 		ServerPlayNetworking.registerGlobalReceiver(
 			ModNetworkPayloads.ScreenTune.TYPE, (payload, context) -> handleTune(payload, context.player())
 		);
@@ -90,6 +110,109 @@ public static void register() {
 		);
 	}
 
+
+	private static void handleScreenwriterLink(ModNetworkPayloads.ScreenwriterLink payload, ServerPlayer player) {
+		DisplayBlockEntity display = ScreenControllerLogic.resolve(player, payload.pos());
+		if (display == null) {
+			player.sendSystemMessage(Component.literal("That screen is too far away or is no longer available."), false);
+			return;
+		}
+		ScreenwriterManager.configureLinkedScreen(player, display, payload.auditorium(), payload.unlink());
+	}
+
+	private static void handlePlaceCustomScreen(ModNetworkPayloads.PlaceCustomScreen payload, ServerPlayer player) {
+		int width = payload.width();
+		int height = payload.height();
+		int audioDepth = payload.audioDepth();
+		int audioSide = payload.audioSide();
+		if (width < DisplayGeometry.MIN_WIDTH || width > DisplayGeometry.MAX_WIDTH
+			|| height < DisplayGeometry.MIN_HEIGHT || height > DisplayGeometry.MAX_HEIGHT) {
+			player.sendSystemMessage(Component.translatable(
+				"message.pixelreel.custom_screen.invalid",
+				DisplayGeometry.MIN_WIDTH, DisplayGeometry.MAX_WIDTH,
+				DisplayGeometry.MIN_HEIGHT, DisplayGeometry.MAX_HEIGHT
+			), true);
+			return;
+		}
+		if (audioDepth < DisplayBlockEntity.MIN_CUSTOM_AUDIO_DEPTH || audioDepth > DisplayBlockEntity.MAX_CUSTOM_AUDIO_DEPTH
+			|| audioSide < DisplayBlockEntity.MIN_CUSTOM_AUDIO_SIDE || audioSide > DisplayBlockEntity.MAX_CUSTOM_AUDIO_SIDE) {
+			player.sendSystemMessage(Component.translatable("message.pixelreel.custom_screen.audio_invalid"), true);
+			return;
+		}
+
+
+		InteractionHand hand = payload.offHand() ? InteractionHand.OFF_HAND : InteractionHand.MAIN_HAND;
+		ItemStack held = player.getItemInHand(hand);
+		boolean curved = held.is(ModItems.CINEMA_SCREEN);
+		boolean flat = held.is(ModItems.CURVED_CINEMA_SCREEN);
+		if (!curved && !flat) {
+			return;
+		}
+
+		BlockPos controllerPos = payload.pos();
+		if (player.distanceToSqr(Vec3.atCenterOf(controllerPos)) > 64.0D) {
+			player.sendSystemMessage(Component.translatable("message.pixelreel.custom_screen.too_far"), true);
+			return;
+		}
+		if (!(player.level() instanceof net.minecraft.server.level.ServerLevel level)) {
+			return;
+		}
+		Direction facing = player.getDirection().getOpposite();
+		DisplayType displayType = curved ? DisplayType.CINEMA_SCREEN : DisplayType.CURVED_CINEMA_SCREEN;
+		DisplayGeometry geometry = curved
+			? DisplayGeometry.customCurved(width, height, displayType.audioRange())
+			: DisplayGeometry.customFlat(width, height, displayType.audioRange());
+
+		if (!canPlaceCustomScreen(level, controllerPos, geometry, facing)) {
+			player.sendSystemMessage(Component.translatable("message.pixelreel.custom_screen.blocked", width, height), true);
+			return;
+		}
+
+		DisplayBlock controllerBlock = curved ? ModBlocks.CINEMA_SCREEN : ModBlocks.CURVED_CINEMA_SCREEN;
+		BlockState controllerState = controllerBlock.defaultBlockState()
+			.setValue(DisplayBlock.FACING, facing)
+			.setValue(DisplayBlock.POWERED, Boolean.FALSE);
+		if (!level.setBlock(controllerPos, controllerState, Block.UPDATE_ALL)) {
+			player.sendSystemMessage(Component.translatable("message.pixelreel.custom_screen.blocked", width, height), true);
+			return;
+		}
+
+		if (!(level.getBlockEntity(controllerPos) instanceof DisplayBlockEntity display)) {
+			level.removeBlock(controllerPos, false);
+			player.sendSystemMessage(Component.translatable("message.pixelreel.custom_screen.failed"), true);
+			return;
+		}
+		display.setCustomSize(width, height);
+		display.setCustomAudioZone(audioDepth, audioSide);
+		DisplayBlock.placePanels(level, controllerPos, display.geometry(), facing, false);
+		if (!player.hasInfiniteMaterials()) {
+			held.shrink(1);
+		}
+		player.sendSystemMessage(Component.translatable("message.pixelreel.custom_screen.placed", width, height), true);
+	}
+
+	private static boolean canPlaceCustomScreen(
+		net.minecraft.server.level.ServerLevel level,
+		BlockPos controllerPos,
+		DisplayGeometry geometry,
+		Direction facing
+	) {
+		for (ScreenShapes.Cell cell : ScreenShapes.cells(geometry)) {
+			if (cell.depthCell() > 0) {
+				continue;
+			}
+			BlockPos pos = ScreenShapes.cellPos(controllerPos, geometry, facing, cell);
+			if (!level.isInWorldBounds(pos) || !level.isLoaded(pos)) {
+				return false;
+			}
+			BlockState state = level.getBlockState(pos);
+			if (!state.isAir() && !state.canBeReplaced()) {
+				return false;
+			}
+		}
+		return true;
+	}
+
 	private static void handleControl(ModNetworkPayloads.ScreenControl payload, ServerPlayer player) {
 		DisplayBlockEntity display = ScreenControllerLogic.resolve(player, payload.pos());
 		if (display == null) {
diff --git a/src/main/java/com/pixelreel/ondemand/OnDemandCatalog.java b/src/main/java/com/pixelreel/ondemand/OnDemandCatalog.java
index 2c8c1cd..cebf12f 100644
--- a/src/main/java/com/pixelreel/ondemand/OnDemandCatalog.java
+++ b/src/main/java/com/pixelreel/ondemand/OnDemandCatalog.java
@@ -65,6 +65,15 @@ public static void refreshConfigured(boolean force) {
 		}
 	}
 
+	/** Cached movie list from the provider's configured libraries. */
+	public static List<JellyfinItemSummary> movies(OnDemandProvider provider) {
+		return switch (provider) {
+			case JELLYFIN -> JellyfinService.INSTANCE.movies(null);
+			case EMBY -> EmbyService.INSTANCE.movies(null);
+			case PLEX -> PlexService.INSTANCE.movies(null);
+		};
+	}
+
 	public static Page page(OnDemandProvider provider, BrowseKind kind, String search, int page) {
 		return switch (provider) {
 			case JELLYFIN -> {
diff --git a/src/main/java/com/pixelreel/registry/ModBlocks.java b/src/main/java/com/pixelreel/registry/ModBlocks.java
index 40a2ddb..0db0dbe 100644
--- a/src/main/java/com/pixelreel/registry/ModBlocks.java
+++ b/src/main/java/com/pixelreel/registry/ModBlocks.java
@@ -4,6 +4,7 @@
 import com.pixelreel.blocks.DisplayBlock;
 import com.pixelreel.blocks.DisplayType;
 import com.pixelreel.blocks.ScreenPanelBlock;
+import com.pixelreel.blocks.ScreenwriterConsoleBlock;
 import java.util.List;
 import java.util.function.Function;
 import net.minecraft.core.registries.Registries;
@@ -22,6 +23,7 @@ public final class ModBlocks {
 	public static final DisplayBlock CINEMA_SCREEN = registerDisplay(DisplayType.CINEMA_SCREEN);
 	public static final DisplayBlock CURVED_CINEMA_SCREEN = registerDisplay(DisplayType.CURVED_CINEMA_SCREEN);
 	public static final ScreenPanelBlock SCREEN_PANEL = registerPanel();
+	public static final ScreenwriterConsoleBlock SCREENWRITER_CONSOLE = registerScreenwriterConsole();
 
 	public static final List<DisplayBlock> ALL_DISPLAYS = List.of(
 		COMPACT_TELEVISION, WALL_TELEVISION, ULTRAWIDE_MONITOR, CINEMA_SCREEN, CURVED_CINEMA_SCREEN
@@ -52,7 +54,7 @@ private static ScreenPanelBlock registerPanel() {
 		ResourceKey<Block> key = ResourceKey.create(Registries.BLOCK, PixelReel.id("screen_panel"));
 		BlockBehaviour.Properties properties = BlockBehaviour.Properties.of()
 			.mapColor(MapColor.NONE)
-			.strength(-1.0F, 3600000.0F)
+			.strength(1.5F, 6.0F)
 			.noOcclusion()
 			.forceSolidOff()
 			.pushReaction(PushReaction.IMMOVEABLE)
@@ -64,6 +66,16 @@ private static ScreenPanelBlock registerPanel() {
 		return (ScreenPanelBlock)Blocks.register(key, factory, properties);
 	}
 
+	private static ScreenwriterConsoleBlock registerScreenwriterConsole() {
+		ResourceKey<Block> key = ResourceKey.create(Registries.BLOCK, PixelReel.id("screenwriter_console"));
+		BlockBehaviour.Properties properties = BlockBehaviour.Properties.of()
+			.mapColor(MapColor.COLOR_BLACK)
+			.strength(2.5F, 8.0F)
+			.sound(SoundType.METAL);
+		Function<BlockBehaviour.Properties, Block> factory = ScreenwriterConsoleBlock::new;
+		return (ScreenwriterConsoleBlock)Blocks.register(key, factory, properties);
+	}
+
 	public static void init() {
 	}
 }
diff --git a/src/main/java/com/pixelreel/registry/ModCreativeTabs.java b/src/main/java/com/pixelreel/registry/ModCreativeTabs.java
index abe40d3..ad5402e 100644
--- a/src/main/java/com/pixelreel/registry/ModCreativeTabs.java
+++ b/src/main/java/com/pixelreel/registry/ModCreativeTabs.java
@@ -22,7 +22,7 @@ public static void init() {
 			PIXEL_REEL,
 			FabricCreativeModeTab.builder()
 				.title(Component.translatable("itemGroup.pixelreel.pixelreel"))
-				.icon(() -> new ItemStack(ModItems.WALL_TELEVISION))
+				.icon(() -> new ItemStack(ModItems.CURVED_CINEMA_SCREEN))
 				.displayItems((parameters, output) -> ModItems.TAB_CONTENTS.forEach(output::accept))
 				.build()
 		);
diff --git a/src/main/java/com/pixelreel/registry/ModItems.java b/src/main/java/com/pixelreel/registry/ModItems.java
index f4da5e6..32e5f0b 100644
--- a/src/main/java/com/pixelreel/registry/ModItems.java
+++ b/src/main/java/com/pixelreel/registry/ModItems.java
@@ -2,8 +2,10 @@
 
 import com.pixelreel.PixelReel;
 import com.pixelreel.blocks.DisplayBlock;
-import com.pixelreel.items.PixelGlassesItem;
+import com.pixelreel.items.CustomScreenBlockItem;
 import com.pixelreel.items.DisplayBlockItem;
+import com.pixelreel.items.PixelGlassesItem;
+import com.pixelreel.items.RemoteControlItem;
 import java.util.List;
 import java.util.function.Function;
 import net.minecraft.core.Registry;
@@ -18,8 +20,18 @@ public final class ModItems {
 	public static final Item COMPACT_TELEVISION = registerDisplayItem(ModBlocks.COMPACT_TELEVISION, "item.pixelreel.display.type.television");
 	public static final Item WALL_TELEVISION = registerDisplayItem(ModBlocks.WALL_TELEVISION, "item.pixelreel.display.type.television");
 	public static final Item ULTRAWIDE_MONITOR = registerDisplayItem(ModBlocks.ULTRAWIDE_MONITOR, "item.pixelreel.display.type.monitor");
-	public static final Item CINEMA_SCREEN = registerDisplayItem(ModBlocks.CINEMA_SCREEN, "item.pixelreel.display.type.cinema");
-	public static final Item CURVED_CINEMA_SCREEN = registerDisplayItem(ModBlocks.CURVED_CINEMA_SCREEN, "item.pixelreel.display.type.cinema");
+	public static final Item CINEMA_SCREEN = registerCustomScreenItem(ModBlocks.CINEMA_SCREEN, true);
+	public static final Item CURVED_CINEMA_SCREEN = registerCustomScreenItem(ModBlocks.CURVED_CINEMA_SCREEN, false);
+	public static final Item SCREENWRITER_CONSOLE = register(
+		"screenwriter_console",
+		properties -> new BlockItem(ModBlocks.SCREENWRITER_CONSOLE, properties),
+		new Item.Properties().useBlockDescriptionPrefix()
+	);
+	public static final Item REMOTE_CONTROL = register(
+		"remote_control",
+		RemoteControlItem::new,
+		new Item.Properties().stacksTo(1)
+	);
 	public static final Item PIXEL_GLASSES = register(
 		"pixel_glasses",
 		PixelGlassesItem::new,
@@ -29,12 +41,21 @@ public final class ModItems {
 	);
 
 	public static final List<Item> TAB_CONTENTS = List.of(
-		COMPACT_TELEVISION, WALL_TELEVISION, ULTRAWIDE_MONITOR, CINEMA_SCREEN, CURVED_CINEMA_SCREEN, PIXEL_GLASSES
+		CURVED_CINEMA_SCREEN, CINEMA_SCREEN, SCREENWRITER_CONSOLE, REMOTE_CONTROL, PIXEL_GLASSES
 	);
 
 	private ModItems() {
 	}
 
+	private static Item registerCustomScreenItem(DisplayBlock block, boolean curved) {
+		String name = BuiltInRegistries.BLOCK.getKey(block).getPath();
+		return register(
+			name,
+			properties -> new CustomScreenBlockItem(block, properties, "item.pixelreel.display.type.custom", curved),
+			new Item.Properties().stacksTo(1).useBlockDescriptionPrefix()
+		);
+	}
+
 	private static Item registerDisplayItem(DisplayBlock block, String tooltipKey) {
 		String name = BuiltInRegistries.BLOCK.getKey(block).getPath();
 		return register(name, properties -> new DisplayBlockItem(block, properties, tooltipKey), new Item.Properties().useBlockDescriptionPrefix());
diff --git a/src/main/java/com/pixelreel/server/ScreenwriterManager.java b/src/main/java/com/pixelreel/server/ScreenwriterManager.java
new file mode 100644
index 0000000..67480d6
--- /dev/null
+++ b/src/main/java/com/pixelreel/server/ScreenwriterManager.java
@@ -0,0 +1,1067 @@
+package com.pixelreel.server;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.pixelreel.PixelReel;
+import com.pixelreel.blockentities.DisplayBlockEntity;
+import com.pixelreel.blocks.DisplayBlock;
+import com.pixelreel.config.ConfigManager;
+import com.pixelreel.config.PixelReelConfig;
+import com.pixelreel.jellyfin.JellyfinItemKind;
+import com.pixelreel.jellyfin.JellyfinItemSummary;
+import com.pixelreel.networking.ScreenAction;
+import com.pixelreel.ondemand.OnDemandCatalog;
+import com.pixelreel.ondemand.OnDemandProvider;
+import com.pixelreel.registry.ModBlocks;
+import java.io.IOException;
+import java.io.Reader;
+import java.io.Writer;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.time.Duration;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Random;
+import java.util.Set;
+import java.util.UUID;
+import java.util.function.Consumer;
+import net.minecraft.ChatFormatting;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.Identifier;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.storage.LevelResource;
+import org.jspecify.annotations.Nullable;
+
+/**
+ * Real-time theatre automation for linked PixelReel screens.
+ *
+ * <p>Schedules are persisted in the world folder, so a server restart does not
+ * reroll the day. When the server comes back during a scheduled movie, playback
+ * resumes at the elapsed real-world position.</p>
+ */
+public final class ScreenwriterManager {
+	public static final String ACTOR = "Screenwriter";
+	public static final int MAX_SCREENS = 30;
+	public static final int HISTORY_DAYS = 3;
+	private static final Gson GSON = new GsonBuilder().setPrettyPrinting().create();
+	private static final DateTimeFormatter TIME_FORMAT = DateTimeFormatter.ofPattern("HH:mm");
+	private static final DateTimeFormatter DISPLAY_TIME = DateTimeFormatter.ofPattern("h:mm a");
+	private static final long LINK_ARM_MILLIS = 120_000L;
+	private static final long GENERATION_RETRY_MILLIS = 60_000L;
+	private static final long START_RETRY_MILLIS = 20_000L;
+
+	private static final Map<UUID, Long> LINK_ARMED = new HashMap<>();
+	private static final Map<String, Long> START_ATTEMPTS = new HashMap<>();
+	private static State state = new State();
+	private static @Nullable MinecraftServer activeServer;
+	private static boolean generationInProgress;
+	private static long lastGenerationAttemptMillis;
+	private static int tickCounter;
+
+	private ScreenwriterManager() {
+	}
+
+	public static void start(MinecraftServer server) {
+		activeServer = server;
+		state = load(server);
+		sanitizeState();
+		generationInProgress = false;
+		lastGenerationAttemptMillis = 0L;
+		tickCounter = 0;
+		LINK_ARMED.clear();
+		START_ATTEMPTS.clear();
+		PixelReel.LOGGER.info(
+			"Screenwriter loaded: {} linked screen(s), automation {}",
+			state.screens.size(),
+			state.enabled ? "enabled" : "disabled"
+		);
+	}
+
+	public static void stop(MinecraftServer server) {
+		if (activeServer == server) {
+			save(server);
+		}
+		activeServer = null;
+		LINK_ARMED.clear();
+		START_ATTEMPTS.clear();
+	}
+
+	public static void tick(MinecraftServer server) {
+		if (activeServer != server) {
+			return;
+		}
+		if (++tickCounter < 20) {
+			return;
+		}
+		tickCounter = 0;
+		LINK_ARMED.entrySet().removeIf(entry -> entry.getValue() < System.currentTimeMillis());
+		START_ATTEMPTS.entrySet().removeIf(entry -> System.currentTimeMillis() - entry.getValue() > 120_000L);
+		if (!state.enabled) {
+			return;
+		}
+
+		LocalDate today = LocalDate.now();
+		if (!today.toString().equals(state.scheduleDate) && !state.screens.isEmpty()) {
+			long now = System.currentTimeMillis();
+			if (!generationInProgress && now - lastGenerationAttemptMillis >= GENERATION_RETRY_MILLIS) {
+				generateToday(server, false, null);
+			}
+		}
+		runSchedule(server, System.currentTimeMillis());
+	}
+
+	public static boolean isEnabled() {
+		return state.enabled;
+	}
+
+	public static void setEnabled(MinecraftServer server, boolean enabled, @Nullable ServerPlayer actor) {
+		state.enabled = enabled;
+		if (!enabled) {
+			stopControlledScreens(server);
+		}
+		save(server);
+		if (actor != null) {
+			actor.sendSystemMessage(
+				Component.literal("Screenwriter automation " + (enabled ? "ON" : "OFF") + ".")
+					.withStyle(enabled ? ChatFormatting.GREEN : ChatFormatting.RED),
+				false
+			);
+		}
+		if (enabled && !LocalDate.now().toString().equals(state.scheduleDate) && !state.screens.isEmpty()) {
+			generateToday(server, false, actor == null ? null : component -> actor.sendSystemMessage(component, false));
+		}
+	}
+
+	public static void toggleEnabled(MinecraftServer server, ServerPlayer actor) {
+		setEnabled(server, !state.enabled, actor);
+	}
+
+	public static void selectConsole(ServerPlayer player, BlockPos consolePos) {
+		if (!(player.level().getBlockState(consolePos).getBlock() == ModBlocks.SCREENWRITER_CONSOLE)) {
+			return;
+		}
+		LINK_ARMED.put(player.getUUID(), System.currentTimeMillis() + LINK_ARM_MILLIS);
+		player.sendSystemMessage(
+			Component.literal("Screenwriter selected. Sneak + right-click a custom cinema screen with the Remote Control, then choose its auditorium number.")
+				.withStyle(ChatFormatting.AQUA),
+			false
+		);
+		player.sendSystemMessage(
+			Component.literal("Linked screens: " + state.screens.size() + "/" + MAX_SCREENS + "  |  Automation: " + (state.enabled ? "ON" : "OFF"))
+				.withStyle(ChatFormatting.GRAY),
+			false
+		);
+		sendConsoleOverview(player);
+	}
+
+	/** Applies a user-selected auditorium number to a linked custom screen. */
+	public static void configureLinkedScreen(ServerPlayer player, DisplayBlockEntity display, int auditorium, boolean unlink) {
+		Long until = LINK_ARMED.get(player.getUUID());
+		if (until == null || until < System.currentTimeMillis()) {
+			player.sendSystemMessage(
+				Component.literal("Select a Screenwriter Console first, then try again within 2 minutes.")
+					.withStyle(ChatFormatting.RED),
+				false
+			);
+			return;
+		}
+		if (!display.isCustomScreen()) {
+			player.sendSystemMessage(Component.literal("Only custom cinema screens can be linked to Screenwriter.").withStyle(ChatFormatting.RED), false);
+			return;
+		}
+		MinecraftServer server = player.level().getServer();
+		if (server == null) {
+			return;
+		}
+
+		String dimension = player.level().dimension().identifier().toString();
+		BlockPos pos = display.getBlockPos();
+		Optional<LinkedScreen> existing = state.screens.stream()
+			.filter(screen -> screen.matches(dimension, pos))
+			.findFirst();
+
+		if (unlink) {
+			if (existing.isEmpty()) {
+				player.sendSystemMessage(Component.literal("That screen is not linked to Screenwriter.").withStyle(ChatFormatting.YELLOW), false);
+				return;
+			}
+			LinkedScreen removed = existing.get();
+			state.screens.remove(removed);
+			save(server);
+			player.sendSystemMessage(
+				Component.literal("Unlinked " + removed.name + " from Screenwriter.").withStyle(ChatFormatting.YELLOW),
+				false
+			);
+			return;
+		}
+
+		if (auditorium < 1 || auditorium > MAX_SCREENS) {
+			player.sendSystemMessage(
+				Component.literal("Auditorium number must be between 1 and " + MAX_SCREENS + ".").withStyle(ChatFormatting.RED),
+				false
+			);
+			return;
+		}
+
+		Optional<LinkedScreen> numberConflict = state.screens.stream()
+			.filter(screen -> screen.auditorium == auditorium)
+			.filter(screen -> !screen.matches(dimension, pos))
+			.findFirst();
+		if (numberConflict.isPresent()) {
+			player.sendSystemMessage(
+				Component.literal("Auditorium " + auditorium + " is already linked to another screen.").withStyle(ChatFormatting.RED),
+				false
+			);
+			return;
+		}
+
+		if (existing.isPresent()) {
+			LinkedScreen linked = existing.get();
+			int oldAuditorium = linked.auditorium;
+			linked.auditorium = auditorium;
+			linked.name = "Auditorium " + auditorium;
+			if (oldAuditorium != auditorium) {
+				for (ScheduledShow show : state.shows) {
+					if (show.auditorium == oldAuditorium) {
+						show.auditorium = auditorium;
+					}
+				}
+			}
+			state.screens.sort(Comparator.comparingInt(screen -> screen.auditorium));
+			save(server);
+			player.sendSystemMessage(
+				Component.literal(oldAuditorium == auditorium
+					? linked.name + " is already linked to this screen."
+					: "Changed this screen from Auditorium " + oldAuditorium + " to " + linked.name + ".")
+					.withStyle(ChatFormatting.GREEN),
+				false
+			);
+			return;
+		}
+
+		if (state.screens.size() >= MAX_SCREENS) {
+			player.sendSystemMessage(Component.literal("Screenwriter already has " + MAX_SCREENS + " linked screens.").withStyle(ChatFormatting.RED), false);
+			return;
+		}
+
+		LinkedScreen linked = new LinkedScreen();
+		linked.auditorium = auditorium;
+		linked.name = "Auditorium " + auditorium;
+		linked.dimension = dimension;
+		linked.x = pos.getX();
+		linked.y = pos.getY();
+		linked.z = pos.getZ();
+		state.screens.add(linked);
+		state.screens.sort(Comparator.comparingInt(screen -> screen.auditorium));
+		save(server);
+		player.sendSystemMessage(
+			Component.literal("Linked screen as " + linked.name + " (" + state.screens.size() + "/" + MAX_SCREENS + ").")
+				.withStyle(ChatFormatting.GREEN),
+			false
+		);
+	}
+
+	private static void sendConsoleOverview(ServerPlayer player) {
+		long now = System.currentTimeMillis();
+		if (state.shows.isEmpty()) {
+			player.sendSystemMessage(Component.literal("Today's schedule has not been generated yet. Use /screenwriter generate if needed.").withStyle(ChatFormatting.YELLOW), false);
+			return;
+		}
+		player.sendSystemMessage(Component.literal("Today's Screenwriter overview:").withStyle(ChatFormatting.GOLD), false);
+		for (LinkedScreen screen : state.screens.stream().sorted(Comparator.comparingInt(s -> s.auditorium)).toList()) {
+			ScheduledShow current = currentShow(screen.auditorium, now);
+			ScheduledShow next = null;
+			for (ScheduledShow show : showsFor(screen.auditorium)) {
+				if (show.startEpochMs > now) {
+					next = show;
+					break;
+				}
+			}
+			String text;
+			if (current != null) {
+				text = screen.name + ": PLAYING " + current.title + " until " + formatTime(current.endEpochMs);
+			} else if (next != null) {
+				text = screen.name + ": next " + next.title + " at " + formatTime(next.startEpochMs);
+			} else {
+				text = screen.name + ": no more shows today";
+			}
+			player.sendSystemMessage(Component.literal(text).withStyle(ChatFormatting.GRAY), false);
+		}
+	}
+
+	public static void setProviderPreference(MinecraftServer server, String raw, Consumer<Component> feedback) {
+		String value = raw == null ? "AUTO" : raw.trim().toUpperCase();
+		if (!value.equals("AUTO") && !value.equals("JELLYFIN") && !value.equals("PLEX")) {
+			feedback.accept(Component.literal("Provider must be auto, jellyfin, or plex.").withStyle(ChatFormatting.RED));
+			return;
+		}
+		state.provider = value;
+		save(server);
+		feedback.accept(Component.literal("Screenwriter media provider set to " + value + ".").withStyle(ChatFormatting.GREEN));
+	}
+
+	public static boolean setOpenTime(MinecraftServer server, String raw, Consumer<Component> feedback) {
+		LocalTime time = parseTime(raw);
+		if (time == null) {
+			feedback.accept(Component.literal("Use 24-hour time without a colon, such as 1100 or 1830 (a colon is also accepted). ").withStyle(ChatFormatting.RED));
+			return false;
+		}
+		LocalTime close = parseTime(state.closeTime);
+		if (close != null && !time.isBefore(close)) {
+			feedback.accept(Component.literal("Opening time must be before closing time.").withStyle(ChatFormatting.RED));
+			return false;
+		}
+		state.openTime = TIME_FORMAT.format(time);
+		save(server);
+		feedback.accept(Component.literal("Screenwriter opening time set to " + DISPLAY_TIME.format(time) + ".").withStyle(ChatFormatting.GREEN));
+		return true;
+	}
+
+	public static boolean setCloseTime(MinecraftServer server, String raw, Consumer<Component> feedback) {
+		LocalTime time = parseTime(raw);
+		if (time == null) {
+			feedback.accept(Component.literal("Use 24-hour time without a colon, such as 2330 or 1800 (a colon is also accepted). ").withStyle(ChatFormatting.RED));
+			return false;
+		}
+		LocalTime open = parseTime(state.openTime);
+		if (open != null && !time.isAfter(open)) {
+			feedback.accept(Component.literal("Closing time must be after opening time.").withStyle(ChatFormatting.RED));
+			return false;
+		}
+		state.closeTime = TIME_FORMAT.format(time);
+		save(server);
+		feedback.accept(Component.literal("Screenwriter closing time set to " + DISPLAY_TIME.format(time) + ".").withStyle(ChatFormatting.GREEN));
+		return true;
+	}
+
+	public static void setTurnaroundMinutes(MinecraftServer server, int minutes, Consumer<Component> feedback) {
+		state.turnaroundMinutes = Math.clamp(minutes, 0, 120);
+		save(server);
+		feedback.accept(Component.literal("Screenwriter turnaround time set to " + state.turnaroundMinutes + " minutes.").withStyle(ChatFormatting.GREEN));
+	}
+
+	public static void setStaggerMinutes(MinecraftServer server, int minutes, Consumer<Component> feedback) {
+		state.staggerMinutes = Math.clamp(minutes, 0, 180);
+		save(server);
+		feedback.accept(Component.literal(
+			state.staggerMinutes == 0
+				? "Screenwriter first-show staggering disabled."
+				: "Screenwriter will spread first showtimes across " + state.staggerMinutes + " minutes."
+		).withStyle(ChatFormatting.GREEN));
+		if (!state.shows.isEmpty()) {
+			feedback.accept(Component.literal("Use /screenwriter regenerate to apply the new stagger to today's existing schedule.")
+				.withStyle(ChatFormatting.GRAY));
+		}
+	}
+
+	public static void setMaxConcurrentShows(MinecraftServer server, int maximum, Consumer<Component> feedback) {
+		state.maxConcurrentShows = Math.clamp(maximum, 0, MAX_SCREENS);
+		save(server);
+		feedback.accept(Component.literal(
+			state.maxConcurrentShows == 0
+				? "Screenwriter simultaneous-show limit disabled (unlimited)."
+				: "Screenwriter will schedule at most " + state.maxConcurrentShows + " simultaneous show(s)."
+		).withStyle(ChatFormatting.GREEN));
+		if (!state.shows.isEmpty()) {
+			feedback.accept(Component.literal("Use /screenwriter regenerate to apply the new limit to today's existing schedule.")
+				.withStyle(ChatFormatting.GRAY));
+		}
+	}
+
+	public static void generateToday(MinecraftServer server, boolean force, @Nullable Consumer<Component> feedback) {
+		if (generationInProgress) {
+			if (feedback != null) {
+				feedback.accept(Component.literal("Screenwriter is already generating a schedule.").withStyle(ChatFormatting.YELLOW));
+			}
+			return;
+		}
+		if (state.screens.isEmpty()) {
+			if (feedback != null) {
+				feedback.accept(Component.literal("Link at least one custom cinema screen first.").withStyle(ChatFormatting.RED));
+			}
+			return;
+		}
+		LocalDate today = LocalDate.now();
+		if (!force && today.toString().equals(state.scheduleDate) && !state.shows.isEmpty()) {
+			if (feedback != null) {
+				feedback.accept(Component.literal("Today's Screenwriter schedule already exists.").withStyle(ChatFormatting.YELLOW));
+			}
+			return;
+		}
+		OnDemandProvider provider = resolvedProvider();
+		if (provider == null) {
+			if (feedback != null) {
+				feedback.accept(Component.literal("No configured Jellyfin/Plex movie provider is available for Screenwriter.").withStyle(ChatFormatting.RED));
+			}
+			lastGenerationAttemptMillis = System.currentTimeMillis();
+			return;
+		}
+
+		generationInProgress = true;
+		lastGenerationAttemptMillis = System.currentTimeMillis();
+		if (feedback != null) {
+			feedback.accept(Component.literal("Screenwriter is reading the " + provider.displayName() + " movie libraries...").withStyle(ChatFormatting.AQUA));
+		}
+		OnDemandCatalog.refresh(provider, true).whenComplete((status, error) -> server.execute(() -> {
+			generationInProgress = false;
+			if (error != null) {
+				PixelReel.LOGGER.warn("Screenwriter library refresh failed", error);
+				if (feedback != null) {
+					feedback.accept(Component.literal("Screenwriter could not refresh the movie library: " + error.getMessage()).withStyle(ChatFormatting.RED));
+				}
+				return;
+			}
+			List<JellyfinItemSummary> movies = OnDemandCatalog.movies(provider).stream()
+				.filter(item -> item.kind() == JellyfinItemKind.MOVIE)
+				.filter(item -> item.runtimeMs() > 0L)
+				.toList();
+			if (movies.isEmpty()) {
+				if (feedback != null) {
+					feedback.accept(Component.literal("No movies with runtimes were found in the selected libraries.").withStyle(ChatFormatting.RED));
+				}
+				return;
+			}
+			int count = buildSchedule(today, provider, movies);
+			save(server);
+			if (feedback != null) {
+				feedback.accept(Component.literal("Generated today's Screenwriter schedule with " + count + " show(s).")
+					.withStyle(count > 0 ? ChatFormatting.GREEN : ChatFormatting.YELLOW));
+			}
+		}));
+	}
+
+	private static int buildSchedule(LocalDate date, OnDemandProvider provider, List<JellyfinItemSummary> sourceMovies) {
+		LocalTime open = parseTime(state.openTime);
+		LocalTime close = parseTime(state.closeTime);
+		if (open == null) {
+			open = LocalTime.of(11, 0);
+		}
+		if (close == null || !close.isAfter(open)) {
+			close = LocalTime.of(23, 30);
+		}
+		ZoneId zone = ZoneId.systemDefault();
+		long openMs = date.atTime(open).atZone(zone).toInstant().toEpochMilli();
+		long closeMs = date.atTime(close).atZone(zone).toInstant().toEpochMilli();
+		Set<String> blocked = blockedByHistory(date);
+		Set<String> usedToday = new HashSet<>();
+		List<JellyfinItemSummary> pool = new ArrayList<>(sourceMovies);
+		Collections.shuffle(pool, new Random(System.nanoTime() ^ date.toEpochDay()));
+		List<ScheduledShow> generated = new ArrayList<>();
+		List<LinkedScreen> orderedScreens = state.screens.stream()
+			.sorted(Comparator.comparingInt(s -> s.auditorium))
+			.toList();
+
+		// Build the day chronologically across all auditoriums instead of filling one
+		// auditorium's entire day first. This keeps a simultaneous-show cap fair: if
+		// the cap is 4 and 10 screens are linked, later auditorium numbers still get
+		// showtimes as capacity opens up rather than being starved by auditoriums 1-4.
+		Map<Integer, Long> nextStarts = new HashMap<>();
+		Set<Integer> exhausted = new HashSet<>();
+		for (int screenIndex = 0; screenIndex < orderedScreens.size(); screenIndex++) {
+			LinkedScreen screen = orderedScreens.get(screenIndex);
+			nextStarts.put(
+				screen.auditorium,
+				openMs + firstShowOffsetMillis(screenIndex, orderedScreens.size(), state.staggerMinutes)
+			);
+		}
+
+		while (!pool.isEmpty() && exhausted.size() < orderedScreens.size()) {
+			LinkedScreen screen = null;
+			long cursor = Long.MAX_VALUE;
+			for (LinkedScreen candidateScreen : orderedScreens) {
+				if (exhausted.contains(candidateScreen.auditorium)) {
+					continue;
+				}
+				long candidateCursor = nextStarts.getOrDefault(candidateScreen.auditorium, closeMs);
+				if (candidateCursor < cursor
+					|| (candidateCursor == cursor && screen != null && candidateScreen.auditorium < screen.auditorium)) {
+					screen = candidateScreen;
+					cursor = candidateCursor;
+				}
+			}
+			if (screen == null || cursor >= closeMs) {
+				break;
+			}
+
+			JellyfinItemSummary chosen = null;
+			long chosenStart = -1L;
+			for (JellyfinItemSummary item : pool) {
+				String key = mediaKey(provider, item.id());
+				if (blocked.contains(key) || usedToday.contains(key)) {
+					continue;
+				}
+				long candidateStart = findNextCapacityStart(
+					cursor,
+					item.runtimeMs(),
+					closeMs,
+					generated,
+					state.maxConcurrentShows
+				);
+				if (candidateStart < 0L) {
+					continue;
+				}
+				if (chosen == null || candidateStart < chosenStart) {
+					chosen = item;
+					chosenStart = candidateStart;
+					if (candidateStart == cursor) {
+						break;
+					}
+				}
+			}
+
+			if (chosen == null) {
+				exhausted.add(screen.auditorium);
+				continue;
+			}
+
+			ScheduledShow show = new ScheduledShow();
+			show.auditorium = screen.auditorium;
+			show.provider = provider.name();
+			show.itemId = chosen.id();
+			show.title = chosen.title();
+			show.runtimeMs = chosen.runtimeMs();
+			show.startEpochMs = chosenStart;
+			show.endEpochMs = chosenStart + chosen.runtimeMs();
+			generated.add(show);
+			String key = mediaKey(provider, chosen.id());
+			usedToday.add(key);
+			pool.remove(chosen);
+			nextStarts.put(
+				screen.auditorium,
+				roundUp(show.endEpochMs + state.turnaroundMinutes * 60_000L, state.roundMinutes)
+			);
+		}
+
+		state.scheduleDate = date.toString();
+		state.shows = generated;
+		state.history.put(date.toString(), new ArrayList<>(usedToday));
+		pruneHistory(date);
+		return generated.size();
+	}
+
+	/**
+	 * Finds the earliest time at or after {@code desiredStart} where adding one
+	 * more show would not exceed Screenwriter's simultaneous-show limit.
+	 * A limit of zero means unlimited.
+	 */
+	private static long findNextCapacityStart(
+		long desiredStart,
+		long runtimeMs,
+		long closeMs,
+		List<ScheduledShow> existing,
+		int maxConcurrentShows
+	) {
+		if (runtimeMs <= 0L || desiredStart + runtimeMs > closeMs) {
+			return -1L;
+		}
+		if (maxConcurrentShows <= 0) {
+			return desiredStart;
+		}
+
+		long start = desiredStart;
+		while (start + runtimeMs <= closeMs) {
+			long end = start + runtimeMs;
+			long conflictAt = firstCapacityConflict(start, end, existing, maxConcurrentShows);
+			if (conflictAt < 0L) {
+				return start;
+			}
+
+			long nextFree = Long.MAX_VALUE;
+			for (ScheduledShow show : existing) {
+				if (show.startEpochMs <= conflictAt && show.endEpochMs > conflictAt) {
+					nextFree = Math.min(nextFree, show.endEpochMs);
+				}
+			}
+			if (nextFree == Long.MAX_VALUE || nextFree <= start) {
+				return -1L;
+			}
+			start = roundUp(nextFree, state.roundMinutes);
+		}
+		return -1L;
+	}
+
+	/** Returns the first instant where the existing schedule is already at capacity. */
+	private static long firstCapacityConflict(
+		long start,
+		long end,
+		List<ScheduledShow> existing,
+		int maxConcurrentShows
+	) {
+		List<Long> checkpoints = new ArrayList<>();
+		checkpoints.add(start);
+		for (ScheduledShow show : existing) {
+			if (show.startEpochMs > start && show.startEpochMs < end) {
+				checkpoints.add(show.startEpochMs);
+			}
+		}
+		Collections.sort(checkpoints);
+		for (long point : checkpoints) {
+			int active = 0;
+			for (ScheduledShow show : existing) {
+				if (show.startEpochMs <= point && show.endEpochMs > point) {
+					active++;
+				}
+			}
+			if (active >= maxConcurrentShows) {
+				return point;
+			}
+		}
+		return -1L;
+	}
+
+	private static void runSchedule(MinecraftServer server, long now) {
+		if (!LocalDate.now().toString().equals(state.scheduleDate)) {
+			return;
+		}
+		for (LinkedScreen linked : state.screens) {
+			DisplayBlockEntity display = resolveDisplay(server, linked);
+			if (display == null) {
+				continue;
+			}
+			ScheduledShow current = currentShow(linked.auditorium, now);
+			if (current == null) {
+				if (ACTOR.equals(display.getControllingPlayer()) && display.isPowered()) {
+					ScreenControllerLogic.apply(display, ScreenAction.POWER_OFF, 0.0F, ACTOR);
+				}
+				continue;
+			}
+			OnDemandProvider provider = OnDemandProvider.byName(current.provider);
+			boolean correctMovie = display.isOnDemand()
+				&& display.onDemandProvider() == provider
+				&& current.itemId.equals(display.getJellyfinItemId());
+			if (correctMovie) {
+				if (!display.isPowered()) {
+					ScreenControllerLogic.apply(display, ScreenAction.POWER_ON, 0.0F, ACTOR);
+				}
+				if (display.isSuspended() || display.isPlaybackPaused()) {
+					ScreenControllerLogic.apply(display, ScreenAction.UNPAUSE, 0.0F, ACTOR);
+				}
+				continue;
+			}
+
+			String attemptKey = linked.auditorium + ":" + current.startEpochMs + ":" + current.itemId;
+			long previousAttempt = START_ATTEMPTS.getOrDefault(attemptKey, 0L);
+			if (now - previousAttempt < START_RETRY_MILLIS) {
+				continue;
+			}
+			START_ATTEMPTS.put(attemptKey, now);
+			long elapsed = Math.clamp(now - current.startEpochMs, 0L, Math.max(0L, current.runtimeMs - 1L));
+			ScreenControllerLogic.playOnDemandItem(display, provider, current.itemId, elapsed, ACTOR);
+		}
+	}
+
+	private static @Nullable ScheduledShow currentShow(int auditorium, long now) {
+		for (ScheduledShow show : state.shows) {
+			if (show.auditorium == auditorium && now >= show.startEpochMs && now < show.endEpochMs) {
+				return show;
+			}
+		}
+		return null;
+	}
+
+	private static @Nullable DisplayBlockEntity resolveDisplay(MinecraftServer server, LinkedScreen linked) {
+		Identifier id = Identifier.tryParse(linked.dimension);
+		if (id == null) {
+			return null;
+		}
+		ResourceKey<Level> key = ResourceKey.create(Registries.DIMENSION, id);
+		ServerLevel level = server.getLevel(key);
+		if (level == null) {
+			return null;
+		}
+		BlockPos pos = new BlockPos(linked.x, linked.y, linked.z);
+		if (!level.isLoaded(pos)) {
+			return null;
+		}
+		return DisplayBlock.displayAt(level, pos);
+	}
+
+	private static void stopControlledScreens(MinecraftServer server) {
+		for (LinkedScreen linked : state.screens) {
+			DisplayBlockEntity display = resolveDisplay(server, linked);
+			if (display != null && ACTOR.equals(display.getControllingPlayer()) && display.isPowered()) {
+				ScreenControllerLogic.apply(display, ScreenAction.POWER_OFF, 0.0F, ACTOR);
+			}
+		}
+	}
+
+	private static @Nullable OnDemandProvider resolvedProvider() {
+		PixelReelConfig config = ConfigManager.get();
+		String preference = state.provider == null ? "AUTO" : state.provider.toUpperCase();
+		if (preference.equals("JELLYFIN")) {
+			return config.isJellyfinConfigured() && config.jellyfinMoviesEnabled ? OnDemandProvider.JELLYFIN : null;
+		}
+		if (preference.equals("PLEX")) {
+			return config.isPlexConfigured() && config.plexMoviesEnabled ? OnDemandProvider.PLEX : null;
+		}
+		if (config.isJellyfinConfigured() && config.jellyfinMoviesEnabled) {
+			return OnDemandProvider.JELLYFIN;
+		}
+		if (config.isPlexConfigured() && config.plexMoviesEnabled) {
+			return OnDemandProvider.PLEX;
+		}
+		return null;
+	}
+
+	private static Set<String> blockedByHistory(LocalDate today) {
+		Set<String> blocked = new HashSet<>();
+		for (int i = 1; i <= HISTORY_DAYS; i++) {
+			List<String> entries = state.history.get(today.minusDays(i).toString());
+			if (entries != null) {
+				blocked.addAll(entries);
+			}
+		}
+		return blocked;
+	}
+
+	private static void pruneHistory(LocalDate today) {
+		state.history.entrySet().removeIf(entry -> {
+			try {
+				LocalDate date = LocalDate.parse(entry.getKey());
+				return date.isBefore(today.minusDays(HISTORY_DAYS + 2L));
+			} catch (DateTimeParseException ignored) {
+				return true;
+			}
+		});
+	}
+
+	private static long firstShowOffsetMillis(int screenIndex, int screenCount, int staggerMinutes) {
+		if (screenIndex <= 0 || screenCount <= 1 || staggerMinutes <= 0) {
+			return 0L;
+		}
+		double fraction = screenIndex / (double)(screenCount - 1);
+		long offsetMinutes = Math.round(fraction * staggerMinutes);
+		return offsetMinutes * 60_000L;
+	}
+
+	private static long roundUp(long epochMs, int minutes) {
+		int safeMinutes = Math.clamp(minutes, 1, 60);
+		long quantum = safeMinutes * 60_000L;
+		long remainder = Math.floorMod(epochMs, quantum);
+		return remainder == 0L ? epochMs : epochMs + quantum - remainder;
+	}
+
+	private static String mediaKey(OnDemandProvider provider, String itemId) {
+		return provider.name() + ":" + itemId;
+	}
+
+	public static Component statusComponent() {
+		OnDemandProvider provider = resolvedProvider();
+		String providerText = state.provider + (provider == null ? " (unavailable)" : " -> " + provider.displayName());
+		return Component.literal(
+			"Screenwriter " + (state.enabled ? "ON" : "OFF")
+				+ " | " + state.screens.size() + "/" + MAX_SCREENS + " screens"
+				+ " | provider " + providerText
+				+ " | " + state.openTime + "-" + state.closeTime
+				+ " | turnaround " + state.turnaroundMinutes + "m"
+				+ " | first-show stagger " + state.staggerMinutes + "m"
+				+ " | max simultaneous " + (state.maxConcurrentShows == 0 ? "unlimited" : state.maxConcurrentShows)
+				+ " | schedule " + (state.scheduleDate.isBlank() ? "none" : state.scheduleDate)
+		).withStyle(ChatFormatting.AQUA);
+	}
+
+	public static List<Component> scheduleChatLines() {
+		List<Component> lines = new ArrayList<>();
+		if (state.shows.isEmpty()) {
+			lines.add(Component.literal("No Screenwriter schedule has been generated yet.").withStyle(ChatFormatting.YELLOW));
+			return lines;
+		}
+		lines.add(Component.literal("SCREENWRITER — " + state.scheduleDate).withStyle(ChatFormatting.AQUA));
+		for (LinkedScreen screen : state.screens.stream().sorted(Comparator.comparingInt(s -> s.auditorium)).toList()) {
+			lines.add(Component.literal(screen.name).withStyle(ChatFormatting.GOLD));
+			List<ScheduledShow> shows = showsFor(screen.auditorium);
+			if (shows.isEmpty()) {
+				lines.add(Component.literal("  No shows scheduled").withStyle(ChatFormatting.GRAY));
+				continue;
+			}
+			for (ScheduledShow show : shows) {
+				lines.add(Component.literal("  " + formatShow(show)).withStyle(ChatFormatting.WHITE));
+			}
+		}
+		return lines;
+	}
+
+	/**
+	 * Builds Written Book pages using a conservative visual-line budget instead of
+	 * a raw character limit. Minecraft books only display a small number of lines
+	 * per page, so long auditorium schedules are continued onto as many pages as
+	 * needed instead of being visually cut off at the bottom.
+	 */
+	public static List<String> scheduleBookPages() {
+		final int maxLinesPerPage = 14;
+		final int wrapAtCharacters = 22;
+		List<String> pages = new ArrayList<>();
+		if (state.shows.isEmpty()) {
+			pages.add("SCREENWRITER\n" + LocalDate.now() + "\n\nNo schedule generated.");
+			return pages;
+		}
+
+		for (LinkedScreen screen : state.screens.stream().sorted(Comparator.comparingInt(s -> s.auditorium)).toList()) {
+			List<ScheduledShow> shows = showsFor(screen.auditorium);
+			int part = 1;
+			List<String> pageLines = bookHeaderLines(screen.name, part);
+
+			if (shows.isEmpty()) {
+				pageLines.add("No shows scheduled");
+				pages.add(String.join("\n", pageLines));
+				continue;
+			}
+
+			for (ScheduledShow show : shows) {
+				List<String> entryLines = new ArrayList<>();
+				entryLines.addAll(wrapBookText(formatTime(show.startEpochMs) + " - " + formatTime(show.endEpochMs), wrapAtCharacters));
+				entryLines.addAll(wrapBookText(show.title == null || show.title.isBlank() ? "Untitled" : show.title, wrapAtCharacters));
+
+				// Normally keep a show together. If a very long title cannot fit on one
+				// page, continue it line-by-line rather than truncating any information.
+				if (pageLines.size() > 4 && pageLines.size() + entryLines.size() > maxLinesPerPage) {
+					pages.add(String.join("\n", pageLines));
+					part++;
+					pageLines = bookHeaderLines(screen.name, part);
+				}
+
+				for (String line : entryLines) {
+					if (pageLines.size() >= maxLinesPerPage) {
+						pages.add(String.join("\n", pageLines));
+						part++;
+						pageLines = bookHeaderLines(screen.name, part);
+					}
+					pageLines.add(line);
+				}
+			}
+
+			pages.add(String.join("\n", pageLines));
+		}
+		return pages;
+	}
+
+	private static List<String> bookHeaderLines(String screenName, int part) {
+		List<String> lines = new ArrayList<>();
+		lines.add("SCREENWRITER");
+		lines.add(state.scheduleDate);
+		lines.add("");
+		lines.add(part == 1 ? screenName : screenName + " (cont. " + part + ")");
+		lines.add("");
+		return lines;
+	}
+
+	private static List<String> wrapBookText(String text, int maxCharacters) {
+		List<String> lines = new ArrayList<>();
+		String remaining = text == null ? "" : text.trim();
+		if (remaining.isEmpty()) {
+			lines.add("");
+			return lines;
+		}
+		while (remaining.length() > maxCharacters) {
+			int split = remaining.lastIndexOf(' ', maxCharacters);
+			if (split <= 0) {
+				split = maxCharacters;
+			}
+			lines.add(remaining.substring(0, split).stripTrailing());
+			remaining = remaining.substring(split).stripLeading();
+		}
+		if (!remaining.isEmpty()) {
+			lines.add(remaining);
+		}
+		return lines;
+	}
+
+	private static List<ScheduledShow> showsFor(int auditorium) {
+		return state.shows.stream()
+			.filter(show -> show.auditorium == auditorium)
+			.sorted(Comparator.comparingLong(show -> show.startEpochMs))
+			.toList();
+	}
+
+	private static String formatShow(ScheduledShow show) {
+		return formatTime(show.startEpochMs) + " - " + formatTime(show.endEpochMs) + "  " + show.title;
+	}
+
+	private static String formatTime(long epochMs) {
+		return DISPLAY_TIME.format(Instant.ofEpochMilli(epochMs).atZone(ZoneId.systemDefault()));
+	}
+
+	private static @Nullable LocalTime parseTime(String raw) {
+		if (raw == null || raw.isBlank()) {
+			return null;
+		}
+		String value = raw.trim();
+
+		// Command-friendly 24-hour forms that do not require a colon:
+		// 9 -> 09:00, 11 -> 11:00, 930 -> 09:30, 1100 -> 11:00,
+		// 2330 -> 23:30. The original HH:mm form remains supported too.
+		if (value.chars().allMatch(Character::isDigit)) {
+			try {
+				int hour;
+				int minute;
+				if (value.length() <= 2) {
+					hour = Integer.parseInt(value);
+					minute = 0;
+				} else if (value.length() == 3) {
+					hour = Integer.parseInt(value.substring(0, 1));
+					minute = Integer.parseInt(value.substring(1));
+				} else if (value.length() == 4) {
+					hour = Integer.parseInt(value.substring(0, 2));
+					minute = Integer.parseInt(value.substring(2));
+				} else {
+					return null;
+				}
+				if (hour < 0 || hour > 23 || minute < 0 || minute > 59) {
+					return null;
+				}
+				return LocalTime.of(hour, minute);
+			} catch (NumberFormatException ignored) {
+				return null;
+			}
+		}
+
+		try {
+			return LocalTime.parse(value, TIME_FORMAT);
+		} catch (DateTimeParseException ignored) {
+			return null;
+		}
+	}
+
+	private static void sanitizeState() {
+		if (state == null) {
+			state = new State();
+		}
+		if (state.provider == null || state.provider.isBlank()) {
+			state.provider = "AUTO";
+		}
+		if (state.openTime == null || parseTime(state.openTime) == null) {
+			state.openTime = "11:00";
+		}
+		if (state.closeTime == null || parseTime(state.closeTime) == null) {
+			state.closeTime = "23:30";
+		}
+		state.turnaroundMinutes = Math.clamp(state.turnaroundMinutes, 0, 120);
+		// Existing Screenwriter save files predate some newer scheduling settings.
+		// Preserve their existing enabled state while migrating missing numeric values.
+		if (state.dataVersion < 2) {
+			state.staggerMinutes = 30;
+		} else {
+			state.staggerMinutes = Math.clamp(state.staggerMinutes, 0, 180);
+		}
+		if (state.dataVersion < 3) {
+			state.maxConcurrentShows = 4;
+			state.dataVersion = 3;
+		} else {
+			state.maxConcurrentShows = Math.clamp(state.maxConcurrentShows, 0, MAX_SCREENS);
+		}
+		state.roundMinutes = Math.clamp(state.roundMinutes, 1, 60);
+		if (state.screens == null) {
+			state.screens = new ArrayList<>();
+		}
+		if (state.shows == null) {
+			state.shows = new ArrayList<>();
+		}
+		if (state.history == null) {
+			state.history = new LinkedHashMap<>();
+		}
+		if (state.scheduleDate == null) {
+			state.scheduleDate = "";
+		}
+		state.screens.removeIf(screen -> screen == null || screen.dimension == null || screen.dimension.isBlank());
+		state.screens.sort(Comparator.comparingInt(screen -> screen.auditorium));
+		if (state.screens.size() > MAX_SCREENS) {
+			state.screens = new ArrayList<>(state.screens.subList(0, MAX_SCREENS));
+		}
+	}
+
+	private static State load(MinecraftServer server) {
+		Path path = statePath(server);
+		if (!Files.exists(path)) {
+			return new State();
+		}
+		try (Reader reader = Files.newBufferedReader(path)) {
+			State loaded = GSON.fromJson(reader, State.class);
+			return loaded == null ? new State() : loaded;
+		} catch (Exception e) {
+			PixelReel.LOGGER.warn("Could not load Screenwriter state from {}", path, e);
+			return new State();
+		}
+	}
+
+	private static void save(MinecraftServer server) {
+		Path path = statePath(server);
+		Path temp = path.resolveSibling(path.getFileName() + ".tmp");
+		try {
+			Files.createDirectories(path.getParent());
+			try (Writer writer = Files.newBufferedWriter(temp)) {
+				GSON.toJson(state, writer);
+			}
+			try {
+				Files.move(temp, path, StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE);
+			} catch (IOException atomicFailure) {
+				Files.move(temp, path, StandardCopyOption.REPLACE_EXISTING);
+			}
+		} catch (Exception e) {
+			PixelReel.LOGGER.warn("Could not save Screenwriter state to {}", path, e);
+		}
+	}
+
+	private static Path statePath(MinecraftServer server) {
+		return server.getWorldPath(LevelResource.ROOT).resolve("pixelreel-screenwriter.json");
+	}
+
+	private static final class State {
+		int dataVersion = 3;
+		boolean enabled = false;
+		String provider = "AUTO";
+		String openTime = "11:00";
+		String closeTime = "23:30";
+		int turnaroundMinutes = 20;
+		int staggerMinutes = 30;
+		int maxConcurrentShows = 4;
+		int roundMinutes = 10;
+		String scheduleDate = "";
+		List<LinkedScreen> screens = new ArrayList<>();
+		List<ScheduledShow> shows = new ArrayList<>();
+		Map<String, List<String>> history = new LinkedHashMap<>();
+	}
+
+	private static final class LinkedScreen {
+		int auditorium;
+		String name = "";
+		String dimension = "minecraft:overworld";
+		int x;
+		int y;
+		int z;
+
+		boolean matches(String dimension, BlockPos pos) {
+			return this.dimension.equals(dimension) && this.x == pos.getX() && this.y == pos.getY() && this.z == pos.getZ();
+		}
+	}
+
+	private static final class ScheduledShow {
+		int auditorium;
+		String provider = "JELLYFIN";
+		String itemId = "";
+		String title = "";
+		long runtimeMs;
+		long startEpochMs;
+		long endEpochMs;
+	}
+}
diff --git a/src/main/resources/assets/pixelreel/blockstates/screenwriter_console.json b/src/main/resources/assets/pixelreel/blockstates/screenwriter_console.json
new file mode 100644
index 0000000..9ba2bf3
--- /dev/null
+++ b/src/main/resources/assets/pixelreel/blockstates/screenwriter_console.json
@@ -0,0 +1,5 @@
+{
+  "variants": {
+    "": { "model": "pixelreel:block/screenwriter_console" }
+  }
+}
diff --git a/src/main/resources/assets/pixelreel/items/cinema_screen.json b/src/main/resources/assets/pixelreel/items/cinema_screen.json
index 170697d..075d607 100644
--- a/src/main/resources/assets/pixelreel/items/cinema_screen.json
+++ b/src/main/resources/assets/pixelreel/items/cinema_screen.json
@@ -1 +1 @@
-{"model":{"type":"minecraft:model","model":"pixelreel:item/cinema_screen"}}
+{"model":{"type":"minecraft:model","model":"pixelreel:item/curved_cinema_screen"}}
diff --git a/src/main/resources/assets/pixelreel/items/curved_cinema_screen.json b/src/main/resources/assets/pixelreel/items/curved_cinema_screen.json
index 075d607..170697d 100644
--- a/src/main/resources/assets/pixelreel/items/curved_cinema_screen.json
+++ b/src/main/resources/assets/pixelreel/items/curved_cinema_screen.json
@@ -1 +1 @@
-{"model":{"type":"minecraft:model","model":"pixelreel:item/curved_cinema_screen"}}
+{"model":{"type":"minecraft:model","model":"pixelreel:item/cinema_screen"}}
diff --git a/src/main/resources/assets/pixelreel/items/remote_control.json b/src/main/resources/assets/pixelreel/items/remote_control.json
new file mode 100644
index 0000000..d84c120
--- /dev/null
+++ b/src/main/resources/assets/pixelreel/items/remote_control.json
@@ -0,0 +1 @@
+{"model":{"type":"minecraft:model","model":"pixelreel:item/remote_control"}}
diff --git a/src/main/resources/assets/pixelreel/items/screenwriter_console.json b/src/main/resources/assets/pixelreel/items/screenwriter_console.json
new file mode 100644
index 0000000..609caa3
--- /dev/null
+++ b/src/main/resources/assets/pixelreel/items/screenwriter_console.json
@@ -0,0 +1,6 @@
+{
+  "model": {
+    "type": "minecraft:model",
+    "model": "pixelreel:item/screenwriter_console"
+  }
+}
diff --git a/src/main/resources/assets/pixelreel/lang/en_us.json b/src/main/resources/assets/pixelreel/lang/en_us.json
index 963f3e7..5bce8af 100644
--- a/src/main/resources/assets/pixelreel/lang/en_us.json
+++ b/src/main/resources/assets/pixelreel/lang/en_us.json
@@ -1,13 +1,14 @@
 {
-	"block.pixelreel.compact_television": "Compact Television",
-	"block.pixelreel.wall_television": "Wall Television",
-	"block.pixelreel.ultrawide_monitor": "Ultrawide Monitor",
-	"block.pixelreel.cinema_screen": "Cinema Screen",
-	"block.pixelreel.curved_cinema_screen": "Curved Cinema Screen",
+	"block.pixelreel.compact_television": "Cinema Screen 23x13",
+	"block.pixelreel.wall_television": "Cinema Screen 27x13 (Cropped)",
+	"block.pixelreel.ultrawide_monitor": "Cinema Screen 27x13",
+	"block.pixelreel.cinema_screen": "Custom Curved Cinema Screen",
+	"block.pixelreel.curved_cinema_screen": "Custom Cinema Screen",
 	"block.pixelreel.screen_panel": "Screen Panel",
-
 	"itemGroup.pixelreel.pixelreel": "pixelReel",
-
+	"item.pixelreel.remote_control": "Remote Control",
+	"item.pixelreel.remote_control.tooltip": "Can be used to control screens or link to Screenwriter",
+	"message.pixelreel.remote.no_screen": "Aim directly at a PixelReel screen.",
 	"item.pixelreel.pixel_glasses": "Pixel Glasses",
 	"item.pixelreel.pixel_glasses.tooltip": "Right-click to wear. Shows a nearby playing screen in fullscreen.",
 	"item.pixelreel.pixel_glasses.remove_tooltip": "Press Esc or X to take them off. Right-click again while holding them to unequip.",
@@ -15,14 +16,13 @@
 	"gui.pixelreel.glasses.escape_hint": "Press %s or Esc to exit",
 	"key.pixelreel.remove_pixel_glasses": "Remove Pixel Glasses",
 	"key.category.pixelreel.pixelreel": "pixelReel",
-
-	"item.pixelreel.display.keywords": "pixelReel · Live TV · television · screen · monitor · jellyfin",
+	"item.pixelreel.display.keywords": "pixelReel \u00b7 Live TV \u00b7 television \u00b7 screen \u00b7 monitor \u00b7 jellyfin",
 	"item.pixelreel.display.type.television": "A television for watching live channels and on-demand media.",
 	"item.pixelreel.display.type.monitor": "An ultrawide monitor for watching live channels and on-demand media.",
 	"item.pixelreel.display.type.cinema": "A cinema screen for watching live channels and on-demand media together.",
-
+	"item.pixelreel.display.type.custom": "Choose the size and auditorium audio zone when you place this screen.",
 	"gui.pixelreel.menu.title": "Live TV - Tunarr",
-	"gui.pixelreel.menu.subtitle": "%s channels · %s",
+	"gui.pixelreel.menu.subtitle": "%s channels \u00b7 %s",
 	"gui.pixelreel.menu.loading": "Loading channels...",
 	"gui.pixelreel.menu.loading_art": "Loading art...",
 	"gui.pixelreel.menu.not_configured": "No channel source is configured (config/pixelreel.json)",
@@ -41,9 +41,26 @@
 	"gui.pixelreel.tooltip.progress": "%s%% elapsed",
 	"gui.pixelreel.tooltip.click": "Click to watch this channel",
 	"gui.pixelreel.tooltip.click_media": "Click to open",
-
+	"gui.pixelreel.custom_screen.title": "Custom Cinema Screen",
+	"gui.pixelreel.custom_curved_screen.title": "Custom Curved Cinema Screen",
+	"gui.pixelreel.custom_screen.subtitle": "Choose screen size and auditorium audio zone",
+	"gui.pixelreel.custom_screen.width": "Width (blocks)",
+	"gui.pixelreel.custom_screen.height": "Height (blocks)",
+	"gui.pixelreel.custom_screen.audio_depth": "Audio depth (blocks)",
+	"gui.pixelreel.custom_screen.audio_side": "Side range past screen edge (blocks)",
+	"gui.pixelreel.custom_screen.audio_hint": "Default: 40 deep, 2 blocks past each side",
+	"gui.pixelreel.custom_screen.audio_invalid": "Depth %s-%s, side range %s-%s",
+	"gui.pixelreel.custom_screen.place": "Place Screen",
+	"gui.pixelreel.custom_screen.cancel": "Cancel",
+	"gui.pixelreel.custom_screen.invalid": "Width %s-%s, height %s-%s",
+	"message.pixelreel.custom_screen.invalid": "That custom screen size is not allowed.",
+	"message.pixelreel.custom_screen.audio_invalid": "That custom screen audio zone is not allowed.",
+	"message.pixelreel.custom_screen.too_far": "Move closer to the placement location.",
+	"message.pixelreel.custom_screen.blocked": "A %sx%s screen will not fit there.",
+	"message.pixelreel.custom_screen.failed": "The custom screen could not be placed.",
+	"message.pixelreel.custom_screen.placed": "Placed a %sx%s custom screen.",
 	"gui.pixelreel.source.title": "Cinema Media",
-	"gui.pixelreel.source.live": "Live TV — Tunarr",
+	"gui.pixelreel.source.live": "Live TV \u2014 Tunarr",
 	"gui.pixelreel.source.movies": "Movies",
 	"gui.pixelreel.source.shows": "TV Shows",
 	"gui.pixelreel.source.configure": "Configure",
@@ -55,35 +72,32 @@
 	"gui.pixelreel.source.jellyfin_disabled": "Jellyfin movies/shows are disabled for you",
 	"gui.pixelreel.source.jellyfin_not_configured": "Jellyfin is not configured yet",
 	"gui.pixelreel.source.jellyfin_error": "Jellyfin: %s",
-	"gui.pixelreel.source.jellyfin_ready": "Jellyfin ready · %s movies · %s shows",
+	"gui.pixelreel.source.jellyfin_ready": "Jellyfin ready \u00b7 %s movies \u00b7 %s shows",
 	"gui.pixelreel.source.ondemand_not_configured": "%s is not configured yet",
 	"gui.pixelreel.source.ondemand_error": "%s: %s",
-	"gui.pixelreel.source.tunarr_not_configured": "Tunarr is not configured — use Tunarr Config",
+	"gui.pixelreel.source.tunarr_not_configured": "Tunarr is not configured \u2014 use Tunarr Config",
 	"gui.pixelreel.source.tunarr_error": "Tunarr: %s",
-	"gui.pixelreel.source.tunarr_ready": "Tunarr ready · %s channels",
-	"gui.pixelreel.source.both_ready": "Tunarr %s channels · Jellyfin %s movies / %s shows",
+	"gui.pixelreel.source.tunarr_ready": "Tunarr ready \u00b7 %s channels",
+	"gui.pixelreel.source.both_ready": "Tunarr %s channels \u00b7 Jellyfin %s movies / %s shows",
 	"gui.pixelreel.source.now_playing": "Now playing: %s",
-
 	"gui.pixelreel.provider.movies.title": "Choose Movies Source",
 	"gui.pixelreel.provider.shows.title": "Choose TV Shows Source",
 	"gui.pixelreel.provider.subtitle": "Select a media server",
-
 	"gui.pixelreel.tunarr.config.title": "Tunarr Configuration",
-	"gui.pixelreel.tunarr.config.subtitle": "Set your live TV playlist · admins only by default",
+	"gui.pixelreel.tunarr.config.subtitle": "Set your live TV playlist \u00b7 admins only by default",
 	"gui.pixelreel.tunarr.config.m3u": "Tunarr URL or M3U playlist",
 	"gui.pixelreel.tunarr.config.xmltv": "XMLTV guide URL (optional)",
 	"gui.pixelreel.tunarr.config.xmltv_hint": "Leave blank to auto-fill from Tunarr",
-	"gui.pixelreel.tunarr.config.help": "Tip: paste http://IP:8000 and Save — M3U + XMLTV are filled automatically",
+	"gui.pixelreel.tunarr.config.help": "Tip: paste http://IP:8000 and Save \u2014 M3U + XMLTV are filled automatically",
 	"gui.pixelreel.tunarr.config.save": "Save & Test",
 	"gui.pixelreel.tunarr.config.not_configured": "No Tunarr playlist configured yet",
-	"gui.pixelreel.tunarr.config.ready": "Connected · %s channels",
-
-	"gui.pixelreel.jellyfin.movies.title": "Movies — %s",
-	"gui.pixelreel.jellyfin.shows.title": "TV Shows — %s",
+	"gui.pixelreel.tunarr.config.ready": "Connected \u00b7 %s channels",
+	"gui.pixelreel.jellyfin.movies.title": "Movies \u2014 %s",
+	"gui.pixelreel.jellyfin.shows.title": "TV Shows \u2014 %s",
 	"gui.pixelreel.jellyfin.search": "Search",
 	"gui.pixelreel.jellyfin.back": "Back",
 	"gui.pixelreel.jellyfin.empty": "No titles found",
-	"gui.pixelreel.jellyfin.page": "%s titles · page %s/%s",
+	"gui.pixelreel.jellyfin.page": "%s titles \u00b7 page %s/%s",
 	"gui.pixelreel.jellyfin.play": "Play",
 	"gui.pixelreel.jellyfin.resume": "Resume",
 	"gui.pixelreel.jellyfin.year": "Year: %s",
@@ -91,14 +105,14 @@
 	"gui.pixelreel.jellyfin.resume_at": "Resume at %s",
 	"gui.pixelreel.jellyfin.no_overview": "No description available.",
 	"gui.pixelreel.jellyfin.seasons": "Seasons",
-	"gui.pixelreel.jellyfin.episodes_of": "Episodes · %s",
+	"gui.pixelreel.jellyfin.episodes_of": "Episodes \u00b7 %s",
 	"gui.pixelreel.jellyfin.watched": "Watched",
 	"gui.pixelreel.jellyfin.config.title": "Jellyfin Configuration",
-	"gui.pixelreel.jellyfin.config.subtitle": "Administrators only · API key is never shown to players",
+	"gui.pixelreel.jellyfin.config.subtitle": "Administrators only \u00b7 API key is never shown to players",
 	"gui.pixelreel.jellyfin.config.url": "Server URL",
 	"gui.pixelreel.jellyfin.config.api_key": "API key",
 	"gui.pixelreel.jellyfin.config.api_key_hint": "Leave blank to keep the existing key",
-	"gui.pixelreel.jellyfin.config.user_id": "User ID (optional — auto-filled from API key)",
+	"gui.pixelreel.jellyfin.config.user_id": "User ID (optional \u2014 auto-filled from API key)",
 	"gui.pixelreel.jellyfin.config.movies_on": "Movies: On",
 	"gui.pixelreel.jellyfin.config.movies_off": "Movies: Off",
 	"gui.pixelreel.jellyfin.config.shows_on": "TV Shows: On",
@@ -106,21 +120,19 @@
 	"gui.pixelreel.jellyfin.config.autoplay_on": "Autoplay next episode: On",
 	"gui.pixelreel.jellyfin.config.autoplay_off": "Autoplay next episode: Off",
 	"gui.pixelreel.jellyfin.config.save": "Save & Test",
-
 	"gui.pixelreel.emby.config.title": "Emby Configuration",
-	"gui.pixelreel.emby.config.subtitle": "Administrators only · API key is never shown to players",
+	"gui.pixelreel.emby.config.subtitle": "Administrators only \u00b7 API key is never shown to players",
 	"gui.pixelreel.emby.config.url": "Server URL",
 	"gui.pixelreel.emby.config.api_key": "API key",
 	"gui.pixelreel.emby.config.api_key_hint": "Leave blank to keep the existing key",
-	"gui.pixelreel.emby.config.user_id": "User ID (optional — auto-filled from API key)",
+	"gui.pixelreel.emby.config.user_id": "User ID (optional \u2014 auto-filled from API key)",
 	"gui.pixelreel.emby.config.movies_on": "Movies: On",
 	"gui.pixelreel.emby.config.movies_off": "Movies: Off",
 	"gui.pixelreel.emby.config.shows_on": "TV Shows: On",
 	"gui.pixelreel.emby.config.shows_off": "TV Shows: Off",
 	"gui.pixelreel.emby.config.save": "Save & Test",
-
 	"gui.pixelreel.plex.config.title": "Plex Configuration",
-	"gui.pixelreel.plex.config.subtitle": "Administrators only · token is never shown to players",
+	"gui.pixelreel.plex.config.subtitle": "Administrators only \u00b7 token is never shown to players",
 	"gui.pixelreel.plex.config.url": "Server URL",
 	"gui.pixelreel.plex.config.token": "X-Plex-Token",
 	"gui.pixelreel.plex.config.token_hint": "Leave blank to keep the existing token",
@@ -129,7 +141,6 @@
 	"gui.pixelreel.plex.config.shows_on": "TV Shows: On",
 	"gui.pixelreel.plex.config.shows_off": "TV Shows: Off",
 	"gui.pixelreel.plex.config.save": "Save & Test",
-
 	"gui.pixelreel.playback.title": "Playback Controls",
 	"gui.pixelreel.playback.open": "Playback Controls",
 	"gui.pixelreel.playback.pause": "Pause",
@@ -139,16 +150,14 @@
 	"gui.pixelreel.playback.play_now": "Play Now",
 	"gui.pixelreel.playback.cancel_next": "Cancel",
 	"gui.pixelreel.playback.next_in": "Next episode playing in %s seconds: %s",
-	"gui.pixelreel.playback.next_overlay": "Next: %s in %ss · open the screen for Play Now / Cancel",
+	"gui.pixelreel.playback.next_overlay": "Next: %s in %ss \u00b7 open the screen for Play Now / Cancel",
 	"gui.pixelreel.playback.subtitles": "Subtitles: %s",
 	"gui.pixelreel.playback.subtitles_none": "Subtitles: none available",
 	"gui.pixelreel.playback.subtitles_pick_empty": "Subtitles: none on this file",
 	"gui.pixelreel.playback.subtitles_title": "Subtitles",
 	"gui.pixelreel.playback.subtitles_current": "Current: %s",
-
-	"chat.pixelreel.status.player": "Player: %s · frame %s · host %s · buffer %s · last problem: %s",
+	"chat.pixelreel.status.player": "Player: %s \u00b7 frame %s \u00b7 host %s \u00b7 buffer %s \u00b7 last problem: %s",
 	"chat.pixelreel.status.player_idle": "Player: idle (no local decoder for this display)",
-
 	"command.pixelreel.players_only": "This command can only be used by a player",
 	"command.pixelreel.no_screen_in_sight": "Look at a television or cinema screen first",
 	"command.pixelreel.channels.header": "Live channels (%s):",
@@ -189,7 +198,6 @@
 	"command.pixelreel.jellyfin.refresh.done": "Jellyfin library refreshed (%s movies, %s shows)",
 	"command.pixelreel.jellyfin.refresh.failed": "Jellyfin refresh failed: %s",
 	"command.pixelreel.no_permission": "You do not have permission for that",
-
 	"message.pixelreel.no_screen": "That display no longer exists",
 	"message.pixelreel.no_channels": "No channels available yet - check /tv status",
 	"message.pixelreel.unknown_channel": "That channel is no longer in the playlist",
@@ -213,5 +221,17 @@
 	"message.pixelreel.ondemand.refresh_failed": "On-demand library refresh failed",
 	"message.pixelreel.tunarr.config_saved": "Tunarr configuration saved",
 	"message.pixelreel.tunarr.config_failed": "Tunarr configuration saved, but the playlist could not be loaded",
-	"message.pixelreel.tunarr.invalid_url": "Enter a valid Tunarr base URL or M3U playlist URL"
+	"message.pixelreel.tunarr.invalid_url": "Enter a valid Tunarr base URL or M3U playlist URL",
+	"block.pixelreel.screenwriter_console": "Screenwriter Console",
+	"item.pixelreel.screenwriter_console": "Screenwriter Console",
+	"gui.pixelreel.screenwriter_link.title": "Screenwriter Screen Link",
+	"gui.pixelreel.screenwriter_link.subtitle": "Choose a unique auditorium number (1-%s)",
+	"gui.pixelreel.screenwriter_link.auditorium": "Auditorium number",
+	"gui.pixelreel.screenwriter_link.link": "Link / Update",
+	"gui.pixelreel.screenwriter_link.unlink": "Unlink",
+	"gui.pixelreel.screenwriter_link.cancel": "Cancel",
+	"gui.pixelreel.screenwriter_link.invalid": "Enter an auditorium number from %s to %s",
+	"gui.pixelreel.playback.reset_connection": "Reset Connection",
+	"message.pixelreel.playback.connection_reset": "Screen connection reset \u2014 resyncing audio/video...",
+	"message.pixelreel.playback.no_connection": "No active screen connection to reset."
 }
diff --git a/src/main/resources/assets/pixelreel/models/block/screenwriter_console.json b/src/main/resources/assets/pixelreel/models/block/screenwriter_console.json
new file mode 100644
index 0000000..8e0a252
--- /dev/null
+++ b/src/main/resources/assets/pixelreel/models/block/screenwriter_console.json
@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/cube_all",
+  "textures": {
+    "all": "pixelreel:block/screenwriter_console"
+  }
+}
diff --git a/src/main/resources/assets/pixelreel/models/item/remote_control.json b/src/main/resources/assets/pixelreel/models/item/remote_control.json
new file mode 100644
index 0000000..a794ac6
--- /dev/null
+++ b/src/main/resources/assets/pixelreel/models/item/remote_control.json
@@ -0,0 +1 @@
+{"parent":"minecraft:item/generated","textures":{"layer0":"pixelreel:item/remote_control"}}
diff --git a/src/main/resources/assets/pixelreel/models/item/screenwriter_console.json b/src/main/resources/assets/pixelreel/models/item/screenwriter_console.json
new file mode 100644
index 0000000..faa6ba5
--- /dev/null
+++ b/src/main/resources/assets/pixelreel/models/item/screenwriter_console.json
@@ -0,0 +1,3 @@
+{
+  "parent": "pixelreel:block/screenwriter_console"
+}
diff --git a/src/main/resources/assets/pixelreel/textures/block/screenwriter_console.png b/src/main/resources/assets/pixelreel/textures/block/screenwriter_console.png
new file mode 100644
index 0000000000000000000000000000000000000000..ac8af6085b56dbd58864294ecd2053fd075ee658
GIT binary patch
literal 28764
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
X1m(@p!ph?000000NkvXXu0mjflczDr

literal 0
HcmV?d00001

diff --git a/src/main/resources/assets/pixelreel/textures/item/remote_control.png b/src/main/resources/assets/pixelreel/textures/item/remote_control.png
new file mode 100644
index 0000000000000000000000000000000000000000..2391ede0a29cbea9b34fbf44b6ebd1cdad07d60e
GIT binary patch
literal 127
zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`Zk{fVAr-fh6BdYFxM29xpGz&{
z0H?CDhz$!b!^0KxgcE#%Bo3H7Jmh?Uq3dwNqLwGyR9RUMi`<V)ZEng;X9)ewbdqfX
ZHv^xqC4-0F@f@Iu44$rjF6*2UngF6PCZqrW

literal 0
HcmV?d00001

diff --git a/src/main/resources/data/pixelreel/loot_table/blocks/screenwriter_console.json b/src/main/resources/data/pixelreel/loot_table/blocks/screenwriter_console.json
new file mode 100644
index 0000000..678d298
--- /dev/null
+++ b/src/main/resources/data/pixelreel/loot_table/blocks/screenwriter_console.json
@@ -0,0 +1,20 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+      "rolls": 1,
+      "bonus_rolls": 0,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "name": "pixelreel:screenwriter_console"
+        }
+      ],
+      "conditions": [
+        {
+          "condition": "minecraft:survives_explosion"
+        }
+      ]
+    }
+  ]
+}
diff --git a/src/main/resources/data/pixelreel/recipe/cinema_screen.json b/src/main/resources/data/pixelreel/recipe/cinema_screen.json
index 7978664..bba3dc6 100644
--- a/src/main/resources/data/pixelreel/recipe/cinema_screen.json
+++ b/src/main/resources/data/pixelreel/recipe/cinema_screen.json
@@ -3,12 +3,13 @@
 	"category": "misc",
 	"pattern": [
 		"WWW",
-		"WRW",
+		"QRQ",
 		"III"
 	],
 	"key": {
 		"I": "minecraft:iron_ingot",
 		"W": "minecraft:white_wool",
+		"Q": "minecraft:quartz",
 		"R": "minecraft:redstone"
 	},
 	"result": {
diff --git a/src/main/resources/data/pixelreel/recipe/curved_cinema_screen.json b/src/main/resources/data/pixelreel/recipe/curved_cinema_screen.json
index 8816694..fc7ab65 100644
--- a/src/main/resources/data/pixelreel/recipe/curved_cinema_screen.json
+++ b/src/main/resources/data/pixelreel/recipe/curved_cinema_screen.json
@@ -3,13 +3,12 @@
 	"category": "misc",
 	"pattern": [
 		"WWW",
-		"QRQ",
+		"WRW",
 		"III"
 	],
 	"key": {
 		"I": "minecraft:iron_ingot",
 		"W": "minecraft:white_wool",
-		"Q": "minecraft:quartz",
 		"R": "minecraft:redstone"
 	},
 	"result": {
diff --git a/src/main/resources/data/pixelreel/recipe/remote_control.json b/src/main/resources/data/pixelreel/recipe/remote_control.json
new file mode 100644
index 0000000..a9da52a
--- /dev/null
+++ b/src/main/resources/data/pixelreel/recipe/remote_control.json
@@ -0,0 +1,18 @@
+{
+	"type": "minecraft:crafting_shaped",
+	"category": "misc",
+	"pattern": [
+		"II",
+		"RB",
+		"II"
+	],
+	"key": {
+		"I": "minecraft:iron_ingot",
+		"R": "minecraft:redstone",
+		"B": "#minecraft:buttons"
+	},
+	"result": {
+		"id": "pixelreel:remote_control",
+		"count": 1
+	}
+}
diff --git a/src/main/resources/data/pixelreel/recipe/screenwriter_console.json b/src/main/resources/data/pixelreel/recipe/screenwriter_console.json
new file mode 100644
index 0000000..6700dc4
--- /dev/null
+++ b/src/main/resources/data/pixelreel/recipe/screenwriter_console.json
@@ -0,0 +1,18 @@
+{
+	"type": "minecraft:crafting_shaped",
+	"category": "misc",
+	"pattern": [
+		"III",
+		"IRI",
+		"DDD"
+	],
+	"key": {
+		"I": "minecraft:iron_ingot",
+		"R": "minecraft:redstone",
+		"D": "minecraft:polished_deepslate"
+	},
+	"result": {
+		"id": "pixelreel:screenwriter_console",
+		"count": 1
+	}
+}
diff --git a/src/main/resources/fabric.mod.json b/src/main/resources/fabric.mod.json
index 67c3e5e..6f8348a 100644
--- a/src/main/resources/fabric.mod.json
+++ b/src/main/resources/fabric.mod.json
@@ -2,10 +2,11 @@
 	"schemaVersion": 1,
 	"id": "pixelreel",
 	"version": "${version}",
-	"name": "pixelReel",
-	"description": "Place televisions and cinema screens in your world and watch live TV channels together.",
+	"name": "PixelReel Custom Fork",
+	"description": "A theater-focused PixelReel fork with configurable flat/curved cinema screens, isolated auditorium audio, remote controls, and Screenwriter automatic movie scheduling for Jellyfin and Plex.",
 	"authors": [
-		"pixelReel contributors"
+		"PixelReel contributors",
+		"PixelReel Custom Fork contributors"
 	],
 	"contact": {},
 	"license": "CC0-1.0",