shellfie 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ab2ae504b1bc34a212d0354f51bc4d39cd9515d2d06703b342615a93dec0e3e
-  data.tar.gz: b442f32768d3a903c955a9830e6d69038ded4d232df459ee9ce93bc3445c9f47
+  metadata.gz: 0dbccd8edad54ded2bda6b8da245ab3f4ab3c9527ffd4bc75ef04cf7b6fc8713
+  data.tar.gz: 5fa83b5f80fae2d6281adc4ef685271af2b8c8f303d4116cbe26904ecf12c2a4
 SHA512:
-  metadata.gz: bf425a5d9791d0d4856d3a241fca4ce732d2a0730d77677a3e9de739e7df6b3a63eeae5dfa826f01361c2b763d69c9f674f86b926e470203d5d11ba9712d9cd6
-  data.tar.gz: 47c58a2d9ddc8ec9ce700c4c5220513a7ded9271952aed2d518c5fb50c567de4227ff73fabede8effa54df70ae8d1ddad6908265a3616ec225126f90f973e17b
+  metadata.gz: 473c51c3384978e8bc493b0a27cc1b5e9949c99c9f14d2cd6516cae963648c07bd281650175713f4028c09be1ce5d0140c119a4ffd7336da92e8a80075c43f30
+  data.tar.gz: fc061b6f9bff4c8f5bf7f512891ed8c13b39bf3342a14a5b98b967b15ac68a7d0dafc582ac884ea402e9d4ba61a0e549ca19d1883575c3af69a4e7e556b1d063

data/CHANGELOG.md

@@ -1,6 +1,60 @@
 # Changelog
 
