canopus 0.4.0 → 0.5.0

data/lib/canopus/project.rb

@@ -4,6 +4,10 @@ require "set"
 require "fileutils"
 require "tempfile"
 require "thuban"
+require_relative "regexp_compat"
+alkaid_path = ENV["ALKAID_PATH"]
+alkaid_root = File.expand_path("../..", __dir__)
+alkaid_path ? require(File.expand_path("lib/alkaid", File.expand_path(alkaid_path, alkaid_root))) : require("alkaid")
 
 module Canopus
   class Project
@@ -89,14 +93,20 @@ module Canopus
       false
     end
 
-    def search(pattern, **options, &block) = Search.new(self).call(pattern, **options, &block)
+    def ignore_matcher
+      Thuban::IgnoreMatcher.load(root, global: false).add("/.canopus/trash/\n")
+    end
+
     def watcher(**options) = Watcher.new(self, **options)
 
     # Each file is replaced atomically; a concurrent write aborts that file.
-    def replace(pattern, replacement, **options)
-      expression = pattern.is_a?(Regexp) ? pattern : Regexp.new(Regexp.escape(pattern))
-      searcher = Search.new(self)
-      paths = searcher.call(expression, **options).map(&:path).uniq
+    def replace(pattern, replacement, workers: 4, max_size: 10 * 1024 * 1024, extensions: nil, limit: nil,
+      case_sensitive: true, cancelled: nil, paths: nil)
+      expression = pattern.is_a?(Regexp) ? pattern : Regexp.new(Regexp.escape(pattern), case_sensitive ? 0 : Regexp::IGNORECASE)
+      matches = Alkaid::Search.new(root, pattern: expression, ignore: ignore_matcher, workers: workers,
+        max_file_size: max_size, max_matches: limit, extensions: extensions, paths: paths, hidden: true,
+        cancelled: cancelled).run
+      paths = matches.map(&:path).uniq
       paths.to_h do |relative|
         absolute = path(relative)
         before = File.stat(absolute)
@@ -123,5 +133,4 @@ module Canopus
   end
 end
 
-require_relative "project/search"
 require_relative "project/watcher"

