# Changelog

## Unreleased

- Initialize the self-modifying program/control stack before the first BIOS call,
  removing firmware-stack dependence. Keep the one-bit experiment at 82 bytes,
  offsets 52/61 and 40 model steps; audit seven boot/control setup headers with
  interrupts masked while establishing SS:SP, without forbidding later STI.

- Add a 142-byte native VGA bitmap with 64 authored pixel-index bytes and a
  separate one-bit palette control. Verify all 64,000 framebuffer bytes and every
  captured RGB pixel, unchanged source/code/disk and explicit browser graphics
  rejection. Genuine two-boot captures include exact decoded-GIF pixel proof;
  current reviewed targets/artifacts grow to 57/90, without changing releases.

- Add print-only lesson layouts for the manual, learning path and eight
  introductions, preserving literal code, Arabic direction and source URLs.
  Verify light page margins and capture actual A4 PDFs for visual QA.

- Document verified fresh-checkout reproduction with exact source/environment,
  all 88 reviewed artifact hashes across two builds, clean generated copies and
  explicit macOS/Linux/browser validation boundaries.

- Identify invalid Before/After bit-comparison drafts independently and select
  the first offending token on failed notation conversion. Preserve both drafts,
  notation and the last valid comparison; clear each corrected error marker.

- Add exact UTF-16 token ranges to browser source diagnostics without changing
  grammar or readable messages. Focus/select the invalid or excess token on CPU
  Lab load failures, preserve inline caret and loaded state, normalize imported
  textarea newlines before validation, and clear stale corrected-error state.

- Make instruction-bit editors a single Tab stop with bit/byte arrows, row/global
  Home/End and native Enter/Space toggles. Retain focus on re-rendered invalid
  encodings, preserve selector focus when shortening fixtures, and connect visible
  keyboard help to the accessible group. Browser navigation does not execute code.

- Inspect all unprefixed short Jcc fields in 16/32/64 contexts with shared
  condition predicates, selector/inversion roles and signed rel8 bit labels.
  Add canonical complementary fixtures, 12,288 encoding cases and six independent
  disassembly goldens. Browser bit edits preserve runtime state; execution and
  unsupported prefix/near scope are unchanged.

- Add an 80-byte native self-modifying program: one writer bit changes one future
  MOV operand bit, turning A into a on COM1 and VGA. A separate literal control,
  full model/native state checks, live code RAM and unchanged disk/source proof
  accompany actual two-boot native captures. Extend the gallery, CPU Lab source
  downloads and read-only bit-diff preset. Current reviewed artifacts grow to 88;
  existing release assets remain untouched.

- Move the remaining five CPU Lab programs from inline JS into annotated canonical
  `.bits` files without changing their bytes. Generate all six preset texts with
  source paths, validate build limits/file boundaries, and expose source downloads
  matched to loaded bytes. Preserve editor/reference identity and the memory export.

- Execute unprefixed immediate ADC/SBB on AL and AX with incoming CF, exact
  outgoing carry/borrow and arithmetic status flags. Preserve AH/IF/DF, check
  270,736 independent ripple cases, and add the same 81-byte native/model/browser
  multiword exercise plus eight independently verified native FLAGS samples.

- Complete the model's sixteen unprefixed short Jcc conditions with JL/JGE/JLE/JG
  and JA/JBE. Explain signed overflow versus unsigned carry, verify 131,072 flag/
  rel8 combinations and 3,384 operand comparisons, and add a literal 95-byte
  native/model/browser exercise with exact history restoration.

- Make QEMU harness resources unwind on launch/connect/greeting failures, use
  file-backed stderr with bounded diagnostic excerpts, and apply absolute QMP
  deadlines/response bounds. Bound terminate/kill waits and verify actual
  stderr-flood and termination-resistant child cleanup alongside protocol faults.

- Add structured literal-source diagnostics with stable codes and one-based
  line/token locations in Python and JavaScript. Preserve existing messages,
  grammar and caller error types; expose optional CLI JSON operational errors.
  Extend seeded cross-runtime parity and verify failed packing preserves output.

- Add a read-only bit-diff workbench with exact positional changes, per-bit roles,
  explicit decoding modes and unchanged bytes whose instruction boundaries/roles
  changed. Separate additions/removals from bit flips, retain invalid-draft state,
  and stop classification at unsupported/truncated encodings without resynchronizing.