-## Unreleased
+## 1.1.0 - 2026-08-29
+
+### Added
+
+- Add executable version 2 sessions with `run`, `record`, and `replay`; PTY sessions support command and key input, waits, assertions, hidden steps, redaction, named captures, editable recordings, and offline cassettes.
+- Add native selectable-text SVG, accessible HTML, MP4, WebM, event-duration PNG sequences, plain and ANSI-preserving text, structured JSON, and asciinema v2 output. Legacy raster-backed SVG remains available as `svg-raster`.
+- Add multiple configured outputs and capture-specific outputs from one session.
+- Add JSON Schemas, file/line/column diagnostics, typo suggestions, and `new`, `format`, `compile`, `schema`, `completion`, and include-aware `watch` authoring commands.
+- Add typed session variables, reusable and repeated step sets, and OS, shell, Ruby, and configured-environment step conditions.
+- Add inferred output names, collision-checked output templates, common aspect presets, bounded parallel batch rendering with `--jobs`, and non-mutating output verification with `generate --check`.
+- Add reproducibility manifests and JSON, SARIF, and JUnit validation reports for CI and editor integrations.
+- Add a reusable GitHub Action for generating or checking outputs and Docker packaging for a consistent rendering environment.
+- Add deterministic animation seeds, separate typing rate, frame timing, and playback speed controls, reverse and ping-pong playback, loop offsets, and format-specific GIF, WebP, and APNG controls.
+- Add configurable East Asian Ambiguous width and report the active Unicode and width-table profile through inspection and manifests.
+- Add broader terminal behavior for cursor movement, erase and insertion controls, alternate screens, scroll regions, colon-form colors, extended underline styles and colors, blink, conceal, and safe OSC 8 links.
+
+### Changed
+
+- Treat every frame `delay` as a post-action delay; a `type` frame's delay now overrides the global command delay, and `lines` initialize the screen when `frames` are also present.
+- Treat an explicit WebP format as static unless the input has frames or `--animate` is supplied.
+- Deprecate `--fps` in favor of `--framerate`; use `--typing-rate` to control input speed independently.
+
+### Fixed
+
+- Correct terminal tab stops, backspace behavior, wide-cell overwrites, grapheme-cluster typing, split Unicode input, line feeds, autowrap, and scroll-region editing.
+- Correct animation duration rounding, duplicate-frame timing, APNG tail duration, playback-speed timing, and minimum video duration.
+- Prevent output collisions before rendering, stream stdout without an output-sized memory copy, preserve existing outputs on failure, and remove partial animation files after errors or interruption.
+- Improve live-session prompt and exit synchronization, preserve asynchronous output, honor PTY dimensions and working directories, and terminate leftover child processes.
+- Improve `doctor` and dependency checks with real rendering, format delegates, fonts, security policy, and temporary-storage diagnostics.
+
+### Security and reliability
+
+- Add include cycle and chain diagnostics, per-file and aggregate size limits, and an optional symlink-aware root policy for includes and session working directories.
+- Add environment allowlists, total and per-step timeouts, bounded regular-expression evaluation, output and control-sequence limits, and rendering workload and temporary-disk budgets.
+- Add opt-in rejection of unsupported terminal graphics and an explicit policy for preserving only bounded `http`, `https`, and `mailto` OSC 8 links.
+
+## 1.0.0 - 2026-05-20
+
+### Added
+
+- Add static SVG and WebP output plus animated WebP and APNG output, with format selection by extension or `--format` and binary output through stdout.
+- Add batch generation from multiple files and glob patterns, directory outputs, automatic output-directory creation, and `--quiet` and `--verbose` modes.
+- Add `inspect` for resolved configuration and output dimensions, and `doctor` for Ruby, ImageMagick, output-directory, and encoding checks.
+- Add custom themes, Dracula, One Dark, Solarized Dark, and Catppuccin Mocha color schemes, configurable colors and window decorations, background gradients, font fallbacks, and block, bar, or underline cursors.
+- Add reusable YAML includes, line selection and semantic prompt, command, and output colors.
+- Add clip, wrap, and scroll overflow modes, exact-size and trimmed canvases, maximum height and line controls, configurable tab width, and per-line or persistent ANSI state.
+- Add animation typing jitter and chunking, output and final delays, frame limits, global, adaptive, or theme palettes, optional dithering, and configurable scroll easing.
+- Add public Ruby APIs for parsing, validating, rendering, and inspecting configurations.
+
+### Changed
+
+- Correct xterm 256-color values and malformed extended colors, and add dim, reverse, strikethrough, and overline styles plus carriage return, backspace, cursor movement, erase, and tab handling.
+- Improve line measurement, clipping, wrapping, fixed-height scrolling, trailing-line preservation, stable animation dimensions, and Windows, Ubuntu, macOS, and headless window rendering.
+- Refuse to replace an existing output unless `--force` is supplied, write outputs atomically, report errors on stderr, and distinguish filesystem failures with their own exit code.
+- Reject unknown keys, invalid types, unsupported values, excessive lines, frames, characters, pixels, and rendered frames with clearer validation errors before rendering.
 
 ## 0.1.1 - 2026-01-12
 
@@ -8,4 +62,4 @@
 
 ## 0.1.0 - 2026-01-12
 
-- Initial release.
+- Initial release.

data/README.md

@@ -1,9 +1,9 @@
-# shellfie
-
-Generate terminal screenshot-style images and animations from YAML.
+<p align="center">
+  <img src="assets/logo-header.svg" alt="Shellfie header logo">
+</p>
 
 <p align="center">
-  <img src="assets/logo-header.svg" alt="shellfie">
+  <strong>Deterministic terminal visuals and executable sessions from YAML</strong>
 </p>
 
 <p align="center">
@@ -14,38 +14,84 @@ Generate terminal screenshot-style images and animations from YAML.
 </p>
 
 <p align="center">
-  <img src="examples/demo.gif" alt="shellfie demo" width="560">
+  <a href="#features">Features</a> ·
+  <a href="#installation">Installation</a> ·
+  <a href="#quick-start">Quick Start</a> ·
+  <a href="#terminal-sessions">Terminal Sessions</a> ·
+  <a href="#configuration">Configuration</a> ·
+  <a href="#automation">Automation</a>
 </p>
 