data/lib/canopus/provider.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module Canopus
+  module Provider
+    Completion = Data.define(:label, :insert_text, :kind, :detail, :documentation,
+      :sort_text, :filter_text, :additional_edits, :source)
+
+    class Registry
+      MAX_PROVIDERS = 64
+      MAX_ITEMS = 10_000
+      MAX_STRING = 65_536
+      PROVIDER_TIMEOUT = 10
+
+      def initialize
+        @completion, @inline, @sequence = {}, {}, 0
+      end
+
+      def register_completion(source, priority:, &supplier)
+        source = normalize_source(source)
+        raise ArgumentError, "completion priority must be finite" unless priority.is_a?(Numeric) && priority.real? && priority.finite?
+        raise ArgumentError, "completion supplier required" unless supplier
+        raise ArgumentError, "too many completion providers" if !@completion.key?(source) && @completion.length >= MAX_PROVIDERS
+
+        @sequence += 1
+        @completion[source] = [priority, @sequence, supplier]
+        source
+      end
+
+      def complete(buffer, offset, context)
+        validate_position(buffer, offset)
+        query = completion_query(context)
+        ranked, jobs = [], []
+        @completion.to_a.each do |source, details|
+          thread = Thread.new { resolve(details.last.call(buffer, offset, context)) }
+          thread.report_on_exception = false
+          jobs << [source, details, thread]
+        end
+        jobs.sort_by! { |_source, (priority, registration, _supplier), _thread| [-priority, registration] }
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + PROVIDER_TIMEOUT
+        jobs.each do |source, (priority, registration, _supplier), thread|
+          break if ranked.length == MAX_ITEMS
+          begin
+            remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            unless !thread.alive? || remaining.positive? && thread.join(remaining)
+              raise RuntimeError, "completion provider timed out"
+            end
+            supplied = thread.value
+            raise TypeError, "completion supplier must return an array" unless supplied.is_a?(Array)
+            raise ArgumentError, "completion provider returned too many items" if supplied.length > MAX_ITEMS
+            supplied = supplied.first(MAX_ITEMS - ranked.length)
+
+            ranked.concat(supplied.each_with_index.map do |item, index|
+              completion = normalize_completion(item, source, buffer)
+              score = Spica.score(query, completion.filter_text || completion.label)
+              [completion, score, priority, registration, index]
+            end)
+          rescue StandardError => error
+            provider_error(context, source, error)
+          end
+        end
+
+        ranked.sort_by! { |completion, score, priority, registration, index| [-score, -priority, completion.sort_text || completion.label, registration, index] }
+        ranked.uniq! { |completion, _score, _priority, _registration, _index| [completion.label, completion.insert_text] }
+        ranked.map!(&:first)
+        ranked.freeze
+      ensure
+        jobs&.each do |_source, _details, thread|
+          thread.kill if thread.alive?
+          begin
+            thread.join
+          rescue StandardError
+            nil
+          end
+        end
+      end
+
+      def register_inline_completion(source, &supplier)
+        source = normalize_source(source)
+        raise ArgumentError, "inline completion supplier required" unless supplier
+        raise ArgumentError, "too many inline completion providers" if !@inline.key?(source) && @inline.length >= MAX_PROVIDERS
+
+        @sequence += 1
+        @inline[source] = [@sequence, supplier]
+        source
+      end
+
+      def inline_completion(buffer, offset)
+        validate_position(buffer, offset)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + PROVIDER_TIMEOUT
+        @inline.sort_by { |_source, (registration, _supplier)| registration }.each do |_source, (_registration, supplier)|
+          remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          break unless remaining.positive?
+          thread = Thread.new { resolve(supplier.call(buffer, offset)) }
+          thread.report_on_exception = false
+          begin
+            remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            break unless !thread.alive? || remaining.positive? && thread.join(remaining)
+            value = thread.value
+            next if value.nil?
+            return normalize_string(value, "inline completion")
+          rescue StandardError
+            next
+          ensure
+            thread.kill if thread.alive?
+            begin
+              thread.join
+            rescue StandardError
+              nil
+            end
+          end
+        end
+        nil
+      end
+
+      private
+
+      def resolve(value)
+        value.respond_to?(:await) ? value.await(timeout: PROVIDER_TIMEOUT) : value
+      end
+
+      def completion_query(context)
+        value = context.respond_to?(:[]) && (context[:query] || context["query"])
+        value.nil? ? "" : normalize_string(value, "completion query", maximum: 256)
+      end
+
+      def normalize_completion(item, source, buffer)
+        raise TypeError, "completion provider must return completions" unless item.is_a?(Completion)
+
+        label = normalize_string(item.label, "completion label")
+        raise ArgumentError, "completion label must not be empty" if label.empty?
+        insert_text = item.insert_text.nil? ? label : normalize_string(item.insert_text, "completion insertion")
+        detail = normalize_optional_string(item.detail, "completion detail")
+        documentation = normalize_optional_string(item.documentation, "completion documentation")
+        sort_text = normalize_optional_string(item.sort_text, "completion sort text")
+        filter_text = normalize_optional_string(item.filter_text, "completion filter text")
+        kind = item.kind
+        unless kind.nil? || kind.is_a?(Integer) || kind.is_a?(Symbol) || kind.is_a?(String)
+          raise TypeError, "invalid completion kind"
+        end
+        kind = normalize_string(kind, "completion kind") if kind.is_a?(String)
+        edits = item.additional_edits || []
+        raise TypeError, "completion additional edits must be an array" unless edits.is_a?(Array)
+        raise ArgumentError, "too many completion additional edits" if edits.length > 1_000
+        edits = edits.map do |entry|
+          unless entry.is_a?(Array) && entry.length == 2 && entry[0].is_a?(Range) && entry[1].is_a?(String) &&
+              entry[0].begin.is_a?(Integer) && entry[0].end.is_a?(Integer) && entry[0].begin >= 0 && entry[0].end >= entry[0].begin &&
+              entry[0].end <= buffer.rope.bytesize
+            raise TypeError, "invalid completion additional edit"
+          end
+          buffer.rope.point_at(entry[0].begin)
+          buffer.rope.point_at(entry[0].end)
+          [(entry[0].begin...entry[0].end).freeze, normalize_string(entry[1], "completion additional edit")].freeze
+        end.freeze
+
+        Completion.new(label, insert_text, kind, detail, documentation, sort_text, filter_text, edits, source)
+      end
+
+      def normalize_optional_string(value, name)
+        value.nil? ? nil : normalize_string(value, name)
+      end
+
+      def normalize_string(value, name, maximum: MAX_STRING)
+        utf8 = value.is_a?(String) && value.valid_encoding? &&
+          (value.encoding == Encoding::UTF_8 || value.encoding.ascii_compatible? && value.ascii_only?)
+        unless utf8 && value.bytesize <= maximum && !value.include?("\0")
+          raise ArgumentError, "invalid #{name}"
+        end
+        value.dup.freeze
+      end
+
+      def normalize_source(source)
+        valid = source.is_a?(Symbol) && !source.to_s.empty? && !source.to_s.include?(":") &&
+          !source.to_s.match?(/[\x00-\x1f\x7f]/)
+        raise ArgumentError, "invalid provider source" unless valid
+        source
+      end
+
+      def validate_position(buffer, offset)
+        size = buffer.respond_to?(:rope) && buffer.rope.respond_to?(:bytesize) ? buffer.rope.bytesize : nil
+        unless offset.is_a?(Integer) && size.is_a?(Integer) && offset.between?(0, size)
+          raise ArgumentError, "invalid provider buffer offset"
+        end
+      end
+
+      def provider_error(context, source, error)
+        return unless context.is_a?(Hash) && context[:errors].is_a?(Array) && context[:errors].length < MAX_PROVIDERS
+        message = error.message.to_s.encode(Encoding::UTF_8, invalid: :replace, undef: :replace).slice(0, 4_096).freeze
+        context[:errors] << [source, message].freeze
+      end
+    end
+  end
+end

