canopus 0.1.0

data/sig/lsp.rbs

@@ -0,0 +1,99 @@
+module Canopus
+  module LSP
+    type json = nil | bool | Integer | Float | String | Array[json] | Hash[String | Symbol, json]
+    type object = Hash[String | Symbol, json]
+    type semantic_token = { line: Integer, character: Integer, length: Integer, type: Integer, modifiers: Integer }
+
+    class Error < StandardError
+    end
+    class Timeout < Error
+    end
+    class ServerError < Error
+      attr_reader code: Integer
+      attr_reader data: json
+      def initialize: (Hash[String, json] error) -> void
+    end
+
+    module Protocol
+      def self.uri: (String path) -> String
+      def self.path: (String uri) -> String
+      def self.position: (Denebola::Rope rope, Integer offset) -> { line: Integer, character: Integer }
+      def self.offset: (Denebola::Rope rope, Hash[String, Integer] position) -> Integer
+      def self.range: (Denebola::Rope rope, Range[Integer] range) -> object
+      def self.uint?: (untyped value) -> bool
+      def self.diagnostics: (Array[object] values) -> Array[object]
+      def self.semantic_delta: (Array[Integer] data, Array[Hash[String, json]] edits) -> Array[Integer]
+      def self.semantic_tokens: (Array[Integer] data, ?legend: Hash[String, Array[String]]?) -> Array[semantic_token]
+    end
+
+    class Future
+      class Subscription
+        def initialize: () { () -> untyped } -> void
+        def detach: () -> untyped
+      end
+      attr_reader id: Integer | String | nil
+      attr_reader callback_errors: Array[Error]
+      def initialize: (Integer | String | nil id, ?on_error: ^(Error) -> untyped) ?{ (Integer | String | nil) -> untyped } -> void
+      def fulfill: (?untyped value, ?error: Exception?) -> Future?
+      def then: () { (untyped, Exception?) -> untyped } -> Future
+      def done?: () -> bool
+      def on_complete: () { () -> untyped } -> Subscription
+      def await: (?timeout: Numeric?) -> untyped
+      def cancel: () -> bool
+    end
+
+    class Transport
+      MAX_MESSAGE: Integer
+      attr_reader stderr_lines: Array[String]
+      attr_reader pid: Integer
+      def initialize: (Array[String] command, ?cwd: String?, ?env: Hash[String, String?]) { (Hash[String, json]?, Exception?) -> untyped } -> void
+      def self.read_message: (IO | StringIO io) -> Hash[String, json]?
+      def self.validate_message: (untyped message) -> Hash[String, json]
+      def write: (object message) -> untyped
+      def alive?: () -> bool
+      def close: () -> untyped
+    end
+
+    class Client
+      attr_reader capabilities: Hash[String, json]
+      attr_reader transport: Transport?
+      attr_reader diagnostics: Hash[String, Array[object]]
+      attr_reader state: :stopped | :starting | :running | :failed
+      attr_reader errors: Array[Error]
+      attr_reader server_info: Hash[String, json]?
+      attr_reader position_encoding: String?
+      def initialize: (command: Array[String], ?root: String, ?dispatch: ^() { () -> untyped } -> untyped, ?restart: bool, ?env: Hash[String, String?], ?initialization_options: json, ?configuration: object) -> void
+      def start: (?timeout: Numeric) -> self
+      def stop: () -> untyped
+      def request: (String | Symbol method, ?json params) -> Future
+      def notify: (String | Symbol method, ?json params) -> untyped
+      def on: (String | Symbol method) { (untyped) -> untyped } -> Proc
+      def supports?: (String | Symbol capability) -> bool
+      def workspace_symbols: (String query) -> Future
+      def resolve_completion: (object item) -> Future
+      def resolve_code_action: (object action) -> Future
+      def resolve_code_lens: (object lens) -> Future
+      def execute_command: (String command, ?arguments: Array[json]) -> Future
+      def open_document: (Buffer buffer, language_id: String) -> String
+      def close_document: (String uri) -> untyped
+      def save_document: (String uri) -> untyped
+      def at: (String method, Buffer buffer, Integer offset, **json params) -> Future
+      def completion: (Buffer buffer, Integer offset, **json params) -> Future
+      def hover: (Buffer buffer, Integer offset, **json params) -> Future
+      def definition: (Buffer buffer, Integer offset, **json params) -> Future
+      def typeDefinition: (Buffer buffer, Integer offset, **json params) -> Future
+      def implementation: (Buffer buffer, Integer offset, **json params) -> Future
+      def references: (Buffer buffer, Integer offset, **json params) -> Future
+      def rename: (Buffer buffer, Integer offset, **json params) -> Future
+      def signatureHelp: (Buffer buffer, Integer offset, **json params) -> Future
+      def documentSymbol: (Buffer buffer, **json params) -> Future
+      def formatting: (Buffer buffer, **json params) -> Future
+      def codeAction: (Buffer buffer, **json params) -> Future
+      def inlayHint: (Buffer buffer, **json params) -> Future
+      def codeLens: (Buffer buffer, **json params) -> Future
+      def diagnostic: (Buffer buffer, **json params) -> Future
+      def semantic_tokens: (Buffer buffer) -> Array[semantic_token]
+      def apply_text_edits: (Buffer buffer, Array[object] edits) -> untyped
+    end
+  end
+end

