canopus 0.3.0 → 0.4.0

data/lib/canopus/display_map/overlay_map.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+class Canopus::DisplayMap::OverlayMap
+  Inline = Data.define(:item, :offset, :width, :cell_width, :height, :align)
+  Block = Data.define(:item, :row, :height, :row_span, :position)
+
+  attr_reader :line_height
+
+  def initialize
+    @inlines, @inline_values, @blocks, @line_height, @input = {}.freeze, [].freeze, {}.freeze, 1, nil
+  end
+
+  def replace(items, rope:, font: nil, font_size: 14, line_height: 20)
+    raise ArgumentError, "decorations must be an array" unless items.is_a?(Array)
+    validate_size(font_size, "font size")
+    validate_size(line_height, "line height")
+    input = [items, font&.object_id, font_size, line_height]
+    return [] if @input == input
+
+    inlines, blocks = Hash.new { |hash, key| hash[key] = [] }, Hash.new { |hash, key| hash[key] = [] }
+    items.each do |item|
+      raise TypeError, "overlays must be decoration items" unless item.is_a?(Canopus::Decoration::Item)
+      next unless %i[inline block].include?(item.kind)
+
+      if item.kind == :inline
+        offset = item.range&.begin
+        raise ArgumentError, "inline decoration requires a range" unless offset.is_a?(Integer)
+        raise RangeError, "inline decoration is outside the buffer" unless offset.between?(0, rope.bytesize)
+        row = rope.point_at(offset).row
+        local = offset - rope.line_start(row)
+        unless Zaniah::Unicode.grapheme_boundary?(rope.line(row), local)
+          raise ArgumentError, "inline decoration splits a grapheme cluster"
+        end
+        style = item.style.is_a?(Hash) ? item.style : {}
+        align = style.fetch(:align, :after)
+        raise ArgumentError, "inline alignment must be before or after" unless %i[before after].include?(align)
+        text = item.content.is_a?(String) ? item.content : item.content.respond_to?(:text) ? item.content.text.to_s : item.content.to_s
+        text = text.encode(Encoding::UTF_8)
+        padding_left = numeric_style(style, :padding_left)
+        padding_right = numeric_style(style, :padding_right)
+        validate_size(padding_left, "inline left padding", allow_zero: true)
+        validate_size(padding_right, "inline right padding", allow_zero: true)
+        padding = padding_left + padding_right
+        width = numeric_style(style, :width, nil) || (font ? font.advance_width(text.codepoints, size: font_size) : Zaniah::Unicode.width(text) * font_size * 0.6)
+        width += padding
+        height = numeric_style(style, :height, line_height)
+        validate_size(width, "inline width")
+        validate_size(height, "inline height")
+        raise ArgumentError, "inline height must not exceed line height" if height > line_height
+        cells = numeric_style(style, :cells, Zaniah::Unicode.width(text))
+        validate_size(cells, "inline cell width", allow_zero: true)
+        inlines[row] << Inline.new(item, offset, width.to_f, cells.to_f, height.to_f, align)
+      else
+        row = item.row
+        raise ArgumentError, "block decoration requires a row" unless row.is_a?(Integer)
+        raise RangeError, "block decoration is outside the buffer" unless row.between?(0, rope.line_count - 1)
+        style = item.style.is_a?(Hash) ? item.style : {}
+        position = style.fetch(:position, :above)
+        raise ArgumentError, "block position must be above or below" unless %i[above below].include?(position)
+        height = numeric_style(style, :height, line_height)
+        validate_size(height, "block height")
+        blocks[row] << Block.new(item, row, height.to_f, (height.to_f / line_height).ceil, position)
+      end
+    end
+    inlines.each_value { |values| values.sort_by! { |value| [value.offset, value.item.priority] }.freeze }
+    blocks.each_value { |values| values.sort_by! { |value| value.item.priority }.freeze }
+    inlines, blocks = inlines.to_h.freeze, blocks.to_h.freeze
+    inline_values = inlines.values.flatten.sort_by(&:offset).freeze
+    return [] if @inlines == inlines && @blocks == blocks && @line_height == line_height
+
+    affected = (@inlines.keys | @blocks.keys | inlines.keys | blocks.keys).select do |row|
+      @inlines.fetch(row, nil) != inlines.fetch(row, nil) ||
+        @blocks.fetch(row, nil) != blocks.fetch(row, nil) || @line_height != line_height
+    end
+    @inlines, @inline_values, @blocks, @line_height, @input = inlines, inline_values, blocks, line_height, input
+    affected.sort
+  end
+
+  def transform(rope, row, text, offsets)
+    start = rope.line_start(row)
+    first, last = offsets.first + start, offsets.last + start
+    index = @inline_values.bsearch_index { |inline| inline.offset >= first }
+    return [] unless index
+    values = []
+    while (inline = @inline_values[index]) && inline.offset <= last
+      values << inline
+      index += 1
+    end
+    boundaries, byte = [0], 0
+    text.each_char { |character| boundaries << (byte += character.bytesize) }
+    values.filter_map do |inline|
+      local = inline.offset - start
+      column = offsets.bsearch_index { |offset| offset >= local } || offsets.length - 1
+      next unless offsets[column] == local
+      inline.with(offset: boundaries.fetch(column))
+    end.freeze
+  end
+
+  def blocks(row, position) = @blocks.fetch(row, []).select { |block| block.position == position }
+
+  def snapshot
+    copy = self.class.allocate
+    copy.instance_variable_set(:@inlines, @inlines)
+    copy.instance_variable_set(:@inline_values, @inline_values)
+    copy.instance_variable_set(:@blocks, @blocks)
+    copy.instance_variable_set(:@line_height, @line_height)
+    copy.instance_variable_set(:@input, nil)
+    copy.freeze
+  end
+
+  private
+
+  def numeric_style(style, key, default = 0)
+    value = style.fetch(key, default)
+    raise ArgumentError, "#{key} must be numeric" unless value.nil? || value.is_a?(Numeric)
+    value
+  end
+
+  def validate_size(value, name, allow_zero: false)
+    valid = value.is_a?(Numeric) && value.real? && value.finite? && (allow_zero ? value >= 0 : value.positive?)
+    raise ArgumentError, "#{name} must be #{allow_zero ? 'nonnegative' : 'positive'} and finite" unless valid
+  end
+end

