presently 0.14.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46e3cc47613d0f667aeead379bdb8ed4c311ae9375c08ca32ceeeca4d57b5919
-  data.tar.gz: d4bf90e706c3a358a30937a3589f493a9c42f70a87babf9cc976407714124b98
+  metadata.gz: 42f99b653f49a0ac23d4c6b49314cde4ef814e70a7d274c7d67914e4f707514d
+  data.tar.gz: f308373c9741dad960682283d52df1d34e285e32e0c9155cd0911d3e62405562
 SHA512:
-  metadata.gz: 07702bbfa6107d4ee4554015450a7008d09d69e6e2c7486a5b5aa6d94b7b15ba188557810634e8fca79bbadcc450793b7d36f01c6878cf04f9d0fe7a74f77de9
-  data.tar.gz: 6b31a696453ce2a9d9adf6fe3b084a4aba9a20a23f4535b3582fab49af4999e62cebe41389cacc3ce7d9227bf0653365b2009892377cb09e20396bfa02a9d204
+  metadata.gz: 48116005297631e4fbdc4d06c1b83cfadb847d61dcb03ea60e603af4c28d9d0e678539fe114fbf6ce4f12e0fbc590281094e7fa40c2be003e9d488be31a25516
+  data.tar.gz: ed77bebb4005f828ab6b09c321cf075778a394706f0ff0bd6ffc2e2852e3c73ac2da3944e1ad7744cb82e3546702d0f81c4a966acc346f9c374b032f29100df9

data/bake/presently/export.rb

