Rename plugin to clever-tee

1 files changed, 0 insertions, 1075 deletions

diff --git a/lua/clever_f/testing/memory_host.lua b/lua/clever_f/testing/memory_host.lua
deleted file mode 100644
index 6147d2c..0000000
--- a/lua/clever_f/testing/memory_host.lua
+++ /dev/null
@@ -1,1075 +0,0 @@
-local capabilities = require("clever_f.capabilities")
-local domain = require("clever_f.domain")
-local text_topology = require("clever_f.text_topology")
-
-local M = {}
-local MemoryHost = {}
-MemoryHost.__index = MemoryHost
-M.MemoryHost = MemoryHost
-local unpack_values = table.unpack or unpack
-
-local function is_integer(value)
-  return type(value) == "number"
-    and value > -math.huge
-    and value < math.huge
-    and value == math.floor(value)
-end
-
-local function copy(value, seen)
-  if type(value) ~= "table" or domain.type_of(value) ~= nil then
-    return value
-  end
-  seen = seen or {}
-  if seen[value] ~= nil then
-    return seen[value]
-  end
-  local result = {}
-  seen[value] = result
-  for key, item in pairs(value) do
-    result[copy(key, seen)] = copy(item, seen)
-  end
-  return result
-end
-
-local function list_copy(values)
-  local result = {}
-  for index = 1, #values do
-    result[index] = values[index]
-  end
-  return result
-end
-
-local function text_snapshot(value)
-  if domain.TextSnapshot.is(value) then
-    return value
-  end
-  if type(value) == "table" and value.lines ~= nil then
-    value = value.lines
-  end
-  return domain.TextSnapshot.new(value)
-end
-
-local function selection_value(value)
-  if value == nil then
-    return domain.Selection.inactive()
-  end
-  return domain.Selection.new(value)
-end
-
-local function macro_state(value)
-  if type(value) == "table" and not domain.MacroState.is(value) then
-    value = value.register
-  end
-  return domain.MacroState.new(value)
-end
-
-local function fold_state(options)
-  if domain.FoldState.is(options.fold_state) then
-    return options.fold_state
-  end
-  return domain.FoldState.new(
-    options.fold_open_policy or {},
-    options.closed_fold_levels or 0
-  )
-end
-
-local function input_packet(value)
-  return domain.InputPacket.from_table(value)
-end
-
-local function normalize_event_names(event_names)
-  if type(event_names) == "string" then
-    event_names = { event_names }
-  end
-  if type(event_names) ~= "table" or #event_names < 1 then
-    error("event names must be a nonempty list", 3)
-  end
-  local result = {}
-  local seen = {}
-  for index = 1, #event_names do
-    local name = event_names[index]
-    if type(name) ~= "string" or name == "" then
-      error("event name must be a nonempty string", 3)
-    end
-    if not seen[name] then
-      seen[name] = true
-      result[#result + 1] = name
-    end
-  end
-  return result, seen
-end
-
-local function normalize_modes(modes)
-  if type(modes) == "string" then
-    modes = { modes }
-  end
-  if type(modes) ~= "table" or #modes < 1 then
-    error("mapping modes must be a nonempty list", 3)
-  end
-  local result = {}
-  for index = 1, #modes do
-    if type(modes[index]) ~= "string" or modes[index] == "" then
-      error("mapping mode must be a nonempty string", 3)
-    end
-    result[index] = modes[index]
-  end
-  return result
-end
-
-function MemoryHost.new(options)
-  options = options or {}
-  if type(options) ~= "table" then
-    error("memory host options must be a table", 2)
-  end
-
-  local cursor_presentation_support = options.cursor_presentation_support
-  if cursor_presentation_support == nil then
-    cursor_presentation_support = options.cmdline_cursor_support
-  end
-  if cursor_presentation_support == nil then
-    cursor_presentation_support = true
-  end
-
-  local raw_mode = options.mode or "n"
-  if domain.ModeContext.is(raw_mode) then
-    raw_mode = raw_mode.full_mode
-  end
-  domain.ModeContext.from_full_mode(raw_mode)
-
-  local self = setmetatable({
-    _text = text_snapshot(options.text or options.buffer_lines or { "" }),
-    _buffer = options.buffer or "buffer-1",
-    _cursor = domain.Position.coerce(options.cursor or { line = 1, byte_column = 1 }),
-    _window = options.window or "window-1",
-    _mode = raw_mode,
-    _selection = selection_value(options.selection),
-    _count = domain.Count.new(options.count),
-    _configuration = copy(options.configuration or {}),
-    _encoding = options.encoding or options.effective_encoding or "utf-8",
-    _lowercase = options.lowercase or vim.fn.tolower,
-    _macro_state = macro_state(options.macro_state or options.macro_register),
-    _fold_state = fold_state(options),
-    _pending_operator = options.pending_operator,
-    _time_values = list_copy(options.time_values_ms or {}),
-    _time_index = 1,
-    _current_time = options.time_ms or 0,
-    _input_packets = {},
-    _input_index = 1,
-    _timer_support = options.timer_support ~= false,
-    _cursor_presentation_support = cursor_presentation_support,
-    _cursor_presentation = copy(options.cursor_presentation or {
-      hidden = false,
-    }),
-    _emit_movement_events = options.emit_movement_events ~= false,
-    _operator_inclusive = false,
-    _operations = {},
-    _prompts = {},
-    _redraws = {},
-    _diagnostics = {},
-    _highlight_groups = copy(options.highlight_groups or {}),
-    _highlights = {},
-    _timers = {},
-    _event_registrations = {},
-    _event_registration_order = {},
-    _actions = {},
-    _mappings = {},
-    _cursor_leases = {},
-    _dot_repeat = nil,
-    _identity_counters = {},
-  }, MemoryHost)
-
-  for index, packet in ipairs(options.input_packets or {}) do
-    self._input_packets[index] = input_packet(packet)
-  end
-
-  self._event_queue = capabilities.EventQueue.new(function(name, payload)
-    self:_deliver_event_now(name, payload)
-  end)
-
-  return capabilities.assert_implements(self)
-end
-
-function M.new(options)
-  return MemoryHost.new(options)
-end
-
-setmetatable(M, {
-  __call = function(_, options)
-    return MemoryHost.new(options)
-  end,
-})
-
-function MemoryHost:_next_identity(prefix)
-  local next_value = (self._identity_counters[prefix] or 0) + 1
-  self._identity_counters[prefix] = next_value
-  return prefix .. "-" .. tostring(next_value)
-end
-
-function MemoryHost:_record(operation, details)
-  local entry = { operation = operation }
-  for key, value in pairs(details or {}) do
-    entry[key] = copy(value)
-  end
-  self._operations[#self._operations + 1] = entry
-end
-
-function MemoryHost:operations()
-  return copy(self._operations)
-end
-
-function MemoryHost:clear_operations()
-  self._operations = {}
-end
-
-function MemoryHost:read_text()
-  self:_record("read_text")
-  return self._text
-end
-
-function MemoryHost:read_cursor()
-  self:_record("read_cursor")
-  return self._cursor
-end
-
-function MemoryHost:read_buffer()
-  self:_record("read_buffer", { buffer = self._buffer })
-  return self._buffer
-end
-
-function MemoryHost:read_window()
-  self:_record("read_window", { window = self._window })
-  return self._window
-end
-
-function MemoryHost:read_mode()
-  self:_record("read_mode", { mode = self._mode })
-  return self._mode
-end
-
-function MemoryHost:read_mode_context()
-  return domain.ModeContext.from_full_mode(self:read_mode())
-end
-
-function MemoryHost:read_pending_operator()
-  self:_record("read_pending_operator", { operator = self._pending_operator })
-  return self._pending_operator
-end
-
-function MemoryHost:read_selection()
-  self:_record("read_selection")
-  return self._selection
-end
-
-function MemoryHost:read_count()
-  self:_record("read_count", { count = self._count.value })
-  return self._count
-end
-
-function MemoryHost:configuration_present(name)
-  if type(name) ~= "string" or name == "" then
-    error("configuration name must be a nonempty string", 2)
-  end
-  local present = self._configuration[name] ~= nil
-  self:_record("configuration_present", { name = name, present = present })
-  return present
-end
-
-function MemoryHost:read_configuration(name)
-  if type(name) ~= "string" or name == "" then
-    error("configuration name must be a nonempty string", 2)
-  end
-  local value = copy(self._configuration[name])
-  self:_record("read_configuration", { name = name, value = value })
-  return value
-end
-
-function MemoryHost:write_configuration(name, value)
-  if type(name) ~= "string" or name == "" then
-    error("configuration name must be a nonempty string", 2)
-  end
-  self._configuration[name] = copy(value)
-  self:_record("write_configuration", { name = name, value = value })
-end
-
-function MemoryHost:read_encoding()
-  self:_record("read_encoding", { encoding = self._encoding })
-  return self._encoding
-end
-
-function MemoryHost:lowercase(value)
-  if type(value) ~= "string" then
-    error("case conversion value must be a string", 2)
-  end
-  local result = self._lowercase(value)
-  if type(result) ~= "string" then
-    error("case converter must return a string", 2)
-  end
-  self:_record("lowercase", { value = value, result = result })
-  return result
-end
-
-function MemoryHost:read_macro_state()
-  self:_record("read_macro_state", { executing = self._macro_state.executing })
-  return self._macro_state
-end
-
-function MemoryHost:read_fold_state()
-  self:_record("read_fold_state", { closed_levels = self._fold_state.closed_levels })
-  return self._fold_state
-end
-
-function MemoryHost:read_time_ms()
-  local value = self._time_values[self._time_index]
-  if value ~= nil then
-    self._time_index = self._time_index + 1
-    self._current_time = value
-  else
-    value = self._current_time
-  end
-  if type(value) ~= "number" then
-    error("time value must be a number", 2)
-  end
-  self:_record("read_time_ms", { value = value })
-  return value
-end
-
-function MemoryHost:set_text(value)
-  self._text = text_snapshot(value)
-end
-
-function MemoryHost:set_cursor(position)
-  self._cursor = domain.Position.coerce(position)
-end
-
-function MemoryHost:set_buffer(buffer)
-  if buffer == nil then
-    error("buffer identity must be present", 2)
-  end
-  self._buffer = buffer
-end
-
-function MemoryHost:set_window(window)
-  if window == nil then
-    error("window identity must be present", 2)
-  end
-  self._window = window
-end
-
-function MemoryHost:set_mode(full_mode)
-  if domain.ModeContext.is(full_mode) then
-    full_mode = full_mode.full_mode
-  end
-  domain.ModeContext.from_full_mode(full_mode)
-  self._mode = full_mode
-end
-
-function MemoryHost:set_selection(selection)
-  self._selection = selection_value(selection)
-end
-
-function MemoryHost:set_count(count)
-  self._count = domain.Count.new(count)
-end
-
-function MemoryHost:set_configuration(name, value)
-  if type(name) ~= "string" or name == "" then
-    error("configuration name must be a nonempty string", 2)
-  end
-  self._configuration[name] = copy(value)
-end
-
-function MemoryHost:unset_configuration(name)
-  self._configuration[name] = nil
-end
-
-function MemoryHost:set_encoding(encoding)
-  if type(encoding) ~= "string" or encoding == "" then
-    error("encoding must be a nonempty string", 2)
-  end
-  self._encoding = encoding
-end
-
-function MemoryHost:set_macro_state(state)
-  self._macro_state = macro_state(state)
-end
-
-function MemoryHost:set_fold_state(state, closed_levels)
-  if domain.FoldState.is(state) then
-    self._fold_state = state
-  else
-    self._fold_state = domain.FoldState.new(state, closed_levels)
-  end
-end
-
-function MemoryHost:set_pending_operator(operator)
-  self._pending_operator = operator
-end
-
-function MemoryHost:push_time_ms(value)
-  if type(value) ~= "number" then
-    error("time value must be a number", 2)
-  end
-  self._time_values[#self._time_values + 1] = value
-end
-
-function MemoryHost:push_input(packet)
-  self._input_packets[#self._input_packets + 1] = input_packet(packet)
-end
-
-function MemoryHost:_emit_movement_event(previous)
-  if self._emit_movement_events and not domain.Position.equal(previous, self._cursor) then
-    self:deliver_event("CursorMoved", {
-      cursor = self._cursor,
-    })
-  end
-end
-
-local function motion_descriptor(motion)
-  if domain.Descriptor.is(motion) then
-    return motion
-  end
-  if type(motion) == "table" and motion.descriptor ~= nil then
-    return domain.Descriptor.from_string(motion.descriptor)
-  end
-  return nil
-end
-
-local function character_boundary(view, position)
-  if view:line_is_empty(position.line) then
-    return 1
-  end
-  return view:character_index_for_position(position)
-end
-
-local function character_lines(snapshot)
-  local result = {}
-  for line_number, line in ipairs(snapshot:lines()) do
-    result[line_number] = text_topology.split_editor_characters(line)
-  end
-  return result
-end
-
-local function joined_range(characters, first, last)
-  local result = {}
-  for index = first, last do
-    result[#result + 1] = characters[index]
-  end
-  return table.concat(result)
-end
-
-local function delete_character_range(
-  snapshot,
-  start_line,
-  start_index,
-  finish_line,
-  finish_index
-)
-  local source = character_lines(snapshot)
-  local lines = snapshot:lines()
-  local result = {}
-
-  for line_number = 1, start_line - 1 do
-    result[#result + 1] = lines[line_number]
-  end
-
-  local prefix = joined_range(source[start_line], 1, start_index - 1)
-  if start_line == finish_line then
-    result[#result + 1] = prefix
-      .. joined_range(
-        source[start_line],
-        finish_index,
-        #source[start_line]
-      )
-  else
-    result[#result + 1] = prefix
-      .. joined_range(
-        source[finish_line],
-        finish_index,
-        #source[finish_line]
-      )
-  end
-
-  for line_number = finish_line + 1, #lines do
-    result[#result + 1] = lines[line_number]
-  end
-  return domain.TextSnapshot.new(result)
-end
-
-local function normalized_cursor(snapshot, encoding, position)
-  local line_number = math.min(position.line, snapshot.line_count)
-  local view = text_topology.new(snapshot, encoding)
-  return view:normalize_endpoint(line_number, position.byte_column)
-end
-
-function MemoryHost:_apply_pending_delete(origin, destination, descriptor)
-  if self._pending_operator ~= "delete" and self._pending_operator ~= "d" then
-    return false
-  end
-
-  local view = text_topology.new(self._text, self._encoding)
-  local origin_index = character_boundary(view, origin)
-  local destination_index = character_boundary(view, destination)
-  local start_line
-  local start_index
-  local finish_line
-  local finish_index
-  local final_cursor
-
-  if descriptor.direction == domain.Direction.FORWARD then
-    start_line = origin.line
-    start_index = origin_index
-    finish_line = destination.line
-    finish_index = destination_index + (self._operator_inclusive and 1 or 0)
-    final_cursor = origin
-  elseif descriptor.family == domain.Family.FIND then
-    start_line = destination.line
-    start_index = destination_index + 1
-    finish_line = origin.line
-    finish_index = origin_index + 1
-    final_cursor = destination
-  else
-    start_line = destination.line
-    start_index = destination_index
-    finish_line = origin.line
-    finish_index = origin_index
-    final_cursor = view:predecessor(destination) or destination
-  end
-
-  self._text = delete_character_range(
-    self._text,
-    start_line,
-    start_index,
-    finish_line,
-    finish_index
-  )
-  self._cursor = normalized_cursor(self._text, self._encoding, final_cursor)
-  self:_record("apply_operator", {
-    operator = self._pending_operator,
-    descriptor = descriptor.value,
-    origin = origin,
-    endpoint = destination,
-    position = self._cursor,
-  })
-  return true
-end
-
-function MemoryHost:apply_cursor(position, motion)
-  position = domain.Position.coerce(position)
-  local previous = self._cursor
-  local descriptor = motion_descriptor(motion)
-  self._cursor = position
-  self:_record("apply_cursor", {
-    position = position,
-    descriptor = descriptor and descriptor.value or nil,
-  })
-  if descriptor ~= nil then
-    local origin = type(motion) == "table" and motion.origin or previous
-    self:_apply_pending_delete(domain.Position.coerce(origin), position, descriptor)
-  end
-  self:_emit_movement_event(previous)
-end
-
-function MemoryHost:apply_selection(position, kind)
-  local previous = self._cursor
-  local next_selection
-  if domain.Selection.is(position) then
-    next_selection = position
-    position = next_selection.focus
-  else
-    position = domain.Position.coerce(position)
-    if kind == nil then
-      kind = self._selection.kind
-    end
-    kind = domain.SelectionKind.from_string(kind)
-    if kind == domain.SelectionKind.NONE then
-      error("selection movement requires a Visual selection kind", 2)
-    end
-    local anchor = self._selection.active and self._selection.anchor or previous
-    next_selection = domain.Selection.active(
-      kind,
-      anchor,
-      position,
-      self._selection.option
-    )
-  end
-
-  self._selection = next_selection
-  self._cursor = position
-  self:_record("apply_selection", {
-    position = position,
-    kind = next_selection.kind.value,
-  })
-  self:_emit_movement_event(previous)
-end
-
-function MemoryHost:set_operator_inclusive(enabled)
-  if type(enabled) ~= "boolean" then
-    error("operator inclusivity must be a Boolean", 2)
-  end
-  self._operator_inclusive = enabled
-  self:_record("set_operator_inclusive", { enabled = enabled })
-end
-
-function MemoryHost:operator_inclusive()
-  return self._operator_inclusive
-end
-
-function MemoryHost:read_input()
-  local packet = self._input_packets[self._input_index]
-  if packet == nil then
-    error("in-memory input queue is empty", 2)
-  end
-  self._input_index = self._input_index + 1
-  self:_record("read_input", { packet = packet:to_table() })
-  if packet.kind == domain.InputPacketKind.ERROR then
-    error(packet.message, 0)
-  end
-  return packet
-end
-
-function MemoryHost:open_fold(position)
-  position = position and domain.Position.coerce(position) or self._cursor
-  local closed_levels = self._fold_state.closed_levels
-  if closed_levels == 0 then
-    self:_record("open_fold", { position = position, opened = false })
-    return false
-  end
-  self:_record("open_fold", {
-    position = position,
-    fold_level = closed_levels,
-    opened = true,
-  })
-  self._fold_state = domain.FoldState.new(
-    self._fold_state:policies(),
-    closed_levels - 1
-  )
-  return true
-end
-
-function MemoryHost:show_prompt(text)
-  if type(text) ~= "string" then
-    error("prompt must be a string", 2)
-  end
-  self._prompts[#self._prompts + 1] = text
-  self:_record("show_prompt", { text = text })
-end
-
-function MemoryHost:prompts()
-  return list_copy(self._prompts)
-end
-
-function MemoryHost:redraw(kind)
-  if kind ~= "screen" and kind ~= "full" and kind ~= "suppressed" then
-    error("redraw kind must be screen, full, or suppressed", 2)
-  end
-  self._redraws[#self._redraws + 1] = kind
-  self:_record("redraw", { kind = kind })
-end
-
-function MemoryHost:redraws()
-  return list_copy(self._redraws)
-end
-
-function MemoryHost:emit_diagnostic(level, text)
-  if level ~= "error" and level ~= "warning" and level ~= "info" then
-    error("diagnostic level must be error, warning, or info", 2)
-  end
-  if type(text) ~= "string" or text == "" then
-    error("diagnostic text must be a nonempty string", 2)
-  end
-  local diagnostic = { level = level, text = text }
-  self._diagnostics[#self._diagnostics + 1] = diagnostic
-  self:_record("emit_diagnostic", diagnostic)
-end
-
-function MemoryHost:diagnostics()
-  return copy(self._diagnostics)
-end
-
-function MemoryHost:read_highlight_group(name)
-  if type(name) ~= "string" or name == "" then
-    error("highlight group name must be a nonempty string", 2)
-  end
-  local definition = self._highlight_groups[name]
-  self:_record("read_highlight_group", {
-    name = name,
-    defined = definition ~= nil,
-  })
-  return copy(definition)
-end
-
-function MemoryHost:highlight_groups()
-  return copy(self._highlight_groups)
-end
-
-function MemoryHost:define_highlight_group(name, definition, options)
-  if type(name) ~= "string" or name == "" then
-    error("highlight group name must be a nonempty string", 2)
-  end
-  if type(definition) ~= "table" then
-    error("highlight group definition must be a table", 2)
-  end
-  options = options or {}
-  if type(options) ~= "table" then
-    error("highlight group options must be a table", 2)
-  end
-  if options.default ~= nil and type(options.default) ~= "boolean" then
-    error("highlight group default option must be a Boolean", 2)
-  end
-  if options.force ~= nil and type(options.force) ~= "boolean" then
-    error("highlight group force option must be a Boolean", 2)
-  end
-
-  local exists = self._highlight_groups[name] ~= nil
-  local applied = not (exists and options.default)
-  if applied then
-    self._highlight_groups[name] = copy(definition)
-  end
-  self:_record("define_highlight_group", {
-    name = name,
-    definition = definition,
-    options = options,
-    applied = applied,
-  })
-  return applied
-end
-
-function MemoryHost:create_highlight(specification)
-  if type(specification) ~= "table" then
-    error("highlight specification must be a table", 2)
-  end
-  if type(specification.group) ~= "string" or specification.group == "" then
-    error("highlight group must be a nonempty string", 2)
-  end
-  local identity = specification.identity or self:_next_identity("highlight")
-  if self._highlights[identity] ~= nil then
-    error("highlight identity is already active", 2)
-  end
-  local stored = copy(specification)
-  stored.identity = identity
-  self._highlights[identity] = stored
-  self:_record("create_highlight", stored)
-  return identity
-end
-
-function MemoryHost:remove_highlight(identity)
-  if type(identity) ~= "string" or identity == "" then
-    error("highlight identity must be a nonempty string", 2)
-  end
-  local removed = self._highlights[identity] ~= nil
-  self._highlights[identity] = nil
-  self:_record("remove_highlight", { identity = identity, removed = removed })
-  return removed
-end
-
-function MemoryHost:highlights()
-  return copy(self._highlights)
-end
-
-function MemoryHost:supports_cursor_presentation()
-  self:_record("supports_cursor_presentation", {
-    supported = self._cursor_presentation_support,
-  })
-  return self._cursor_presentation_support
-end
-
-function MemoryHost:suppress_cursor_presentation()
-  if not self._cursor_presentation_support then
-    self:_record("suppress_cursor_presentation", { supported = false })
-    return nil
-  end
-  local identity = self:_next_identity("cursor-presentation")
-  self._cursor_leases[identity] = copy(self._cursor_presentation)
-  local suppressed = copy(self._cursor_presentation)
-  suppressed.hidden = true
-  self._cursor_presentation = suppressed
-  self:_record("suppress_cursor_presentation", {
-    identity = identity,
-    supported = true,
-  })
-  return identity
-end
-
-function MemoryHost:restore_cursor_presentation(identity)
-  if identity == nil then
-    self:_record("restore_cursor_presentation", { restored = false })
-    return false
-  end
-  local saved = self._cursor_leases[identity]
-  if saved == nil then
-    error("cursor presentation lease is inactive", 2)
-  end
-  self._cursor_presentation = saved
-  self._cursor_leases[identity] = nil
-  self:_record("restore_cursor_presentation", {
-    identity = identity,
-    restored = true,
-  })
-  return true
-end
-
-function MemoryHost:cursor_presentation()
-  return copy(self._cursor_presentation)
-end
-
-function MemoryHost:supports_timers()
-  self:_record("supports_timers", { supported = self._timer_support })
-  return self._timer_support
-end
-
-function MemoryHost:start_timer(delay_ms, callback)
-  if not is_integer(delay_ms) or delay_ms < 0 then
-    error("timer delay must be a nonnegative integer", 2)
-  end
-  if type(callback) ~= "function" then
-    error("timer callback must be a function", 2)
-  end
-  if not self._timer_support then
-    self:_record("start_timer", { delay_ms = delay_ms, supported = false })
-    return nil
-  end
-  local identity = self:_next_identity("timer")
-  self._timers[identity] = {
-    identity = identity,
-    delay_ms = delay_ms,
-    callback = callback,
-    active = true,
-  }
-  self:_record("start_timer", {
-    identity = identity,
-    delay_ms = delay_ms,
-    supported = true,
-  })
-  return identity
-end
-
-function MemoryHost:stop_timer(identity)
-  if type(identity) ~= "string" or identity == "" then
-    error("timer identity must be a nonempty string", 2)
-  end
-  local timer = self._timers[identity]
-  local stopped = timer ~= nil and timer.active
-  if timer ~= nil then
-    timer.active = false
-  end
-  self:_record("stop_timer", { identity = identity, stopped = stopped })
-  return stopped
-end
-
-function MemoryHost:fire_timer(identity)
-  local timer = self._timers[identity]
-  if timer == nil then
-    error("timer identity is unknown", 2)
-  end
-  if not timer.active then
-    self:_record("ignore_timer", { identity = identity })
-    return false
-  end
-  timer.active = false
-  self:_record("fire_timer", { identity = identity })
-  timer.callback(identity)
-  return true
-end
-
-function MemoryHost:timers()
-  local result = {}
-  for identity, timer in pairs(self._timers) do
-    result[identity] = {
-      identity = identity,
-      delay_ms = timer.delay_ms,
-      active = timer.active,
-    }
-  end
-  return result
-end
-
-function MemoryHost:register_events(event_names, callback, options)
-  local names, name_set = normalize_event_names(event_names)
-  if type(callback) ~= "function" then
-    error("event callback must be a function", 2)
-  end
-  local identity = self:_next_identity("event-registration")
-  self._event_registrations[identity] = {
-    identity = identity,
-    names = names,
-    name_set = name_set,
-    callback = callback,
-    options = copy(options or {}),
-    active = true,
-  }
-  self._event_registration_order[#self._event_registration_order + 1] = identity
-  self:_record("register_events", {
-    identity = identity,
-    names = names,
-    options = options or {},
-  })
-  return identity
-end
-
-function MemoryHost:remove_event_registration(identity)
-  local registration = self._event_registrations[identity]
-  local removed = registration ~= nil and registration.active
-  if registration ~= nil then
-    registration.active = false
-  end
-  self:_record("remove_event_registration", {
-    identity = identity,
-    removed = removed,
-  })
-  return removed
-end
-
-function MemoryHost:_deliver_event_now(name, payload)
-  self:_record("event", { name = name, payload = payload })
-  local order = list_copy(self._event_registration_order)
-  local event_buffer = payload.buffer or self._buffer
-  for _, identity in ipairs(order) do
-    local registration = self._event_registrations[identity]
-    local registration_buffer = registration.options.buffer
-    if registration.active
-      and registration.name_set[name]
-      and (registration_buffer == nil or registration_buffer == event_buffer)
-    then
-      registration.callback(name, payload)
-    end
-  end
-end
-
-function MemoryHost:deliver_event(name, payload)
-  if type(name) ~= "string" or name == "" then
-    error("event name must be a nonempty string", 2)
-  end
-  payload = copy(payload or {})
-  local queued = self._event_queue:is_transition_active()
-  self:_record(queued and "queue_event" or "deliver_event", {
-    name = name,
-    payload = payload,
-  })
-  return self._event_queue:emit(name, payload)
-end
-
-function MemoryHost:begin_action_transition()
-  local token = self._event_queue:begin_transition()
-  self:_record("begin_action_transition", { identity = token })
-  return token
-end
-
-function MemoryHost:commit_action_transition(token)
-  self:_record("commit_action_transition", { identity = token })
-  self._event_queue:commit_transition(token)
-end
-
-function MemoryHost:pending_event_count()
-  return self._event_queue:pending_count()
-end
-
-function MemoryHost:event_registrations()
-  local result = {}
-  for identity, registration in pairs(self._event_registrations) do
-    result[identity] = {
-      identity = identity,
-      names = list_copy(registration.names),
-      options = copy(registration.options),
-      active = registration.active,
-    }
-  end
-  return result
-end
-
-function MemoryHost:register_action(name, callback)
-  if type(name) ~= "string" or name == "" then
-    error("action name must be a nonempty string", 2)
-  end
-  if type(callback) ~= "function" then
-    error("action callback must be a function", 2)
-  end
-  if self._actions[name] ~= nil then
-    error("action is already registered", 2)
-  end
-  self._actions[name] = callback
-  self:_record("register_action", { name = name })
-  return name
-end
-
-function MemoryHost:invoke_action(name, ...)
-  local callback = self._actions[name]
-  if callback == nil then
-    error("action is not registered", 2)
-  end
-  local arguments = { ... }
-  local argument_count = select("#", ...)
-  local token = self:begin_action_transition()
-  local results = {
-    pcall(function()
-      return callback(unpack_values(arguments, 1, argument_count))
-    end),
-  }
-  self:commit_action_transition(token)
-  local succeeded = table.remove(results, 1)
-  if not succeeded then
-    error(results[1], 0)
-  end
-  return unpack_values(results)
-end
-
-function MemoryHost:register_mapping(modes, lhs, action, options)
-  modes = normalize_modes(modes)
-  if type(lhs) ~= "string" or lhs == "" then
-    error("mapping lhs must be a nonempty string", 2)
-  end
-  if type(action) ~= "string" and type(action) ~= "function" then
-    error("mapping action must be an action name or function", 2)
-  end
-  local identity = self:_next_identity("mapping")
-  self._mappings[identity] = {
-    identity = identity,
-    modes = modes,
-    lhs = lhs,
-    action = action,
-    options = copy(options or {}),
-  }
-  self:_record("register_mapping", {
-    identity = identity,
-    modes = modes,
-    lhs = lhs,
-    action = type(action) == "string" and action or "<function>",
-    options = options or {},
-  })
-  return identity
-end
-
-function MemoryHost:mappings()
-  return copy(self._mappings)
-end
-
-function MemoryHost:register_dot_repeat(payload, callback)
-  if not domain.DotPayload.is(payload) then
-    error("dot-repeat payload must be a DotPayload", 2)
-  end
-  if callback ~= nil and type(callback) ~= "function" then
-    error("dot-repeat callback must be a function", 2)
-  end
-  self._dot_repeat = {
-    payload = payload,
-    callback = callback,
-    operator = self._pending_operator,
-    mode = self._mode,
-  }
-  self:_record("register_dot_repeat", { payload = payload:to_table() })
-  return payload
-end
-
-function MemoryHost:dot_repeat_payload()
-  return self._dot_repeat and self._dot_repeat.payload or nil
-end
-
-function MemoryHost:replay_dot(count)
-  if self._dot_repeat == nil or self._dot_repeat.callback == nil then
-    error("dot repeat is not executable", 2)
-  end
-  self._pending_operator = self._dot_repeat.operator
-  self._mode = self._dot_repeat.mode
-  return self._dot_repeat.callback(self._dot_repeat.payload, domain.Count.new(count))
-end
-
-return M