data/lib/canopus/display_map.rb

@@ -10,14 +10,15 @@ module Canopus
   class DisplayMap
     BACKGROUND_THRESHOLD = 1 << 20
     Row = Data.define(:text, :offsets, :kind, :metadata)
-    attr_reader :fold_map, :tab_map, :wrap_map, :block_map, :tree, :recomputed_lines
+    attr_reader :fold_map, :overlay_map, :tab_map, :wrap_map, :block_map, :tree, :recomputed_lines
     attr_reader :layout_error
 
     def initialize(buffer, tab_size: 4, wrap_width: nil, background_threshold: BACKGROUND_THRESHOLD)
       raise ArgumentError, "background threshold must be nonnegative or nil" unless background_threshold.nil? || (background_threshold.is_a?(Integer) && background_threshold >= 0)
       @background_threshold, @generation = background_threshold, 0
       @buffer, @rope = buffer, buffer.rope
-      @fold_map, @tab_map, @wrap_map, @block_map = FoldMap.new, TabMap.new(tab_size: tab_size), WrapMap.new(width: wrap_width), BlockMap.new
+      @fold_map, @overlay_map, @tab_map, @wrap_map, @block_map = FoldMap.new, OverlayMap.new,
+        TabMap.new(tab_size: tab_size), WrapMap.new(width: wrap_width), BlockMap.new
       rebuild
       @subscription = buffer.on_edit { |patch| apply(patch) }
     end
@@ -86,6 +87,17 @@ module Canopus
       @tab_map = TabMap.new(tab_size: size)
       rebuild(reuse: true)
     end
+    def set_overlays(items, font: nil, font_size: 14, line_height: 20)
+      affected = @overlay_map.replace(items, rope: @rope, font: font, font_size: font_size, line_height: line_height)
+      return false if affected.empty?
+
+      @recomputed_lines = 0
+      affected.select { |row| row.between?(0, @rope.line_count - 1) }
+        .flat_map { |row| first, last = affected_lines(row, row); (first..last).to_a }.uniq.sort.each do |row|
+        replace_lines(row, row, row)
+      end
+      true
+    end
     def fold(range)
       raise Error, "folding is disabled for large read-only files" if @lazy
       range = range.begin...(range.end + (range.exclude_end? ? 0 : 1))
