shellfie 0.1.1 → 1.1.0

data/lib/shellfie/cli_info.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+require "json"
+require "optparse"
+require "yaml"
+require "cgi/escape"
+
+module Shellfie
+  module CLIInfo
+    private
+
+    def run_init
+      puts <<~YAML
+        # Shellfie configuration file
+        version: 1
+        theme: macos
+        title: "Terminal — zsh"
+
+        window:
+          width: 600
+          padding: 20
+
+        lines:
+          - prompt: "$ "
+            command: "gem install shellfie"
+
+          - output: |
+              Fetching shellfie-#{VERSION}.gem
+              Successfully installed shellfie-#{VERSION}
+              1 gem installed
+
+          - prompt: "$ "
+            command: "shellfie --version"
+
+          - output: "shellfie #{VERSION}"
+      YAML
+    end
+
+    def run_themes
+      puts "Available themes:"
+      puts
+      ThemeRegistry.available_themes.each { |theme| puts "  #{theme}" }
+      puts
+      puts "Available color schemes:"
+      ThemeRegistry.available_color_schemes.each { |scheme| puts "  #{scheme}" }
+      puts
+      puts "Use: shellfie generate config.yml -o output.png -t THEME_NAME"
+    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}"
+      puts "  Mode: #{config.animated? ? "animated" : "static"}"
+      puts "  Lines: #{config.lines.size}" if config.static?
+      puts "  Source frames: #{config.frames.size}" if config.animated?
+      puts "  Estimated render frames: #{AnimationFrameBuilder.new(config).build.size}" if config.animated?
+      geometry = Renderer.new(config).estimate
+      puts "  Estimated size: #{geometry[:canvas_width]}x#{geometry[:canvas_height]}"
+      puts "  Logical size: #{geometry[:logical_width]}x#{geometry[:logical_height]} @#{geometry[:scale]}x"
+    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]}"
+      puts "  Title: #{info[:config][:title]}"
+      puts "  Mode: #{info[:config][:frames].empty? ? "static" : "animated"}"
+      puts "  Lines: #{info[:config][:lines].size}"
+      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
+      failed = false
+      DependencyChecker.doctor.each do |check|
+        status = check[:ok] ? "ok" : "fail"
+        failed ||= !check[:ok]
+        puts "#{status.ljust(4)} #{check[:name]}: #{check[:detail]}"
+      end
+      exit 4 if failed
+    end
+
+    def run_version
+      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 - Deterministic terminal visual compiler
+
+        Usage: shellfie <command> [options]
+               shf <command> [options]
+
+        Commands:
+          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
+          inspect     Print resolved config and estimated image size
+          doctor      Check dependencies and local environment
+          version     Show version
+          help        Show this help
+
+        Generate Options:
+          -o, --output PATH      Output path/template (defaults beside input)
+          -t, --theme NAME       Override theme (macos, ubuntu, windows)
+          -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
+          --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        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
+          shellfie generate config.yml -o demo.gif --animate
+          shellfie generate config.yml -o retina.png --scale 2
+          shellfie init > my-config.yml
+          shellfie themes
+
+          # Short form
+          shf generate config.yml -o terminal.png
+          shf init > config.yml
+      HELP
+    end
+  end
+end

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

@@ -1,40 +1,86 @@
 # frozen_string_literal: true
 
+require_relative "config_validation"
+require_relative "config_defaults"
+require_relative "errors"
+require_relative "theme_registry"
+
 module Shellfie
   class Config
-    DEFAULTS = {
-      theme: "macos",
-      window: {
-        width: 600,
-        padding: 20,
-        opacity: 1.0,
-        visible_lines: nil
-      },
-      font: {
-        family: "Monaco",
-        size: 14,
-        line_height: 1.4
-      },
-      animation: {
-        typing_speed: 80,
-        command_delay: 500,
-        cursor_blink: true,
-        loop: false
-      }
-    }.freeze
+    include ConfigValidation
+
+    VALID_THEMES = ThemeRegistry.available_themes.freeze
+    VALID_OVERFLOW_MODES = %w[clip wrap scroll].freeze
+    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)
+        case value
+        when Hash
+          value.each_with_object({}) { |(key, nested_value), result| result[key] = deep_dup(nested_value) }
+        when Array
+          value.map { |nested_value| deep_dup(nested_value) }
+        else
+          value
+        end
+      end
+
+      def deep_freeze(value)
+        case value
+        when Hash
+          value.each_value { |nested_value| deep_freeze(nested_value) }
+        when Array
+          value.each { |nested_value| deep_freeze(nested_value) }
+        end
+        value.freeze
+      end
+
+      def normalize_keys(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, nested_value), result|
+            normalized_key = key.is_a?(String) ? key.to_sym : key
+            result[normalized_key] = normalize_keys(nested_value)
+          end
+        when Array
+          value.map { |nested_value| normalize_keys(nested_value) }
+        else
+          value
+        end
+      end
+    end
+
+    DEFAULTS = deep_freeze(deep_dup(ConfigDefaults::VALUES))
 
