badline 0.17.0 → 0.19.0

data/lib/badline/storage/d90_image.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    # A D9060 or D9090 hard disk: 153 cylinders of 32 blocks a head, four
+    # heads on the D9060 and six on the D9090. DOS 3.0 numbers a block by
+    # its cylinder as the track, from 0, and by head × 32 + sector as the
+    # sector. The controller numbers the same block by its place in the
+    # image (LBA), and reads and writes it there.
+    #
+    # The image's size tells the two apart. One of another size, such as an
+    # empty file to format, takes the heads it's given, or four, and reads as
+    # zeros past its end.
+    class D90Image < DiskImage
+      CYLINDERS = 153
+      SECTORS_PER_HEAD = 32
+
+      # The heads of each drive, by the size of its image.
+      HEADS = { 5_013_504 => 4, 7_520_256 => 6 }.freeze
+
+      # The BAM entry of a head: a free count and a four-byte bitmap.
+      ENTRY = 5
+
+      # The heads of the drive an image of the size belongs to, or nil for
+      # a size neither has.
+      def self.heads_for(size) = HEADS[size]
+
+      attr_reader :heads
+
+      def initialize(path, read_only: false, bytes: nil, heads: nil)
+        super(path, read_only:, bytes:)
+        @heads = heads || HEADS.fetch(@bytes.length, 4)
+        size = block_count * SECTOR_SIZE
+        @bytes.concat(Array.new(size - @bytes.length, 0)) if @bytes.length < size
+      end
+
+      def sectors_in(_track) = @heads * SECTORS_PER_HEAD
+
+      # The blocks the disk holds.
+      def block_count = CYLINDERS * sectors_in(0)
+
+      # The controller's number for the block.
+      def lba(track, sector) = (track * sectors_in(track)) + sector
+
+      def header_block = [76, 20]
+
+      # Whether the disk holds the blocks from the LBA on.
+      def blocks?(lba, count) = lba >= 0 && lba + count <= block_count
+
+      # The bytes of the blocks from the LBA on, or nil when the disk
+      # doesn't hold them all.
+      def read_blocks(lba, count)
+        @bytes[lba * SECTOR_SIZE, count * SECTOR_SIZE] if blocks?(lba, count)
+      end
+
+      # Writes whole blocks from the LBA on, straight to the host file. It
+      # writes nothing when the disk doesn't hold them all. A disk that
+      # takes no writes raises WRITE PROTECT ON and keeps its blocks.
+      def write_blocks(lba, bytes)
+        return unless (bytes.length % SECTOR_SIZE).zero? && blocks?(lba, bytes.length / SECTOR_SIZE)
+        raise WriteError, WriteError::WRITE_PROTECT_ON unless writable?
+
+        store(lba * SECTOR_SIZE, bytes)
+        @bytes[lba * SECTOR_SIZE, bytes.length] = bytes
+        @entries = nil
+      end
+
+      def bam_block?(track, sector) = block?(track, sector)
+
+      def block_free?(track, sector)
+        block?(track, sector) && @bytes[bitmap_byte(track, sector)][sector % 8] == 1
+      end
+
+      private
+
+      def error_tables = {}
+
+      def store(offset, bytes)
+        File.open(@path, "r+b") do |file|
+          file.seek(offset)
+          file.write(bytes.pack("C*"))
+        end
+      rescue SystemCallError
+        raise WriteError, WriteError::WRITE_PROTECT_ON
+      end
+
+      def block?(track, sector)
+        track.between?(0, CYLINDERS - 1) && sector.between?(0, sectors_in(track) - 1)
+      end
+
+      def track_offset(track) = track * sectors_in(track)
+
+      def clear_blocks
+        header = sector_offset(*header_block)
+        @bytes.fill(0, 0, header)
+        @bytes.fill(0, header + SECTOR_SIZE, (block_count * SECTOR_SIZE) - header - SECTOR_SIZE)
+      end
+
+      # The header at 76/20 holds the disk name at $06 and the ID at $18,
+      # after the link to the directory's first block, 76/10.
+      def header_name = 0x06
+      def directory_track = 76
+      def directory_sector = 10
+      def directory_interleave = 3
+      def interleave = 10
+      def reserved_tracks = [76]
+
+      # A link to track 0 ends a chain, so files never go there.
+      def allocation_order = super - [0]
+
+      def bam_tracks = 0..(CYLINDERS - 1)
+      def header_link = [76, 10]
+      def dos_type = "3A"
+      def header_tail = 4
+
+      # The header holds no format letter after its link.
+      def write_header(name, id)
+        super
+        write_at(*header_block, 2, [0])
+      end
+
+      # The BAM takes sector 0 of a cylinder for each group of cylinders
+      # its entries fit in, twelve on a D9060 and eight on a D9090: the
+      # cylinder after the group's first, or the last one for a group of
+      # one at the end.
+      def tracks_per_bam_block = (SECTOR_SIZE - 16) / (@heads * ENTRY)
+
+      def bam_block_track(track)
+        first = track - (track % tracks_per_bam_block)
+        [first + 1, CYLINDERS - 1].min
+      end
+
+      def entry_offset(track, sector)
+        group = track % tracks_per_bam_block
+        sector_offset(bam_block_track(track), 0) + 16 +
+          (((group * @heads) + (sector / SECTORS_PER_HEAD)) * ENTRY)
+      end
+
+      def bitmap_byte(track, sector) = entry_offset(track, sector) + 1 + ((sector % SECTORS_PER_HEAD) / 8)
+
+      def mark(track, sector, free)
+        return if !block?(track, sector) || block_free?(track, sector) == free
+
+        entry = entry_offset(track, sector)
+        byte = bitmap_byte(track, sector)
+        bit = 1 << (sector % 8)
+        @bytes[byte] = free ? @bytes[byte] | bit : @bytes[byte] & ~bit
+        @bytes[entry] = (@bytes[entry] + (free ? 1 : -1)) & 0xff
+      end
+
+      def free_track(track)
+        @heads.times do |head|
+          @bytes[entry_offset(track, head * SECTORS_PER_HEAD), ENTRY] = [SECTORS_PER_HEAD, 0xff, 0xff, 0xff, 0xff]
+        end
+      end
+
+      def blocks_free
+        (bam_tracks.to_a - reserved_tracks).sum do |track|
+          (0...@heads).sum { |head| @bytes[entry_offset(track, head * SECTORS_PER_HEAD)] }
+        end
+      end
+
+      # Block 0/0 points at the bad-block list in 0/1, the directory, the
+      # header and the BAM's first block, and holds the ID. Each BAM block
+      # links the next and the one before it, $FF $FF at either end, and
+      # names the first cylinder it covers and the one past its last.
+      def bam_headers(id)
+        groups = bam_tracks.each_slice(tracks_per_bam_block).to_a
+        blocks = groups.map { |tracks| bam_block_track(tracks.first) }
+        bam = groups.each_with_index.map do |tracks, i|
+          following = i == groups.length - 1 ? [0xff, 0xff] : [blocks[i + 1], 0]
+          previous = i.zero? ? [0xff, 0xff] : [blocks[i - 1], 0]
+          [blocks[i], 0, [*following, *previous, tracks.first, tracks.last + 1]]
+        end
+        [[0, 0, [0, 1, 0, 0xff, *header_link, *header_block, blocks.first, 0, *id]],
+         [0, 1, Array.new(SECTOR_SIZE, 0xff)], *bam]
+      end
+    end
+  end
+end