data/sig/markdown.rbs

@@ -0,0 +1,11 @@
+module Canopus
+  class Markdown
+    class Run < Data
+      attr_reader text: String
+      attr_reader style: Symbol | String
+      attr_reader url: String?
+    end
+    def initialize: (String source, ?width: Integer, ?max_rows: Integer, ?markup: bool) -> void
+    attr_reader rows: Array[Array[Run]]
+  end
+end

data/sig/performance_recorder.rbs

@@ -0,0 +1,23 @@
+module Canopus
+  class PerformanceRecorder
+    type statistics = {
+      frames: Integer, retained_frames: Integer, last_frame_ms: Float?,
+      last_allocations: Integer?, last_draw_calls: Integer?, median_frame_ms: Numeric,
+      p95_frame_ms: Numeric, max_frame_ms: Numeric, mean_allocations: Numeric,
+      sampling_samples: Integer
+    }
+    def initialize: (Zaniah::Platform::Headless::Window window, ?trace_allocations: bool, ?sampling: bool,
+      ?capacity: Integer, ?sample_capacity: Integer, ?interval: Numeric) -> void
+    attr_reader sampler: Thread?
+    def start: () -> self
+    def stop: () -> self
+    def measure: [A] () { () -> A } -> A
+    def statistics: () -> statistics
+    def report: () -> Hash[Symbol, untyped]
+    def write: (String path) -> String
+    def self.context: (?Zaniah::Platform::Headless::Window? window) -> Hash[Symbol, untyped]
+    def self.validate_paths: (Array[String?] paths, ?protected: Array[String?]) -> Array[String]
+    def self.write_json: (String path, untyped report) -> String
+    def self.write_crash: (String path, Exception exception, ?window: Zaniah::Platform::Headless::Window?) -> String
+  end
+end

data/sig/search_services.rbs

@@ -0,0 +1,8 @@
+module Canopus
+  class Buffer
+    def copy_anchor: (Buffer source, Anchor anchor) -> Anchor
+  end
+  class Workspace
+    def cancel_project_search: () -> void
+  end
+end

data/sig/services.rbs

