shellfie 1.0.0 → 1.1.0

data/lib/shellfie/text_metrics.rb

@@ -1,23 +1,64 @@
 # frozen_string_literal: true
 
+require "rbconfig"
+
 module Shellfie
   module TextMetrics
+    UNICODE_VERSION = RbConfig::CONFIG["UNICODE_VERSION"] || "unknown"
+    WIDTH_TABLE_VERSION = "1"
+    AMBIGUOUS_RANGES = [
+      0x00a1..0x00a1, 0x00a4..0x00a4, 0x00a7..0x00a8, 0x00aa..0x00aa, 0x00ad..0x00ae,
+      0x00b0..0x00b4, 0x00b6..0x00ba, 0x00bc..0x00bf, 0x00c6..0x00c6, 0x00d0..0x00d0,
+      0x00d7..0x00d8, 0x00de..0x00e1, 0x00e6..0x00e6, 0x00e8..0x00ea, 0x00ec..0x00ed,
+      0x00f0..0x00f0, 0x00f2..0x00f3, 0x00f7..0x00fa, 0x00fc..0x00fc, 0x00fe..0x00fe,
+      0x0101..0x0101, 0x0111..0x0113, 0x011b..0x011b, 0x0126..0x0127, 0x012b..0x012b,
+      0x0131..0x0133, 0x0138..0x0138, 0x013f..0x0142, 0x0144..0x0144, 0x0148..0x014b,
+      0x014d..0x014d, 0x0152..0x0153, 0x0166..0x0167, 0x016b..0x016b, 0x01ce..0x01dc,
+      0x0251..0x0251, 0x0261..0x0261, 0x02c4..0x02c4, 0x02c7..0x02c7, 0x02c9..0x02cb,
+      0x02cd..0x02d0, 0x02d8..0x02db, 0x02dd..0x02df, 0x0391..0x03a1, 0x03a3..0x03a9,
+      0x03b1..0x03c1, 0x03c3..0x03c9, 0x0401..0x0401, 0x0410..0x044f, 0x0451..0x0451,
+      0x2010..0x2010, 0x2013..0x2016, 0x2018..0x2019, 0x201c..0x201d, 0x2020..0x2022,
+      0x2024..0x2026, 0x2030..0x2030, 0x2032..0x2033, 0x2035..0x2035, 0x203b..0x203e,
+      0x2074..0x2074, 0x207f..0x207f, 0x2081..0x2084, 0x20ac..0x20ac, 0x2103..0x2103,
+      0x2105..0x2105, 0x2109..0x2109, 0x2113..0x2113, 0x2116..0x2116, 0x2121..0x2122,
+      0x2126..0x2126, 0x212b..0x212b, 0x2153..0x2154, 0x215b..0x215e, 0x2160..0x216b,
+      0x2170..0x2179, 0x2189..0x2189, 0x2190..0x2199, 0x21b8..0x21b9, 0x21d2..0x21d4,
+      0x21e7..0x21e7, 0x2200..0x2200, 0x2202..0x2203, 0x2207..0x2208, 0x220b..0x220b,
+      0x220f..0x2211, 0x2215..0x2215, 0x221a..0x221a, 0x221d..0x2220, 0x2223..0x2223,
+      0x2225..0x2225, 0x2227..0x222c, 0x222e..0x222e, 0x2234..0x2237, 0x223c..0x223d,
+      0x2248..0x2248, 0x224c..0x224c, 0x2252..0x2252, 0x2260..0x2261, 0x2264..0x2267,
+      0x226a..0x226b, 0x226e..0x226f, 0x2282..0x2283, 0x2286..0x2287, 0x2295..0x2295,
+      0x2299..0x2299, 0x22a5..0x22a5, 0x22bf..0x22bf, 0x2312..0x2312, 0x2460..0x254b,
+      0x2550..0x2573, 0x2580..0x258f, 0x2592..0x2595, 0x25a0..0x25a1, 0x25a3..0x25a9,
+      0x25b2..0x25b3, 0x25b6..0x25b7, 0x25bc..0x25bd, 0x25c0..0x25c1, 0x25c6..0x25c8,
+      0x25cb..0x25cb, 0x25ce..0x25d1, 0x25e2..0x25e5, 0x25ef..0x25ef, 0x2605..0x2606,
+      0x2609..0x2609, 0x260e..0x260f, 0x261c..0x261c, 0x261e..0x261e, 0x2640..0x2640,
+      0x2642..0x2642, 0x2660..0x2661, 0x2663..0x2665, 0x2667..0x266a, 0x266c..0x266d,
+      0x266f..0x266f, 0xe000..0xf8ff, 0xfffd..0xfffd
+    ].freeze
+
     module_function
 
