presently 0.16.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c2eaa843e93a1ef3f3c97b0e89c80a3ee4484ddbee4c105ca39bc7c324671ea
-  data.tar.gz: bc27aa664ca531b38da8b807e3fcb438a41c4338a180c1ddd39fc1daa0c549ed
+  metadata.gz: 532d867fea4dad3add38479e76432b7eabfe6769d1f45930cf6c3be61174648e
+  data.tar.gz: e197012bf34d8708eeb012205e07289a392a2263b29045a4d052239d578c961f
 SHA512:
-  metadata.gz: 98959ac207c29fa8a4bf444e0d1e476e584183615d04abed09c8f74cda3a338ed61f9517f67d5e7e5bb40aa624c352100bf1c2f36c61663a81f61ec509fe52d8
-  data.tar.gz: 30ca2a30e72d1f0c0dbc71b31786349ecd8d8c70eae5d69f29e701e77cd2f39487909a71a4699b2be9b70169cc170065313da35e46394ab92d0b378f3849e38a
+  metadata.gz: 5d2bbb05d71ba4939e5a4491ce039bff503fd276f7a18d2d13cfb0e21d07259d4f3748d3c7fb630ae53544afafa0807c688f95e8b2c3954870620600f72692ba
+  data.tar.gz: 5d6052ff6a37f309cefc28fd6d9fe5fb15a46fbdf08bd1981959546e398a3a5536b7fdf6377af9459fc613d2d42cdb69ac8f610f64828985afb3884a7d144c48

data/bake/presently/export.rb

@@ -6,6 +6,7 @@
 def initialize(context)
 	super
 	
+	require "base64"
 	require "fileutils"
 	require "uri"
 end
@@ -23,12 +24,7 @@ end
 # @parameter timing [Boolean] Include slide duration and elapsed time. Default: `true`.
 # @parameter timeout [Integer] Seconds to wait for the page to signal readiness. Default: `60`.
 def pdf(output: "presentation.pdf", slides_root: "slides", notes: true, speaker: true, timing: true, slide_width_px: 1920, slide_height_px: 1080, notes_height_px: 300, timeout: 60)
-	require "async"
-	require "async/http/endpoint"
-	require "async/service"
-	require "async/webdriver"
 	require "presently"
