badline 0.12.1 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8872c5d5117a691aa38d054acd5dd7e84f7abf737c977a2dc309c6dc3072381d
-  data.tar.gz: fa4f4e5b3729989c78443f73bd655c2083555d62a8d3ee45437d147bfe0e5fb8
+  metadata.gz: 320b4659e6c9945509741f928989b2378d38ae18a51c1dd5bbca706e3b3ada54
+  data.tar.gz: 9a6ce80ab26e74e325c8fb660f4ed1fabc64a6e3c1859b723b3816aebe3f4b55
 SHA512:
-  metadata.gz: d278ba0e0341242af3e1782a8c003bc4cbdb1594be434021b5bbccae126ddf12dd89ffa0520dd615075a77f89b1285595d2101868db0e6679b69130586ed210c
-  data.tar.gz: 5dabb1d53a29dc43b619f90abd67495ab3847d3ba8d8f89275d45f276aac4fbe3ca37a4963f048e300e88cd50228b35bd39da7efbd431f46527b893b1c4bd95c
+  metadata.gz: 0f4e3b6c6bc7c35eec18ea3a81165050183e92eeebab3c04b12472970b5b0a87d8ad860ceac81e411a39836c601239b3e708bcffbcb7f4eb6561599c1cda1522
+  data.tar.gz: 61d6698127237a45d99febd816088da06d227519b34455188babc7dafebb977613a61c1472ed348c691433a8c02f4dcbab0346f48083b71fc02035f64f7c8549

data/CHANGELOG.md

@@ -1,5 +1,71 @@
 # Changelog
 