@@ -166,6 +178,14 @@ module Canopus
       local = offset - @rope.line_start(source)
       lines = display_lines(source, local: local).rows
       prefix = @tree.prefix_summary(source).display_rows
+      lines.each_with_index do |line, i|
+        next unless line.kind == :text && line.metadata&.any? do |placement|
+          placement.align == :before && placement.item.range.begin == offset
+        end
+
+        column = line.offsets.bsearch_index { |position| position >= local } || line.offsets.length - 1
+        return DisplayPoint.new(prefix + i, column)
+      end
       lines.each_with_index do |line, i|
         next unless line.kind == :text
         next if local > line.offsets.last
@@ -261,7 +281,7 @@ module Canopus
         @worker = nil
         return
       end
-      @builder = LineBuilder.new(@rope, @fold_map, @tab_map, @wrap_map, @block_map)
+      @builder = LineBuilder.new(@rope, @fold_map, @overlay_map, @tab_map, @wrap_map, @block_map)
       @background = background_layout?(@rope)
       unless reuse && @background && @tree && @tree.size == @rope.line_count
         values = @background ? @builder.pending_lines(0, @rope.line_count) : Array.new(@rope.line_count) { |row| build_line(row) }
@@ -276,7 +296,7 @@ module Canopus
       @pending_result = nil
       @failed = false
       @layout_error = nil
-      @builder = LineBuilder.new(@rope, @fold_map, @tab_map, @wrap_map, @block_map)
+      @builder = LineBuilder.new(@rope, @fold_map, @overlay_map, @tab_map, @wrap_map, @block_map)
       replacement = @background ? @builder.pending_lines(first, new_last - first + 1) : Array.new(new_last - first + 1) { |i| build_line(first + i) }
       if first < @computed_prefix
         @computed_prefix = old_last + 1 >= @computed_prefix ? first : @computed_prefix + new_last - old_last
@@ -340,6 +360,7 @@ end
 require_relative "display_map/summary"
 require_relative "display_map/line_set"
 require_relative "display_map/pending_line_set"
+require_relative "display_map/overlay_map"
 
 Canopus::DisplayMap::EMPTY_LINES = Canopus::DisplayMap::LineSet.new([].freeze)
 Canopus::DisplayMap::UNWRAPPED_LINE = Canopus::DisplayMap::PendingLineSet.new(1)

data/lib/canopus/lsp/client.rb

@@ -46,6 +46,7 @@ module Canopus
         raise Error, "missing semantic token legend" if semantic && (!semantic.is_a?(Hash) || !semantic["legend"].is_a?(Hash))
         Protocol.semantic_tokens([], legend: semantic["legend"]) if semantic.is_a?(Hash)
         notify("initialized", {})
+        reopen_documents if @reopening_documents
         @state = :running
         self
       rescue StandardError => error
@@ -279,21 +280,28 @@ module Canopus
         return if @restart_thread&.alive?
         previous = @transport
         @restart_thread = Thread.new do
-          previous.close
-          until @closing || @restarts >= 3
-            @restarts += 1
-            sleep(0.2 * @restarts)
-            break if @closing
-            begin
-              start
-              @documents.values.dup.each { |buffer, language, _| open_document(buffer, language_id: language) }
-              break
-            rescue StandardError => failure
-              report_error(failure)
+          @reopening_documents = true
+          begin
+            previous.close
+            until @closing || @restarts >= 3
+              @restarts += 1
+              sleep(0.2 * @restarts)
+              break if @closing
+              begin
+                start
+                break
+              rescue StandardError => failure
+                report_error(failure)
+              end
             end
+          ensure
+            @reopening_documents = false
           end
         end
       end
+      def reopen_documents
+        @documents.values.dup.each { |buffer, language, _| open_document(buffer, language_id: language) }
+      end
     end
   end
 end