@@ -50,12 +50,15 @@ def pdf(output: "presentation.pdf", slides_root: "slides", notes: true, speaker:
 		begin
 			environment = Async::Service::Environment.build(
 				Presently::Environment::Application,
-				root: context.root,
-				slides_root: File.expand_path(slides_root, context.root),
+				root: Dir.pwd,
+				slides_root: slides_root,
 				endpoint: Async::HTTP::Endpoint.parse("http://localhost", bound_endpoint)
 			)
 			
-			evaluator = environment.evaluator
+			# PDF export always requires an HTTP server, regardless of the configured
+			# Lively transport:
+			transport = environment.with(environment.evaluator.http_environment)
+			evaluator = transport.evaluator
 			server = evaluator.make_server(evaluator.endpoint)
 			server_task = task.async{server.run}
 			

data/context/animating-slides.md

@@ -0,0 +1,254 @@
+# Animating Slides
+
+This guide explains how to animate content within slides using the slide scripting system.
+
+## Slide Scripts
+
+Any slide can include a JavaScript block at the end of its presenter notes section. The script runs in the browser immediately after the slide renders.
+
+~~~ markdown
+---
+template: default
+duration: 30
+---
+
+- First point
+- Second point
+- Third point
+
+---
+
+Your presenter notes here.
+
+```javascript
+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.
+
+If the script contains a syntax error or throws an exception, the error is logged to the browser console and the presentation continues unaffected.
+
+## The Slide API
+
+### `slide.find(selector)`
+
+Queries elements within the slide body matching the given CSS selector. Returns a `SlideElements` collection. This is a pure query with no side effects.
+
+``` javascript
+slide.find("li")           // all list items
+slide.find("h2, li")       // headings and list items in document order
+slide.find(".callout")     // elements with a specific class
+```
+
+### `elements.show(n, options)`
+
+Shows the first `n` elements in the collection and hides the rest. Returns a `Promise` that resolves when any reveal animation completes.
+
+``` javascript
+slide.find("li").show(0)  // all hidden
+slide.find("li").show(1)  // first visible, rest hidden
+slide.find("li").show(3)  // first three visible, rest hidden
+```
+
+Options:
+
+| Option | Description |
+|---|---|
+| `effect` | Entry animation for the newly revealed element. See effects below. |
+
+### `elements.builder(options)`
+
+Creates a `SlideBuilder` with default options and a cached position. Use this instead of calling `show()` manually when you want to reveal elements one at a time from a script.
+
+``` javascript
+const bullets = slide.find("li").builder({effect: "fly-up"})
+bullets.show(0)       // hide all initially
+bullets.next()        // reveal first, plays fly-up
+bullets.next()        // reveal second, plays fly-up
+bullets.finished      // true when all revealed
+```
+
+### `SlideBuilder#next(overrides)`
+
+Reveals the next element using the builder's default effect. Only touches the single newly revealed element — O(1). Returns a `Promise`. Accepts optional overrides for this step.
+
+### `SlideBuilder#show(n, overrides)`
+
+Sets the builder to an arbitrary position. Useful for initialization and jumping. Iterates all elements for correctness.
+
+### `SlideBuilder#play(interval, callback)`
+
+Reveals all remaining elements in sequence, with `interval` milliseconds between each step. An optional callback is invoked after each `next()` — return `false` to stop playback early. Requires the builder to be created via `slide.find(...).builder()` so that timeouts are tracked and cancelled when the slide changes.
+
+``` javascript
+// Play all elements at 400ms intervals:
+boxes.play(400)
+
+// Stop early based on a condition:
+boxes.play(400, () => !paused)
+
+// Inspect the builder after each step:
+boxes.play(400, (builder) => !builder.finished)
+```
+
+### `SlideBuilder#finished`
+
+Returns `true` when all elements have been revealed.
+
+## Build Sequences
+
+A build sequence is a series of consecutive slides with the same content, each revealing one more element. Because the slides are real files, each has its own duration and presenter notes — you can write exactly what to say when each element appears.
+
+~~~ markdown
+<!-- 030-overview.md -->
+---
+template: default
+duration: 20
+transition: fade
+---
+
+- Real-time synchronization
+- Markdown-based slides
+- Multiple templates
+
+---
+
+Let's walk through the key features.
+
+```javascript
+slide.find("li").show(0)
+```
+~~~
+
+~~~ markdown
+<!-- 031-overview.md -->
+---
+template: default
+duration: 20
+transition: fade
+---
+
+- Real-time synchronization
+- Markdown-based slides
+- Multiple templates
+
+---
+
+The display and presenter stay in sync over a WebSocket connection.
+
+```javascript
+slide.find("li").show(1)
+```
+~~~
+
+Because all elements are in the DOM from the start (just hidden), the vertical layout stays consistent throughout the sequence — there is no shift as elements appear.
+
+## Build Effects
+
+Pass an `effect` option to animate the newly revealed element as it appears. The effect plays as a CSS animation on the element and is removed automatically once it completes.
+
+``` javascript
+slide.find("li").show(2, {effect: "fly-up"})
+```
+
+Available effects:
+
+| Effect | Animation |
+|---|---|
+| `fade` | Fades in |
+| `fly-left` | Slides in from the left |
+| `fly-right` | Slides in from the right |
+| `fly-up` | Rises in from below |
+| `fly-down` | Drops in from above |
+| `scale` | Scales up from 80% |
+
+## Multiple Build Groups
+
+A slide can have multiple independent build groups. Each `find().show()` call is self-contained:
+
+``` javascript
+// Reveal list items as one group, callout div as another
+slide.find("li").show(3)
+slide.find(".callout").show(1, {effect: "fly-up"})
+```
+
+## In-Slide Animation with `slide.after()`
+
+For sequential reveals within a single slide (without navigating to the next slide), use `slide.after()`. Each step fires a delay in milliseconds relative to the previous step. Returns a `SlideContext` so subsequent `.after()` calls chain naturally.
+
+``` javascript
+const panes = slide.find(".pane").builder({effect: "fade"})
+const items = slide.find(".item").builder({effect: "fly-up"})
+panes.show(0)
+items.show(0)
+
+slide
+  .after(400, () => panes.next())
+  .after(400, () => items.next())
+  .after(300, () => items.next())
+  .after(400, () => panes.next())
+```
+
+All timeouts registered via `slide.after()` (and the underlying `slide.setTimeout()`) are automatically cancelled when the user navigates to another slide, so stale callbacks never fire.
+
+The global `setTimeout` in slide scripts is also automatically tracked — you can use it directly and it will be cancelled on slide change.
+
+## 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.
+
+``` javascript
+const steps = slide.find(".step").builder({effect: "fly-up"})
+steps.show(0)
+
+slide.loop((context) => {
+  steps.show(0)  // reset at the start of each iteration
+  context
+    .after(800, () => steps.next())
+    .after(800, () => steps.next())
+    .after(800, () => steps.next())
+}, { delay: 1500 })
+```
+
+The `delay` option adds extra time after the last step before the next iteration begins — useful for giving the audience a moment to read the fully-revealed state before it resets.
+
+The callback is responsible for resetting any state (such as calling `builder.show(0)`) at the start of each iteration. This keeps the loop body self-contained and makes the reset timing explicit.
+
+All timeouts are tracked through the parent slide, so the loop stops automatically when the user navigates away — no cleanup needed.
+
+## Absolutely Positioned Elements
+
+All slide templates support absolutely positioned elements since the slide container is `position: relative`. You can overlay any element on top of normal slide content:
+
+~~~ markdown
+<div style="position: absolute; bottom: 2rem; right: 2rem; background: var(--accent); color: white; padding: 0.5rem 1rem; border-radius: 6px;">
+  Callout text
+</div>
+~~~
+
+In the `diagram` template, all direct `<div>` children are `position: absolute` by default, so you can build free-form layouts without repeating the positioning declaration:
+
+~~~ markdown
+---
+template: diagram
+---
+
+<div style="left: 10%; top: 20%; width: 35%; height: 30%; background: var(--surface-light);">
+  Node A
+</div>
+
+<div style="left: 55%; top: 20%; width: 35%; height: 30%; background: var(--surface-light);">
+  Node B
+</div>
+~~~
+
+Combine with the scripting system to animate diagram elements into place:
+
+``` javascript
+const nodes = slide.find("div").builder({group: "node", effect: "fade"})
+nodes.show(0)
+slide
+  .after(400, () => nodes.next())
+  .after(400, () => nodes.next())
+```

data/context/getting-started.md

@@ -0,0 +1,321 @@
+# Getting Started
+
+This guide explains how to use `presently` to create and deliver web-based presentations using Markdown slides.
+
+## Installation
+
+Add the gem to your project:
+
+``` bash
+$ gem install presently
+```
+
+## Core Concepts
+
+Presently has several core concepts:
+
+- A {ruby Presently::Presentation} which loads and manages slide content from Markdown files.
+- A {ruby Presently::PresentationController} which manages the mutable state of a presentation: current slide, clock, and listeners.
+- A {ruby Presently::Slide} which represents a single slide parsed from a Markdown file with YAML frontmatter.
+- A {ruby Presently::DisplayView} which renders the audience-facing full-screen display.
+- A {ruby Presently::PresenterView} which renders the presenter console with notes, timing, and slide previews.
+
+## Creating Your First Presentation
+
+Create a new directory for your presentation:
+
+``` bash
+$ mkdir my-talk
+$ cd my-talk
+$ mkdir slides
+```
+
+### Writing Slides
+
+Each slide is a Markdown file in the `slides/` directory. Files are ordered alphabetically, so prefix them with numbers:
+
+``` markdown
+---
+template: title
+duration: 30
+---
+
+# Title
+
+Welcome to My Talk
+
+# Subtitle
+
+A presentation built with Presently
+
+---
+
+These are presenter notes — only visible in the presenter view.
+```
+
+Each slide has three parts:
+
+1. **YAML frontmatter** between `---` markers at the top, specifying the template, duration, and other metadata.
+2. **Content** with Markdown headings that become named sections for the template.
+3. **Presenter notes** after a `---` separator in the body (optional).
+
+### Running the Presentation
+
+Start the server from your presentation directory:
+
+``` bash
+$ presently
+```
+
+Then open two browser windows:
+
+- `http://localhost:9292/` — the audience display.
+- `http://localhost:9292/presenter` — the presenter console.
+
+Advancing slides in either window updates both in real-time via WebSockets.
+
+### Keyboard Controls
+
+- **Arrow Right / Space / Page Down** — next slide.
+- **Arrow Left / Page Up** — previous slide.
+- **F** — toggle full-screen (display view).
+
+## Templates
+
+Templates define the visual layout of each slide. Select a template using the `template` field in the frontmatter.
+
+### Default
+
+A general-purpose content slide. All content without a heading goes into the `body` section.
+
+``` markdown
+---
+template: default
+duration: 60
+---
+
+- First point
+- Second point
+- Third point
+```
+
+### Title
+
+A large title with a subtitle, centered on the slide.
+
+``` markdown
+---
+template: title
+duration: 30
+---
+
+# Title
+
+My Presentation Title
+
+# Subtitle
+
+A subtitle or tagline
+```
+
+### Section
+
+A section divider slide with a large heading and accent background.
+
+``` markdown
+---
+template: section
+duration: 15
+---
+
+# Heading
+
+Part Two
+```
+
+### Two Column
+
+A side-by-side layout with `left` and `right` sections.
+
+``` markdown
+---
+template: two_column
+duration: 90
+---
+
+# Left
+
+**Server Side**
+
+- Ruby + Lively
+- WebSocket connections
+
+# Right
+
+**Client Side**
+
+- Live DOM updates
+- CSS animations
+```
+
+### Code
+
+A syntax-highlighted code slide with optional focus regions for code walkthroughs. Use the `focus` frontmatter to specify which lines to highlight (1-based). Lines outside the focus range are dimmed, and the code scrolls to center the focused region.
+
+``` markdown
+---
+template: code
+duration: 60
+focus: 2-8
+title: Constructor
+---
+
+```ruby
+class Presentation
+  def initialize
+    @slides = []
+    @current_index = 0
+  end
+
+  def advance!
+    @current_index += 1
+  end
+end
+​```
+```
+
+Create animated walkthroughs by using multiple slides with the same code but different `focus` ranges. The transition between them smoothly scrolls and shifts the dim overlays.
+
+### Statement
+
+A prominent statement or quote, centered on the slide. Supports an optional `# Translation` section.
+
+``` markdown
+---
+template: statement
+duration: 30
+---
+
+The best way to predict the future is to create it.
+
+# Translation
+
+未来を予測する最善の方法は、それを創ることである。
+```
+
+### Translations
+
+All templates support an optional `# Translation` section. When present, the translation is displayed below the main content in a lighter style. This works with `title`, `section`, `statement`, and `image` templates.
+
+### Image
+
+A centered image with an optional caption.
+
+``` markdown
+---
+template: image
+duration: 30
+---
+
+![Architecture diagram](/images/architecture.png)
+
+# Caption
+
+System architecture overview
+```
+
+### Diagram
+
+A free-form layout slide with a `position: relative` container. Direct `<div>` children are `position: absolute` by default, so you can place elements precisely using inline styles. Use this for custom diagrams, annotated layouts, or any slide that doesn't fit a standard template.
+
+``` markdown
+---
+template: diagram
+duration: 60
+---
+
+<div style="left: 10%; top: 20%; width: 35%; height: 25%;">
+  Browser
+</div>
+
+<div style="left: 55%; top: 20%; width: 35%; height: 25%;">
+  Server
+</div>
+```
+
+All other templates also support absolutely positioned overlays since the slide container is `position: relative`. This lets you add callouts, badges, or annotations on top of any template's normal content.
+
+## Transitions
+
+Slides transition instantly by default. Add a `transition` key to the frontmatter to animate between slides:
+
+``` markdown
+---
+template: default
+transition: fade
+---
+```
+
+Available transitions:
+
+| Transition | Effect |
+|---|---|
+| `fade` | Crossfade between slides |
+| `slide-left` | Current slide exits left, next enters from right |
+| `slide-right` | Current slide exits right, next enters from left |
+
+## Presenter Notes
+
+Presenter notes appear after a `---` separator in the slide body. They support standard Markdown including **bold** and *italic*. Italic text is styled as a stage direction — use it for cues that shouldn't be spoken aloud:
+
+``` markdown
+---
+
+*Take a breath and wait for the room to settle.*
+
+Hi everyone, thanks for being here.
+
+*Make eye contact with the front row.*
+```
+
+## Presenter Console
+
+The presenter view at `/presenter` provides:
+
+- **Current and next slide previews** — see what's coming without switching windows.
+- **Presenter notes** — notes from the slide's `---` separator section.
+- **Timer controls** — Start, Pause, Resume, and Reset buttons.
+- **Pacing indicator** — shows whether you're on time, ahead, or behind based on per-slide `duration` metadata.
+- **Progress bar** — visual indicator of time consumed for the current slide.
+- **Reload button** — reload slides from disk without restarting the server.
+
+## Custom Templates
+
+You can provide your own `.xrb` template files by configuring the templates root:
+
+``` ruby
+# In your environment configuration:
+service "presently" do
+  include Presently::Environment::Application
+
+  def templates_root
+    File.expand_path("templates", self.root)
+  end
+end
+```
+
+Templates receive a {ruby Presently::TemplateScope} with access to `self.slide` (the {ruby Presently::Slide} instance) and `self.section(name)` for retrieving named content sections.
+
+## Customizing the Application
+
+For advanced customization, create an `application.rb` and run with `presently application.rb`:
+
+``` ruby
+#!/usr/bin/env presently
+
+class Application < Presently::Application
+  def title
+    "My Conference Talk"
+  end
+end
+```

data/context/index.yaml

@@ -0,0 +1,16 @@
+# Automatically generated context index for Utopia::Project guides.
+# Do not edit then files in this directory directly, instead edit the guides and then run `bake utopia:project:agent:context:update`.
+---
+description: A web-based presentation tool built with Lively.
+metadata:
+  documentation_uri: https://socketry.github.io/presently/
+  source_code_uri: https://github.com/socketry/presently.git
+files:
+- path: getting-started.md
+  title: Getting Started
+  description: This guide explains how to use `presently` to create and deliver web-based
+    presentations using Markdown slides.
+- path: animating-slides.md
+  title: Animating Slides
+  description: This guide explains how to animate content within slides using the
+    slide scripting system.

data/lib/presently/export.rb

@@ -20,8 +20,16 @@ module Presently
 		PageSize = Struct.new(:slide_width_px, :slide_height_px, :notes_height_px, keyword_init: true) do
 			PX_PER_CM = 96.0 / 2.54
 			
+			# Convert the slide width from CSS pixels to centimetres.
+			# @returns [Float] The slide width in centimetres.
 			def slide_width_cm  = (slide_width_px  / PX_PER_CM).round(4)
+			
+			# Convert the slide height from CSS pixels to centimetres.
+			# @returns [Float] The slide height in centimetres.
 			def slide_height_cm = (slide_height_px / PX_PER_CM).round(4)
+			
+			# Convert the notes panel height from CSS pixels to centimetres.
+			# @returns [Float] The notes panel height in centimetres.
 			def notes_height_cm = (notes_height_px / PX_PER_CM).round(4)
 		end
 		

data/lib/presently/slide.rb

@@ -249,7 +249,7 @@ module Presently
 		end
 		
 		# The transition type for animating into this slide.
-		# @returns [String | Nil] The transition name (e.g. `"fade"`, `"slide-left"`, `"morph"`), or `nil` for instant swap.
+		# @returns [String | Nil] The transition name (e.g. `"fade"`, `"slide-left"`, `"slide-right"`), or `nil` for instant swap.
 		def transition
 			@front_matter&.fetch("transition", nil)
 		end

data/lib/presently/version.rb

@@ -5,5 +5,5 @@
 
 # @namespace
 module Presently
-	VERSION = "0.14.0"
+	VERSION = "0.15.0"
 end

data/public/_static/index.css

@@ -364,18 +364,6 @@ html[data-transition="slide-right"]::view-transition-new(slide-container) {
 	animation: vt-slide-in-left 0.4s ease-in-out;
 }
 
-/* Magic move — the browser interpolates position/size for matched
-   view-transition-name elements. No cross-fade on the container
-   to avoid background dimming. */
-html[data-transition="morph"]::view-transition-old(slide-container) {
-	animation: none;
-	opacity: 0;
-}
-
-html[data-transition="morph"]::view-transition-new(slide-container) {
-	animation: none;
-}
-
 @keyframes vt-fade-out {
 	from { opacity: 1; }
 	to { opacity: 0; }
@@ -410,13 +398,6 @@ html[data-transition="morph"]::view-transition-new(slide-container) {
    BUILD EFFECTS
    ======================== */
 
-/* Suppress both pseudo-elements for hidden build elements so they
-   neither crossfade in nor crossfade out during the transition. */
-::view-transition-old(.build-hidden),
-::view-transition-new(.build-hidden) {
-	display: none;
-}
-
 /* Fade */
 .build-fade {
 	animation: vt-fade-in 0.4s ease;

data/public/slide.js

@@ -3,7 +3,6 @@
 // instead of tracking count manually. Created via SlideElements#builder(options).
 export class SlideBuilder {
 	#elements;
-	#prefix;
 	#defaultEffect;
 	#slide;
 	#step = 0;
@@ -11,7 +10,6 @@ export class SlideBuilder {
 	constructor(slide, elements, options = {}) {
 		this.#slide = slide;
 		this.#elements = elements;
-		this.#prefix = options.group || 'build';
 		this.#defaultEffect = options.effect || null;
 	}
 
@@ -26,16 +24,8 @@ export class SlideBuilder {
 		let revealedElement = null;
 
 		this.#elements.forEach((element, index) => {
-			// Only assign a group name if the element doesn't already have an explicit one.
-			// Preserving explicit names allows elements to participate in morph transitions
-			// to other slides while still being managed by the build system.
-			if (!element.style.viewTransitionName || element.style.viewTransitionName === 'none') {
-				element.style.viewTransitionName = `${this.#prefix}-${index + 1}`;
-			}
-
 			if (index < count) {
 				element.style.visibility = 'visible';
-				element.style.viewTransitionClass = '';
 
 				if (index === count - 1 && effect) {
 					element.classList.add(`build-${effect}`);
@@ -43,9 +33,6 @@ export class SlideBuilder {
 				}
 			} else {
 				element.style.visibility = 'hidden';
-				// Keep viewTransitionClass set so morph transitions can suppress
-				// crossfading on hidden elements when called inside startViewTransition.
-				element.style.viewTransitionClass = 'build-hidden';
 			}
 		});
 
@@ -75,11 +62,7 @@ export class SlideBuilder {
 		const effect = this.#slide.animated ? (overrides.effect !== undefined ? overrides.effect : this.#defaultEffect) : null;
 		const element = this.#elements[this.#step];
 
-		if (!element.style.viewTransitionName || element.style.viewTransitionName === 'none') {
-			element.style.viewTransitionName = `${this.#prefix}-${this.#step + 1}`;
-		}
 		element.style.visibility = 'visible';
-		element.style.viewTransitionClass = '';
 
 		this.#step += 1;
 
@@ -141,7 +124,6 @@ export class SlideElements {
 
 	// Create a stateful SlideBuilder for this element collection with default options.
 	// @parameter options [Object] Default options applied to every show() / next() call.
-	//   group: prefix for view-transition-name (default: "build")
 	//   effect: "fade", "fly-up", "fly-down", "fly-left", "fly-right", "scale"
 	// @returns [SlideBuilder]
 	builder(options = {}) {
@@ -152,7 +134,6 @@ export class SlideElements {
 	// Delegates to SlideBuilder for the actual implementation.
 	// @parameter count [Integer] Number of elements to show.
 	// @parameter options [Object]
-	//   group: prefix for view-transition-name (default: "build")
 	//   effect: "fade", "fly-up", "fly-down", "fly-left", "fly-right", "scale"
 	// @returns [Promise] Resolves when the animation completes (or immediately if no effect).
 	show(count, options = {}) {

data/readme.md

@@ -23,12 +23,19 @@ Please see the [project documentation](https://socketry.github.io/presently/) fo
 
   - [Getting Started](https://socketry.github.io/presently/guides/getting-started/index) - This guide explains how to use `presently` to create and deliver web-based presentations using Markdown slides.
 
-  - [Animating Slides](https://socketry.github.io/presently/guides/animating-slides/index) - This guide explains how to animate content within slides using the `morph` transition and the slide scripting system.
+  - [Animating Slides](https://socketry.github.io/presently/guides/animating-slides/index) - This guide explains how to animate content within slides using the slide scripting system.
 
 ## Releases
 
 Please see the [project releases](https://socketry.github.io/presently/releases/index) for all releases.
 
+### v0.15.0
+
+q
+
+  - Export works from current working directory.
+      - Remove explicit support for `morph` transition.
+
 ### v0.14.0
 
   - Increase code font size by 50%.
@@ -77,10 +84,6 @@ Please see the [project releases](https://socketry.github.io/presently/releases/
 
   - Add `bake presently:slides:speakers` task to print a timing breakdown grouped by speaker. Each speaker's slides are listed in presentation order with individual and total durations, making it easy to balance talk time in multi-speaker presentations. Slides without a `speaker` key are grouped under `(no speaker)`.
 
-### v0.5.0
-
-  - Add optional `speaker` front matter key to slides. When present, the current speaker's name is shown in the timing bar. If the next slide has a different speaker, a handoff indicator (e.g. `→ Next Speaker`) is shown alongside, giving presenters an at-a-glance cue for tag-team talks.
-
 ## See Also
 
   - [lively](https://github.com/socketry/lively) — The real-time application framework that powers Presently.

data/releases.md

@@ -1,5 +1,12 @@
 # Releases
 
+## v0.15.0
+
+q
+
+  - Export works from current working directory.
+      - Remove explicit support for `morph` transition.
+
 ## v0.14.0
 
   - Increase code font size by 50%.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: presently
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.16'
+        version: '0.18'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.16'
+        version: '0.18'
 - !ruby/object:Gem::Dependency
   name: markly
   requirement: !ruby/object:Gem::Requirement
@@ -90,6 +90,9 @@ files:
 - bake/presently/rehearse.rb
 - bake/presently/slides.rb
 - bin/presently
+- context/animating-slides.md
+- context/getting-started.md
+- context/index.yaml
 - lib/presently.rb
 - lib/presently/application.rb
 - lib/presently/clock.rb
@@ -240,7 +243,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.10
 specification_version: 4
 summary: A web-based presentation tool built with Lively.
 test_files: []