canopus 0.4.0 → 0.5.0

data/lib/canopus/workspace/problems_aware.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "zaniah/ui"
+
+module Canopus
+  module Workspace::ProblemsAware
+    PROBLEM_LABEL_LIMIT = 200
+    PROBLEM_FILTER_LIMIT = 4_096
+
+    def problems_tree
+      @problems_tree ||= Zaniah::UI::TreeView.new(problem_nodes, height: 320).on_select do |value, _event, _context|
+        select_problem(value)
+      end
+    end
+
+    def filter_problems(severity: nil, source: nil, text: nil)
+      severity = Diagnostics::SEVERITIES.fetch(severity, severity) if severity.is_a?(Symbol)
+      unless severity.nil? || severity.is_a?(Integer) && severity.between?(1, 4)
+        raise ArgumentError, "invalid problem severity"
+      end
+      unless source.nil? || Diagnostics::SOURCES.include?(source)
+        raise ArgumentError, "invalid problem source"
+      end
+      unless text.nil? || text.is_a?(String) && text.encoding == Encoding::UTF_8 && text.valid_encoding? &&
+          text.bytesize <= PROBLEM_FILTER_LIMIT && !text.include?("\0")
+        raise ArgumentError, "invalid problem text"
+      end
+
+      @problem_filter = {severity: severity, source: source, text: text&.downcase}.freeze
+      refresh_problems
+      @problem_filter
+    end
+
+    def show_problem_filter
+      self.palette = {kind: :problem_filter, query: +(@problem_filter_query || ""), index: 0, matches: []}
+    end
+
+    private
+
+    def apply_problem_filter(query)
+      unless query.is_a?(String) && query.encoding == Encoding::UTF_8 && query.valid_encoding? &&
+          query.bytesize <= PROBLEM_FILTER_LIMIT && !query.include?("\0")
+        raise ArgumentError, "invalid problem filter"
+      end
+      severity = source = nil
+      text = query.gsub(/(?:\A|\s+)(severity|source):(\S+)/i) do
+        key, value = Regexp.last_match(1).downcase, Regexp.last_match(2).downcase
+        if key == "severity"
+          severity = value == "all" ? nil : Diagnostics::SEVERITIES.find { |name, _| name.to_s == value }&.last
+          raise ArgumentError, "invalid problem severity" if value != "all" && !severity
+        else
+          source = value == "all" ? nil : Diagnostics::SOURCES.find { |name| name.to_s == value }
+          raise ArgumentError, "invalid problem source" if value != "all" && !source
+        end
+        " "
+      end.gsub(/\s+/, " ").strip
+      @problem_filter_query = query.dup.freeze
+      filter_problems(severity: severity, source: source, text: text)
+      @panels.show("problems")
+    end
+
+    def diagnostics_changed(uri)
+      uris = uri.is_a?(Array) ? uri : [uri]
+      targets = uris.each_with_object({}) do |value, result|
+        Sadr::Protocol.path(value)
+        result[value] = true
+      end
+      @buffers.each_value.uniq.each do |buffer|
+        invalidate_diagnostics(buffer) if buffer.path && targets.key?(Sadr::Protocol.uri(buffer.path))
+      end
+      refresh_problems
+    rescue Sadr::Error
+      nil
+    end
+
+    def refresh_problems
+      @problems_tree&.replace(problem_nodes)
+      count = @diagnostics.counts.values.sum
+      @panels.badge("problems", count.zero? ? nil : count) if @panels&.key?("problems")
+      @window&.request_frame
+      nil
+    end
+
+    def problem_nodes
+      filter = @problem_filter || {}
+      entries = @diagnostics.all(severity: filter[:severity], source: filter[:source])
+      if (text = filter[:text]) && !text.empty?
+        entries = entries.select { |entry| entry.diagnostic.fetch("message").downcase.include?(text) }
+      end
+      entries.group_by(&:uri).map do |uri, problems|
+        {id: [:problem_file, uri].freeze, label: problem_path(uri), value: nil,
+         children: problems.map do |entry|
+           diagnostic = entry.diagnostic
+           severity = Diagnostics::SEVERITIES.key(diagnostic.fetch("severity", 1))
+           line = diagnostic.dig("range", "start", "line") + 1
+           message = diagnostic.fetch("message").gsub(/\s+/, " ").strip
+           label = "#{severity} [#{entry.source}] #{line}: #{message}"
+           label = label.each_char.first(PROBLEM_LABEL_LIMIT - 1).join + "…" if label.length > PROBLEM_LABEL_LIMIT
+           {id: [:problem, entry.source, uri, diagnostic.object_id].freeze,
+            label: label.freeze, value: entry}.freeze
+         end.freeze}.freeze
+      end.freeze
+    end
+
+    def problem_path(uri)
+      path = Sadr::Protocol.path(uri)
+      prefix = @root + File::SEPARATOR
+      label = path.start_with?(prefix) ? path.delete_prefix(prefix) : path
+      label.length > PROBLEM_LABEL_LIMIT ? label.each_char.first(PROBLEM_LABEL_LIMIT - 1).join + "…" : label
+    end
+
+    def select_problem(entry)
+      return false unless entry.is_a?(Diagnostics::Entry)
+
+      path = Sadr::Protocol.path(entry.uri)
+      raise Error, "Problem target is not a file" unless File.file?(path)
+      target = open(path)
+      position = Sadr::Protocol.range_value(entry.diagnostic.fetch("range")).start
+      offset = Sadr::Protocol.offset(target.buffer.rope, position)
+      unless Sadr::Protocol.position(target.buffer.rope, offset) == position
+        raise Error, "Problem target position is no longer valid"
+      end
+      target.select(offset)
+      target.reveal_cursor
+      true
+    rescue Error, KeyError, RangeError, TypeError, SystemCallError, Sadr::Error => error
+      @message = "Cannot open problem: #{error.message}"
+      false
+    end
+  end
+end