-	require "presently/environment/application"
 	
 	page_size = Presently::Export::PageSize.new(
 		slide_width_px:  slide_width_px,
@@ -43,6 +39,121 @@ def pdf(output: "presentation.pdf", slides_root: "slides", notes: true, speaker:
 		slide_width_px: slide_width_px, slide_height_px: slide_height_px, notes_height_px: notes_height_px
 	)
 	
+	with_browser_session(slides_root: slides_root, timeout: timeout) do |session, base_url|
+		session.resize_window(
+			page_size.slide_width_px,
+			page_size.slide_height_px
+		)
+		
+		session.navigate_to("#{base_url}/export?#{query}")
+		
+		# Block until export.js dispatches presently:ready.
+		session.execute_async(<<~JS)
+			const done = arguments[arguments.length - 1];
+			if (window.__PRESENTLY_READY) { done(); return; }
+			document.addEventListener('presently:ready', () => done(), {once: true});
+		JS
+		
+		pdf_data = session.print(
+			background:    true,
+			margin:        {top: 0, bottom: 0, left: 0, right: 0},
+			page:          {width: page_size.slide_width_cm, height: page_height_cm},
+			shrink_to_fit: false
+		)
+		
+		FileUtils.mkdir_p(File.dirname(File.expand_path(output)))
+		File.write(output, pdf_data, mode: "wb")
+	end
+	
+	return {path: output}
+end
+
+# Export the narrated presentation to an MP4 video.
+#
+# This uses Chromium's experimental `Page.startScreenRecording` DevTools
+# command. Until that command reaches Chrome for Testing, pass matching
+# Chromium and ChromeDriver paths explicitly (or through the
+# `PRESENTLY_CHROME_PATH` and `PRESENTLY_CHROMEDRIVER_PATH` environment
+# variables).
+#
+# @parameter output [String] Output MP4 path. Default: `presentation.mp4`.
+# @parameter slides_root [String] The slides directory. Default: `slides`.
+# @parameter width [Integer] Maximum video width. Default: `1920`.
+# @parameter height [Integer] Maximum video height. Default: `1080`.
+# @parameter frame_rate [Integer] Maximum video frame rate. Default: `30`.
+# @parameter timeout [Integer] Seconds to wait for the playback page to load. Default: `60`.
+# @parameter duration_limit [Integer] Maximum presentation duration in seconds. Default: `3600`.
+# @parameter browser_version [String] Chrome for Testing version used when explicit paths are omitted. Default: `canary`.
+# @parameter browser_path [String | Nil] Path to a Chromium executable supporting screen recording.
+# @parameter driver_path [String | Nil] Path to a matching ChromeDriver executable.
+def video(output: "presentation.mp4", slides_root: "slides", width: 1920, height: 1080, frame_rate: 30, timeout: 60, duration_limit: 3600, browser_version: "canary", browser_path: nil, driver_path: nil)
+	browser_path ||= ENV["PRESENTLY_CHROME_PATH"]
+	driver_path ||= ENV["PRESENTLY_CHROMEDRIVER_PATH"]
+	
+	with_browser_session(
+		slides_root: slides_root,
+		timeout: timeout,
+		script_timeout: duration_limit,
+		browser_version: browser_version,
+		browser_path: browser_path,
+		driver_path: driver_path,
+		chrome_arguments: ["--autoplay-policy=no-user-gesture-required", "--hide-scrollbars"]
+	) do |session, base_url|
+		resize_viewport(session, width, height)
+		session.navigate_to("#{base_url}/playback?autoplay=false&controls=false")
+		
+		ready = session.execute_async(<<~JS)
+			const done = arguments[arguments.length - 1];
+			if (window.__PRESENTLY_PLAYBACK_ERROR) { done({error: window.__PRESENTLY_PLAYBACK_ERROR}); return; }
+			if (window.__PRESENTLY_PLAYBACK_READY) { done({ready: true}); return; }
+			document.addEventListener('presently:playback-error', event => done({error: event.detail.message}), {once: true});
+			document.addEventListener('presently:playback-ready', () => done({ready: true}), {once: true});
+		JS
+		
+		raise "Playback preparation failed: #{ready["error"]}" if ready["error"]
+		
+		recording_started = false
+		stream = nil
+		playback = nil
+		
+		begin
+			devtools(session, "Page.startScreenRecording", audio: true, maxWidth: width, maxHeight: height, frameRate: frame_rate)
+			recording_started = true
+			
+			session.execute("window.__PRESENTLY_PLAYBACK_START();")
+			playback = session.execute_async(<<~JS)
+				const done = arguments[arguments.length - 1];
+				if (window.__PRESENTLY_PLAYBACK_ERROR) { done({error: window.__PRESENTLY_PLAYBACK_ERROR}); return; }
+				if (window.__PRESENTLY_PLAYBACK_FINISHED) { done({finished: true}); return; }
+				document.addEventListener('presently:playback-error', event => done({error: event.detail.message}), {once: true});
+				document.addEventListener('presently:playback-finished', () => done({finished: true}), {once: true});
+			JS
+		ensure
+			if recording_started
+				stream = devtools(session, "Page.stopScreenRecording")["stream"]
+			end
+		end
+		
+		raise "Playback failed: #{playback["error"]}" if playback&.dig("error")
+		raise "Chromium did not return the recorded video stream!" unless stream
+		
+		write_devtools_stream(session, stream, output)
+	end
+	
+	return {path: output}
+end
+
+private
+
+def with_browser_session(slides_root:, timeout:, script_timeout: timeout, browser_version: "stable", browser_path: nil, driver_path: nil, chrome_arguments: [])
+	require "async"
+	require "async/http/endpoint"
+	require "async/service"
+	require "async/webdriver"
+	require "presently/environment/application"
+	
+	result = nil
+	
 	Async do |task|
 		# Bind port 0 first so we know the actual address before starting the server.
 		bound_endpoint = Async::HTTP::Endpoint.parse("http://localhost:0").bound
@@ -55,7 +166,7 @@ def pdf(output: "presentation.pdf", slides_root: "slides", notes: true, speaker:
 				endpoint: Async::HTTP::Endpoint.parse("http://localhost", bound_endpoint)
 			)
 			
-			# PDF export always requires an HTTP server, regardless of the configured
+			# Export always requires an HTTP server, regardless of the configured
 			# Lively transport:
 			transport = environment.with(environment.evaluator.http_environment)
 			evaluator = transport.evaluator
@@ -63,53 +174,22 @@ def pdf(output: "presentation.pdf", slides_root: "slides", notes: true, speaker:
 			server_task = task.async{server.run}
 			
 			begin
-				# Derive the actual base URL from the bound socket address.
-				base_url = nil
-				bound_endpoint.local_address_endpoint.each do |endpoint|
-					address = endpoint.address
-					host = address.ipv6? ? "[#{address.ip_address}]" : address.ip_address
-					base_url = "http://#{host}:#{address.ip_port}"
-					break
-				end
-				
-				export_url = "#{base_url}/export?#{query}"
-				
-				bridge = Async::WebDriver::Bridge::Chrome.for(:stable)
+				base_url = export_base_url(bound_endpoint)
+				bridge = chrome_bridge(browser_version, browser_path, driver_path)
 				driver = bridge.start
 				
 				begin
 					client = Async::WebDriver::Client.open(driver.endpoint)
 					
 					begin
-						session = client.session(bridge.default_capabilities)
+						capabilities = bridge.default_capabilities
+						capabilities[:alwaysMatch][:"goog:chromeOptions"][:args].concat(chrome_arguments)
+						session = client.session(capabilities)
 						
 						begin
-							session.resize_window(
-								page_size.slide_width_px,
-								page_size.slide_height_px
-							)
-							
 							session.page_load_timeout = timeout * 1000
-							session.script_timeout = timeout * 1000
-							
-							session.navigate_to(export_url)
-							
-							# Block until export.js dispatches presently:ready.
-							session.execute_async(<<~JS)
-								const done = arguments[arguments.length - 1];
-								if (window.__PRESENTLY_READY) { done(); return; }
-								document.addEventListener('presently:ready', () => done(), {once: true});
-							JS
-							
-							pdf_data = session.print(
-								background:    true,
-								margin:        {top: 0, bottom: 0, left: 0, right: 0},
-								page:          {width: page_size.slide_width_cm, height: page_height_cm},
-								shrink_to_fit: false
-							)
-							
-							FileUtils.mkdir_p(File.dirname(File.expand_path(output)))
-							File.write(output, pdf_data, mode: "wb")
+							session.script_timeout = script_timeout * 1000
+							result = yield(session, base_url)
 						ensure
 							session.close
 						end
@@ -128,5 +208,67 @@ def pdf(output: "presentation.pdf", slides_root: "slides", notes: true, speaker:
 		end
 	end
 	
-	return {path: output}
+	return result
+end
+
+def chrome_bridge(browser_version, browser_path, driver_path)
+	if browser_path || driver_path
+		options = {}
+		options[:browser_path] = File.expand_path(browser_path) if browser_path
+		options[:driver_path] = File.expand_path(driver_path) if driver_path
+		
+		Async::WebDriver::Bridge::Chrome.new(**options)
+	else
+		Async::WebDriver::Bridge::Chrome.for(browser_version.to_sym)
+	end
+end
+
+def export_base_url(bound_endpoint)
+	bound_endpoint.local_address_endpoint.each do |endpoint|
+		address = endpoint.address
+		host = address.ipv6? ? "[#{address.ip_address}]" : address.ip_address
+		return "http://#{host}:#{address.ip_port}"
+	end
+	
+	raise "Could not determine the export server address!"
+end
+
+def resize_viewport(session, width, height)
+	# WebDriver sizes the outer window, while screen recording captures the page
+	# viewport. Measure the browser decoration after an initial resize and
+	# compensate so the recorded video has the requested dimensions.
+	session.resize_window(width, height)
+	dimensions = session.execute(<<~JS)
+		return {outerWidth, outerHeight, innerWidth, innerHeight};
+	JS
+	
+	session.resize_window(
+		width + dimensions["outerWidth"] - dimensions["innerWidth"],
+		height + dimensions["outerHeight"] - dimensions["innerHeight"]
+	)
+end
+
+def devtools(session, command, **parameters)
+	session.post("goog/cdp/execute", {cmd: command, params: parameters})
+rescue Async::WebDriver::Error => error
+	raise "Chromium does not support #{command}: #{error.message}"
+end
+
+def write_devtools_stream(session, stream, output)
+	path = File.expand_path(output)
+	FileUtils.mkdir_p(File.dirname(path))
+	
+	begin
+		File.open(path, "wb") do |file|
+			loop do
+				chunk = devtools(session, "IO.read", handle: stream, size: 1024 * 1024)
+				data = chunk["data"]
+				data = Base64.strict_decode64(data) if chunk["base64Encoded"]
+				file.write(data)
+				break if chunk["eof"]
+			end
+		end
+	ensure
+		devtools(session, "IO.close", handle: stream)
+	end
 end

data/bake/presently/recordings.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+def initialize(context)
+	super
+	
+	require "pathname"
+	require "presently/recordings/normalizer"
+end
+
+# Normalize all completed slide recordings to a consistent loudness.
+#
+# Original recordings are preserved under `input_root`. Normalized WebM/Opus
+# files are written to the corresponding paths under `output_root`. Existing
+# outputs newer than their source are skipped unless `force` is enabled.
+#
+# @parameter input_root [String] Source recordings directory. Default: `audio`.
+# @parameter output_root [String] Normalized recordings directory. Default: `audio-normalized`.
+# @parameter integrated_loudness [Float] Target integrated loudness in LUFS. Default: `-16.0`.
+# @parameter true_peak [Float] Maximum true peak in dBTP. Default: `-1.5`.
+# @parameter loudness_range [Float] Target loudness range in LU. Default: `11.0`.
+# @parameter bitrate [String] Output Opus bitrate. Default: `128k`.
+# @parameter force [Boolean] Normalize recordings even when output is current. Default: `false`.
+# @parameter command [String] FFmpeg executable. Default: `ffmpeg`.
+def normalize(input_root: "audio", output_root: "audio-normalized", integrated_loudness: -16.0, true_peak: -1.5, loudness_range: 11.0, bitrate: "128k", force: false, command: "ffmpeg")
+	input_root = File.expand_path(input_root)
+	output_root = File.expand_path(output_root)
+	
+	if input_root == output_root
+		raise ArgumentError, "output_root must be different from input_root so originals are preserved!"
+	end
+	
+	files = Dir.glob(File.join(input_root, "**", "*.webm")).sort
+	if files.empty?
+		puts "No WebM recordings found under #{input_root}."
+		return {processed: 0, skipped: 0, output_root: output_root}
+	end
+	
+	normalizer = Presently::Recordings::Normalizer.new(command: command)
+	processed = 0
+	skipped = 0
+	
+	files.each do |input_path|
+		relative_path = Pathname.new(input_path).relative_path_from(Pathname.new(input_root)).to_s
+		output_path = File.join(output_root, relative_path)
+		
+		if !force && File.file?(output_path) && File.mtime(output_path) >= File.mtime(input_path)
+			puts "Skipping #{relative_path} (already normalized)."
+			skipped += 1
+			next
+		end
+		
+		print "Normalizing #{relative_path}... "
+		measurements = normalizer.normalize(
+			input_path,
+			output_path,
+			integrated_loudness: integrated_loudness,
+			true_peak: true_peak,
+			loudness_range: loudness_range,
+			bitrate: bitrate,
+		)
+		input = measurements.fetch(:input)
+		output = measurements.fetch(:output)
+		puts "#{input.fetch("input_i")} LUFS → #{output.fetch("input_i")} LUFS, #{output.fetch("input_tp")} dBTP"
+		processed += 1
+	end
+	
+	puts "Normalized #{processed} recording#{"s" unless processed == 1}; skipped #{skipped}."
+	return {processed: processed, skipped: skipped, output_root: output_root}
+end

data/context/animating-slides.md

@@ -25,7 +25,7 @@ slide.find("li").show(1)
 ```
 ~~~
 
-The script receives a `slide` object — an instance of the `Slide` class from `slide.js` — scoped to the current slide's body.
+The script receives a `slide` object — an instance of the `Slide` class exported by `@socketry/presently` — scoped to the current slide's body.
 
 If the script contains a syntax error or throws an exception, the error is logged to the browser console and the presentation continues unaffected.
 
@@ -194,6 +194,30 @@ All timeouts registered via `slide.after()` (and the underlying `slide.setTimeou
 
 The global `setTimeout` in slide scripts is also automatically tracked — you can use it directly and it will be cancelled on slide change.
 
+## Slide Lifetime and Cleanup
+
+Slide scripts can start resources other than timers, including audio, video, observers, animations, and event listeners. Use `slide.defer(callback)` to release those resources when the slide is deactivated:
+
+``` javascript
+const audio = new Audio("introduction.mp3")
+audio.play()
+
+slide.defer(() => {
+  audio.pause()
+})
+```
+
+Deferred callbacks run in reverse registration order when the slide changes. Registering a callback after the slide has already been deactivated runs it immediately, preventing asynchronously-created resources from escaping the slide's lifetime.
+
+The `slide.signal` getter exposes an `AbortSignal` which is aborted at the same time. Browser APIs which support abort signals can therefore be bound directly to the slide:
+
+``` javascript
+const button = slide.element.querySelector("button")
+button.addEventListener("click", handleClick, {signal: slide.signal})
+```
+
+Aborting the signal removes this event listener; it does not invoke `handleClick`. Use `slide.defer(...)` for resources which do not accept an `AbortSignal`.
+
 ## Looping Animations with `slide.loop()`
 
 To repeat an animation indefinitely, use `slide.loop()`. The callback receives a fresh `SlideContext` each iteration and can use `after()` to schedule steps in the same way as a regular chain. The loop waits for all steps to complete and then restarts, with an optional extra pause between iterations.

data/lib/presently/application.rb

@@ -4,12 +4,17 @@
 # Copyright, 2026, by Samuel Williams.
 
 require "lively"
-require "uri"
+require "protocol/url"
 
 require_relative "presentation"
 require_relative "presentation_controller"
+require_relative "home_view"
 require_relative "display_view"
 require_relative "presenter_view"
+require_relative "recording_view"
+require_relative "recordings"
+require_relative "slide_assets"
+require_relative "playback"
 require_relative "export"
 require_relative "page"
 require_relative "state"
@@ -17,25 +22,29 @@ require_relative "state"
 module Presently
 	# Represents the main Presently application middleware.
 	#
-	# Handles routing for the display view (`/`), presenter view (`/presenter`),
-	# and WebSocket connections (`/live`). Creates a shared {PresentationController}
-	# that keeps all connected clients in sync.
+	# Routes the presentation, recording, playback, export, and live interfaces.
+	# Creates a shared {PresentationController} that keeps connected clients in sync.
 	class Application < Lively::Application
 		# Initialize a new Presently application.
 		# @parameter delegate [Protocol::HTTP::Middleware] The next middleware in the chain.
 		# @parameter slides_root [String] The directory containing slide files.
 		# @parameter templates_roots [Array(String)] Additional directories to search for templates.
-		def initialize(delegate, slides_root: "slides", templates_roots: [])
+		# @parameter recordings_root [String | Nil] Directory where source narration is stored. Defaults to `audio` beside the slides directory.
+		# @parameter playback_recordings_root [String | Nil] Directory containing normalized narration. Defaults to `audio-normalized` beside the slides directory.
+		def initialize(delegate, slides_root: "slides", templates_roots: [], recordings_root: nil, playback_recordings_root: nil)
 			@slides_root = slides_root
 			@templates_roots = templates_roots
+			@recordings = Recordings.new(recordings_root || File.expand_path("../audio", slides_root))
+			@playback_recordings = Recordings.new(playback_recordings_root || File.expand_path("../audio-normalized", slides_root))
 			
-			super(delegate)
+			slide_assets = SlideAssets.new(delegate, root: @slides_root, stylesheets: ->{controller.presentation.stylesheets})
+			super(slide_assets)
 		end
 		
 		# The view classes that this application allows.
 		# @returns [Array(Class)] The allowed view classes.
 		def allowed_views
-			[DisplayView, PresenterView]
+			[HomeView, DisplayView, PresenterView, RecordingView]
 		end
 		
 		# The shared state passed to all views via the resolver.
@@ -61,37 +70,155 @@ module Presently
 			"Presently"
 		end
 		
-		# Create the body view for the given request path.
+		# Create a Presently page with the presentation-specific stylesheets.
+		# @parameter view [Live::View] The root view for the page.
+		# @returns [Page] The presentation page.
+		def make_page(view)
+			stylesheets = controller.presentation.stylesheets.map(&:url)
+			Page.new(title: title, body: view, stylesheets: stylesheets)
+		end
+		
+		# Add Presently's application routes.
+		# @parameter router [Lively::Router::Builder] The router to configure.
+		def configure_routes(router)
+			router.get("/") do
+				body = resolver.root(HomeView)
+				Page.new(title: title, body: body).call
+			end
+			
+			router.get("/display"){make_page(resolver.root(DisplayView)).call}
+			router.get("/presenter"){make_page(resolver.root(PresenterView)).call}
+			router.get("/record"){make_page(resolver.root(RecordingView)).call}
+			
+			router.route("/recordings", methods: ["GET", "HEAD", "PUT"]) do |request|
+				handle_recording(request, request_parameters(request))
+			end
+			
+			router.route("/playback/recordings", methods: ["GET", "HEAD"]) do |request|
+				handle_playback_recording(request, request_parameters(request))
+			end
+			
+			router.get("/playback") do |request|
+				render_playback(request_parameters(request))
+			end
+			
+			router.get("/export") do |request|
+				render_export(request_parameters(request))
+			end
+		end
+		
+		private
+		
+		# Parse query parameters from the incoming request target.
 		# @parameter request [Protocol::HTTP::Request] The incoming request.
-		# @returns [Live::View | Nil] The view for the path, or `nil` for unknown paths.
-		def body(request)
-			case request.path
-			when "/"
-				DisplayView.new(controller: controller)
-			when "/presenter"
-				PresenterView.new(controller: controller)
+		# @returns [Hash] The decoded query parameters.
+		def request_parameters(request)
+			Protocol::URL::Reference[request.path].parse_query!
+		end
+		
+		# Render the narrated playback interface.
+		def render_playback(parameters)
+			presentation = Presentation.load(@slides_root, controller.templates)
+			recording_urls = presentation.slides.each_index.map do |index|
+				slide = presentation.slides[index]
+				if @playback_recordings.exist?(slide) || @recordings.exist?(slide)
+					"/playback/recordings?index=#{index}"
+				end
 			end
+			
+			playback = Playback.new(
+				presentation: presentation,
+				recording_urls: recording_urls,
+				**Playback.options_from_parameters(parameters),
+			)
+			
+			Protocol::HTTP::Response[200, [["content-type", "text/html"]], [playback.call]]
 		end
 		
-		# Handle an HTTP request by rendering the appropriate page.
+		# Render the printable export interface.
+		def render_export(parameters)
+			presentation = Presentation.load(@slides_root, controller.templates)
+			export = Export.new(presentation: presentation, **Export.options_from_parameters(parameters))
+			
+			Protocol::HTTP::Response[200, [["content-type", "text/html"]], [export.call]]
+		end
+		
+		# Handle reading and writing a slide recording.
+		# @parameter request [Protocol::HTTP::Request] The incoming request.
+		# @parameter parameters [Hash] The decoded query parameters.
+		# @returns [Protocol::HTTP::Response]
+		def handle_recording(request, parameters)
+			index = recording_index(parameters)
+			return Protocol::HTTP::Response[400, [], ["A valid slide index is required."]] unless index
+			
+			slide = controller.slides[index]
+			return Protocol::HTTP::Response[404, [], ["Slide not found."]] unless slide
+			
+			case request.method
+			when "GET", "HEAD"
+				serve_recording(request, slide, @recordings)
+			when "PUT"
+				store_recording(request, slide)
+			end
+		end
+		
+		# Serve normalized narration for playback, falling back to the source take.
+		def handle_playback_recording(request, parameters)
+			index = recording_index(parameters)
+			return Protocol::HTTP::Response[400, [], ["A valid slide index is required."]] unless index
+			
+			slide = controller.slides[index]
+			return Protocol::HTTP::Response[404, [], ["Slide not found."]] unless slide
+			
+			recordings = @playback_recordings.exist?(slide) ? @playback_recordings : @recordings
+			serve_recording(request, slide, recordings)
+		end
+		
+		# Extract the slide index from decoded query parameters.
+		# @parameter parameters [Hash] The decoded query parameters.
+		# @returns [Integer | Nil]
+		def recording_index(parameters)
+			Integer(parameters.fetch("index"))
+		rescue ArgumentError, KeyError
+			nil
+		end
+		
+		# Serve an existing recording.
+		# @parameter request [Protocol::HTTP::Request] The incoming request.
+		# @parameter slide [Slide] The requested slide.
+		# @returns [Protocol::HTTP::Response]
+		def serve_recording(request, slide, recordings)
+			unless recordings.exist?(slide)
+				return Protocol::HTTP::Response[404, [], ["Recording not found."]]
+			end
+			
+			headers = [
+				["content-type", Recordings::CONTENT_TYPE],
+				["cache-control", "no-store"],
+			]
+			body = recordings.read(slide) unless request.method == "HEAD"
+			
+			Protocol::HTTP::Response[200, headers, body]
+		end
+		
+		# Store an uploaded recording.
 		# @parameter request [Protocol::HTTP::Request] The incoming request.
-		# @returns [Protocol::HTTP::Response] The HTTP response.
-		def handle(request)
-			path, query = request.path.split("?", 2)
-			
-			if path == "/export"
-				options = Export.options_from_query(query)
-				presentation = Presentation.load(@slides_root, controller.templates)
-				export = Export.new(presentation: presentation, **options)
-				return Protocol::HTTP::Response[200, [["content-type", "text/html"]], [export.call]]
+		# @parameter slide [Slide] The slide being recorded.
+		# @returns [Protocol::HTTP::Response]
+		def store_recording(request, slide)
+			content_type = request.headers["content-type"]&.split(";", 2)&.first
+			unless content_type == Recordings::CONTENT_TYPE
+				return Protocol::HTTP::Response[415, [], ["Expected #{Recordings::CONTENT_TYPE}."]]
 			end
 			
-			if body = self.body(request)
-				page = Page.new(title: title, body: body)
-				return Protocol::HTTP::Response[200, [], [page.call]]
-			else
-				return Protocol::HTTP::Response[404, [], ["Not Found"]]
+			unless request.body
+				return Protocol::HTTP::Response[400, [], ["A recording body is required."]]
 			end
+			
+			@recordings.write(slide, request.body)
+			Protocol::HTTP::Response[201, [["content-type", "application/json"]], ["{\"saved\":true}"]]
+		rescue Recordings::TooLarge => error
+			Protocol::HTTP::Response[413, [], [error.message]]
 		end
 	end
 end