data/lib/canopus/panel.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Canopus
+  module Panel
+    Definition = Data.define(:id, :title, :icon, :dock, :build, :badge)
+
+    class Registry
+      DOCKS = %i[left right bottom].freeze
+
+      attr_reader :docks
+
+      def initialize(docks)
+        @docks = docks
+        @definitions, @states = {}, {}
+      end
+
+      def register(definition, visible: true, size: nil)
+        definition = normalize(definition)
+        raise ArgumentError, "panel visibility must be true or false" unless [true, false].include?(visible)
+        size ||= @docks.fetch(definition.dock)[:size]
+        raise ArgumentError, "invalid panel size" unless size.is_a?(Numeric) && size.finite? && size.positive?
+        @definitions[definition.id] = definition
+        @states[definition.id] ||= {visible: visible, size: size}
+        definition
+      end
+
+      def fetch(id) = @definitions.fetch(id.to_s)
+      def key?(id) = @definitions.key?(id.to_s)
+      def visible?(id)
+        definition = fetch(id)
+        !!@states.fetch(definition.id)[:visible]
+      end
+
+      def show(id)
+        definition = fetch(id)
+        state = @states.fetch(definition.id)
+        state[:visible] = true
+        dock = @docks.fetch(definition.dock)
+        dock[:size], dock[:visible] = state[:size], true
+        definition
+      end
+
+      def hide(id)
+        definition = fetch(id)
+        state = @states.fetch(definition.id)
+        state[:size], state[:visible] = @docks.fetch(definition.dock)[:size], false
+        @docks.fetch(definition.dock)[:visible] = false if active(definition.dock).empty?
+        definition
+      end
+
+      def toggle(id) = visible?(id) ? hide(id) : show(id)
+
+      def active(dock)
+        raise ArgumentError, "invalid dock side" unless DOCKS.include?(dock)
+        @definitions.each_value.select { |definition| definition.dock == dock && visible?(definition.id) }
+      end
+
+      def badge(id, value)
+        definition = fetch(id).with(badge: value)
+        @definitions[definition.id] = definition
+      end
+
+      def resize(dock, size)
+        raise ArgumentError, "invalid dock size" unless size.is_a?(Numeric) && size.finite? && size.positive?
+        @docks.fetch(dock)[:size] = size
+        active(dock).each { |definition| @states.fetch(definition.id)[:size] = size }
+        size
+      end
+
+      def state
+        @states.to_h { |id, value| [id, {"visible" => value[:visible], "size" => value[:size]}] }
+      end
+
+      def restore(state, docks: nil)
+        raise ArgumentError, "panel state must be an object" unless state.is_a?(Hash) && state.length <= 1_000
+        restored = state.each_with_object({}) do |(id, value), result|
+          id = id.to_s
+          valid = value.is_a?(Hash) && [true, false].include?(value["visible"]) &&
+            value["size"].is_a?(Numeric) && value["size"].finite? && value["size"].positive?
+          raise ArgumentError, "invalid panel state: #{id}" if @definitions.key?(id) && !valid
+          next unless valid
+          result[id] = {visible: value["visible"], size: value["size"]}
+        end
+        @docks.replace(docks.transform_values(&:dup)) if docks
+        @states.merge!(restored)
+        self
+      end
+
+      private
+
+      def normalize(definition)
+        raise ArgumentError, "panel definition required" unless definition.is_a?(Definition)
+        id, title, icon, dock, build, badge = definition.deconstruct
+        valid_id = (id.is_a?(String) || id.is_a?(Symbol)) && !id.to_s.empty? &&
+          !id.to_s.include?(":") && !id.to_s.match?(/[\x00-\x1f\x7f]/)
+        raise ArgumentError, "invalid panel id" unless valid_id
+        raise ArgumentError, "panel title must be a string" unless title.is_a?(String)
+        raise ArgumentError, "invalid dock side" unless DOCKS.include?(dock)
+        raise ArgumentError, "panel builder must be callable" unless build.respond_to?(:call)
+        Definition.new(id.to_s.dup.freeze, title.dup.freeze, icon, dock, build, badge)
+      end
+    end
+  end
+end

data/lib/canopus/settings.rb

@@ -10,7 +10,12 @@ module Canopus
       "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" => {"bottom" => {"size" => 280, "visible" => false}.freeze}.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,
@@ -27,9 +32,17 @@ module Canopus
         "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"},