data/lib/badline/storage/kim_tape.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    # A KIM-1 cassette, held as the times its signal crosses zero, in
+    # microseconds from the start of the tape, which are the KIM-1's
+    # cycles. The KIM-1 writes the tape as a square wave on U2's PB7, each
+    # bit 3,700 Hz then 2,400 Hz, and reads it back through a 565 PLL and a
+    # 311 comparator, which hold PB7 high through the 2,400 Hz tone and low
+    # through the 3,700 Hz one (User Manual, appendix E). edges gives the
+    # times PB7 changes as the tape plays.
+    #
+    # A tape reads from a .wav file, 8-bit or 16-bit PCM, its first
+    # channel only, and writes one back as a square wave.
+    class KIMTape
+      class FormatError < StandardError; end
+
+      # A period longer than this many microseconds is the 2,400 Hz tone:
+      # the split between the tones, at the geometric mean of the two.
+      SPLIT = 336
+
+      # The time constants, in seconds, of the detector's DC level and of
+      # its envelope, which sets the hysteresis.
+      DC_TIME = 0.002
+      ENVELOPE_TIME = 0.005
+
+      # The signal crosses the DC level once it swings this fraction of the
+      # envelope past it, and not for an envelope smaller than SILENCE, of
+      # full scale.
+      HYSTERESIS = 0.3
+      SILENCE = 0.03
+
+      # A gap this many microseconds long between crossings plays as
+      # silence in the .wav a tape writes.
+      GAP = 2_000
+
+      # The file the tape reads from and writes back to, or "" for none.
+      attr_reader :path, :crossings
+
+      # The tape in the .wav file at `path`.
+      def self.read(path) = new(path, crossings: from_wav(File.binread(path).bytes))
+
+      # A blank tape at `path`, written to the host file.
+      def self.create(path)
+        tape = new(path)
+        tape.save
+        tape
+      end
+
+      # The zero crossings of the .wav file in `bytes`.
+      def self.from_wav(bytes)
+        raise FormatError, "Not a RIFF WAVE file" unless bytes[0, 4] == "RIFF".bytes && bytes[8, 4] == "WAVE".bytes
+
+        format = nil
+        pos = 12
+        while pos + 8 <= bytes.length
+          id = bytes[pos, 4].pack("C*")
+          size = little_endian(bytes, pos + 4, 4)
+          format = bytes[pos + 8, 16] if id == "fmt "
+          return Detector.new(Format.new(format)).crossings(bytes, pos + 8, size) if id == "data" && format
+
+          pos += 8 + size + (size & 1)
+        end
+        raise FormatError, "No PCM data in the WAVE file"
+      end
+
+      def self.little_endian(bytes, pos, count)
+        value = 0
+        count.times { |i| value |= bytes[pos + i].to_i << (8 * i) }
+        value
+      end
+
+      def initialize(path = "", crossings: [])
+        @path = path
+        @crossings = crossings
+      end
+
+      # The time of the last crossing.
+      def duration = @crossings.empty? ? 0 : @crossings.last
+
+      # Erases the tape from `time` on, as a deck recording from there
+      # does.
+      def erase_from(time)
+        @crossings.pop while !@crossings.empty? && @crossings.last >= time
+      end
+
+      # Records a crossing at `time`, after the last one.
+      def record(time)
+        @crossings << time
+      end
+
+      # The times PB7 changes as the tape plays, from high at its start: to
+      # low where a period is the 3,700 Hz tone and back to high where one
+      # is the 2,400 Hz tone. Each period runs over two crossings, and two
+      # in a row must agree before PB7 follows, so that one crossing out of
+      # place doesn't split a bit. The period that straddles the change
+      # lies between the tones, so PB7 changes half way through it.
+      def edges
+        crossings = @crossings
+        edges = []
+        high = true
+        disagree = 0
+        i = 2
+        while i < crossings.length
+          low_tone = crossings[i] - crossings[i - 2] > SPLIT
+          if low_tone == high
+            disagree = 0
+          else
+            disagree += 1
+            if disagree == 2
+              high = low_tone
+              edges << ((crossings[i - 3] + crossings[i - 2]) / 2)
+              disagree = 0
+            end
+          end
+          i += 1
+        end
+        edges
+      end
+
+      # Writes the tape back to its host file.
+      def save
+        write_wav(@path)
+      end
+
+      # Writes the tape to `path` as a .wav file, a square wave of `bits`
+      # (8 or 16) at `rate` samples a second.
+      def write_wav(path, rate: 44_100, bits: 8)
+        samples = square_wave(rate, bits == 8 ? 96 : 24_000)
+        bytes = bits == 8 ? samples.map { |sample| sample + 128 } : samples.flat_map { |s| [s & 0xff, (s >> 8) & 0xff] }
+        File.binwrite(path, (wav_header(rate, bits, bytes.length) + bytes).pack("C*"))
+      end
+
+      private
+
+      # The tape as samples of `amplitude`: silent up to the first
+      # crossing, after a GAP and at the end, and otherwise each crossing
+      # turning the wave over.
+      def square_wave(rate, amplitude)
+        samples = []
+        crossings = @crossings
+        count = crossings.empty? ? 0 : (((crossings.last + GAP) * rate) / 1_000_000) + 1
+        index = 0
+        level = -amplitude
+        count.times do |n|
+          time = (n * 1_000_000) / rate
+          while index < crossings.length && crossings[index] <= time
+            level = -level
+            index += 1
+          end
+          samples << (index.zero? || time - crossings[index - 1] > GAP ? 0 : level)
+        end
+        samples
+      end
+
+      def wav_header(rate, bits, size)
+        bytes_per_sample = bits / 8
+        "RIFF".bytes + le(36 + size, 4) + "WAVEfmt ".bytes + le(16, 4) + le(1, 2) + le(1, 2) +
+          le(rate, 4) + le(rate * bytes_per_sample, 4) + le(bytes_per_sample, 2) + le(bits, 2) +
+          "data".bytes + le(size, 4)
+      end
+
+      def le(value, count) = Array.new(count) { |i| (value >> (8 * i)) & 0xff }
+
+      # A WAVE file's fmt chunk: PCM, 8-bit unsigned or 16-bit signed.
+      class Format
+        attr_reader :channels, :rate, :bits
+
+        def initialize(chunk)
+          tag = KIMTape.little_endian(chunk, 0, 2)
+          @channels = KIMTape.little_endian(chunk, 2, 2)
+          @rate = KIMTape.little_endian(chunk, 4, 4)
+          @bits = KIMTape.little_endian(chunk, 14, 2)
+          return if [1, 0xfffe].include?(tag) && [8, 16].include?(@bits) && @channels.positive?
+
+          raise FormatError, "Only 8-bit and 16-bit PCM WAVE files are supported"
+        end
+
+        def frame_size = @channels * @bits / 8
+
+        # The first channel's sample at `pos`, from -1 to 1.
+        def level_at(bytes, pos)
+          return (bytes[pos] - 128) / 128.0 if @bits == 8
+
+          value = bytes[pos] | (bytes[pos + 1] << 8)
+          (value >= 0x8000 ? value - 0x10000 : value) / 32_768.0
+        end
+      end
+
+      # Finds where a recording crosses zero. A cassette's signal wanders
+      # off its centre and fades, so the detector follows its DC level and
+      # its envelope, and counts a crossing only once the signal swings past
+      # the DC level by HYSTERESIS of the envelope, timing it where it
+      # crossed the DC level, between two samples.
+      class Detector
+        def initialize(format)
+          @format = format
+          rate = format.rate
+          @dc_step = 1.0 / (rate * DC_TIME)
+          @decay = Math.exp(-1.0 / (rate * ENVELOPE_TIME))
+          @scale = 1_000_000.0 / rate
+          @dc = @envelope = @previous = @rose = @fell = 0.0
+          @high = false
+          @found = []
+        end
+
+        # The crossings, in microseconds, of the samples in `bytes` from
+        # `pos`, `size` bytes of them.
+        def crossings(bytes, pos, size)
+          format = @format
+          frame = format.frame_size
+          last = [pos + size, bytes.length].min - frame
+          n = 0
+          while pos <= last
+            follow(format.level_at(bytes, pos), n)
+            pos += frame
+            n += 1
+          end
+          @found
+        end
+
+        private
+
+        # Takes the sample `sample`, the `index`th.
+        def follow(sample, index)
+          @dc += (sample - @dc) * @dc_step
+          level = sample - @dc
+          @envelope *= @decay
+          @envelope = level.abs if level.abs > @envelope
+          previous = @previous
+          if previous <= 0 && level.positive?
+            @rose = index - 1 + (previous / (previous - level))
+          elsif previous >= 0 && level.negative?
+            @fell = index - 1 + (previous / (previous - level))
+          end
+          @previous = level
+          swing(level) if @envelope > SILENCE
+        end
+
+        # Turns over at a `level` far enough past the DC level.
+        def swing(level)
+          swing = @envelope * HYSTERESIS
+          if !@high && level > swing
+            @high = true
+            @found << (@rose * @scale).round
+          elsif @high && level < -swing
+            @high = false
+            @found << (@fell * @scale).round
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/storage/papertape.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    # A MOS papertape, the .ptp or .pap the KIM-1 monitor's Q command
+    # punches and its L command reads (User Manual, appendix F). Each
+    # record is a semicolon, then in hex its count of data bytes, its
+    # address, high byte first, the bytes and a 16-bit checksum, the sum
+    # of every byte before it, high byte first. The last record has a
+    # count of 0, the number of records before it where the address goes,
+    # and its checksum, which the monitor checks without counting the
+    # records. What comes between records, a line's end, NULs
+    # and the XOFF that ends a dump, the monitor skips, as this does.
+    class Papertape
+      class FormatError < StandardError; end
+
+      # One record's data: its bytes and where they go.
+      class Record
+        attr_reader :address, :bytes
+
+        def initialize(address, bytes)
+          @address = address
+          @bytes = bytes
+        end
+      end
+
+      HEX = "0123456789ABCDEFabcdef"
+
+      # The Records, in the tape's order.
+      attr_reader :records
+
+      # The tape's text from its start to the last record's end, which a
+      # teletype sends for the L command.
+      attr_reader :text
+
+      def self.read(path) = new(File.binread(path))
+
+      def initialize(text)
+        @records = []
+        @text = text.b
+        @position = 0
+        read_records
+      end
+
+      # Where the first record goes.
+      def start_address = @records.first.address
+
+      private
+
+      def read_records
+        loop do
+          start = @text.index(";", @position)
+          raise FormatError, "no last record" if start.nil?
+
+          @position = start + 1
+          count = byte
+          address = word
+          data = Array.new(count) { byte }
+          check(count, address, data)
+          return finish if count.zero?
+
+          @records << Record.new(address, data)
+        end
+      end
+
+      def check(count, address, data)
+        sum = (count + (address >> 8) + (address & 0xff) + data.sum) & 0xffff
+        raise FormatError, "bad checksum in the record at $#{address.to_s(16).rjust(4, '0')}" unless word == sum
+      end
+
+      def finish
+        raise FormatError, "no records" if @records.empty?
+
+        @text = @text[0, @position]
+      end
+
+      def byte
+        digits = @text[@position, 2].to_s
+        unless digits.size == 2 && HEX.include?(digits[0]) && HEX.include?(digits[1])
+          raise FormatError, "not a hex byte at offset #{@position}"
+        end
+
+        @position += 2
+        digits.to_i(16)
+      end
+
+      def word = (byte << 8) | byte
+    end
+  end
+end

