canopus 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b3f1beb3dd3a5647f1ac04e7fc710356c5a90d4d8c3cefa01d676c463bd95950
+  data.tar.gz: 5e4b81d47c4c442b3f74b4e87745d0c8e7e06b3a4119ee845205fd6c1628f22a
+SHA512:
+  metadata.gz: ecb15f56e99c82bc6b7d7a1368096d5d4db4ea53b9993ea2ad3cd804ea5cd61fb6ca33a4470856d89a0e4ae22004d7876df992f8233a26e0864e2da27fbf5c71
+  data.tar.gz: 91e0d07140b34dda056874ce090bc37507a055f8f8685e5678c458cdfe74dd7d8137598793c2c8fb11152828de307f2f2b7e85040719c85b80bc6f3bce8d0cc9

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0 — 2026-09-11
+
+- Initial release.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,148 @@
+# Canopus
+
+A Ruby-native code editor built on Zaniah: persistent UTF-8 buffers, native GPU
+windows, language-server tools, a terminal, Git inspection, editable project
+search results, and Vim bindings.
+
+The launcher requires CRuby 3.1+. It attempts to enable YJIT on macOS/Linux
+and falls back to ordinary Ruby when unavailable; Windows uses ordinary Ruby
+([runtime decision](docs/adr/005-windows-runtime.md)). OS libraries use Fiddle; language
+servers and the terminal shell are user-installed programs. Ruby libraries are
+installed as gem dependencies; Prism is bundled with recent Ruby releases.
+
+Native windows need `require "fiddle"` to work in the chosen Ruby installation.
+On Ruby distributions that package it separately (including the Ruby 4.0 build
+used here), install that standard-library component first. Development Bundler
+configuration includes it; headless rendering does not load it.
+
+## Run from this checkout
+
+```sh
+bundle install
+bundle exec ruby exe/canopus --project . README.md
+ruby exe/canopus --headless /tmp/canopus.png README.md
+ruby exe/canopus --tui README.md
+```
+
+`--help` lists backend, session, settings, replay, cache, and plugin options.
+macOS uses Metal, Linux uses Wayland/EGL or X11/GLX, and Windows uses WGL.
+
+Install a local artifact with:
+
+```sh
+gem build canopus.gemspec
+gem install --local canopus-0.1.0.gem
+canopus --project .
+```
+
+See [packaging](docs/distribution.md) for desktop bundles and platform
+requirements.
+
+## Everyday controls
+
+| Action | macOS | Linux / Windows |
+| --- | --- | --- |
+| File finder / commands | Cmd-P / Cmd-Shift-P | Ctrl-P / Ctrl-Shift-P |
+| Save / undo / redo | Cmd-S / Cmd-Z / Cmd-Shift-Z | Ctrl-S / Ctrl-Z / Ctrl-Shift-Z |
+| Find / project search | Cmd-F / Cmd-Shift-F | Ctrl-F / Ctrl-Shift-F |
+| Replace / next occurrence | Cmd-Alt-F / Cmd-D | Ctrl-H / Ctrl-D |
+| All occurrences / move lines | Cmd-Shift-L / Alt-Up or Down | Ctrl-Shift-L / Alt-Up or Down |
+| Completion / definition | Ctrl-Space / F12 | Ctrl-Space / F12 |
+| Split / terminal | Cmd-Backslash / Ctrl-Backtick | Ctrl-Backslash / Ctrl-Backtick |
+
+The palette exposes Git diff/blame/hunk reversal/branch switching, language
+actions, project file operations, settings, themes, [Vim mode](docs/vim.md), and docks. Drag tabs
+to reorder or move them between panes; drag separators to resize panes and docks.
+Project deletion moves files into `.canopus/trash`. Dirty documents and disk
+save conflicts are preserved for an explicit decision.
+
+The file finder keeps recent files first and previews text without opening tabs.
+Completion supports additional edits and [snippets](docs/snippets.md), including
+mirrors, transforms, choices, and Tab / Shift-Tab navigation. Hover cards render
+bounded Markdown; only explicitly clicked HTTP(S) links open externally.
+Notifications are dismissible and expire automatically.
+
+Project-search results are editable; Save writes changes back to their source
+files. Replacement changes remain unsaved until then.
+
+Search palettes use Ctrl-Alt-R for regular expressions, Ctrl-Alt-C for case sensitivity,
+Ctrl-Alt-W for whole words and Ctrl-Alt-S for the selection captured when search opened.
+Replacements support Ruby backreferences, and stale selections are rejected.
+Resource-changing LSP actions show the affected paths before confirmation;
+PageUp / PageDown scroll the list. See [workspace edits](docs/workspace_edits.md).
+
+## Settings and extensions
+
+`settings.open` opens `.canopus/settings.jsonc`. User settings live at
+`$XDG_CONFIG_HOME/canopus/settings.jsonc` or
+`~/.config/canopus/settings.jsonc`. Layers are defaults, user, project, explicit
+`--settings`, then language overrides. Saved changes reload; invalid values
+preserve the previous valid settings. Ctrl-Space completes setting names.
+
+```jsonc
+{
+  "theme": "auto",
+  "font_size": 14,
+  "icon_theme": null,
+  "vim_mode": false,
+  "use_tabs": false,
+  "keymap": [
+    { "context": "Editor && !vim_mode", "bindings": { "ctrl-k ctrl-s": "file.save" } }
+  ],
+  "languages": { "ruby": { "tab_size": 2 } },
+  "language_servers": { "ruby": ["ruby-lsp"] }
+}
+```
+
+See [language servers](docs/lsp.md) for server-specific options and reload
+behavior.
+
+Keymap groups extend the defaults; later matching bindings win. Space-separated
+keys form a chord with a one-second timeout, and `null` removes a default action
+binding. Contexts support `Editor`, `vim_mode`, comparisons and boolean operators,
+not Ruby evaluation. Language-specific `keymap` arrays replace the global array.
+Saved keymaps reload atomically, including palette labels; invalid expressions
+leave the previous settings intact. Limits are 128 groups and 1,024 bindings.
+
+An icon theme is a JSONC file with `file`, `directory`, `expanded_directory`, and
+an `extensions` map (for example `".rb": "ruby.svg"`). SVG paths are relative to
+that theme file and must remain inside its directory. Only the supported static
+SVG subset is drawn; scripts, external references and entities are not executed.
+
+Plugins require explicit trust:
+
+```sh
+ruby exe/canopus --plugin examples/plugins/word_count.rb \
+  --trust-plugins --grant read_buffer
+```
+
+The default separate process contains crashes and timeouts. It is **not an OS
+security sandbox**: trusted Ruby retains the invoking user's OS privileges.
+API grants restrict the editor bridge, not arbitrary Ruby filesystem/network
+access. `--plugins-in-process` opts into direct execution.
+
+## Development and limits
+
+```sh
+bundle exec rake test
+bundle exec rake bench
+bundle exec ruby tools/check_dependencies.rb test/type/smoke.rb
+bundle exec rbs -I sig -r alhena -r antares -r denebola -r zaniah -r stringio -r strscan validate
+```
+
+Components are Zaniah, Alhena, Denebola, Spica, Kochab and Antares.
+Rouge supplies lexers; REXML parses static SVG; unicode-display_width and
+unicode-emoji supply terminal-cell tables. They are installed from RubyGems.
+
+Files over 100MiB use a bounded-cache UTF-8 read-only path without wrapping or
+folding. Large-file UTF-16/legacy encodings are not supported there. Rouge
+lexers that cannot resume exactly use a documented bounded-window fallback,
+which can approximate long-distance syntax state. Git supports SHA-1 repositories,
+not every Git index/object extension. See the [architecture decisions](docs/adr).
+
+Opt-in [profiling and local crash reports](docs/performance.md) expose real
+frame times and allocations without uploading project data.
+
+## License
+
+MIT; see [LICENSE.txt](LICENSE.txt).