data/lib/canopus/workspace/project_searchable.rb

@@ -68,8 +68,7 @@ module Canopus
     def prepare_project_search(pattern, generation, sources, settings:, paths: nil, async: true)
       work = lambda do
         prepared = nil
-        paths ||= @project.search(pattern, workers: 4, limit: 10_000,
-          cancelled: -> { search_cancelled?(generation) }).map(&:path).uniq.freeze
+        paths ||= search_project_paths(pattern, generation)
         next if search_cancelled?(generation)
         prepared = build_search_preparation(pattern, generation, sources, paths, settings)
         next unless prepared
@@ -95,6 +94,81 @@ module Canopus
       async ? @search_job = Thread.new(&work) : work.call
     end
 
+    def search_project_paths(pattern, generation)
+      project_search_matches(pattern, cancelled: -> { search_cancelled?(generation) }).map(&:path).uniq.freeze
+    end
+
+    def workspace_symbol_fallback(query, generation, deadline)
+      matches = project_search_matches(query, ignore_case: true,
+        cancelled: -> { workspace_symbol_cancelled?(generation, deadline) })
+      cancelled = -> { workspace_symbol_cancelled?(generation, deadline) }
+      lines, paths, symbols = {}.compare_by_identity, {}, []
+      matches.each do |match|
+        break if cancelled.call
+        symbol = fallback_workspace_symbol(match, lines: lines, paths: paths, cancelled: cancelled)
+        symbols << symbol if symbol
+      end
+      symbols.freeze
+    end
+
+    def project_search_matches(pattern, ignore_case: false, cancelled:)
+      Alkaid::Search.new(@root, pattern: pattern, ignore_case: ignore_case, ignore: @project.ignore_matcher, workers: 4,
+        max_file_size: 10 * 1024 * 1024, max_matches: 10_000, hidden: true, cancelled: cancelled).run
+    end
+
+    def fallback_workspace_symbol(match, lines: {}.compare_by_identity, paths: {}, cancelled: -> { false })
+      absolute = if paths.key?(match.path)
+        paths[match.path]
+      else
+        paths[match.path] = File.realpath(File.join(@root, match.path))
+      end
+      prefix = @root.end_with?(File::SEPARATOR) ? @root : @root + File::SEPARATOR
+      return unless absolute.start_with?(prefix)
+
+      range = match.ranges.first
+      state = lines[match.line] ||= {valid: match.line.valid_encoding?, offset: 0, units: 0}
+      return unless state[:valid] && range && range.begin >= 0 && range.end <= match.line.bytesize &&
+        match.line_number.positive? && !cancelled.call
+      first = workspace_symbol_utf16_column(match.line, range.begin, state, cancelled)
+      last = workspace_symbol_utf16_column(match.line, range.end, state, cancelled)
+      return unless first && last
+      preview = fallback_workspace_symbol_preview(match.line, range)
+      return if preview.empty?
+      {"name" => preview.freeze, "kind" => 13, "containerName" => match.path.dup.freeze,
+        "location" => {"uri" => Sadr::Protocol.uri(absolute).freeze, "range" => {
+          "start" => {"line" => match.line_number - 1, "character" => first}.freeze,
+          "end" => {"line" => match.line_number - 1, "character" => last}.freeze
+        }.freeze}.freeze}.freeze
+    rescue Errno::ENOENT, Errno::EACCES, Errno::ELOOP, EncodingError
+      nil
+    end
+
+    def workspace_symbol_utf16_column(line, target, state, cancelled)
+      offset, units = target < state[:offset] ? [0, 0] : state.values_at(:offset, :units)
+      update = offset == state[:offset]
+      while offset < target
+        return if cancelled.call
+        finish = [offset + Workspace::LanguageAware::WORKSPACE_SYMBOL_UTF16_CHUNK_BYTES, target].min
+        if finish < target
+          finish -= 1 while finish > offset && line.getbyte(finish)&.between?(0x80, 0xBF)
+        end
+        return if finish <= offset
+        units += line.byteslice(offset, finish - offset).encode(Encoding::UTF_16LE).bytesize / 2
+        offset = finish
+      end
+      state[:offset], state[:units] = offset, units if update
+      units
+    end
+
+    def fallback_workspace_symbol_preview(line, range)
+      first = [range.begin - 96, 0].max
+      first += 1 while first < range.begin && line.getbyte(first)&.between?(0x80, 0xBF)
+      last = [first + Workspace::LanguageAware::WORKSPACE_SYMBOL_PREVIEW_BYTES, line.bytesize].min
+      last -= 1 while last > range.begin && line.getbyte(last)&.between?(0x80, 0xBF)
+      preview = line.byteslice(first, last - first).to_s.gsub(/\s+/, " ").strip
+      bounded_workspace_symbol_text(preview, Workspace::LanguageAware::WORKSPACE_SYMBOL_PREVIEW_BYTES)
+    end
+
     def build_search_preparation(pattern, generation, sources, paths, settings)
       prepared = SearchPreparation.new(sources, {}, nil, 0, settings)
       excerpts = []
