badline 0.12.0 → 0.13.0

data/lib/badline/kernal_trap/dos/channel.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    class DOS
+      # One open channel on the virtual drive, holding a file, a block buffer
+      # or the command channel's status message. It gives out one byte at a
+      # time and flags the last one, so the bus can raise EOI with it. A
+      # channel cut short by a read error never flags one, and holds the
+      # error for the drive to report once its bytes run out.
+      class Channel
+        attr_accessor :buffer
+        attr_reader :error, :pointer
+        attr_writer :lead
+
+        def initialize(bytes = [], error: nil, writable: false, base: 0)
+          @base = base
+          replace(bytes)
+          @error = error
+          @writable = writable
+        end
+
+        # A block buffer opened with "#", which reads and writes one of the
+        # drive's buffers in its RAM, so M-R and M-W reach the same bytes. It
+        # hands out the whole block unless a B-R sets a shorter end, and
+        # flags that byte as the last. The DOS opens it with the pointer at 1
+        # and the buffer's number as the byte to send, so the first read
+        # answers with the number and the next one moves on to the third
+        # byte.
+        def self.buffer(memory, number)
+          new(memory.ram, writable: true, base: Memory.buffer_address(number)).tap do |channel|
+            channel.buffer = number
+            channel.rewind(BLOCK_SIZE)
+            channel.pointer = 1
+            channel.lead = number
+          end
+        end
+
+        # A file's bytes, up to the first block its chain can't read. The
+        # drive reads a block ahead before sending the last byte of the one
+        # before, so a bad block holds that byte back too, and a bad first
+        # block or a missing file leaves nothing to send.
+        def self.for_file(storage, name, type)
+          data = storage.read_file(name, type:)
+          return new([], error: [FILE_NOT_FOUND]) unless data
+
+          failure = storage.respond_to?(:read_error) && storage.read_error(name, type:)
+          return new(data) unless failure
+
+          new(data[0, failure[:offset] - 1] || [], error: failure.values_at(:error, :track, :sector))
+        end
+
+        # The file an open names. The drive keeps the first block of the file
+        # a LOAD (secondary address 0) opens at $7E and $026F of its memory,
+        # and a LOAD of a name starting with "*" reopens that file rather than
+        # the first one on the disk. Loaders write the block there with M-W
+        # to load a file the directory doesn't list. A LOAD of "$" reads the
+        # directory as a BASIC program, which a pattern after a colon narrows
+        # to the files it names.
+        def self.for_name(storage, memory, secondary, name, type)
+          return new(storage.directory.bytes(name)) if listing?(storage, secondary, name)
+
+          file = Storage.parse_name(name).first
+          return for_file(storage, file, type) unless secondary.zero? && storage.respond_to?(:first_block)
+
+          last = memory.last_program if name.start_with?("*")
+          return at_block(storage, *last) if last
+
+          block = storage.first_block(file, type:)
+          memory.last_program = block if block
+          for_file(storage, file, type)
+        end
+
+        def self.listing?(storage, secondary, name)
+          secondary.zero? && name.start_with?("$") && storage.respond_to?(:directory)
+        end
+
+        # The file whose chain starts at the block.
+        def self.at_block(storage, track, sector)
+          data = storage.read_file_at(track, sector)
+          data ? new(data) : new([], error: [ILLEGAL_TRACK_OR_SECTOR, track, sector])
+        end
+
+        # Reads what save_state wrote after the flag that marks a file open
+        # for writing (Channels.channel_from_state). A buffer channel
+        # takes its block in `ram`, the drive's RAM, again.
+        def self.from_state(input, ram)
+          new.tap { |channel| channel.load_state(input, ram) }
+        end
+
+        # A buffer channel's bytes are the drive's RAM, which the drive
+        # writes itself.
+        def save_state(out)
+          out.boolean(false).boolean(@writable).int(@base).int(@length).int(@pointer)
+          out.optional_int(@lead).optional_int(@buffer).boolean(!@error.nil?)
+          out.ints(@error) if @error
+          out.blob(@bytes) unless @writable
+        end
+
+        def load_state(input, ram)
+          @writable = input.boolean?
+          @base = input.int
+          @length = input.int
+          @pointer = input.int
+          @lead = input.optional_int
+          @buffer = input.optional_int
+          @error = input.boolean? ? input.ints : nil
+          @bytes = @writable ? ram : input.blob
+        end
+
+        def replace(bytes, length = bytes.length)
+          @bytes = bytes
+          rewind(length)
+        end
+
+        def rewind(length)
+          @length = length
+          self.pointer = 0
+        end
+
+        def pointer=(position)
+          @pointer = position
+          @lead = nil
+        end
+
+        # A block read into the channel. A buffer channel takes it into its
+        # buffer, a file channel hands it out in place of the file.
+        def load(block, length)
+          return replace(block.dup, length) unless @writable
+
+          @bytes[@base, block.length] = block
+          rewind(length)
+        end
+
+        def writable? = @writable
+
+        # A buffer channel's block, as a block write puts it on the disk.
+        def block = @bytes[@base, BLOCK_SIZE]
+
+        def exhausted?
+          @pointer >= @length
+        end
+
+        # A file that holds nothing but its error never opened.
+        def failed?
+          exhausted? && !@error.nil?
+        end
+
+        # Each byte lands at the pointer, which wraps within the block.
+        def write(bytes)
+          @lead = nil
+          bytes.each do |byte|
+            @bytes[@base + @pointer] = byte
+            @pointer = (@pointer + 1) & 0xff
+          end
+        end
+
+        def read
+          return read_buffer if @writable
+          return if exhausted?
+
+          byte = @lead || @bytes[@base + @pointer]
+          @lead = nil
+          @pointer += 1
+          [byte, exhausted? && !@error]
+        end
+
+        private
+
+        # A buffer never runs out. Past its last byte, which goes out with
+        # EOI, the pointer wraps back to the second, and a pointer set past
+        # the end runs on around the block to it.
+        def read_buffer
+          byte = @lead || @bytes[@base + @pointer]
+          @lead = nil
+          last = @pointer == @length - 1
+          @pointer = last ? 1 : (@pointer + 1) & 0xff
+          [byte, last]
+        end
+      end
+    end
+  end
+end