-    attr_reader :theme, :title, :window, :font, :lines, :animation, :frames, :headless
+    attr_reader :version, :theme, :window_theme, :color_scheme, :colors, :window_decoration, :title, :window, :font,
+                :lines, :animation, :frames, :headless, :cursor, :limits, :source_paths
 
     def initialize(options = {})
+      options = self.class.normalize_keys(options)
       merged = merge_defaults(options)
+      @version = merged[:version]
       @theme = merged[:theme]
+      @window_theme = merged[:window_theme]
+      @color_scheme = merged[:color_scheme]
+      @colors = merged[:colors]
+      @window_decoration = merged[:window_decoration]
       @title = merged[:title] || "Terminal"
       @window = merged[:window]
       @font = merged[:font]
       @lines = merged[:lines] || []
       @animation = merged[:animation]
       @frames = merged[:frames] || []
-      @headless = options[:headless] || false
+      @cursor = merged[:cursor]
+      @limits = merged[:limits]
+      @headless = merged[:headless] || false
+      @source_paths = Array(options[:source_paths])
+
+      validate!
+      freeze_state!
     end
 
     def static?
@@ -45,21 +91,62 @@ module Shellfie
       !static?
     end
 
+    def to_h
+      {
+        version: version,
+        theme: theme,
+        window_theme: window_theme,
+        color_scheme: color_scheme,
+        colors: colors,
+        window_decoration: window_decoration,
+        title: title,
+        window: window,
+        font: font,
+        animation: animation,
+        cursor: cursor,
+        limits: limits,
+        headless: headless,
+        lines: lines.map(&:to_h),
+        frames: frames.map(&:to_h)
+      }
+    end
+
     private
 
     def merge_defaults(options)
-      result = {}
+      result = self.class.deep_dup(DEFAULTS)
       DEFAULTS.each do |key, value|
+        next unless options.key?(key)
+
         result[key] = if value.is_a?(Hash) && options[key].is_a?(Hash)
-                        value.merge(options[key])
+                        result[key].merge(options[key])
                       else
-                        options.key?(key) ? options[key] : value
+                        self.class.deep_dup(options[key])
                       end
       end
       result[:title] = options[:title]
       result[:lines] = options[:lines]
       result[:frames] = options[:frames]
+      result[:headless] = options[:headless] if options.key?(:headless)
       result
     end
+
+    def freeze_state!
+      @colors = self.class.deep_freeze(@colors)
+      @window_decoration = self.class.deep_freeze(@window_decoration)
+      @window = self.class.deep_freeze(@window)
+      @font = self.class.deep_freeze(@font)
+      @animation = self.class.deep_freeze(@animation)
+      @cursor = self.class.deep_freeze(@cursor)
+      @limits = self.class.deep_freeze(@limits)
+      @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
+      freeze
+    end
   end
 end

data/lib/shellfie/config_defaults.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Shellfie
+  module ConfigDefaults
+    VALUES = {
+      version: 1,
+      theme: "macos",
+      window_theme: nil,
+      color_scheme: nil,
+      colors: {},
+      window_decoration: {},
+      window: {
+        width: 600,
+        height: nil,
+        padding: 20,
+        opacity: 1.0,
+        visible_lines: nil,
+        max_lines: nil,
+        max_height: nil,
+        wrap: false,
+        overflow: "clip",
+        margin: nil,
+        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
+      },
+      font: {
+        family: "Monaco",
+        size: 14,
+        line_height: 1.4,
+        fallback_family: nil,
+        italic_family: nil,
+        emoji_family: nil
+      },
+      animation: {
+        typing_speed: 80,
+        command_delay: 500,
+        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",
+        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",
+        color: nil
+      },
+      limits: {
+        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
+  end
+end