canopus 0.4.0 → 0.5.0

data/lib/canopus/settings.rb

@@ -1,68 +1,61 @@
 # frozen_string_literal: true
 
 require "json"
+require "fileutils"
+require "tempfile"
 require "kochab"
+require_relative "settings/schema"
 
 module Canopus
   class Settings
-    DEFAULTS = {"font_size" => 14, "tab_size" => 4, "use_tabs" => false, "soft_wrap" => false, "vim_mode" => false, "keymap" => [].freeze,
-      "scroll_friction" => 12,
-      "theme" => "Canopus Dark", "font_family" => nil, "icon_theme" => nil, "languages" => {}, "language_servers" => {},
-      "tabs" => {"activate_on_close" => "history", "close_on_middle_click" => true, "close_empty_pane" => true,
-        "reopen_history_limit" => 20, "confirm_on_close_dirty" => true}.freeze,
-      "dock" => {"left" => {"size" => 220, "visible" => true}.freeze,
-        "right" => {"size" => 260, "visible" => false}.freeze,
-        "bottom" => {"size" => 280, "visible" => false}.freeze,
-        "panels" => {"explorer" => {"size" => 220, "visible" => true}.freeze,
-          "search" => {"size" => 220, "visible" => false}.freeze,
-          "terminal" => {"size" => 280, "visible" => false}.freeze}.freeze}.freeze,
-      "terminal" => {"shell" => nil, "working_directory" => "project", "env" => {}.freeze, "scrollback_lines" => 10_000,
-        "font_size" => nil, "line_height" => 1.2, "copy_on_select" => false, "blinking" => "terminal_controlled", "cursor_shape" => "block",
-        "close_on_exit" => "clean", "confirm_close_running" => true, "confirm_multiline_paste" => true,
-        "restore_on_startup" => false, "hide_when_empty" => false, "max_bytes_per_frame" => 262_144,
-        "queue_limit_bytes" => 8_388_608, "resize_debounce_ms" => 100, "min_rows" => 4, "min_cols" => 20}.freeze}.freeze
-    SCHEMA = {"$schema" => "https://json-schema.org/draft/2020-12/schema", "type" => "object", "properties" => {
-      "font_size" => {"type" => "number", "minimum" => 6, "maximum" => 96},
-      "tab_size" => {"type" => "integer", "minimum" => 1, "maximum" => 16},
-      "scroll_friction" => {"type" => "number", "minimum" => 0, "maximum" => 100},
-      "soft_wrap" => {"type" => "boolean"}, "vim_mode" => {"type" => "boolean"},
-      "use_tabs" => {"type" => "boolean"},
-      "keymap" => {"type" => "array", "maxItems" => 128, "items" => {"type" => "object", "required" => ["bindings"], "properties" => {
-        "context" => {"type" => "string", "maxLength" => 256},
-        "bindings" => {"type" => "object", "maxProperties" => 1024, "additionalProperties" => {"type" => ["string", "null"]}}}}},
-      "theme" => {"type" => "string"}, "font_family" => {"type" => ["string", "null"]},
-      "icon_theme" => {"type" => ["string", "null"]},
-      "tabs" => {"type" => "object"}, "terminal" => {"type" => "object"},
-      "dock" => {"type" => "object", "properties" => {
-        "left" => {"$ref" => "#/$defs/dock"}, "right" => {"$ref" => "#/$defs/dock"},
-        "bottom" => {"$ref" => "#/$defs/dock"}, "panels" => {"type" => "object", "maxProperties" => 1000,
-          "additionalProperties" => {"$ref" => "#/$defs/panel"}}}},
-      "languages" => {"type" => "object", "additionalProperties" => {"$ref" => "#"}},
-      "language_servers" => {"type" => "object"}}, "$defs" => {
-        "dock" => {"type" => "object", "required" => %w[size visible], "properties" => {
-          "size" => {"type" => "number", "exclusiveMinimum" => 0}, "visible" => {"type" => "boolean"}}},
-        "panel" => {"type" => "object", "required" => %w[size visible], "properties" => {
-          "size" => {"type" => "number", "exclusiveMinimum" => 0}, "visible" => {"type" => "boolean"}}}}}.freeze
+    ReloadFallback = Struct.new(:values, keyword_init: true)
+    private_constant :ReloadFallback
+    DEFAULT_AUTO_PAIRS = Schema::DEFAULT_AUTO_PAIRS
+    DEFAULTS = Schema::DEFAULTS
+    SCHEMA = Schema::JSON_SCHEMA
+    SCHEMA_MODEL = Schema::KOCHAB_SCHEMA
+    SCHEMA_METADATA = SCHEMA_MODEL
     attr_reader :values, :errors, :layers
     def self.schema = SCHEMA