@@ -143,15 +217,17 @@ module Canopus
 
     def search_excerpt_ranges(rope, pattern, limit, generation)
       ranges, count = [], 0
-      rope.to_s.to_enum(:scan, pattern).each do
-        break if search_cancelled?(generation)
-        match = Regexp.last_match
-        row, last_row = rope.point_at(match.bytebegin(0)).row, rope.point_at(match.byteend(0)).row
-        first = rope.line_start([row - 1, 0].max)
-        last = last_row + 2 < rope.line_count ? rope.line_start(last_row + 2) : rope.bytesize
-        ranges.last && first <= ranges.last.end ? ranges[-1] = ranges.last.begin...[ranges.last.end, last].max : ranges << (first...last)
-        count += 1
-        break if count >= limit
+      Canopus.with_regexp_timeout(pattern) do
+        rope.to_s.to_enum(:scan, pattern).each do
+          break if search_cancelled?(generation)
+          match = Regexp.last_match
+          row, last_row = rope.point_at(match.bytebegin(0)).row, rope.point_at(match.byteend(0)).row
+          first = rope.line_start([row - 1, 0].max)
+          last = last_row + 2 < rope.line_count ? rope.line_start(last_row + 2) : rope.bytesize
+          ranges.last && first <= ranges.last.end ? ranges[-1] = ranges.last.begin...[ranges.last.end, last].max : ranges << (first...last)
+          count += 1
+          break if count >= limit
+        end
       end
       [ranges, count]
     end