-## Install
+---
 
-Requirements:
+Shellfie compiles YAML into deterministic terminal images, animations, and semantic transcripts. When explicitly requested, it can also run real PTY sessions, assert their output, record cassettes, and replay them offline.
 
-- Ruby 3.0+
-- ImageMagick 7+
+<p align="center">
+  <img src="examples/demo.gif" alt="Shellfie generating and validating an animated terminal demo" width="720">
+  <br>
+  <sub>Generated by Shellfie from <a href="examples/demo_animation.yml">examples/demo_animation.yml</a>.</sub>
+</p>
+
+## Features
+
+- Deterministic compose mode that never executes configuration content
+- Optional PTY execution with waits, assertions, captures, and redaction
+- Editable recordings and offline cassette replay
+- PNG, WebP, native SVG, HTML, GIF, APNG, MP4, WebM, and PNG sequence output
+- Plain text, ANSI, JSON, and asciinema v2 semantic transcripts
+- macOS, Ubuntu, Windows, and custom window styles, plus a headless mode
+- ANSI colors and controls, Unicode grapheme handling, and configurable ambiguous width
+- JSON Schemas, source-aware diagnostics, formatting, compilation, completion, and watch commands
+- Resource limits, path policies, dependency preflight, and atomic output replacement
+
+## Installation
+
+Add Shellfie to your Gemfile:
+
+```ruby
+gem "shellfie"
+```
+
+Then install:
+
+```bash
+bundle install
+```
+
+Or install it directly:
 
 ```bash
-brew install imagemagick
 gem install shellfie
 ```
 
-For Bundler:
+### Requirements
 
-```ruby
-gem "shellfie"
+- Ruby 3.0+
+- ImageMagick
+- ffmpeg for MP4, WebM, and APNG output
+
+Install media dependencies on macOS:
+
+```bash
+brew install imagemagick ffmpeg
 ```
 
+On Ubuntu or Debian:
+
+```bash
+sudo apt install imagemagick ffmpeg
+```
+
+Static and animated composition works on macOS, Linux, and Windows. Live PTY sessions are not supported on native Windows.
+
 ## Quick Start
 
 Create `terminal.yml`:
 
 ```yaml
+version: 1
 theme: macos
-title: "Terminal - zsh"
-
-window:
-  width: 600
-  padding: 20
+title: "Terminal"
 
 lines:
   - prompt: "$ "
@@ -59,82 +105,184 @@ Generate an image:
 shellfie generate terminal.yml -o terminal.png
 ```
 
-Use `shf` as a short alias for `shellfie`.
+Without `-o`, Shellfie writes `terminal.png` beside the input. `shf` is available as a short alias for `shellfie`.
+
+### Output Formats
+
+| Kind | Formats |
+| --- | --- |
+| Static | PNG, WebP, native selectable-text SVG, accessible HTML |
+| Animated | GIF, WebP, APNG, MP4, WebM, event-duration PNG sequence with `timeline.json` |
+| Semantic | TXT, ANSI, JSON, asciinema v2 (`asciicast` or `cast`) |
+
+Use `svg-raster` only when the legacy PNG-backed SVG behavior is required.
 
 ## CLI
 
+| Command | Purpose |
+| --- | --- |
+| `generate` | Render a version 1 compose configuration |
+| `run` | Execute and render a version 2 terminal session |
+| `record` | Execute a session and save a cassette or editable YAML |
+| `replay` | Render a cassette without executing its commands |
+| `new` / `init` | Create or print starter configuration |
+| `format` | Normalize YAML formatting |
+| `compile` | Print the resolved configuration or session IR |
+| `validate` | Validate input as text, JSON, SARIF, or JUnit |
+| `inspect` | Show resolved settings, dimensions, fonts, and resource estimates |
+| `schema` | Print the version 1 or version 2 JSON Schema |
+| `completion` | Print bash, zsh, fish, or PowerShell completion |
+| `watch` | Regenerate when a configuration or include changes |
+| `themes` | List available themes and color schemes |
+| `doctor` | Check media tools, formats, fonts, policies, and storage |
+| `version` | Show the installed Shellfie version |
+
+## Terminal Sessions
+
+Version 2 sessions execute commands only through `run` or `record`; review a session before running it. A minimal session looks like this:
+
+```yaml
+version: 2
+mode: run
+title: "Recorded shell"
+theme: macos
+
+terminal:
+  shell: /bin/sh
+  columns: 80
+  rows: 16
+  timeout: 10s
+
+steps:
+  - type: printf 'hello from shellfie\n'
+    speed: 30cps
+  - key: enter
+  - expect:
+      screen_contains: hello from shellfie
+      exit_status: 0
+  - capture: complete
+
+outputs:
+  - path: session.svg
+    format: svg
+    capture: complete
+  - path: session.txt
+    format: txt
+```
+
+Run, record, or replay it:
+
 ```bash