+    def self.schema_model = SCHEMA_MODEL
+    def self.schema_metadata = SCHEMA_MODEL
+    def self.file_diagnostics(path)
+      return nil unless File.file?(path)
+
+      document = Kochab.parse(File.read(path))
+      diagnostics = document.errors.dup
+      if document.valid?
+        diagnostics.concat(SCHEMA_MODEL.validate(document).reject { |diagnostic| diagnostic.message == "Required value is missing" })
+      end
+      [document, diagnostics.freeze].freeze
+    rescue Errno::ENOENT, Errno::EACCES, Errno::EISDIR
+      nil
+    end
     def self.user_path
       File.join(ENV["XDG_CONFIG_HOME"] || File.expand_path("~/.config"), "canopus", "settings.jsonc")
     end
     def initialize(*layers)
+      fallback = layers.pop.values if layers.last.is_a?(ReloadFallback)
       @values, @errors = DEFAULTS.dup, []
       @layers = layers.compact
+      @reload_fallback = fallback
+      @initializing = true
       layers.compact.each { |layer| merge!(layer.is_a?(String) ? parse_file(layer) : layer) }
+      @initializing = false
+      @reload_fallback = nil
       validate!
     end
     def [](key) = @values[key.to_s]
     def paths = @layers.grep(String)
-    def reload = self.class.new(*@layers)
+    def reload = self.class.new(*@layers, ReloadFallback.new(values: @values))
     def for_language(language) = Settings.new(@values, @values.fetch("languages", {}).fetch(language, {}))
     def merge!(layer)
-      raise Error, "settings must be an object" unless layer.is_a?(Hash)
+      document = layer.is_a?(Kochab::Document)
+      raise Error, "settings must be an object" unless document || layer.is_a?(Hash)
       previous = @values
-      @values = merge(@values, layer)
+      @values = document ? merge_document(@values, layer) : merge_hash(@values, layer)
       validate!
+      @layers << snapshot_layer(layer) unless @initializing
       self
     rescue StandardError
       @values = previous if previous
@@ -72,8 +65,22 @@ module Canopus
       source = File.file?(path) ? File.read(path) : "{}\n"
       doc = Kochab.parse(source)
       raise Error, "cannot edit invalid settings" unless doc.valid?
-      replacement = Kochab.apply(source, doc.set([key.to_s], value))
-      Settings.new(Kochab.parse(replacement).value)
+      key_path = key.is_a?(Array) ? key : [key]
+      raise Error, "settings key path must contain strings" unless key_path.all? { |part| part.is_a?(String) && !part.empty? }
+      editable_source = source
+      (1...key_path.length).each do |length|
+        current = Kochab.parse(editable_source)
+        parent = key_path[0...length]
+        next if current.range_of(parent)
+
+        editable_source = Kochab.apply(editable_source, current.set(parent, {}))
+      end
+      doc = Kochab.parse(editable_source)
+      replacement = Kochab.apply(editable_source, doc.set(key_path, value))
+      candidate = Kochab.parse(replacement)
+      schema_errors = SCHEMA_MODEL.validate(candidate).reject { |diagnostic| diagnostic.message == "Required value is missing" }
+      raise Error, "invalid setting #{key_path.join(".")}: #{schema_errors.first.message}" unless schema_errors.empty?
+      Settings.new(candidate)
       FileUtils.mkdir_p(File.dirname(path))
       Tempfile.create([".settings-", ".json"], File.dirname(path)) do |file|
         file.write(replacement)
@@ -90,10 +97,30 @@ module Canopus
       document = Kochab.parse(File.read(path))
       @errors.concat(document.errors)
       raise Error, "invalid settings: #{path}" unless document.valid?
-      document.value
+      raise Error, "settings must be an object" unless document.value.is_a?(Hash)
+      document
+    end
+    def merge_hash(left, right)
+      left.merge(right) { |_, old, new| old.is_a?(Hash) && new.is_a?(Hash) ? merge_hash(old, new) : new }
     end
