Rename plugin to clever-tee

1 files changed, 0 insertions, 1165 deletions

diff --git a/lua/clever_f/host_adapter.lua b/lua/clever_f/host_adapter.lua
deleted file mode 100644
index a4ec77d..0000000
--- a/lua/clever_f/host_adapter.lua
+++ /dev/null
@@ -1,1165 +0,0 @@
-local capabilities = require("clever_f.capabilities")
-local domain = require("clever_f.domain")
-
-local M = {}
-local unpack_values = table.unpack or unpack
-local HostAdapter = {}
-HostAdapter.__index = HostAdapter
-M.HostAdapter = HostAdapter
-
-M.ActionEffect = {
-  NONE = "none",
-  ESCAPE = "escape",
-  ERROR = "error",
-}
-M.CONFIGURATION_PREFIX = "clever_f_"
-M.CONFIGURATION_GLOBALS = {
-  suppress_default_mappings = "clever_f_not_overwrites_standard_mappings",
-}
-
-local BOOLEAN_CONFIGURATION = {
-  search_current_line_only = true,
-  ignore_case = true,
-  smart_case = true,
-  use_migemo = true,
-  fix_key_direction = true,
-  show_prompt = true,
-  mark_cursor = true,
-  hide_cursor_on_cmdline = true,
-  mark_char = true,
-  mark_direct = true,
-  clean_labels_eagerly = true,
-}
-
-local adapter_records = setmetatable({}, { __mode = "k" })
-
-local function fail(message, level)
-  error(message, (level or 1) + 1)
-end
-
-local function current_runtime(options)
-  if type(options) == "table" then
-    if options.runtime ~= nil then
-      return options.runtime
-    end
-    if options.api ~= nil then
-      return options
-    end
-    return rawget(_G, "vim")
-  end
-  if options ~= nil and options ~= HostAdapter then
-    return options
-  end
-  return rawget(_G, "vim")
-end
-
-local function require_runtime(runtime)
-  if type(runtime) ~= "table" or type(runtime.api) ~= "table" then
-    fail("HostAdapter requires the Nvim Lua runtime", 3)
-  end
-  return runtime
-end
-
-function HostAdapter.new(options)
-  if HostAdapter.is(options) then
-    return options
-  end
-  local adapter = setmetatable({}, HostAdapter)
-  local record = {
-    runtime = require_runtime(current_runtime(options)),
-    next_identity = 1,
-    highlights = {},
-    timers = {},
-    cursor_presentations = {},
-    events = {},
-    actions = {},
-    mappings = {},
-    dot_repeat = nil,
-    dot_bridge = nil,
-    event_order = {},
-    action_diagnostics = nil,
-    augroup = nil,
-  }
-  record.event_queue = capabilities.EventQueue.new(function(_, delivery)
-    delivery.callback(delivery.name, delivery.payload)
-  end)
-  adapter_records[adapter] = record
-  return adapter
-end
-
-function HostAdapter.is(value)
-  return type(value) == "table" and adapter_records[value] ~= nil
-end
-
-function HostAdapter:runtime()
-  return adapter_records[self].runtime
-end
-
-function HostAdapter:read_text()
-  local lines = self:runtime().api.nvim_buf_get_lines(0, 0, -1, true)
-  if #lines == 0 then
-    lines = { "" }
-  end
-  return domain.TextSnapshot.new(lines)
-end
-
-function HostAdapter:read_buffer()
-  return self:runtime().api.nvim_get_current_buf()
-end
-
-function HostAdapter:read_window()
-  return self:runtime().api.nvim_get_current_win()
-end
-
-function HostAdapter:read_cursor()
-  local position = self:runtime().api.nvim_win_get_cursor(0)
-  return domain.Position.new(position[1], position[2] + 1)
-end
-
-function HostAdapter:read_mode()
-  return self:runtime().api.nvim_get_mode().mode
-end
-
-local function selection_option(runtime)
-  local value = runtime.api.nvim_get_option_value(
-    "selection",
-    { scope = "global" }
-  )
-  if value == "exclusive" then
-    return domain.SelectionOption.EXCLUSIVE
-  end
-  return domain.SelectionOption.INCLUSIVE
-end
-
-function HostAdapter:read_selection()
-  local runtime = self:runtime()
-  local context = domain.ModeContext.from_full_mode(self:read_mode())
-  local kind = context.visual_kind or context.select_kind
-  local option = selection_option(runtime)
-  if kind == nil then
-    return domain.Selection.inactive(option)
-  end
-  local raw_anchor = runtime.fn.getpos("v")
-  local focus = self:read_cursor()
-  local anchor
-  if type(raw_anchor) == "table"
-    and type(raw_anchor[2]) == "number"
-    and raw_anchor[2] > 0
-    and type(raw_anchor[3]) == "number"
-    and raw_anchor[3] > 0
-  then
-    anchor = domain.Position.new(raw_anchor[2], raw_anchor[3])
-  else
-    anchor = focus
-  end
-  return domain.Selection.active(kind, anchor, focus, option)
-end
-
-function HostAdapter:read_count()
-  local runtime = self:runtime()
-  local count = runtime.v.count1
-  if type(count) ~= "number" or count < 1 then
-    count = 1
-  end
-  return domain.Count.new(count)
-end
-
-local function configuration_global(name)
-  if type(name) ~= "string" or name == "" then
-    fail("configuration name must be a nonempty string", 3)
-  end
-  return M.CONFIGURATION_GLOBALS[name] or M.CONFIGURATION_PREFIX .. name
-end
-
-function M.configuration_global(name)
-  return configuration_global(name)
-end
-
-function HostAdapter:configuration_present(name)
-  local global = configuration_global(name)
-  return self:runtime().fn.exists("g:" .. global) == 1
-end
-
-local function normalize_configuration(name, value)
-  if BOOLEAN_CONFIGURATION[name] and type(value) == "number" then
-    return value ~= 0
-  end
-  return value
-end
-
-function HostAdapter:read_configuration(name)
-  local global = configuration_global(name)
-  return normalize_configuration(name, self:runtime().g[global])
-end
-
-function HostAdapter:write_configuration(name, value)
-  local global = configuration_global(name)
-  self:runtime().g[global] = value
-end
-
-function HostAdapter:read_encoding()
-  local runtime = self:runtime()
-  return runtime.api.nvim_get_option_value(
-    "encoding",
-    { scope = "global" }
-  )
-end
-
-function HostAdapter:lowercase(value)
-  if type(value) ~= "string" then
-    fail("case conversion value must be a string", 2)
-  end
-  local result = self:runtime().fn.tolower(value)
-  if type(result) ~= "string" then
-    fail("Nvim case conversion must return a string", 2)
-  end
-  return result
-end
-
-function HostAdapter:read_macro_state()
-  local register = self:runtime().fn.reg_executing()
-  return domain.MacroState.new(register ~= "" and register or nil)
-end
-
-local function fold_open_policies(value)
-  local result = {}
-  for item in tostring(value):gmatch("[^,]+") do
-    if item == "hor" then
-      item = "horizontal"
-    end
-    result[#result + 1] = item
-  end
-  return result
-end
-
-function HostAdapter:read_fold_state()
-  local runtime = self:runtime()
-  local foldopen = runtime.api.nvim_get_option_value(
-    "foldopen",
-    { scope = "global" }
-  )
-  local line = self:read_cursor().line
-  local closed_levels = runtime.fn.foldclosed(line) == -1 and 0 or 1
-  return domain.FoldState.new(
-    fold_open_policies(foldopen),
-    closed_levels
-  )
-end
-
-function HostAdapter:read_time_ms()
-  local runtime = self:runtime()
-  local uv = runtime.uv or runtime.loop
-  if type(uv) ~= "table" or type(uv.hrtime) ~= "function" then
-    fail("HostAdapter runtime must provide a monotonic clock", 2)
-  end
-  return uv.hrtime() / 1000000
-end
-
-function HostAdapter:read_pending_operator()
-  local operator = self:runtime().v.operator
-  if operator == nil then
-    return ""
-  end
-  return operator
-end
-
-function HostAdapter:apply_cursor(position)
-  position = domain.Position.coerce(position)
-  self:runtime().api.nvim_win_set_cursor(
-    0,
-    { position.line, position.byte_column - 1 }
-  )
-end
-
-function HostAdapter:apply_selection(position)
-  if domain.Selection.is(position) then
-    if not position.active then
-      fail("selection movement requires an active selection", 2)
-    end
-    position = position.focus
-  end
-  return self:apply_cursor(position)
-end
-
-function HostAdapter:set_operator_inclusive(enabled)
-  if type(enabled) ~= "boolean" then
-    fail("operator inclusivity must be a Boolean", 2)
-  end
-  if not enabled then
-    return
-  end
-
-  local runtime = self:runtime()
-  local api = runtime.api
-  local selection
-  if type(api.nvim_get_option_value) == "function" then
-    selection = api.nvim_get_option_value("selection", { scope = "global" })
-  end
-  if selection ~= "exclusive" then
-    api.nvim_cmd({
-      cmd = "normal",
-      bang = true,
-      args = { "v" },
-    }, {})
-    return
-  end
-  if type(api.nvim_set_option_value) ~= "function"
-    or type(runtime.schedule) ~= "function"
-  then
-    fail("HostAdapter cannot preserve exclusive selection during an operator", 2)
-  end
-
-  api.nvim_set_option_value("selection", "inclusive", { scope = "global" })
-  local ok, command_error = pcall(api.nvim_cmd, {
-    cmd = "normal",
-    bang = true,
-    args = { "v" },
-  }, {})
-  if not ok then
-    api.nvim_set_option_value("selection", selection, { scope = "global" })
-    error(command_error, 0)
-  end
-  runtime.schedule(function()
-    api.nvim_set_option_value("selection", selection, { scope = "global" })
-  end)
-end
-
-local function string_bytes(value)
-  local bytes = {}
-  for index = 1, #value do
-    bytes[index] = string.byte(value, index)
-  end
-  return bytes
-end
-
-function HostAdapter:read_input()
-  local runtime = self:runtime()
-  local value = runtime.fn.getcharstr()
-  if type(value) ~= "string" or value == "" then
-    fail("Nvim target input must be a nonempty string", 2)
-  end
-  local bytes = string_bytes(value)
-  if #bytes == 3
-    and bytes[1] == 0x80
-    and bytes[2] == 0xfd
-    and bytes[3] == 0x60
-  then
-    return domain.InputPacket.raw_bytes(bytes)
-  end
-  if #bytes == 1 and bytes[1] == 27 then
-    return domain.InputPacket.special_key("Escape", bytes)
-  end
-  if bytes[1] == 0x80 then
-    local name = type(runtime.fn.keytrans) == "function"
-        and runtime.fn.keytrans(value)
-      or "Special"
-    return domain.InputPacket.special_key(name, value)
-  end
-  return domain.InputPacket.text(value)
-end
-
-function HostAdapter:open_fold(position)
-  position = position and domain.Position.coerce(position) or self:read_cursor()
-  local runtime = self:runtime()
-  if runtime.fn.foldclosed(position.line) == -1 then
-    return false
-  end
-  runtime.api.nvim_cmd({
-    cmd = "normal",
-    bang = true,
-    args = { "zo" },
-  }, {})
-  return true
-end
-
-function HostAdapter:show_prompt(text)
-  if type(text) ~= "string" then
-    fail("prompt must be a string", 2)
-  end
-  self:runtime().api.nvim_echo({ { text } }, false, {})
-end
-
-function HostAdapter:redraw(kind)
-  if kind == "suppressed" then
-    return false
-  end
-  if kind ~= "screen" and kind ~= "full" then
-    fail("redraw kind must be screen, full, or suppressed", 2)
-  end
-  self:runtime().api.nvim_cmd({
-    cmd = "redraw",
-    bang = kind == "full",
-  }, {})
-  return true
-end
-
-local DIAGNOSTIC_LEVELS = {
-  error = "ERROR",
-  warning = "WARN",
-  info = "INFO",
-}
-
-function HostAdapter:emit_diagnostic(level, text)
-  local level_name = DIAGNOSTIC_LEVELS[level]
-  if level_name == nil then
-    fail("diagnostic level must be error, warning, or info", 2)
-  end
-  if type(text) ~= "string" or text == "" then
-    fail("diagnostic text must be a nonempty string", 2)
-  end
-  local record = adapter_records[self]
-  local runtime = record.runtime
-  if type(runtime.notify) ~= "function" then
-    fail("HostAdapter runtime must provide notify", 2)
-  end
-  local levels = type(runtime.log) == "table" and runtime.log.levels or {}
-  runtime.notify(text, levels[level_name], { title = "clever-f" })
-  if record.action_diagnostics ~= nil then
-    record.action_diagnostics[level .. "\0" .. text] = true
-  end
-end
-
-local install_dot_bridge
-
-function HostAdapter:register_dot_repeat(payload, callback)
-  if not domain.DotPayload.is(payload) then
-    fail("dot-repeat payload must be a DotPayload", 2)
-  end
-  if callback ~= nil and type(callback) ~= "function" then
-    fail("dot-repeat callback must be a function", 2)
-  end
-  local record = adapter_records[self]
-  record.dot_repeat = {
-    payload = payload,
-    callback = callback,
-    operator = self:read_pending_operator(),
-  }
-  if install_dot_bridge ~= nil then
-    install_dot_bridge(self)
-  end
-  if record.dot_bridge ~= nil then
-    record.dot_bridge.awaiting_change = true
-  end
-  return payload
-end
-
-function HostAdapter:dot_repeat_payload()
-  local registration = adapter_records[self].dot_repeat
-  return registration and registration.payload or nil
-end
-
-function HostAdapter:replay_dot(count)
-  local registration = adapter_records[self].dot_repeat
-  if registration == nil or registration.callback == nil then
-    fail("dot repeat is not executable", 2)
-  end
-  return registration.callback(
-    registration.payload,
-    domain.Count.new(count)
-  )
-end
-
-local function next_identity(adapter, prefix)
-  local record = adapter_records[adapter]
-  local identity = prefix .. "-" .. tostring(record.next_identity)
-  record.next_identity = record.next_identity + 1
-  return identity
-end
-
-local function highlight_exists(runtime, name)
-  if type(runtime.fn) == "table" and type(runtime.fn.hlexists) == "function" then
-    return runtime.fn.hlexists(name) == 1
-  end
-  local definition = runtime.api.nvim_get_hl(0, {
-    name = name,
-    link = true,
-    create = false,
-  })
-  return next(definition) ~= nil
-end
-
-function HostAdapter:read_highlight_group(name)
-  if type(name) ~= "string" or name == "" then
-    fail("highlight group name must be a nonempty string", 2)
-  end
-  local runtime = self:runtime()
-  if not highlight_exists(runtime, name) then
-    return nil
-  end
-  return runtime.api.nvim_get_hl(0, {
-    name = name,
-    link = true,
-    create = false,
-  })
-end
-
-local function native_highlight_definition(definition, options)
-  if type(definition) ~= "table" then
-    fail("highlight group definition must be a table", 3)
-  end
-  options = options or {}
-  if type(options) ~= "table" then
-    fail("highlight group options must be a table", 3)
-  end
-  local native = {}
-  for key, value in pairs(definition) do
-    if key ~= "guifg" and key ~= "guibg" and key ~= "gui" then
-      native[key] = value
-    end
-  end
-  if definition.guifg ~= nil then
-    native.fg = definition.guifg
-  end
-  if definition.guibg ~= nil then
-    native.bg = definition.guibg
-  end
-  for key, value in pairs(definition.gui or {}) do
-    native[key] = value
-  end
-  if options.default ~= nil then
-    native.default = options.default
-  end
-  if options.force ~= nil then
-    native.force = options.force
-  end
-  return native
-end
-
-function HostAdapter:define_highlight_group(name, definition, options)
-  if type(name) ~= "string" or name == "" then
-    fail("highlight group name must be a nonempty string", 2)
-  end
-  options = options or {}
-  local runtime = self:runtime()
-  if options.default and highlight_exists(runtime, name) then
-    return false
-  end
-  runtime.api.nvim_set_hl(
-    0,
-    name,
-    native_highlight_definition(definition, options)
-  )
-  return true
-end
-
-local function overlay_positions(specification)
-  local positions = specification.positions
-  if positions == nil and specification.position ~= nil then
-    positions = { specification.position }
-  end
-  if type(positions) ~= "table" then
-    fail("highlight positions must be a list", 3)
-  end
-  local native = {}
-  for index, position in ipairs(positions) do
-    position = domain.Position.coerce(position)
-    native[index] = { position.line, position.byte_column }
-  end
-  if #native == 0 then
-    native[1] = { 0 }
-  end
-  return native
-end
-
-local function overlay_priority(value)
-  if value == "high" then
-    return 100
-  end
-  if value == "ordinary" or value == nil then
-    return 10
-  end
-  if type(value) == "number" then
-    return value
-  end
-  fail("highlight priority must be high, ordinary, or numeric", 3)
-end
-
-function HostAdapter:create_highlight(specification)
-  if type(specification) ~= "table" then
-    fail("highlight specification must be a table", 2)
-  end
-  if type(specification.group) ~= "string" or specification.group == "" then
-    fail("highlight group must be a nonempty string", 2)
-  end
-  if specification.window == nil then
-    fail("highlight window must identify its Nvim window", 2)
-  end
-  local record = adapter_records[self]
-  local identity = specification.identity or next_identity(self, "highlight")
-  if record.highlights[identity] ~= nil then
-    fail("highlight identity is already active", 2)
-  end
-  local match_id = record.runtime.fn.matchaddpos(
-    specification.group,
-    overlay_positions(specification),
-    overlay_priority(specification.priority),
-    -1,
-    { window = specification.window }
-  )
-  if type(match_id) ~= "number" or match_id < 0 then
-    fail("Nvim could not create the window-local highlight", 2)
-  end
-  record.highlights[identity] = {
-    match_id = match_id,
-    window = specification.window,
-  }
-  return identity
-end
-
-function HostAdapter:remove_highlight(identity)
-  local record = adapter_records[self]
-  local resource = record.highlights[identity]
-  if resource == nil then
-    return false
-  end
-  record.highlights[identity] = nil
-  record.runtime.fn.matchdelete(resource.match_id, resource.window)
-  return true
-end
-
-local function nonnegative_integer(value, name)
-  if type(value) ~= "number"
-    or value < 0
-    or value ~= math.floor(value)
-    or value == math.huge
-  then
-    fail((name or "value") .. " must be a nonnegative integer", 3)
-  end
-  return value
-end
-
-function HostAdapter:supports_timers()
-  local fn = self:runtime().fn
-  return type(fn) == "table"
-    and type(fn.timer_start) == "function"
-    and type(fn.timer_stop) == "function"
-end
-
-function HostAdapter:start_timer(delay_ms, callback)
-  nonnegative_integer(delay_ms, "timer delay")
-  if type(callback) ~= "function" then
-    fail("timer callback must be a function", 2)
-  end
-  if not self:supports_timers() then
-    return nil
-  end
-  local record = adapter_records[self]
-  local identity = next_identity(self, "timer")
-  local timer_id = record.runtime.fn.timer_start(delay_ms, function()
-    local resource = record.timers[identity]
-    if resource == nil or not resource.active then
-      return
-    end
-    record.timers[identity] = nil
-    callback(identity)
-  end)
-  if type(timer_id) ~= "number" or timer_id < 0 then
-    fail("Nvim could not start the timer", 2)
-  end
-  record.timers[identity] = {
-    timer_id = timer_id,
-    active = true,
-  }
-  return identity
-end
-
-function HostAdapter:stop_timer(identity)
-  local record = adapter_records[self]
-  local resource = record.timers[identity]
-  if resource == nil or not resource.active then
-    return false
-  end
-  record.timers[identity] = nil
-  record.runtime.fn.timer_stop(resource.timer_id)
-  return true
-end
-
-local function event_names(value)
-  if type(value) == "string" then
-    value = { value }
-  end
-  if type(value) ~= "table" or #value == 0 then
-    fail("event names must be a nonempty list", 3)
-  end
-  local names = {}
-  local set = {}
-  for index, name in ipairs(value) do
-    if type(name) ~= "string" or name == "" then
-      fail("event name must be a nonempty string", 3)
-    end
-    if not set[name] then
-      names[#names + 1] = name
-      set[name] = true
-    end
-  end
-  return names, set
-end
-
-local function event_payload(adapter, event)
-  local payload = {
-    buffer = event.buf,
-    file = event.file,
-    match = event.match,
-    data = event.data,
-  }
-  local api = adapter:runtime().api
-  if type(api.nvim_get_current_win) == "function" then
-    payload.window = api.nvim_get_current_win()
-  end
-  return payload
-end
-
-local function event_augroup(record)
-  if record.augroup == nil then
-    record.augroup = record.runtime.api.nvim_create_augroup(
-      "clever_f",
-      { clear = true }
-    )
-  end
-  return record.augroup
-end
-
-local function queue_event(record, name, payload, callback)
-  return record.event_queue:emit(name, {
-    name = name,
-    payload = payload,
-    callback = callback,
-  })
-end
-
-function HostAdapter:register_events(names, callback, options)
-  local name_set
-  names, name_set = event_names(names)
-  if type(callback) ~= "function" then
-    fail("event callback must be a function", 2)
-  end
-  options = options or {}
-  if type(options) ~= "table" then
-    fail("event registration options must be a table", 2)
-  end
-  local record = adapter_records[self]
-  local identity = next_identity(self, "event-registration")
-  local autocmd_options = {
-    group = event_augroup(record),
-    desc = "clever-f " .. table.concat(names, "/"),
-    callback = function(event)
-      local resource = record.events[identity]
-      if resource ~= nil and resource.active then
-        queue_event(
-          record,
-          event.event,
-          event_payload(self, event),
-          resource.callback
-        )
-      end
-    end,
-  }
-  if options.buffer ~= nil then
-    autocmd_options.buffer = options.buffer
-  end
-  local autocmd_id = record.runtime.api.nvim_create_autocmd(
-    names,
-    autocmd_options
-  )
-  record.events[identity] = {
-    autocmd_id = autocmd_id,
-    names = names,
-    name_set = name_set,
-    callback = callback,
-    buffer = options.buffer,
-    active = true,
-  }
-  record.event_order[#record.event_order + 1] = identity
-  return identity
-end
-
-function HostAdapter:remove_event_registration(identity)
-  local record = adapter_records[self]
-  local resource = record.events[identity]
-  if resource == nil or not resource.active then
-    return false
-  end
-  resource.active = false
-  record.runtime.api.nvim_del_autocmd(resource.autocmd_id)
-  return true
-end
-
-local DOT_MOTION_MAPPING = "<Plug>(clever-f-dot-motion)"
-
-local function dot_bridge_supported(runtime)
-  return type(runtime.keymap) == "table"
-    and type(runtime.keymap.set) == "function"
-    and type(runtime.keymap.del) == "function"
-    and type(runtime.fn.maparg) == "function"
-    and type(runtime.fn.mapset) == "function"
-    and type(runtime.api.nvim_feedkeys) == "function"
-end
-
-local function restore_dot_mapping(record)
-  local bridge = record.dot_bridge
-  if bridge == nil or not bridge.active then
-    return false
-  end
-  bridge.active = false
-  pcall(record.runtime.keymap.del, "n", ".")
-  if type(bridge.previous_mapping) == "table"
-    and next(bridge.previous_mapping) ~= nil
-  then
-    record.runtime.fn.mapset("n", false, bridge.previous_mapping)
-  end
-  return true
-end
-
-local function dot_replay_keys(runtime, count, operator)
-  local prefix = count > 0 and tostring(count) or ""
-  local keys = prefix .. operator .. DOT_MOTION_MAPPING
-  if type(runtime.keycode) == "function" then
-    return runtime.keycode(keys)
-  end
-  return runtime.api.nvim_replace_termcodes(keys, true, false, true)
-end
-
-install_dot_bridge = function(adapter)
-  local record = adapter_records[adapter]
-  local runtime = record.runtime
-  if not dot_bridge_supported(runtime) then
-    return nil
-  end
-  local bridge = record.dot_bridge
-  if bridge == nil then
-    bridge = {
-      active = false,
-      awaiting_change = false,
-      previous_mapping = nil,
-    }
-    record.dot_bridge = bridge
-    runtime.keymap.set("o", DOT_MOTION_MAPPING, function()
-      local registration = record.dot_repeat
-      if registration == nil or registration.callback == nil then
-        return
-      end
-      local outcome = registration.callback(
-        registration.payload,
-        adapter:read_count()
-      )
-      if domain.ActionOutcome.is(outcome) then
-        adapter:translate_action_outcome(outcome)
-      end
-    end, {
-      silent = true,
-      remap = false,
-      desc = "clever-f dot motion",
-    })
-    local has_cmd_atom = type(runtime.fn.exists) == "function"
-      and runtime.fn.exists("##CmdAtom") == 1
-    local ownership_events = has_cmd_atom
-        and "CmdAtom"
-      or { "TextChanged", "TextChangedI", "TextChangedP" }
-    runtime.api.nvim_create_autocmd(ownership_events, {
-      group = event_augroup(record),
-      desc = "clever-f dot ownership",
-      callback = function(event)
-        if has_cmd_atom and not (event.data and event.data.changed) then
-          return
-        end
-        if bridge.awaiting_change then
-          bridge.awaiting_change = false
-          return
-        end
-        restore_dot_mapping(record)
-      end,
-    })
-  end
-  if not bridge.active then
-    bridge.previous_mapping = runtime.fn.maparg(".", "n", false, true)
-    runtime.keymap.set("n", ".", function()
-      local registration = record.dot_repeat
-      if registration == nil or registration.operator == "" then
-        restore_dot_mapping(record)
-        runtime.api.nvim_feedkeys(".", "n", false)
-        return
-      end
-      bridge.awaiting_change = true
-      local count = runtime.v.count or 0
-      runtime.api.nvim_feedkeys(
-        dot_replay_keys(runtime, count, registration.operator),
-        "n",
-        false
-      )
-    end, {
-      silent = true,
-      remap = false,
-      desc = "clever-f dot repeat",
-    })
-    bridge.active = true
-  end
-  return bridge
-end
-
-function HostAdapter:deliver_event(name, payload)
-  if type(name) ~= "string" or name == "" then
-    fail("event name must be a nonempty string", 2)
-  end
-  payload = payload or {}
-  local record = adapter_records[self]
-  local event_buffer = payload.buffer
-  for _, identity in ipairs(record.event_order) do
-    local resource = record.events[identity]
-    if resource.active
-      and resource.name_set[name]
-      and (resource.buffer == nil
-        or event_buffer == nil
-        or resource.buffer == event_buffer)
-    then
-      queue_event(record, name, payload, resource.callback)
-    end
-  end
-end
-
-function HostAdapter:begin_action_transition()
-  local record = adapter_records[self]
-  record.action_diagnostics = {}
-  return record.event_queue:begin_transition()
-end
-
-function HostAdapter:commit_action_transition(token)
-  local record = adapter_records[self]
-  local result = record.event_queue:commit_transition(token)
-  record.action_diagnostics = nil
-  return result
-end
-
-local function terminal_cursor_option(runtime)
-  return runtime.fn.eval("&t_ve")
-end
-
-local function set_terminal_cursor_option(runtime, value)
-  runtime.api.nvim_cmd({
-    cmd = "let",
-    args = { "&t_ve", "=", runtime.fn.string(value) },
-  }, {})
-end
-
-function HostAdapter:supports_cursor_presentation()
-  local runtime = self:runtime()
-  return type(runtime.api.nvim_get_option_value) == "function"
-    and type(runtime.api.nvim_set_option_value) == "function"
-    and type(runtime.api.nvim_cmd) == "function"
-    and type(runtime.fn) == "table"
-    and type(runtime.fn.exists) == "function"
-    and runtime.fn.exists("+t_ve") == 1
-    and type(runtime.fn.eval) == "function"
-    and type(runtime.fn.string) == "function"
-end
-
-function HostAdapter:suppress_cursor_presentation()
-  if not self:supports_cursor_presentation() then
-    return nil
-  end
-  local record = adapter_records[self]
-  local runtime = record.runtime
-  local identity = next_identity(self, "cursor-presentation")
-  local saved = {
-    guicursor = runtime.api.nvim_get_option_value(
-      "guicursor",
-      { scope = "global" }
-    ),
-    terminal_cursor = terminal_cursor_option(runtime),
-  }
-  runtime.api.nvim_set_option_value(
-    "guicursor",
-    "a:ver1",
-    { scope = "global" }
-  )
-  local ok, failure = pcall(set_terminal_cursor_option, runtime, "")
-  if not ok then
-    runtime.api.nvim_set_option_value(
-      "guicursor",
-      saved.guicursor,
-      { scope = "global" }
-    )
-    error(failure, 0)
-  end
-  record.cursor_presentations[identity] = saved
-  return identity
-end
-
-function HostAdapter:restore_cursor_presentation(identity)
-  local record = adapter_records[self]
-  local saved = record.cursor_presentations[identity]
-  if saved == nil then
-    return false
-  end
-  record.cursor_presentations[identity] = nil
-  record.runtime.api.nvim_set_option_value(
-    "guicursor",
-    saved.guicursor,
-    { scope = "global" }
-  )
-  set_terminal_cursor_option(record.runtime, saved.terminal_cursor)
-  return true
-end
-
-local function escape_key(runtime)
-  if type(runtime.keycode) == "function" then
-    return runtime.keycode("<Esc>")
-  end
-  if type(runtime.api.nvim_replace_termcodes) == "function" then
-    return runtime.api.nvim_replace_termcodes("<Esc>", true, false, true)
-  end
-  return string.char(27)
-end
-
-function HostAdapter:return_escape()
-  local runtime = self:runtime()
-  if type(runtime.api.nvim_feedkeys) ~= "function" then
-    fail("HostAdapter runtime must provide nvim_feedkeys", 2)
-  end
-  runtime.api.nvim_feedkeys(escape_key(runtime), "n", false)
-end
-
-function HostAdapter:emit_action_error(text)
-  return self:emit_diagnostic("error", text)
-end
-
-function HostAdapter:translate_action_outcome(outcome)
-  if not domain.ActionOutcome.is(outcome) then
-    fail("host action translation requires an ActionOutcome", 2)
-  end
-  if outcome.kind == domain.ActionKind.ESCAPE then
-    self:return_escape()
-    return M.ActionEffect.ESCAPE
-  end
-  if outcome.kind == domain.ActionKind.ERROR then
-    local diagnostics = adapter_records[self].action_diagnostics
-    local key = "error\0" .. outcome.diagnostic
-    if diagnostics == nil or not diagnostics[key] then
-      self:emit_action_error(outcome.diagnostic)
-    end
-    return M.ActionEffect.ERROR
-  end
-  return M.ActionEffect.NONE
-end
-
-local function packed(...)
-  return { n = select("#", ...), ... }
-end
-
-local function invoke_callback(adapter, callback, ...)
-  local arguments = packed(...)
-  local token = adapter:begin_action_transition()
-  local results = packed(pcall(function()
-    local values = packed(callback(unpack_values(arguments, 1, arguments.n)))
-    if domain.ActionOutcome.is(values[1]) then
-      adapter:translate_action_outcome(values[1])
-    end
-    return unpack_values(values, 1, values.n)
-  end))
-  local commit = packed(pcall(adapter.commit_action_transition, adapter, token))
-  if not results[1] then
-    error(results[2], 0)
-  end
-  if not commit[1] then
-    error(commit[2], 0)
-  end
-  return unpack_values(results, 2, results.n)
-end
-
-function HostAdapter:register_action(name, callback)
-  if type(name) ~= "string" or name == "" then
-    fail("action name must be a nonempty string", 2)
-  end
-  if type(callback) ~= "function" then
-    fail("action callback must be a function", 2)
-  end
-  local actions = adapter_records[self].actions
-  if actions[name] ~= nil then
-    fail("action is already registered", 2)
-  end
-  actions[name] = callback
-  return name
-end
-
-function HostAdapter:invoke_action(name, ...)
-  local callback = adapter_records[self].actions[name]
-  if callback == nil then
-    fail("action is not registered", 2)
-  end
-  return invoke_callback(self, callback, ...)
-end
-
-function HostAdapter:invoke_callback(callback, ...)
-  if type(callback) ~= "function" then
-    fail("action callback must be a function", 2)
-  end
-  return invoke_callback(self, callback, ...)
-end
-
-local function mapping_modes(value)
-  if type(value) == "string" then
-    value = { value }
-  end
-  if type(value) ~= "table" or #value == 0 then
-    fail("mapping modes must be a nonempty list", 3)
-  end
-  local result = {}
-  for index, mode in ipairs(value) do
-    if type(mode) ~= "string" or mode == "" then
-      fail("mapping mode must be a nonempty string", 3)
-    end
-    result[index] = mode
-  end
-  return result
-end
-
-function HostAdapter:register_mapping(modes, lhs, action, options)
-  modes = mapping_modes(modes)
-  if type(lhs) ~= "string" or lhs == "" then
-    fail("mapping lhs must be a nonempty string", 2)
-  end
-  if type(action) ~= "string" and type(action) ~= "function" then
-    fail("mapping action must be an action name or function", 2)
-  end
-  options = options or {}
-  if type(options) ~= "table" then
-    fail("mapping options must be a table", 2)
-  end
-  local callback
-  if type(action) == "string" then
-    callback = function()
-      return self:invoke_action(action)
-    end
-  else
-    callback = function(...)
-      return invoke_callback(self, action, ...)
-    end
-  end
-  local native_options = {
-    silent = options.silent == true,
-    remap = options.remap == true,
-    desc = options.desc
-      or ("clever-f " .. (type(action) == "string" and action or lhs)),
-  }
-  self:runtime().keymap.set(modes, lhs, callback, native_options)
-  local identity = next_identity(self, "mapping")
-  adapter_records[self].mappings[identity] = {
-    modes = modes,
-    lhs = lhs,
-    action = action,
-    options = options,
-    callback = callback,
-  }
-  return identity
-end
-
-function M.new(options)
-  return HostAdapter.new(options)
-end
-
-setmetatable(M, {
-  __call = function(_, options)
-    return HostAdapter.new(options)
-  end,
-})
-
-return M