-shellfie generate config.yml -o output.png
-shellfie generate config.yml -o demo.gif --animate
-shellfie generate config.yml -o output.svg --format svg
-shellfie generate config.yml -o output.png --scale 2 --no-shadow
-shellfie generate config.yml -o output.png --no-header
-shellfie validate config.yml
-shellfie themes
-shellfie init
+shellfie run session.yml
+shellfie record session.yml --cassette session.json
+shellfie record session.yml --yaml editable-recording.yml
+shellfie replay session.json -o session.gif --animate
 ```
 
-Common `generate` options:
+### Session Actions
 
-| Option | Description |
+| Action | Purpose |
 | --- | --- |
-| `-o, --output PATH` | Output path |
-| `-t, --theme NAME` | Override theme |
-| `-a, --animate` | Render animation |
-| `-s, --scale FACTOR` | Output scale: `1`, `2`, or `3` |
-| `-w, --width PIXELS` | Override window width |
-| `--format FORMAT` | `png`, `gif`, `svg`, `webp`, or `apng` |
-| `--fps FPS` | Override animation typing FPS |
-| `--overflow MODE` | `clip`, `wrap`, or `scroll` |
-| `--no-shadow` | Disable shadow |
-| `--transparent` | Transparent background |
-| `--no-header` | Headless output |
-| `--force` | Overwrite existing files |
+| `run` | Execute a command directly, hidden by default |
+| `type` | Type visible text at a configurable rate |
+| `key` | Send Enter, arrows, modifiers, and other terminal keys |
+| `sleep` | Add a deterministic presentation pause |
+| `wait` | Wait for screen, line, prompt, exit, or stable-screen conditions |
+| `expect` | Assert screen text, lines, exit status, cursor, elapsed time, or a text golden |
+| `hide` / `show` | Control whether preparation and cleanup are recorded |
+| `capture` | Name an intermediate screen for a specific output |
 
-Static output supports `png`, `svg`, and `webp`.
-Animated output supports `gif`, `webp`, and `apng`.
+Sessions also support `requires`, step-level working directories, multiple outputs, reusable includes, environment allowlists, total and per-step timeouts, and redaction patterns. Set `terminal.cwd_policy: root` to confine working directories to the session root. Use `async: true` before interacting with a long-running or full-screen process, then synchronize with `wait`.
 
-## Configuration
+Variables use `{{name}}` placeholders. Reusable `step_sets` expand through `use`, `repeat` repeats a step or set, and `if` can select steps by OS, shell, Ruby requirement, or explicitly configured environment values. Expansion is bounded and cycles are rejected.
+
+## Authoring
+
+Create and inspect configurations without rendering them:
 
-Static content uses `lines`:
+```bash
+shellfie new terminal.yml --template static
+shellfie new demo.yml --template animation
+shellfie new session.yml --template run
+shellfie format terminal.yml
+shellfie compile terminal.yml --format json
+shellfie validate terminal.yml --format sarif
+shellfie inspect terminal.yml --json
+shellfie watch terminal.yml -o terminal.png
+```
+
+Templates include `static`, `animation`, `run`, `tui`, `ci`, and `theme-gallery`. JSON Schemas live in [`schema/`](schema/); add the following directive for editor validation:
 
 ```yaml
