shellfie 1.0.0 → 1.1.0

data/lib/shellfie/cli_info.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+require "json"
+require "optparse"
+require "yaml"
+require "cgi/escape"
+
 module Shellfie
   module CLIInfo
     private
@@ -7,6 +12,7 @@ module Shellfie
     def run_init
       puts <<~YAML
         # Shellfie configuration file
+        version: 1
         theme: macos
         title: "Terminal — zsh"
 
@@ -42,10 +48,32 @@ module Shellfie
     end
 
     def run_validate
+      format = "text"
+      OptionParser.new { |opts| opts.on("--format FORMAT", "text, json, sarif, or junit") { |value| format = value } }.parse!(@args)
+      raise ValidationError, "validation format must be text, json, sarif, or junit" unless %w[text json sarif junit].include?(format)
+      @options[:validation_format] = format
       input_file = @args.shift
       raise ConfigError, "Input file is required" unless input_file
+      @options[:validation_path] = input_file
+
+      if configuration_version(input_file) == 2
+        session = SessionConfig.parse(input_file)
+        return emit_validation_report(valid: true, path: input_file, details: { version: 2, steps: session.steps.size, outputs: session.outputs.size }) if format != "text"
+
+        puts "✓ Session configuration is valid"
+        puts "  Steps: #{session.steps.size}"
+        puts "  Outputs: #{session.outputs.size}"
+        return
+      end
 
       config = Parser.parse(input_file)
+      if format != "text"
+        return emit_validation_report(
+          valid: true, path: input_file,
+          details: { version: 1, theme: config.theme, mode: config.animated? ? "animated" : "static" }
+        )
+      end
+
       puts "✓ Configuration is valid"
       puts "  Theme: #{config.theme}"
       puts "  Title: #{config.title}"
@@ -59,10 +87,38 @@ module Shellfie
     end
 
     def run_inspect
+      json = false
+      OptionParser.new { |opts| opts.on("--json", "Print machine-readable JSON") { json = true } }.parse!(@args)
       input_file = @args.shift
       raise ConfigError, "Input file is required" unless input_file
 
+      if configuration_version(input_file) == 2
+        session = SessionConfig.parse(input_file)
+        info = {
+          config: session.to_h,
+          mode: session.mode,
+          terminal: session.terminal,
+          steps: session.steps.size,
+          outputs: session.outputs
+        }
+        return puts(JSON.pretty_generate(info)) if json
+
+        puts "Session:"
+        puts "  Version: 2"
+        puts "  Mode: #{session.mode}"
+        puts "  Terminal: #{session.terminal[:columns]}x#{session.terminal[:rows]} (#{session.terminal[:shell]})"
+        puts "  Steps: #{session.steps.size}"
+        puts "  Outputs: #{session.outputs.size}"
+        return
+      end
+
       info = Shellfie.inspect_config(input_file)
+      info[:unicode] = {
+        version: TextMetrics::UNICODE_VERSION,
+        width_table: TextMetrics::WIDTH_TABLE_VERSION,
+        ambiguous_width: info.dig(:config, :window, :ambiguous_width) || 1
+      }
+      return puts(JSON.pretty_generate(info)) if json
       puts "Config:"
       puts "  Version: #{info[:config][:version]}"
       puts "  Theme: #{info[:theme]}"
@@ -72,6 +128,11 @@ module Shellfie
       puts "  Frames: #{info[:config][:frames].size}"
       puts "  Estimated size: #{info[:geometry][:canvas_width]}x#{info[:geometry][:canvas_height]}"
       puts "  Logical size: #{info[:geometry][:logical_width]}x#{info[:geometry][:logical_height]} @#{info[:geometry][:scale]}x"
+      puts "  Unicode: #{info[:unicode][:version]} (width table #{info[:unicode][:width_table]}, ambiguous=#{info[:unicode][:ambiguous_width]})"
+      info.fetch(:fonts, {}).each do |style, font|
+        fingerprint = font[:sha256] ? " (sha256: #{font[:sha256]})" : ""
+        puts "  Font #{style}: #{font[:name] || "not found"}#{fingerprint}"
+      end
     end
 
     def run_doctor
