logicxkit 0.2.0__tar.gz → 0.3.0__tar.gz

logicxkit-0.3.0/CHANGELOG.md

@@ -0,0 +1,192 @@
+# Changelog
+
+Notable changes to logicxkit. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/);
+versions follow [semantic versioning](https://semver.org/spec/v2.0.0.html).
+
+## 0.3.0 — 2026-09-14
+
+### Added
+
+- `logic quantize-drums`: the live-drum quantize on a copy without Logic — the drum group with
+  Editing (Selection) and Quantize-Locked (Audio), other groups off, Q-Reference on the
+  reference tracks, flex Slicing, and one flex marker per hit found in the reference audio with
+  its target on the 1/N grid (`services/onsets.py`, `flexmarkers.py`, `quantize_drums.py`).
+  CONFIRMED: Logic re-saved a written take with every marker intact.
+- `logic regions` reads a region's first frame within its file.
+- `midi --region` and `regions --audio` place their entry correctly on a project whose regions
+  carry flex markers.
+- `logic regions` maps an entry to its region record by ranking the counters of every audio
+  entry in every sequence, take folders included; the earlier base-offset rule mislabelled a
+  project with take folders.
+- `logic quantize-drums` takes a reference's audio from the file named after its region,
+  handles member regions that start at different bars, and names the files it used.
+- `logic project` names a native insert from its type id when the slot carries no name string,
+  as `plugins` does; a built patch's eight inserts read as eight.
+- The drum-quantize onset detector is tuned against the transients Logic marked across four
+  grids: 78% of them found, 88% of its own among them (was 55% and 90%).
+- The package carries Logic's own record templates and native plug-in donor slots, regenerated
+  from the public corpus by `bin/regen_data.py`, so `add-track`, `stack-create`, `send --add`,
+  `arrangement --add` and native `chains` work after `pip install` alone; a data root
+  (`LOGICXKIT_DATA`) still takes precedence, and `chains` reads both donor libraries.
+- `stack-create` works on a session with no stack, patterning on Logic's own first stack;
+  `arrangement --add` makes the arrangement track when the song has none; `send --add` works on
+  a project with no send to clone.
+- `logic midi` reads a song's MIDI regions — notes, controllers, program changes, pitch bends,
+  loop flag — and `--export` writes a format-1 Standard MIDI File.
+- `logic plugins` names every slot's plug-in and reports which third-party components this Mac
+  lacks, for one project or a folder of them.
+- `logic patch` reads a Library patch bundle — its nodes, each channel's settings, strip and
+  plug-ins — in both shapes Logic writes.
+- The group-events loss reported on 2026-09-08 does not reproduce on the blank-born project;
+  `tests/goldens/test_groups.py` pins create, assign, add, assign.
+- `logic midi --region` and `--note` write an empty MIDI region and notes on a copy; Logic re-saved
+  one with its notes intact.
+- `logic regions` reads every MIDI and audio region with its file record (name, format, frames,
+  rate, channels, bits); `--audio` imports a PCM WAV at the project's rate as a region.
+- `logic sessionplayer` reads a Session Player region's drummer, preset and settings (the JSON in
+  its record) and its generated notes; Complexity, Fill Amount and Swing pinned by one editor
+  move per save.
+- `logic patch --build` writes a patch bundle from a `.cst`, into Logic's own library only with
+  `--install`; a built patch loaded from the Library with all its inserts.
+- Nine more public goldens: a third send and the slot base it moves to 4, the Signature List's
+  meter and key creates and edits after bar 1, and a Tempo List point and its edit.
+- Sixty-two more public goldens: MIDI region writes and their re-saves, audio region writes and
+  a re-save, three audio imports, a Session Player track and three settings, a Library-saved
+  patch and a built one loaded.
+- `tools/driver` and `tools/stage_public.py`: the accessibility driver that records goldens from
+  Logic, with the recipe and the traps; CONTRIBUTING describes recording one.
+- Forty-three public goldens: the arrangement track and sections, an instrument track, a track
+  header click, eight native inserts, MIDI events one field per save, meter changes, and
+  Logic's re-saves of route, transplant, bypass, send, stack-create, arrangement and reorder
+  outputs.
+
+### Changed
+
+- `tempo --add` and `--ramp` write each point's time word (data +8, 1/2000 s from the SMPTE
+  origin) as Logic computes it; Logic's own points and curve runs match to the digit.
+- `route`, `transplant`, `bypass` and `reorder` are CONFIRMED: Logic re-saved one write of each
+  with the written bytes intact.
+- `logic donors` names Logic's plug-ins that ship without factory presets (Gain, EnVerb).
+
+### Fixed
+
+- `logic regions --audio` numbers an import as Logic's own imports do — entry word, record header
+  slots, file ordinal and link chain, registry entry, current and selected marks — and refuses a
+  project whose audio regions are in any other layout, or a WAV whose name it already holds,
+  before anything is copied. Logic re-saved two such imports with every region record kept.
+- `logic midi --note` goes into the region on the named track that holds its bar, never another
+  track's region at the same tick, and is refused when no region or several hold it.
+- `logic midi --region` writes a region's length and track for a name of any length; Logic
+  re-saved regions named four and nine bytes long as written.
+- `logic midi --export` writes the song's tempo map and time signatures, and refuses events
+  before bar 1 instead of raising.
+- `logic quantize-drums` reads 32/64-bit float and extensible WAVs, and refuses a song whose tempo
+  changes and reference audio with no hits.
+- `logic patch --build` refuses a file that is not a channel strip, leaves nothing behind when it
+  fails, and replaces a bundle with `--overwrite` only once the new one is complete, exiting 1
+  with the path of a replaced bundle it could not remove.
+- A channel's group field is a bitmask, one bit per group: `logic group` reads a channel that
+  is in several groups, or in group 3 or higher, as Logic does; `--create` keeps a member's
+  other groups, `--assign` moves it out of every other one.
+- `logic group` shows a switched-off group and `--group N --on/--off` sets it (flags bit 31).
+- `logic regions` reads a recorded project's regions: the entry counter's base, the flex
+  marker blocks after a flexed entry, and a flexed audio region's RBA sequence is not a MIDI
+  region.
+
+## 0.2.0 — 2026-09-12
+
+### Fixed
+
+- `validate_project` checks third-party plugin slots for duplicate keys and index collisions.
+- `apply-template` places each added track after the one added just above it, so a run of new
+  tracks lands in template order in one pass.
+- `stacks --move` and `levels --to` write through the integrity gate; a refused result is
+  discarded.
+- A project writer whose step fails part-way discards the whole copy, including alternatives
+  it had already written.
+- `logic project` reads a channel's inserts from its plugin-slot records at slot base 2, 3 or 4;
+  a plugin name in a property record, such as an aux's input source, is not an insert.
+- `logic header` computes the header width from the project's own name-column width and never
+  below Logic's 180-pixel floor, and says when a width grown from one stored on that floor is
+  an estimate.
+- `logic controlbar` keeps a project's stored button order and inserts a newly shown control
+  where Logic does.
+- `logic stacks` reads summing stacks (a grouping header bound to an Aux with members under
+  it) as well as folder stacks; `--move` refuses a summing stack.
+- `logic reorder` moves a stack header together with its members, and refuses to move a row into
+  or out of a summing stack.
+- `apply-template` moves a project's slot keys from base 2 to 4 only when a channel carries a
+  send at key 2.
+- Bar numbers given to `arrangement`, `tempo` and `signature` follow the song's time signatures.
+- `logic arrangement` refuses a non-ASCII section name.
+- `build` and `pst` refuse Logic's own library without `--install` whatever
+  `LOGICXKIT_AUDIO_MUSIC_APPS` is set to, and refuse under the folder it names.
+- `build`, `verify` and `pst` refuse a preset name that is not a plain file name.
+- `logic pst` marks a failed preset `!!` and exits 1.
+- `apply-template` without `--out`, `--plan` or `--propose-map` exits 2 with a message.
+- A quoted `~` expands in every path argument, including lists such as `recdiff --baseline`.
+- A JUCE plugin state nested past the recursion limit decodes to nothing.
+- Scanning a file for embedded plists takes one parse per plist.
+
+### Added
+
+- `apply-template --plan` names the session tracks the template has no counterpart for.
+- `chains` and `levels --to` are CONFIRMED.
+- Sends read their level (`Send.level`, `Send.level_exact`).
+- Leaving a group is measured against Logic's own No Group save.
+- The slot base is read from the channel records' own word when they agree, and follows the
+  number of sends (2, 3 or 4).
+- `bin/run fetch-corpus` downloads the public golden corpus; `LOGICXKIT_REQUIRE_GOLDENS=public`
+  and `LOGICXKIT_GOLDENS=owner` steer the goldens between the two corpora.
+- `logic image --overwrite`; without it an existing file is kept.
+
+## 0.1.1 — 2026-09-11
+
+### Fixed
+
+- The headless AU host finds `auprobe.swift` inside the installed package, so `au params` and
+  state decodes use it.
+
+### Added
+
+- `docs/README.md` (documentation index), `docs/INSTALLATION.md` and `docs/commands.md`.
+- `py.typed`: the package is annotated and now says so to type checkers.
+- `aulatency.swift` is documented in `src/logicxkit/au/README.md`; it ships in the wheel and
+  is run directly with `swift`.
+
+## 0.1.0 — 2026-09-10
+
+First public release.
+
+### Added
+
+- `logicxkit logic` — Logic Pro channel-strip (`.cst`) build and decode, read-only `.logicx`
+  project analysis, and writers for the track list, stacks, groups, sends, routing, channel
+  levels and width, arrangement, tempo, time and key signatures, transport modes, metronome,
+  track headers, control bar, toolbar and Logic's own settings. Every project-mutating command
+  requires `--out` and works on a copy.
+- `logicxkit logic apply-template` — migrate a session onto a template, pairing by Environment
+  object id within a lineage and by an explicit map across lineages.
+- `logicxkit logic diff` — project-to-project and project-to-strip-library drift.
+- `logicxkit logic image` / `ocr` — extract and OCR the auto-saved WindowImage via Apple Vision.
+- `logicxkit au` — Audio Unit preset and state decode: FabFilter `.ffp` and `.aupreset`, Waves
+  XPst, TR5 chain XML, sonible protobuf field walk, and the third-party states embedded in
+  `.cst` strips and `.logicx` projects.
+- Headless AU host (`auprobe.swift`) — loads an installed plugin's state and dumps every
+  parameter with real names and UI-formatted values.
+- `logicxkit logic capabilities` — what each command is trusted for, generated from
+  `logic/_capabilities.py`.
+- `logicxkit --version` (`-V`) prints the installed version.
+- Write gate (`logic/services/integrity.py`): every project write is held against its input and
+  refused on any regression; a refused run discards the copy.
+- A write by a command whose capability level is `CLAIMED`, `DERIVED` or `BROKEN` prints a
+  one-line notice naming that level (`LOGICXKIT_NO_NOTICE=1` silences it).
+- `logic transplant` refuses a clone that overruns the channel's slot key range or crosses a
+  record class version; `--force` overrides.
+- `logic build` and `logic pst` refuse to write into Logic's own library unless `--install` is
+  passed.
+- Strip specs take `output_root`, which moves where built strips land without moving where
+  their sources are read from.
+- CI on a macOS runner; `v*` tags build an sdist + wheel, check the wheel carries the Swift
+  helpers and no reference material, and publish to PyPI through a trusted publisher gated on
+  reviewer approval.