@@ -197,6 +273,7 @@ module Canopus
       @buffers[projection.object_id] = projection
       @active_pane.editors << prepared.editor
       @active_pane.activate(@active_pane.editors.length - 1)
+      invalidate_hidden_selection_ranges
       @message = "#{prepared.count} matches — edit excerpts, then Save to save source files"
       @window&.request_frame
       prepared = nil

data/lib/canopus/workspace/project_tree_editable.rb

@@ -45,7 +45,9 @@ module Canopus
           close_language_documents(buffer)
         rescue StandardError => error
           @message = "Path moved; language server close failed: #{error.message}"
-          @opened_lsp_documents&.delete_if { |(_, document), _| document.equal?(buffer) }
+          @opened_lsp_documents&.keys&.each do |client, document|
+            forget_language_document(client, document) if document.equal?(buffer)
+          end
         end
         buffer.relocate(new_path)
         @buffers[new_path] = buffer

data/lib/canopus/workspace/recoverable.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Canopus
+  module Workspace::Recoverable
+    MAX_DRAFT_BYTES = 10 << 20
+    MAX_SNAPSHOT_BYTES = 64 << 20
+    SNAPSHOT_OVERHEAD_BYTES = 4 << 20
+    JSON_ESCAPE_FACTOR = 6
+
+    def recovery_directory = File.join(@root, ".canopus", "recovery")
+
+    def recovery_candidates
+      return [] unless @settings["recovery"]["enabled"] && recovery_directory_safe?
+      ignored = @ignored_recovery_candidates || []
+      Dir.glob(File.join(recovery_directory, "*.json")).reject do |path|
+        path == @recovery_path || ignored.include?(path) || recovery_candidate_locked?(path) || !valid_recovery_candidate?(path)
+      end.sort_by { |path| -File.mtime(path).to_f }
+    rescue SystemCallError
+      []
+    end
+
+    def offer_recovery
+      return false if @palette || !(candidate = recovery_candidates.first)
+      time = File.mtime(candidate).getlocal.strftime("%Y-%m-%d %H:%M:%S")
+      self.palette = {kind: :recovery, query: "Recover unsaved changes from #{time}?", index: 0,
+        matches: ["Restore", "Discard"], candidate: candidate}
+      true
+    rescue SystemCallError
+      false
+    end
+
+    def resolve_recovery(choice)
+      prompt = @palette
+      return false unless prompt&.dig(:kind) == :recovery
+      candidate = prompt.fetch(:candidate)
+      self.palette = nil
+      unless !recovery_candidate_locked?(candidate) && valid_recovery_candidate?(candidate)
+        raise Error, "recovery snapshot is no longer safe to read"
+      end
+      if choice == :restore
+        open_paths = @panes.flat_map { |pane| pane.editors.filter_map { |current| current.buffer.path } }.uniq
+        restore_session(candidate)
+        open_paths.each { |path| open(path) }
+        discard_recovery(candidate) if !@settings["recovery"]["enabled"] || poll_recovery(force: true)
+        self.message = "Recovered unsaved changes"
+      else
+        raise Error, "recovery snapshot is no longer safe to discard" unless discard_recovery(candidate)
+        self.message = "Discarded recovered changes"
+      end
+      true
+    rescue StandardError => error
+      (@ignored_recovery_candidates ||= []) << candidate if candidate
+      notify("Recovery ignored: #{error.message}")
+      false
+    end
+
+    def poll_recovery(now: Process.clock_gettime(Process::CLOCK_MONOTONIC), force: false)
+      recovery = @settings["recovery"]
+      return false if @closed
+      interval = recovery["interval"] / 1000.0
+      return false if !force && @last_recovery_poll && now - @last_recovery_poll < interval
+      @last_recovery_poll = now
+      (@recovery_mutex ||= Mutex.new).synchronize do
+        dirty = recovery_buffers.select(&:dirty?)
+        eligible = dirty.reject { |buffer| buffer.rope.bytesize > MAX_DRAFT_BYTES }
+        state = [recovery["enabled"], *dirty.map { |buffer| [buffer.object_id, buffer.version, buffer.path] }]
+        return false if !force && state == @recovery_state
+        if !recovery["enabled"] || eligible.empty?
+          remove_recovery_snapshot
+          notify("Crash recovery skipped #{dirty.length} buffer(s) larger than 10 MiB") if recovery["enabled"] && !dirty.empty?
+          @recovery_state = state
+          return false
+        end
+        if recovery_snapshot_too_large?(eligible)
+          remove_recovery_snapshot
+          notify("Crash recovery drafts exceeded the 64 MiB snapshot budget and were not retained")
+          @recovery_state = state
+          return false
+        end
+        ensure_recovery_storage
+        save_session(@recovery_path, max_draft_bytes: MAX_DRAFT_BYTES)
+        if File.size(@recovery_path) > MAX_SNAPSHOT_BYTES
+          remove_recovery_snapshot
+          notify("Crash recovery snapshot exceeded 64 MiB and was not retained")
+          @recovery_state = state
+          return false
+        end
+        notify("Crash recovery skipped #{dirty.length - eligible.length} buffer(s) larger than 10 MiB") if dirty.length != eligible.length
+        @recovery_state = state
+        true
+      end
+    rescue StandardError => error
+      notify("Crash recovery failed: #{error.message}")
+      false
+    end
+
+    def close_recovery(clean: true)
+      (@recovery_mutex ||= Mutex.new).synchronize do
+        remove_recovery_snapshot if clean
+        @recovery_lock&.close
+        @recovery_lock = nil
+        remove_recovery_lock if clean
+      end
+    end
+
+    def preserve_recovery! = @preserve_recovery = true
+
+    private
+
+    def recovery_buffers
+      @buffers.values.flat_map { |buffer| buffer.is_a?(MultiBuffer) ? buffer.excerpts.map(&:buffer) : buffer }.uniq
+    end
+
+    def ensure_recovery_storage
+      parent = File.dirname(recovery_directory)
+      raise Error, "recovery path is a symbolic link" if File.symlink?(parent) || File.symlink?(recovery_directory)
+      FileUtils.mkdir_p(parent)
+      begin
+        Dir.mkdir(recovery_directory, 0o700) unless File.directory?(recovery_directory)
+      rescue Errno::EEXIST
+        raise unless File.directory?(recovery_directory)
+      end
+      File.chmod(0o700, recovery_directory)
+      ignore = File.join(recovery_directory, ".gitignore")
+      begin
+        File.open(ignore, File::WRONLY | File::CREAT | File::EXCL, 0o600) { |file| file.write("*\n") }
+      rescue Errno::EEXIST
+        nil
+      end
+      initialize_recovery_lock
+    end
+
+    def initialize_recovery_lock
+      token = @recovery_token ||= "#{Process.pid}-#{SecureRandom.hex(12)}"
+      @recovery_path ||= File.join(recovery_directory, "#{token}.json")
+      @recovery_lock_path ||= File.join(recovery_directory, "#{token}.lock")
+      return if @recovery_lock
+      raise Error, "recovery lock is a symbolic link" if File.symlink?(@recovery_lock_path)
+      flags = File::RDWR | File::CREAT
+      flags |= File::NOFOLLOW if defined?(File::NOFOLLOW)
+      @recovery_lock = File.open(@recovery_lock_path, flags, 0o600)
+      raise Error, "recovery lock is already held" unless @recovery_lock.flock(File::LOCK_EX | File::LOCK_NB)
+    end
+
+    def valid_recovery_candidate?(path)
+      return false unless recovery_path_safe?(path) && File.file?(path) && File.size(path) <= MAX_SNAPSHOT_BYTES
+      data = JSON.parse(File.binread(path))
+      buffers = data["buffers"]
+      [1, 2].include?(data["version"]) && data["root"] == @root && buffers.is_a?(Hash) &&
+        buffers.length <= 10_000 && buffers.any? { |_, value| value.is_a?(Hash) && value["draft"].is_a?(String) }
+    rescue JSON::ParserError, JSON::NestingError, SystemCallError
+      false
+    end
+
+    def recovery_candidate_locked?(path)
+      return true unless recovery_path_safe?(path)
+      lock_path = path.sub(/\.json\z/, ".lock")
+      return true if File.symlink?(lock_path)
+      return false unless File.file?(lock_path)
+      File.open(lock_path, File::RDWR) do |lock|
+        acquired = lock.flock(File::LOCK_EX | File::LOCK_NB)
+        lock.flock(File::LOCK_UN) if acquired
+        !acquired
+      end
+    rescue Errno::EACCES, Errno::EAGAIN
+      true
+    rescue SystemCallError
+      false
+    end
+
+    def discard_recovery(path)
+      return false unless recovery_path_safe?(path) && !recovery_candidate_locked?(path)
+      lock_path = path.sub(/\.json\z/, ".lock")
+      return false if File.symlink?(lock_path)
+      File.delete(path) if File.file?(path)
+      File.delete(lock_path) if File.file?(lock_path)
+      true
+    end
+
+    def recovery_snapshot_too_large?(buffers)
+      SNAPSHOT_OVERHEAD_BYTES + buffers.sum { |buffer| buffer.rope.bytesize * JSON_ESCAPE_FACTOR } > MAX_SNAPSHOT_BYTES
+    end
+
+    def remove_recovery_snapshot
+      File.delete(@recovery_path) if @recovery_path && recovery_path_safe?(@recovery_path) && File.file?(@recovery_path)
+    end
+
+    def remove_recovery_lock
+      return unless @recovery_lock_path && recovery_directory_safe? && File.dirname(@recovery_lock_path) == recovery_directory
+      File.delete(@recovery_lock_path) if !File.symlink?(@recovery_lock_path) && File.file?(@recovery_lock_path)
+    end
+
+    def recovery_path_safe?(path)
+      recovery_directory_safe? && File.dirname(File.expand_path(path)) == recovery_directory && !File.symlink?(path)
+    end
+
+    def recovery_directory_safe?
+      parent = File.dirname(recovery_directory)
+      !File.symlink?(parent) && !File.symlink?(recovery_directory) && File.directory?(recovery_directory)
+    end
+  end
+end