data/docs/adr/001-runtime-gem-components.md

@@ -0,0 +1,24 @@
+# ADR 001: Consume released components as runtime gems
+
+- Status: Accepted
+- Date: 2026-09-11
+
+## Context
+
+Canopus uses components maintained and released from independent repositories.
+It can load them from sibling checkouts, copy their sources into this repository,
+combine the repositories, or depend on their released gems. An installed Canopus
+gem must not depend on the development directory layout.
+
+## Decision
+
+Keep each component repository as its source and release boundary. Consume its
+released gem as a runtime dependency without copying component sources into the
+Canopus repository or locating sibling checkouts.
+
+## Consequences
+
+Canopus packages stay small and component fixes follow normal gem releases.
+Installations require access to compatible component versions, and coordinated
+changes may need multiple releases. Revisit this decision if components can no
+longer provide compatible releases independently.

data/docs/adr/002-bounded-diff-engine.md

@@ -0,0 +1,22 @@
+# ADR 002: Use one bounded diff engine
+
+- Status: Accepted
+- Date: 2026-09-10
+
+## Context
+
+Git diffs must have predictable memory use and stable results for large or
+repetitive files. Canopus can use a general-purpose diff dependency, switch
+algorithms by input size, or apply one bounded implementation to every input.
+
+## Decision
+
+Use the linear-space Myers implementation for every Git diff instead of
+switching algorithms by input size.
+
+## Consequences
+
+Memory behavior and tie-breaking remain consistent across file sizes, but
+Canopus owns the implementation and its performance limits. Revisit this
+decision if a maintained implementation provides the same bounds and stable
+results with less maintenance.