data/lib/canopus/regexp_compat.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-unless Regexp.method_defined?(:timeout)
-  require "timeout"
+require "timeout"
 
+unless Regexp.method_defined?(:timeout)
   class Regexp
-    TimeoutError = Class.new(StandardError)
+    TimeoutError = Class.new(RegexpError)
     TIMEOUTS = ObjectSpace::WeakMap.new
 
     def timeout = TIMEOUTS[self]
@@ -13,18 +13,50 @@ unless Regexp.method_defined?(:timeout)
   Regexp.singleton_class.prepend(Module.new do
     def new(*arguments, timeout: nil)
       expression = super(*arguments)
-      Regexp::TIMEOUTS[expression] = timeout
+      Regexp::TIMEOUTS[expression] = normalize_timeout(timeout)
+      expression
+    end
+
+    def compile(*arguments, timeout: nil)
+      expression = super(*arguments)
+      Regexp::TIMEOUTS[expression] = normalize_timeout(timeout)
       expression
     end
+
+    private
+
+    def normalize_timeout(timeout)
+      return if timeout.nil?
+      raise TypeError, "no implicit conversion to float from string" if timeout.is_a?(String)
+
+      seconds = Float(timeout)
+      return if seconds.nan?
+      raise ArgumentError, "invalid timeout: #{timeout.inspect}" unless seconds.positive?
+      return if seconds < 0.000000001
+      return 18_446_744_073.709553 if seconds.infinite?
+
+      (seconds * 1_000_000_000).floor.fdiv(1_000_000_000)
+    end
+  end)
+
+  Regexp.prepend(Module.new do
+    def initialize_copy(other)
+      super
+      Regexp::TIMEOUTS[self] = other.timeout
+    end
   end)
 
   module Canopus
+    REGEXP_TIMEOUT_COMPAT = true
+
     def self.with_regexp_timeout(expression)
       expression.timeout ? Timeout.timeout(expression.timeout, Regexp::TimeoutError) { yield } : yield
     end
   end
 else
   module Canopus
+    REGEXP_TIMEOUT_COMPAT = false
+
     def self.with_regexp_timeout(_expression) = yield
   end
 end