@@ -0,0 +1,81 @@
+module Canopus
+  class Project
+    interface _NativeWatcher
+      def poll: (?timeout: Numeric) -> Array[untyped]
+      def close: () -> void
+    end
+    attr_reader root: String
+    def initialize: (String root) -> void
+    def path: (String relative) -> String
+    def files: (?include_hidden: bool, ?follow_symlinks: bool, ?include_symlinks: bool, ?include_directories: bool, ?extensions: Array[String]?, ?max_size: Integer?) -> Enumerator[String, self]
+             | (?include_hidden: bool, ?follow_symlinks: bool, ?include_symlinks: bool, ?include_directories: bool, ?extensions: Array[String]?, ?max_size: Integer?) { (String) -> void } -> self
+    def ignored?: (String relative, ?directory: bool) -> bool
+    def search: (String | Regexp pattern, ?workers: Integer, ?max_size: Integer?, ?extensions: Array[String]?, ?limit: Integer?, ?case_sensitive: bool, ?cancelled: ^() -> bool, ?paths: Array[String]?) ?{ (Search::Match) -> void } -> Array[Search::Match]
+    def replace: (String | Regexp pattern, String replacement, ?workers: Integer, ?max_size: Integer?, ?extensions: Array[String]?, ?limit: Integer?, ?case_sensitive: bool, ?cancelled: ^() -> bool, ?paths: Array[String]?) -> Hash[String, Integer]
+    def watcher: (?interval: Numeric, ?native: _NativeWatcher?) -> Watcher
+
+    class Search
+      DEFAULT_MAX_SIZE: Integer
+      class Match < Struct[untyped]
+        attr_accessor path: String
+        attr_accessor line: Integer
+        attr_accessor column: Integer
+        attr_accessor byte_offset: Integer
+        attr_accessor text: String
+        attr_accessor match: String
+        def self.new: (path: String, line: Integer, column: Integer, byte_offset: Integer, text: String, match: String) -> instance
+      end
+      def initialize: (Project project) -> void
+      def call: (String | Regexp pattern, ?workers: Integer, ?max_size: Integer?, ?extensions: Array[String]?, ?limit: Integer?, ?case_sensitive: bool, ?cancelled: ^() -> bool, ?paths: Array[String]?) ?{ (Match) -> void } -> Array[Match]
+    end
+    class IgnoreMatcher
+      class Rule < Struct[untyped]
+        attr_accessor base: String
+        attr_accessor expression: Regexp
+        attr_accessor negated: bool
+        attr_accessor directory: bool
+        def self.new: (base: String, expression: Regexp, negated: bool, directory: bool) -> instance
+      end
+      def initialize: (?Array[Rule] rules) -> void
+      def add: (String source, ?base: String) -> instance
+      def ignored?: (String path, ?directory: bool) -> bool
+    end
+    class Watcher
+      class Event < Struct[untyped]
+        attr_accessor type: :created | :modified | :deleted
+        attr_accessor path: String
+        def self.new: (type: :created | :modified | :deleted, path: String) -> instance
+      end
+      attr_reader backend: :native | :polling
+      attr_reader snapshot: Hash[String, [Integer, Integer, Time, Time]]
+      def initialize: (Project project, ?interval: Numeric, ?native: _NativeWatcher?) -> void
+      def poll: (?timeout: Numeric) -> Array[Event]
+      def start: () { (Event) -> void } -> self
+      def close: () -> self
+    end
+  end
+
+  class MultiBuffer < Buffer
+    class Excerpt < Struct[untyped]
+      attr_accessor buffer: Buffer
+      attr_accessor first: Buffer::Anchor
+      attr_accessor last: Buffer::Anchor
+      attr_accessor title: String
+      attr_accessor view_start: Integer?
+      attr_accessor view_end: Integer?
+      def self.new: (Buffer buffer, Buffer::Anchor first, Buffer::Anchor last, String title, ?Integer? view_start, ?Integer? view_end) -> instance
+    end
+    attr_reader excerpts: Array[Excerpt]
+    def initialize: (?excerpts: Array[[Buffer, Range[Integer]] | [Buffer, Range[Integer], String?]]) -> void
+    def add_excerpt: (Buffer buffer, Range[Integer] range, ?title: String?) -> self
+    def attach_sources: (Hash[Buffer, Buffer] replacements) -> self
+    def dirty?: () -> bool
+    def begin_undo_group: () -> self
+    def end_undo_group: () -> Array[Buffer]
+    def edit: (changes changes, ?kind: Symbol, ?selections: Array[Selection], ?before_selections: Array[Selection], ?time: Numeric, ?group: bool) -> patch?
+    def undo: () -> bool
+    def redo: () -> bool
+    def save: (?String? path, ?force: bool) -> self
+    def close: () -> void
+  end
+end

data/sig/snippet.rbs