data/docs/adr/003-background-language-analysis.md

@@ -0,0 +1,22 @@
+# ADR 003: Isolate background language analysis in processes
+
+- Status: Accepted
+- Date: 2026-09-10
+
+## Context
+
+Language analysis must not block editing, install stale results, or require
+`fork`, which is unavailable on native Windows. Work can run in threads sharing
+live objects or in portable child processes exchanging serializable data.
+
+## Decision
+
+Run named language-analysis handlers in bounded `Process.spawn` workers that
+exchange framed JSON. Install results on the foreground tick only when their
+document generation still matches.
+
+## Consequences
+
+Analysis is portable, cancellable, and isolated from mutable editor objects.
+Messages cannot carry live Ruby objects and require serialization. Revisit this
+decision if process startup or serialization prevents interactive performance.

data/docs/adr/004-persistent-display-map.md

@@ -0,0 +1,23 @@
+# ADR 004: Store display transforms in one persistent summary tree
+
+- Status: Accepted
+- Date: 2026-09-10
+
+## Context
+
+Folding, tab expansion, wrapping, and block inlays all transform buffer
+positions into displayed positions. Canopus can maintain separate mutable maps
+for each transform or combine their ordered summaries in one persistent tree.
+
+## Decision
+
+Represent Fold, Tab, Wrap, and Block transforms in one persistent summary tree.
+Keep hit testing and edits tied to exact buffer ranges while pixel reflow runs
+asynchronously.
+
+## Consequences
+
+Transforms share one source of positional truth and snapshots remain cheap.
+Updates and queries depend on the combined summary invariants, and asynchronous
+reflow can briefly show provisional layout. Revisit this decision if transforms
+stop being line-local or the combined tree becomes a measured bottleneck.

data/docs/adr/005-windows-runtime.md

@@ -0,0 +1,27 @@
+# ADR 005: Run native Windows without requiring YJIT
+
+- Status: Accepted
+- Date: 2026-09-10
+
+## Context
+
+The editor must run on macOS, Linux, and native Windows. Requiring YJIT on every
+platform conflicts with CRuby builds that do not support it on Windows. The
+alternatives are to reject those Windows runtimes, introduce a different JIT,
+or allow the supported CRuby interpreter while retaining the same functional
+and performance expectations.
+
+## Decision
+
+Require CRuby 3.1 or newer. Attempt to enable YJIT on macOS and Linux, falling
+back to the interpreter when the selected Ruby build lacks it. On native Windows,
+preserve an already enabled JIT but do not pass an unsupported YJIT flag.
+
+## Consequences
+
+The application can start on native Windows without maintaining another JIT or
+excluding the platform. Runtime performance now varies by Ruby build, so results
+must identify the engine and JIT state. This does not relax the performance or
+native-platform validation requirements. Revisit the decision when official
+Windows YJIT support is available or interpreter performance cannot satisfy the
+budgets.

data/docs/adr/README.md

@@ -0,0 +1,36 @@
+# Architecture decision records
+
+This directory records durable implementation choices made between credible
+alternatives. Operational workflow, release policy, command syntax, detailed
+formats, test evidence, benchmark results, and migration procedures belong in
+the relevant reference or design document.
+
+ADR filenames and headings use a gap-free three-digit sequence beginning with
+`001`. Create new records with this template:
+
+```markdown
+# ADR NNN: Implementation decision title
+
+- Status: Proposed
+- Date: YYYY-MM-DD
+
+## Context
+
+Describe the concrete implementation question and its compatibility, data,
+runtime, or component constraints. Operational workflow and release policy do
+not belong in this directory; see [the scope](README.md).
+
+Name the credible alternatives. If there was no meaningful alternative, record
+the behavior in reference documentation instead of creating an ADR.
+
+## Decision
+
+Describe the durable boundary or architecture choice. Leave command syntax,
+field-by-field formats, test evidence, benchmark results, and migration steps
+in their authoritative documents.
+
+## Consequences
+
+Describe the important positive and negative trade-offs, including what would
+make this decision worth revisiting.
+```