- Execute unprefixed 16-bit-addressed memory MOV byte/word loads and stores with
  one decoder shared by inspection and execution. Preserve byte aliases/flags,
  journal RAM writes, reject word segment-limit crossings atomically, and restore
  self-modifying code through history. Add 2,304 oracle cases and one canonical
  model/native exercise as the sixth CPU Lab preset; registers/RAM/defined flags
  match QEMU. Wider/address-overridden/segment-overridden forms remain unsupported.

- Inspect 16-bit MOV memory address fields with symbolic bases, default DS/SS,
  signed displacements and the absolute r/m6 exception. Add 5,888 bounded cases,
  three disassembly goldens and a native DS/SS load probe. No memory execution,
  wider addressing, segment/address overrides or SIB support is added.

- Execute unprefixed register-direct byte/word MOV in the bounded model, preserving
  the other byte of aliased registers and every modeled flag. Add 2,048 independent
  byte-layout oracle cases, exact history checks and a native seven-copy/FLAGS probe.
  Memory addressing and wider/prefixed execution remain unsupported.

- Inspect register-direct MOV direction/width and ModR/M register fields in
  explicit 16/32/64 contexts, including independent REX.R/B extensions, AH versus
  SPL and byte forms that ignore 66/REX.W operand sizing. Add four literal fixtures
  and 18 independent disassembly goldens; no memory-form or wider execution support.

- Share exact loaded CPU Lab bytes through bounded, versioned URL fragments.
  Shared programs open paused in the model; malformed links preserve state.
  Comments, pending drafts, runtime memory and history are excluded. A selectable
  URL remains available when clipboard permission is denied.

- Reject source directories and named pipes during manifest preflight before
  opening source data or creating build output; a FIFO cannot stall the packer.

- Add a curated 256-byte protected-mode invalid-selector #GP probe verifying the
  CPU-pushed error-code doubleword, preserved DS and correct stack cleanup before
  IRETD. This handles one known invalid load, not general exception recovery.

- Add a curated 200-byte protected-mode UD2/#UD research probe with native gate,
  saved-frame, known-length EIP adjustment and IRETD evidence. Tests verify the
  CPU-set descriptor accessed bit while preserving all literal instruction bytes.
  General exception dispatch and hardware interrupts remain outside its scope.

- Add a curated 70-byte native divide-error probe with exact exception-frame,
  repaired-instruction retry and unrepaired repeated-fault QEMU checks. This is
  real-mode research; protected-mode fault handling and release assets are unchanged.

- Reject malformed manifests, conflicting packaging options and resolved output
  aliases before writing; preflight every literal source and derived package so a
  bad later target preserves previous build artifacts. I/O errors and concurrent
  filesystem changes remain outside multi-file transactional guarantees.

- Add read-only ELF64 anatomy inspection: actual fields, segment permissions,
  exact entry/file mapping and zero fill. Verify reviewed preset hashes; bound
  imports and byte-map rendering, preserve prior files on errors, and add six
  artifact checks, 2,000 seeded mutations and three-browser keyboard/mobile tests.

## 0.3.0 — 2026-10-12

- Add a deterministic release-provenance manifest tying the exact source commit,
  literal source files, reviewed payloads, packaged artifacts and release archives.
  Native target instruction bytes and boot images remain unchanged from v0.2.0.

- Add a literal hex draft to the CPU Lab, sharing binary parser boundaries and
  limits. Valid binary edits update hex without changing loaded state or comments;
  explicit hex loading replaces the binary draft and resets. Test all byte values,
  1,000 seeded round trips and three-browser draft/state behavior.

- Export/import exact loaded CPU Lab programs as `.bits` or raw `.bin`; preserve
  original bytes before self-modification and leave model execution/history intact.
  Reject invalid raw sizes and cancel stale asynchronous reads/errors after a newer
  source choice or draft. Real downloads and round trips pass in three browsers.

- Add explicit 16/32/64 decoding context to the existing bit playground: scoped
  MOV/XOR/legacy INC/DEC inspection, 66/REX fields, exact imm64, per-bit roles,
  literal `.bits` fixtures and independent disassembly goldens. Disable simulation
  for unsupported contexts; add actual context/bit-change recording and mobile checks.

- Stage and atomically replace `bitpack` outputs, preserving old files on injected
  sync/rename failures and cleaning staging files. Keep output symlinks, isolate
  other hard links, preserve existing basic modes, create private new files and
  reject non-file destinations. Target bytes are unchanged.

- Add a reproducible host-model benchmark for interpretation, history recording
  and full rewind/replay, with environment/source/workload hashes, semantic checks,
  retained CI JSON and an actual dated local sample. No native performance claim.

- Render all eight maintained introductions as localized website pages with
  language navigation, canonical/hreflang metadata, sitemap entries, escaped
  literal code and Arabic RTL layout. Three-browser mobile/keyboard checks and
  canonical documentation-copy checks run in CI.

