abbu 0.8.1 → 0.18.0

data/lib/abbu/merge_plan.rb

@@ -0,0 +1,132 @@
+# lib/abbu/merge_plan.rb
+# frozen_string_literal: true
+
+require_relative 'contact'
+require_relative 'merge_values'
+
+module Abbu
+  # A detached review artifact, not an assertion that two records are one person.
+  # Materialization is opt-in and never writes an archive or live store.
+  class MergePlan
+    MULTIVALUES = %i[emails phones addresses groups urls notes related_names social_profiles
+                     dates instant_messages].freeze
+    SCALARS = %i[first_name middle_name last_name company nickname prefix suffix job_title department maiden_name
+                 phonetic_first_name phonetic_middle_name phonetic_last_name phonetic_company pronouns ringtone
+                 texttone birthday anniversary verification_code lunar_birthday created_at modified_at].freeze
+    FIELDS = (MULTIVALUES + SCALARS + %i[image_uri image_path group_memberships source]).freeze
+    POLICIES = %i[union_multivalues prefer_newer prefer_source prefer_more_complete].freeze
+
+    attr_reader :policy, :fields, :sources, :conflicts
+
+    def initialize(left, right, policy: nil, source: nil)
+      validate_policy(policy, source)
+      @policy = policy
+      @records = [left, right].map { |contact| snapshot(contact) }.freeze
+      @sources = @records.map { |record| record[:source] }.freeze
+      preferred = preferred_index(source)
+      @fields = build_fields(preferred).freeze
+      @conflicts = @fields.select { |_, field| field[:conflict] }.freeze
+      freeze
+    end
+
+    def to_h
+      { policy: policy, sources: sources, inputs: @records, fields: fields, conflicts: conflicts.keys.freeze,
+        materializable: !policy.nil? && conflicts.values.none? { |field| field[:unresolved] } }.freeze
+    end
+
+    def materialize
+      validate_materialization
+      Contact.new.tap do |contact|
+        fields.each { |name, field| assign_field(contact, name, field[:selected]) }
+      end
+    end
+
+    private
+
+    def validate_policy(policy, source)
+      raise ArgumentError, 'unknown merge policy' if policy && !POLICIES.include?(policy)
+      raise ArgumentError, 'source requires prefer_source' if source && policy != :prefer_source
+    end
+
+    def validate_materialization
+      raise ArgumentError, 'an explicit merge policy is required' unless policy
+      raise ArgumentError, 'unresolved scalar conflicts require a deciding policy' if
+        conflicts.values.any? { |field| field[:unresolved] }
+    end
+
+    def assign_field(contact, name, selected)
+      values = name == :image ? selected || {} : { name => selected }
+      values.each { |key, value| contact.public_send(:"#{key}=", MergeValues.copy(value)) }
+    end
+
+    def snapshot(contact)
+      FIELDS.to_h { |name| [name, MergeValues.copy(contact.public_send(name), freeze: true)] }.freeze
+    end
+
+    def preferred_index(source)
+      case policy
+      when :prefer_source then source_index(source)
+      when :prefer_newer then comparison_index(@records.map { |record| record[:modified_at] }, Time)
+      when :prefer_more_complete then comparison_index(@records.map { |record| completeness(record) }, Integer)
+      end
+    end
+
+    def source_index(source)
+      raise ArgumentError, 'prefer_source requires an exact source relative_path' unless source.is_a?(String)
+
+      indices = sources.each_index.select { |index| sources[index]&.fetch(:relative_path, nil) == source }
+      raise ArgumentError, 'preferred source must identify exactly one input' unless indices.one?
+
+      indices.first
+    end
+
+    def comparison_index(values, type)
+      return unless values.all?(type)
+      return if values[0] == values[1]
+
+      values[0] > values[1] ? 0 : 1
+    end
+
+    def completeness(record)
+      (SCALARS - %i[created_at modified_at]).count { |key| present?(record[key]) } +
+        MULTIVALUES.count { |key| present?(record[key]) }
+    end
+
+    def present?(value)
+      !value.nil? && !(value.respond_to?(:empty?) && value.empty?)
+    end
+
+    def build_fields(preferred)
+      result = union_fields
+      SCALARS.each { |name| result[name] = scalar_field(@records.map { |record| record[name] }, preferred) }
+      result[:image] = scalar_field(images, preferred)
+      result
+    end
+
+    def union_fields
+      MULTIVALUES.to_h do |name|
+        values = @records.map { |record| record.fetch(name) }
+        [name, { selected: values.flatten(1).uniq.freeze, reason: :lossless_union, conflict: false }.freeze]
+      end
+    end
+
+    def images
+      @records.map do |record|
+        image = record.slice(:image_uri, :image_path)
+        image.freeze if image.values.any? { |value| present?(value) }
+      end
+    end
+
+    def scalar_field(values, preferred)
+      conflict = values[0] != values[1] && values.all? { |value| present?(value) }
+      index = conflict ? preferred : values.index { |value| present?(value) }
+      selected = index.nil? ? nil : values[index]
+      { selected: selected, alternatives: values.freeze, conflict: conflict,
+        unresolved: conflict && preferred.nil?, reason: reason(conflict) }.freeze
+    end
+
+    def reason(conflict)
+      conflict ? policy || :review_required : :uncontested
+    end
+  end
+end