data/lib/canopus/selection.rb

@@ -8,4 +8,16 @@ module Canopus
     def empty? = anchor == head
     def reversed? = head < anchor
   end
+
+  BlockSelection = Data.define(:anchor, :head) do
+    include Enumerable
+
+    def each
+      return enum_for(__method__) unless block_given?
+      first, last = [anchor.row, head.row].minmax
+      first.upto(last) do |row|
+        yield DisplayPoint.new(row, anchor.column), DisplayPoint.new(row, head.column)
+      end
+    end
+  end
 end

data/lib/canopus/settings/schema.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "kochab"
+
+module Canopus
+  class Settings
+    module Schema
+      DEFAULT_AUTO_PAIRS = [["(", ")"], ["[", "]"], ["{", "}"], ['"', '"'], ["'", "'"]].map(&:freeze).freeze
+      DEFAULT_VALUES = {
+        "font_size" => 14, "tab_size" => 4, "use_tabs" => false, "soft_wrap" => false, "vim_mode" => false, "keymap" => [],
+        "auto_pairs" => DEFAULT_AUTO_PAIRS, "scroll_friction" => 12,
+        "theme" => "Canopus Dark", "font_family" => nil, "icon_theme" => nil, "languages" => {}, "language_servers" => {},
+        "debug_adapters" => {},
+        "tabs" => {"activate_on_close" => "history", "close_on_middle_click" => true, "close_empty_pane" => true,
+          "reopen_history_limit" => 20, "confirm_on_close_dirty" => true},
+        "diagnostics" => {"inline" => true, "inline_max_length" => 80, "severity" => "warning"},
+        "inlay_hints" => {"enabled" => true, "parameter_names" => true, "types" => true, "max_length" => 30},
+        "code_lens" => {"enabled" => true}, "bracket_colorization" => true,
+        "indent_guides" => {"enabled" => true, "active" => true},
+        "render_whitespace" => "boundary", "render_ideographic_space" => true,
+        "sticky_scroll" => {"enabled" => true, "max_lines" => 5}, "breadcrumbs" => {"enabled" => true},
+        "minimap" => {"enabled" => false, "width" => 100, "show_diagnostics" => true},
+        "auto_save" => "off", "auto_save_delay" => 1_000,
+        "editorconfig" => true, "trim_trailing_whitespace" => nil, "insert_final_newline" => nil, "max_line_length" => nil,
+        "persistent_undo" => {"enabled" => true, "max_entries" => 1_000, "expire_days" => 30},
+        "format_on_save" => false, "code_actions_on_save" => [], "format_on_save_timeout" => 2_000,
+        "git" => {"inline_blame" => "off", "autofetch" => false, "autofetch_interval" => 180},
+        "plugins" => {"sandbox" => "auto"},
+        "recovery" => {"enabled" => true, "interval" => 5_000},
+        "dock" => {"left" => {"size" => 220, "visible" => true}, "right" => {"size" => 260, "visible" => false},
+          "bottom" => {"size" => 280, "visible" => false},
+          "panels" => {"explorer" => {"size" => 220, "visible" => true}, "search" => {"size" => 220, "visible" => false},
+            "terminal" => {"size" => 280, "visible" => false}}},
+        "terminal" => {"shell" => nil, "working_directory" => "project", "env" => {}, "scrollback_lines" => 10_000,
+          "profiles" => {}, "default_profile" => nil, "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, "shell_integration" => true, "max_bytes_per_frame" => 262_144,
+          "queue_limit_bytes" => 8_388_608, "resize_debounce_ms" => 100, "min_rows" => 4, "min_cols" => 20}
+      }.freeze
+
+      NULL_TYPES = {
+        %w[terminal shell] => ["string", "array", "null"],
+        %w[terminal default_profile] => ["string", "null"],
+        %w[terminal font_size] => ["number", "null"],
+        %w[font_family] => ["string", "null"], %w[icon_theme] => ["string", "null"],
+        %w[trim_trailing_whitespace] => ["boolean", "null"], %w[insert_final_newline] => ["boolean", "null"],
+        %w[max_line_length] => ["integer", "null"]
+      }.freeze
+
+      BASE_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"},
+        "auto_pairs" => {"type" => "array", "maxItems" => 64, "items" => {"type" => "array", "minItems" => 2, "maxItems" => 2, "items" => {"type" => "string"}}},
+        "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", "properties" => {
+          "activate_on_close" => {"type" => "string", "enum" => %w[history neighbour left right]},
+          "close_on_middle_click" => {"type" => "boolean"}, "close_empty_pane" => {"type" => "boolean"},
+          "reopen_history_limit" => {"type" => "integer", "minimum" => 0, "maximum" => 1000},
+          "confirm_on_close_dirty" => {"type" => "boolean"}}},
+        "terminal" => {"type" => "object", "properties" => {
+          "shell" => {"type" => ["string", "array", "null"]}, "working_directory" => {"type" => "string"},
+          "env" => {"type" => "object", "additionalProperties" => {"type" => ["string", "null"]}},
+          "scrollback_lines" => {"type" => "integer", "minimum" => 0, "maximum" => 1_000_000},
+          "shell_integration" => {"type" => "boolean"}, "default_profile" => {"type" => ["string", "null"]},
+          "profiles" => {"type" => "object", "additionalProperties" => {"$ref" => "#/$defs/terminal_profile"}},
+          "font_size" => {"type" => ["number", "null"], "minimum" => 6, "maximum" => 96},
+          "line_height" => {"type" => "number", "minimum" => 0.5, "maximum" => 4}, "copy_on_select" => {"type" => "boolean"},
+          "blinking" => {"type" => "string", "enum" => %w[off on terminal_controlled]},
+          "cursor_shape" => {"type" => "string", "enum" => %w[block bar underline]},
+          "close_on_exit" => {"type" => "string", "enum" => %w[never clean always]},
+          "confirm_close_running" => {"type" => "boolean"}, "confirm_multiline_paste" => {"type" => "boolean"},
+          "restore_on_startup" => {"type" => "boolean"}, "hide_when_empty" => {"type" => "boolean"},
+          "max_bytes_per_frame" => {"type" => "integer", "minimum" => 1, "maximum" => 16_777_216},
+          "queue_limit_bytes" => {"type" => "integer", "minimum" => 65_536, "maximum" => 268_435_456},
+          "resize_debounce_ms" => {"type" => "integer", "minimum" => 0, "maximum" => 10_000},
+          "min_rows" => {"type" => "integer", "minimum" => 1, "maximum" => 1000},
+          "min_cols" => {"type" => "integer", "minimum" => 1, "maximum" => 1000}}},
+        "diagnostics" => {"type" => "object", "required" => %w[inline inline_max_length severity], "properties" => {
+          "inline" => {"type" => "boolean"}, "inline_max_length" => {"type" => "integer", "minimum" => 1, "maximum" => 10_000},
+          "severity" => {"type" => "string", "enum" => %w[error warning information hint]}}},
+        "inlay_hints" => {"type" => "object", "required" => %w[enabled parameter_names types max_length], "properties" => {
+          "enabled" => {"type" => "boolean"}, "parameter_names" => {"type" => "boolean"}, "types" => {"type" => "boolean"},
+          "max_length" => {"type" => "integer", "minimum" => 1, "maximum" => 10_000}}},
+        "code_lens" => {"type" => "object", "required" => ["enabled"], "properties" => {"enabled" => {"type" => "boolean"}}},
+        "bracket_colorization" => {"type" => "boolean"},
+        "indent_guides" => {"type" => "object", "required" => %w[enabled active], "properties" => {"enabled" => {"type" => "boolean"}, "active" => {"type" => "boolean"}}},
+        "render_whitespace" => {"type" => "string", "enum" => %w[none boundary selection all]}, "render_ideographic_space" => {"type" => "boolean"},
+        "sticky_scroll" => {"type" => "object", "required" => %w[enabled max_lines], "properties" => {"enabled" => {"type" => "boolean"}, "max_lines" => {"type" => "integer", "minimum" => 1, "maximum" => 20}}},
+        "breadcrumbs" => {"type" => "object", "required" => ["enabled"], "properties" => {"enabled" => {"type" => "boolean"}}},
+        "minimap" => {"type" => "object", "required" => %w[enabled width show_diagnostics], "properties" => {"enabled" => {"type" => "boolean"}, "width" => {"type" => "integer", "minimum" => 40, "maximum" => 400}, "show_diagnostics" => {"type" => "boolean"}}},
+        "auto_save" => {"type" => "string", "enum" => %w[off after_delay on_focus_change]}, "auto_save_delay" => {"type" => "integer", "minimum" => 100, "maximum" => 3_600_000},
+        "editorconfig" => {"type" => "boolean"}, "trim_trailing_whitespace" => {"type" => ["boolean", "null"]}, "insert_final_newline" => {"type" => ["boolean", "null"]},
+        "max_line_length" => {"type" => ["integer", "null"], "minimum" => 1, "maximum" => 1_000_000},
+        "persistent_undo" => {"type" => "object", "additionalProperties" => false, "required" => %w[enabled max_entries expire_days], "properties" => {
+          "enabled" => {"type" => "boolean"}, "max_entries" => {"type" => "integer", "minimum" => 1, "maximum" => 10_000}, "expire_days" => {"type" => "integer", "minimum" => 1, "maximum" => 3_650}}},
+        "format_on_save" => {"type" => "boolean"}, "code_actions_on_save" => {"type" => "array", "maxItems" => 64, "uniqueItems" => true, "items" => {"type" => "string", "minLength" => 1, "maxLength" => 256}},
+        "format_on_save_timeout" => {"type" => "integer", "minimum" => 1, "maximum" => 60_000},
+        "git" => {"type" => "object", "additionalProperties" => false, "required" => %w[inline_blame autofetch autofetch_interval], "properties" => {
+          "inline_blame" => {"type" => "string", "enum" => %w[off cursor all]}, "autofetch" => {"type" => "boolean"}, "autofetch_interval" => {"type" => "integer", "minimum" => 10, "maximum" => 86_400}}},
+        "plugins" => {"type" => "object", "additionalProperties" => false, "required" => ["sandbox"], "properties" => {
+          "sandbox" => {"type" => "string", "enum" => %w[off auto required]}}},
+        "recovery" => {"type" => "object", "additionalProperties" => false, "required" => %w[enabled interval], "properties" => {"enabled" => {"type" => "boolean"}, "interval" => {"type" => "integer", "minimum" => 100, "maximum" => 3_600_000}}},
+        "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" => {"allOf" => [{"$ref" => "#"}, {"properties" => {"languages" => false, "debug_adapters" => false, "recovery" => false, "auto_save" => false, "auto_save_delay" => false, "persistent_undo" => false}}]}},
+        "language_servers" => {"type" => "object", "additionalProperties" => {"anyOf" => [{"type" => "null"}, {"$ref" => "#/$defs/language_server"}, {"type" => "array", "minItems" => 1, "items" => {"type" => "string", "minLength" => 1}}, {"type" => "array", "minItems" => 1, "maxItems" => 16, "items" => {"$ref" => "#/$defs/language_server"}}]}},
+        "debug_adapters" => {"type" => "object", "maxProperties" => 64, "propertyNames" => {"type" => "string", "minLength" => 1, "maxLength" => 128, "pattern" => "^[A-Za-z0-9_.-]+$"}, "additionalProperties" => {"$ref" => "#/$defs/debug_adapter"}}},
+        "$defs" => {
+          "language_server" => {"type" => "object", "additionalProperties" => false, "required" => ["command"], "properties" => {"command" => {"type" => "array", "minItems" => 1, "items" => {"type" => "string", "minLength" => 1}}, "env" => {"type" => "object", "additionalProperties" => {"type" => ["string", "null"]}}, "initialization_options" => {}, "configuration" => {"type" => "object"}, "features" => {"type" => "array", "minItems" => 1, "uniqueItems" => true, "items" => {"type" => "string", "enum" => %w[completion diagnostics codeAction formatting definition typeDefinition implementation hover signatureHelp references rename documentSymbol codeLens inlayHint semanticTokens documentHighlight foldingRange selectionRange callHierarchy typeHierarchy documentLink linkedEditingRange workspaceSymbol]}}}},
+          "debug_adapter" => {"type" => "object", "additionalProperties" => false, "required" => %w[command transport], "properties" => {"command" => {"type" => "array", "minItems" => 1, "maxItems" => 32, "items" => {"type" => "string", "minLength" => 1, "maxLength" => 4096, "pattern" => "^(?![\\s\\S]*[\\u0000-\\u001f\\u007f])[\\s\\S]+$"}}, "transport" => {"type" => "string", "enum" => %w[stdio tcp]}}},
+          "terminal_profile" => {"type" => "object", "additionalProperties" => false, "properties" => {"command" => {"anyOf" => [{"type" => "string", "minLength" => 1}, {"type" => "array", "minItems" => 1, "items" => {"type" => "string"}}]}, "path" => {"type" => "string", "minLength" => 1}, "args" => {"type" => "array", "items" => {"type" => "string"}}, "env" => {"type" => "object", "additionalProperties" => {"type" => ["string", "null"]}}}},
+          "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
+
+      def self.copy(value)
+        case value
+        when Hash then value.to_h { |key, child| [key, copy(child)] }
+        when Array then value.map { |child| copy(child) }
+        else value
+        end
+      end
+
+      def self.inferred(value, path)
+        return {"type" => NULL_TYPES.fetch(path, "null")} if value.nil?
+
+        type = case value
+               when true, false then "boolean"
+               when Integer then "integer"
+               when Numeric then "number"
+               when String then "string"
+               when Array then "array"
+               when Hash then "object"
+               else "any"
+               end
+        result = {"type" => type}
+        result["items"] = value.empty? ? {"type" => "any"} : inferred(value.first, path + [0]) if value.is_a?(Array)
+        result
+      end
+
+      def self.annotate(node, defaults, path = [])
+        result = copy(node)
+        unless path.empty?
+          result["description"] ||= "#{path.join(".")} setting"
+          result["default"] = copy(defaults)
+        end
+        if defaults.is_a?(Hash)
+          properties = result["properties"] ||= {}
+          defaults.each do |name, value|
+            properties[name] = annotate(properties.fetch(name, inferred(value, path + [name])), value, path + [name])
+          end
+        elsif defaults.is_a?(Array) && result["items"].is_a?(Hash) && !defaults.empty?
+          result["items"] = annotate(result["items"], defaults.first, path + [0])
+        end
+        result
+      end
+
+      def self.deep_freeze(value)
+        case value
+        when Hash
+          value.each { |key, child| deep_freeze(key); deep_freeze(child) }
+        when Array
+          value.each { |child| deep_freeze(child) }
+        end
+        value.freeze
+      end
+
+      def self.describe_nodes(node, path = [])
+        result = copy(node)
+        result["description"] ||= "#{path.join(".")} setting" unless path.empty?
+        if result["properties"].is_a?(Hash)
+          result["properties"] = result["properties"].to_h do |name, child|
+            [name, describe_nodes(child, path + [name])]
+          end
+        end
+        result["items"] = describe_nodes(result["items"], path + [0]) if result["items"].is_a?(Hash)
+        result["additionalProperties"] = describe_nodes(result["additionalProperties"], path + ["*"]) if result["additionalProperties"].is_a?(Hash)
+        if result["$defs"].is_a?(Hash)
+          result["$defs"] = result["$defs"].to_h { |name, child| [name, describe_nodes(child, path + [name])] }
+        end
+        result
+      end
+
+      def self.kochab_input(schema)
+        result = copy(schema)
+        result.dig("properties", "languages", "additionalProperties")["$ref"] = "#"
+        result
+      end
+
+      JSON_SCHEMA = describe_nodes(annotate(BASE_SCHEMA, DEFAULT_VALUES)).freeze
+      KOCHAB_SCHEMA = Kochab::Schema.from_json_schema(kochab_input(JSON_SCHEMA))
+      DEFAULTS = deep_freeze(KOCHAB_SCHEMA.defaults)
+    end
+  end
+end