selenium_screencast 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cfab0bcb1ad7671634b430664e40b6678a33976668c25a99b98b2811e1bd154f
+  data.tar.gz: c0e4767fe92439c6f7d20d21cd6f82f9f994c0f7d68f76ce4c0aaff86ea06b92
+SHA512:
+  metadata.gz: 20c5220b49c3124ab6a6b3b43d3aececf774c16e32fe2700069a4716bfebec4e47fe99062668a2b5fa1bb7b4f106f39107c6fb00c6da906ce4b0ddcea0885d31
+  data.tar.gz: '073424481ffb0cf5f55d330f21ccbc24fa3d1c62fba206cd6986ac89841a6def28e5dfa06139faa475b20f50d5b0e0fe7d1d5a93df41ede872be92b9fda673b6'

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-07-26
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,10 @@
+# Code of Conduct
+
+"selenium_screencast" follows [The Ruby Community Conduct Guideline](https://www.ruby-lang.org/en/conduct) in all "collaborative space", which is defined as community communications channels (such as mailing lists, submitted patches, commit comments, etc.):
+
+* Participants will be tolerant of opposing views.
+* Participants must ensure that their language and actions are free of personal attacks and disparaging personal remarks.
+* When interpreting the words and actions of others, participants should always assume good intentions.
+* Behaviour which can be reasonably considered harassment will not be tolerated.
+
+If you have any concerns about behaviour within this project, please contact us at ["lala.akira@gmail.com"](mailto:"lala.akira@gmail.com").

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 aki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,287 @@
+# SeleniumScreencast
+
+Record your Capybara/Selenium system specs as webm or mp4 video, using the
+Chrome DevTools Protocol (CDP) screencast API. `SeleniumScreencast` captures
+the JPEG frame stream from `Page.startScreencast`, then encodes it into a
+webm or mp4 video with `ffmpeg` — no browser extensions or external
+recording tools required.
+
+## Requirements
+
+- `ffmpeg` available on `PATH` (or point `FFMPEG_BIN` / `ffmpeg_bin` at it).
+  For `mp4` output, `ffmpeg` must include an H.264 (`libx264`) encoder.
+- A Chrome/Chromium-based driver used through `selenium-webdriver`, since
+  recording relies on the CDP `devtools` connection exposed by Selenium's
+  Chrome bridge (e.g. system specs driven by `:selenium_chrome_headless` or
+  similar)
+
+## Installation
+
+Add the gem to your application's test group:
+
+```bash
+bundle add selenium_screencast --group test
+```
+
+## Usage
+
+### RSpec / Capybara
+
+Require the RSpec adapter once, e.g. in `rails_helper.rb` or a spec support
+file:
+
+```ruby
+require "selenium_screencast/rspec"
+```
+
+This automatically records every `type: :system` example when recording is
+enabled, and by default saves a video after each example finishes (regardless
+of pass/fail). See [Recording only failed specs](#recording-only-failed-specs)
+to keep videos only for failures.
+
+Enable recording by setting `RECORD_VIDEO` when running specs:
+
+```bash
+RECORD_VIDEO=1 bundle exec rspec spec/system/checkout_spec.rb
+```
+
+Videos are written as webm (or mp4, depending on `config.format`) files
+under the configured `output_dir` (`Rails.root.join("tmp/videos")` in a Rails
+app, or `tmp/videos` relative to the working directory otherwise). Each file
+is named after the example's full description, sanitized to a safe filename
+with a random suffix to avoid collisions, e.g.
+`Checkout_completes_purchase_a1b2c3d4.webm` (or `....mp4` when `format` is
+`:mp4`).
+
+### Configuration
+
+Configure defaults in an initializer or spec support file:
+
+```ruby
+SeleniumScreencast.configure do |config|
+  config.slow_factor = 4          # default: 8.0
+  config.output_fps = 30          # default: 30
+  config.ffmpeg_bin = "ffmpeg"    # default: "ffmpeg"
+  config.quality = 80             # default: 80
+  config.every_nth_frame = 1      # default: 1
+  config.last_frame_duration = 0.5 # default: 0.5 (seconds, before slow_factor)
+  config.inflight_delay = 0.2     # default: 0.2 (seconds, wait before stopping)
+  config.output_dir = "tmp/videos" # default: Rails.root/tmp/videos, or tmp/videos
+  config.debug = false            # default: false
+  config.format = :webm           # default: :webm (:webm or :mp4)
+  config.failed_only = false      # default: false
+end
+```
+
+| Option                | Description                                                                 | Default |
+| ---------------------- | ---------------------------------------------------------------------------- | ------- |
+| `slow_factor`          | Playback slow-motion multiplier applied to inter-frame durations             | `8.0`   |
+| `output_fps`           | Fixed output frame rate (CFR) that ffmpeg re-encodes to                      | `30`    |
+| `ffmpeg_bin`           | Path to the `ffmpeg` executable                                              | `"ffmpeg"` |
+| `quality`              | JPEG quality requested from the CDP screencast; must be 0-100               | `80`    |
+| `every_nth_frame`      | Only capture every Nth screencast frame from Chrome; must be >= 1           | `1`     |
+| `last_frame_duration`  | Seconds the final frame is held for, before `slow_factor` is applied        | `0.5`   |
+| `inflight_delay`       | Seconds to wait after stopping the screencast, to let in-flight frames land. Skipped when the frames are discarded without encoding | `0.2`   |
+| `output_dir`           | Directory videos are written to                                             | `Rails.root/tmp/videos` (Rails) or `tmp/videos` |
+| `debug`                | Keep the intermediate JPEG frame files (and concat list) instead of deleting them after encoding | `false` |
+| `format`               | Output video format (`:webm` or `:mp4`); determines container and codec      | `:webm` |
+| `failed_only`          | Only keep the video for examples that failed; passing examples are recorded but never encoded | `false` |
+
+**Precedence: environment variable > `configure` value > default.** When one
+of the environment variables below is set, it always wins over a value set
+via `SeleniumScreencast.configure`.
+
+### Clearing previous videos
+
+When recording is enabled (`RECORD_VIDEO` is set), `output_dir` is emptied
+once at the start of each rspec run, so this run's videos aren't mixed with
+stale files from previous runs. This happens automatically via the
+`selenium_screencast/rspec` adapter's `before(:suite)` hook — no
+configuration needed.
+
+When `RECORD_VIDEO` is unset, the output dir is left untouched (the
+"disabled -> nothing happens" contract).
+
+The cleanup runs at most once per process. With `parallel_tests`,
+`before(:suite)` fires once per RSpec worker process, so each worker empties
+the shared output dir at startup (not exactly once across all processes).
+Because the workers share one `output_dir` and start at different times, a
+slower-starting worker can wipe videos a faster worker already recorded in
+the same run. If you rely on `parallel_tests`, give each worker its own
+`output_dir` (e.g. keyed by `TEST_ENV_NUMBER`) so a worker only clears its
+own directory.
+
+Only the directory contents are removed; the directory itself is kept.
+
+### Environment variables
+
+| Variable             | Effect                                                        | Default |
+| --------------------- | --------------------------------------------------------------- | ------- |
+| `RECORD_VIDEO`        | Enables recording when present (any non-empty value)            | disabled |
+| `RECORD_VIDEO_TESTS`      | Comma-separated spec file paths to record. When set (alongside `RECORD_VIDEO`), only matching specs are recorded. See [Recording only specific specs](#recording-only-specific-specs). | all specs |
+| `RECORD_VIDEO_TESTS_FILE` | Path to a file listing spec paths (one per line) to record. Combined (union) with `RECORD_VIDEO_TESTS`. A missing file raises an error. | unset |
+| `RECORD_VIDEO_FAILED_ONLY` | Only keep the video for examples that failed, when present (any non-empty value). See [Recording only failed specs](#recording-only-failed-specs). | disabled |
+| `RECORD_SLOW_FACTOR`  | Overrides the playback slow-motion multiplier                   | `8`     |
+| `RECORD_QUALITY`      | Overrides the JPEG quality (0-100) requested from the screencast | `80`    |
+| `RECORD_EVERY_NTH_FRAME` | Overrides how many screencast frames to skip (capture every Nth frame; must be >= 1) | `1`     |
+| `FFMPEG_BIN`          | Overrides the path to the `ffmpeg` executable                    | `ffmpeg` |
+| `RECORD_DEBUG`        | Keeps intermediate frame files on disk when present              | disabled |
+| `RECORD_VIDEO_FORMAT` | Overrides the output format (`webm` / `mp4`)                     | `webm`  |
+
+### Recording only specific specs
+
+By default, when `RECORD_VIDEO` is enabled, **every** `type: :system` example is
+recorded. When you run the full suite but only want video for a few specs — for
+example, to review a newly added spec — narrow recording to specific spec files
+with `RECORD_VIDEO_TESTS` (comma-separated) and/or `RECORD_VIDEO_TESTS_FILE`
+(one path per line). All the specs still **run**; only the listed ones are
+**recorded**.
+
+```bash
+# Inline list — the whole suite runs; only these two specs are recorded
+RECORD_VIDEO=1 RECORD_VIDEO_TESTS="spec/system/checkout_spec.rb,spec/system/login_spec.rb" \
+  bundle exec rspec
+
+# List from a file (e.g. generated by CI from the changed specs)
+RECORD_VIDEO=1 RECORD_VIDEO_TESTS_FILE=tmp/record_targets.txt bundle exec rspec
+```
+
+When both `RECORD_VIDEO_TESTS` and `RECORD_VIDEO_TESTS_FILE` are set, the union
+of the two lists is used.
+
+Behavior summary:
+
+| `RECORD_VIDEO` | Target list (`RECORD_VIDEO_TESTS` / `RECORD_VIDEO_TESTS_FILE`) | Result |
+| --- | --- | --- |
+| unset | (ignored) | Recording disabled entirely; the target list is never read. |
+| set | both unset | Every system spec is recorded (backward-compatible default). |
+| set | set, with matching paths | Only the matching spec files are recorded. |
+| set | set, but effectively empty (blank values only) | Nothing is recorded — an empty selection does **not** fall back to recording everything. |
+
+Paths are compared after normalizing against `Rails.root` (or the working
+directory when not running under Rails), so relative paths (`spec/system/...`,
+`./spec/system/...`) and absolute paths all match the same spec.
+
+### Recording only failed specs
+
+When running the full suite in CI, you typically don't want a video for every
+passing example — only for the ones that failed, so they can be attached as
+build artifacts. Set `RECORD_VIDEO_FAILED_ONLY` (or `config.failed_only`) to
+do this:
+
+```bash
+RECORD_VIDEO=1 RECORD_VIDEO_FAILED_ONLY=1 bundle exec rspec
+```
+
+**Honest overhead note:** whether an example passed or failed is only known
+after it finishes, so CDP frame capture still runs for **every** example —
+this can't be avoided. What's actually skipped is `ffmpeg` encoding, which is
+the dominant cost of recording. For examples that pass, `ffmpeg` is never
+invoked, so neither the video file nor its intermediate frame directory
+(`*_frames`) is ever created — encoding isn't skipped by deleting output
+afterward, it's skipped from the start. The `inflight_delay` wait is skipped
+too, since it only exists to let a trailing frame make it into the video.
+
+Whether a video is kept depends on the example's outcome:
+
+| Example outcome | Video kept? |
+| --- | --- |
+| passed | No |
+| failed | Yes |
+| failed via `aggregate_failures` | Yes |
+| failed in a user's own `after` hook | Yes |
+| pending, failed as expected | No (a known failure doesn't need a video) |
+| pending but unexpectedly passed | Yes (this is a real failure) |
+| skipped | No |
+
+`RECORD_VIDEO_FAILED_ONLY` combines with `RECORD_VIDEO_TESTS` /
+`RECORD_VIDEO_TESTS_FILE` as an **AND**: an example is only encoded if it's
+both in the target list (or no list is set) **and** it failed.
+
+Interaction with `RECORD_DEBUG`: for a passing example, nothing is encoded,
+so there are no frames left to keep — `RECORD_DEBUG` has no effect on
+passing examples. `RECORD_DEBUG` remains useful for inspecting the source
+frames behind a video that _was_ produced (i.e. a failing example).
+
+### Reducing recording overhead
+
+Since CDP frame capture can't be skipped for any example (see above), the
+remaining lever is making that capture itself cheaper. Two knobs help:
+
+- Lowering `RECORD_QUALITY` (or `config.quality`) shrinks each JPEG frame,
+  reducing CDP transfer and disk I/O.
+- Raising `RECORD_EVERY_NTH_FRAME` (or `config.every_nth_frame`) reduces the
+  number of frames captured at all.
+
+**Note:** raising `every_nth_frame` does not shorten the video or make it
+play faster. Frame display durations are computed from the deltas between
+consecutive CDP frame timestamps, so skipping frames just widens those gaps
+and each surviving frame is held on screen longer — total playback time is
+preserved. What you lose is temporal resolution (motion looks choppier
+between frames), not timing fidelity.
+
+```bash
+RECORD_VIDEO=1 RECORD_QUALITY=40 RECORD_EVERY_NTH_FRAME=2 bundle exec rspec
+```
+
+### Core API (without Capybara)
+
+`SeleniumScreencast::Recorder` only needs an object that responds to
+`#devtools` (as provided by `selenium-webdriver`'s Chrome bridge), so it can
+be used directly without Capybara or RSpec:
+
+```ruby
+require "selenium_screencast"
+require "selenium-webdriver"
+
+driver = Selenium::WebDriver.for(:chrome)
+recorder = SeleniumScreencast::Recorder.new(driver, output_path: "out.webm")
+
+recorder.start
+# ... drive the browser ...
+recorder.stop
+```
+
+## How it works
+
+1. Starts a CDP screencast session (`Page.startScreencast`) and writes each
+   incoming JPEG frame to a sequential file, acknowledging every frame so
+   Chrome keeps streaming.
+2. On stop, builds an ffmpeg concat list where each frame's display duration
+   is derived from the delta between its Chrome timestamp and the next
+   frame's (variable frame rate), scaled by `slow_factor`.
+3. Runs `ffmpeg` once against that concat list, re-encoding the variable
+   frame rate stream to a fixed `output_fps` (CFR) file, using VP9/webm or
+   H.264/mp4 depending on `config.format`. If the configured `ffmpeg`
+   executable cannot be found, a clear `SeleniumScreencast::Error` is raised
+   before encoding instead of failing silently.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then,
+run `rake spec` to run the tests. You can also run `bin/console` for an
+interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+To release a new version, update the version number in `version.rb`, and
+then run `bundle exec rake release`, which will create a git tag for the
+version, push git commits and the created tag, and push the `.gem` file to
+[rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/aki77/selenium_screencast. This project is intended to be
+a safe, welcoming space for collaboration, and contributors are expected to
+adhere to the [code of conduct](https://github.com/aki77/selenium_screencast/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the SeleniumScreencast project's codebases, issue
+trackers, chat rooms and mailing lists is expected to follow the
+[code of conduct](https://github.com/aki77/selenium_screencast/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/selenium_screencast/configuration.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module SeleniumScreencast
+  # Holds the configuration for the recording engine.
+  #
+  # Value precedence is "env var > value set via configure > default".
+  # Env vars always win, since they're often used to temporarily change
+  # behavior in CI, etc. An env var of nil / empty string is treated as
+  # "unset" (this does not rely on ActiveSupport's String#blank?).
+  class Configuration
+    DEFAULT_SLOW_FACTOR = 8.0
+    DEFAULT_OUTPUT_FPS = 30
+    DEFAULT_FFMPEG_BIN = "ffmpeg"
+    DEFAULT_QUALITY = 80
+    DEFAULT_EVERY_NTH_FRAME = 1
+    DEFAULT_LAST_FRAME_DURATION = 0.5
+    DEFAULT_INFLIGHT_DELAY = 0.2
+    DEFAULT_FORMAT = :webm
+
+    attr_writer :slow_factor, :output_fps, :ffmpeg_bin, :quality,
+                :every_nth_frame, :last_frame_duration, :inflight_delay,
+                :output_dir, :debug, :format, :failed_only
+
+    def slow_factor
+      env_or("RECORD_SLOW_FACTOR", value_or_default(@slow_factor, DEFAULT_SLOW_FACTOR), &:to_f)
+    end
+
+    def output_fps
+      value_or_default(@output_fps, DEFAULT_OUTPUT_FPS)
+    end
+
+    def ffmpeg_bin
+      env_or("FFMPEG_BIN", value_or_default(@ffmpeg_bin, DEFAULT_FFMPEG_BIN)) { |v| v }
+    end
+
+    # The output format (:webm / :mp4). Resolved with env > configure >
+    # default, then normalized to absorb case, surrounding whitespace, and
+    # symbol/string variance. An unsupported value is a config error, so it
+    # raises a clear Error.
+    def format
+      raw = env_or("RECORD_VIDEO_FORMAT", value_or_default(@format, DEFAULT_FORMAT)) { |v| v }
+      normalize_format(raw)
+    end
+
+    # JPEG quality (0-100). Resolved with env > configure > default, then
+    # validated to be within the range CDP accepts.
+    def quality
+      raw = env_or("RECORD_QUALITY", value_or_default(@quality, DEFAULT_QUALITY), &:to_i)
+      normalize_int_in_range(raw, "quality", 0..100, "between 0 and 100")
+    end
+
+    # Capture every Nth frame. Resolved with env > configure > default, then
+    # validated to be a positive value.
+    def every_nth_frame
+      raw = env_or("RECORD_EVERY_NTH_FRAME",
+                   value_or_default(@every_nth_frame, DEFAULT_EVERY_NTH_FRAME), &:to_i)
+      normalize_int_in_range(raw, "every_nth_frame", 1.., ">= 1")
+    end
+
+    def last_frame_duration
+      value_or_default(@last_frame_duration, DEFAULT_LAST_FRAME_DURATION)
+    end
+
+    def inflight_delay
+      value_or_default(@inflight_delay, DEFAULT_INFLIGHT_DELAY)
+    end
+
+    # The output directory. A user-specified value takes priority; otherwise
+    # Rails.root/tmp/videos in a Rails environment, or the relative tmp/videos
+    # outside Rails.
+    def output_dir
+      return Pathname(@output_dir.to_s) unless @output_dir.nil?
+
+      defined?(Rails) ? Rails.root.join("tmp/videos") : Pathname("tmp/videos")
+    end
+
+    # Recording is enabled when RECORD_VIDEO is set.
+    def enabled?
+      env_present?("RECORD_VIDEO")
+    end
+
+    # Whether the given spec file should be recorded.
+    # Always false if the arm (enabled?) is disabled (the target list env vars
+    # are not read at all in that case). If neither target list env var is
+    # set, records everything (true), as before. If set, normalizes and checks
+    # for a match. An effectively empty list is always false (does not fall
+    # back to recording everything).
+    def recording_target?(spec_file)
+      return false unless enabled?
+      return true unless target_list_configured?
+      return false if spec_file.nil? || spec_file.to_s.empty?
+
+      recording_target_paths.include?(normalize_test_path(spec_file))
+    end
+
+    # Frame images are kept (for debugging) when RECORD_DEBUG is set.
+    def debug?
+      env_present?("RECORD_DEBUG") || @debug == true
+    end
+
+    # Only failed examples keep their video when RECORD_VIDEO_FAILED_ONLY is
+    # set. Recording itself still runs for every example (frames must be
+    # captured before the outcome is known); this flag only decides whether the
+    # captured frames get encoded into a video at the end. Orthogonal to
+    # RECORD_VIDEO_TESTS: when both are set, only the listed specs that also
+    # failed produce a video.
+    def failed_only?
+      env_present?("RECORD_VIDEO_FAILED_ONLY") || @failed_only == true
+    end
+
+    private
+
+    # Returns the default if the @ivar is nil (checked with nil? since false/0
+    # are valid values to keep as-is).
+    def value_or_default(value, default)
+      value.nil? ? default : value
+    end
+
+    # Normalizes a format value. Absorbs differences in case, surrounding
+    # whitespace, and symbol/string, and raises a clear Error for an
+    # unsupported value as a config error. The supported formats are read from
+    # the neutral VIDEO_FORMATS as the single source (shared with Encoder).
+    def normalize_format(value)
+      normalized = value.to_s.strip.downcase.to_sym
+      supported = SeleniumScreencast::VIDEO_FORMATS.keys
+      unless supported.include?(normalized)
+        raise SeleniumScreencast::Error,
+              "Unsupported video format: #{value.inspect} " \
+              "(supported: #{supported.join(", ")})"
+      end
+      normalized
+    end
+
+    # Shared validator for integer options constrained to a range. Raises a
+    # clear Error (config error) when the value falls outside range, including
+    # the received value via inspect for easier debugging. bound_desc spells
+    # out the range in prose, since a Range alone can't say it readably.
+    def normalize_int_in_range(value, name, range, bound_desc)
+      unless range.cover?(value)
+        raise SeleniumScreencast::Error,
+              "Invalid #{name}: #{value.inspect} (must be #{bound_desc})"
+      end
+      value
+    end
+
+    # If the env var key is set, returns its value transformed by the block.
+    # If unset (nil/empty string), returns default (this consolidates the
+    # "env var > default" precedence).
+    def env_or(key, default)
+      env_present?(key) ? yield(ENV.fetch(key)) : default
+    end
+
+    def env_present?(key)
+      v = ENV.fetch(key, nil)
+      !v.nil? && !v.empty?
+    end
+
+    # Whether either RECORD_VIDEO_TESTS or RECORD_VIDEO_TESTS_FILE is set
+    # (even to a blank value). This is what distinguishes "env unset =
+    # record everything" from "set but empty = zero targets".
+    def target_list_configured?
+      env_present?("RECORD_VIDEO_TESTS") || env_present?("RECORD_VIDEO_TESTS_FILE")
+    end
+
+    # The normalized path set of target specs.
+    # The union of RECORD_VIDEO_TESTS (comma-separated) and
+    # RECORD_VIDEO_TESTS_FILE (newline-separated). Blanks are removed and the
+    # rest is normalized into a Set. An effectively empty result is an empty
+    # Set (= zero targets). Since recording_target? is called on every
+    # before(:each) of a system spec, the I/O for RECORD_VIDEO_TESTS_FILE's
+    # File.readlines, etc. is memoized on the singleton instance instead of
+    # being repeated once per example (env vars are assumed immutable for the
+    # life of the process).
+    def recording_target_paths
+      @recording_target_paths ||=
+        (target_paths_from_env + target_paths_from_file)
+        .filter_map { |p| (s = p&.strip) && !s.empty? ? normalize_test_path(s) : nil }
+        .to_set
+    end
+
+    # Splits RECORD_VIDEO_TESTS on commas. [] if unset.
+    def target_paths_from_env
+      env_or("RECORD_VIDEO_TESTS", []) { |v| v.split(",") }
+    end
+
+    # Reads the RECORD_VIDEO_TESTS_FILE file, newline-separated. [] if unset.
+    # Since env_or only evaluates the block when the arm is active (the env
+    # var is set), the existence check does not run either when the arm is
+    # inactive. Raises an Error if set but the file does not exist.
+    def target_paths_from_file
+      env_or("RECORD_VIDEO_TESTS_FILE", []) do |path|
+        raise SeleniumScreencast::Error, "RECORD_VIDEO_TESTS_FILE not found: #{path}" unless File.file?(path)
+
+        File.readlines(path, chomp: true)
+      end
+    end
+
+    # Normalizes a spec path to one relative to base (= Rails.root or pwd).
+    # The same normalization is applied to both the target list side and the
+    # current example side so they can be matched.
+    def normalize_test_path(path)
+      expanded = Pathname(path.to_s).expand_path(base_path)
+      expanded.relative_path_from(base_path).to_s
+    rescue ArgumentError
+      # Where relativizing is impossible (outside base, e.g. a different
+      # drive), settle for the absolute path string. If expand_path itself
+      # fails and expanded is unassigned (nil), fall back to the original path
+      # string (this prevents nil.to_s's empty string from polluting the
+      # target set and causing a false match).
+      (expanded || path).to_s
+    end
+
+    # The base directory for normalization. Same Rails-branching concern as
+    # output_dir.
+    def base_path
+      defined?(Rails) ? Rails.root : Pathname.pwd
+    end
+  end
+end

data/lib/selenium_screencast/encoder.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module SeleniumScreencast
+  # Encodes a frame sequence to webm (VP9) via the ffmpeg concat demuxer.
+  # Composed of pure computation (dropping static frames, computing durations,
+  # building concat.txt) plus a single ffmpeg call, so the computation part
+  # can be unit tested.
+  class Encoder
+    def self.file_extension(format)
+      format_spec(format).fetch(:ext)
+    end
+
+    # Returns the VIDEO_FORMATS entry for a format symbol. An unsupported value
+    # is converted into the unified-contract SeleniumScreencast::Error instead
+    # of a plain KeyError (matching callers that only rescue
+    # SeleniumScreencast::Error).
+    def self.format_spec(format)
+      SeleniumScreencast::VIDEO_FORMATS.fetch(format) do
+        raise SeleniumScreencast::Error,
+              "Unsupported video format: #{format.inspect} " \
+              "(supported: #{SeleniumScreencast::VIDEO_FORMATS.keys.join(", ")})"
+      end
+    end
+
+    def initialize(frame_store, output_path:, config: SeleniumScreencast.config)
+      @frame_store = frame_store
+      @output_path = output_path
+      @config = config
+    end
+
+    def encode
+      frames = drop_leading_static_frames(@frame_store.frames)
+      return if frames.empty?
+
+      # Resolve @config.format (raises Error on an invalid value) and check
+      # that ffmpeg is available before doing wasted work like writing
+      # concat.txt.
+      format_spec = self.class.format_spec(@config.format)
+      ensure_ffmpeg_available!
+      concat_path = @frame_store.write_concat_list(build_concat_list(frames))
+      run(ffmpeg_argv(concat_path, format_spec))
+    end
+
+    # Drops the leading static frames where "nothing has changed yet".
+    # Right after a page loads, the same screen tends to repeat, so frames up
+    # to the first change are discarded so the video starts from actual
+    # interaction. If every frame is identical, only the last one is kept.
+    def drop_leading_static_frames(frames)
+      first_changed_index =
+        frames.each_cons(2).find_index { |prev, curr| !same_frame_content?(prev, curr) }
+      return frames.last(1) if first_changed_index.nil?
+
+      frames.drop(first_changed_index + 1)
+    end
+
+    # Builds the list string for the ffmpeg concat demuxer.
+    # The last file is listed twice because the concat demuxer interprets each
+    # duration as "the display time until the next file", so giving the last
+    # frame a display time requires listing the same file once more.
+    def build_concat_list(frames)
+      durations = frame_durations(frames)
+      lines =
+        frames.each_with_index.flat_map do |frame, i|
+          ["file '#{frame[:file]}'", "duration #{durations[i].round(3)}"]
+        end
+      lines << "file '#{frames.last[:file]}'"
+      "#{lines.join("\n")}\n"
+    end
+
+    private
+
+    # Computes the display duration of each frame. CDP frames are variable
+    # frame rate (VFR), so the diff of metadata.timestamp is used as real time
+    # and stretched by slow_factor (to show the interaction more slowly).
+    # This is repacked to CFR via -r at encode time.
+    def frame_durations(frames)
+      frames.each_with_index.map do |frame, i|
+        next_frame = frames[i + 1]
+        next @config.last_frame_duration * @config.slow_factor unless next_frame
+        next 0.0 unless frame[:time] && next_frame[:time]
+
+        (next_frame[:time] - frame[:time]) * @config.slow_factor
+      end
+    end
+
+    # Compares two frames for identical content. Differing :size is a fast
+    # rejection that needs no disk I/O, since compressed JPEGs that differ
+    # almost always differ in byte size. It is only a rejection, never a
+    # proof of equality: two different JPEGs can happen to compress to the
+    # same byte count, so equal (or missing) :size still falls back to a
+    # real byte comparison.
+    def same_frame_content?(frame_a, frame_b)
+      return false if frame_a[:size] && frame_b[:size] && frame_a[:size] != frame_b[:size]
+
+      File.binread(frame_a[:file]) == File.binread(frame_b[:file])
+    end
+
+    # Repacks the VFR frame sequence into constant frame rate (CFR) via -r, and
+    # outputs with the codec from format_spec (the webm/VP9 argv is identical
+    # to before, for backward compatibility).
+    def ffmpeg_argv(concat_path, format_spec)
+      [
+        @config.ffmpeg_bin, "-y", "-f", "concat", "-safe", "0", "-i", concat_path.to_s,
+        "-r", @config.output_fps.to_s, "-c:v", format_spec[:codec], *format_spec[:extra], @output_path.to_s
+      ]
+    end
+
+    # Runs ffmpeg. Kept as a separate method so it can be stubbed in tests.
+    def run(argv)
+      warn "SeleniumScreencast: running ffmpeg: #{argv.join(" ")}" if @config.debug?
+      out, status = Open3.capture2e(*argv)
+      unless status.success?
+        warn "SeleniumScreencast: ffmpeg encoding failed: #{status}"
+        # ffmpeg writes the actual cause (missing encoder, bad dimensions, etc.)
+        # to stderr, which capture2e merges into out. Surface it under
+        # RECORD_DEBUG so failures like exit 187 can be diagnosed.
+        warn "SeleniumScreencast: ffmpeg output:\n#{out}" if @config.debug?
+      end
+      status
+    end
+
+    # Raises an Error with a clear cause and remedy if ffmpeg_bin is not
+    # executable. Calling this before running the encode prevents
+    # Open3.capture2e from crashing with Errno::ENOENT and silently producing
+    # no video.
+    def ensure_ffmpeg_available!
+      return if ffmpeg_executable?
+
+      raise SeleniumScreencast::Error,
+            "ffmpeg executable not found: #{@config.ffmpeg_bin.inspect}. " \
+            "Install ffmpeg and make sure it is on PATH, or set the ffmpeg path via " \
+            "FFMPEG_BIN env / config.ffmpeg_bin."
+    end
+
+    # A `which`-equivalent existence check (assumes macOS/Linux). If the value
+    # contains a directory separator (absolute/relative path), checks that
+    # path directly; otherwise searches for it as a command name on PATH.
+    def ffmpeg_executable?
+      bin = @config.ffmpeg_bin.to_s
+      return executable_file?(bin) if bin.include?(File::SEPARATOR)
+
+      ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).any? do |dir|
+        executable_file?(File.join(dir, bin))
+      end
+    end
+
+    def executable_file?(path)
+      File.file?(path) && File.executable?(path)
+    end
+  end
+end

data/lib/selenium_screencast/frame_store.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+
+module SeleniumScreencast
+  # Saves received JPEG frames to disk with sequential numbering, and holds
+  # the frame metadata. Deals only with the filesystem and has no dependency
+  # on selenium, so it can be tested standalone.
+  class FrameStore
+    # Frame info in the order received. Each element is { file:, time:, size: }.
+    # The key names match the original implementation (passed on to Encoder).
+    # size: is the byte size of the written JPEG, recorded so Encoder can use
+    # it as a fast-path rejection when comparing frames for staticness,
+    # without having to read the frame back from disk.
+    attr_reader :frames
+
+    # Builds a FrameStore by deriving the frame directory from the output file
+    # path. Frame images are placed in "<basename>_frames" in the same
+    # directory as the output file.
+    def self.for_output(output_path)
+      path = Pathname(output_path.to_s)
+      frames_dir = path.dirname.join("#{path.basename(".*")}_frames")
+      new(frames_dir)
+    end
+
+    def initialize(dir)
+      @dir = Pathname(dir.to_s)
+      FileUtils.mkdir_p(@dir)
+      @frames = []
+      @mutex = Mutex.new
+    end
+
+    # Writes the JPEG byte string sequentially as 0001.jpg, and so on, and
+    # appends the metadata to frames. The index matches the original
+    # implementation: @frames.size + 1 (starting at 0001).
+    # CDP runs the callback on a new thread for every screencastFrame event, so
+    # numbering, writing, and appending are all serialized under a Mutex to
+    # prevent frame collisions or loss.
+    def write(jpeg_bytes, timestamp:)
+      @mutex.synchronize do
+        index = @frames.size + 1
+        file = @dir.join(format("%04d.jpg", index))
+        File.binwrite(file, jpeg_bytes)
+        @frames << { file: file.to_s, time: timestamp, size: jpeg_bytes.bytesize }
+      end
+    end
+
+    # Writes the concat demuxer list to concat.txt in the frame directory, and
+    # returns its path.
+    def write_concat_list(content)
+      path = concat_path
+      File.write(path, content)
+      path
+    end
+
+    # Removes the entire frame directory unless keep is true.
+    def cleanup(keep:)
+      FileUtils.rm_rf(@dir) unless keep
+    end
+
+    private
+
+    def concat_path
+      @dir.join("concat.txt")
+    end
+  end
+end

data/lib/selenium_screencast/recorder.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module SeleniumScreencast
+  # The recording lifecycle built on CDP (Chrome DevTools Protocol)'s
+  # Page.startScreencast. Receives a browser that responds to #devtools via
+  # injection, and knows nothing about Capybara or RSpec.
+  class Recorder
+    def initialize(browser, output_path:, config: SeleniumScreencast.config)
+      @browser = browser
+      @output_path = Pathname(output_path.to_s)
+      @config = config
+      @state = nil
+    end
+
+    def start
+      raise "SeleniumScreencast::Recorder is already recording" if recording?
+
+      devtools = @browser.devtools(target_type: "page")
+
+      frame_store = FrameStore.for_output(@output_path)
+
+      callback = build_frame_callback(devtools, frame_store)
+      # on returns the array of registered callbacks. Removing our own
+      # callback from this array on stop keeps it from lingering into the
+      # next recording.
+      callbacks = devtools.page.on(:screencast_frame, &callback)
+
+      begin
+        devtools.page.start_screencast(
+          format: "jpeg", quality: @config.quality, every_nth_frame: @config.every_nth_frame
+        )
+      rescue StandardError
+        # If starting fails, remove ourselves from the shared callback array
+        # immediately before re-raising, so we don't linger in it.
+        callbacks.delete(callback)
+        raise
+      end
+
+      @state = { devtools:, callback:, callbacks:, frame_store: }
+    end
+
+    # Stops the recording. With encode: false, the captured frames are
+    # discarded without invoking ffmpeg, so nothing is written to output_path.
+    # This lets a caller that only wants video under some condition (e.g. the
+    # RSpec adapter's "failed only" mode) skip the encode cost entirely rather
+    # than encoding and deleting afterwards. Recorder is told whether to
+    # encode, never why: it stays unaware of test outcomes.
+    def stop(encode: true)
+      state = @state
+      return if state.nil?
+
+      stop_screencast(state, wait_for_inflight: encode)
+
+      encode_frames(state) if encode
+    ensure
+      # Even if encode raises SeleniumScreencast::Error (invalid format value,
+      # ffmpeg missing), always clean up in ensure so the intermediate JPEG
+      # frames don't linger uncleaned.
+      # debug? only applies when we actually encoded: keeping frames is for
+      # inspecting what a produced video was built from, so with encode: false
+      # they are always removed. Otherwise a full suite in "failed only" mode
+      # would leave a *_frames dir behind for every passing example.
+      state&.fetch(:frame_store)&.cleanup(keep: @config.debug? && encode)
+      @state = nil
+      # NOTE: never close devtools. It's a shared instance memoized per target
+      # on the browser side; closing it would break other recordings and
+      # selenium's own devtools usage too. Removing ourselves from the
+      # callback array is sufficient cleanup.
+    end
+
+    def recording?
+      !@state.nil?
+    end
+
+    private
+
+    # Tells CDP to stop delivering frames and unregisters our callback. This
+    # always runs, even when not encoding: leaving the screencast running would
+    # spill frames into the next recording.
+    #
+    # wait_for_inflight adds a short grace period so a frame still in flight can
+    # land before the frames are handed to the encoder. It is only worth paying
+    # when we are going to encode; when the frames are about to be discarded the
+    # sleep would just be dead time on every example that skips encoding.
+    def stop_screencast(state, wait_for_inflight:)
+      state[:devtools].page.stop_screencast
+      sleep @config.inflight_delay if wait_for_inflight
+    rescue StandardError => e
+      warn "SeleniumScreencast: exception in stop_screencast: #{e.class}: #{e.message}"
+    ensure
+      state[:callbacks].delete(state[:callback])
+    end
+
+    def encode_frames(state)
+      Encoder.new(
+        state[:frame_store],
+        output_path: @output_path,
+        config: @config
+      ).encode
+    end
+
+    def build_frame_callback(devtools, frame_store)
+      lambda do |params|
+        begin
+          # Decode Base64 with the standard unpack (equivalent to
+          # Base64.decode64) to avoid depending on the base64 gem, which
+          # dropped out of the default gems as of Ruby 3.4.
+          frame_store.write(
+            params["data"].unpack1("m"),
+            timestamp: params.dig("metadata", "timestamp")
+          )
+        rescue StandardError => e
+          warn "SeleniumScreencast: exception in screencastFrame callback: #{e.class}: #{e.message}"
+        end
+        # Skipping the ack would make CDP stop delivering frames altogether,
+        # so it must always be sent regardless of whether write succeeded.
+        devtools.page.screencast_frame_ack(session_id: params["sessionId"])
+      end
+    end
+  end
+end

data/lib/selenium_screencast/rspec.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "fileutils"
+require "selenium_screencast"
+
+begin
+  require "rspec/core"
+rescue LoadError
+  raise LoadError,
+        "selenium_screencast/rspec requires rspec-core. Add `gem \"rspec\"` to your Gemfile " \
+        "before requiring \"selenium_screencast/rspec\"."
+end
+
+module SeleniumScreencast
+  # A thin RSpec adapter for Capybara system specs (type: :system).
+  # The only dependency on Capybara is `page.driver.browser`; this module
+  # itself does not require Capybara.
+  module RSpecHelper
+    # Starts recording. Does nothing if the config is disabled.
+    # A failure to start is warned instead of raised, so it does not affect the
+    # test result. However, SeleniumScreencast::Error is a contractual exception
+    # signaling a configuration problem (e.g. a wrong RECORD_VIDEO_TESTS_FILE
+    # path), so it is not swallowed and is re-raised. Any other StandardError
+    # (Recorder start failure, an unexpected I/O error while judging the
+    # recording target, etc.) is warned and skipped as before, without
+    # affecting the test result.
+    def start_screencast_recording
+      config = SeleniumScreencast.config
+      return unless config.recording_target?(current_spec_file)
+
+      dir = config.output_dir
+      FileUtils.mkdir_p(dir)
+      path = dir.join(screencast_filename(config))
+      browser = page.driver.browser
+      @screencast_recorder = SeleniumScreencast::Recorder.new(browser, output_path: path)
+      @screencast_recorder.start
+    rescue SeleniumScreencast::Error
+      raise
+    rescue StandardError => e
+      warn "SeleniumScreencast: failed to start recording: #{e.class}: #{e.message}"
+      @screencast_recorder = nil
+    end
+
+    # Stops recording. A failure to stop is warned instead of raised.
+    # However, SeleniumScreencast::Error is a contractual exception signaling a
+    # configuration problem (e.g. ffmpeg missing or an invalid format value),
+    # so, just like start, it is not swallowed and is re-raised. stop also runs
+    # encoding (Encoder#encode) along this path, so without this rescue the
+    # intent of "raise a clear Error when ffmpeg is missing" would be swallowed
+    # by warn and stop working.
+    #
+    # By default the video is kept regardless of pass/fail. When
+    # RECORD_VIDEO_FAILED_ONLY is enabled, a passing example stops with
+    # encode: false so ffmpeg is never invoked for it: recording (CDP frame
+    # capture) cannot be avoided since the outcome is only known afterwards,
+    # but the expensive part is skipped, and no file is written to output_dir.
+    def stop_screencast_recording
+      return if @screencast_recorder.nil?
+
+      @screencast_recorder.stop(encode: keep_video?)
+    rescue SeleniumScreencast::Error
+      raise
+    rescue StandardError => e
+      warn "SeleniumScreencast: failed to stop recording: #{e.class}: #{e.message}"
+    ensure
+      @screencast_recorder = nil
+    end
+
+    private
+
+    # Generates a filename that also supports non-ASCII describe/it text (same
+    # behavior as the original copy-tuner implementation). Collapses runs of
+    # non-\p{Word} characters into _, squeezes repeated _, and strips a
+    # leading _.
+    def screencast_filename(config)
+      raw = "#{RSpec.current_example.metadata[:full_description]}_#{SecureRandom.hex(4)}"
+      safe = raw.gsub(/[^\p{Word}]+/u, "_").squeeze("_").delete_prefix("_")
+      ext = SeleniumScreencast::Encoder.file_extension(config.format)
+      "#{safe}.#{ext}"
+    end
+
+    # The spec file path of the current example. nil if it cannot be obtained.
+    def current_spec_file
+      RSpec.current_example&.metadata&.fetch(:file_path, nil)
+    end
+
+    # Whether this example's video should actually be written out.
+    # Always true unless the "failed only" mode is on.
+    def keep_video?
+      return true unless SeleniumScreencast.config.failed_only?
+
+      example_failed?
+    end
+
+    # Whether the current example failed, judged from RSpec.current_example in
+    # an after(:each) hook.
+    #
+    # execution_result.status is deliberately NOT used: RSpec assigns it in
+    # Example#finish, which runs *after* the after(:each) hooks, so it is still
+    # nil at this point. Example#exception, on the other hand, is already set by
+    # then, and it also covers a failure raised from a user's own after hook
+    # (config-level after hooks run last) and aggregate_failures (which stores a
+    # MultipleExceptionError).
+    #
+    # Pending/skip fall out correctly for free: for an example pending as
+    # expected, RSpec routes the error into execution_result.pending_exception
+    # and leaves #exception nil, so no video is kept for a known failure. An
+    # example that unexpectedly passes while pending gets a
+    # PendingExampleFixedError in #exception, so its video is kept.
+    #
+    # If current_example is somehow unavailable, treat it as failed and keep the
+    # video: an extra video is harmless, a missing video for a real failure is
+    # not.
+    def example_failed?
+      example = RSpec.current_example
+      return true if example.nil?
+
+      !example.exception.nil?
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include SeleniumScreencast::RSpecHelper, type: :system
+
+  # NOTE: register per-example hooks lazily, through before(:suite).
+  #   This file can be required before the system-test-style driven_by call,
+  #   so registering before(:each) directly would run it before driven_by and
+  #   leave current_driver as rack_test. Registering inside before(:suite)
+  #   defers it until after driven_by, so recording can start on the selenium
+  #   driver.
+  config.before(:suite) do
+    SeleniumScreencast.clean_output_dir!
+    RSpec.configure do |c|
+      c.before(:each, type: :system) { start_screencast_recording }
+      c.after(:each, type: :system) { stop_screencast_recording }
+    end
+  end
+end

data/lib/selenium_screencast/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SeleniumScreencast
+  VERSION = "0.1.0"
+end

data/lib/selenium_screencast.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+require_relative "selenium_screencast/version"
+require_relative "selenium_screencast/configuration"
+require_relative "selenium_screencast/frame_store"
+require_relative "selenium_screencast/encoder"
+require_relative "selenium_screencast/recorder"
+
+# CDP screencast recording engine, independent of Capybara.
+# Provides access to config and creation/reset of Configuration.
+module SeleniumScreencast
+  class Error < StandardError; end
+
+  # ffmpeg settings per output format. Both Configuration (which formats are
+  # allowed) and Encoder (which codec builds the argv per format) treat this
+  # as the single source of truth. Letting either side hold its own allowlist
+  # would let them drift apart, passing validation but raising KeyError when
+  # building argv, so it lives here in a neutral location instead.
+  #   ext   : output file extension (the container is inferred by ffmpeg from it)
+  #   codec : video codec passed to -c:v
+  #   extra : codec-specific extra options (mp4/H.264 pins yuv420p for playback
+  #           compatibility, and scales to even dimensions since libx264 with
+  #           yuv420p requires the width and height to be divisible by 2 —
+  #           an odd-sized capture otherwise aborts encoding, e.g. exit 187)
+  # format_spec returns this entry as-is and ffmpeg_argv reads from it, so nested
+  # Hash / Array values are frozen too, preventing an accidental mutation from
+  # corrupting global state (it raises FrozenError instead, so it gets noticed).
+  VIDEO_FORMATS = {
+    webm: { ext: "webm", codec: "libvpx-vp9", extra: [].freeze }.freeze,
+    mp4: {
+      ext: "mp4", codec: "libx264",
+      extra: ["-vf", "scale=trunc(iw/2)*2:trunc(ih/2)*2", "-pix_fmt", "yuv420p"].freeze
+    }.freeze
+  }.freeze
+
+  class << self
+    def configure
+      yield config
+      config
+    end
+
+    def config
+      @config ||= Configuration.new
+    end
+
+    def reset_config!
+      @config = Configuration.new
+      @output_dir_cleaned = false
+    end
+
+    # Empties output_dir at the start of a run so this run's videos aren't
+    # mixed with stale files from a previous run. No-op unless recording is
+    # enabled (RECORD_VIDEO), preserving the "disabled -> nothing happens"
+    # contract. Wipes at most once per process, so registering it in a
+    # before(:suite) hook is idempotent. Does nothing if the directory does
+    # not exist yet.
+    def clean_output_dir!
+      return unless config.enabled?
+      return if @output_dir_cleaned
+
+      @output_dir_cleaned = true
+      dir = config.output_dir
+      return unless File.directory?(dir)
+
+      # Enumerate entries with Dir.children instead of interpolating dir into a
+      # Dir.glob pattern: a dir path containing glob metacharacters ([, {, *,
+      # ...) would otherwise be misparsed and silently clean nothing.
+      Dir.children(dir).each { |name| FileUtils.rm_rf(File.join(dir, name)) }
+    end
+  end
+end

data/sig/selenium_screencast.rbs

@@ -0,0 +1,4 @@
+module SeleniumScreencast
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: selenium_screencast
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- aki
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: selenium-webdriver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: selenium-devtools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Captures JPEG frames from Chrome via the CDP Page.startScreencast API
+  and encodes them into a webm video with ffmpeg. Wires into RSpec/Capybara system
+  specs with a single require, and its behavior (enable/disable, slow-motion factor,
+  ffmpeg binary, debug output) can be controlled via environment variables.
+email:
+- lala.akira@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/selenium_screencast.rb
+- lib/selenium_screencast/configuration.rb
+- lib/selenium_screencast/encoder.rb
+- lib/selenium_screencast/frame_store.rb
+- lib/selenium_screencast/recorder.rb
+- lib/selenium_screencast/rspec.rb
+- lib/selenium_screencast/version.rb
+- sig/selenium_screencast.rbs
+homepage: https://github.com/aki77/selenium_screencast
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/aki77/selenium_screencast
+  source_code_uri: https://github.com/aki77/selenium_screencast/tree/v0.1.0
+  changelog_uri: https://github.com/aki77/selenium_screencast/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.15
+specification_version: 4
+summary: Record Capybara/Selenium system specs to webm video via Chrome DevTools screencast.
+test_files: []