data/lib/badline/kernal_trap/{drive → dos}/channels.rb

@@ -2,7 +2,7 @@
 
 module Badline
   module KernalTrap
-    class Drive
+    class DOS
       # The drive's open data channels by secondary address, and the five
       # buffers they hold. The DOS hands out the highest free buffer.
       # Reading the BAM when it initializes the disk takes buffer 4, so

data/lib/badline/kernal_trap/{drive → dos}/memory.rb

@@ -2,7 +2,7 @@
 
 module Badline
   module KernalTrap
-    class Drive
+    class DOS
       # The drive's 2K of RAM, as M-W and M-R reach it, with the job queue
       # that runs a read job written into it: a job code for each of five
       # buffers at $00, their track and sector pairs from $06, and the

data/lib/badline/kernal_trap/{drive → dos}/parameters.rb

@@ -2,7 +2,7 @@
 
 module Badline
   module KernalTrap
-    class Drive
+    class DOS
       # The numbers a DOS command takes. The DOS skips spaces, commas and
       # cursor-rights before a parameter, reads it from the characters $30
       # to $3F that follow, the low nibble of each, and skips whatever

data/lib/badline/kernal_trap/{drive → dos}/status.rb

@@ -2,7 +2,7 @@
 
 module Badline
   module KernalTrap
-    class Drive
+    class DOS
       # The command channel's side of the drive: the last DOS error with the
       # track and sector it happened at, or the bytes an M-R read. Once its
       # last byte has been read, it holds OK again.

data/lib/badline/kernal_trap/{drive → dos}/write_file.rb

@@ -2,7 +2,7 @@
 
 module Badline
   module KernalTrap
-    class Drive
+    class DOS
       # A channel open for writing a file. It gathers the bytes sent to it,
       # and the drive writes the file to the disk when the channel closes.
       # An append starts from the file's end, a replace writes over the

data/lib/badline/kernal_trap/{drive → dos}/writes.rb

@@ -2,7 +2,7 @@
 
 module Badline
   module KernalTrap
-    class Drive
+    class DOS
       # Opens for writing, the S command and the reports a write makes. A
       # file open for writing takes the type its name asks for, or SEQ on a
       # data channel. On a write-protected disk, or storage that doesn't