-theme: macos
-title: "Terminal"
+# yaml-language-server: $schema=../schema/shellfie-v1.schema.json
+```
 
-window:
-  width: 600
-  padding: 20
-  visible_lines: 8
-  overflow: clip
+Use schema version 2 for executable sessions. Run `shellfie schema 1` or `shellfie schema 2` to print either schema, and `shellfie completion zsh` to generate shell completion.
 
-font:
-  family: Monaco
-  size: 14
-  line_height: 1.4
+## Automation
 
-lines:
-  - prompt: "$ "
-    command: "gem install shellfie"
-  - output: |
-      Successfully installed shellfie
-      1 gem installed
+Use the Docker-based GitHub Action to generate an output or fail when a committed output is stale:
+
+```yaml
+- uses: ydah/shellfie@main
+  with:
+    input: examples/simple.yml
+    output: docs/terminal.png
+    check: "true"
 ```
 
-Animations use `frames`:
+Or build and run the included container locally:
+
+```bash
+docker build -t shellfie .
+docker run --rm -v "$PWD:/work" shellfie \
+  generate /work/examples/simple.yml -o /work/terminal.png --force
+```
+
+Use `--manifest manifest.json` during generation to record configuration and output hashes, Ruby, OS, ImageMagick, ffmpeg, and resolved font fingerprints.
+
+## Configuration
+
+### Compose Configuration
+
+| Key | Purpose |
+| --- | --- |
+| `theme` | `macos`, `ubuntu`, `windows`, or `custom` |
+| `window_theme` | Window chrome to use with a custom theme |
+| `color_scheme` | Built-in palette: `dracula`, `one_dark`, `solarized_dark`, or `catppuccin_mocha` |
+| `colors` | Individual color overrides |
+| `window` | Width, height, padding, wrapping, clipping, scrolling, and terminal policies |
+| `font` | Family, fallback families, size, and line height |
+| `animation` | Typing, timing, playback, loop, palette, and encoder controls |
+| `cursor` | Cursor style and color |
+| `headless` | Hide window chrome |
+| `lines` | Initial or static terminal content |
+| `frames` | Animated terminal events |
+| `limits` | Source, output-frame, pixel, and temporary-storage ceilings |
+
+Static content uses `lines`; animations add `frames`:
 
 ```yaml
+version: 1
 theme: macos
 title: "Demo"
 
+window:
+  width: 600
+  padding: 20
+  visible_lines: 8
+  overflow: clip
+
 animation:
   typing_speed: 50
-  command_delay: 500
+  framerate: 30
+  playback_speed: 1.0
   cursor_blink: true
   loop: true
-  palette: global
-  dither: true
-  scroll_easing: ease_out
+  seed: 1
+
+lines:
+  - output: "Ready"
 
 frames:
   - prompt: "$ "