-    def cell_width(text)
-      text.to_s.each_char.sum { |char| char_width(char) }
+    def graphemes(text)
+      string = text.to_s.dup
+      string.force_encoding(Encoding::UTF_8)
+      string.scrub.scan(/\X/)
     end
 
-    def pixel_width(text, font_size)
-      (cell_width(text) * font_size * 0.6).ceil
+    def cell_width(text, ambiguous_width: 1)
+      graphemes(text).sum { |grapheme| grapheme_width(grapheme, ambiguous_width: ambiguous_width) }
     end
 
-    def take_cells(text, max_cells)
+    def pixel_width(text, font_size, ambiguous_width: 1)
+      (cell_width(text, ambiguous_width: ambiguous_width) * font_size * 0.6).ceil
+    end
+
+    def take_cells(text, max_cells, ambiguous_width: 1)
       result = +""
       used_cells = 0
 
-      text.to_s.each_char do |char|
-        width = char_width(char)
+      graphemes(text).each do |char|
+        width = grapheme_width(char, ambiguous_width: ambiguous_width)
         break if used_cells + width > max_cells
 
         result << char
@@ -27,10 +68,10 @@ module Shellfie
       result
     end
 
-    def drop_cells(text, cells_to_drop)
+    def drop_cells(text, cells_to_drop, ambiguous_width: 1)
       used_cells = 0
-      text.to_s.each_char.with_object(+"") do |char, result|
-        width = char_width(char)
+      graphemes(text).each_with_object(+"") do |char, result|
+        width = grapheme_width(char, ambiguous_width: ambiguous_width)
         if used_cells < cells_to_drop
           used_cells += width
           next
@@ -40,15 +81,15 @@ module Shellfie
       end
     end
 
-    def split_cells(text, max_cells)
+    def split_cells(text, max_cells, ambiguous_width: 1)
       return [text.to_s] if max_cells <= 0
 
       chunks = []
       current = +""
       used_cells = 0
 
-      text.to_s.each_char do |char|
-        width = char_width(char)
+      graphemes(text).each do |char|
+        width = grapheme_width(char, ambiguous_width: ambiguous_width)
         if used_cells.positive? && used_cells + width > max_cells
           chunks << current
           current = +""
@@ -63,21 +104,33 @@ module Shellfie
       chunks
     end
 
-    def char_width(char)
+    def char_width(char, ambiguous_width: 1)
       codepoint = char.ord
       return 0 if combining?(codepoint)
       return 0 if codepoint < 32 || codepoint == 0x7f
       return 2 if wide?(codepoint)
+      return ambiguous_width if ambiguous?(codepoint)
 
       1
     end
 
+    def grapheme_width(grapheme, ambiguous_width: 1)
+      codepoints = grapheme.codepoints
+      return 0 if codepoints.empty? || codepoints.all? { |codepoint| combining?(codepoint) }
+      return 2 if grapheme.include?("\u200d") || grapheme.include?("\ufe0f") || grapheme.include?("\u20e3") ||
+                  grapheme.match?(/[\u{1f1e6}-\u{1f1ff}]{2}/)
+
+      codepoints.map { |codepoint| char_width(codepoint.chr(Encoding::UTF_8), ambiguous_width: ambiguous_width) }.max || 0
+    end
+
     def combining?(codepoint)
       (0x0300..0x036f).cover?(codepoint) ||
         (0x1ab0..0x1aff).cover?(codepoint) ||
         (0x1dc0..0x1dff).cover?(codepoint) ||
         (0x20d0..0x20ff).cover?(codepoint) ||
-        (0xfe20..0xfe2f).cover?(codepoint)
+        (0xfe00..0xfe0f).cover?(codepoint) ||
+        (0xfe20..0xfe2f).cover?(codepoint) ||
+        (0xe0100..0xe01ef).cover?(codepoint)
     end
 
     def wide?(codepoint)
@@ -92,5 +145,11 @@ module Shellfie
         (0xffe0..0xffe6).cover?(codepoint) ||
         (0x1f300..0x1faff).cover?(codepoint)
     end
+
+    def ambiguous?(codepoint)
+      return false if codepoint < 0x00a1
+
+      AMBIGUOUS_RANGES.any? { |range| range.cover?(codepoint) }
+    end
   end
 end