data/lib/badline/kernal_trap/{drive.rb → dos.rb}

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
-require "badline/kernal_trap/drive/block_commands"
-require "badline/kernal_trap/drive/channels"
-require "badline/kernal_trap/drive/memory"
-require "badline/kernal_trap/drive/parameters"
-require "badline/kernal_trap/drive/status"
-require "badline/kernal_trap/drive/writes"
-require "badline/kernal_trap/drive/write_file"
+require "badline/kernal_trap/dos/block_commands"
+require "badline/kernal_trap/dos/channel"
+require "badline/kernal_trap/dos/channels"
+require "badline/kernal_trap/dos/memory"
+require "badline/kernal_trap/dos/parameters"
+require "badline/kernal_trap/dos/status"
+require "badline/kernal_trap/dos/writes"
+require "badline/kernal_trap/dos/write_file"
 
 module Badline
   module KernalTrap
@@ -16,7 +17,7 @@ module Badline
     # LOAD. A disk image whose host file takes writes takes files, blocks
     # and BAM changes too. Other disks are write-protected, though storage
     # that can write files still takes a SAVE handed over whole.
-    class Drive
+    class DOS
       include BlockCommands
       include Writes
 
@@ -146,10 +147,10 @@ module Badline
       # vector, as U: does.
       def reset! = reset(cold: true)
 
-      # The mounted storage's setup, for Storage.reopen, then the drive's
+      # The mounted storage's setup (Snapshot::StorageSetup), then the drive's
       # RAM, its status and its open channels.
       def save_state(out)
-        @storage.save_setup(out)
+        Snapshot::StorageSetup.write(@storage, out)
         out.marker("TRAP DRIVE")
         @memory.save_state(out)
         @status.save_state(out)

data/lib/badline/kernal_trap/{file.rb → file_routine.rb}

@@ -2,7 +2,7 @@
 
 module Badline
   module KernalTrap
-    class File < Routine
+    class FileRoutine < Routine
       private
 
       def active?

data/lib/badline/kernal_trap/load.rb

@@ -12,7 +12,7 @@ module Badline
     # below $0334, into the zero page, the stack or the KERNAL vectors: the
     # ROM's byte loop then loads it through the serial traps, and a loader
     # that overwrites ISTOP takes over mid-load as it does on a real drive.
-    class Load < File
+    class Load < FileRoutine
       # ST bits at $90
       EOI = 0x40
       VERIFY_MISMATCH = 0x10
@@ -23,9 +23,9 @@ module Badline
       # address even when the first one relocated.
       LOAD_SECONDARY = 0x60
 
-      def initialize(cpu:, bus:, layout:, drive:)
+      def initialize(cpu:, bus:, layout:, dos:)
         super(cpu:, bus:, layout:)
-        @drive = drive
+        @dos = dos
       end
 
       def call
@@ -38,7 +38,7 @@ module Badline
 
         data, complete = receive(name)
         if low_memory?(data)
-          @drive.close(0)
+          @dos.close(0)
         else
           finish(data, complete)
         end
@@ -50,10 +50,10 @@ module Badline
       # flagged EOI. A read error in the file's chain stops the bytes early,
       # with no EOI.
       def receive(name)
-        @drive.open(0, name)
+        @dos.open(0, name)
         data = []
         loop do
-          byte, eoi = @drive.read(0)
+          byte, eoi = @dos.read(0)
           return [data, false] unless byte
 
           data << byte

data/lib/badline/kernal_trap/save.rb

@@ -15,15 +15,15 @@ module Badline
     # write: the drive stops listening, so ST reads DEVICE NOT PRESENT,
     # and the ROM returns without an error. A "@" before the drive prefix
     # writes over a file of the same name.
-    class Save < File
+    class Save < FileRoutine
       SECONDARY = 0x61
 
       # ST bit at $90
       DEVICE_NOT_PRESENT = 0x80
 
-      def initialize(cpu:, bus:, layout:, drive:)
+      def initialize(cpu:, bus:, layout:, dos:)
         super(cpu:, bus:, layout:)
-        @drive = drive
+        @dos = dos
         @saving = false
       end
 
@@ -38,7 +38,7 @@ module Badline
       def call
         return unless active?
         return finish if @saving
-        return unless @drive.saves?
+        return unless @dos.saves?
 
         @bus.poke(0xb9, SECONDARY)
         return @cpu.program_counter = @layout.missing_file_name_exit if name.empty?