data/lib/abbu/merge_preview.rb

@@ -0,0 +1,35 @@
+# lib/abbu/merge_preview.rb
+# frozen_string_literal: true
+
+require_relative 'merge_plan'
+require_relative 'utils/deduplicator'
+
+module Abbu
+  class MergePreview
+    def self.validate!(options)
+      return unless options.values_at(:merge_preview, :merge_policy, :prefer_source).any?
+
+      raise ArgumentError, '--merge-policy/--prefer-source require --merge-preview' unless options[:merge_preview]
+
+      allowed = %i[merge_preview merge_policy prefer_source strict live live_path]
+      raise ArgumentError, '--merge-preview cannot be combined with other operations' if
+        options.any? { |key, value| value && !allowed.include?(key) }
+    end
+
+    def self.plans(contacts, policy: nil, source: nil)
+      validate_policy!(policy, source)
+      Utils::Deduplicator.new(contacts).matches.map do |match|
+        { status: match.status, score: match.score, evidence: match.evidence,
+          plan: MergePlan.new(match.left, match.right, policy: policy, source: source).to_h }
+      end
+    end
+
+    def self.validate_policy!(policy, source)
+      # Validate policies even for empty inputs, before enumerating candidate pairs.
+      MergePlan.new(Contact.new, Contact.new, policy: policy) unless policy == :prefer_source
+      raise ArgumentError, 'source requires prefer_source' if source && policy != :prefer_source
+      raise ArgumentError, 'prefer_source requires a source path' if policy == :prefer_source && !source.is_a?(String)
+    end
+    private_class_method :validate_policy!
+  end
+end

data/lib/abbu/merge_values.rb

@@ -0,0 +1,26 @@
+# lib/abbu/merge_values.rb
+# frozen_string_literal: true
+
+require 'date'
+
+module Abbu
+  module MergeValues
+    module_function
+
+    def copy(value, freeze: false)
+      result = duplicate(value, freeze: freeze)
+      freeze ? result.freeze : result
+    end
+
+    def duplicate(value, freeze:)
+      case value
+      when Hash then value.to_h { |key, item| [copy(key, freeze: freeze), copy(item, freeze: freeze)] }
+      when Array then value.map { |item| copy(item, freeze: freeze) }
+      when String, Time, Date then value.dup
+      when NilClass, TrueClass, FalseClass, Symbol, Numeric then value
+      else raise ArgumentError, 'unsupported contact value'
+      end
+    end
+  end
+  private_constant :MergeValues
+end

data/lib/abbu/parsers/plist_parser.rb

@@ -38,6 +38,15 @@ module Abbu
         @paths.filter_map { |file| parse_file(file) }
       end
 
+      def each_contact
+        return enum_for(:each_contact) unless block_given?
+
+        @paths.each do |file|
+          contact = parse_file(file)
+          yield contact if contact
+        end
+      end
+
       private
 
       def resolve_paths(paths)

data/lib/abbu/parsers/sqlite_parser.rb

@@ -49,8 +49,33 @@ module Abbu
         end
       end
 
+      def each_contact(&block)
+        return enum_for(:each_contact) unless block
+
+        @db_paths.each do |path|
+          stream_db(path, &block)
+        end
+      end
+
       private
 