+      "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"}}}.freeze
+      "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
     attr_reader :values, :errors, :layers
     def self.schema = SCHEMA
     def self.user_path
@@ -163,8 +176,19 @@ module Canopus
 
     def validate_dock!
       dock = @values["dock"]
-      bottom = dock["bottom"] if dock.is_a?(Hash)
-      raise Error, "invalid dock.bottom" unless bottom.is_a?(Hash) && bottom["size"].is_a?(Numeric) && bottom["size"].positive? && [true, false].include?(bottom["visible"])
+      raise Error, "dock must be an object" unless dock.is_a?(Hash)
+      %w[left right bottom].each { |side| validate_dock_state!(dock[side], "dock.#{side}") }
+      panels = dock["panels"]
+      raise Error, "dock.panels must be an object" unless panels.is_a?(Hash) && panels.length <= 1_000
+      panels.each do |id, state|
+        raise Error, "invalid panel id" unless id.is_a?(String) && id.bytesize.between?(1, 256)
+        validate_dock_state!(state, "dock.panels.#{id}")
+      end
+    end
+
+    def validate_dock_state!(state, name)
+      valid_size = state.is_a?(Hash) && state["size"].is_a?(Numeric) && state["size"].finite? && state["size"].positive?
+      raise Error, "invalid #{name}" unless valid_size && [true, false].include?(state["visible"])
     end
   end
 end

data/lib/canopus/tab_map.rb

@@ -7,8 +7,9 @@ module Canopus
       raise ArgumentError, "tab size must be positive" unless tab_size.is_a?(Integer) && tab_size.positive?
       @tab_size = tab_size
     end
-    def transform(text, offsets, checkpoint: nil)
-      output, positions, column, i = +"", [offsets.first], 0, 0
+    def transform(text, offsets, checkpoint: nil, overlays: nil)
+      output, positions, column, i, input_byte = +"", [offsets.first], 0, 0, 0
+      boundaries = {0 => 0} if overlays
       text.each_grapheme_cluster do |char|
         checkpoint&.call if (i & 1023).zero?
         if char == "\t"
@@ -23,8 +24,12 @@ module Canopus
           column += char.ascii_only? ? char.length : Zaniah::Unicode.width(char)
         end
         i += char.length
+        input_byte += char.bytesize
+        boundaries[input_byte] = output.bytesize if boundaries
       end
-      [output, positions]
+      return [output, positions] unless overlays
+
+      [output, positions, overlays.map { |overlay| overlay.with(offset: boundaries.fetch(overlay.offset)) }.freeze]
     end
   end
 end

data/lib/canopus/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Canopus
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/canopus/workspace/git_aware.rb

@@ -30,6 +30,7 @@ module Canopus
     def invalidate_git
       @git_generation = (@git_generation || 0) + 1
       @git_status = @git_diff_cache = nil
+      @decorations.invalidate(:git)
       @panes.each do |pane|
         pane.editors.each do |current|
           current.display_map.block_map.blocks.values.each { |block| current.display_map.remove_block(block.id) if block.kind == :git_diff }
@@ -73,7 +74,10 @@ module Canopus
             diff = Porrima.diff(before, snapshot.to_s, context: 0)
             diff.hunks
             diff.marks
-            post { (@git_diff_cache ||= {})[key] = diff } unless @closed
+            post do
+              (@git_diff_cache ||= {})[key] = diff
+              @decorations.invalidate(:git, buffer: buffer)
+            end unless @closed
           rescue StandardError => error
             post { @message = "Git diff: #{error.message}" } unless @closed
           end
@@ -89,6 +93,18 @@ module Canopus
     end
     def git_hunks(buffer = editor.buffer, async: true) = git_diff(buffer, async: async)&.hunks || []
     def git_gutter_marks(buffer = editor.buffer) = git_diff(buffer)&.marks || []
+    def git_decorations(buffer, rows)
+      git_gutter_marks(buffer).filter_map do |mark|
+        first = [mark.new_line, 1].max - 1
+        count = mark.kind == :removed ? 1 : mark.count
+        next if first + count <= rows.begin || first >= rows.end
+
+        color = mark.kind == :removed ? :error : mark.kind == :added ? "#80b987" : :accent
+        style = {color: color, rows: count}.freeze
+        click = ->(current, row) { toggle_git_hunk(current, row: row) }
+        Decoration::Item.new(:gutter, nil, first, "Toggle Git hunk", style, 0, :git, click)
+      end
+    end
     def show_git_diff
       path = git_relative_path
       before = Buffer.decode_bytes(git.blob(path).to_s).first