@@ -56,7 +56,7 @@ module Badline
 
       def finish
         @saving = false
-        saved = @drive.save(name, payload, replace: full_filename.start_with?("@"))
+        saved = @dos.save(name, payload, replace: full_filename.start_with?("@"))
         @bus.poke(0x90, DEVICE_NOT_PRESENT) unless saved
         @bus.poke(0xac, @bus.peek(0xae))
         @bus.poke(0xad, @bus.peek(0xaf))

data/lib/badline/kernal_trap/serial.rb

@@ -23,9 +23,9 @@ module Badline
 
       NO_DATA = [0x0d, EOI | READ_TIMEOUT].freeze
 
-      def initialize(cpu:, bus:, layout:, drive:, device: DEVICE)
+      def initialize(cpu:, bus:, layout:, dos:, device: DEVICE)
         super(cpu:, bus:, layout:)
-        @drive = drive
+        @dos = dos
         @device = device
         @listening = false
         @talking = false
@@ -144,7 +144,7 @@ module Badline
       # takes data only on a channel it has open. Otherwise nothing holds
       # the data line when a byte starts, so the KERNAL finds no device.
       def accepted?
-        [OPEN, CLOSE].include?(@frame) || @drive.listening?(@listen_channel)
+        [OPEN, CLOSE].include?(@frame) || @dos.listening?(@listen_channel)
       end
 
       def unlisten
@@ -188,15 +188,15 @@ module Badline
         return unless @listen_channel
 
         case @frame
-        when OPEN then @drive.open(@listen_channel, @buffer.pack("C*"))
-        when CLOSE then @drive.close(@listen_channel)
-        else @drive.write(@listen_channel, @buffer)
+        when OPEN then @dos.open(@listen_channel, @buffer.pack("C*"))
+        when CLOSE then @dos.close(@listen_channel)
+        else @dos.write(@listen_channel, @buffer)
         end
         @buffer = []
       end
 
       def received
-        byte, eoi = @drive.read(@talk_channel)
+        byte, eoi = @dos.read(@talk_channel)
         return NO_DATA unless byte
 
         [byte, eoi ? EOI : 0]

data/lib/badline/kernal_trap.rb

@@ -2,9 +2,8 @@
 
 require "badline/kernal_trap/layout"
 require "badline/kernal_trap/routine"
-require "badline/kernal_trap/channel"
-require "badline/kernal_trap/drive"
-require "badline/kernal_trap/file"
+require "badline/kernal_trap/dos"
+require "badline/kernal_trap/file_routine"
 require "badline/kernal_trap/load"
 require "badline/kernal_trap/save"
 require "badline/kernal_trap/serial"

data/lib/badline/machine/clocking.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Badline
+  module Machine
+    # Running a machine from outside its own #cycle!, and the handlers that
+    # wait for its KERNAL to boot. C64, Vic20 and C128 each include it
+    # and answer #cycle!, #cycles and #init_threshold, the cycle at which
+    # #on_init's handlers run, and keep the handlers in @init_handlers.
+    module Clocking
+      # Runs `count` cycles, one #cycle! after another.
+      def run_cycles(count)
+        i = 0
+        while i < count
+          cycle!
+          i += 1
+        end
+      end
+
+      # Runs cycles until the block returns true or the cycle count passes
+      # `limit`, checking before each cycle.
+      def run_until(limit)
+        cycle! until yield || @cycles > limit
+      end
+
+      # Runs the block once the KERNAL has booted (see init_threshold), or
+      # now if it has.
+      def on_init(&block)
+        if booting?
+          @init_handlers << block
+        else
+          block.call
+        end
+      end
+
+      def inspect
+        "#<#{self.class.name} cycles=#{@cycles} cpu=(#{@cpu.inspect})>"
+      end
+
+      private
+
+      def booting?
+        @cycles < init_threshold
+      end
+
+      def handle_init
+        @init_handlers.each(&:call)
+      end
+    end
+  end
+end

data/lib/badline/machine.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+require "badline/machine/clocking"
+
 module Badline
   # = Machine
   #
   # The machines badline builds by family, as the command line's
-  # subcommand names them: the C64, Computer, the VIC-20, Vic20, and the
+  # subcommand names them: the C64, Badline::C64, the VIC-20, Vic20, and the
   # C128 in C64 mode, C128.
   #
   # A machine answers what the front end, Media, the runners and the