data/lib/canopus/workspace/session_persistable.rb

@@ -2,36 +2,53 @@
 
 module Canopus
   module Workspace::SessionPersistable
-    def save_session(path)
+    def save_session(path, max_draft_bytes: nil)
       records = {}
       record = lambda do |buffer|
         id = buffer.object_id.to_s
         return id if records.key?(id)
-        records[id] = if buffer.is_a?(MultiBuffer)
-          {excerpts: buffer.excerpts.map do |excerpt|
-            {buffer: record.call(excerpt.buffer), first: excerpt.buffer.resolve(excerpt.first),
+        entry = if buffer.is_a?(MultiBuffer)
+          excerpts = buffer.excerpts.filter_map do |excerpt|
+            source = record.call(excerpt.buffer)
+            next unless source
+            {buffer: source, first: excerpt.buffer.resolve(excerpt.first),
               last: excerpt.buffer.resolve(excerpt.last), title: excerpt.title}
-          end}
+          end
+          next if excerpts.length != buffer.excerpts.length
+          {excerpts: excerpts}
         else
+          next if max_draft_bytes && (buffer.dirty? || !buffer.path) && buffer.rope.bytesize > max_draft_bytes
           {path: buffer.path, draft: buffer.dirty? || !buffer.path ? buffer.text : nil,
             digest: buffer.disk_digest, encoding: buffer.encoding.name, bom: buffer.bom.unpack1("H*"), read_only: buffer.read_only}
         end
+        records[id] = entry
         id
       end
       state = {version: 2, root: @root, layout: encode_layout(@layout), recent_files: @recent_files || [],
         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,
+        terminals: @terminals.map do |current|
+          cwd = current.respond_to?(:cwd) ? current.cwd : current.vt.cwd
+          {cwd: cwd || (current.respond_to?(:initial_cwd) ? current.initial_cwd : @root), title: @terminal_names[current],
+            profile: terminal_profile(current)}
+        end,
+        active_terminal: @active_terminal_index, terminal_layout: encode_terminal_layout(@terminal_layout),
+        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),
+          {active: pane.active_index, tabs: pane.editors.filter_map do |current|
+            buffer_id = record.call(current.buffer)
+            next unless buffer_id
+            {buffer_id: buffer_id, cursor: current.primary.head, pinned: pane.pinned.include?(current),
               selections: current.selections.map { |selection| {anchor: selection.anchor, head: selection.head} },
               scroll_x: current.scroll_x, scroll_y: current.scroll_y}
           end}
         end, buffers: records}