+      def stream_db(path)
+        @active_db_path = path
+        db = SQLite3::Database.new(path.to_s, readonly: true)
+        db.results_as_hash = true
+        statement = stream_statement(db)
+        statement.execute.each { |row| yield build_contact(db, row, path) }
+      ensure
+        statement&.close
+        db&.close
+      end
+
+      def stream_statement(db)
+        db.prepare('SELECT * FROM ZABCDRECORD WHERE Z_ENT != 15')
+      rescue SQLite3::Exception
+        fail_required_schema(@active_db_path)
+      end
+
       def parse_db(db_path)
         @active_db_path = db_path
         db = SQLite3::Database.new(db_path.to_s, readonly: @readonly)

data/lib/abbu/snapshot_diff.rb

@@ -0,0 +1,125 @@
+# lib/abbu/snapshot_diff.rb
+# frozen_string_literal: true
+
+require 'pathname'
+require 'time'
+
+require_relative 'utils/deduplicator'
+
+module Abbu
+  # Snapshot observations, not assertions of identity or events between captures.
+  class SnapshotDiff
+    FIELDS = %i[first_name middle_name last_name emails phones company addresses groups group_memberships
+                nickname prefix suffix job_title department maiden_name phonetic_first_name phonetic_middle_name
+                phonetic_last_name phonetic_company pronouns ringtone texttone urls notes related_names
+                social_profiles birthday anniversary dates instant_messages verification_code lunar_birthday
+                image_uri image_path created_at modified_at source].freeze
+
+    attr_reader :result
+
+    def initialize(before, after, max_pairs: 100_000)
+      raise ArgumentError, 'max_pairs must be a positive Integer' unless max_pairs.is_a?(Integer) && max_pairs.positive?
+
+      left = before.respond_to?(:contacts) ? before.contacts : before.to_a
+      right = after.respond_to?(:contacts) ? after.contacts : after.to_a
+      raise ArgumentError, 'snapshot comparison exceeds max_pairs' if left.length * right.length > max_pairs
+
+      @result = freeze_tree(compare(left, right))
+    end
+
+    def to_h
+      result
+    end
+
+    private
+
+    def compare(left, right)
+      candidates = candidates_for(left, right)
+      @left_counts = candidates.map { |item| item[:before_index] }.tally
+      @right_counts = candidates.map { |item| item[:after_index] }.tally
+      @old_records = left.map { |contact| record(contact) }
+      @new_records = right.map { |contact| record(contact) }
+      classify(candidates)
+    end
+
+    def classify(candidates)
+      paired, ambiguous = candidates.partition do |item|
+        item[:score] >= Utils::Deduplicator::PROBABLE_SCORE &&
+          @left_counts[item[:before_index]] == 1 && @right_counts[item[:after_index]] == 1
+      end
+      build_result(paired, ambiguous)
+    end
+
+    def candidates_for(left, right)
+      left.each_with_index.flat_map do |old_contact, old_index|
+        right.each_with_index.filter_map do |new_contact, new_index|
+          match = Utils::Deduplicator.new([old_contact, new_contact]).matches.first
+          next unless match
+
+          { before_index: old_index, after_index: new_index, score: match.score, evidence: copy(match.evidence) }
+        end
+      end
+    end
+
+    def build_result(paired, ambiguous)
+      changes = paired.map { |pair| comparison(pair) }
+      {
+        schema_version: 1,
+        added: indexed_unmatched(@new_records, @right_counts),
+        removed: indexed_unmatched(@old_records, @left_counts),
+        changed: changes.reject { |item| item[:fields].empty? },
+        unchanged: changes.select { |item| item[:fields].empty? },
+        ambiguous: ambiguous.map { |pair| with_records(pair) }
+      }
+    end
+
+    def with_records(pair)
+      pair.merge(before: @old_records.fetch(pair[:before_index]), after: @new_records.fetch(pair[:after_index]))
+    end
+
+    def comparison(pair)
+      records = with_records(pair)
+      fields = FIELDS.filter_map do |field|
+        next if records[:before][field] == records[:after][field]
+
+        [field, { before: records[:before][field], after: records[:after][field] }]
+      end.to_h
+      records.merge(fields: fields)
+    end
+
+    def indexed_unmatched(records, counts)
+      records.each_with_index.filter_map do |contact, index|
+        { index: index, contact: contact } unless counts.key?(index)
+      end
+    end
+
+    def record(contact)
+      FIELDS.to_h { |field| [field, copy(contact.public_send(field))] }
+    end
+
+    def copy(value)
+      case value
+      when Hash then value.to_h { |key, item| [key, copy(item)] }
+      when Array then value.map { |item| copy(item) }
+      else copy_scalar(value)
+      end
+    end
+
+    def copy_scalar(value)
+      case value
+      when Time then value.iso8601(9)
+      when Pathname then value.to_s
+      when String then value.dup
+      else value
+      end
+    end
+
+    def freeze_tree(value)
+      case value
+      when Hash then value.each { |key, item| [key, item].each { |part| freeze_tree(part) } }
+      when Array then value.each { |item| freeze_tree(item) }
+      end
+      value.freeze
+    end
+  end
+end