@@ -26,7 +28,7 @@ module Badline
   #   +press_cartridge_button+, +release_cartridge_button+,
   #   +attach_drive1541+, +drive1541+, +true_drive+ and +plug_true_drive+
   #   for the drive Media::TrueDrive plugs in, +attach_drive1581+,
-  #   +drive1581+ and +plug_drive1581+ for a 1581 (Drive1581::Slot), and
+  #   +drive1581+ and +plug_drive1581+ for a 1581 (Drives::Model1581::Slot), and
   #   +address_bus+ for its +cartridge+ and +detach_cartridge+.
   # - Snapshots and tests: +snapshot+, +restore+, +save_snapshot+,
   #   +install_debug_register+ and +capture_output+.
@@ -44,22 +46,48 @@ module Badline
   # +press_caps_lock+, +release_caps_lock+, +press_display_key+,
   # +release_display_key+, and +attach_drive1571+ and +drive1571+ for the
   # C128D's 1571, its true drive.
+  #
+  # Each machine includes Machine::Clocking for the clocking part.
   module Machine
+    # Media the machine named doesn't take.
+    class Unsupported < ArgumentError; end
+
     # A new machine of `family`, :c64, :vic20 or :c128, the model of it
     # `model` names. A C64's model is one of Model::ALL, with its SID
     # `sid_model` when not nil and an REU of `reu` K when not nil. A
     # VIC-20's is "pal", with the RAM expansion `ram` names
     # (Vic20::Bus::RAM_CONFIGURATIONS), unexpanded when nil. A C128's is
-    # one of C128::Model::ALL, with its SID `sid_model` when not nil.
+    # one of C128::Model::ALL, with its SID `sid_model` when not nil, built
+    # for C64 mode.
     def self.build(family, model:, sid_model: nil, reu: nil, ram: nil)
       return vic20(model, ram) if family == :vic20
-      return C128.new(model:, sid_model:) if family == :c128
+      return c128(model, sid_model, :c64) if family == :c128
       raise ArgumentError, "no machine family named #{family}" unless family == :c64
 
       profile = Model.named(model)
-      Computer.new(vic_model: profile.vic_model, cia_model: profile.cia_model,
-                   sid_model: sid_model || profile.sid_model, region: profile.region, reu:,
-                   kernal: profile.kernal, datasette: profile.datasette, board: profile.board)
+      C64.new(vic_model: profile.vic_model, cia_model: profile.cia_model,
+              sid_model: sid_model || profile.sid_model, region: profile.region, reu:,
+              kernal: profile.kernal, datasette: profile.datasette, board: profile.board)
+    end
+
+    # The machine the command line's `options` name, to start `media`, a
+    # path or nil. A C64 or a C128 without a SID named takes the one a .sid
+    # tune names. The C128 is built for C128 mode, with C= held through the
+    # reset, so its KERNAL starts C64 mode, for --c64 (+c64_mode?+) or media
+    # only C64 mode runs: a .sid tune or a program that loads at the C64's
+    # BASIC start. A VIC-20 without RAM named gets the expansion the media
+    # needs (Media::Vic20Media.ram_for) and yields a line saying so. Raises
+    # Unsupported for media a VIC-20 doesn't take.
+    def self.for_options(options, media, &)
+      family = options.family
+      return vic20_for(media, options.model, options.ram, &) if family == :vic20
+
+      sid_model = options.sid_model || Media.sid_model(media, otherwise: nil)
+      return build(:c64, model: options.model, sid_model:, reu: options.reu) unless family == :c128
+
+      machine = c128(options.model, sid_model, :c128)
+      machine.hold_commodore_key if options.c64_mode? || c64_media?(media)
+      machine
     end
 
     def self.vic20(model, ram)
@@ -68,5 +96,33 @@ module Badline
       Vic20.new(ram: ram || :unexpanded)
     end
     private_class_method :vic20