data/lib/badline/storage.rb

@@ -5,13 +5,17 @@ require "badline/storage/p00"
 require "badline/storage/host_directory"
 require "badline/storage/disk_image"
 require "badline/storage/d64_image"
+require "badline/storage/d67_image"
 require "badline/storage/d71_image"
 require "badline/storage/d81_image"
 require "badline/storage/d80_image"
 require "badline/storage/d82_image"
+require "badline/storage/d90_image"
 require "badline/storage/g64_image"
 require "badline/storage/t64"
 require "badline/storage/tap"
+require "badline/storage/papertape"
+require "badline/storage/kim_tape"
 require "badline/storage/crt_file"
 require "badline/storage/unavailable"
 

data/lib/badline/support/kim1_checkpoint.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Badline
+  module Support
+    # A Checkpoint of a KIM-1: its CPU, the 1K of RAM, each 6530's RAM,
+    # ports and timer, the panel's held key and what its digits show, and
+    # what the teletype has printed and its line's level.
+    module KIM1Checkpoint
+      COMPONENTS = %w[cpu ram u2 u3 panel tty].freeze
+
+      def self.take(machine)
+        ram = machine.ram
+        Checkpoint.new(machine.cycles, [
+                         Checkpoint.fnv1a(Checkpoint.cpu_state(machine.cpu)),
+                         Checkpoint.fnv1a(Checkpoint.ram(ram, ram.length)),
+                         Checkpoint.fnv1a(rriot_state(machine.u2)),
+                         Checkpoint.fnv1a(rriot_state(machine.u3)),
+                         Checkpoint.fnv1a(panel_state(machine.panel)),
+                         Checkpoint.fnv1a(teletype_state(machine.teletype))
+                       ], COMPONENTS)
+      end
+
+      def self.parse(line) = Checkpoint.parse(line, COMPONENTS)
+
+      def self.rriot_state(rriot) = rriot.idle_state.map { |value| bit(value) } + [rriot.timer.counter]
+
+      def self.panel_state(panel)
+        held = panel.held
+        [held.nil? ? -1 : KIM1::Panel::KEYS.index(held), *panel.display]
+      end
+
+      def self.teletype_state(teletype) = teletype.output.bytes + [teletype.line_high? ? 1 : 0]
+
+      def self.bit(value)
+        return value if value.is_a?(Integer)
+
+        value ? 1 : 0
+      end
+    end
+  end
+end