@@ -0,0 +1,42 @@
+module Canopus
+  class Snippet
+    MAX_SOURCE: Integer
+    MAX_OUTPUT: Integer
+    MAX_DEPTH: Integer
+    MAX_NODES: Integer
+    VARIABLES: Array[String]
+
+    def initialize: (String source, ?variables: Hash[String | Symbol, String?]) -> void
+    attr_reader text: String
+    attr_reader tabstops: Hash[Integer, Array[Range[Integer]]]
+    attr_reader choices: Hash[Integer, Array[String]]
+    attr_reader transforms: Array[Occurrence]
+    attr_reader occurrences: Array[Occurrence]
+
+    class Occurrence < Data
+      attr_reader index: Integer
+      attr_reader range: Range[Integer]
+      attr_reader transform: Transform?
+      attr_reader parents: Array[Integer]
+      def self.new: (Integer index, Range[Integer] range, Transform? transform, Array[Integer] parents) -> instance
+    end
+
+    class Transform
+      TIMEOUT: Float
+      attr_reader pattern: String
+      attr_reader flags: String
+      def apply: (String value) -> String
+    end
+  end
+
+  class Editor
+    def insert_snippet: (String source, ?variables: Hash[String | Symbol, String?], ?workspace_root: String?, ?clipboard: String?) -> Snippet
+    def next_snippet: () -> bool
+    def previous_snippet: () -> bool
+    def snippet_active?: () -> bool
+    def snippet_choices: () -> Array[String]?
+    def choose_snippet: (String | Integer value) -> bool
+    def clear_snippet: () -> nil
+    def snippet_variables: (?workspace_root: String?, ?clipboard: String?, ?now: Time, ?selection: Selection, ?cursor_index: Integer) -> Hash[String, String?]
+  end
+end

data/sig/terminal.rbs

@@ -0,0 +1,125 @@
+module Canopus
+  module Terminal
+    type color = Integer | [Integer, Integer, Integer] | nil
+    type attributes = Hash[Symbol, bool | Integer | [Integer, Integer, Integer]]
+    type mouse_action = :press | :move | :release
+    class Cell < Struct[untyped]
+      attr_accessor text: String
+      attr_accessor width: Integer
+      attr_accessor foreground: color
+      attr_accessor background: color
+      attr_accessor attributes: attributes
+      attr_accessor hyperlink: String?
+      def self.new: (text: String, width: Integer, ?foreground: color, ?background: color, attributes: attributes, ?hyperlink: String?) -> instance
+    end
+    class Scrollback
+      include Enumerable[Array[Cell]]
+      class Count < Struct[untyped]
+        attr_accessor lines: Integer
+        def self.new: (Integer lines) -> instance
+        def self.zero: () -> instance
+        def +: (Count other) -> Count
+      end
+      class Row < Struct[untyped]
+        attr_accessor cells: Array[Cell]
+        def self.new: (Array[Cell] cells) -> instance
+        def summary: () -> Count
+      end
+      attr_reader tree: Denebola::Tree
+      attr_reader limit: Integer
+      def initialize: (Integer limit) -> void
+      def clear: () -> Denebola::Tree
+      def length: () -> Integer
+      alias size length
+      def []: (Integer index) -> Array[Cell]?
+      def each: () -> Enumerator[Array[Cell], Denebola::Tree]
+              | () { (Array[Cell]) -> void } -> Denebola::Tree
+      def push: (Array[Cell] cells) -> Denebola::Tree?
+    end
+    class Grid
+      attr_reader columns: Integer
+      attr_reader rows: Integer
+      attr_reader cells: Array[Array[Cell]]
+      attr_reader scrollback: Scrollback
+      attr_reader cursor_x: Integer
+      attr_reader cursor_y: Integer
+      attr_reader scroll_top: Integer
+      attr_reader scroll_bottom: Integer
+      attr_accessor foreground: color
+      attr_accessor background: color
+      attr_accessor attributes: attributes
+      attr_accessor hyperlink: String?
+      attr_accessor autowrap: bool
+      attr_accessor insert_mode: bool
+      attr_accessor origin_mode: bool
+      attr_accessor cursor_visible: bool
+      def initialize: (?columns: Integer, ?rows: Integer, ?scrollback: Integer) -> void
+      def reset: () -> void
+      def []: (Integer row, ?nil column) -> Array[Cell]?
+            | (Integer row, Integer column) -> Cell?
+      def alternate?: () -> bool
+      def lines: () -> Array[String]
+      def text: () -> String
+      def put: (String char) -> void
+      def self.width: (String char) -> Integer
+      def move: (?x: Integer, ?y: Integer, ?relative: bool) -> void
+      def position: (Integer row, Integer column) -> void
+      def carriage_return: () -> void
+      def backspace: () -> void
+      def linefeed: () -> void
+      def reverse_index: () -> void
+      def tab: (?Integer count, ?backward: bool) -> void
+      def tab_set: () -> Array[Integer]
+      def tab_clear: (?all: bool) -> void
+      def margins: (?Integer top, ?Integer bottom) -> void
+      def scroll_up: (?Integer count) -> void
+      def scroll_down: (?Integer count) -> void
+      def erase_display: (?Integer mode) -> void
+      def erase_line: (?Integer mode) -> void
+      def erase_characters: (?Integer count) -> void
+      def insert_characters: (?Integer count) -> void
+      def delete_characters: (?Integer count) -> void
+      def insert_lines: (?Integer count) -> void
+      def delete_lines: (?Integer count) -> void
+      def save_cursor: () -> void
+      def restore_cursor: () -> void
+      def alternate: (bool enable, ?save: bool) -> void
+      def resize: (columns: Integer, rows: Integer) -> void
+      def selection: ([Integer, Integer] start, [Integer, Integer] finish, ?history: bool) -> String
+      def links: (Integer row) -> Array[{url: String, column: Integer, end_column: Integer}]
+      def file_paths: (Integer row, ?cwd: String) -> Array[{path: String, line: Integer, column: Integer}]
+    end
+    class VT
+      DEC_GRAPHICS: Hash[String, String]
+      attr_reader grid: Grid
+      attr_reader title: String?
+      attr_reader cwd: String?
+      attr_reader modes: Hash[Integer, bool]
+      attr_reader replies: Array[String]
+      attr_reader bell_count: Integer
+      def initialize: (?Grid grid) ?{ (String) -> void } -> void
+      def feed: (String bytes) -> self
+      def paste: (String text) -> String
+      def mouse: (button: Symbol | Integer | nil, column: Integer, row: Integer, ?action: mouse_action, ?shift: bool, ?alt: bool, ?control: bool) -> String
+      def key: (String | Symbol name, ?shift: bool, ?alt: bool, ?control: bool) -> String
+    end
+    class PTY
+      attr_reader reader: IO?
+      attr_reader writer: IO?
+      attr_reader pid: Integer
+      attr_reader grid: Grid
+      attr_reader vt: VT
+      attr_reader status: Process::Status?
+      def initialize: (?command: String | Array[String], ?cwd: String, ?columns: Integer, ?rows: Integer, ?env: Hash[String, String?], ?scrollback: Integer) -> void
+      def read: (?timeout: Numeric?, ?max_bytes: Integer) -> String?
+      def write: (String bytes) -> Integer
+      def paste: (String text) -> Integer
+      def key: (String | Symbol name, ?shift: bool, ?alt: bool, ?control: bool) -> Integer
+      def mouse: (button: Symbol | Integer | nil, column: Integer, row: Integer, ?action: mouse_action, ?shift: bool, ?alt: bool, ?control: bool) -> Integer
+      def resize: (columns: Integer, rows: Integer) -> void
+      def signal: (?String | Integer name) -> void
+      def alive?: () -> bool
+      def close: () -> void
+    end
+  end
+end