data/lib/abbu/snapshot_history.rb

@@ -0,0 +1,66 @@
+# lib/abbu/snapshot_history.rb
+# frozen_string_literal: true
+
+require_relative 'archive'
+require_relative 'history_tracker'
+
+module Abbu
+  # Stream snapshot observations; IDs are local to this ordered analysis only.
+  class SnapshotHistory
+    include Enumerable
+
+    DEFAULT_LIMITS = { snapshots: 100, contacts: 10_000, pairs: 100_000 }.freeze
+
+    def initialize(paths, strict: false, retention: 2, limits: {})
+      limits = validated_limits(limits)
+      raise ArgumentError, 'retention must be a nonnegative integer' unless retention.is_a?(Integer) && retention >= 0
+
+      @paths = snapshot_paths(paths, limits[:snapshots])
+      @strict = strict
+      @options = { retention: retention, max_contacts: limits[:contacts], max_pairs: limits[:pairs] }.freeze
+    end
+
+    def self.from_directory(path, **)
+      raise ArgumentError, 'snapshot directory is unavailable' unless File.directory?(path)
+
+      paths = Dir.children(path).sort.filter_map do |name|
+        candidate = File.join(path, name)
+        candidate if name.end_with?('.abbu') && File.directory?(candidate)
+      end
+      new(paths, **)
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      tracker = HistoryTracker.new(**@options)
+      @paths.each_with_index do |path, index|
+        archive = Archive.new(path, strict: @strict)
+        snapshot = { index: index, path: path }.freeze
+        transition = tracker.advance(archive.contacts, snapshot)
+        yield transition.merge(diagnostics: archive.diagnostics.map(&:to_h).freeze).freeze
+      end
+      self
+    end
+
+    private
+
+    def validated_limits(limits)
+      raise ArgumentError, 'unknown limit' unless (limits.keys - DEFAULT_LIMITS.keys).empty?
+
+      DEFAULT_LIMITS.merge(limits).tap do |settings|
+        settings.each_value do |bound|
+          raise ArgumentError, 'limits must be positive integers' unless bound.is_a?(Integer) && bound.positive?
+        end
+      end
+    end
+
+    def snapshot_paths(paths, limit)
+      result = paths.take(limit + 1).map { |path| File.expand_path(path).freeze }.freeze
+      raise ArgumentError, 'snapshot count exceeds max_snapshots' if result.length > limit
+      raise ArgumentError, 'snapshot paths must be unique' if result.uniq.length != result.length
+
+      result
+    end
+  end
+end

data/lib/abbu/utils/fuzzy_matcher.rb