-    def merge(left, right)
-      left.merge(right) { |_, old, new| old.is_a?(Hash) && new.is_a?(Hash) ? merge(old, new) : new }
+    def merge_document(previous, document)
+      fallback = previous_layer(document.value, @reload_fallback || previous)
+      SCHEMA_MODEL.merge(previous, fallback, document)
+    end
+    def previous_layer(layer, previous)
+      layer.each_with_object({}) do |(key, value), result|
+        old = previous[key]
+        next unless previous.key?(key)
+
+        result[key] = value.is_a?(Hash) && old.is_a?(Hash) ? previous_layer(value, old) : snapshot_layer(old)
+      end
+    end
+    def snapshot_layer(value)
+      case value
+      when Hash then value.to_h { |key, child| [key, snapshot_layer(child)] }
+      when Array then value.map { |child| snapshot_layer(child) }
+      else value
+      end
     end
     def validate!
       {"font_size" => 6..96, "tab_size" => 1..16, "scroll_friction" => 0..100}.each do |key, range|
@@ -101,20 +128,46 @@ module Canopus
         raise Error, "invalid #{key}" unless value.is_a?(Numeric) && range.cover?(value)
       end
       raise Error, "tab_size must be an integer" unless @values["tab_size"].is_a?(Integer)
-      %w[soft_wrap vim_mode use_tabs].each { |key| raise Error, "#{key} must be true or false" unless [true, false].include?(@values[key]) }
+      %w[soft_wrap vim_mode use_tabs render_ideographic_space format_on_save].each { |key| raise Error, "#{key} must be true or false" unless [true, false].include?(@values[key]) }
+      raise Error, "invalid render_whitespace" unless %w[none boundary selection all].include?(@values["render_whitespace"])
       validate_keymap!
+      validate_auto_pairs!
       %w[languages language_servers].each { |key| raise Error, "#{key} must be an object" unless @values[key].is_a?(Hash) }
       raise Error, "theme must be a string" unless @values["theme"].is_a?(String)
       raise Error, "font_family must be a string or null" unless @values["font_family"].nil? || @values["font_family"].is_a?(String)
       raise Error, "icon_theme must be a string or null" unless @values["icon_theme"].nil? || @values["icon_theme"].is_a?(String)
       validate_tabs!
       validate_terminal!
+      validate_diagnostics!
+      validate_inlay_hints!
+      validate_code_lens!
+      validate_structural_guides!
+      validate_sticky_scroll!
+      validate_breadcrumbs!
+      validate_minimap!
+      validate_auto_save!
+      validate_editorconfig!
+      validate_persistent_undo!
+      validate_save_actions!
+      validate_git!
+      validate_plugins!
+      validate_recovery!
+      validate_language_server_keys!
+      snapshot_language_servers!
+      validate_debug_adapters!
       validate_dock!
       @values["languages"] = @values["languages"].to_h do |name, layer|
         raise Error, "language settings must be objects" unless name.is_a?(String) && layer.is_a?(Hash)
         raise Error, "language settings cannot contain nested languages" if layer.key?("languages")
+        %w[debug_adapters recovery auto_save auto_save_delay persistent_undo].each do |key|
+          raise Error, "#{key} is a global setting" if layer.key?(key) || layer.key?(key.to_sym)
+        end
         checked = Settings.new(@values.merge("languages" => {}), layer)
-        [name, layer.key?("keymap") ? layer.merge("keymap" => checked["keymap"]) : layer]
+        layer = layer.merge("keymap" => checked["keymap"]) if layer.key?("keymap")
+        layer = layer.merge("auto_pairs" => checked["auto_pairs"]) if layer.key?("auto_pairs")
+        layer = layer.merge("code_actions_on_save" => checked["code_actions_on_save"]) if layer.key?("code_actions_on_save")
+        layer = layer.merge("language_servers" => checked["language_servers"]) if layer.key?("language_servers")
+        [name, layer]
       end
     end
     def validate_keymap!
@@ -140,6 +193,23 @@ module Canopus
       raise Error, "invalid keymap: #{error.message}"
     end
 
+    def validate_auto_pairs!
+      pairs = @values["auto_pairs"]
+      raise Error, "auto_pairs must be an array of at most 64 pairs" unless pairs.is_a?(Array) && pairs.length <= 64
+      openers = {}
+      @values["auto_pairs"] = pairs.map do |pair|
+        raise Error, "auto_pairs entries must contain an opener and closer" unless pair.is_a?(Array) && pair.length == 2
+        opener, closer = pair
+        unless [opener, closer].all? { |value| value.is_a?(String) && value.encoding == Encoding::UTF_8 && value.valid_encoding? &&
+          value.each_grapheme_cluster.one? && !value.match?(/\p{Cc}/) }
+          raise Error, "auto_pairs openers and closers must be single non-control UTF-8 graphemes"
+        end
+        raise Error, "auto_pairs openers must be unique" if openers[opener]
+        openers[opener] = true
+        [opener.dup.freeze, closer.dup.freeze].freeze
+      end.freeze
+    end
+
     def validate_tabs!
       tabs = @values["tabs"]
       raise Error, "tabs must be an object" unless tabs.is_a?(Hash)