data/sig/vim.rbs

@@ -0,0 +1,27 @@
+module Canopus
+  class Vim
+    type mode = :normal | :insert | :replace | :visual | :visual_line | :visual_block
+    type register = [String, bool | :block] | [String, :block, Integer]
+
+    OPERATORS: Array[String]
+    VISUAL_MODES: Array[Symbol]
+
+    def initialize: (Editor editor) -> void
+    attr_reader mode: mode
+    attr_reader registers: Hash[String, register]
+    attr_reader marks: Hash[String, Buffer::Anchor]
+    attr_reader macros: Hash[String, Array[String]]
+    attr_reader command_line: String?
+    attr_reader status: String
+    attr_accessor on_command: (^(String) -> void)?
+
+    # Input is a single grapheme or a normalized key such as "esc" or "ctrl-v".
+    def feed: (String key) -> void
+    # Zero-based UTF-8 byte offset of the active edge, including visual mode.
+    def cursor_position: () -> Integer
+    # On blur: finish insert history and return to Normal, preserving registers.
+    def deactivate: () -> self
+    # On close: finish history and release every owned buffer anchor.
+    def dispose: () -> void
+  end
+end

data/sig/workspace_edits.rbs

@@ -0,0 +1,11 @@
+module Canopus
+  module Workspace::Edit
+    # A preflighted, single-use plan. Resource changes still require explicit UI
+    # confirmation at Workspace#apply_workspace_edit; construction does not write.
+    class Plan
+      def initialize: (Workspace workspace, LSP::object edit) -> void
+      def apply: () -> LSP::object
+      def close: () -> void
+    end
+  end
+end