@@ -144,50 +292,63 @@ frames:
     delay: 1000
 ```
 
-Useful top-level keys:
+A frame `delay` is applied after its action; on a `type` frame it overrides `animation.command_delay`. When both `lines` and `frames` are present, `lines` initialize the screen before animated events run.
 
-| Key | Purpose |
-| --- | --- |
-| `theme` | `macos`, `ubuntu`, `windows`, or `custom` |
-| `color_scheme` | Built-in color scheme such as `dracula` |
-| `colors` | Theme color overrides |
-| `window` | Size, padding, wrapping, clipping, scrolling |
-| `font` | Font family, size, line height |
-| `animation` | Typing speed, delays, loop, palette, easing |
-| `cursor` | Cursor style and color |
-| `headless` | Hide window chrome |
-| `lines` | Static terminal content |
-| `frames` | Animated terminal content |
+### Generate Options
 
-ANSI colors and styles are supported in `prompt`, `command`, and `output`, including 8-color, bright, 256-color, and RGB escape sequences.
+| Option | Description |
+| --- | --- |
+| `-o, --output PATH` | Output path or `{name}-{theme}-{scale}.{format}` template |
+| `--preset NAME` | Exact `readme`, `ogp`, `widescreen`, `standard`, or `vertical` canvas |
+| `-t, --theme NAME` | Override the theme |
+| `-a, --animate` | Render animation |
+| `-s, --scale FACTOR` | Output scale: `1`, `2`, or `3` |
+| `-w, --width PIXELS` | Override width |
+| `--format FORMAT` | Select an output format |
+| `--check` | Fail if an existing output is stale without replacing it |
+| `--jobs N` | Render up to 32 inputs in parallel after preflight |
+| `--typing-rate CPS` | Override typing rate in characters per second |
+| `--framerate FPS` | Set output timing precision |
+| `--seed N` | Set the deterministic animation seed |
+| `--playback-speed FACTOR` | Scale the final timeline |
+| `--overflow MODE` | `clip`, `wrap`, or `scroll` |
+| `--no-shadow` | Disable the window shadow |
+| `--transparent` | Use a transparent background |
+| `--no-header` | Hide window chrome |
+| `--force` | Replace an existing output |
 
-## Themes
+### Advanced Controls
 
-Built-in window themes:
+- Set `animation.direction` to `forward`, `reverse`, or `ping_pong`; `animation.loop_offset` selects a different initial frame.
+- Tune GIF colors and optimization, WebP quality and lossless mode, APNG prediction and loop count, and scroll easing under `animation`.
+- Set `window.ambiguous_width` to `1` or `2`; inspection and manifests report the active Unicode and width-table profile.
+- Set `window.osc_policy: preserve` to keep bounded `http`, `https`, and `mailto` OSC 8 links in SVG and HTML.
+- Set `window.graphics_policy: error` to reject SIXEL, Kitty, or iTerm2 graphics instead of discarding them.
+- Use `include` for shared YAML. Set `include_policy: root` to reject paths outside the root configuration directory, including symlink escapes.
+- Set resource ceilings under `limits`; Shellfie checks source size, pixels, frame work, and temporary storage before expensive rendering.
 
-- `macos`
-- `ubuntu`
-- `windows`
+## How It Works
 
-Headless output removes window chrome:
+1. Configuration parsing resolves includes, validates input, and reports source locations.
+2. Compose, live PTY, or cassette input is normalized into terminal events.
+3. The terminal screen applies Unicode, ANSI, cursor, erase, alternate-screen, and scroll behavior.
+4. Raster, SVG, HTML, video, or semantic renderers produce the requested outputs.
+5. Output files are written atomically after dependency, collision, and resource preflight.
 
-```yaml
-headless: true
-```
-
-or:
-
-```bash
-shellfie generate config.yml -o output.png --no-header
-```
+`generate` is deterministic and never runs configuration content. `run` and `record` opt into PTY execution. `replay` uses a cassette and does not execute the recorded commands.
 
 ## Development
 
 ```bash
 bundle install
 bundle exec rspec