data/lib/badline/support/superpet_checkpoint.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "pet_checkpoint"
+
+module Badline
+  module Support
+    # A Checkpoint of a SuperPET: the PET's components (PETCheckpoint), the
+    # board's latches and bank RAM, the 6702, the ACIA, the 6809 with
+    # whether it has the bus, and the traps on the Waterloo ROM's IEEE-488
+    # routines, empty without a disk on device 8.
+    module SuperPETCheckpoint
+      COMPONENTS = (PETCheckpoint::COMPONENTS + %w[board dongle acia m6809 waterloo]).freeze
+
+      def self.take(machine)
+        pet = PETCheckpoint.take(machine)
+        board = machine.board
+        dongle = machine.dongle
+        acia = machine.acia
+        Checkpoint.new(machine.cycles, pet.digests + [
+          Checkpoint.fnv1a([board.bank_latch, board.system_latch, board.socket, *board.cells]),
+          Checkpoint.fnv1a(dongle.registers + [dongle.latch, dongle.shift_at]),
+          Checkpoint.fnv1a([acia.command, acia.control, acia.status, acia.due]),
+          Checkpoint.fnv1a(m6809_state(machine.m6809) + [machine.m6809_running? ? 1 : 0]),
+          Checkpoint.fnv1a(machine.waterloo_traps&.state || [])
+        ], COMPONENTS)
+      end
+
+      def self.m6809_state(cpu)
+        [cpu.a, cpu.b, cpu.x, cpu.y, cpu.u, cpu.s, cpu.pc, cpu.dp, cpu.cc, cpu.cycles]
+      end
+
+      def self.parse(line) = Checkpoint.parse(line, COMPONENTS)
+    end
+  end
+end