-      state[:background_buffers] = @buffers.values.select(&:dirty?).map { |buffer| record.call(buffer) }
+      state[:background_buffers] = @buffers.values.select(&:dirty?).filter_map { |buffer| record.call(buffer) }
+      if max_draft_bytes && state[:panes][state[:active_pane]][:tabs].empty?
+        state[:active_pane] = state[:panes].index { |pane| !pane[:tabs].empty? } || state[:active_pane]
+      end
       FileUtils.mkdir_p(File.dirname(path))
       Tempfile.create([".session-", ".json"], File.dirname(path)) do |file|
+        file.chmod(0o600)
         file.write(JSON.pretty_generate(state))
         file.flush
         file.fsync
@@ -69,6 +86,7 @@ module Canopus
         elsif entry["path"] && File.file?(entry["path"])
           buffer = Buffer.open(entry["path"])
         end
+        load_persistent_undo(buffer) if buffer && buffer.path && !buffer.dirty?
         loaded[id] = buffer
         if buffer
           key = buffer.path ? canonical_path(buffer.path) : buffer.object_id
@@ -146,10 +164,13 @@ module Canopus
       terminal_records = validate_session_terminals(data) if @settings["terminal"]["restore_on_startup"]
       clear_vim_states
       close_language_documents
+      @buffers.each_value { |buffer| detach_breakpoints(buffer) }
       @panes.each { |pane| pane.editors.each(&:dispose) }
       @buffers.each_value(&:close)
       @panels.restore(restored_panels, docks: restored_docks)