data/docs/distribution.md

@@ -0,0 +1,27 @@
+# Packaging
+
+`tools/package.rb` creates a source-based macOS app, Linux launcher and desktop
+file, or Windows launcher and shortcut installer. The package includes Canopus
+sources and assets, but not Ruby, native binaries, or gem dependencies.
+
+```sh
+ruby tools/package.rb --platform mac --output /tmp/Canopus.app --ruby /path/to/ruby
+ruby tools/package.rb --platform linux --output /tmp/canopus-linux --ruby /usr/bin/ruby
+ruby tools/package.rb --platform windows --output /tmp/canopus-windows --ruby ruby.exe
+ruby tools/package_test.rb
+```
+
+The output path must not exist and must be outside the source tree. Build for the
+Ruby executable available on the destination machine. Canopus requires CRuby
+3.1 or newer and its runtime gems installed for that Ruby. The installed package
+does not require Bundler.
+
+macOS's system Ruby is generally too old. Linux requires its Wayland/EGL/OpenGL
+or X11/GLX libraries, XKB, and `zenity` for file dialogs. Move a Linux package to
+its final location before installing its generated desktop file. On Windows, run
+`Create-Shortcut.ps1` from the package to create a shortcut.
+
+These packages are unsigned and do not bundle security updates for Ruby. Signing,
+notarization, automatic updates, and a relocatable Ruby runtime require separate
+platform-specific release work. See [ADR 005](adr/005-windows-runtime.md) for the
+Windows/YJIT runtime decision.

data/docs/lsp.md

@@ -0,0 +1,38 @@
+# Language servers
+
+Canopus uses separately installed language servers over LSP 3.17. Configure a
+server with an argument array or an options object:
+
+```json
+{
+  "language_servers": {
+    "ruby": {
+      "command": ["ruby-lsp"],
+      "env": {"RUBYOPT": null},
+      "initialization_options": {},
+      "configuration": {"rubyLsp": {"enabledFeatures": {"diagnostics": true}}}
+    }
+  }
+}
+```
+
+`languages.<language>.language_servers.<language>` overrides the global entry.
+An absent or `null` entry auto-detects the language's default executable; it does
+not disable the server. If no executable is found, Canopus leaves that language
+without a server. Invalid settings keep the previous working connection.
+
+Changes to the command, environment, or initialization options restart the
+connection and reopen its documents. A configuration-only change sends
+`workspace/didChangeConfiguration` without restarting. Resource-changing server
+requests require confirmation as described in [workspace edits](workspace_edits.md).
+
+Editor positions use UTF-8 byte offsets internally and are converted to LSP
+UTF-16 positions. Servers selecting another position encoding are rejected.
+Messages are limited to 32 MiB, crashes fail pending requests, and a connection
+is restarted at most three times.
+
+Developers can test installed servers with:
+
+```sh
+ruby script/lsp_interop.rb ruby rust typescript go
+```

data/docs/performance.md

@@ -0,0 +1,40 @@
+# Diagnostics
+
+Profiling and crash reports are opt-in:
+
+```sh
+ruby --yjit exe/canopus --profile /tmp/canopus-profile.json example.rb
+ruby --yjit exe/canopus --profile /tmp/canopus-allocations.json \
+  --trace-allocations example.rb
+ruby exe/canopus --crash-report /tmp/canopus-crash.json example.rb
+```
+
+`--profile` records bounded frame timings, Ruby allocation counts, stack samples,
+runtime details, and native draw counts when available. `--trace-allocations`
+also summarizes locations of live traced objects, but can substantially increase
+memory use and frame time. Missing native counters are reported as `null`.
+
+`--crash-report` writes only after a handled Ruby exception. It includes a bounded
+message, backtrace, cause chain, and runtime/rendering context. It does not include
+environment variables, command-line arguments, buffers, project files,
+screenshots, or arbitrary object values, and nothing is uploaded. Messages and
+backtraces can still contain local paths or sensitive text, so review reports
+before sharing them. Native crashes and process termination cannot reliably be
+captured by this hook.
+
+Use an existing private directory and a distinct filename for each report.
+Symlinks and paths overlapping selected input or configuration files are rejected.
+On macOS and Linux reports request mode `0600`; Windows users should choose a
+private directory with appropriate ACLs.
+
+Developers can produce current, reproducible measurements with:
+
+```sh
+ruby --yjit bench/frame_profile.rb --frames 120 --output /tmp/frames.json
+ruby bench/startup.rb --runs 3
+ruby --yjit tools/native_check.rb --idle /tmp/native-check.png
+```
+
+Compare results only when the platform, renderer, viewport, Ruby/JIT mode,
+warmup, and diagnostic options match. Headless software rendering is a regression
+check, not a hardware-GPU performance result.