@@ -0,0 +1,116 @@
+# lib/abbu/utils/fuzzy_matcher.rb
+# frozen_string_literal: true
+
+require_relative 'deduplicator'
+
+module Abbu
+  module Utils
+    # Suggestions, not identity assertions. Bounds fail explicitly rather than
+    # silently truncating candidates; source contacts are never modified.
+    class FuzzyMatcher
+      FUZZY_WEIGHT = 0.15
+
+      def initialize(contact, candidates, threshold: 0.85, max_candidates: 10_000, max_name_length: 128)
+        validate_options(threshold, max_candidates, max_name_length)
+        @contact = contact
+        @candidates = candidates.take(max_candidates + 1)
+        raise ArgumentError, 'candidate limit exceeded' if @candidates.length > max_candidates
+
+        @threshold = threshold
+        @max_name_length = max_name_length
+      end
+
+      def matches
+        left_name = normalized_name(@contact)
+        results = @candidates.filter_map do |candidate|
+          next if candidate.equal?(@contact)
+
+          suggestion(candidate, left_name, normalized_name(candidate))
+        end
+        return results unless results.count { |match| match.score >= Deduplicator::MINIMUM_SCORE } > 1
+
+        results.map do |match|
+          Deduplicator::Match.new(left: match.left, right: match.right, evidence: match.evidence,
+                                  score: match.score, status: :ambiguous)
+        end
+      end
+
+      private
+
+      def validate_options(threshold, *bounds)
+        raise ArgumentError, 'threshold must be finite and between 0 and 1' unless
+          threshold.is_a?(Numeric) && threshold.real? && threshold.finite? && threshold.between?(0, 1)
+
+        bounds.each { |bound| validate_bound(bound) }
+      end
+
+      def validate_bound(bound)
+        raise ArgumentError, 'bounds must be positive integers' unless bound.is_a?(Integer) && bound.positive?
+      end
+
+      def normalized_name(contact)
+        name = contact.full_name.unicode_normalize(:nfc).downcase.strip.gsub(/\s+/, ' ')
+        raise ArgumentError, 'name length limit exceeded' if name.length > @max_name_length
+
+        name
+      end
+
+      def suggestion(candidate, left_name, right_name)
+        exact = Deduplicator.new([@contact, candidate]).matches.first
+        fuzzy = fuzzy_evidence(candidate, left_name, right_name)
+        return unless exact || fuzzy
+
+        evidence = combined_evidence(exact, fuzzy)
+        score = exact ? exact.score : fuzzy.fetch(:contribution)
+        Deduplicator::Match.new(left: @contact, right: candidate, evidence: evidence,
+                                score: score, status: exact ? exact.status : :ambiguous)
+      end
+
+      def combined_evidence(exact, fuzzy)
+        evidence = exact ? exact_evidence(exact) : []
+        evidence << fuzzy.merge(contribution: exact ? 0.0 : fuzzy.fetch(:contribution)).freeze if fuzzy
+        evidence
+      end
+
+      def exact_evidence(exact)
+        remaining = exact.score
+        seen = []
+        exact.evidence.map do |item|
+          contribution = seen.include?(item[:type]) ? 0.0 : [Deduplicator::WEIGHTS.fetch(item[:type]), remaining].min
+          remaining = (remaining - contribution).round(2)
+          seen << item[:type]
+          item.merge(contribution: contribution).freeze
+        end
+      end
+
+      def fuzzy_evidence(candidate, left_name, right_name)
+        return if left_name.empty? || right_name.empty?
+
+        distance = edit_distance(left_name.codepoints, right_name.codepoints)
+        similarity = 1.0 - (distance.to_f / [left_name.length, right_name.length].max)
+        return if similarity < @threshold
+
+        { type: :fuzzy_name, algorithm: :levenshtein, left_raw: @contact.full_name,
+          right_raw: candidate.full_name, left_normalized: left_name, right_normalized: right_name,
+          distance: distance, similarity: similarity, contribution: (similarity * FUZZY_WEIGHT).round(4) }.freeze
+      end
+
+      def edit_distance(left, right)
+        row = (0..right.length).to_a
+        left.each_with_index do |character, index|
+          row = distance_row(row, right, character, index)
+        end
+        row.last
+      end
+
+      def distance_row(row, right, character, index)
+        next_row = [index + 1]
+        right.each_with_index do |other, column|
+          substitution = row[column] + (character == other ? 0 : 1)
+          next_row << [next_row[column] + 1, row[column + 1] + 1, substitution].min
+        end
+        next_row
+      end
+    end
+  end
+end

data/lib/abbu/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Abbu
-  VERSION = '0.8.1'
+  VERSION = '0.18.0'
 end

data/lib/abbu.rb

@@ -7,17 +7,26 @@ require_relative 'abbu/diagnostic'
 require_relative 'abbu/parse_error'
 require_relative 'abbu/archive'
 require_relative 'abbu/live_store'
+require_relative 'abbu/machine_command'
+require_relative 'abbu/merge_plan'
+require_relative 'abbu/merge_preview'
 require_relative 'abbu/query'
 require_relative 'abbu/schema_inspector'