data/sig/workspace_services.rbs

@@ -0,0 +1,117 @@
+module Canopus
+  class Project::Tree
+    class Entry < Data
+      attr_reader path: String
+      attr_reader name: String
+      attr_reader depth: Integer
+      attr_reader directory: bool
+      attr_reader expanded: bool
+      def self.new: (String path, String name, Integer depth, bool directory, bool expanded) -> instance
+    end
+    attr_reader expanded: Set[String]
+    def initialize: (Array[String] files, ?expanded: Set[String]) -> void
+    def toggle: (String path) -> void
+    def reveal: (String path) -> void
+    def visible: () -> Array[Entry]
+  end
+  class IconTheme
+    FILE: String
+    FOLDER: String
+    def initialize: (?String? path) -> void
+    def texture: (String path, ?directory: bool, ?expanded: bool, ?size: Numeric, ?scale: Numeric, ?color: String) -> Zaniah::GPU::Texture
+  end
+  class Workspace
+    type layout_node = {pane: Pane} | {direction: :horizontal | :vertical, children: Array[layout_node]}
+    type palette_state = Hash[Symbol, untyped]
+    type search_options = { ?case_sensitive: bool, ?whole_word: bool, ?range: Range[Integer] }
+    type semantic_style = {line: Integer, character: Integer, length: Integer, type: Integer, modifiers: Integer, name: String?}
+    attr_reader actions: Zaniah::Input::ActionRegistry
+    attr_reader project: Project?
+    attr_reader docks: Hash[Symbol, {visible: bool, size: Numeric}]
+    attr_reader panels: Hash[String, [Symbol, ^() -> (Zaniah::Element | String)]]
+    attr_accessor window: Zaniah::Platform::Headless::Window?
+    attr_reader palette: palette_state?
+    def palette=: (palette_state? value) -> void
+    attr_accessor terminal: Terminal::PTY?
+    attr_accessor selected_project_path: String?
+    attr_reader hover_card: String?
+    attr_reader hover_markup: bool?
+    attr_reader semantic_styles: Hash[Buffer, [Integer, Array[semantic_style]]]?
+    def layout: () -> layout_node
+    def project_tree: () -> Project::Tree
+    def project_path: (String relative) -> String
+    def create_project_entry: (String relative, ?directory: bool) -> String
+    def rename_project_entry: (String relative, String destination) -> String
+    def trash_project_entry: (String relative) -> String
+    def file_preview: (String path) -> Array[String]
+    def start_watching: () -> void
+    def poll_changes: () -> void
+    def icon_theme: () -> IconTheme
+    def settings_path: () -> String
+    def open_settings: () -> Editor
+    def settings_completions: () -> palette_state
+    def settings_document?: (Buffer buffer) -> bool?
+    def configure_text_system: (?cache_dir: String?) -> Zaniah::TextSystem::Renderer
+    def apply_settings: () -> void
+    def poll_settings: (?force: bool) -> void
+    def dismiss_hover: () -> nil
+    def close_language_documents: (?Buffer? buffer) -> void
+    def semantic_spans_for: (Buffer buffer, Integer row) -> Array[[Integer, Integer, String]]
+    def accept_language_result: (palette_state palette, Integer index) -> void
+    def show_diagnostics: () -> void
+    def show_outline: () -> void
+    def git: () -> Git::Repository?
+    def git_status: () -> Hash[String, String]
+    def invalidate_git: () -> nil
+    def poll_git_changes: (?now: Numeric) -> void
+    def git_relative_path: (?Buffer buffer) -> String
+    def git_hunks: (?Buffer buffer, ?async: bool) -> Array[Git::Diff::Hunk]
+    def show_git_diff: () -> Language::Document
+    def toggle_git_hunk: (?Editor current, ?row: Integer?) -> bool
+    def show_git_blame: () -> String
+    def revert_current_hunk: () -> patch?
+    def checkout_branch: (String name) -> String
+    def search_query: (String query, palette_state state) -> [String | Regexp, search_options]
+    def search_project: (String query, ?regexp: bool, ?case_sensitive: bool, ?whole_word: bool, ?async: bool) -> (Thread | MultiBuffer | nil)
+    def replace_in_buffer: (String | Regexp pattern, String replacement, ?case_sensitive: bool, ?whole_word: bool, ?range: Range[Integer]?) -> Integer
+    def fold_current: () -> untyped
+    def language_ready: (Editor editor, Language::Document document) -> void
+  end
+  class Editor
+    def replace_selections: (String | Array[String] texts, ?kind: Symbol, ?group: bool, ?cursor_back: Integer, ?before_selections: Array[Selection]) -> Array[Selection]
+  end
+  class Language::Document
+    def invalidate: (patch patch) -> void
+    # Prism is a lazy optional parser; its native types are not a runtime or RBS
+    # dependency for applications which use other languages/headless rendering.
+    def ruby_syntax: () -> untyped
+  end
+  module Plugins
+    class API
+      def initialize: (Workspace workspace, Array[String] permissions) -> void
+      def permit!: (String permission) -> void
+    end
+  end
+  class Buffer::Transaction
+    attr_writer before: rope
+    attr_writer after: rope
+    attr_writer before_selections: Array[Selection]
+    attr_writer after_selections: Array[Selection]
+    attr_writer patch: patch
+    attr_writer kind: Symbol
+    attr_writer time: Numeric
+  end
+  class Snippet::Transform
+    type format_nodes = Array[String | Format]
+    class Format < Data
+      attr_reader index: Integer
+      attr_reader operation: String | Symbol
+      attr_reader positive: format_nodes
+      attr_reader negative: format_nodes
+      def self.new: (Integer index, String | Symbol operation, format_nodes positive, format_nodes negative) -> instance
+    end
+    def self.parse: (StringScanner scanner, Integer depth) -> instance
+    def self.parse_format: (StringScanner scanner, Array[String] endings, Integer depth, ?Array[Integer] budget) -> format_nodes
+    def initialize: (String pattern, format_nodes replacement, String flags) -> void
+  end
+end