+      @panels.hide("hierarchy") if @panels.key?("hierarchy")
       @panes, @buffers, @layout = restored_panes, restored_buffers, restored_layout
+      @buffers.each_value { |buffer| attach_breakpoints(buffer) unless buffer.is_a?(MultiBuffer) }
       @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
@@ -166,29 +187,80 @@ module Canopus
 
     def validate_session_terminals(data)
       records = data.fetch("terminals", [])
-      raise Error, "invalid session terminals" unless records.is_a?(Array) && records.length <= 100 && records.all? { |item| item.is_a?(Hash) && item["cwd"].is_a?(String) }
+      valid = records.is_a?(Array) && records.length <= 100 && records.all? do |item|
+        item.is_a?(Hash) && item["cwd"].is_a?(String) && (item["profile"].nil? || item["profile"].is_a?(String))
+      end
+      raise Error, "invalid session terminals" unless valid
       active = data.fetch("active_terminal", 0)
       raise Error, "invalid active terminal" unless records.empty? || active.is_a?(Integer) && active.between?(0, records.length - 1)
+      if data["terminal_layout"]
+        visible = []
+        validate_terminal_layout(data["terminal_layout"], records.length, visible)
+        raise Error, "active terminal missing from layout" unless visible.include?(active)
+      end
       records
     end
 
     def restore_terminals(data, records)