data/lib/shellfie/transcript_renderer.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "animation_frame_builder"
+require_relative "ansi_parser"
+require_relative "output_writer"
+
+module Shellfie
+  class TranscriptRenderer
+    def initialize(config)
+      @config = config
+    end
+
+    def render(output_path, format:, io: nil)
+      OutputWriter.write(output_path, extension: format, io: io) do |temporary_path|
+        value = case format
+                when "json" then JSON.pretty_generate(document)
+                when "ansi" then ansi_text
+                when "asciicast", "cast" then asciicast
+                else text
+                end
+        File.write(temporary_path, value)
+      end
+    end
+
+    private
+
+    attr_reader :config
+
+    def final_lines
+      return config.lines if config.frames.empty?
+
+      AnimationFrameBuilder.new(config).build.last[:lines]
+    end
+
+    def text
+      final_lines.flat_map do |line|
+        command = "#{line.prompt}#{line.command}" if line.prompt || line.command
+        [command, line.output].compact.map { |value| plain_text(value) }
+      end.join("\n") + "\n"
+    end
+
+    def ansi_text
+      final_lines.flat_map do |line|
+        command = "#{line.prompt}#{line.command}" if line.prompt || line.command
+        [command, line.output].compact
+      end.join("\n") + "\n"
+    end
+
+    def asciicast
+      width = [config.window[:width].to_i / 8, 1].max
+      header = { version: 2, width: width, height: [final_lines.size, 1].max, env: { "TERM" => "xterm-256color" } }
+      elapsed = 0.0
+      source = config.frames.empty? ? [{ text: ansi_text, delay: 0 }] : config.frames.map do |frame|
+        { text: frame_to_ansi(frame), delay: frame.delay }
+      end
+      events = source.map do |event|
+        value = [elapsed.round(6), "o", event[:text]]
+        elapsed += event[:delay].to_f / 1_000
+        value
+      end
+      ([JSON.generate(header)] + events.map { |event| JSON.generate(event) }).join("\n") + "\n"
+    end
+
+    def frame_to_ansi(frame)
+      command = "#{frame.prompt}#{frame.command}" if frame.prompt || frame.command
+      [command, frame.output].compact.join("\r\n") + "\r\n"
+    end
+
+    def document
+      {
+        version: 1,
+        title: config.title,
+        lines: final_lines.map { |line| plain_value(line.to_h) },
+        events: config.frames.map { |frame| plain_value(frame.to_h) }
+      }
+    end
+
+    def plain_value(value)
+      case value
+      when String then plain_text(value)
+      when Array then value.map { |item| plain_value(item) }
+      when Hash then value.transform_values { |item| plain_value(item) }
+      else value
+      end
+    end
+
+    def plain_text(value)
+      AnsiParser.new(state_mode: :line).parse(value.to_s).map(&:text).join
+    end
+  end
+end