data/docs/snippets.md

@@ -0,0 +1,32 @@
+# Snippets
+
+Canopus accepts [LSP/VS Code snippet syntax](https://code.visualstudio.com/docs/editing/userdefinedsnippets#_snippet-syntax),
+including numbered tab stops, nested defaults, mirrors, choices, variables, and
+placeholder transforms. Parsing never executes shell commands, Ruby, or
+JavaScript.
+
+```text
+${1:name} = ${2|value,nil|}$0
+${1/(.*)/${1:/upcase}/}
+```
+
+Tab and Shift-Tab move between fields. Mirrors update together, leaving a field
+applies its transforms, and `$0` ends the session. If `$0` is omitted, Canopus
+adds a final caret. Undo, redo, or starting another snippet ends the current
+session. Each cursor expands its own snippet and selected-text variables.
+
+Standard filename, workspace, selection, date/time, random, UUID, clipboard, and
+language-comment variables are available. Unknown bare variables become editable
+placeholders; known but unavailable variables use their default or an empty
+string.
+
+Transforms support the portable Ruby/JavaScript regular-expression overlap and
+flags `g`, `i`, `m`, `s`, and `u`. Replacement formats include capture references,
+case conversion, and conditional/default forms. JavaScript-only features such as
+Unicode property escapes and regex backreferences are rejected rather than
+silently changed. Ruby code and replacement text are never evaluated.
+
+Snippet source is limited to 1 MiB, expanded text and individual transform output
+to 4 MiB, nesting to 32 levels, and regular-expression execution to 50 ms. A
+navigation step has a combined 250 ms transform deadline. Exceeding a limit raises
+an error before transformed edits are committed.

data/docs/vim.md

@@ -0,0 +1,24 @@
+# Vim mode
+
+Set `"vim_mode": true` or use the command palette to enable modal editing. Canopus
+implements its own Vim-compatible command parser; it does not launch Vim.
+
+Modes include Normal, Insert, Replace, Visual, Visual Line, and Visual Block.
+Supported motions include character, word/WORD, line, paragraph, matching-pair,
+find-character, mark, and page motions. Counts compose with operators.
+
+Operators include delete, change, yank, shift, reindent, case conversion, and
+swap case. Text objects cover words, sentences, paragraphs, nested brackets,
+quotes, and tags. Visual-block operations use display cells, preserving partial
+tabs and wide Unicode glyphs. Undo/redo, repeat, joins, paste, registers, marks,
+macros, search, and substitution are supported.
+
+The Ex subset includes line addresses, `w [path]`, `reg`, tab/shift width and
+expand-tab options, relative numbers, and `s` with `g` and `i`. Other Ex commands
+are forwarded to workspace commands.
+
+Search and substitution use Ruby regular expressions, not Vim's magic dialect.
+Vimscript, arbitrary shell commands, and user mappings are not interpreted.
+Clipboard registers `+` and `*` are in-memory registers rather than OS clipboard
+integrations. Counts are capped at 10,000; macro playback allows 10 nested calls
+and 10,000 keys.

data/docs/workspace_edits.md

@@ -0,0 +1,32 @@
+# Language-server file operations
+
+Language servers can request ordered file creation, rename, deletion, and text
+edits. Canopus shows every resource-changing request before writing anything.
+Apply and Cancel are separate choices, resource operations default to Cancel,
+and cancelling reports failure to the server without changing files.
+
+Before confirmation, Canopus validates the complete operation sequence, including
+versions and paths produced by earlier operations in the same request. Text edits
+remain normal unsaved buffer changes. Renames preserve open buffers; filesystem
+operations are not part of text undo history.
+
+Safety rules:
+
+- Targets must be local paths inside the project. Traversal through parent
+  symlinks, special files, Git metadata, and the recovery directory is rejected.
+- Deletes and overwrites reject dirty or read-only documents. Rename destinations
+  must not collide with another open buffer.
+- Parent directories must already exist or be created earlier in the same request.
+  Deleting a nonempty directory requires an explicit recursive operation.
+- A request is limited to 10,000 document operations, 100,000 filesystem entries,
+  100,000 text edits, and 32 MiB of inserted text.
+
+Deleted files and overwritten destinations move to `.canopus/trash/lsp-*` with
+their original contents and permissions. Backups are not deleted automatically.
+If an operation fails, Canopus attempts to reverse completed moves and places new
+files in recovery rather than deleting them permanently.
+
+This is not an operating-system transaction. Concurrent external changes,
+permission failures, process termination, or callback errors can prevent complete
+rollback. Recovery never overwrites an unexpected destination; inspect the
+reported recovery paths before restoring files.

data/examples/native_smoke.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Development checkout: sibling gem paths are used only by this example.
+root = File.expand_path("../..", __dir__)
+%w[denebola zaniah alhena kochab spica antares canopus].each do |name|
+  $LOAD_PATH.unshift(File.join(root, name, "lib"))
+end
+require "canopus"
+
+workspace = Canopus::Workspace.new(root: File.expand_path("..", __dir__))
+workspace.open("lib/canopus.rb")
+window = Zaniah::Platform.open_window(backend: :mac, gpu: ARGV.include?("--gl") ? :opengl : :metal, width: 800, height: 500, title: "Canopus native integration")
+window.text_system = Zaniah::TextSystem::Renderer.new
+controller = Canopus::Controller.new(workspace, window)
+controller.tick
+workspace.split(:horizontal)
+controller.tick
+path = ARGV.find { |arg| arg.end_with?(".png") } || File.join(Dir.tmpdir, "canopus-native.png")
+window.write_png(path)
+raise "native scene was not submitted" unless window.device.draw_calls.positive?
+raise "split editor not rendered" unless controller.view.editor_bounds.length == 2
+puts "#{window.device.class}: #{window.device.draw_calls} draws, #{path}"
+workspace.close
+window.on_close { true }
+window.close

data/examples/plugins/word_count.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Requires explicit trust plus the read_buffer permission. Works in either mode.
+register_action("sample.word_count", description: "Count words in the current buffer") do |api|
+  text = api.text
+  api.notify("#{text.scan(/\S+/).length} words, #{text.length} characters")
+end
+
+register_panel("Word count", side: :right) do |api|
+  "Words: #{api.text.scan(/\S+/).length}"
+end

data/exe/canopus

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rbconfig"
+require "rubygems"
+unless RUBY_ENGINE == "ruby" && (RUBY_VERSION.split(".").first(2).map(&:to_i) <=> [3, 1]) >= 0
+  abort "Canopus requires CRuby 3.1 or newer."
+end
+unless RUBY_PLATFORM.match?(/mswin|mingw/) || RbConfig::CONFIG["YJIT_SUPPORT"] != "yes" ||
+    (defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled?) || ENV["CANOPUS_YJIT_REEXEC"] == "1"
+  ENV["CANOPUS_YJIT_REEXEC"] = "1"
+  flags = ["--yjit"]
+  exec(RbConfig.ruby, *flags, __FILE__, *ARGV)
+end
+ENV.delete("CANOPUS_YJIT_REEXEC")
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "canopus"
+require "canopus/cli"
+exit Canopus::CLI.main(ARGV)

data/lib/canopus/block_map.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Canopus
+  class BlockMap
+    Block = Data.define(:id, :row, :text, :kind)
+    attr_reader :blocks
+    def initialize = @blocks = {}
+    def insert(id, row:, text:, kind: :diagnostic) = @blocks[id] = Block.new(id, row, text, kind)
+    def remove(id) = @blocks.delete(id)
+    def at(row) = @blocks.values.select { |block| block.row == row }
+    def apply(patch)
+      @blocks.transform_values! do |block|
+        old = patch.before.line_start([block.row, patch.before.line_count - 1].min)
+        row = patch.after.point_at(patch.map_offset(old, bias: :left)).row
+        Block.new(block.id, row, block.text, block.kind)
+      end
+    end
+  end
+end