@@ -158,9 +228,10 @@ module Canopus
         (terminal["shell"].is_a?(Array) && terminal["shell"].all? { |value| value.is_a?(String) })
       raise Error, "invalid terminal.working_directory" unless terminal["working_directory"].is_a?(String)
       raise Error, "invalid terminal.env" unless terminal["env"].is_a?(Hash) && terminal["env"].all? { |key, value| key.is_a?(String) && (value.nil? || value.is_a?(String)) }
+      validate_terminal_profiles!(terminal)
       raise Error, "invalid terminal.font_size" unless terminal["font_size"].nil? || terminal["font_size"].is_a?(Numeric) && terminal["font_size"].between?(6, 96)
       raise Error, "invalid terminal.line_height" unless terminal["line_height"].is_a?(Numeric) && terminal["line_height"].between?(0.5, 4)
-      %w[confirm_close_running confirm_multiline_paste copy_on_select restore_on_startup hide_when_empty].each do |key|
+      %w[confirm_close_running confirm_multiline_paste copy_on_select restore_on_startup hide_when_empty shell_integration].each do |key|
         raise Error, "terminal.#{key} must be true or false" unless [true, false].include?(terminal[key])
       end
       raise Error, "invalid terminal.close_on_exit" unless %w[never clean always].include?(terminal["close_on_exit"])
@@ -174,6 +245,214 @@ module Canopus
       end
     end
 