data/lib/shellfie/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Shellfie
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/lib/shellfie/yaml_safety.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require "yaml"
+
+module Shellfie
+  module YamlSafety
+    MAX_DEPTH = 100
+    MAX_NODES = 100_000
+
+    module_function
+
+    def annotate_validation_error(error, documents, provenance: {})
+      if (target = validation_path(error.message)) && (origin = provenance[target])
+        path, local_path = origin
+        content = documents.assoc(path)&.last
+        if content && (location = location_for_path(content, local_path))
+          return error.class.new("#{path}:#{location[0]}:#{location[1]}: #{error.message}")
+        end
+      end
+
+      documents.each do |path, content|
+        next unless path && content
+
+        location = validation_location(content, error.message)
+        return error.class.new("#{path}:#{location[0]}:#{location[1]}: #{error.message}") if location
+      end
+
+      path = documents.first&.first
+      error.class.new(path ? "#{path}: #{error.message}" : error.message)
+    end
+
+    def read_file(path, max_bytes:, label: "Configuration")
+      raise ParseError, "#{label} file not found: #{path}" unless File.file?(path)
+
+      content = File.open(path, "rb") { |file| file.read(max_bytes + 1) }
+      raise ParseError, "#{label} file is too large: #{path} (max #{max_bytes} bytes)" if content.bytesize > max_bytes
+
+      content
+    end
+
+    def load_file(path, max_bytes:, label: "Configuration", symbolize_names: true)
+      value = YAML.safe_load(
+        read_file(path, max_bytes: max_bytes, label: label), symbolize_names: symbolize_names, aliases: true
+      )
+      validate_tree!(value)
+    rescue Psych::Exception => e
+      raise ParseError, "Invalid #{label.downcase} YAML syntax: #{e.message}"
+    end
+
+    def validate_tree!(value)
+      active = {}
+      nodes = 0
+      stack = [[value, 0, false]]
+
+      until stack.empty?
+        node, depth, leaving = stack.pop
+        next unless node.is_a?(Hash) || node.is_a?(Array)
+        if leaving
+          active.delete(node.object_id)
+          next
+        end
+
+        raise ParseError, "YAML aliases must not contain cycles" if active[node.object_id]
+        raise ParseError, "YAML nesting is too deep (max #{MAX_DEPTH})" if depth > MAX_DEPTH
+        nodes += 1
+        raise ParseError, "YAML structure is too large (max #{MAX_NODES} collections)" if nodes > MAX_NODES
+
+        active[node.object_id] = true
+        stack << [node, depth, true]
+        children = node.is_a?(Hash) ? node.flat_map { |key, nested| [key, nested] } : node
+        children.reverse_each { |child| stack << [child, depth + 1, false] }
+      end
+
+      value
+    end
+
+    def validation_location(content, message)
+      locations = {}
+      collect_locations(Psych.parse(content).root, [], locations)
+      target = validation_path(message)
+      return locations[target] if target && locations[target]
+
+      locations.sort_by { |path, _location| -path.size }.each do |path, location|
+        return location if message.include?(format_path(path))
+      end
+      nil
+    rescue Psych::Exception
+      nil
+    end
+
+    def location_for_path(content, path)
+      locations = {}
+      collect_locations(Psych.parse(content).root, [], locations)
+      locations[path] || locations[path[0...-1]]
+    rescue Psych::Exception
+      nil
+    end
+
+    def collect_locations(node, path, locations)
+      case node
+      when Psych::Nodes::Mapping
+        node.children.each_slice(2) do |key, value|
+          next unless key.respond_to?(:value)
+
+          child_path = path + [key.value.to_sym]
+          locations[child_path] = [key.start_line + 1, key.start_column + 1]
+          collect_locations(value, child_path, locations)
+        end
+      when Psych::Nodes::Sequence
+        node.children.each_with_index { |child, index| collect_locations(child, path + [index], locations) }
+      end
+    end
+
+    def validation_path(message)
+      if (match = /Unknown (.+?) key\(s\):\s*([^,\s]+)/.match(message))
+        prefix = match[1] == "configuration" ? [] : parse_path(match[1])
+        return prefix + [match[2].to_sym]
+      end
+
+      explicit = message[/\b(?:steps|outputs|frames|lines)\[\d+\](?:\.[a-z_]+)*|\b(?:terminal|render|window|font|animation|cursor|limits)\.[a-z_]+/]
+      return parse_path(explicit) if explicit
+
+      {
+        "Session config version" => [:version], "mode must" => [:mode], "Invalid theme" => [:theme],
+        "redaction" => [:redact], "requires" => [:requires], "terminal.env" => %i[terminal env],
+        "title must" => [:title], "headless must" => [:headless]
+      }.each { |fragment, path| return path if message.include?(fragment) }
+      nil
+    end
+
+    def parse_path(value)
+      value.to_s.scan(/[A-Za-z_][A-Za-z0-9_]*|\d+/).map { |part| part.match?(/\A\d+\z/) ? part.to_i : part.to_sym }
+    end
+
+    def format_path(path)
+      path.each_with_object(+"") do |part, result|
+        if part.is_a?(Integer)
+          result << "[#{part}]"
+        else
+          result << "." unless result.empty?
+          result << part.to_s
+        end
+      end
+    end
+  end
+end

data/lib/shellfie.rb

@@ -16,6 +16,13 @@ module Shellfie
   autoload :ImageMagickCommandBuilder, File.expand_path("shellfie/image_magick_command_builder", __dir__)
   autoload :RenderChromeCache, File.expand_path("shellfie/render_chrome_cache", __dir__)
   autoload :Renderer, File.expand_path("shellfie/renderer", __dir__)