-      old, old_index, old_visible = @terminals, @active_terminal_index, terminal_visible
+      old, old_index, old_visible, old_layout = @terminals, @active_terminal_index, terminal_visible, @terminal_layout
+      old_profiles = @terminal_profiles
       @terminals = []
+      @terminal_profiles = {}.compare_by_identity
+      @terminal_layout = nil
       records.each do |record|
         cwd = File.directory?(record["cwd"]) ? record["cwd"] : @root
-        created = new_terminal(cwd: cwd)
+        profile = record["profile"] if @settings["terminal"]["profiles"].key?(record["profile"])
+        created = new_terminal(cwd: cwd, profile: profile)
         rename_terminal(record["title"], created) if record["title"].is_a?(String)
       end
       @active_terminal_index = @terminals.empty? ? 0 : data.fetch("active_terminal", 0)
+      @terminal_layout = if @terminals.empty?
+        nil
+      elsif data["terminal_layout"]
+        decode_terminal_layout(data["terminal_layout"], @terminals)
+      else
+        {terminal: terminal}
+      end
+      invalidate_terminal_layout_resize
       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 = old_index
+      @terminal_profiles = old_profiles
+      @terminal_layout = old_layout
       self.terminal_visible = old_visible
       @message = "Session restored; terminals could not start"
     end
+
+    def encode_terminal_layout(node)
+      return unless node
+      return {terminal: @terminals.index(node[:terminal])} if node[:terminal]
+      {direction: node[:direction], ratio: node.fetch(:ratio, 0.5),
+        children: node[:children].map { |child| encode_terminal_layout(child) }}
+    end
+
+    def validate_terminal_layout(node, count, seen = [], depth = 0)
+      raise Error, "invalid terminal layout" unless node.is_a?(Hash) && depth < 100
+      if node.key?("terminal")
+        index = node["terminal"]
+        raise Error, "invalid terminal layout" unless index.is_a?(Integer) && index.between?(0, count - 1) && !seen.include?(index)
+        seen << index
+        return true
+      end
+      direction, ratio, children = node.values_at("direction", "ratio", "children")
+      valid = %w[horizontal vertical].include?(direction) && ratio.is_a?(Numeric) && ratio.finite? &&
+        ratio.between?(0.1, 0.9) && children.is_a?(Array) && children.length == 2
+      raise Error, "invalid terminal layout" unless valid
+      children.each { |child| validate_terminal_layout(child, count, seen, depth + 1) }
+      true
+    end
+
+    def decode_terminal_layout(node, terminals)
+      return {terminal: terminals.fetch(node.fetch("terminal"))} if node.key?("terminal")
+      {direction: node.fetch("direction").to_sym, ratio: node.fetch("ratio"),
+        children: node.fetch("children").map { |child| decode_terminal_layout(child, terminals) }}
+    end
   end
 end