- Add a recorded execution timeline to the CPU Lab. Select any state without
  executing instructions; show nearby recorded instructions and net register,
  flag and RAM changes. Arrow/Home/End keyboard controls work in three browsers.

- Add concise introductions in English, Simplified Chinese, Spanish, French,
  Japanese, Portuguese, German and Arabic; preserve shared literal examples and
  quickstart commands, with an English-source freshness manifest and link checks.

- Add conduct and security policies, enable private GitHub vulnerability reporting,
  route sensitive reports away from public issue forms and document a contributor
  source map. Verify published root reference files match canonical documents.

- Check arithmetic flags with an independent ripple-carry oracle, seeded ADD/SUB/CMP
  cases, all INC/DEC registers and exhaustive 8-bit TEST masks. Preserve IF/DF;
  represent undefined logical AF explicitly. These checks run in site CI.

- Align browser and host source parsing for initial UTF-8 BOMs, Unicode whitespace
  and comment-ending line boundaries; reject embedded BOMs consistently. Add
  658 seeded round-trip/rejection and cross-language diagnostic cases.

- Add exact recorded-state Back/Forward to the CPU Lab. Restore registers, flags,
  changed RAM, screen/serial output, UART state, instruction pointer and halt state;
  execution after a rewind replaces the old future. History uses scalar snapshots
  and byte deltas, with no per-frame full-RAM copy.

- Record exact changed model RAM bytes and consume that journal in the CPU Lab
  instead of copying/scanning 1 MiB on every instruction. Target binaries are unchanged.

## 0.2.0 — 2026-10-12

- Add an 813-byte native shell with nine exact commands, real memory experiments,
  handler-entry register/flag snapshots and checked loading of a returning
  150-byte disk app. Preserve the original monitor.
- Add a 568-byte 32-bit protected-mode/GDT/IDT software-interrupt experiment,
  independent success/failure QEMU checks and authentic native capture provenance.

- Add an editable 512-byte Boot Sector Builder with live byte fields, safe
  unsupported-encoding handling and exact image/source downloads.
- Add the Visual CPU Lab with full modeled 16-bit state, memory, stack, controls
  and breakpoints; 20 four-level challenges with hints and local progress.
- Add eight dedicated Pages routes and a source-generated roadmap feed.
- Add an eight-byte Linux exit size comparison while preserving the original;
  three genuine browser demo GIFs, contributor guides and issue forms.

- Correct modern real-mode `PUSH SP` in the bounded browser model and verify
  stack/flags/call/segmented-memory behavior with an independent QEMU probe.
- Add modeled arithmetic flags, CS/logical IP, near calls/returns, direct memory,
  string direction and memory-based instruction fetch for edited programs.
- Add strict, bounded literal `.bits` parsing, exact formatting, image framing
  validation and per-bit change descriptions shared by new browser instruments.
- Restrict public downloads and release archives to reviewed manifest outputs;
  browser test exports or other temporary images cannot enter published artifacts.
- Reject in-place packing and source aliases, packaged-output collisions and
  corrupted derived images/ELFs before publication. Honor 16-bit IP wrap in the
  teaching model and CPU Lab sequential preview.

## 0.1.1 — 2026-10-12

- Accept arbitrary `#` comment prose, including pipe separators, without changing
  the packed bytes. Structured annotations remain separate from byte syntax;
  malformed target metadata still fails source verification.
- Verify failed CLI packing leaves an existing output file intact.
- Isolate release artifacts by version so checksums cannot include older archives.
- Target instruction bytes and all boot images match v0.1.0 exactly.

## 0.1.0 — 2026-10-12

- Handwritten 512-byte x86 BIOS boot program with VGA/COM1 greeting and halt.
- Strict binary packer, annotated byte inspector, verifier and bit-level diff.
- Linux x86-64 exit, arithmetic, text, loop and comparison payloads with ELF
  header packaging; native Linux CI execution.
- BIOS keyboard and VGA demonstrations; checked two-sector disk loader.
- Interactive monitor with exact commands, bounded editable input and real
  boot-memory inspection.
- Ten per-byte guides, architecture and reproduction tutorials; real QEMU boot
  capture with provenance.
- Published interactive website with editable instruction fields, all 512
  annotated boot bytes, bounded boot simulation and responsive keyboard controls.
- Verified CI, automatic Pages deployment, repository topics and social preview.
- Public v0.1.0 release with five independently bootable images, full image/source
  archives and externally re-downloaded SHA-256-verified artifacts.