+  autoload :TerminalScreen, File.expand_path("shellfie/terminal_screen", __dir__)
+  autoload :TranscriptRenderer, File.expand_path("shellfie/transcript_renderer", __dir__)
+  autoload :Cassette, File.expand_path("shellfie/cassette", __dir__)
+  autoload :Session, File.expand_path("shellfie/session", __dir__)
+  autoload :SessionConfig, File.expand_path("shellfie/session_config", __dir__)
+  autoload :SessionRunner, File.expand_path("shellfie/session_runner", __dir__)
+  autoload :ReproducibilityManifest, File.expand_path("shellfie/reproducibility_manifest", __dir__)
 
   class << self
     def parse(source)
@@ -41,7 +48,7 @@ module Shellfie
     def inspect_config(source, scale: 1, shadow: true)
       config = parse(source)
       geometry = Renderer.new(config).estimate(scale: scale, shadow: shadow)
-      { config: config.to_h, theme: config.theme, geometry: geometry }
+      { config: config.to_h, theme: config.theme, geometry: geometry, fonts: Renderer.new(config).font_info }
     end
   end
 end

data/schema/shellfie-v1.schema.json

@@ -0,0 +1,153 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://raw.githubusercontent.com/ydah/shellfie/main/schema/shellfie-v1.schema.json",
+  "title": "Shellfie compose configuration",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "version": { "const": 1 },
+    "include": { "oneOf": [{ "type": "string" }, { "type": "array", "items": { "type": "string" } }] },
+    "include_policy": { "enum": ["allow", "root"] },
+    "theme": { "enum": ["macos", "ubuntu", "windows", "custom"] },
+    "window_theme": { "enum": ["macos", "ubuntu", "windows"] },
+    "color_scheme": { "enum": ["dracula", "one_dark", "solarized_dark", "catppuccin_mocha", null] },
+    "colors": {
+      "type": "object",
+      "propertyNames": { "enum": ["background", "foreground", "title_bar", "title_text", "title_bar_border", "border", "selection", "black", "red", "green", "yellow", "blue", "magenta", "cyan", "white", "bright_black", "bright_red", "bright_green", "bright_yellow", "bright_blue", "bright_magenta", "bright_cyan", "bright_white"] },
+      "additionalProperties": { "type": "string" }
+    },
+    "window_decoration": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "title_bar_height": { "type": "number", "minimum": 0 },
+        "button_size": { "type": "number", "minimum": 0 },
+        "button_spacing": { "type": "number", "minimum": 0 },
+        "button_width": { "type": "number", "minimum": 0 },
+        "corner_radius": { "type": "number", "minimum": 0 },
+        "shadow": {
+          "type": "object", "additionalProperties": false,
+          "properties": {
+            "blur": { "type": "number", "minimum": 0 }, "offset_x": { "type": "number" },
+            "offset_y": { "type": "number" }, "color": { "type": "string" }
+          }
+        }
+      }
+    },
+    "title": { "type": "string" },
+    "headless": { "type": "boolean" },
+    "window": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "width": { "type": "integer", "minimum": 120 },
+        "height": { "type": ["integer", "null"], "minimum": 1 },
+        "padding": { "type": "integer", "minimum": 0, "maximum": 40 },
+        "opacity": { "type": "number", "minimum": 0, "maximum": 1 },
+        "visible_lines": { "type": ["integer", "null"], "minimum": 1 },
+        "max_lines": { "type": ["integer", "null"], "minimum": 1 },
+        "max_height": { "type": ["integer", "null"], "minimum": 1 },
+        "wrap": { "type": "boolean" },
+        "overflow": { "enum": ["clip", "wrap", "scroll"] },
+        "margin": { "type": ["integer", "null"], "minimum": 0 },
+        "exact_size": { "type": "boolean" },
+        "trim": { "type": "boolean" },
+        "tab_width": { "type": "integer", "minimum": 1 },
+        "ambiguous_width": { "enum": [1, 2] },
+        "osc_policy": { "enum": ["ignore", "preserve", "apply"] },
+        "graphics_policy": { "enum": ["ignore", "error"] },
+        "ansi_state": { "enum": ["persistent", "line"] },
+        "background_gradient": { "type": ["array", "null"], "minItems": 2, "maxItems": 2, "items": { "type": "string" } },
+        "scroll_offset": { "type": "number", "minimum": 0, "maximum": 1 }
+      }
+    },
+    "font": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "family": { "type": ["string", "null"] },
+        "size": { "type": "number", "exclusiveMinimum": 0 },
+        "line_height": { "type": "number", "exclusiveMinimum": 0 },
+        "fallback_family": { "type": ["string", "null"] },
+        "italic_family": { "type": ["string", "null"] },
+        "emoji_family": { "type": ["string", "null"] }
+      }
+    },
+    "animation": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "typing_speed": { "type": "integer", "minimum": 0, "maximum": 86400000 },
+        "command_delay": { "type": "integer", "minimum": 0, "maximum": 86400000 },
+        "cursor_blink": { "type": "boolean" },
+        "loop": { "type": "boolean" },
+        "typing_jitter": { "type": "number", "minimum": 0, "maximum": 1 },
+        "seed": { "type": "integer", "minimum": 0, "maximum": 2147483647 },
+        "typing_chunk_size": { "type": "integer", "minimum": 1 },
+        "output_delay": { "type": "integer", "minimum": 0, "maximum": 86400000 },
+        "final_delay": { "type": "integer", "minimum": 0, "maximum": 86400000 },
+        "max_frames": { "type": ["integer", "null"], "minimum": 1 },
+        "dither": { "type": "boolean" },
+        "palette": { "enum": ["global", "adaptive", "theme"] },
+        "gif_colors": { "type": "integer", "minimum": 2, "maximum": 256 },
+        "gif_optimize": { "type": "boolean" },
+        "webp_lossless": { "type": "boolean" },
+        "webp_quality": { "type": "integer", "minimum": 0, "maximum": 100 },
+        "webp_method": { "type": "integer", "minimum": 0, "maximum": 6 },
+        "webp_near_lossless": { "type": "integer", "minimum": 0, "maximum": 100 },
+        "apng_prediction": { "enum": ["none", "sub", "up", "avg", "paeth", "mixed"] },
+        "loop_count": { "type": ["integer", "null"], "minimum": 0, "maximum": 65535 },
+        "direction": { "enum": ["forward", "reverse", "ping_pong"] },
+        "loop_offset": { "type": "integer", "minimum": 0 },
+        "scroll_easing": { "enum": ["linear", "ease_in", "ease_out", "ease_in_out"] },
+        "framerate": { "type": "integer", "minimum": 1, "maximum": 120 },
+        "playback_speed": { "type": "number", "exclusiveMinimum": 0, "maximum": 100 }
+      }
+    },
+    "cursor": {
+      "type": "object", "additionalProperties": false,
+      "properties": { "style": { "enum": ["block", "bar", "underline"] }, "color": { "type": ["string", "null"] } }
+    },
+    "limits": {
+      "type": "object", "additionalProperties": false,
+      "properties": {
+        "max_lines": { "type": "integer", "minimum": 1, "maximum": 10000 },
+        "max_frames": { "type": "integer", "minimum": 1, "maximum": 500 },
+        "max_render_frames": { "type": "integer", "minimum": 1, "maximum": 2000 },
+        "max_characters": { "type": "integer", "minimum": 1, "maximum": 200000 },
+        "max_pixels": { "type": "integer", "minimum": 1, "maximum": 50000000 },
+        "max_total_pixels": { "type": "integer", "minimum": 1, "maximum": 2000000000 },
+        "max_temp_bytes": { "type": "integer", "minimum": 1, "maximum": 8000000000 }
+      }
+    },
+    "lines": { "type": "array", "maxItems": 10000, "items": { "$ref": "#/$defs/line" } },
+    "frames": { "type": "array", "maxItems": 500, "items": { "$ref": "#/$defs/frame" } }
+  },
+  "anyOf": [{ "required": ["lines"] }, { "required": ["frames"] }],
+  "$defs": {
+    "line": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "prompt": { "type": "string" }, "command": { "type": "string" }, "output": { "type": "string" },
+        "prompt_color": { "type": "string" }, "command_color": { "type": "string" }, "output_color": { "type": "string" },
+        "selected": { "type": "boolean" }
+      },
+      "anyOf": [{ "required": ["prompt"] }, { "required": ["command"] }, { "required": ["output"] }]
+    },
+    "frame": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "prompt": { "type": "string" }, "type": { "type": "string" }, "output": { "type": "string" },
+        "screen": { "type": "array", "items": { "type": "string" } },
+        "delay": { "type": "integer", "minimum": 0, "maximum": 86400000 }, "prompt_color": { "type": "string" },
+        "command_color": { "type": "string" }, "output_color": { "type": "string" }
+      },
+      "allOf": [
+        { "anyOf": [{ "required": ["type"] }, { "required": ["output"] }, { "required": ["screen"] }, { "required": ["delay"] }] },
+        { "if": { "required": ["prompt"] }, "then": { "required": ["type"] } }
+      ]
+    }
+  }
+}