+    def validate_terminal_profiles!(terminal)
+      profiles = terminal["profiles"]
+      raise Error, "terminal.profiles must be an object" unless profiles.is_a?(Hash) && profiles.length <= 100
+      profiles.each do |name, profile|
+        valid_name = name.is_a?(String) && name.valid_encoding? && name.bytesize.between?(1, 128) && name == name.strip
+        raise Error, "invalid terminal profile name" unless valid_name
+        unless profile.is_a?(Hash) && profile.keys.all? { |key| %w[command path args env].include?(key) }
+          raise Error, "invalid terminal profile #{name}"
+        end
+        command = profile["command"]
+        path, args, env = profile.values_at("path", "args", "env")
+        valid_command = command.nil? || command.is_a?(String) && !command.empty? ||
+          command.is_a?(Array) && command.first.is_a?(String) && !command.first.empty? &&
+            command.all? { |value| value.is_a?(String) }
+        raise Error, "invalid terminal profile command #{name}" unless valid_command
+        raise Error, "terminal profile #{name} cannot use command with path or args" if command && (path || args)
+        raise Error, "terminal profile #{name} args require path" if args && !path
+        raise Error, "invalid terminal profile path #{name}" unless path.nil? || path.is_a?(String) && !path.empty?
+        raise Error, "invalid terminal profile args #{name}" unless args.nil? || args.is_a?(Array) && args.all? { |value| value.is_a?(String) }
+        valid_env = env.nil? || env.is_a?(Hash) && env.all? { |key, value| key.is_a?(String) && (value.nil? || value.is_a?(String)) }
+        raise Error, "invalid terminal profile env #{name}" unless valid_env
+      end
+      default = terminal["default_profile"]
+      unless default.nil? || default.is_a?(String) && profiles.key?(default)
+        raise Error, "terminal.default_profile must name a configured profile"
+      end
+    end
+
+    def validate_git!
+      git = @values["git"]
+      raise Error, "git must be an object" unless git.is_a?(Hash)
+      raise Error, "invalid git.inline_blame" unless %w[off cursor all].include?(git["inline_blame"])
+      raise Error, "git.autofetch must be true or false" unless [true, false].include?(git["autofetch"])
+      interval = git["autofetch_interval"]
+      raise Error, "invalid git.autofetch_interval" unless interval.is_a?(Integer) && interval.between?(10, 86_400)
+    end
+
+    def validate_recovery!
+      recovery = @values["recovery"]
+      raise Error, "recovery must be an object" unless recovery.is_a?(Hash)
+      raise Error, "recovery.enabled must be true or false" unless [true, false].include?(recovery["enabled"])
+      interval = recovery["interval"]
+      raise Error, "invalid recovery.interval" unless interval.is_a?(Integer) && interval.between?(100, 3_600_000)
+    end
+
+    def validate_plugins!
+      plugins = @values["plugins"]
+      raise Error, "plugins must be an object" unless plugins.is_a?(Hash)
+      raise Error, "invalid plugins.sandbox" unless %w[off auto required].include?(plugins["sandbox"])
+    end
+
+    def validate_diagnostics!
+      diagnostics = @values["diagnostics"]
+      raise Error, "diagnostics must be an object" unless diagnostics.is_a?(Hash)
+      raise Error, "diagnostics.inline must be true or false" unless [true, false].include?(diagnostics["inline"])
+      length = diagnostics["inline_max_length"]
+      raise Error, "invalid diagnostics.inline_max_length" unless length.is_a?(Integer) && length.between?(1, 10_000)
+      unless %w[error warning information hint].include?(diagnostics["severity"])
+        raise Error, "invalid diagnostics.severity"
+      end
+    end
+
+    def validate_inlay_hints!
+      hints = @values["inlay_hints"]
+      raise Error, "inlay_hints must be an object" unless hints.is_a?(Hash)
+      %w[enabled parameter_names types].each do |key|
+        raise Error, "inlay_hints.#{key} must be true or false" unless [true, false].include?(hints[key])
+      end
+      length = hints["max_length"]
+      raise Error, "invalid inlay_hints.max_length" unless length.is_a?(Integer) && length.between?(1, 10_000)
+    end
+
+    def validate_code_lens!
+      lens = @values["code_lens"]
+      raise Error, "code_lens must be an object" unless lens.is_a?(Hash)
+      raise Error, "code_lens.enabled must be true or false" unless [true, false].include?(lens["enabled"])
+    end
+
+    def validate_structural_guides!
+      unless [true, false].include?(@values["bracket_colorization"])
+        raise Error, "bracket_colorization must be true or false"
+      end
+      guides = @values["indent_guides"]
+      raise Error, "indent_guides must be an object" unless guides.is_a?(Hash)
+      %w[enabled active].each do |key|
+        raise Error, "indent_guides.#{key} must be true or false" unless [true, false].include?(guides[key])
+      end
+    end
+
+    def validate_sticky_scroll!
+      sticky = @values["sticky_scroll"]
+      raise Error, "sticky_scroll must be an object" unless sticky.is_a?(Hash)
+      raise Error, "sticky_scroll.enabled must be true or false" unless [true, false].include?(sticky["enabled"])
+      unless sticky["max_lines"].is_a?(Integer) && sticky["max_lines"].between?(1, 20)
+        raise Error, "invalid sticky_scroll.max_lines"
+      end
+    end
+
+    def validate_breadcrumbs!
+      breadcrumbs = @values["breadcrumbs"]
+      unless breadcrumbs.is_a?(Hash) && [true, false].include?(breadcrumbs["enabled"])
+        raise Error, "breadcrumbs.enabled must be true or false"
+      end
+    end
+
+    def validate_minimap!
+      minimap = @values["minimap"]
+      raise Error, "minimap must be an object" unless minimap.is_a?(Hash)
+      %w[enabled show_diagnostics].each do |key|
+        raise Error, "minimap.#{key} must be true or false" unless [true, false].include?(minimap[key])
+      end
+      raise Error, "invalid minimap.width" unless minimap["width"].is_a?(Integer) && minimap["width"].between?(40, 400)
+    end
+
+    def validate_auto_save!
+      raise Error, "invalid auto_save" unless %w[off after_delay on_focus_change].include?(@values["auto_save"])
+      delay = @values["auto_save_delay"]
+      raise Error, "invalid auto_save_delay" unless delay.is_a?(Integer) && delay.between?(100, 3_600_000)
+    end
+
+    def validate_editorconfig!
+      raise Error, "editorconfig must be true or false" unless [true, false].include?(@values["editorconfig"])
+      %w[trim_trailing_whitespace insert_final_newline].each do |key|
+        value = @values[key]
+        raise Error, "#{key} must be true, false, or null" unless value.nil? || [true, false].include?(value)
+      end
+      length = @values["max_line_length"]
+      raise Error, "invalid max_line_length" unless length.nil? || length.is_a?(Integer) && length.between?(1, 1_000_000)
+    end
+
+    def validate_persistent_undo!
+      persistent = @values["persistent_undo"]
+      raise Error, "persistent_undo must be an object" unless persistent.is_a?(Hash)
+      raise Error, "persistent_undo.enabled must be true or false" unless [true, false].include?(persistent["enabled"])
+      max_entries = persistent["max_entries"]
+      raise Error, "invalid persistent_undo.max_entries" unless max_entries.is_a?(Integer) && max_entries.between?(1, 10_000)
+      expire_days = persistent["expire_days"]
+      raise Error, "invalid persistent_undo.expire_days" unless expire_days.is_a?(Integer) && expire_days.between?(1, 3_650)
+    end
+
+    def validate_save_actions!
+      actions = @values["code_actions_on_save"]
+      valid = actions.is_a?(Array) && actions.length <= 64 && actions.uniq.length == actions.length && actions.all? do |action|
+        action.is_a?(String) && action.valid_encoding? && action.bytesize.between?(1, 256) &&
+          action == action.strip && !action.match?(/[\x00-\x1f\x7f]/)
+      end
+      raise Error, "invalid code_actions_on_save" unless valid
+      @values["code_actions_on_save"] = actions.map { |action| action.dup.freeze }.freeze
+      timeout = @values["format_on_save_timeout"]
+      raise Error, "invalid format_on_save_timeout" unless timeout.is_a?(Integer) && timeout.between?(1, 60_000)
+    end
+
+    def snapshot_language_servers!
+      snapshot = JSON.parse(JSON.generate(@values["language_servers"]))
+      freeze_value = lambda do |value|
+        value.each { |key, child| key.freeze; freeze_value.call(child) } if value.is_a?(Hash)
+        value.each { |child| freeze_value.call(child) } if value.is_a?(Array)
+        value.freeze
+      end
+      @values["language_servers"] = freeze_value.call(snapshot)
+    rescue JSON::GeneratorError, JSON::ParserError, JSON::NestingError
+      raise Error, "invalid language_servers"
+    end
+
+    def validate_language_server_keys!
+      @values["language_servers"].each do |name, value|
+        raise Error, "language server names must be strings" unless name.is_a?(String)
+        options = value.is_a?(Array) ? value.select { |item| item.is_a?(Hash) } : value.is_a?(Hash) ? [value] : []
+        options.each do |option|
+          raise Error, "language server option keys must be strings" unless option.keys.all? { |key| key.is_a?(String) }
+          env = option["env"]
+          raise Error, "language server env keys must be strings" if env.is_a?(Hash) && !env.keys.all? { |key| key.is_a?(String) }
+        end
+      end
+    end
+
+    def validate_debug_adapters!
+      adapters = @values["debug_adapters"]
+      raise Error, "debug_adapters must be an object of at most 64 adapters" unless adapters.is_a?(Hash) && adapters.length <= 64
+      adapters.each do |type, options|
+        valid_type = type.is_a?(String) && type.valid_encoding? && type.bytesize.between?(1, 128) &&
+          type.match?(/\A[A-Za-z0-9_.-]+\z/)
+        raise Error, "invalid debug adapter type" unless valid_type
+        unless options.is_a?(Hash) && options.keys.all? { |key| key.is_a?(String) } &&
+          (options.keys - %w[command transport]).empty?
+          raise Error, "invalid debug adapter options for #{type}"
+        end
+        command = options["command"]
+        valid_command = command.is_a?(Array) && command.length.between?(1, 32) && command.all? do |argument|
+          argument.is_a?(String) && argument.valid_encoding? && argument.bytesize.between?(1, 4096) &&
+            !argument.match?(/[\x00-\x1f\x7f]/)
+        end
+        raise Error, "invalid debug adapter command for #{type}" unless valid_command
+        raise Error, "invalid debug adapter transport for #{type}" unless %w[stdio tcp].include?(options["transport"])
+      end
+      serialized = JSON.generate(adapters)
+      raise Error, "debug_adapters exceeds 1 MiB" if serialized.bytesize > 1_048_576
+      snapshot = JSON.parse(serialized)
+      freeze_value = lambda do |value|
+        value.each { |key, child| key.freeze; freeze_value.call(child) } if value.is_a?(Hash)
+        value.each { |child| freeze_value.call(child) } if value.is_a?(Array)
+        value.freeze
+      end
+      @values["debug_adapters"] = freeze_value.call(snapshot)
+    rescue JSON::GeneratorError, JSON::ParserError, JSON::NestingError
+      raise Error, "invalid debug_adapters"
+    end
+
     def validate_dock!
       dock = @values["dock"]
       raise Error, "dock must be an object" unless dock.is_a?(Hash)