@@ -88,15 +149,49 @@ module Shellfie
       puts "shellfie #{VERSION}"
     end
 
+    def emit_validation_report(valid:, path: nil, details: nil, error: nil)
+      format = @options[:validation_format]
+      path ||= @options[:validation_path]
+      message = error&.message
+      case format
+      when "json"
+        puts JSON.pretty_generate(version: 1, valid: valid, path: path, details: details, errors: message ? [{ message: message }] : [])
+      when "sarif"
+        result = if message
+                   [{ level: "error", message: { text: message }, locations: path ? [{ physicalLocation: { artifactLocation: { uri: path } } }] : [] }]
+                 else
+                   []
+                 end
+        puts JSON.pretty_generate(
+          version: "2.1.0", "$schema": "https://json.schemastore.org/sarif-2.1.0.json",
+          runs: [{ tool: { driver: { name: "shellfie", version: VERSION } }, results: result }]
+        )
+      when "junit"
+        failure = %(<failure message="#{CGI.escapeHTML(message)}">#{CGI.escapeHTML(message)}</failure>) if message
+        puts %(<testsuite name="shellfie validate" tests="1" failures="#{valid ? 0 : 1}"><testcase name="#{CGI.escapeHTML(path || "configuration")}">#{failure}</testcase></testsuite>)
+      else
+        raise ValidationError, "validation format must be text, json, sarif, or junit"
+      end
+    end
+
     def show_help
       puts <<~HELP
-        Shellfie - Terminal screenshot-style image generator
+        Shellfie - Deterministic terminal visual compiler
 
         Usage: shellfie <command> [options]
                shf <command> [options]
 
         Commands:
-          generate    Generate image from configuration file
+          generate    Render outputs from a configuration file
+          run         Execute and render a version 2 terminal session
+          record      Run a session and save a cassette or editable YAML
+          replay      Render an existing cassette without executing commands
+          new         Create a config from a template
+          format      Normalize YAML formatting
+          compile     Print the resolved config or session IR
+          schema      Print the version 1 or 2 JSON Schema
+          completion  Print bash, zsh, fish, or PowerShell completion
+          watch       Regenerate when a config or included file changes
           init        Output sample configuration
           themes      List available themes
           validate    Validate configuration file
@@ -106,22 +201,27 @@ module Shellfie
           help        Show this help
 
         Generate Options:
-          -o, --output PATH      Output file path (required)
+          -o, --output PATH      Output path/template (defaults beside input)
           -t, --theme NAME       Override theme (macos, ubuntu, windows)
-          -a, --animate          Generate animated GIF
+          -a, --animate          Render animated output
           -s, --scale FACTOR     Output scale (1, 2, 3)
           -w, --width PIXELS     Override width
           --no-shadow            Disable shadow effect
           --no-header            Disable window header (headless mode)
           --transparent          Transparent background
-          --fps FPS              Override animation typing FPS
+          --typing-rate CPS      Typing rate in characters per second
+          --framerate FPS        Output timing precision
+          --seed N               Deterministic animation jitter seed
+          --playback-speed N     Playback speed multiplier
+          --fps FPS              Deprecated alias for --framerate
           --overflow MODE        Line overflow mode: clip, wrap, scroll
           --wrap, --no-wrap      Enable or disable long-line wrapping
           --exact-size           Match canvas to configured window size
-          --format FORMAT        Output format: png, gif, svg, webp, apng
+          --format FORMAT        Also: mp4, webm, png-sequence, html, txt, json
           --force                Overwrite existing output files
           --quiet                Suppress non-error output
           --verbose              Print progress details
+          --manifest PATH        Write environment and output fingerprints
 
         Examples:
           shellfie generate config.yml -o terminal.png

data/lib/shellfie/cli_run.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "optparse"
+require "yaml"
+require_relative "cassette"
+require_relative "output_writer"
+require_relative "session_config"
+
+module Shellfie
+  module CLIRun
+    private
+
+    def run_session(record: false)
+      parser = build_run_parser(record: record)
+      parser.parse!(@args)
+      input = @args.shift
+      raise ConfigError, "Session configuration is required" unless input
+
+      config = SessionConfig.parse(input)
+      raise ConfigError, "mode: replay is not executable; use shellfie replay CASSETTE.json" if config.mode == "replay"
+      cassette_path = @options[:cassette]
+      yaml_path = @options[:yaml]
+      raise ConfigError, "record requires --cassette PATH or --yaml PATH" if record && !cassette_path && !yaml_path
+      resolved_outputs = resolve_session_outputs(config.outputs, base_dir: config.base_dir, allow_empty: record && (cassette_path || yaml_path))
+      preflight_session_artifacts!(resolved_outputs, cassette_path, yaml_path, input_path: config.path)
+      preflight_render_dependencies!(resolved_outputs.map { |_path, format, _output| format })
+      raise DependencyError, "Live sessions are not supported on native Windows" if Gem.win_platform?
+
+      require_relative "session_runner"
+      session = SessionRunner.new(config).run
+      write_cassette(cassette_path, session) if cassette_path
+      write_recording(yaml_path, session) if yaml_path
+      render_session_outputs(session, config.outputs, base_dir: config.base_dir, theme: config.theme, render: config.render,
+                                                      resolved: resolved_outputs)
+    end
+
+    def replay_session
+      build_replay_parser.parse!(@args)
+      input = @args.shift
+      raise ConfigError, "Cassette file is required" unless input
+
+      session = Cassette.read(input)
+      render_session_outputs(session, [], base_dir: Dir.pwd, theme: @options[:theme] || "macos", render: {})
+    end
+
+    def build_run_parser(record:)
+      OptionParser.new do |opts|
+        opts.banner = "Usage: shellfie #{record ? "record" : "run"} SESSION.yml [options]"
+        session_output_options(opts)
+        opts.on("--cassette PATH", "Write an offline replay cassette") { |path| @options[:cassette] = path }
+        opts.on("--yaml PATH", "Write an editable compose recording") { |path| @options[:yaml] = path } if record
+      end
+    end
+
+    def build_replay_parser
+      OptionParser.new do |opts|
+        opts.banner = "Usage: shellfie replay SESSION.json [options]"
+        session_output_options(opts)
+        opts.on("-t", "--theme NAME", "Render theme") { |theme| @options[:theme] = theme }
+      end
+    end
+
+    def session_output_options(opts)
+      opts.on("-o", "--output PATH", "Output path (overrides config outputs)") { |path| @options[:output] = path }
+      opts.on("--format FORMAT", "Output format") { |format| @options[:format] = parse_format(format) }
+      opts.on("-a", "--animate", "Render the captured timeline") { @options[:animate] = true }
+      opts.on("--force", "Overwrite existing outputs") { @options[:force] = true }
+      opts.on("--quiet", "Suppress generated paths") { @options[:quiet] = true }
+    end
+
+    def render_session_outputs(session, configured_outputs, base_dir:, theme:, render:, resolved: nil)
+      resolved ||= resolve_session_outputs(configured_outputs, base_dir: base_dir)
+      resolved.each do |path, format, output|
+        ensure_output_writable!(path)
+        animate = output.fetch(:animate, @options[:animate] || CLIGenerate::ANIMATED_FORMATS.include?(format))
+        capture = output[:capture]
+        captured_lines = capture && (session.captures[capture] || session.captures[capture.to_sym])
+        raise ConfigError, "Unknown capture: #{capture}" if capture && !captured_lines
+
+        config = session.render_config(theme: theme, options: render, animated: animate, lines: captured_lines)
+        original_options = @options
+        @options = @options.merge(output.slice(:scale, :shadow, :transparent))
+        write_rendered_output(config, path, animate: animate, format: format)
+      ensure
+        @options = original_options
+      end
+    end
+
+    def resolve_session_outputs(configured_outputs, base_dir:, allow_empty: false)
+      outputs = if @options[:output]
+                  [{ path: @options[:output], format: @options[:format], animate: @options[:animate] }]
+                else
+                  configured_outputs
+                end
+      raise ConfigError, "Output is required with -o or outputs in the session config" if outputs.empty? && !allow_empty
+
+      resolved = outputs.map do |output|
+        path = output[:path] == "-" ? "-" : File.expand_path(output[:path], base_dir)
+        format = (output[:format] || @options[:format] || File.extname(path).delete_prefix(".")).to_s.downcase
+        unless CLIGenerate::SUPPORTED_FORMATS.include?(format)
+          raise ValidationError, "format must be one of: #{CLIGenerate::SUPPORTED_FORMATS.join(", ")}"
+        end
+        animate = output[:animate].nil? ? (@options[:animate] || CLIGenerate::ANIMATED_FORMATS.include?(format)) : output[:animate]
+        validate_output_mode!(format, animate)
+        raise ConfigError, "Captured screens cannot be rendered as animations" if output[:capture] && animate
+
+        [path, format, output.merge(animate: animate)]
+      end
+      duplicate = resolved.group_by(&:first).find { |_path, items| items.size > 1 }&.first
+      raise ConfigError, "Multiple outputs resolve to the same path: #{duplicate}" if duplicate
+
+      resolved
+    end
+
+    def preflight_session_artifacts!(resolved_outputs, cassette_path, yaml_path, input_path: nil)
+      metadata = [cassette_path, yaml_path].compact
+      raise ConfigError, "Cassette and YAML outputs cannot be stdout" if metadata.include?("-")
+
+      paths = resolved_outputs.filter_map { |path, _format, _output| path unless path == "-" } +
+              metadata.map { |path| File.expand_path(path) }
+      collision = paths.group_by { |path| canonical_output_path(path) }.find { |_path, items| items.size > 1 }&.first
+      raise ConfigError, "Session artifacts resolve to the same path: #{collision}" if collision
+      canonical_paths = paths.map { |path| canonical_output_path(path) }
+      sequence_dirs = resolved_outputs.filter_map do |path, format, _output|
+        canonical_output_path(path) if format == "png-sequence"
+      end
+      nested = sequence_dirs.find do |directory|
+        canonical_paths.any? { |path| path != directory && (path_within?(path, directory) || path_within?(directory, path)) }
+      end
+      raise ConfigError, "Session artifact conflicts with a PNG sequence directory: #{nested}" if nested
+      if input_path && paths.any? { |path| canonical_output_path(path) == canonical_output_path(input_path) }
+        raise ConfigError, "Session artifact conflicts with the session configuration: #{input_path}"
+      end
+      resolved_outputs.each do |path, format, _output|
+        if format == "png-sequence" && Dir.exist?(path) && !replaceable_png_sequence_directory?(path)
+          raise FileSystemError, "Refusing to replace a non-Shellfie directory: #{path}"
+        end
+      end
+
+      paths.each { |path| ensure_output_writable!(path) }
+      if resolved_outputs.any? { |_path, format, output| format == "mp4" && (@options[:transparent] || output[:transparent]) }
+        raise ConfigError, "MP4 output does not support transparency"
+      end
+    end
+
+    def write_cassette(path, session)
+      FileUtils.mkdir_p(File.dirname(path)) unless File.dirname(path) == "."
+      if File.exist?(path) && !@options[:force]
+        raise FileSystemError, "Cassette already exists: #{path} (use --force to overwrite)"
+      end
+
+      Cassette.write(path, session)
+      $stderr.puts "Recorded: #{path}" unless @options[:quiet]
+    end
+
+    def write_recording(path, session)
+      FileUtils.mkdir_p(File.dirname(path)) unless File.dirname(path) == "."
+      if File.exist?(path) && !@options[:force]
+        raise FileSystemError, "Recording already exists: #{path} (use --force to overwrite)"
+      end
+
+      OutputWriter.write(path, extension: "yml") { |temporary_path| File.write(temporary_path, YAML.dump(session.compose_hash)) }
+      $stderr.puts "Recorded: #{path}" unless @options[:quiet]
+    end
+  end
+end

data/lib/shellfie/config.rb

@@ -14,6 +14,8 @@ module Shellfie
     VALID_CURSOR_STYLES = %w[block bar underline].freeze
     VALID_PALETTES = %w[global adaptive theme].freeze
     VALID_SCROLL_EASINGS = %w[linear ease_in ease_out ease_in_out].freeze
+    VALID_APNG_PREDICTIONS = %w[none sub up avg paeth mixed].freeze
+    VALID_ANIMATION_DIRECTIONS = %w[forward reverse ping_pong].freeze
 
     class << self
       def deep_dup(value)
@@ -55,7 +57,7 @@ module Shellfie
     DEFAULTS = deep_freeze(deep_dup(ConfigDefaults::VALUES))
 
     attr_reader :version, :theme, :window_theme, :color_scheme, :colors, :window_decoration, :title, :window, :font,
-                :lines, :animation, :frames, :headless, :cursor, :limits
+                :lines, :animation, :frames, :headless, :cursor, :limits, :source_paths
 
     def initialize(options = {})
       options = self.class.normalize_keys(options)
@@ -75,6 +77,7 @@ module Shellfie
       @cursor = merged[:cursor]
       @limits = merged[:limits]
       @headless = merged[:headless] || false
+      @source_paths = Array(options[:source_paths])
 
       validate!
       freeze_state!
@@ -139,6 +142,7 @@ module Shellfie
       @lines = self.class.deep_freeze(@lines)
       @frames = self.class.deep_freeze(@frames)
       @title.freeze
+      @source_paths = self.class.deep_freeze(@source_paths)
       @theme.freeze
       @window_theme.freeze if @window_theme
       @color_scheme.freeze if @color_scheme

data/lib/shellfie/config_defaults.rb

@@ -11,6 +11,7 @@ module Shellfie
       window_decoration: {},
       window: {
         width: 600,
+        height: nil,
         padding: 20,
         opacity: 1.0,
         visible_lines: nil,
@@ -22,6 +23,9 @@ module Shellfie
         exact_size: false,
         trim: false,
         tab_width: 8,
+        ambiguous_width: 1,
+        osc_policy: "ignore",
+        graphics_policy: "ignore",
         ansi_state: "persistent",
         background_gradient: nil,
         scroll_offset: 0.0
@@ -40,13 +44,26 @@ module Shellfie
         cursor_blink: true,
         loop: false,
         typing_jitter: 0.0,
+        seed: 0,
         typing_chunk_size: 1,
         output_delay: 0,
         final_delay: 1_000,
         max_frames: nil,
         dither: true,
         palette: "global",
-        scroll_easing: "linear"
+        gif_colors: 256,
+        gif_optimize: true,
+        webp_lossless: true,
+        webp_quality: 100,
+        webp_method: 4,
+        webp_near_lossless: 100,
+        apng_prediction: "paeth",
+        loop_count: nil,
+        direction: "forward",
+        loop_offset: 0,
+        scroll_easing: "linear",
+        framerate: 30,
+        playback_speed: 1.0
       },
       cursor: {
         style: "block",
@@ -57,7 +74,9 @@ module Shellfie
         max_frames: 500,
         max_render_frames: 2_000,
         max_characters: 200_000,
-        max_pixels: 50_000_000
+        max_pixels: 50_000_000,
+        max_total_pixels: 2_000_000_000,
+        max_temp_bytes: 8_000_000_000
       }
     }.freeze
   end

data/lib/shellfie/config_validation.rb

@@ -2,10 +2,22 @@
 
 module Shellfie
   module ConfigValidation
+    RESOURCE_LIMIT_CEILINGS = {
+      max_lines: 10_000,
+      max_frames: 500,
+      max_render_frames: 2_000,
+      max_characters: 200_000,
+      max_pixels: 50_000_000,
+      max_total_pixels: 2_000_000_000,
+      max_temp_bytes: 8_000_000_000
+    }.freeze
+    MAX_FRAME_DELAY_MS = 86_400_000
+
     def validate!
       validate_version!
       validate_theme!
       validate_window!
+      validate_appearance!
       validate_font!
       validate_animation!
       validate_cursor!
@@ -45,13 +57,18 @@ module Shellfie
       validate_window_theme!
       validate_color_scheme!
       validate_positive_integer!(@window[:width], "window.width")
+      validate_optional_positive_integer!(@window[:height], "window.height")
       validate_non_negative_integer!(@window[:padding], "window.padding")
+      raise ValidationError, "window.padding must be at most 40" if @window[:padding] > 40
       %i[opacity scroll_offset].each { |key| validate_number_range!(@window[key], "window.#{key}", 0.0, 1.0) }
       validate_optional_positive_integer!(@window[:visible_lines], "window.visible_lines")
       validate_optional_positive_integer!(@window[:max_lines], "window.max_lines")
       validate_optional_positive_integer!(@window[:max_height], "window.max_height")
       validate_optional_non_negative_integer!(@window[:margin], "window.margin")
       validate_positive_integer!(@window[:tab_width], "window.tab_width")
+      validate_inclusion!(@window[:ambiguous_width], "window.ambiguous_width", [1, 2])
+      validate_inclusion!(@window[:osc_policy], "window.osc_policy", %w[ignore preserve apply])
+      validate_inclusion!(@window[:graphics_policy], "window.graphics_policy", %w[ignore error])
       validate_boolean!(@window[:wrap], "window.wrap")
       validate_boolean!(@window[:exact_size], "window.exact_size")
       validate_boolean!(@window[:trim], "window.trim")
@@ -61,6 +78,29 @@ module Shellfie
       validate_minimum_width!
     end
 
+    def validate_appearance!
+      raise ValidationError, "title must be a string" unless @title.is_a?(String)
+      unless @colors.values.all?(String)
+        raise ValidationError, "colors values must be strings"
+      end
+      %i[title_bar_height button_size button_spacing button_width corner_radius].each do |key|
+        next unless @window_decoration.key?(key)
+
+        validate_non_negative_number!(@window_decoration[key], "window_decoration.#{key}")
+      end
+      return unless @window_decoration.key?(:shadow)
+
+      shadow = @window_decoration[:shadow]
+      raise ValidationError, "window_decoration.shadow must be a mapping" unless shadow.is_a?(Hash)
+      validate_non_negative_number!(shadow[:blur], "window_decoration.shadow.blur") if shadow.key?(:blur)
+      %i[offset_x offset_y].each do |key|
+        validate_finite_number!(shadow[key], "window_decoration.shadow.#{key}") if shadow.key?(key)
+      end
+      if shadow.key?(:color) && !shadow[:color].is_a?(String)
+        raise ValidationError, "window_decoration.shadow.color must be a string"
+      end
+    end
+
     def validate_font!
       validate_optional_string!(@font[:family], "font.family")
       validate_optional_string!(@font[:fallback_family], "font.fallback_family")
@@ -74,15 +114,43 @@ module Shellfie
       validate_non_negative_integer!(@animation[:typing_speed], "animation.typing_speed")
       validate_non_negative_integer!(@animation[:command_delay], "animation.command_delay")
       validate_number_range!(@animation[:typing_jitter], "animation.typing_jitter", 0.0, 1.0)
+      validate_non_negative_integer!(@animation[:seed], "animation.seed")
+      raise ValidationError, "animation.seed must be at most 2147483647" if @animation[:seed] > 2_147_483_647
       validate_positive_integer!(@animation[:typing_chunk_size], "animation.typing_chunk_size")
       validate_non_negative_integer!(@animation[:output_delay], "animation.output_delay")
       validate_non_negative_integer!(@animation[:final_delay], "animation.final_delay")
+      %i[typing_speed command_delay output_delay final_delay].each do |key|
+        if @animation[key] > MAX_FRAME_DELAY_MS
+          raise ValidationError, "animation.#{key} must be at most #{MAX_FRAME_DELAY_MS}"
+        end
+      end
       validate_optional_positive_integer!(@animation[:max_frames], "animation.max_frames")
       validate_boolean!(@animation[:cursor_blink], "animation.cursor_blink")
       validate_boolean!(@animation[:loop], "animation.loop")
       validate_boolean!(@animation[:dither], "animation.dither")
+      validate_boolean!(@animation[:gif_optimize], "animation.gif_optimize")
+      validate_boolean!(@animation[:webp_lossless], "animation.webp_lossless")
       validate_inclusion!(@animation[:palette], "animation.palette", self.class::VALID_PALETTES)
+      validate_inclusion!(@animation[:apng_prediction], "animation.apng_prediction", self.class::VALID_APNG_PREDICTIONS)
+      validate_positive_integer!(@animation[:gif_colors], "animation.gif_colors")
+      raise ValidationError, "animation.gif_colors must be between 2 and 256" unless @animation[:gif_colors].between?(2, 256)
+      %i[webp_quality webp_near_lossless].each do |key|
+        validate_non_negative_integer!(@animation[key], "animation.#{key}")
+        raise ValidationError, "animation.#{key} must be at most 100" if @animation[key] > 100
+      end
+      validate_non_negative_integer!(@animation[:webp_method], "animation.webp_method")
+      raise ValidationError, "animation.webp_method must be at most 6" if @animation[:webp_method] > 6
+      unless @animation[:loop_count].nil?
+        validate_non_negative_integer!(@animation[:loop_count], "animation.loop_count")
+        raise ValidationError, "animation.loop_count must be at most 65535" if @animation[:loop_count] > 65_535
+      end
       validate_inclusion!(@animation[:scroll_easing], "animation.scroll_easing", self.class::VALID_SCROLL_EASINGS)
+      validate_inclusion!(@animation[:direction], "animation.direction", self.class::VALID_ANIMATION_DIRECTIONS)
+      validate_non_negative_integer!(@animation[:loop_offset], "animation.loop_offset")
+      validate_positive_integer!(@animation[:framerate], "animation.framerate")
+      validate_positive_number!(@animation[:playback_speed], "animation.playback_speed")
+      raise ValidationError, "animation.framerate must be at most 120" if @animation[:framerate] > 120
+      raise ValidationError, "animation.playback_speed must be at most 100" if @animation[:playback_speed] > 100
     end
 
     def validate_cursor!
@@ -94,11 +162,21 @@ module Shellfie
     def validate_lines!
       raise ValidationError, "lines must be an Array" unless @lines.is_a?(Array)
       raise ValidationError, "frames must be an Array" unless @frames.is_a?(Array)
+      @frames.each_with_index do |frame, index|
+        unless frame.respond_to?(:delay) && frame.delay.is_a?(Integer) && frame.delay.between?(0, MAX_FRAME_DELAY_MS)
+          raise ValidationError, "frames[#{index}].delay must be between 0 and #{MAX_FRAME_DELAY_MS}"
+        end
+      end
     end
 
     def validate_limits!
+      unknown = @limits.keys - RESOURCE_LIMIT_CEILINGS.keys
+      raise ValidationError, "Unknown limits key(s): #{unknown.join(", ")}" unless unknown.empty?
+
       @limits.each_key do |key|
         validate_positive_integer!(@limits[key], "limits.#{key}")
+        ceiling = RESOURCE_LIMIT_CEILINGS.fetch(key)
+        raise ValidationError, "limits.#{key} must be at most #{ceiling}" if @limits[key] > ceiling
       end
     end
 
@@ -137,10 +215,9 @@ module Shellfie
     end
 
     def validate_minimum_width!
-      min_width = [120, (@window[:padding] * 2) + 40].max
-      return if @window[:width] >= min_width
+      return if @window[:width] >= 120
 
-      raise ValidationError, "window.width must be at least #{min_width}px for the configured padding"
+      raise ValidationError, "window.width must be at least 120px"
     end
 
     def validate_optional_positive_integer!(value, name)
@@ -174,11 +251,23 @@ module Shellfie
     end
 
     def validate_positive_number!(value, name)
-      return if value.is_a?(Numeric) && value.positive?
+      return if value.is_a?(Numeric) && value.finite? && value.positive?
 
       raise ValidationError, "#{name} must be a positive number"
     end
 
+    def validate_non_negative_number!(value, name)
+      return if value.is_a?(Numeric) && value.finite? && value >= 0
+
+      raise ValidationError, "#{name} must be a non-negative number"
+    end
+
+    def validate_finite_number!(value, name)
+      return if value.is_a?(Numeric) && value.finite?
+
+      raise ValidationError, "#{name} must be a finite number"
+    end
+
     def validate_number_range!(value, name, min, max)
       return if value.is_a?(Numeric) && value >= min && value <= max