{logicxkit-0.2.0 → logicxkit-0.3.0}/CONTRIBUTING.md

@@ -52,6 +52,15 @@ diff the record list against the input.
   and not history.
 - Tests travel with the change.
 
+## Recording a golden
+
+Every format claim rests on one deliberate change in Logic and a byte diff against the save
+before it. `tools/driver/README.md` has the loop and the traps; `tools/driver/drive.py` performs
+one action and one Save As per step, `tools/driver/diff.py` diffs two saves, and
+`tools/stage_public.py` files the saves under `resources/public/` with a manifest key and the
+facts a test may assert. Only saves of a project born in Logic on your own machine go into the
+public corpus; a session that holds anyone's music or third-party plug-in state stays out.
+
 ## Licensing of contributions
 
 logicxkit is Apache-2.0. Under section 5 of that licence, anything you deliberately submit for

{logicxkit-0.2.0 → logicxkit-0.3.0}/MANIFEST.in

@@ -2,7 +2,7 @@
 # `test`. conftest.py and the `_*.py` helpers it imports are left behind, so the tree cannot collect.
 recursive-include tests *.py
 # Named, not globbed: an sdist is built from the working tree, where untracked files can sit.
-include bin/fetch_corpus.py tests/goldens/corpus.json tests/goldens/manifest.json
+include bin/fetch_corpus.py bin/regen_data.py tests/goldens/corpus.json tests/goldens/manifest.json
 # test_capabilities.py reads these two; without them the shipped suite fails rather than skips.
 recursive-include docs *.md
 recursive-include config *.json