+## [0.14.0](https://github.com/elektronaut/badline/compare/v0.13.0...v0.14.0) (2026-10-11)
+
+
+### Features
+
+* add the keyed snapshot record encoding ([1b87aed](https://github.com/elektronaut/badline/commit/1b87aeddea27f81cb1ccedbbef2bba58c2db0bb3))
+* boot the Plus/4 and the C16 to READY headless ([278020e](https://github.com/elektronaut/badline/commit/278020ee0256fa1d085391fd0e7a6679ac80dbcb))
+* bundle the 264 series ROMs and refuse badline plus4 until it runs ([7072ae7](https://github.com/elektronaut/badline/commit/7072ae7cb6e1ccd96a4e02eb1146b7b1bfaf7125))
+* give each machine its keyboard buffer layout ([0b64648](https://github.com/elektronaut/badline/commit/0b64648fec3cd56bbbee1ac4dc8fe446c84dd4b9))
+* keep the KERNAL's file variables in KernalTrap::Layout ([0ca7488](https://github.com/elektronaut/badline/commit/0ca7488505b2b7af9f358bdf6d3e86a1e1c768e3))
+* keyed snapshot fields for device 8 through the KERNAL traps ([cce36f2](https://github.com/elektronaut/badline/commit/cce36f2f740c5337cd2b0a66fe99394114409c32))
+* keyed snapshot fields for each machine's own state and setup ([ff251a6](https://github.com/elektronaut/badline/commit/ff251a62cbad4502f576628a4f4c5d3d6a22eaf8))
+* keyed snapshot fields for the 1541 ([f3f57b7](https://github.com/elektronaut/badline/commit/f3f57b7e24471e198304bfd90ba16c4abb7c4c16))
+* keyed snapshot fields for the 1571 ([5ceb741](https://github.com/elektronaut/badline/commit/5ceb7416a1902252d97c80aff22658a68e4abfb6))
+* keyed snapshot fields for the 1581 ([1c67e29](https://github.com/elektronaut/badline/commit/1c67e298c24e82e92cc5feddcc0153143d4eda8d))
+* keyed snapshot fields for the 6502 cores and the Z80 ([8ee592e](https://github.com/elektronaut/badline/commit/8ee592e5ee5b658c8f452cf4bdf9df044f8c19ab))
+* keyed snapshot fields for the C128's MMU ([aa861ca](https://github.com/elektronaut/badline/commit/aa861cac0a33d79f777b60310f0cb573024f2d60))
+* keyed snapshot fields for the cartridges ([349ae81](https://github.com/elektronaut/badline/commit/349ae81c7c002f5c1b94fa50cc994a6b7ec16915))
+* keyed snapshot fields for the CIA ([b5a6ff8](https://github.com/elektronaut/badline/commit/b5a6ff8b02026daa3ec6247ab4024d35efedb18e))
+* keyed snapshot fields for the datasette and its tape ([37a52f1](https://github.com/elektronaut/badline/commit/37a52f1018ab226a60395e1c98c6a362c0159f01))
+* keyed snapshot fields for the memories, RAM expansions and buses ([14b1a95](https://github.com/elektronaut/badline/commit/14b1a951a44c2bc23871208b9843489d4ca6963c))
+* keyed snapshot fields for the REU ([8088ac5](https://github.com/elektronaut/badline/commit/8088ac52c68667db7d6acdc6e0f0b629e165b0b3))
+* keyed snapshot fields for the SID ([b58f88d](https://github.com/elektronaut/badline/commit/b58f88d1a98346aba4dbec0dead306b3d36b32f7))
+* keyed snapshot fields for the VDC ([b894c3e](https://github.com/elektronaut/badline/commit/b894c3ef0b83988d17f03027b1831e7be3739be3))
+* keyed snapshot fields for the VIA ([52ab12c](https://github.com/elektronaut/badline/commit/52ab12cb129adedc8a3f0b7df469a1440eb72309))
+* keyed snapshot fields for the VIC-I and its sound ([a47d3e8](https://github.com/elektronaut/badline/commit/a47d3e823891e5d597141423f1675962ac266df7))
+* keyed snapshot fields for the VIC-II ([8fc8b4c](https://github.com/elektronaut/badline/commit/8fc8b4c39f8ae5cac781f51f0bbeab5134c3bc9f))
+* latch the VIC's sprite collisions when a snapshot settles ([a1c9429](https://github.com/elektronaut/badline/commit/a1c9429fefdbbc57407fb68baf057209d7163db1))
+* let a unit report its own adjustments when its snapshot loads ([3b3af19](https://github.com/elektronaut/badline/commit/3b3af19ef0d74b0a45fbea96feef107f26db12a6))
+* read Plus/4 CRT images ([450148d](https://github.com/elektronaut/badline/commit/450148db02c8057cc071f6d867707aa45a87c996))
+* read version 2 C16 tapes and time the datasette's read level ([7e78070](https://github.com/elektronaut/badline/commit/7e78070877394a4657e23699a3098f297469be05))
+* report a VIC-II line restarted from another renderer's snapshot ([6cb0607](https://github.com/elektronaut/badline/commit/6cb06075d410e59a8cd6f7d82d29757819e23e67))
+* run the 264 testbench's exitcode rows as testbench-plus4 and testbench-c16 ([862f14b](https://github.com/elektronaut/badline/commit/862f14bd474bdac92017f25a57a057cf1f42a63f))
+* run the Lorenz suite's plus4 build as lorenz-plus4 ([006efdd](https://github.com/elektronaut/badline/commit/006efddeb3a052714b99ff9b11ec18dd85cb6778))
+* save and load snapshots as BL-* modules ([25db1be](https://github.com/elektronaut/badline/commit/25db1be28817d292c314672c5401251d36d11902))
+* save snapshots at the next instruction boundary ([3f9ae3c](https://github.com/elektronaut/badline/commit/3f9ae3cf5392c194a1915801c9da4739832649e3))
+
+
+### Bug Fixes
+
+* boot C128 boot sectors on .g64 and .g71 images ([81ad184](https://github.com/elektronaut/badline/commit/81ad1842fdc66b5ddb5d2988eb699409741f376a))
+* draw the true drive's power LED, and the LEDs of a drive plugged in after start ([982c522](https://github.com/elektronaut/badline/commit/982c522c56c46d193ca5d15f49c59f221f04ad8e))
+* drive the datasette's write line from the CPU port's bit 3 ([b90c29d](https://github.com/elektronaut/badline/commit/b90c29dd758eb7867930c5f26dbd0ae510f430af))
+* let a held key go as the key it pressed across a C128 mode switch ([3a8d731](https://github.com/elektronaut/badline/commit/3a8d7313034f0b69057528b58ff247250b7e7168))
+* read the ROMs and I/O a C128 KERNAL bank maps when saving ([3e4db21](https://github.com/elektronaut/badline/commit/3e4db218959237fada950e4b65238203af10e3c6))
+* run the VIC-20's sound voices whether or not the host plays them ([13052c7](https://github.com/elektronaut/badline/commit/13052c7bbb9ca2b4ed678935ec6b88cc84bb2806))
+* take the C128's own keys in --at key= ([428047c](https://github.com/elektronaut/badline/commit/428047cc4eca55b70967048d49579840b90ea946))
+* type --at type= text on the C128's key matrix while the Z80 runs ([39d77ff](https://github.com/elektronaut/badline/commit/39d77ff29989a46c82184cd2dde03e8d470c553b))
+
+## [0.13.0](https://github.com/elektronaut/badline/compare/v0.12.1...v0.13.0) (2026-10-11)
+
+
+### Features
+
+* read and write memory through the machine ([0a71be9](https://github.com/elektronaut/badline/commit/0a71be914fda736bdc10c320b86cf9e0bf91b05b))
+
+
+### Bug Fixes
+
+* take dead keys such as ´ on a Mac as key presses ([44bc087](https://github.com/elektronaut/badline/commit/44bc087a0def79a3d1f8837d7e479297aca7094f))
+
+
+### Performance Improvements
+
+* type the values a snapshot restores ([71e6e62](https://github.com/elektronaut/badline/commit/71e6e6229880d413adf2071a69263f7930536157))
+
 ## [0.12.1](https://github.com/elektronaut/badline/compare/v0.12.0...v0.12.1) (2026-10-10)
 
 
@@ -64,7 +130,6 @@
 * bundle the PET 64's KERNAL, 901246-01 ([9a029ec](https://github.com/elektronaut/badline/commit/9a029ecfe25c0d9a806d8858253c4c172e175b7f))
 
 
-### Miscellaneous Chores
 
 * release 0.10.1 ([9d6f6ba](https://github.com/elektronaut/badline/commit/9d6f6ba71a647f24f00a830fbc772531fbcb4d92))
 

data/CLAUDE.md

@@ -6,42 +6,61 @@ This file covers how to work on the code.
 
 ## Orientation
 
-`lib/badline/` holds one file per chip or subsystem, and namespaced groups
-live in subdirectories:
-
-- **Machine**: `computer.rb` clocks everything once per cycle (`cycle!`:
-  VIC, both CIAs, SID and the datasette, then the CPU unless the VIC holds
-  BA low). `address_bus.rb` handles banking and page-table dispatch
-- **CPU**: `cpu.rb`, `instruction.rb` and `instruction_set/`, plus
-  `interrupts.rb`
-- **VIC-II**: `vic.rb` and `vic/`, covering the sequencer, sprites, graphics
-  modes, border and register timing
-- **CIA**: `cia.rb` and `cia/` (timers, serial), plus `time_of_day.rb`
-- **REU**: `reu.rb` and `reu/`, the RAM Expansion Unit's registers and
-  its DMA, which `Computer#cycle!` clocks in place of the CPU while it
-  holds the bus
-- **SID**: `sid.rb` and `sid/`. `audio/` plays and renders tunes for
-  `badline-ruby --headless` and `--audio-out`
+`lib/badline/` is grouped by namespace, and a constant's path follows its
+directory: `chips/vic.rb` is `Badline::Chips::VIC`.
+
+- **Machine**: `c64.rb` (`Badline::C64`) clocks everything once per cycle
+  (`cycle!`: VIC, both CIAs, SID and the datasette, then the CPU unless
+  the VIC holds BA low). `c64/` holds the rest of the C64's board:
+  `c64/bus.rb` handles banking and page-table dispatch, and
+  `c64/banked_ram.rb` and `c64/banked_ram/` the +60K and +256K boards
+  that bank in extra RAM through `$D100`. `vic20.rb` and `vic20/`, and
+  `c128.rb` and `c128/`, are the other two families, and `machine.rb`
+  builds each by name. Every family reads and writes memory as its CPU
+  sees it with `peek` and `poke`
+- **CPU**: `chips/cpu.rb` and `chips/cpu/`: the 6502 core
+  (`Chips::CPU::Core`, which each family's and each drive's CPU
+  includes), `instruction.rb` and `instruction_set/`, `interrupts.rb`,
+  `traps.rb` and the 6510's I/O port, `port.rb`. `chips/z80.rb` is the
+  C128's Z80
+- **VIC-II**: `chips/vic.rb` and `chips/vic/`, covering the sequencer,
+  sprites, graphics modes, border and register timing. `chips/vic_i.rb`
+  is the VIC-20's VIC-I and its sound, and `chips/vdc.rb` the C128's VDC
+- **CIA**: `chips/cia.rb` and `chips/cia/` (timers, serial and the TOD
+  clock, `time_of_day.rb`). `chips/via.rb` is the 6522 of the VIC-20 and
+  the drives
+- **REU**: `c64/reu.rb` and `c64/reu/`, the RAM Expansion Unit's
+  registers and its DMA, which `C64#cycle!` clocks in place of the CPU
+  while it holds the bus
+- **SID**: `chips/sid.rb` and `chips/sid/`. `audio/` plays and renders
+  tunes for `badline-ruby --headless` and `--audio-out`, and `sid_tune/`
+  reads `.sid` files, the HVSC's song lengths and its STIL
 - **Media and host I/O**: `storage/` (disk, tape and cartridge image
-  formats), `cartridge/` (mappers), `kernal_trap/` (the LOAD/SAVE and IEC
-  traps that stand in for a drive), `media.rb` (attach and autostart),
-  `datasette.rb`, and `input/` (the mouse and paddles)
+  formats), `c64/cartridge/` (mappers), `kernal_trap/` (the LOAD/SAVE
+  and IEC traps, and `kernal_trap/dos/`, the virtual DOS that stands in
+  for a drive), `media.rb` (attach and autostart), `drives/` (the true
+  1541, 1571 and 1581, the engine they share, the serial bus and the
+  datasette), and `input/` (the keyboard, joysticks, control ports,
+  mouse and paddles)
 - **Front end**: `frontend/`, the SDL window both builds run (app loop,
   screen, pacer, sound, controls, gamepads, snapshots), in Spinel's
   subset, over the one binding in `sdl.rb` (`ffi.rb` implements it on
   CRuby)
 - **Native**: `native/` holds the native `badline`, the core and the
   front end compiled with Spinel (`rake native:build`, `native/README.md`).
-  `spinel/` holds the Spinel test harnesses
+  `spinel/` holds the Spinel test harnesses, and `support/` the
+  checkpoints they and `bin/machine_diff` digest a machine with, which
+  stay out of the core
 
-Timing-critical code lives in `cpu`, `interrupts`, `vic`, `cia` and `sid` and
-in the order `Computer#cycle!` clocks them. Changes there move the test
+Timing-critical code lives in `chips/` (`cpu`, `vic`, `cia` and `sid`) and
+in the order `C64#cycle!` clocks them. Changes there move the test
 suites below. `frontend/` changes move none of them.
 
 Namespaced groups live in `lib/badline/<namespace>/`, with a sibling
 `lib/badline/<namespace>.rb` that requires the members, directly or through
 other members. `lib/badline.rb`
-requires only the namespace file.
+requires only the namespace file. `chips/` and `drives/` have no sibling
+file: `core.rb` requires their members one by one.
 
 ### Oracles
 
@@ -54,7 +73,7 @@ requires only the namespace file.
 | VICE testbench | `bin/testbench <subtree>` | `VICII/`, `CIA/`, `interrupts/`, `CPU/`, cartridges with `--carts`, the true 1541 drive with `--drive`, the VIC-20 with `--vic20`, the C128 in C64 mode with `--c128c64`, in C128 mode with `--c128`, and its Z80 with `--c128-z80` |
 | VICE SID testprogs | `bin/sidtests` | SID |
 | Drive scenarios | `bin/drive_scenarios` | The true 1541 running the DOS ROM: save, format, the error channel, idle, write protect and autostart |
-| CIA offline grids | `bundle exec rspec --tag slow spec/badline/cia` | CIA timers and shift register, against a bare CIA in about 2 min |
+| CIA offline grids | `bundle exec rspec --tag slow spec/badline/chips/cia` | CIA timers and shift register, against a bare CIA in about 2 min |
 
 The CIA offline grids replay Lorenz's `cia1ta` and `cia1tb` sweeps (about
 8 s) and the `cia-sdr-icr` loop for every timer A latch (about 2 min),
@@ -67,21 +86,30 @@ documents the baseline format, the suites and how rows are compared.
 
 `bin/machine_diff <scenario|media> --against <rev>` checks that a change
 leaves emulation alone. It runs the scenario on this tree and on `<rev>`'s
-`lib/` side by side, digests the CPU, RAM, VIC, CIAs and SID every million
-cycles, and names the first component that differs. Use it for refactors
-and speed work.
+`lib/` side by side, digests each chip every million cycles (the CPU, RAM,
+VIC, CIAs and SID, the VIC-20's VIAs and sound, the C128's VDC, MMU and
+Z80), and names the first component that differs. It builds a C64 unless
+`--family vic20` or `--family c128` (with `--mode c64|c128`) says
+otherwise. Use it for refactors and speed work.
+
+`bin/snapshot_check` checks snapshots. For each scenario (`--list`) it saves
+twice, then saves, loads and saves again, and expects the same bytes each
+time. It then runs the saved and the loaded machine side by side and names
+the first difference. `--carts` does the same for every cartridge mapper,
+and `--diff A B` compares two snapshot files module by module. Run it on any
+change to a unit's saved state.
 
 ## Driving the emulator headlessly
 
 `exe/badline-ruby <media>` opens the SDL window, which is no use for checking
-work. Drive a `Badline::Computer` from Ruby instead, as the `bin/` runners do:
+work. Drive a `Badline::C64` from Ruby instead, as the `bin/` runners do:
 
 ```ruby
-computer = Badline::Computer.new
+computer = Badline::C64.new
 Badline::Media.attach(computer, path)  # PRG, disk, tape, CRT or directory; autostarts
 computer.on_init { computer.type_text("print 6*7\r") }  # after boot (~2.5M cycles)
 3_500_000.times { computer.cycle! }
-computer.address_bus.peek(0x0400)      # screen RAM starts at $0400
+computer.peek(0x0400)                  # screen RAM starts at $0400
 ```
 
 - `computer.capture_output` traps CHROUT and records what the machine prints
@@ -132,7 +160,7 @@ worktree and owns a different set of files.
 
 - `rake vendor:checkout` fetches SingleStepTests 65x02, the Z80 sample
   and VICE-testprogs into `vendor/`
-- `bundle exec rspec`: line coverage is about 97%. `spec/spec_helper.rb`
+- `bundle exec rspec`: line coverage is about 95%. `spec/spec_helper.rb`
   fails a whole-suite run (every spec file, no filters) below 90%, while
   single-file and filtered runs skip the floor. `:slow` specs are excluded
   by default: run them with `bundle exec rspec --tag slow`
@@ -179,12 +207,25 @@ the rows your change can't reach tell you nothing about it.
   `ruby --yjit bin/lorenz [image] [start_test] [max_cycles]` (resumes the
   chain at a named test, and `--stop-after NAME` ends it once that test is
   done). These take seconds to minutes
-- A pull request's CI is the verdict. It runs every suite on the Spinel
-  build, compared row by row against
-  `test/baselines/`, and every job is a required check. A row that moved
-  fails it. A pull request that changes only docs, or only a release's
-  version bump, skips the specs and suites; pushes to main always run
-  them. Re-record only those rows, in the same change:
+- A pull request's CI is the verdict, and a pull request merges on it
+  alone. It runs the specs, Rubocop, Minitest, the harness builds, the
+  Spinel checks, the native round trip, and the suites its changed files
+  can reach, on the Spinel build, compared row by row against
+  `test/baselines/`. `test/support/ci_reach.rb` maps paths to suites, and
+  a path it doesn't name runs every suite. A row that moved fails it. A
+  pull request that changes only docs, or only a release's version bump,
+  skips the specs and suites. A row that moves in a pull request's CI is
+  re-recorded in that pull request with its reason; nobody waits for
+  `suites.yml` to confirm it. A change that reaches a suite the map
+  doesn't name adds the path to `test/support/ci_reach.rb` in the same
+  pull request, and a change that adds a directory under `lib/badline/`
+  gives it a rule
+- The full suites run on main every two hours (`.github/workflows/suites.yml`).
+  Nobody waits for it, polls it or dispatches it to check a pull request.
+  Its result is a `suites` commit status and, when red, one `suites-red`
+  issue the planner owns. A red main never blocks a merge. A release
+  publishes only once its tagged commit is green
+- Re-record only the rows that moved, in the same change:
   `rake "regression:record:<suite>[filter,...]"` (quote it, because zsh
   globs the brackets). It runs only the matching tests on CRuby and
   splices their rows into the baseline, and every other row keeps its
@@ -196,7 +237,7 @@ the rows your change can't reach tell you nothing about it.
   `(suite)` row too. Explain every moved row in the pull request. Never
   re-record just to make a diff go away
 - For a change whose reach you can't bound to a set of filters, such as
-  reordering `Computer#cycle!` or changing the LOAD trap every suite loads
+  reordering `C64#cycle!` or changing the LOAD trap every suite loads
   through, push and let CI run the suites
 - The Regression workflow runs the suites on CRuby, started by hand from
   the Actions tab, for a person checking that CRuby and Spinel agree.
@@ -248,6 +289,13 @@ you change code a pinned rule governs, re-derive the rule against its test
 and update the doc if the rule moves. A green suite alone isn't enough,
 because the suite can stay green while the rule breaks.
 
+## Rubocop
+
+The Metrics limits in `.rubocop.yml` are house limits, set with headroom
+above the largest class, module and method in the tree. A change that needs
+more should raise the limit in the same pull request and say why, rather
+than split a class or shorten an unrelated method to fit.
+
 ## Issues and pull requests
 
 Before filing an issue or opening a pull request, read CONTRIBUTING.md and follow it. Use the exact headings from its skeletons. Report only what you observed or verified, and don't include hypotheses about causes. Open an issue before writing non-trivial code; only changes with one obvious fix (typos, broken links, clear-cut fixes) go straight to a pull request.

data/CONTRIBUTING.md

@@ -91,9 +91,10 @@ bundle exec rubocop
 ## Tests and commits
 
 - Add tests for any behavior you change.
-- CI runs rubocop, the specs and every regression suite on each pull
-  request, and fails on any suite row that differs from its baseline in
-  `test/baselines/`. When a change moves rows on purpose, re-record just
+- CI runs rubocop, the specs and the regression suites a pull request's
+  changes can reach on each pull request, and fails on any suite row that
+  differs from its baseline in `test/baselines/`. Every suite runs on
+  `main` every two hours. When a change moves rows on purpose, re-record just
   those rows as [test/baselines/README.md](test/baselines/README.md)
   describes, and say why in the pull request.
 - Write commit messages using

data/README.md

@@ -22,7 +22,7 @@ It comes in two builds of the same emulator:
   sound, so it's the one to play games with.
 - **`badline-ruby`**, which comes with the Ruby gem and runs on CRuby. It
   runs slower than a real C64, so its sound is off by default. The gem is
-  also a library, which runs a `Badline::Computer` from Ruby without a
+  also a library, which runs a `Badline::C64` from Ruby without a
   window.
 
 ## Installation
@@ -107,6 +107,7 @@ differences noted in the table. `--help` lists the options for either.
 | `--script FILE` | Run the events in `FILE`, one `FRAME:EVENT` a line |
 | `--screenshot FILE` | Save the last frame as a `.bmp` |
 | `--save-snapshot FILE` | Save the machine as a `.vsf` snapshot after the last frame |
+| `--vice` | Add VICE's modules to `--save-snapshot`'s C64 snapshot, so x64sc opens it too |
 
 ```sh
 badline --unpaced --frames 12000 --true-drive disk1.d64 \
@@ -139,7 +140,8 @@ Without `--true-drive`, device 8 is no drive at all but traps on the
 KERNAL's disk routines. Loading is instant, but fast loaders and copy
 protection that run code on the drive need `--true-drive`, which puts
 an emulated 1541 there, running its own DOS at a real 1541's speed. Its
-red LED lights in the bottom right corner of the border. With
+red activity LED and green power LED light in the bottom right corner
+of the border. With
 `--true-drive`, a `.d81` goes in an emulated 1581 in place of the 1541.
 [doc/media.md](doc/media.md) has the details, and how to attach media
 from Ruby.
@@ -225,10 +227,11 @@ snapshots, and x128's `.vsf` files don't load.
 badline's data folder, replacing the oldest, and `F12` restores the
 newest, even after badline has quit and started again. badline also
 autosaves every two minutes of play, and the pause menu's Snapshots page
-saves under a name and loads any of them. Snapshots use
-VICE's `.vsf` format: badline opens those x64sc saves, and x64sc opens
-badline's. See [doc/snapshots.md](doc/snapshots.md) for where they're
-kept, what they hold and how far the two agree.
+saves under a name and loads any of them. Snapshots from badline 0.14.0
+on load in every later version. They use VICE's `.vsf` format: badline
+opens those x64sc saves, and x64sc opens badline's saved with `--vice`.
+See [doc/snapshots.md](doc/snapshots.md) for where they're kept, what
+they hold and how far the two agree.
 
 ## Playing and rendering SID tunes
 

data/doc/library.md

@@ -1,16 +1,16 @@
 # Using badline from Ruby
 
-The gem is also a library, which runs a `Badline::Computer` from Ruby
+The gem is also a library, which runs a `Badline::C64` from Ruby
 without a window.
 
 ```ruby
 require "badline"
 
-computer = Badline::Computer.new
+computer = Badline::C64.new
 Badline::Media.attach(computer, "game.d64")         # attaches and autostarts
 computer.on_init { computer.type_text("print 6*7\r") } # once the machine has booted
 3_500_000.times { computer.cycle! }
-computer.address_bus.peek(0x0400)                   # screen RAM starts at $0400
+computer.peek(0x0400)                               # screen RAM starts at $0400
 ```
 
 [media.md](media.md) covers attaching and swapping media, and
@@ -18,7 +18,7 @@ computer.address_bus.peek(0x0400)                   # screen RAM starts at $0400
 
 ## Building a machine
 
-`Badline::Computer.new` builds the default machine: a PAL C64 with the
+`Badline::C64.new` builds the default machine: a PAL C64 with the
 6569 VIC-II, 6526 CIAs and a 6581 SID. Its keywords build others, and
 `Badline::Model.named("c64c")` gives the ones `--model` names for each
 model (`Badline::Model::ALL`):
@@ -41,11 +41,11 @@ model (`Badline::Model::ALL`):
 - `reu: 512` plugs in a RAM Expansion Unit of that many K.
 - `kernal: :sx64` fits the SX-64's KERNAL, and `datasette: false`
   leaves the cassette port empty, so inserting a tape raises
-  `Badline::Datasette::Missing`. The SX-64 has both.
+  `Badline::Drives::Datasette::Missing`. The SX-64 has both.
 - `kernal: :pet64` fits the PET 64's KERNAL, and `board: :pet64` its
   green monochrome monitor: the VIC's `palette` is
-  `Badline::VIC::GREEN_PALETTE`, each colour's luminance in green. The
-  PET 64 has both.
+  `Badline::Chips::VIC::GREEN_PALETTE`, each colour's luminance in
+  green. The PET 64 has both.
 - `kernal: :gs` fits the C64GS's BASIC and KERNAL, and `board: :gs` its
   case, which has no keyboard: `computer.keyboard` takes no keys. The
   C64GS has both, and no datasette.
@@ -68,7 +68,7 @@ Am29F040 EAPI on attach, as VICE does. Flash writes stay in memory and
 are lost when the emulator quits: the `.crt` file is never overwritten.
 
 A GEO-RAM takes the expansion port, so it can't sit alongside a
-cartridge: `computer.attach_cartridge(Badline::Cartridge::GeoRAM.new(size: 512))`.
+cartridge: `computer.attach_cartridge(Badline::C64::Cartridge::GeoRAM.new(size: 512))`.
 Its contents are lost when the emulator quits.
 
 ## ROMs
@@ -79,5 +79,5 @@ directory that holds `kernal.rom`, `basic.rom` and `character.rom`, plus
 `kernal-sx64.rom` for the SX-64, `kernal-pet64.rom` for the PET 64,
 `c64gs.rom` for the C64GS and `eapi/eapi-am29f040-14` if you
 attach EasyFlash cartridges.
-`Badline.rom_path = dir` does the same before a `Badline::Computer` is
+`Badline.rom_path = dir` does the same before a `Badline::C64` is
 built, and `nil` restores the bundled set.

data/doc/media.md

@@ -31,7 +31,8 @@ own DOS ROM on its own 6502 and talking to the machine over the serial
 bus. It reads `.d64` and `.g64` images, which it autostarts with the
 same `LOAD"*",8,1` and `RUN`, but not `.d71`, `.d81` or `.t64` images
 or directories. Loading runs at the speed of a real 1541, and the
-drive's red LED lights in the bottom right corner of the border.
+drive's red activity LED and green power LED light in the bottom right
+corner of the border. A 1581 flashes its power LED after an error.
 
 A `.g64` holds the disk's raw GCR, half tracks and all, so copy
 protection and fast loaders that read it work.