+require_relative 'abbu/snapshot_diff'
+require_relative 'abbu/snapshot_history'
 require_relative 'abbu/source'
 require_relative 'abbu/parsers/sqlite_parser'
 require_relative 'abbu/parsers/plist_parser'
 require_relative 'abbu/exporters/csv_exporter'
+require_relative 'abbu/exporters/icalendar_exporter'
 require_relative 'abbu/exporters/json_exporter'
+require_relative 'abbu/exporters/jsonl_exporter'
+require_relative 'abbu/exporters/sqlite_exporter'
 require_relative 'abbu/exporters/vcard_exporter'
 require_relative 'abbu/image_extractor'
 require_relative 'abbu/utils/contact_identity'
 require_relative 'abbu/utils/deduplicator'
+require_relative 'abbu/utils/fuzzy_matcher'
 require_relative 'abbu/utils/label_normalizer'
 
 module Abbu

data/sig/fuzzy_matcher.rbs

@@ -0,0 +1,22 @@
+# sig/fuzzy_matcher.rbs
+module Abbu
+  module Utils
+    class Deduplicator
+      class Match
+        attr_reader left: Contact
+        attr_reader right: Contact
+        attr_reader evidence: Array[Hash[Symbol, untyped]]
+        attr_reader score: Float
+        attr_reader confidence: Symbol
+        attr_reader status: Symbol
+        def sources: () -> Array[untyped]
+        def ambiguous?: () -> bool
+        def merge: (?policy: untyped) -> untyped
+      end
+    end
+    class FuzzyMatcher
+      def initialize: (Contact contact, Enumerable[Contact] candidates, ?threshold: Numeric, ?max_candidates: Integer, ?max_name_length: Integer) -> void
+      def matches: () -> Array[Deduplicator::Match]
+    end
+  end
+end

data/sig/icalendar_exporter.rbs

@@ -0,0 +1,13 @@
+# sig/icalendar_exporter.rbs
+module Abbu
+  module Exporters
+    class IcalendarExporter
+      type diagnostic = { category: Symbol, contact_index: Integer, field: Symbol }
+      attr_reader diagnostics: Array[diagnostic]
+      def initialize: (Enumerable[Contact] contacts, year: Integer, generated_at: Time, calendar_id: String) -> void
+      def to_ical: () -> String
+      def to_file: (String | Pathname path) -> Integer
+      def to_stdout: () -> nil
+    end
+  end
+end

data/sig/machine_output.rbs

@@ -0,0 +1,23 @@
+# sig/machine_output.rbs
+module Abbu
+  module Exporters
+    class JsonExporter
+      def payload: () -> Array[Hash[Symbol, untyped]]
+    end
+  end
+
+  class MachineOutput
+    def initialize: (untyped input) -> void
+    def contacts: (?Enumerable[Contact] records) -> Array[Hash[Symbol, untyped]]
+    def stats: () -> Hash[Symbol, Integer]
+    def diagnostics: () -> Array[Hash[Symbol, untyped]]
+    def duplicates: () -> Array[Hash[Symbol, untyped]]
+    def matches: () -> Array[Hash[Symbol, untyped]]
+    def images: (String destination) -> Hash[Symbol, untyped]
+  end
+
+  class MachineCommand
+    def initialize: (Hash[Symbol, untyped] options, Array[String] arguments, ?stdout: untyped, ?stderr: untyped) -> void
+    def run: () -> Integer
+  end
+end

data/sig/mcp.rbs

@@ -0,0 +1,19 @@
+# sig/mcp.rbs
+module Abbu
+  module Mcp
+    class ReadSession
+      def initialize: (untyped input) -> void
+      def query: (mode: String, value: String, ?offset: Integer, ?limit: Integer) -> Hash[Symbol, untyped]
+      def stats: () -> Hash[Symbol, Integer]
+      def diagnostics: () -> Array[Hash[Symbol, untyped]]
+      def sources: () -> Array[Hash[Symbol, untyped]]
+      def groups: () -> Array[Hash[Symbol, untyped]]
+    end
+
+    class Server
+      attr_reader server: untyped
+      def initialize: (path: String, ?live: bool, ?strict: bool) -> void
+      def open: () -> untyped
+    end
+  end
+end