data/lib/badline/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Badline
-  VERSION = "0.17.0"
+  VERSION = "0.19.0"
 end

data/lib/badline/vic20/keyed_modules.rb

@@ -28,7 +28,7 @@ module Badline
       end
 
       # Raises Snapshot::FormatError for the modules of a VIC-20 with
-      # another RAM expansion.
+      # another RAM expansion or of another model.
       def load_modules(modules)
         machine = modules.machine
         check_snapshot_setup(Snapshot::Vic20Setup.read_fields(machine))
@@ -62,9 +62,12 @@ module Badline
       end
 
       def check_snapshot_setup(setup)
-        return if setup.ram == @ram_configuration
+        unless setup.ram == @ram_configuration
+          raise Snapshot::FormatError, "the snapshot is of a VIC-20 with #{setup.ram} RAM, not #{@ram_configuration}"
+        end
+        return if setup.model == @model
 
-        raise Snapshot::FormatError, "the snapshot is of a VIC-20 with #{setup.ram} RAM, not #{@ram_configuration}"
+        raise Snapshot::FormatError, "the snapshot is of a #{setup.model.upcase} VIC-20, not a #{@model.upcase} one"
       end
     end
 

data/lib/badline/vic20/keyed_state.rb

@@ -3,9 +3,9 @@
 module Badline
   class Vic20
     # The machine's own fields in a keyed snapshot module (Snapshot::Keyed,