+
+    def self.c128(model, sid_model, mode) = C128.new(model:, sid_model:, mode:)
+    private_class_method :c128
+
+    def self.vic20_for(media, model, ram)
+      unless media.nil?
+        unsupported = Media::Vic20Media::UNSUPPORTED.include?(File.extname(media).downcase)
+        raise Unsupported, "doesn't go in a VIC-20" if unsupported
+
+        unless ram
+          ram = Media::Vic20Media.ram_for(media)
+          yield "RAM expansion: #{ram}"
+        end
+      end
+      build(:vic20, model:, ram:)
+    end
+    private_class_method :vic20_for
+
+    def self.c64_media?(media)
+      return false if media.nil? || !File.file?(media)
+
+      extension = File.extname(media).downcase
+      return true if extension == ".sid"
+      return false unless %w[.prg .p00].include?(extension)
+
+      [Media::BASIC_START, Media::BASIC_START - 1].include?(Storage::P00.load_address(media))
+    end
+    private_class_method :c64_media?
   end
 end

data/lib/badline/media/boot_disk.rb

@@ -15,7 +15,7 @@ module Badline
     module BootDisk
       SIGNATURE = "CBM".bytes.freeze
       AUTO_BOOT = "copyright cbm 86"
-      TYPES = %w[.d64 .d71 .d81].freeze
+      TYPES = Extensions.of(%i[disk])
 
       class << self
         def takes?(computer, path)
@@ -38,7 +38,7 @@ module Badline
           type = File.extname(path).downcase
           return false unless TYPES.include?(type) && File.file?(path)
 
-          image = MOUNT_TYPES.fetch(type).new(path, read_only: true)
+          image = Media.open_storage(path, { read_only: true })
           block = image.read_block(1, 0)
           return true if block && block[0, 3] == SIGNATURE
 

data/lib/badline/media/disk_list.rb

@@ -11,9 +11,9 @@ module Badline
       # A list naming no disk image that's there.
       class Error < ArgumentError; end
 
-      EXTENSIONS = %w[.m3u .vfl].freeze
+      EXTENSIONS = Extensions.of(%i[disk_list])
 
-      def self.list?(path) = EXTENSIONS.include?(File.extname(path).downcase)
+      def self.list?(path) = Extensions.kind(path) == :disk_list
 
       # The disk `path` puts in the drive: a list's first disk, or the
       # path itself.
@@ -32,7 +32,7 @@ module Badline
         found = []
         entries(list).each do |entry|
           disk = entry.start_with?("/") ? entry : File.join(directory, entry)
-          found << disk if DiskSet::EXTENSIONS.include?(File.extname(disk).downcase) && File.file?(disk)
+          found << disk if Extensions::DISKS.include?(File.extname(disk).downcase) && File.file?(disk)
         end
         found
       end

data/lib/badline/media/disk_set.rb

@@ -13,7 +13,7 @@ module Badline
     # ahead of the names.
     module DiskSet
       KINDS = %w[disk disc side part].freeze
-      EXTENSIONS = %w[.d64 .d71 .d81 .g64].freeze
+      EXTENSIONS = Extensions::DISKS
 
       # The paths of the set's disks in order, or just `path` when it
       # belongs to none. A list's set is the disks it lists.

data/lib/badline/media/extensions.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # The kind of medium each file extension names, which every check of a
+    # path's extension reads. A file with any other extension is a program.
+    # It loads on its own, for Options.
+    #
+    # - :disk, a disk image that the traps mount and a true drive reads
+    # - :gcr, a disk's raw GCR, which only a true drive reads
+    # - :archive, a .t64, which the traps mount read-only
+    # - :tape, :cartridge and :tune
+    # - :disk_list, a list of the disks of a set (DiskList)
+    module Extensions
+      KINDS = {
+        ".d64" => :disk, ".d71" => :disk, ".d81" => :disk, ".g64" => :gcr, ".g71" => :gcr, ".t64" => :archive,
+        ".tap" => :tape, ".crt" => :cartridge, ".sid" => :tune, ".m3u" => :disk_list, ".vfl" => :disk_list
+      }.freeze
+
+      # The kind of the medium at `path`, by its extension.
+      def self.kind(path) = KINDS.fetch(File.extname(path).downcase, :program)
+
+      # The extensions of the kinds given.
+      def self.of(kinds) = KINDS.keys.select { |extension| kinds.include?(KINDS[extension]) }.freeze
+
+      # Disk images, which a drive reads.
+      DISKS = of(%i[disk gcr])
+
+      # What goes in device 8 through the traps.
+      MOUNTABLE = of(%i[disk archive])
+    end
+  end
+end