data/lib/canopus/workspace/session_persistable.rb

@@ -19,9 +19,9 @@ module Canopus
         id
       end
       state = {version: 2, root: @root, layout: encode_layout(@layout), recent_files: @recent_files || [],
-        active_pane: @panes.index(@active_pane), docks: @docks,
+        active_pane: @panes.index(@active_pane), docks: @docks, panels: @panels.state,
         terminals: @terminals.map { |current| {cwd: current.vt.cwd || (current.respond_to?(:initial_cwd) ? current.initial_cwd : @root), title: @terminal_names[current]} },
-        active_terminal: @active_terminal_index, terminal_visible: !!@terminal_visible,
+        active_terminal: @active_terminal_index, terminal_visible: terminal_visible,
         panes: @panes.map do |pane|
           {active: pane.active_index, tabs: pane.editors.map do |current|
             {buffer_id: record.call(current.buffer), cursor: current.primary.head, pinned: pane.pinned.include?(current),
@@ -133,6 +133,14 @@ module Canopus
         raise Error, "invalid session dock" unless value.is_a?(Hash) && [true, false].include?(value["visible"]) && value["size"].is_a?(Numeric) && value["size"].finite? && value["size"].positive?
         restored_docks[side.to_sym] = {visible: value["visible"], size: value["size"].clamp(40, 4000)}
       end
+      restored_panels = data.fetch("panels", {})
+      raise Error, "invalid session panels" unless restored_panels.is_a?(Hash) && restored_panels.length <= 1_000
+      restored_panels.each do |id, value|
+        next unless @panels.key?(id)
+        valid = value.is_a?(Hash) && [true, false].include?(value["visible"]) &&
+          value["size"].is_a?(Numeric) && value["size"].finite? && value["size"].positive?
+        raise Error, "invalid session panel" unless valid
+      end
       active = data.fetch("active_pane", 0)
       raise Error, "invalid active pane" unless active.is_a?(Integer) && active.between?(0, restored_panes.length - 1)
       terminal_records = validate_session_terminals(data) if @settings["terminal"]["restore_on_startup"]
@@ -140,7 +148,8 @@ module Canopus
       close_language_documents
       @panes.each { |pane| pane.editors.each(&:dispose) }
       @buffers.each_value(&:close)
-      @panes, @buffers, @layout, @docks = restored_panes, restored_buffers, restored_layout, restored_docks
+      @panels.restore(restored_panels, docks: restored_docks)
+      @panes, @buffers, @layout = restored_panes, restored_buffers, restored_layout
       @active_pane = @panes[active]
       @recent_files = Array(data["recent_files"]).select { |item| item.is_a?(String) && File.file?(item) }.first(100)
       restore_terminals(data, terminal_records) if terminal_records
@@ -164,7 +173,7 @@ module Canopus
     end
 
     def restore_terminals(data, records)
-      old, old_index, old_visible = @terminals, @active_terminal_index, @terminal_visible
+      old, old_index, old_visible = @terminals, @active_terminal_index, terminal_visible
       @terminals = []
       records.each do |record|
         cwd = File.directory?(record["cwd"]) ? record["cwd"] : @root
@@ -172,12 +181,13 @@ module Canopus
         rename_terminal(record["title"], created) if record["title"].is_a?(String)
       end
       @active_terminal_index = @terminals.empty? ? 0 : data.fetch("active_terminal", 0)
-      @terminal_visible = !!data["terminal_visible"] && !@terminals.empty?
+      self.terminal_visible = !!data["terminal_visible"] && !@terminals.empty?
       old.each { |current| current.close if current.respond_to?(:close) }
     rescue StandardError
       @terminals.each { |current| current.close if current.respond_to?(:close) }
       @terminals = old
-      @active_terminal_index, @terminal_visible = old_index, old_visible
+      @active_terminal_index = old_index
+      self.terminal_visible = old_visible
       @message = "Session restored; terminals could not start"
     end
   end