+gem build shellfie.gemspec
 ```
 
+## Contributing
+
+Bug reports and pull requests are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md) and [SECURITY.md](SECURITY.md) before submitting changes or security reports.
+
 ## License
 
-[MIT](LICENSE)
+Released under the [MIT License](LICENSE).

data/lib/shellfie/animation_frame_builder.rb

@@ -2,12 +2,13 @@
 
 require_relative "animation_scroll_easing"
 require_relative "animation_timeline"
+require_relative "text_metrics"
 
 module Shellfie
   class AnimationFrameBuilder
     def initialize(config)
       @config = config
-      @random = Random.new(0)
+      @random = Random.new(config.animation[:seed])
       @scroll_easing = AnimationScrollEasing.new(config)
     end
 
@@ -15,9 +16,12 @@ module Shellfie
       return [{ lines: @config.lines, delay: @config.animation[:final_delay] }] if @config.frames.empty?
 
       frames = []
-      current_lines = []
+      current_lines = @config.lines.flat_map { |line| line_data(line) }
       AnimationTimeline.new(@config).each do |event|
         case event.kind
+        when :screen
+          current_lines.replace(event.frame.screen.map { |line| { output: line } })
+          frames << { lines: build_display_lines(current_lines), delay: [event.frame.delay, 1].max }
         when :command
           frames.concat(command_frames(current_lines, event.frame))
         when :output
@@ -62,7 +66,7 @@ module Shellfie
       frames = []
       prompt = frame.prompt || ""
       command = frame.type
-      chars = command.chars
+      chars = TextMetrics.graphemes(command)
       chunk_size = @config.animation[:typing_chunk_size]
 
       (chunk_size..chars.length).step(chunk_size).each do |index|
@@ -93,7 +97,11 @@ module Shellfie
     end
 
     def command_pause_frames(current_lines, frame)
-      delay = @config.animation[:command_delay]
+      delay = if frame.output
+                @config.animation[:command_delay]
+              else
+                frame.delay.positive? ? frame.delay : @config.animation[:command_delay]
+              end
       return [] unless delay.positive?
       return [{ lines: build_display_lines(current_lines), delay: delay }] unless @config.animation[:cursor_blink]
 
@@ -109,11 +117,11 @@ module Shellfie
       output_delay = @config.animation[:output_delay]
 
       if output_delay.positive?
-        output_lines.each_with_index.each_with_object([]) do |(line, index), frames|
+        frames = output_lines.each_with_index.each_with_object([]) do |(line, index), result|
           previous_count = current_lines.size
           current_lines << { output: line, output_color: frame.output_color }
           delay = @scroll_easing.output_delay(output_delay, index, output_lines.size)
-          frames.concat(
+          result.concat(
             @scroll_easing.transition_frames(
               build_display_lines(current_lines),
               delay: delay,
@@ -121,9 +129,11 @@ module Shellfie
             )
           )
         end
+        frames << { lines: build_display_lines(current_lines), delay: frame.delay } if frame.delay.positive?
+        frames
       else
         output_lines.each { |line| current_lines << { output: line, output_color: frame.output_color } }
-        [{ lines: build_display_lines(current_lines), delay: frame.delay || 100 }]
+        [{ lines: build_display_lines(current_lines), delay: [frame.delay, 1].max }]
       end
     end
 
@@ -131,6 +141,20 @@ module Shellfie
       { prompt: prompt, command: command, cursor: cursor, prompt_color: prompt_color, command_color: command_color }
     end
 
+    def line_data(line)
+      data = []
+      if line.prompt || line.command
+        data << command_line(
+          line.prompt,
+          line.command,
+          prompt_color: line.prompt_color,
+          command_color: line.command_color
+        )
+      end
+      data.concat(line.output.to_s.split("\n", -1).map { |output| { output: output, output_color: line.output_color } }) if line.output
+      data
+    end
+
     def cursor_command_line(frame)
       command_line(
         frame.prompt || "",

data/lib/shellfie/animation_timeline.rb

@@ -12,6 +12,7 @@ module Shellfie
       return enum_for(:each) unless block_given?
 
       @config.frames.each do |frame|
+        yield Event.new(kind: :screen, frame: frame) if frame.screen
         yield Event.new(kind: :command, frame: frame) if frame.type
         yield Event.new(kind: :output, frame: frame) if frame.output
         yield Event.new(kind: :pause, frame: frame) if pause_frame?(frame)
@@ -21,7 +22,7 @@ module Shellfie
     private
 
     def pause_frame?(frame)
-      frame.delay&.positive? && frame.output.nil? && frame.type.nil?
+      frame.delay&.positive? && frame.output.nil? && frame.type.nil? && frame.screen.nil?
     end
   end
 end