data/tools/certify_snippet_regex.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Development oracle only. Node is never required by Canopus at runtime.
+require "json"
+require "open3"
+require_relative "../lib/canopus"
+
+patterns = ["", "a", ".", ".*", "^", "$", "^.$", "^a", "a$", '[a-z]+', '[^a]', '(a)?', '(a+)(b*)',
+  '(?=a)', '(?<=a)b', '(?:a|b)+', '\d+', '\w+', '\s+', '\S+', '\b', '\B', '[a\s]', '[\S]', '[a[b]']
+flags = ["", "g", "i", "gi", "m", "gm", "s", "gs", "u", "gu", "ims", "gimsu"]
+values = ["", "a", "A", "ab", "aab", "abc123", "aa\nbb", "a\r\nb", "a\rb", "\n", "日本", "a日本b",
+  "\u00a0", "x\ufeffy", "a\u2028b", "a\u2029b", "😀", "a😀b"]
+cases = patterns.product(flags, values).reject { |pattern, options, value| (!options.include?("u") || pattern == '\B') && value.match?(/[\u{10000}-\u{10ffff}]/) }
+javascript = <<~JS
+  let input = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', part => input += part);
+  process.stdin.on('end', () => {
+    const result = JSON.parse(input).map(([pattern, flags, value]) =>
+      Buffer.from(value.replace(new RegExp(pattern, flags), (...args) => {
+        const captures = args.slice(0, -2);
+        return [0, 1, 2].map(index => '[' + (captures[index] || '') + ']').join('');
+      })).toString('base64')
+    );
+    process.stdout.write(JSON.stringify(result));
+  });
+JS
+output, error, status = Open3.capture3("node", "-e", javascript, stdin_data: JSON.generate(cases))
+abort error unless status.success?
+expected = JSON.parse(output).map { |encoded| encoded.unpack1("m0").force_encoding(Encoding::UTF_8) }
+cases.each_with_index do |(pattern, options, value), index|
+  snippet = Canopus::Snippet.new("${VALUE/#{pattern}/[$0][$1][$2]/#{options}}", variables: {"VALUE" => value})
+  abort "Mismatch #{cases[index].inspect}: expected #{expected[index].inspect}, got #{snippet.text.inspect}" unless snippet.text == expected[index]
+end
+puts "Certified #{cases.length} snippet transform cases against JavaScript RegExp (#{patterns.length} patterns, #{flags.length} flag combinations, #{values.length} inputs)."