{logicxkit-0.2.0/src/logicxkit.egg-info → logicxkit-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: logicxkit
-Version: 0.2.0
+Version: 0.3.0
 Summary: Logic Pro project and channel-strip tooling, and Audio Unit preset and state decoding
 Author: Mike Farr
 License-Expression: Apache-2.0
@@ -61,8 +61,8 @@ deliberate change per Logic save, then a byte diff against the save before it. T
 is the tidiest example — every button id was pinned on fifty single-toggle saves (2026-09-04),
 and a control bar written by this tool and copied whole onto another project came up in Logic
 with that exact set. That standard is not uniform across the tool. Some commands have been
-opened in Logic and confirmed, some are reasoned from diffs and never opened, and a few carry
-defects reproduced on real projects. **[`docs/CAPABILITIES.md`][caps]
+opened in Logic and confirmed, some are reasoned from diffs and never opened, and a defect
+reproduced on a real project is recorded until a regression test closes it. **[`docs/CAPABILITIES.md`][caps]
 carries the level and the evidence for every command, and `bin/run logic capabilities` prints
 the same table.** Read it before you point a writer at a session you care about.
 
@@ -90,7 +90,8 @@ pip install logicxkit
 logicxkit logic project ~/Music/Logic/Song.logicx    # read-only, to see it working
 ```
 
-That gets you the `logicxkit` command. To work on it instead, clone it and let `bin/run` build
+That gets you the `logicxkit` command, and with it the record templates and native plug-in
+donors the writers need — Logic's own, taken from its saves of a blank project. To work on it instead, clone it and let `bin/run` build
 the venv — every command below is written that way, and `bin/run logic …` and
 `logicxkit logic …` are the same thing:
 
@@ -112,6 +113,12 @@ bin/run logic levels "<song.logicx>"                     # channel fader + pan
 bin/run logic stacks "<song.logicx>" [--tracks]          # track stacks / arrange list
 bin/run logic ocr "<song.logicx>"                        # OCR the auto-saved WindowImage
 bin/run logic neural "<strip.cst | song.logicx>"         # Neural DSP knob values
+bin/run logic midi "<song.logicx>" [--export out.mid]      # MIDI regions, or a .mid of them
+bin/run logic plugins "<song.logicx | folder>"            # plug-ins referenced, and which are missing
+bin/run logic patch "<name.patch | folder>"               # a Library patch: channels, strips, plug-ins
+bin/run logic regions "<song.logicx>"                     # every MIDI and audio region, with files
+bin/run logic sessionplayer "<song.logicx>"               # Session Player drummer, preset, settings
+bin/run logic quantize-drums "<song.logicx>" --out DIR    # quantize a drum take to the grid, no Logic
 bin/run au strip "<strip.cst | song.logicx>"             # every embedded 3rd-party state
 bin/run au preset "<preset.aupreset | .ffp>"             # a preset file, named, in real units
 bin/run logic capabilities -v                            # what each writer is trusted for
@@ -125,7 +132,12 @@ bin/run logic capabilities -v                            # what each writer is t
   (extract the auto-saved WindowImage) and **`logic ocr`** (Apple-Vision OCR of it — reads the
   mixer as Logic drew it); **`logic levels`** (fader + pan, read and copy between projects);
   **`logic stacks`** (folder stacks and the arrange track list, and `--move` to put a track into
-  a stack); **Neural DSP state decode** (`logic neural`); and the project editors — track
+  a stack); **`logic midi`** (MIDI regions and their export as a `.mid`); **`logic plugins`**
+  (every referenced plug-in, and which this Mac lacks); **`logic patch`** (a Library patch
+  bundle's channels, strips and plug-ins, and `--build` to make one); **`logic regions`** (MIDI
+  and audio regions with their files, and `--audio` to import a WAV); **`logic sessionplayer`**
+  (a Session Player region's settings and generated notes); **Neural DSP state decode** (`logic
+  neural`); and the project editors — MIDI regions and notes, track
   header, control bar, toolbar, transport modes, metronome, channel width, mixer groups,
   arrangement sections, tempo, time signature and key, track add/rename/colour/hide/reorder,
   sends, routing, and `apply-template` to move a session onto another project's layout. See
@@ -182,7 +194,7 @@ Three more things write outside `--out`, and one warning:
   slot keys, ending at its `.cst` reference record; a clone that overruns that run deletes the
   reference, and `validate_project` cannot see the loss. A clone across record class versions
   cannot be legalised either. Both stop the run and say what to do instead; `--force` writes
-  anyway. The remaining open defects are listed in
+  anyway. Any open defect is listed in
   [`docs/CAPABILITIES.md`][caps].
 
 ## Layout
@@ -224,9 +236,10 @@ release asset and fetched by `bin/run fetch-corpus` into `resources/public/`, pi
 checksum in `tests/goldens/corpus.json`. `tests/goldens/manifest.json` names each save by a
 neutral key with the facts a test may assert. The **owner's corpus** — controlled saves cut
 from real sessions, project templates, finished mixes, a channel-strip library snapshot — is
-Logic-authored material containing real music and **is not here**; the same goes for the
-data root the tools load (record templates Logic wrote, plugin-slot donor records, AU
-parameter tables), none of which are ours to publish.
+Logic-authored material containing real music and **is not here**. The record templates and
+native plug-in donors the writers need ship inside the package (`src/logicxkit/data`, Logic's
+own from the public corpus); a data root (`LOGICXKIT_DATA`) adds third-party donors and AU
+parameter tables, which are not ours to publish.
 
 The consequence for a fresh clone: **`bin/run pytest` runs green, but every golden skips until
 `bin/run fetch-corpus` has run**, and the keys only the owner's corpus has skip regardless. The

{logicxkit-0.2.0 → logicxkit-0.3.0}/README.md

@@ -31,8 +31,8 @@ deliberate change per Logic save, then a byte diff against the save before it. T
 is the tidiest example — every button id was pinned on fifty single-toggle saves (2026-09-04),
 and a control bar written by this tool and copied whole onto another project came up in Logic
 with that exact set. That standard is not uniform across the tool. Some commands have been
-opened in Logic and confirmed, some are reasoned from diffs and never opened, and a few carry
-defects reproduced on real projects. **[`docs/CAPABILITIES.md`][caps]
+opened in Logic and confirmed, some are reasoned from diffs and never opened, and a defect
+reproduced on a real project is recorded until a regression test closes it. **[`docs/CAPABILITIES.md`][caps]
 carries the level and the evidence for every command, and `bin/run logic capabilities` prints
 the same table.** Read it before you point a writer at a session you care about.
 
@@ -60,7 +60,8 @@ pip install logicxkit
 logicxkit logic project ~/Music/Logic/Song.logicx    # read-only, to see it working
 ```
 
-That gets you the `logicxkit` command. To work on it instead, clone it and let `bin/run` build
+That gets you the `logicxkit` command, and with it the record templates and native plug-in
+donors the writers need — Logic's own, taken from its saves of a blank project. To work on it instead, clone it and let `bin/run` build
 the venv — every command below is written that way, and `bin/run logic …` and
 `logicxkit logic …` are the same thing:
 
@@ -82,6 +83,12 @@ bin/run logic levels "<song.logicx>"                     # channel fader + pan
 bin/run logic stacks "<song.logicx>" [--tracks]          # track stacks / arrange list
 bin/run logic ocr "<song.logicx>"                        # OCR the auto-saved WindowImage
 bin/run logic neural "<strip.cst | song.logicx>"         # Neural DSP knob values
+bin/run logic midi "<song.logicx>" [--export out.mid]      # MIDI regions, or a .mid of them
+bin/run logic plugins "<song.logicx | folder>"            # plug-ins referenced, and which are missing
+bin/run logic patch "<name.patch | folder>"               # a Library patch: channels, strips, plug-ins
+bin/run logic regions "<song.logicx>"                     # every MIDI and audio region, with files
+bin/run logic sessionplayer "<song.logicx>"               # Session Player drummer, preset, settings
+bin/run logic quantize-drums "<song.logicx>" --out DIR    # quantize a drum take to the grid, no Logic
 bin/run au strip "<strip.cst | song.logicx>"             # every embedded 3rd-party state
 bin/run au preset "<preset.aupreset | .ffp>"             # a preset file, named, in real units
 bin/run logic capabilities -v                            # what each writer is trusted for
@@ -95,7 +102,12 @@ bin/run logic capabilities -v                            # what each writer is t
   (extract the auto-saved WindowImage) and **`logic ocr`** (Apple-Vision OCR of it — reads the
   mixer as Logic drew it); **`logic levels`** (fader + pan, read and copy between projects);
   **`logic stacks`** (folder stacks and the arrange track list, and `--move` to put a track into
-  a stack); **Neural DSP state decode** (`logic neural`); and the project editors — track
+  a stack); **`logic midi`** (MIDI regions and their export as a `.mid`); **`logic plugins`**
+  (every referenced plug-in, and which this Mac lacks); **`logic patch`** (a Library patch
+  bundle's channels, strips and plug-ins, and `--build` to make one); **`logic regions`** (MIDI
+  and audio regions with their files, and `--audio` to import a WAV); **`logic sessionplayer`**
+  (a Session Player region's settings and generated notes); **Neural DSP state decode** (`logic
+  neural`); and the project editors — MIDI regions and notes, track
   header, control bar, toolbar, transport modes, metronome, channel width, mixer groups,
   arrangement sections, tempo, time signature and key, track add/rename/colour/hide/reorder,
   sends, routing, and `apply-template` to move a session onto another project's layout. See
@@ -152,7 +164,7 @@ Three more things write outside `--out`, and one warning:
   slot keys, ending at its `.cst` reference record; a clone that overruns that run deletes the
   reference, and `validate_project` cannot see the loss. A clone across record class versions
   cannot be legalised either. Both stop the run and say what to do instead; `--force` writes
-  anyway. The remaining open defects are listed in
+  anyway. Any open defect is listed in
   [`docs/CAPABILITIES.md`][caps].
 
 ## Layout
@@ -194,9 +206,10 @@ release asset and fetched by `bin/run fetch-corpus` into `resources/public/`, pi
 checksum in `tests/goldens/corpus.json`. `tests/goldens/manifest.json` names each save by a
 neutral key with the facts a test may assert. The **owner's corpus** — controlled saves cut
 from real sessions, project templates, finished mixes, a channel-strip library snapshot — is
-Logic-authored material containing real music and **is not here**; the same goes for the
-data root the tools load (record templates Logic wrote, plugin-slot donor records, AU
-parameter tables), none of which are ours to publish.
+Logic-authored material containing real music and **is not here**. The record templates and
+native plug-in donors the writers need ship inside the package (`src/logicxkit/data`, Logic's
+own from the public corpus); a data root (`LOGICXKIT_DATA`) adds third-party donors and AU
+parameter tables, which are not ours to publish.
 
 The consequence for a fresh clone: **`bin/run pytest` runs green, but every golden skips until
 `bin/run fetch-corpus` has run**, and the keys only the owner's corpus has skip regardless. The

logicxkit-0.3.0/bin/regen_data.py

@@ -0,0 +1,252 @@
+"""Regenerate src/logicxkit/data/logic from the public golden corpus (`bin/run fetch-corpus`).
+
+    bin/run python bin/regen_data.py
+
+Every template is a record Logic wrote in a public save of a blank project, so the package
+ships Logic's own bytes and nothing vendor-authored.
+"""
+from __future__ import annotations
+
+import json
+import struct
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "tests"))
+import _goldens  # noqa: E402
+from logicxkit.logic.services.binding import channels  # noqa: E402
+from logicxkit.logic.services.channel_alloc import mixer_record  # noqa: E402
+from logicxkit.logic.services.environment import ENV_TAG, object_id_of  # noqa: E402
+from logicxkit.logic.services.groups import (  # noqa: E402
+    EVENT,
+    EVENT_FADER_AT,
+    EVENT_OBJECT_AT,
+    EVENT_VALUE_AT,
+    EVENT_VALUE_HI_AT,
+    EVENT_VALUE_LO_AT,
+    FADER_IDS,
+    TAIL,
+    read_groups,
+)
+from logicxkit.logic.services.insert import HEADER, project_records  # noqa: E402
+from logicxkit.logic.services.recbuild import slot_of  # noqa: E402
+from logicxkit.logic.services.recdiff import load_project_data  # noqa: E402
+from logicxkit.logic.services.sends import is_send  # noqa: E402
+from logicxkit.logic.services.stacks import read_stacks  # noqa: E402
+from logicxkit.logic.services.tracklist import arrange_run, flat_run, row_object  # noqa: E402
+
+TEXT_HEAD = 98                      # a qSxT's fixed head; the section name follows
+SLOT_KEYS = range(2, 20)            # a channel's plug-in and property records
+
+OUT = ROOT / "src" / "logicxkit" / "data"
+SOURCE = ("Logic Pro 12.3.1 on a blank project: {what} (public corpus {a} -> {b}; "
+          "regenerated by bin/regen_data.py)")
+
+
+def _load(key: str) -> bytes:
+    p = _goldens.path(key)
+    if p is None:
+        raise SystemExit(f"golden {key!r} is not on this machine — run bin/run fetch-corpus")
+    return load_project_data(p)
+
+
+def _new(pair: tuple[str, str]) -> list:
+    """Records of the second save whose (tag, payload) the first lacks."""
+    a, b = (project_records(_load(k)) for k in pair)
+    seen = {(r.tag, r.raw[HEADER:]) for r in a}
+    return [r for r in b if (r.tag, r.raw[HEADER:]) not in seen]
+
+
+def _split(raw: bytes) -> dict:
+    return {"header": raw[:HEADER].hex(), "payload": raw[HEADER:].hex()}
+
+
+def _source(pair: tuple[str, str], what: str) -> str:
+    return SOURCE.format(what=what, a=pair[0], b=pair[1])
+
+
+def channel(pair: tuple[str, str], label: str) -> dict:
+    """The mixer record of the strip labelled ``label`` in the second save."""
+    data = _load(pair[1])
+    owner = next((o for o, c in channels(data).items() if c.label == label), None)
+    if owner is None:
+        raise SystemExit(f"{pair[1]}: no strip labelled {label!r}")
+    return {"source": _source(pair, f"the {label} strip"), **_split(mixer_record(project_records(data), owner))}
+
+
+def send(pair: tuple[str, str]) -> dict:
+    """The one send the second save added."""
+    added = [r for r in _new(pair) if is_send(r)]
+    if len(added) != 1:
+        raise SystemExit(f"{pair}: {len(added)} new send record(s), wanted one")
+    return {"source": _source(pair, "the send the second save added"), **_split(added[0].raw)}
+
+
+def _bare_event(event: bytes, fader: str) -> str:
+    e = bytearray(event)
+    struct.pack_into("<I", e, EVENT_OBJECT_AT, 0)
+    struct.pack_into("<I", e, EVENT_FADER_AT, FADER_IDS[fader])
+    struct.pack_into("<I", e, EVENT_VALUE_AT, 0)
+    struct.pack_into("<H", e, EVENT_VALUE_HI_AT, 0)
+    struct.pack_into("<H", e, EVENT_VALUE_LO_AT, 0)
+    return bytes(e).hex()
+
+
+def group(pair: tuple[str, str], name: str) -> dict:
+    """The group triple named ``name``: the `qeSM`, its `karT` marker and its `qSvE` events."""
+    records = project_records(_load(pair[1]))
+    g = next((g for g in read_groups(_load(pair[1])) if g.name == name), None)
+    if g is None:
+        raise SystemExit(f"{pair[1]}: no group named {name!r}")
+    qesm, marker, qsve = (records[g.start + k].raw for k in range(3))
+    events = qsve[HEADER:-TAIL]
+    if not events or len(events) % EVENT:
+        raise SystemExit(f"{pair[1]}: group {name!r} has no member events to pattern on")
+    return {"source": _source(pair, f"the group {name!r}"),
+            "qesm_header": qesm[:HEADER].hex(), "qesm_payload": qesm[HEADER:].hex(),
+            "marker_header": marker[:HEADER].hex(), "qsve_header": qsve[:HEADER].hex(),
+            "qsve_tail": qsve[-TAIL:].hex(),
+            "member_events": {f: _bare_event(events[:EVENT], f) for f in FADER_IDS},
+            "notes": "member_events: one event per linked fader, from the group's first event "
+                     "with the object id (+4), fader id (+12) and value (+8, +20, +30) reset; "
+                     "the writer stamps all three"}
+
+
+def stack_folder(pair: tuple[str, str], name: str) -> dict:
+    """The folder stack ``name``: its Sub strip, header object, arrange row and flat row."""
+    data = _load(pair[1])
+    records = project_records(data)
+    stack = next((s for s in read_stacks(data, None) if s.name == name), None)
+    if stack is None:
+        raise SystemExit(f"{pair[1]}: no stack named {name!r}")
+    obj = next(r.raw for r in records if r.tag == ENV_TAG and object_id_of(r) == stack.object_id)
+    run = arrange_run(records)
+    row = next(records[i].raw for i in run if row_object(records[i].raw) == stack.object_id)
+    flat = next(records[i].raw for i in flat_run(records, run)
+                if row_object(records[i].raw) == stack.object_id)
+    roles = {"strip": mixer_record(records, stack.owner), "object": obj, "row": row, "flat_row": flat}
+    return {"source": _source(pair, f"the folder stack {name!r} Logic created over three tracks"),
+            "records": {role: _split(raw) for role, raw in roles.items()}}
+
+
+def inst_track(pair: tuple[str, str], label: str) -> dict:
+    """The instrument slot and property records Logic gave the strip labelled ``label``."""
+    data = _load(pair[1])
+    owner = next((o for o, c in channels(data).items() if c.label == label), None)
+    if owner is None:
+        raise SystemExit(f"{pair[1]}: no strip labelled {label!r}")
+    recs = [r for r in project_records(data) if r.tag == b"UCuA" and r.owner == owner and r.key in SLOT_KEYS]
+    return {"_": _source(pair, f"the {label} strip's slot records; owner re-stamped on use"),
+            "records": {str(r.key): r.raw.hex() for r in sorted(recs, key=lambda r: r.key)}}
+
+
+def section_text(pair: tuple[str, str], name: str) -> dict:
+    """The name record of the section called ``name``, less the name itself."""
+    text = name.encode("ascii") + b"\0"
+    text += b"\0" * (len(text) % 2)
+    hit = next((r for r in _new(pair) if r.tag == b"qSxT" and r.raw[HEADER + TEXT_HEAD:] == text), None)
+    if hit is None:
+        raise SystemExit(f"{pair}: no new section text record named {name!r}")
+    return {"source": _source(pair, f"the section {name!r}'s name record"),
+            "header": hit.raw[:HEADER].hex(), "head": hit.raw[HEADER:HEADER + TEXT_HEAD].hex()}
+
+
+def arrangement_track(pair: tuple[str, str]) -> dict:
+    """Everything Logic added for the arrangement track and its first section: the section
+    and track sequence triples with the `snrT` after the last `tSxT`, the `OgnS` before the
+    first `rpyH`, the last `MneG` and the empty text record."""
+    records = project_records(_load(pair[1]))
+    anchor = max(i for i, r in enumerate(records) if r.tag == b"tSxT")
+    run = records[anchor + 1:anchor + 8]
+    if [r.tag for r in run] != [b"qeSM", b"karT", b"qSvE"] * 2 + [b"snrT"]:
+        raise SystemExit(f"{pair[1]}: no two sequence triples and snrT after the last tSxT")
+    first_rpyh = next(i for i, r in enumerate(records) if r.tag == b"rpyH")
+    ogns = max(i for i, r in enumerate(records[:first_rpyh]) if r.tag == b"OgnS")
+    mneg = max(i for i, r in enumerate(records) if r.tag == b"MneG")
+    empty = next(r for r in records if r.tag == b"qSxT" and slot_of(r.raw) == 0 and r.raw[HEADER + TEXT_HEAD:] == b"\0")
+    roles = dict(zip(("section_qesm", "section_marker", "section_qsve", "track_qesm", "track_marker",
+                      "track_qsve", "snrt"), (r.raw for r in run)))
+    roles |= {"ogns": records[ogns].raw, "mneg": records[mneg].raw, "text_empty": empty.raw}
+    return {"source": _source(pair, "the arrangement track shown and its first section added"),
+            "records": {role: _split(raw) for role, raw in roles.items()}}
+
+
+def midi_region(pair: tuple[str, str], track_label: str) -> dict:
+    """The region Logic made on the strip labelled ``track_label``: its sequence triple and the
+    song container's 80-byte entry for it."""
+    from logicxkit.logic.services.regions import ENTRY, TAIL, placements, song_container
+    from logicxkit.logic.services.sequence import sequences, triple_by_slot
+    data = _load(pair[1])
+    records = project_records(data)
+    run = arrange_run(records)
+    song = song_container(records, run)
+    payload = records[song.end].raw[HEADER:]
+    labels = {}
+    from logicxkit.logic.services.stacks import read_tracks
+    names = {r["object_id"]: r["name"] for r in read_tracks(data, None)}
+    entries = [(off, oid) for off, oid, _row in placements(records) if names.get(oid) == track_label]
+    if len(entries) != 1:
+        raise SystemExit(f"{pair[1]}: {len(entries)} region(s) on {track_label!r}, wanted one")
+    off, _oid = entries[0]
+    entry = payload[off:off + ENTRY]
+    slot = struct.unpack_from("<I", entry, 32)[0]
+    t = triple_by_slot(sequences(records), slot)
+    roles = {"qesm": records[t.start].raw, "marker": records[t.start + 1].raw, "qsve": records[t.end].raw, "entry": entry}
+    return {"source": _source(pair, f"the empty MIDI region on {track_label!r} (Pencil tool click)"),
+            "records": {role: _split(raw) if role != "entry" else {"payload": raw.hex()} for role, raw in roles.items()}}
+
+def audio_region(pair: tuple[str, str]) -> dict:
+    """The audio file record, region record and song-container entry Logic added for one
+    imported WAV."""
+    from logicxkit.logic.services.regions import ENTRY, TAIL, song_container
+    new = _new(pair)
+    lfua = [r for r in new if r.tag == b"lFuA"]
+    grua = [r for r in new if r.tag == b"gRuA"]
+    if len(lfua) != 1 or len(grua) != 1:
+        raise SystemExit(f"{pair}: {len(lfua)} file and {len(grua)} region record(s), wanted one each")
+    records = project_records(_load(pair[1]))
+    song = song_container(records, arrange_run(records))
+    payload = records[song.end].raw[HEADER:]
+    entries = [payload[i:i + ENTRY] for i in range(0, len(payload) - TAIL, ENTRY)]
+    audio = [e for e in entries if struct.unpack_from("<H", e, 0)[0] == 0x24]
+    if len(audio) != 1:
+        raise SystemExit(f"{pair[1]}: {len(audio)} audio entries, wanted one")
+    return {"source": _source(pair, "one WAV imported with File > Import > Audio File"),
+            "records": {"lfua": _split(lfua[0].raw), "grua": _split(grua[0].raw), "entry": {"payload": audio[0].hex()}}}
+
+# name -> (golden keys the extraction reads, how to make it)
+TEMPLATES = {
+    "audio-channel-12.3.1.json": (("tracks-two-audio-logic",),
+                                  lambda: channel(("blank-base", "tracks-two-audio-logic"), "Audio 2")),
+    "aux-track-12.3.1.json": (("stack-summing-logic",),
+                              lambda: channel(("stack-folder-flattened-logic", "stack-summing-logic"), "Aux 1")),
+    "group-12.3.1.json": (("group-drums-logic",),
+                          lambda: group(("stack-folder-flattened-logic", "group-drums-logic"), "Drums")),
+    "send-12.3.1.json": (("levels-resave-logic", "send-bus-1-logic"),
+                         lambda: send(("levels-resave-logic", "send-bus-1-logic"))),
+    "stack-folder-12.3.1.json": (("stack-folder-logic",),
+                                 lambda: stack_folder(("tracks-three-audio-logic", "stack-folder-logic"), "Sub 1")),
+    "inst-track-12.3.1.json": (("tracks-instrument-logic",),
+                               lambda: inst_track(("arrangement-section-1-selected-logic", "tracks-instrument-logic"), "Inst 1")),
+    "section-text-12.3.1.json": (("arrangement-track-logic", "arrangement-first-section-logic"),
+                                 lambda: section_text(("arrangement-track-logic", "arrangement-first-section-logic"), "Intro")),
+    "arrangement-track-12.3.1.json": (("arrangement-first-section-logic",),
+                                      lambda: arrangement_track(("stack-folder-flattened-logic", "arrangement-first-section-logic"))),
+    "midi-region-12.3.1.json": (("midi-empty-region-logic",),
+                                lambda: midi_region(("inserts-native-all-logic", "midi-empty-region-logic"), "Inst 1")),
+    "audio-region-12.3.1.json": (("midi-write-resave-logic", "audio-one-region-logic"),
+                                 lambda: audio_region(("midi-write-resave-logic", "audio-one-region-logic"))),
+}
+
+
+def main() -> int:
+    (OUT / "logic").mkdir(parents=True, exist_ok=True)
+    for name, (_keys, make) in TEMPLATES.items():
+        (OUT / "logic" / name).write_text(json.dumps(make(), indent=1) + "\n")
+        print("wrote", name)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())