-    # BL-MACHINE): the family, its RAM expansion by name, the cycle count,
-    # the RESTORE key's NMI, and the host's typing still to feed and on_init
-    # handlers still to run under host.*.
+    # BL-MACHINE): the family, its RAM expansion and model by name, the
+    # cycle count, the RESTORE key's NMI, and the host's typing still to
+    # feed and on_init handlers still to run under host.*.
     module KeyedState
       # How many more on_init handlers the machine a snapshot was taken of had
       # yet to run than this one has. Nil until the machine is restored.
@@ -20,10 +20,11 @@ module Badline
 
       def save_machine_fields(out)
         out.text("family", "vic20").text("written_by", VERSION)
-        Snapshot::Vic20Setup.new(ram: @ram_configuration).write_fields(out)
+        Snapshot::Vic20Setup.new(ram: @ram_configuration, model: @model).write_fields(out)
         out.int("cycles", @cycles).bool("nmi_asserted", @nmi_asserted)
         pending = @pending_keys
         out.ints("host.pending_keys", pending) if pending
+        save_init_keys(out)
         out.int("host.init_pending", @cycles <= @init_threshold ? @init_handlers.length : 0)
       end
 
@@ -32,6 +33,7 @@ module Badline
         @nmi_asserted = input.bool("nmi_asserted", @nmi_asserted)
         pending = input.ints("host.pending_keys", [])
         @pending_keys = pending.empty? ? nil : pending.dup
+        load_init_keys(input)
         @init_handlers_lost = [input.int("host.init_pending", 0) - @init_handlers.length, 0].max
       end