2.5 (a): worker mode in the core — process() on a thread of its own

[tap]

Stacked on #28 (the design). Only the top commit, 65a0694, is new here. Merge #28 first.

Step (a) of plan 2.5, following the decided design.

What changes

core/include/tap/python/worker.h runs a processor's process() on a worker thread, a fixed number of vectors behind the audio thread.

• The audio thread only copies vectors in and out of a lock-free ring. It never takes the GIL, allocates, locks or prints. It wakes the worker with a C++20 atomic notify, which never blocks.
• The worker takes the slots in order and runs the existing processor::process(). Per-sample and per-vector classes work unchanged, with 2.4's channel matching.
• Underruns: if a vector's outputs aren't ready when they're due, that vector is output as silence. The worker still processes it and catches up, so the latency stays fixed and the class still sees every vector in order.
• A whole ring behind (the latency plus 0.25 s, at least 16 vectors): new inputs are dropped until the worker catches up, so the class sees a gap. This corrects the design text, which said "oldest". Dropping new ones is what a single-producer, single-consumer ring can do without racing the worker for a slot it's using; the plan is updated.
• Reports: both kinds are reported once per load, from the main thread. The processor gains load_count() so the worker can tell when a load has happened.
• Starting and stopping: the audio thread borrows the ring for each vector by taking an atomic pointer. start() and stop() therefore wait at most one vector, even while a host's old signal chain is still running, and a vector that arrives meanwhile is silence.
• Threads: the core's CMake target now links Threads.

Tests (test_worker.cpp, fixture stalls.py)

• Latency: worker output equals direct output L vectors later, per sample and per vector, L = 1, 2, 3, with two channels.
• Channel matching: a missing host input reads as silence, an extra output is silent, and short vectors work.
• Stalls: a 0.2 s stall goes silent and is reported once; after it, the output is back at the same latency. A second stall is not reported again; after a reload, a stall is reported again.
• Drops: a stall that runs past the ring drops exactly the 12 vectors beyond it. Their outputs are silent and aren't counted as late.
• Lifecycle: restart with a new vector size and latency, stop, and stop during a stall (it waits for the vector in progress).
• Reloads: ten reloads while an audio thread runs at real-time pace; the last reload is what plays.

Checked locally (macOS)

• Core battery 83/83.
• The worker scenarios passed 15 runs in a row.
• ThreadSanitizer: clean on the worker scenarios and the existing threading and reload ones.
• clang-format and clang-tidy-18 pass.

Step (b), the Max object (@mode, @latency, @latencysamples, and a runtime test in Max), is next.

🤖 Generated with Claude Code

https://claude.ai/code/session_019rVV9SkjkWmiBXFMT4whkz