feat!: change CLAP IDs to io.narl.bass-foundry.<product>, release all plugins

The io.storyboard.* IDs were a leftover from Motif Storyboard and named old functions (motif, sub-anchor, layer-align) instead of the products. Every plugin now uses io.narl.bass-foundry.<product>, and IDs are frozen from here on, even across renames. Hosts see the new IDs as different plugins: delete the old .clap files, rescan, and add the plugins again in existing projects. Rivet session JSON and Patina parameter IDs are unchanged. - Rivet 0.5.0, Patina 0.3.0; Anvil, Crucible, Lathe, Temper, Weld and Knurl 0.2.0. - Docs, changelogs and the release table describe the change. - Website: upgrade note in the Install section.
feat(website): add the fl.narl.io site
2026-11-06 11:51:11 +01:00 · 2026-11-06 11:30:12 +01:00 · 2026-11-06 08:49:11 +01:00 · 2026-11-06 08:34:14 +01:00 · 2026-11-06 08:31:41 +01:00 · 2026-11-06 08:01:02 +01:00
218 changed files with 44491 additions and 3349 deletions
@@ -1,27 +1,69 @@
 name: Rust plugin toolchain
-description: Native checks and optional Windows GNU cross-compilation in Node's Debian container
+description: >-
+  Native checks and optional Windows GNU cross-compilation in Node's Debian
+  container. Restores the Rust toolchain, Cargo registry, and the caller's
+  build directories from the runner cache, and saves them after the job.
 inputs:
  windows:
    description: Install the Windows cross compiler
    default: "false"
+  cache-name:
+    description: Distinguishes build-directory caches of different jobs
+    required: true
+  target-paths:
+    description: Build directories to cache, one per line, relative to the workspace
+    default: target
 runs:
  using: composite
  steps:
+    - name: Cache keys
+      id: keys
+      shell: bash
+      run: |
+        # A new ISO week starts fresh caches, so stale build output cannot grow forever
+        # and the stable toolchain is refreshed regularly.
+        echo "week=$(date -u +%G-%V)" >> "$GITHUB_OUTPUT"
+    - name: Restore Rust toolchain and Cargo registry
+      uses: https://github.com/actions/cache@v4
+      with:
+        path: |
+          .cargo-ci/bin
+          .cargo-ci/registry/index
+          .cargo-ci/registry/cache
+          .cargo-ci/git/db
+          .rustup-ci
+        key: rust-${{ inputs.windows }}-${{ steps.keys.outputs.week }}-${{ hashFiles('Cargo.lock', 'plugins/*/plugin/Cargo.lock', 'tools/editor-check/Cargo.lock') }}
+        restore-keys: |
+          rust-${{ inputs.windows }}-${{ steps.keys.outputs.week }}-
+    - name: Restore build directories
+      uses: https://github.com/actions/cache@v4
+      with:
+        path: ${{ inputs.target-paths }}
+        # One entry per job, week, and dependency set: compiled dependencies are
+        # reused, and only this repository's crates rebuild on each push.
+        key: build-${{ inputs.cache-name }}-${{ steps.keys.outputs.week }}-${{ hashFiles('Cargo.lock', 'plugins/*/plugin/Cargo.lock', 'tools/editor-check/Cargo.lock') }}
+        restore-keys: |
+          build-${{ inputs.cache-name }}-${{ steps.keys.outputs.week }}-
    - name: Install build prerequisites
      shell: bash
      run: |
        apt-get update
        apt-get install -y --no-install-recommends python3 curl ca-certificates pkg-config libgl1-mesa-dev libx11-dev libxcursor-dev libx11-xcb-dev libxcb1-dev libxcb-dri2-0-dev libxcb-icccm4-dev libxkbcommon-x11-dev
+        if [ "${{ inputs.windows }}" = "true" ]; then
+          apt-get install -y --no-install-recommends gcc-mingw-w64-x86-64
+        fi
    - name: Install Rust
      shell: bash
      run: |
-        curl --proto '=https' --tlsv1.2 -fsSL https://sh.rustup.rs -o /tmp/rustup-init.sh
-        sh /tmp/rustup-init.sh -y --profile minimal --default-toolchain stable
+        if [ ! -x "$CARGO_HOME/bin/rustup" ]; then
+          curl --proto '=https' --tlsv1.2 -fsSL https://sh.rustup.rs -o /tmp/rustup-init.sh
+          sh /tmp/rustup-init.sh -y --profile minimal --default-toolchain none --no-modify-path
+        fi
        echo "$CARGO_HOME/bin" >> "$GITHUB_PATH"
-        "$CARGO_HOME/bin/rustup" component add rustfmt clippy
-    - name: Install Windows target
-      if: inputs.windows == 'true'
-      shell: bash
-      run: |
-        apt-get install -y --no-install-recommends gcc-mingw-w64-x86-64
-        rustup target add x86_64-pc-windows-gnu
+        # No-op when the restored toolchain is already current.
+        "$CARGO_HOME/bin/rustup" toolchain install stable --profile minimal -c rustfmt -c clippy
+        "$CARGO_HOME/bin/rustup" default stable
+        if [ "${{ inputs.windows }}" = "true" ]; then
+          "$CARGO_HOME/bin/rustup" target add x86_64-pc-windows-gnu
+        fi
+        "$CARGO_HOME/bin/rustc" --version
@@ -10,7 +10,10 @@ permissions:

 env:
  CARGO_HOME: ${{ gitea.workspace }}/.cargo-ci
+  RUSTUP_HOME: ${{ gitea.workspace }}/.rustup-ci
  CARGO_TERM_COLOR: always
+  # Incremental data is not reused between CI runs; it only inflates the cache.
+  CARGO_INCREMENTAL: "0"

 jobs:
  check:
@@ -19,13 +22,18 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        plugin: [rivet, patina]
+        plugin: [rivet, patina, anvil, crucible, lathe, temper, weld, knurl]
    steps:
      - uses: https://github.com/actions/checkout@v4
        with:
          token: ${{ secrets.GITEA_TOKEN }}
          persist-credentials: false
      - uses: ./.gitea/actions/setup
+        with:
+          cache-name: check-${{ matrix.plugin }}
+          target-paths: |
+            target
+            plugins/${{ matrix.plugin }}/plugin/target
      - run: python3 -m unittest discover -s scripts/tests -v
      - run: python3 scripts/check-plugin.py --plugin "${{ matrix.plugin }}"

@@ -38,6 +46,9 @@ jobs:
          token: ${{ secrets.GITEA_TOKEN }}
          persist-credentials: false
      - uses: ./.gitea/actions/setup
+        with:
+          cache-name: previews
+          target-paths: tools/editor-check/target
      - run: |
          cargo fmt --all -- --check
          cargo fmt --manifest-path tools/editor-check/Cargo.toml -- --check
@@ -45,6 +56,12 @@ jobs:
          cargo run --manifest-path tools/editor-check/Cargo.toml --locked -- target/editor/rivet.png --plugin rivet
          cargo run --manifest-path tools/editor-check/Cargo.toml --locked -- target/editor/patina.png --plugin patina
          cargo run --manifest-path tools/editor-check/Cargo.toml --locked -- target/editor/patina-compact.png --plugin patina --compact
+          cargo run --manifest-path tools/editor-check/Cargo.toml --locked -- target/editor/anvil.png --plugin anvil
+          cargo run --manifest-path tools/editor-check/Cargo.toml --locked -- target/editor/crucible.png --plugin crucible
+          cargo run --manifest-path tools/editor-check/Cargo.toml --locked -- target/editor/lathe.png --plugin lathe
+          cargo run --manifest-path tools/editor-check/Cargo.toml --locked -- target/editor/temper.png --plugin temper
+          cargo run --manifest-path tools/editor-check/Cargo.toml --locked -- target/editor/weld.png --plugin weld
+          cargo run --manifest-path tools/editor-check/Cargo.toml --locked -- target/editor/knurl.png --plugin knurl
      - uses: https://github.com/actions/upload-artifact@v3-node20
        with:
          name: editor-previews
@@ -65,14 +82,22 @@ jobs:
      - uses: ./.gitea/actions/setup
        with:
          windows: "true"
+          cache-name: windows-preview
+          target-paths: target/windows
      - run: |
          python3 scripts/build-plugin.py --plugin rivet --target x86_64-pc-windows-gnu
          python3 scripts/build-plugin.py --plugin patina --target x86_64-pc-windows-gnu
+          python3 scripts/build-plugin.py --plugin anvil --target x86_64-pc-windows-gnu
+          python3 scripts/build-plugin.py --plugin crucible --target x86_64-pc-windows-gnu
+          python3 scripts/build-plugin.py --plugin lathe --target x86_64-pc-windows-gnu
+          python3 scripts/build-plugin.py --plugin temper --target x86_64-pc-windows-gnu
+          python3 scripts/build-plugin.py --plugin weld --target x86_64-pc-windows-gnu
+          python3 scripts/build-plugin.py --plugin knurl --target x86_64-pc-windows-gnu
          python3 scripts/package-windows.py
      - uses: https://github.com/actions/upload-artifact@v3-node20
        with:
-          name: rivet-patina-windows-x86_64
+          name: bass-foundry-windows-x86_64
          path: |
-            dist/rivet-patina-windows-x86_64.zip
-            dist/rivet-patina-windows-x86_64.zip.sha256
+            dist/bass-foundry-windows-x86_64.zip
+            dist/bass-foundry-windows-x86_64.zip.sha256
          retention-days: 30
@@ -1,14 +1,16 @@
 name: Independent plugin release
 on:
  push:
-    tags: ["rivet-v*", "patina-v*"]
+    tags: ["rivet-v*", "patina-v*", "anvil-v*", "crucible-v*", "lathe-v*", "temper-v*", "weld-v*", "knurl-v*"]

 permissions:
  contents: read

 env:
  CARGO_HOME: ${{ gitea.workspace }}/.cargo-ci
+  RUSTUP_HOME: ${{ gitea.workspace }}/.rustup-ci
  CARGO_TERM_COLOR: always
+  CARGO_INCREMENTAL: "0"
  RELEASE_REF: ${{ gitea.ref }}

 jobs:
@@ -44,6 +46,10 @@ jobs:
      - uses: ./.gitea/actions/setup
        with:
          windows: "true"
+          # CARGO_TARGET_DIR holds both the native checks and the Windows build.
+          # Kept apart from branch builds; a release never reuses preview output.
+          cache-name: release-${{ needs.plan.outputs.plugin }}
+          target-paths: target/windows
      - run: |
          python3 -m unittest discover -s scripts/tests -v
          python3 scripts/check-plugin.py --plugin "$PLUGIN"
@@ -30,6 +30,25 @@ dependencies = [
 "zerocopy",
 ]

+[[package]]
+name = "anvil-core"
+version = "0.1.0"
+dependencies = [
+ "common-dsp",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "anvil-ui"
+version = "0.1.0"
+dependencies = [
+ "anvil-core",
+ "common-dsp",
+ "common-ui",
+ "egui",
+]
+
 [[package]]
 name = "autocfg"
 version = "1.5.1"
@@ -48,6 +67,17 @@ version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"

+[[package]]
+name = "common-dsp"
+version = "0.1.0"
+
+[[package]]
+name = "common-ui"
+version = "0.1.0"
+dependencies = [
+ "egui",
+]
+
 [[package]]
 name = "crossbeam-queue"
 version = "0.3.14"
@@ -63,6 +93,26 @@ version = "0.8.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6"

+[[package]]
+name = "crucible-core"
+version = "0.1.0"
+dependencies = [
+ "common-dsp",
+ "crossbeam-queue",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "crucible-ui"
+version = "0.1.0"
+dependencies = [
+ "common-dsp",
+ "common-ui",
+ "crucible-core",
+ "egui",
+]
+
 [[package]]
 name = "ecolor"
 version = "0.31.1"
@@ -120,6 +170,44 @@ version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"

+[[package]]
+name = "knurl-core"
+version = "0.1.0"
+dependencies = [
+ "common-dsp",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "knurl-ui"
+version = "0.1.0"
+dependencies = [
+ "common-dsp",
+ "common-ui",
+ "egui",
+ "knurl-core",
+]
+
+[[package]]
+name = "lathe-core"
+version = "0.1.0"
+dependencies = [
+ "common-dsp",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "lathe-ui"
+version = "0.1.0"
+dependencies = [
+ "common-dsp",
+ "common-ui",
+ "egui",
+ "lathe-core",
+]
+
 [[package]]
 name = "libc"
 version = "0.2.191"
@@ -214,7 +302,7 @@ dependencies = [

 [[package]]
 name = "patina-core"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
 "rustfft",
 "serde",
@@ -223,7 +311,7 @@ dependencies = [

 [[package]]
 name = "patina-render"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
 "patina-core",
 "serde_json",
@@ -231,8 +319,9 @@ dependencies = [

 [[package]]
 name = "patina-ui"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
+ "common-ui",
 "egui",
 "patina-core",
 ]
@@ -281,7 +370,7 @@ dependencies = [

 [[package]]
 name = "rivet-app"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
 "crossbeam-queue",
 "rivet-core",
@@ -291,7 +380,7 @@ dependencies = [

 [[package]]
 name = "rivet-core"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
 "serde",
 "serde_json",
@@ -299,14 +388,14 @@ dependencies = [

 [[package]]
 name = "rivet-midi"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
 "rivet-core",
 ]

 [[package]]
 name = "rivet-preview"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
 "rivet-core",
 "rivet-midi",
@@ -409,6 +498,25 @@ dependencies = [
 "unicode-ident",
 ]

+[[package]]
+name = "temper-core"
+version = "0.1.0"
+dependencies = [
+ "common-dsp",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "temper-ui"
+version = "0.1.0"
+dependencies = [
+ "common-dsp",
+ "common-ui",
+ "egui",
+ "temper-core",
+]
+
 [[package]]
 name = "transpose"
 version = "0.2.3"
@@ -437,6 +545,25 @@ version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"

+[[package]]
+name = "weld-core"
+version = "0.1.0"
+dependencies = [
+ "crossbeam-queue",
+ "rustfft",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "weld-ui"
+version = "0.1.0"
+dependencies = [
+ "common-ui",
+ "egui",
+ "weld-core",
+]
+
 [[package]]
 name = "windows-link"
 version = "0.2.1"
@@ -1,7 +1,7 @@
 [workspace]
 resolver = "2"
-members = ["plugins/rivet/core", "plugins/rivet/midi", "plugins/rivet/preview", "plugins/rivet/app", "plugins/patina/core", "plugins/patina/render", "plugins/patina/ui"]
-exclude = ["plugins/rivet/plugin", "tools/editor-check", "plugins/patina/plugin"]
+members = ["plugins/common/ui", "plugins/common/dsp", "plugins/anvil/core", "plugins/anvil/ui", "plugins/lathe/core", "plugins/lathe/ui", "plugins/temper/core", "plugins/temper/ui", "plugins/weld/core", "plugins/weld/ui", "plugins/knurl/core", "plugins/knurl/ui", "plugins/crucible/core", "plugins/crucible/ui", "plugins/rivet/core", "plugins/rivet/midi", "plugins/rivet/preview", "plugins/rivet/app", "plugins/patina/core", "plugins/patina/render", "plugins/patina/ui"]
+exclude = ["plugins/rivet/plugin", "tools/editor-check", "plugins/patina/plugin", "plugins/anvil/plugin", "plugins/crucible/plugin", "plugins/lathe/plugin", "plugins/temper/plugin", "plugins/weld/plugin", "plugins/knurl/plugin"]

 [workspace.package]
 edition = "2021"
@@ -16,3 +16,16 @@ rivet-midi = { path = "plugins/rivet/midi" }
 [profile.release]
 lto = "thin"
 strip = "symbols"
+
+# Signal-level tests render seconds of audio; unoptimised DSP makes them crawl.
+[profile.dev.package.common-dsp]
+opt-level = 2
+[profile.dev.package.lathe-core]
+opt-level = 2
+[profile.dev.package.temper-core]
+opt-level = 2
+[profile.dev.package.knurl-core]
+opt-level = 2
+
+[profile.dev.package.weld-core]
+opt-level = 2
@@ -1,70 +1,199 @@
-# Rivet & Patina
+# Bass Foundry

-Two Rust CLAP plugins for writing and refining bass music.
+**Rust CLAP plugins for writing, designing and mixing bass music in FL Studio.**

-| Plugin | Purpose | Guide |
-| --- | --- | --- |
-| **Rivet** | Join motifs into connected phrases, preserve identity, and explore branches | [Rivet](docs/rivet/README.md) |
-| **Patina** | Smooth harsh resonances while retaining tone and transient character | [Patina](docs/patina/README.md) |
+Website: [fl.narl.io](https://fl.narl.io)
+
+![CLAP](https://img.shields.io/badge/format-CLAP-6c5ce7)
+![FL Studio 2024.1+](https://img.shields.io/badge/FL%20Studio-2024.1%2B-ff8a00)
+![Windows x64](https://img.shields.io/badge/platform-Windows%20x64-0078d4)
+![Rust stable](https://img.shields.io/badge/Rust-stable-b7410e)
+![License ISC](https://img.shields.io/badge/license-ISC-2ea44f)
+
+Riddim and dubstep basses change patch on every switch-up. Fixed-frequency tools
+then act differently on every note: the sub jumps, an EQ cut lands on another
+harmonic, the distortion gets fizzy on one note and dull on the next. Most plugins
+in this suite follow the played note, so a setting means the same thing on every
+note. Each plugin is a separate product with its own version, guide and release.
+
+## Plugins
+
+| Plugin | What it does | Load it on | Latency | Docs |
+| --- | --- | --- | --- | --- |
+| **[Rivet](docs/rivet/README.md)** | Tells a MIDI motif as a story on a storyboard of roles and joins the seams into one phrase | Channel Rack | none | [Guide](docs/rivet/README.md) · [Changes](docs/rivet/CHANGELOG.md) |
+| **[Patina](docs/patina/README.md)** | Smooths harsh, ringing resonances while plain harmonic tone and transients pass | Any mixer track | one analysis frame | [Guide](docs/patina/README.md) · [Changes](docs/patina/CHANGELOG.md) |
+| **[Anvil](docs/anvil/README.md)** | Replaces the sub with a clean mono sine: one level and one start phase on every note | Bass bus | 80 ms | [Guide](docs/anvil/README.md) · [Changes](docs/anvil/CHANGELOG.md) |
+| **[Crucible](docs/crucible/README.md)** | Records the last bars all the time, then slices, cleans and exports key-labelled samples with one button | End of the chain to resample | none | [Guide](docs/crucible/README.md) · [Changes](docs/crucible/CHANGELOG.md) |
+| **[Lathe](docs/lathe/README.md)** | EQ with one band on each harmonic of the played note: a cut on harmonic 3 stays on harmonic 3 | Bass, after the synth | ≈ 67 ms | [Guide](docs/lathe/README.md) · [Changes](docs/lathe/CHANGELOG.md) |
+| **[Temper](docs/temper/README.md)** | Distortion that drives every note the same: level and tone filters follow the note | Bass | ≈ 67 ms + oversampling | [Guide](docs/temper/README.md) · [Changes](docs/temper/CHANGELOG.md) |
+| **[Weld](docs/weld/README.md)** | Phase-aligns one bass layer to another layer through the sidechain, so the layers sum in the mids instead of cancelling | One layer's track, other layer as sidechain | none | [Guide](docs/weld/README.md) · [Changes](docs/weld/CHANGELOG.md) |
+| **[Knurl](docs/knurl/README.md)** | Gives every cycle of the note its own level, timing and grit: in-tune subharmonic growl, rattle and fry on every note | Bass | ≈ 71 ms | [Guide](docs/knurl/README.md) · [Changes](docs/knurl/CHANGELOG.md) |
+
+Plugins with latency report it to the host, so FL Studio compensates the delay.
+Anvil, Lathe, Temper and Knurl detect pitch from the audio. They can also take the
+pitch from MIDI.

 The names come from metalwork: a **rivet** joins pieces; **patina** changes a
-surface while leaving its character. They share a Rust foundation and keep
-their own musical purpose, code, documentation, and version.
+surface and keeps its character; an **anvil** is the solid base that everything
+is struck on; a **crucible** melts material down to be cast again; a **lathe**
+turns a piece so each cut lands the same all the way round; **tempering** sets
+how hard and how tough a metal ends up; a **weld** fuses two pieces into one;
+**knurling** presses a ridged grip pattern into a surface.
+The suite is the **foundry**: the workshop where the bass gets cast, shaped and
+finished. Hosts list the plugins under the vendor name *Bass Foundry*.
+
+## Editors
+
+<table>
+  <tr>
+    <td width="50%"><a href="docs/rivet/README.md"><img src="docs/rivet/assets/editor.png" alt="Rivet editor"></a><br><b>Rivet</b>: storyboard composition</td>
+    <td width="50%"><a href="docs/patina/README.md"><img src="docs/patina/assets/editor.png" alt="Patina editor"></a><br><b>Patina</b>: resonance smoothing</td>
+  </tr>
+  <tr>
+    <td><a href="docs/anvil/README.md"><img src="docs/anvil/assets/editor.png" alt="Anvil editor"></a><br><b>Anvil</b>: sub anchor</td>
+    <td><a href="docs/crucible/README.md"><img src="docs/crucible/assets/editor.png" alt="Crucible editor"></a><br><b>Crucible</b>: resampler</td>
+  </tr>
+  <tr>
+    <td><a href="docs/lathe/README.md"><img src="docs/lathe/assets/editor.png" alt="Lathe editor"></a><br><b>Lathe</b>: harmonic EQ</td>
+    <td><a href="docs/temper/README.md"><img src="docs/temper/assets/editor.png" alt="Temper editor"></a><br><b>Temper</b>: tracked distortion</td>
+  </tr>
+  <tr>
+    <td><a href="docs/weld/README.md"><img src="docs/weld/assets/editor.png" alt="Weld editor"></a><br><b>Weld</b>: layer phase alignment</td>
+    <td><a href="docs/knurl/README.md"><img src="docs/knurl/assets/editor.png" alt="Knurl editor"></a><br><b>Knurl</b>: cycle texture</td>
+  </tr>
+</table>
+
+The previews are rendered headless from the real editor code by
+`tools/editor-check`, so they match what the plugin draws.

 ## Install

-Download the desired plugin's Windows ZIP from its Gitea release. Extract it
-and copy `Rivet.clap` or `Patina.clap` into:
+1. Open the plugin's release on Gitea. Every plugin has its own release tag,
+   for example `lathe-v0.1.0`.
+2. Download `<plugin>-windows-x86_64-<version>.zip`. You can check it against
+   the `.zip.sha256` file next to it.
+3. Extract the ZIP and copy the `.clap` file into:

-```text
-C:\Program Files\Common Files\CLAP\
+   ```text
+   C:\Program Files\Common Files\CLAP\
+   ```
+
+4. In FL Studio 2024.1 or newer, open **Options → Manage plugins**, enable
+   **Verify plugins**, and click **Find installed plugins**.
+5. Load Rivet in the Channel Rack. Load the other plugins in mixer effect slots.
+
+Keep the font license (`licenses/`) with redistributed packages.
+
+Every branch and pull-request pipeline also builds a combined Windows preview
+ZIP, `bass-foundry-windows-x86_64.zip`, in its **windows** job. Use it to test unreleased changes.
+
+> **Upgrading from an earlier build?** The CLAP IDs changed from
+> `io.storyboard.*` to `io.narl.bass-foundry.<product>`, so hosts see each
+> plugin as new. Delete the old `.clap` files, rescan, and add the plugins again
+> in existing projects. Motif Storyboard and Resonance Compressor are now Rivet
+> and Patina, and the vendor is "Bass Foundry".
+
+## Build from source
+
+You need:
+
+- Rust stable and Python 3.11 or newer.
+- For the Windows target on Linux: the `x86_64-pc-windows-gnu` Rust target and
+  MinGW (`x86_64-w64-mingw32-gcc`).
+- For the native wrapper tests on Linux: pkg-config and the X11/XCB and OpenGL
+  development headers. Rivet's optional standalone also needs ALSA/JACK headers.
+
+```sh
+# Tests for all engines, editors and tools
+cargo test --workspace --locked
+
+# Formatting, tests and lints for one product, including its CLAP wrapper
+python3 scripts/check-plugin.py --plugin lathe
+
+# Windows build, then the ZIPs (all plugins, or --plugin <name>)
+python3 scripts/build-plugin.py --plugin lathe --target x86_64-pc-windows-gnu
+python3 scripts/package-windows.py
+
+# Headless editor preview
+cargo run --manifest-path tools/editor-check/Cargo.toml -- target/editor/lathe.png --plugin lathe
 ```

-In FL Studio 2024.1 or newer, open **Options → Manage plugins**, enable
-**Verify plugins**, and **Find installed plugins**. Load Rivet in the Channel Rack;
-load Patina in a mixer effect slot.
+Plugin names for the scripts are `rivet`, `patina`, `anvil`, `crucible`,
+`lathe`, `temper`, `weld` and `knurl`. Builds go to `dist/<target>/<Name>.clap`. No
+script installs anything into a DAW. [Development and testing](docs/development.md)
+has the full command list.

-Normal branch/PR pipelines also provide a combined Windows preview ZIP in the
-**windows** job. Releases are separate: `rivet-v0.3.0` and `patina-v0.1.0`
-publish independently. See [release workflow](docs/releases.md).
+## Quality checks

-These names replace Motif Storyboard and Resonance Compressor. Their CLAP IDs
-and saved-state identifiers are preserved; replace old scanned copies and rescan.
+Every push and pull request runs these checks in CI
+(`.gitea/workflows/check.yml`):
+
+- **Engine tests.** Every engine has tests for its signal behaviour and latency
+  against measured targets.
+- **Realtime safety.** Every audio effect has a test that fails if the audio
+  thread allocates memory.
+- **Host tests.** Each wrapper is loaded through the exported CLAP ABI, without
+  a DAW. The tests check the ports, the reported latency, state save and load,
+  and processing at 44.1, 48 and 96 kHz.
+- **Lints.** `rustfmt` and `clippy -D warnings` for every package and wrapper.
+- **Editor previews.** All editors are rendered headless and kept as CI
+  artifacts.
+- **Windows builds.** Every `.clap` is cross-compiled and packaged.
+
+Release ZIPs are deterministic and contain checksums for every file. Things CI
+cannot check stay manual: FL Studio routing, native window behaviour, and
+listening.

 ## Repository

 ```text
 plugins/
-  catalog.json         Product metadata used by build and release tools
-  rivet/
-    core/              Motifs, harmony, variation, history, performance
-    midi/              Standard MIDI import/export
-    app/               Worker jobs and real-time audition control
-    preview/           Offline MIDI/WAV development tool
-    plugin/            CLAP wrapper, editor, optional standalone
-  patina/
-    core/              Spectral detector and attenuation engine
-    ui/                Shared native editor and embedded fonts
-    render/            Offline WAV evaluation
-    plugin/            CLAP audio-effect wrapper
-tools/editor-check/    Headless visual QA for both editors
-scripts/               Shared build, packaging, release, and analysis tools
-docs/rivet/            Rivet guide, theory, research, and editor previews
-docs/patina/           Patina guide, research, and editor preview
-references/            Local reference audio; excluded from distribution
+  catalog.json         Product metadata for the build, check and release tools
+  rivet/               core · midi · app · preview · plugin
+  patina/              core · ui · render · plugin
+  anvil/               core · ui · plugin
+  crucible/            core · ui · plugin
+  lathe/               core · ui · plugin
+  temper/              core · ui · plugin
+  weld/                core · ui · plugin
+  knurl/               core · ui · plugin
+  common/
+    ui/                Shared look: palette, embedded fonts, knobs, panels, meters
+    dsp/               Shared filters, pitch tracking, oversampling, meters, WAV files
+tools/editor-check/    Headless editor renderer for visual QA
+scripts/               Build, check, packaging, release and analysis tools
+docs/<plugin>/         Guide, changelog and editor preview for each plugin
+docs/ideas.md          Problems in bass-music production and the plugin ideas for them
+references/            Local reference audio; never distributed
+website/               The fl.narl.io site: Astro, nginx container, reads catalog and previews
 ```

-The root Cargo workspace contains the engines and supporting tools. Each CLAP
-wrapper has an independent workspace and lockfile so SDK dependencies stay
-separate. [Development and testing](docs/development.md) covers the commands.
+Each product follows the same split:

-```sh
-cargo test --workspace --locked
-python scripts/build-plugin.py --plugin rivet --target x86_64-pc-windows-gnu
-python scripts/build-plugin.py --plugin patina --target x86_64-pc-windows-gnu
-python scripts/package-windows.py
-```
+- `core` is the engine. It is plain Rust, does not depend on a plugin SDK, and
+  is tested on its own.
+- `ui` is the egui editor, built on `common-ui`.
+- `plugin` is the CLAP wrapper on a pinned NIH-plug revision.

-Windows is the release target. Linux remains useful for tests, cross-compilation,
-and headless editor previews. FL Studio routing, native window behavior, and
-artistic listening still require manual checks in the target setup.
+The root Cargo workspace holds the engines, editors and tools. Each wrapper is
+its own workspace with its own lockfile, so SDK dependencies stay separate.
+`plugins/catalog.json` is the single list of products. The scripts and CI read
+it, so adding a plugin starts there.
+
+## Releases
+
+Each plugin is versioned and released on its own. Its version is the `version`
+in `plugins/<plugin>/plugin/Cargo.toml`. A tag `<plugin>-v<version>`, for example
+`temper-v0.1.0`, starts the release workflow. The workflow builds, checks and
+publishes that plugin's Windows ZIP to a Gitea release. See
+[docs/releases.md](docs/releases.md).
+
+## Roadmap
+
+[docs/ideas.md](docs/ideas.md) lists the production problems the suite targets,
+the released plugins and the ideas for the next ones.
+
+## License
+
+ISC, see [LICENSE](LICENSE). The embedded Roboto Condensed fonts are under the
+SIL Open Font License ([OFL.txt](plugins/common/ui/assets/OFL.txt)).
@@ -0,0 +1,19 @@
+# Anvil changelog
+
+## 0.2.0
+
+- Change the CLAP ID to `io.narl.bass-foundry.anvil`. Hosts see this as a new
+  plugin: delete the old `.clap` file, rescan, and add the plugin again in
+  existing projects.
+
+## 0.1.0
+
+- Introduce Anvil, a sub anchor for bass music.
+- Replace the band below Split with a clean mono sine. Every note gets the same
+  peak level and starts at the same phase, so switch-ups and kick hits line up.
+- Detect pitch and note starts from the audio with 80 ms lookahead, or follow
+  MIDI notes sent to the effect.
+- Controls: Sub level, Split, Dynamics, Drive, Octave, Glide, Phase, Gate, Keep,
+  Output, Retrigger, Snap to semitone, Bypass. Solo sub monitors only the new sub.
+- Note readout, level meters and an oscilloscope of the original low band against
+  the new sub.
@@ -0,0 +1,62 @@
+# Anvil
+
+Anvil gives every bass note the same solid sub. Current version **0.1.0**.
+
+In riddim and dubstep, each switch-up patch brings its own sub: a different level,
+a different phase, sometimes two layers that cancel. The drop's weight jumps from
+note to note and the kick lands differently on each one. Anvil removes the
+original band below **Split** and puts a clean mono sine in its place. The sine
+follows the bass pitch, has the same peak level on every note, and starts at the
+same phase on every note.
+
+![Anvil](assets/editor.png)
+
+## Install on Windows
+
+Copy `Anvil.clap` into `C:\Program Files\Common Files\CLAP\`. In FL Studio 2024.1
+or newer, open Options → Manage plugins, enable Verify plugins, and Find installed
+plugins. Load Anvil in the mixer slot of the bass bus. Keep the font license with
+redistributed packages.
+
+## Work with it
+
+1. Put Anvil on the bass bus, after the sound design and before the bus
+   compression or clipping.
+2. Set **Split** just above the sub. 80–100 Hz suits most riddim basses.
+3. Set **Sub level** once. Every patch on the bus now gets this level.
+4. Use **Phase** to line the start of each note up with your kick. With
+   **Retrigger** on, every note starts at this phase.
+5. Turn on **Solo sub** to hear only the new sub; the scope shows the original
+   low band (grey) against the new sub (accent).
+
+Other controls:
+
+- **Dynamics** at 0 % holds the level for the whole note. Raise it to let the sub
+  follow the original's volume shape, for example a wobble.
+- **Drive** adds upper harmonics so the sub reads on phones and laptops.
+- **Octave** moves the sub against the detected note. Use −1 for a bass played
+  one octave up.
+- **Glide** slides between overlapping notes; 0 jumps.
+- **Gate** is the input level that counts as a note. Raise it if tails or reverb
+  start new notes.
+- **Keep** blends some of the original low band back under the new sub.
+- **Snap to semitone** rounds detected pitch. Turn it off for pitch bends and slides.
+
+### Pitch from MIDI
+
+Detection follows the audio by default. For heavy formant or FM basses where the
+fundamental is unclear, select **MIDI** and route the bass's MIDI notes to Anvil.
+In FL Studio, set the bass channel's MIDI output port and Anvil's input port to the
+same number, or duplicate the notes into a pattern on a channel that feeds Anvil.
+
+## Timing and limits
+
+Detection uses 80 ms of lookahead, reported to the host for delay compensation,
+so each note's pitch is known before its attack leaves the plugin. Pitch range is
+25–250 Hz, one voice: chords and layered notes in the sub band are not separated.
+Notes shorter than about 15 ms may not be recognised. A pitch move of more than
+0.7 semitone that holds for two analysis hops (10 ms) starts a new note.
+
+The crossover is a 4th-order Linkwitz–Riley pair, so with Keep at 100 % and no
+note playing, the signal passes with flat magnitude. Stereo above the split is
+kept; the new sub is mono.
@@ -0,0 +1,19 @@
+# Crucible changelog
+
+## 0.2.0
+
+- Change the CLAP ID to `io.narl.bass-foundry.crucible`. Hosts see this as a new
+  plugin: delete the old `.clap` file, rescan, and add the plugin again in
+  existing projects.
+
+## 0.1.0
+
+- Introduce Crucible, a resampler that always records its input.
+- Capture the newest 1–16 complete bars on the host's bar grid, or the newest
+  audio when the transport is stopped. Tempo changes inside a take are followed.
+- Slice on a straight or triplet grid, or at transients. Add and remove cuts by
+  hand, include or exclude slices, and audition them in place.
+- Clean every slice: trim leading silence, fade both ends, normalise to −0.3 dBFS.
+  The root note of each pitched slice is detected and written into the file.
+- Export the loop, every slice, and optionally a 2048-sample wavetable for Serum
+  and Vital into a dated folder.
@@ -0,0 +1,60 @@
+# Crucible
+
+Crucible melts the bars you just played into ready-to-use samples. Current version
+**0.1.0**.
+
+Resampling is the core loop of riddim sound design: bounce, open in Edison, chop,
+trim, declick, normalise, find the key, name, save, load into a sampler. Crucible
+does all of it from one button. It always records its input, so the take you
+liked is already there when you press **Capture**.
+
+![Crucible](assets/editor.png)
+
+## Install on Windows
+
+Copy `Crucible.clap` into `C:\Program Files\Common Files\CLAP\`. In FL Studio
+2024.1 or newer, open Options → Manage plugins, enable Verify plugins, and Find
+installed plugins. Load Crucible in a mixer slot at the end of the chain you want
+to resample. Keep the font license with redistributed packages.
+
+## Work with it
+
+1. Play the pattern or song section.
+2. Choose **Bars** (1–16) and press **Capture**. Crucible takes the newest complete
+   bars on FL's bar grid. With the transport stopped, it takes the newest audio at
+   the last known tempo instead.
+3. Choose how to slice: **Grid** (1/4, 1/8, 1/16, 1/8T, 1/16T) or **Transients**
+   with a Sensitivity. Double-click the waveform to add a cut, right-click to remove
+   the nearest one.
+4. Click a slice to hear it. Untick **Export** to leave it out.
+5. Press **Export**.
+
+Each export creates a folder named after the date, time and tempo, holding:
+
+- `loop.wav`: the whole take, for Slicex or Edison;
+- `s01_F1.wav`, `s02_G#1.wav`, …: one file per slice, named by its detected root
+  note. The root is also stored in the file's sampler chunk;
+- `wavetable.wav` when **Wavetable** is on: up to 256 single-cycle frames of 2048
+  samples from the selected slice. Each frame starts on a rising zero crossing, so
+  frames morph without phase jumps. Serum reads the frame size from the file; in
+  Vital, import it as a wavetable with 2048-sample frames.
+
+Every slice is cleaned on export: **Trim silence** removes leading silence below
+−60 dBFS, **Declick** fades both ends (default 2 ms), **Normalize** peaks it at
+−0.3 dBFS. Files are 32-bit float WAV at the session rate.
+
+Add the export folder to FL's browser once (Options → File settings → Browser extra
+search folders). New exports then appear there and can be dragged into channels,
+the playlist or Edison. **Open folder** shows the latest export in Explorer.
+
+## Timing and limits
+
+Crucible adds no latency and passes audio through untouched. Auditioned slices are
+mixed into its output only while they play. The history holds 72 s, enough for
+16 bars at 60 BPM. The newest eight takes stay in memory until the plugin is
+removed; they are not saved with the project, so export what you want to keep.
+
+Bar alignment follows the host's song position and time signature. Root notes are
+detected between 35 Hz and 1 kHz. Unpitched slices, such as drums or noise, get
+no note in their name. Transient slicing finds hits that rise out of quieter
+audio; for legato basses, slice on the grid.
@@ -1,93 +1,158 @@
 # Development

-Run commands from the repository root. Rust stable and Python **3.11 or newer**
-are required. Lockfiles are committed for the core workspace, both CLAP wrappers,
-and the headless editor tool.
+Run commands from the repository root. You need Rust stable and Python **3.11 or
+newer**. Lockfiles are committed for the root workspace, every CLAP wrapper and
+the headless editor tool. Use `--locked` so a build never changes them silently.

 ## Product boundaries

-The catalog in [plugins/catalog.json](../plugins/catalog.json) defines product
-names, wrapper manifests, documentation, internal packages, and distribution
-licenses. Shared build/check/release tools consume it. Each wrapper's Cargo
-package version is the authoritative release version.
+[plugins/catalog.json](../plugins/catalog.json) is the single list of products.
+For each product it defines the display name, the wrapper manifest, the library
+name, the documentation folder, the CLAP ID, the internal packages and the
+licenses to ship. The build, check, package and release scripts and the script
+tests read it. The version in each wrapper's `Cargo.toml` is the release version.

-The root workspace contains Rivet's core, MIDI, application, and offline preview
-crates, plus Patina's core, editor, and renderer. Wrappers under
-`plugins/<product>/plugin/` remain independent workspaces because they depend on
-a pinned NIH-plug Git revision. Their host identities and persistence stay separate.
+Every product has the same split:
+
+| Folder | Content | Workspace |
+| --- | --- | --- |
+| `plugins/<product>/core/` | Engine. Plain Rust, no plugin SDK, tested on its own | root |
+| `plugins/<product>/ui/` | egui editor, built on `common-ui` | root |
+| `plugins/<product>/plugin/` | CLAP wrapper on a pinned NIH-plug revision | own |
+
+Rivet has more crates in the root workspace (`midi`, `app`, `preview`), and
+Patina has `render` for offline WAV evaluation. The shared crates are:
+
+- `common-ui`: palette, embedded fonts, header, panels, knobs, meters.
+- `common-dsp`: filters, YIN pitch tracking, the note tracker used by Anvil,
+  Lathe, Temper and Knurl, 4× oversampling, meters and WAV files.
+
+The wrappers stay separate workspaces, each with its own lockfile, so the
+NIH-plug Git dependency stays out of the root workspace. Host identities and
+saved state are separate for every product.
+
+The engines run allocation-free on the audio thread. Analysis that is too heavy
+for the audio thread (Rivet's generation jobs, Weld's cross-spectrum and fit) runs on a worker
+thread. Data goes to the editor through lock-free queues.

 ## Checks

 ```sh
 cargo test --workspace --locked
 cargo clippy --workspace --all-targets --locked -- -D warnings
-python scripts/check-plugin.py --plugin rivet
-python scripts/check-plugin.py --plugin patina
-python -m unittest discover -s scripts/tests -v
+python3 scripts/check-plugin.py --plugin <product>
+python3 -m unittest discover -s scripts/tests -v
 ```

-The product check script checks formatting, tests, and lints that product's
-packages and wrapper without compiling the other plugin. Offline builds work
-once dependencies are cached; append `--offline` to manual Cargo commands.
+Products: `rivet`, `patina`, `anvil`, `crucible`, `lathe`, `temper`, `weld`,
+`knurl`.

-Native wrapper tests on Linux require pkg-config, X11/XCB, and OpenGL development
-headers. Rivet's optional standalone also needs ALSA/JACK headers. Gitea installs
-the headers needed by its check jobs.
+`check-plugin.py` runs formatting, tests and clippy for one product's packages
+and its wrapper, without compiling the other products. Run it for every product
+when you change a shared crate or the root workspace. Offline builds work once
+the dependencies are cached; add `--offline` to manual Cargo commands.
+
+The test types are:
+
+- **Engine tests** (`core/tests/dsp.rs` and similar) measure signal behaviour
+  and latency against fixed targets.
+- **Realtime tests** (`core/tests/realtime.rs`) install a counting allocator
+  and fail if the audio-thread path allocates.
+- **Host tests** (`plugin/tests/host.rs`) load the wrapper through the exported
+  CLAP ABI without a DAW. They check the ports, latency, state save and load,
+  and processing at 44.1, 48 and 96 kHz with odd block sizes.
+- **Script tests** (`scripts/tests/`) cover the catalog, release planning,
+  packaging and the publish client with fake transports. They also fail when a
+  catalog product is missing from a CI workflow.
+
+The native wrapper tests on Linux need pkg-config and the X11/XCB and OpenGL
+development headers. Rivet's optional standalone also needs ALSA/JACK headers.
+The Gitea check jobs install these headers.

 ## Windows builds

-On Windows, install Rust and the MSVC build tools. For Linux cross-compilation,
-install the Rust `x86_64-pc-windows-gnu` target and MinGW's
-`x86_64-w64-mingw32-gcc`.
+On Windows, install Rust and the MSVC build tools. To cross-compile on Linux,
+install the Rust `x86_64-pc-windows-gnu` target and MinGW
+(`x86_64-w64-mingw32-gcc`).

 ```sh
-python scripts/build-plugin.py --plugin rivet --target x86_64-pc-windows-gnu
-python scripts/build-plugin.py --plugin patina --target x86_64-pc-windows-gnu
-python scripts/package-windows.py
-python scripts/package-windows.py --plugin rivet
-python scripts/package-windows.py --plugin patina
+python3 scripts/build-plugin.py --plugin <product> --target x86_64-pc-windows-gnu
+python3 scripts/package-windows.py                    # combined preview ZIP
+python3 scripts/package-windows.py --plugin <product> # one product's release ZIP
 ```

-Build outputs use `dist/<target>/Rivet.clap` and `Patina.clap`, with docs and
-licenses retaining their directory structure. `CARGO_TARGET_DIR` is supported
-for sharing compilation between wrappers. MSVC packaging accepts
+Builds go to `dist/<target>/<Name>.clap`, with the docs and licenses in the same
+folder structure. `CARGO_TARGET_DIR` is supported for sharing one build
+directory between wrappers. MSVC packaging accepts
 `--target x86_64-pc-windows-msvc`.

-The combined ZIP is `dist/rivet-patina-windows-x86_64.zip`. Individual ZIPs use
-`<product>-windows-x86_64-<version>.zip`. Each ZIP has internal file checksums and
-an external `.zip.sha256`. ZIP metadata is deterministic; binaries still depend
-on the toolchain and build environment. Packaging includes only selected catalog
-entries, never old binaries left in `dist`.
+- The combined ZIP is `dist/bass-foundry-windows-x86_64.zip`. It holds every
+  product that has been built.
+- A product ZIP is `<product>-windows-x86_64-<version>.zip` and holds only that
+  product.

-Linux builds remain available for local development; CI produces Windows release
-binaries only. Neither build nor packaging installs plugins into a DAW.
+Every ZIP has a `SHA256SUMS` file inside and a `.zip.sha256` file next to it.
+ZIP metadata is deterministic; the binaries still depend on the toolchain and
+the build environment. Packaging takes only the selected catalog entries, never
+old binaries left in `dist`.
+
+Linux builds are for local development; CI produces only Windows binaries. No
+script installs a plugin into a DAW.

 ## Editor previews

 ```sh
-cargo run --manifest-path tools/editor-check/Cargo.toml -- /tmp/rivet.png --plugin rivet
-cargo run --manifest-path tools/editor-check/Cargo.toml -- /tmp/rivet-creative.png --plugin rivet --creative
-cargo run --manifest-path tools/editor-check/Cargo.toml -- /tmp/patina.png --plugin patina
-cargo run --manifest-path tools/editor-check/Cargo.toml -- /tmp/patina-compact.png --plugin patina --compact
+mkdir -p target/editor
+cargo run --manifest-path tools/editor-check/Cargo.toml -- target/editor/<product>.png --plugin <product>
+cargo run --manifest-path tools/editor-check/Cargo.toml -- target/editor/rivet-creative.png --plugin rivet --creative
+cargo run --manifest-path tools/editor-check/Cargo.toml -- target/editor/patina-compact.png --plugin patina --compact
 ```

-Patina also accepts `--silent`, `--delta`, and `--bypass` as render fixtures.
-The tool compiles actual editor code and software-renders without a display.
-These checks do not establish native host embedding, keyboard routing, or audible
-artistic quality. Use the product guides for FL Studio acceptance checks.
+Patina also accepts `--silent`, `--delta` and `--bypass`. The tool compiles the
+real editor code, feeds it synthetic analysis data and renders it in software
+without a display. Copy a checked render to `docs/<product>/assets/editor.png`
+to update the guide. These renders do not prove native host embedding, keyboard
+routing or how the plugin sounds; use the FL Studio checks in each product guide.
+
+## Add a product
+
+1. Create `plugins/<product>/{core,ui,plugin}`. Copy the wrapper `Cargo.toml`
+   and `Cargo.lock` of a similar product so the NIH-plug revision matches.
+2. Add `core` and `ui` to the root `members`, the wrapper to `exclude`, and a
+   `[profile.dev.package.<product>-core] opt-level = 2` entry if the tests run
+   heavy DSP.
+3. Add the product to `plugins/catalog.json` with a new, unique CLAP ID.
+4. Add it to `.gitea/workflows/check.yml` (check matrix, editor preview,
+   Windows build) and to the tag list in `release.yml`. The script tests fail
+   until you do.
+5. Add a `--plugin <product>` fixture to `tools/editor-check`.
+6. Write `docs/<product>/README.md`, `CHANGELOG.md` and `assets/editor.png`, and
+   add the product to the root README.

 ## Compatibility and naming

-| Product | Former display name | Preserved CLAP ID |
+The suite is called **Bass Foundry**; this is the vendor name hosts show. Hosts
+identify plugins by CLAP ID, so the vendor name does not affect saved projects.
+
+| Product | Former display name | CLAP ID |
 | --- | --- | --- |
-| Rivet | Motif Storyboard | `io.storyboard.motif` |
-| Patina | Resonance Compressor | `io.storyboard.resonance-compressor` |
+| Rivet | Motif Storyboard | `io.narl.bass-foundry.rivet` |
+| Patina | Resonance Compressor | `io.narl.bass-foundry.patina` |
+| Anvil | (new) | `io.narl.bass-foundry.anvil` |
+| Crucible | (new) | `io.narl.bass-foundry.crucible` |
+| Lathe | (new) | `io.narl.bass-foundry.lathe` |
+| Temper | (new) | `io.narl.bass-foundry.temper` |
+| Weld | (new) | `io.narl.bass-foundry.weld` |
+| Knurl | (new) | `io.narl.bass-foundry.knurl` |

-Rivet retains `story-session-v1` and its session migration support; Patina retains
-all parameter IDs. No JSON/state migration is introduced by the rename. These
-historical identifiers and copyright notices intentionally remain in source.
-Replace old scanned plugin files before rescanning, rather than keeping duplicate
-CLAP IDs installed. Verify existing-project recall in FL Studio.
+CLAP IDs use the form `io.narl.bass-foundry.<product>`. Builds tagged before
+this scheme used `io.storyboard.*` IDs; hosts treat the new IDs as different
+plugins, so projects saved with those builds need the plugin added again. From now on an ID is frozen: if a product is renamed, its CLAP ID
+stays. A new plugin gets `io.narl.bass-foundry.<slug>` with its product slug.

-See [release workflow](releases.md) for tagged publishing. Actual Gitea runner
-execution and FL Studio validation remain separate from local checks.
+Rivet keeps `story-session-v1` and its session migration. Patina keeps all
+parameter IDs. The copyright notice keeps its original holder name. Delete old
+plugin files before rescanning, so FL Studio does not list both builds.
+
+See [releases](releases.md) for tagged publishing. Runs on the real Gitea runner
+and checks in FL Studio are separate from the local checks.
@@ -0,0 +1,202 @@
+# Plugin ideas
+
+A running list of plugin ideas for riddim, dubstep and bass-music sound design.
+Each entry names the problem first. Entries are grouped as released or idea. Names follow the metalwork theme of the Bass Foundry suite.
+
+## Problems seen in bass-music production
+
+1. Every bass patch brings its own sub level and phase, so the weight of a drop
+   jumps between switch-ups, and layered patches cancel in the sub.
+2. Patches at the same peak level still differ in perceived loudness and
+   brightness. The usual fix is hand-set gain or clipping per patch.
+3. Resampling is repetitive: bounce, chop, trim, declick, normalise, find the
+   root key, name, save, load into a sampler.
+4. Writing wobbles: LFO shapes are drawn, synced, copied and edited for every
+   variation. Triplet and dotted patterns plus per-note changes take long.
+5. Unison, OTT and stereo distortion widen the mids. Parts disappear in mono or
+   on club systems.
+6. Kick and bass clash. Sidechain helps, but the sub phase at each note start
+   changes how the kick hits.
+7. Distortion chains build up harsh resonances. (Patina covers this.)
+8. Comparing a drop with a reference: the difference is usually sub/mid balance
+   over time, which generic meters do not show clearly.
+9. Fixed-frequency tools act differently on every note. An EQ boost at 300 Hz
+   lifts the 4th harmonic of one note and the 7th of another; a distortion with
+   a fixed tone filter sounds brighter on low notes than on high notes.
+10. Layered bass patches partly cancel in the mids, not only in the sub.
+11. Texture makes a riddim patch: grit, rattle, metal, vowel, noise. It takes long
+    chains (distortion, comb, formant, OTT, resample, repeat), and the result
+    changes from note to note.
+12. Grit and tone cannot be shaped separately. More distortion for more grit
+    also changes the body, the level and the low end.
+13. Resampled textures sound printed: a loop of one moment, with no movement
+    inside the note.
+14. Texture changes inside a note (the switch-up within one held note) need
+    automation lanes or chopping.
+15. There is no meter for texture. Two switch-ups can sound "the same" without
+    a clear reason, and generic analysers show only level and spectrum.
+
+## Released
+
+### Anvil — sub anchor (problems 1, 6)
+
+Replaces the band below a split frequency with a clean mono sine that follows
+the bass pitch, at one level and one start phase for every note. Pitch comes
+from detection with 80 ms lookahead or from MIDI. See [Anvil](anvil/README.md).
+
+### Crucible — resampler (problem 3)
+
+Records the input continuously. One click captures the last bars on the host
+bar grid, slices on a grid or on hits, trims, declicks, normalises, detects the
+root key and exports labelled WAVs, a full loop and an optional Serum/Vital
+wavetable. See [Crucible](crucible/README.md).
+
+### Lathe — harmonic EQ (problem 9)
+
+EQ bands placed on harmonics 1–32 of the detected note instead of fixed
+frequencies. "+4 dB on harmonic 3, −6 dB on harmonic 7" sounds the same on F1
+and on C2. Odd/even balance, tilt over harmonic number, and a Focus control
+that lifts or cuts everything between the harmonics. Uses Anvil's pitch
+tracker, or MIDI. See [Lathe](lathe/README.md).
+
+### Temper — note-tracked distortion (problem 9)
+
+A waveshaper whose tone filters before and after the shaper follow the note, so
+every note distorts with the same character and the same harmonic content.
+Input level is normalised before the shaper, so drive does not depend on how
+loud the patch is, and the output is gain-matched. Oversampled to keep aliasing
+(which is never harmonic) out. See [Temper](temper/README.md).
+
+### Weld — layer phase alignment (problem 10)
+
+Takes a second bass layer through the sidechain. It fits polarity and a chain
+of up to four allpass sections to the measured cross-spectrum (no added
+delay), so the layers sum instead of cancel. A display shows how much level the
+cancellation cost and how much Weld recovered. Anvil solves the sub band; Weld
+solves the mids. See [Weld](weld/README.md).
+
+### Knurl — cycle texture (problems 11, 13)
+
+Follows the played note and treats every cycle on its own: a repeating level
+pattern (in-tune subharmonics), random level and timing per cycle, and a noise
+burst per cycle tuned to the note. Amounts are counted in cycles, so the texture
+is the same on every note. Slow per-harmonic drift is postponed. See
+[Knurl](knurl/README.md).
+
+## Ideas
+
+### Ballast — switch-up loudness leveller (problem 2)
+
+Measures short-term perceived loudness per note or per switch-up against a
+target or a reference patch and adjusts gain only, so each switch-up lands at
+the same loudness without compression changing its character. Earlier working
+name: Hit Leveler. Pairs with Anvil: Anvil levels the sub, Ballast the whole
+patch.
+
+### Bellows — pitch-tracked resonator
+
+A comb or Karplus-style resonator tuned to the detected note. It turns noise,
+distortion or drums into pitched metallic tone that is in key on every note.
+Damping, harmonic spread, single or multiple combs.
+
+### Gauge — low-end mono check (problem 5)
+
+Shows phase correlation and mono-sum loss per band and per note in the bass
+range, and marks the notes where widening breaks the mono sum. Optional fixes:
+mono below a chosen frequency and phase rotation on the mids. Display-first, so
+it is a small build. Earlier working name: Bass Mono Check.
+
+### Wobble sequencer (problem 4)
+
+Step patterns for volume, filter, formant and pitch with triplet and dotted
+grids built in. Each MIDI note selects a different pattern, so a switch-up is a
+different note in the piano roll. ShaperBox overlaps, but it has no note-keyed
+patterns. No name yet.
+
+### Drop compare (problem 8)
+
+Loudness-matched A/B of a drop against a reference, with sub, low-mid, mid and
+high energy over time: for example "your sub is 3 dB under the reference in
+bars 2–4". No name yet.
+
+## Texture ideas
+
+These ideas target problems 11–15; Knurl, the first of them, is released above.
+Most of them reuse the note tracker in
+`common-dsp`, so a texture setting means the same thing on every note, the same
+way Lathe and Temper work.
+
+### Anneal — tone and grit split (problem 12)
+
+Annealing changes how a metal behaves without changing its shape. Anneal
+splits the signal into three parts: the harmonic part (energy on the harmonics
+of the tracked note), the residual noise and grit between the harmonics, and
+the transients. Each part has a level fader, a drive and a tilt.
+
+- Turn the grit up 6 dB and keep the body and the sub unchanged.
+- Take all the grit out of a layer and leave a clean tone for further design.
+- Listen to each part solo, or send the grit to a second output for its own
+  chain.
+
+DSP: an STFT with the note tracker; harmonic masks at k·f0, with a width that
+follows the pitch; a transient mask from spectral flux. Latency is one FFT
+frame. The display shows the three parts in different colours on Lathe's
+harmonic strip.
+
+### Swarf — in-key granular shavings (problems 11, 13)
+
+Swarf is the shavings that machining leaves. Swarf records the bass itself and
+sprays short grains of it back as a layer. Grain lengths are whole pitch
+periods, and every grain is retuned to the note playing now, so the shredded
+layer stays in key across a riddim line. Controls are density, spray (position
+spread back in time), grain size in cycles, reverse probability, and a
+harmonic-only filter for the layer. It is useful for the "shredded metal" top
+layer, and works on a resample from Crucible as well.
+
+### Etch — texture imprint (problem 11)
+
+Etching transfers a pattern onto metal with acid. Etch takes a texture source
+through the sidechain or from a loaded sample (a metal scrape, a vocal, a field
+recording) and imprints its fine structure on the bass. The bass keeps its
+pitch and its harmonic levels; between and on the harmonics, the source's
+noise, roughness and movement come through. A "harmonic lock" mode samples the
+source's spectral envelope only at the bass harmonics, so the imprint is always
+in key. It differs from a vocoder: a vocoder transfers the envelope, and Etch
+transfers the surface.
+
+### Chase — talking formants that hit harmonics (problems 11, 14)
+
+Chasing shapes metal by hammering it from the front. Chase is a formant filter
+with a 2D vowel pad (a, e, i, o, u, plus "yoi" and "wub" shapes). You draw a
+path over the pad and sync it to the tempo, or let each MIDI note select a path.
+The formants stay in Hz, so a vowel stays a vowel on every note. A **snap**
+control moves each resonant peak onto the nearest harmonic of the tracked
+note, so a narrow formant never falls into the gap between two harmonics and
+vanishes on some notes. Gain-matched, so a vowel change does not change the
+level.
+
+### Damascus — texture step sequencer (problem 14)
+
+Damascus steel is folded from layers into a visible pattern. Damascus holds up
+to four texture slots (for example a formant, a comb, a sample-rate reducer and
+a Knurl-type rattle) and a tempo-synced step grid that chooses a slot, or a mix
+of two, per step. Steps have their own crossfade time, so changes can be hard
+cuts or smears. Each slot is gain-matched, so the steps change texture and not
+level. Each MIDI note can select its own pattern, which is a texture switch-up
+inside one held note. This overlaps with the wobble sequencer above; both could
+become one plugin.
+
+### Loupe — texture meter (problem 15)
+
+A loupe is the lens used to inspect engraving. Loupe measures texture per note
+over time:
+
+- roughness and fluctuation strength (psychoacoustic models);
+- harmonic-to-noise ratio, which shows how gritty a sound is;
+- inharmonicity, which shows how metallic a sound is;
+- brightness relative to the note (harmonic centroid, not centroid in Hz).
+
+It places every switch-up of a drop as a point on a texture map. Two patches
+that sit on the same point are why a drop sounds repetitive. A reference track
+can be loaded for comparison. Display only, so it is a small build, and it fits
+with Gauge and Drop compare.
@@ -0,0 +1,20 @@
+# Knurl changelog
+
+## 0.2.0
+
+- Change the CLAP ID to `io.narl.bass-foundry.knurl`. Hosts see this as a new
+  plugin: delete the old `.clap` file, rescan, and add the plugin again in
+  existing projects.
+
+## 0.1.0
+
+- Introduce Knurl, texture per cycle of the played note.
+- Step patterns over 1–16 cycles make subharmonics in tune with every note:
+  Off, Double, Triple, Fry, Gallop, Stutter, or a drawn pattern.
+- Random level and timing per cycle, and a noise burst per cycle tuned to the
+  note (Tone, Position, Length), switchable per step.
+- Same every note or Free random sequences.
+- Detect pitch and note starts from the audio with about 71 ms of latency, or
+  follow MIDI notes sent to the effect.
+- Editor shows the last eight cycles overlaid and the pattern with the playing
+  step.
@@ -0,0 +1,86 @@
+# Knurl
+
+Knurl gives every cycle of the note its own level, timing and grit. Current
+version **0.1.0**.
+
+Knurling presses a ridged pattern into metal. Riddim and dubstep basses get their
+character the same way, from surface texture: rattle, growl, fry, grit. Usually
+that texture comes from long chains of distortion, comb filters, formants and
+resampling, and it changes from note to note. Knurl works on single cycles of the
+wave instead. It follows the played note and treats each cycle on its own, and
+every amount is counted in cycles, not in Hz or tempo. So the texture has the
+same grain on F1 and on C2.
+
+![Knurl](assets/editor.png)
+
+## Install on Windows
+
+Copy `Knurl.clap` into `C:\Program Files\Common Files\CLAP\`. In FL Studio 2024.1
+or newer, open Options → Manage plugins, enable Verify plugins, and Find installed
+plugins. Load Knurl in a mixer slot of the bass. Keep the font license with
+redistributed packages.
+
+## Work with it
+
+1. Play the bass. The note readout shows what Knurl tracks; the scope overlays
+   the last eight cycles of the output, so the texture is visible cycle by cycle.
+2. Choose a **Pattern**. The pattern sets the level of each cycle and repeats:
+   - **Double** (0, −9 dB): every second cycle quieter. This makes a sub-octave
+     growl, exactly in tune, about 8 dB under the fundamental.
+   - **Triple** (0, −12, −12 dB): a growl an octave and a fifth down.
+   - **Fry** (0, −14, −5, −14 dB, the default): an uneven vocal-fry rattle.
+   - **Gallop** and **Stutter**: rhythmic patterns over six and eight cycles.
+   - **Off**: every cycle at full level.
+3. Draw your own pattern on the bars: drag a bar to set the level of that cycle,
+   double-click to reset it. **Steps** sets the length (1–16 cycles).
+4. Add surface:
+   - **Level** gives every cycle a random level (standard deviation in dB).
+   - **Time** moves every cycle a little in time (percent of a period): rattle
+     and scrape.
+   - **Grit** adds a short noise burst inside every cycle. **Tone** sets its
+     lowest frequency in harmonics of the note, **Position** where in the cycle
+     it sits, and **Length** how long it is. The squares under the pattern bars
+     switch the burst per step.
+5. **Edge** sets how soft each step change is. Low values are sharper and
+   buzzier; high values smoother.
+
+**Random**: **Same every note** (default) restarts every random sequence at each
+note, so identical notes sound identical, which keeps a riddim line tight.
+**Free** lets the sequences run on, so every note differs.
+
+**Mix** blends with the delayed dry signal; **Output** trims the level.
+
+### Pitch from MIDI
+
+For basses whose fundamental is unclear (heavy FM, formant or noise patches),
+select **MIDI** and route the bass's MIDI notes to Knurl. In FL Studio, set the
+bass channel's MIDI output port and Knurl's input port to the same number.
+**Gate** sets the input level that counts as a note in AUDIO mode; **Snap to
+semitone** rounds the detected pitch (turn it off for slides).
+
+## Timing and limits
+
+Knurl delays the audio by about 71 ms: 67 ms of pitch-detection lookahead plus
+4 ms of room for the timing jitter. The delay is reported to the host for delay
+compensation, so the cycle clock knows every note before its attack leaves the
+plugin. The cycle clock restarts at every note start, so the pattern always
+begins with step 1 on the attack. Pitch range is 30–500 Hz, one note at a time.
+Between notes the effects fade out over 20 ms, so tails stay clean.
+
+Knurl works per cycle of the tracked pitch; it does not look for cycle borders in
+the waveform. With a stable pitch that is the same thing. With heavy pitch
+modulation inside a note the pattern follows the tracked pitch, which can lag a
+fast bend. Both channels get the same treatment, so the effect is mono-safe.
+
+## How it works
+
+A note tracker (shared with Anvil, Lathe and Temper) detects pitch and note
+starts ahead of the delayed audio. A cycle clock starts at 0 on every note and
+advances by f0 / sample rate. Each cycle gets its step gain and its random level
+and time offset from a hash of the cycle number, so the result is deterministic.
+Step changes are raised-cosine crossfades over the last **Edge** of a cycle;
+level jitter crossfades over half a cycle and time jitter over the whole cycle,
+read from the delay line with cubic interpolation. The grit is white noise
+through a state-variable highpass at **Tone** × f0, shaped by a sin² window and
+scaled to the input level. There is no nonlinearity, so no oversampling is
+needed.
@@ -0,0 +1,19 @@
+# Lathe changelog
+
+## 0.2.0
+
+- Change the CLAP ID to `io.narl.bass-foundry.lathe`. Hosts see this as a new
+  plugin: delete the old `.clap` file, rescan, and add the plugin again in
+  existing projects.
+
+## 0.1.0
+
+- Introduce Lathe, a harmonic EQ for bass sound design.
+- Bands sit on harmonics 1–32 of the played note instead of fixed frequencies,
+  so a cut on harmonic 3 stays on harmonic 3 on every note.
+- Draw a gain per harmonic; Tilt, Odd/Even and Between shape the whole series.
+- Detect pitch and note starts from the audio with 67 ms lookahead, or follow
+  MIDI notes sent to the effect. Filters retune at each note's attack.
+- Controls: Tilt, Odd/Even, Between, Width, Harmonics, Smooth, Gate, Mix,
+  Output, Snap to semitone, Bypass. Shapes: Flat, Odd only, Even only, Hollow.
+- Harmonic editor shows the measured level of each harmonic before and after.
@@ -0,0 +1,66 @@
+# Lathe
+
+Lathe is an EQ whose bands sit on the harmonics of the note being played.
+Current version **0.1.0**.
+
+A normal EQ works in fixed frequencies. A cut at 130 Hz takes out the 3rd
+harmonic of an F1 bass, the 2nd of a C2, and the fundamental of a C3, so the
+same bass sounds different on every note of a riddim line. Lathe follows the
+pitch and places one band on each harmonic: "−12 dB on harmonic 3" stays on
+harmonic 3 whatever note plays.
+
+![Lathe](assets/editor.png)
+
+## Install on Windows
+
+Copy `Lathe.clap` into `C:\Program Files\Common Files\CLAP\`. In FL Studio 2024.1
+or newer, open Options → Manage plugins, enable Verify plugins, and Find installed
+plugins. Load Lathe in a mixer slot of the bass, after the synth and before bus
+processing. Keep the font license with redistributed packages.
+
+## Work with it
+
+1. Play the bass. The note readout shows what Lathe tracks; the lower strip of the
+   editor shows each harmonic's level going in (grey) and coming out (pink).
+2. Draw gains on the harmonic bars. Drag across bars to paint a shape;
+   Shift-drag for fine steps; double-click a bar to reset it.
+3. Use the macros for the whole series:
+   - **Tilt** brightens or darkens in dB per octave of harmonic number. The
+     fundamental is the pivot.
+   - **Odd/Even** lifts odd harmonics and lowers even ones (positive, more
+     square-like) or the reverse (negative, more octave-like).
+   - **Between** sets the gain halfway between harmonics. Cut it to clean up noise,
+     beating and inharmonic grit; lift it for dirt.
+4. **Width** sets every band's bandwidth as a share of the harmonic spacing. Narrow
+   bands touch only the harmonic; wide bands also move its surroundings.
+
+Other controls:
+
+- **Harmonics** is how many harmonics are shaped (8–32). Higher harmonics pass
+  unchanged.
+- **Smooth** is the retune time for slides and pitch bends. A new note always
+  retunes at once, on its attack.
+- **Gate** is the input level that counts as a note. Raise it if tails or reverb
+  start new notes.
+- **Mix** blends with the delayed dry signal; **Output** trims the level.
+- **Snap to semitone** rounds the detected pitch. Turn it off for slides.
+- **Shapes** set the drawn gains: Flat, Odd only, Even only, or Hollow (harmonics
+  2–4 cut).
+
+The drawn gains are saved with the project but are not automation parameters;
+the macros are.
+
+### Pitch from MIDI
+
+For basses whose fundamental is unclear (heavy FM, formant or noise patches),
+select **MIDI** and route the bass's MIDI notes to Lathe. In FL Studio, set the
+bass channel's MIDI output port and Lathe's input port to the same number.
+
+## Timing and limits
+
+Detection uses about 67 ms of lookahead, reported to the host for delay
+compensation, so the bands are tuned before each note's attack leaves the
+plugin. Pitch range is 30–500 Hz, one note at a time; chords are not separated.
+Before the first note Lathe passes audio unchanged; between notes it holds the
+last tuning so tails keep their shape. Bands above 0.45 × the sample rate are
+skipped.
@@ -1,5 +1,23 @@
 # Patina changelog

+## 0.3.0
+
+- Change the CLAP ID to `io.narl.bass-foundry.patina`. Hosts see this as a new
+  plugin: delete the old `.clap` file, rescan, and add the plugin again in
+  existing projects.
+
+## 0.2.0
+
+- Rebuild the detector so it finds resonant bumps instead of cutting individual
+  harmonics: band-averaged power, temporal smoothing, a harmonic-top envelope,
+  and a robust tilt-aware reference.
+- Replace six overlapping controls with Depth, Sharpness, and Selectivity.
+  Focus points now read the same way everywhere: up cuts more, down protects.
+- Halve the analysis window to 2048 samples at 44.1/48 kHz (about 43 ms delay).
+- Show the detector envelope and reference on the plot.
+- New dark metallic look with a single accent colour, shared with Rivet.
+- Breaking: projects saved with 0.1 load the new controls at their defaults.
+
 ## 0.1.0

 - Introduce Patina, formerly Resonance Compressor, as an independent mixing effect.
@@ -1,10 +1,11 @@
 # Patina

 Patina smooths a sound’s rough surface without erasing its character. Formerly
-**Resonance Compressor**; current version **0.1.0**.
+**Resonance Compressor**; current version **0.2.0**.

-A mixing effect for controlling local spectral peaks while retaining the intended
-sound. Independently designed in Rust; no claim of matching Soothe or Quance.
+A mixing effect that finds harsh, ringing regions as they happen and pulls them
+down, while plain harmonic tone passes. Independently designed in Rust; no claim
+of matching Soothe or Quance.

 ![Patina](assets/editor.png)

@@ -19,40 +20,60 @@ redistributed packages.

 ## Work with it

-Loop a troublesome passage in context. Restrict Low/High frequency, then adjust
-Amount and Max cut. Sensitivity is a prominence threshold: lower catches more.
-Neighborhood defines the spectral reference; Cut width smooths the attenuation.
-Attack and Release smooth gain changes; Transient guard briefly relaxes cuts.
+Three controls decide what happens:

-Double-click the plot to add one of four focus points. Positive sensitivity
-makes the detector more eager; negative values protect the region by raising
-the threshold. Drag a point, wheel to change width, or use its numeric fields.
-Range boundary handles constrain where processing may act. Focus is detector
-weighting, not a static EQ boost and not an absolute protection guarantee.
+- **Depth** is the largest cut, in dB. 0 dB does nothing.
+- **Sharpness** sets what counts as a resonance. Low values follow broad,
+  smooth bumps (honk, boxiness). High values target narrow rings and whistles.
+- **Selectivity** sets how far a bump must stand out before it is cut. Low
+  values treat any bump; high values treat only the worst.
+
+Start with Depth around 6 dB. Raise Selectivity until only the harsh parts show
+cuts, then use Delta to hear what is removed. Restrict Low/High frequency to keep
+the source’s body out of reach. Attack and Release set how quickly cuts grow and
+recover; Transient guard briefly relaxes cuts on attacks to keep punch.
+
+Double-click the plot to add one of four focus points. Drag a point up to cut
+more in that region, down to protect it. Wheel changes its width. Range handles
+on the plot drag the processing limits.
+
+On the plot, the grey fill is the measured input. The bright line is what the
+detector hears (its smoothed spectral envelope); the dim line is what it expects
+there. Accent-coloured cuts appear where the bright line rises above the dim one
+by more than Selectivity allows. The blue curve is the focus/protect shape.

-Cyan shows spectral input energy, coral the attenuation, violet detector focus.
-The left scale is calibrated per-bin spectral power; the right scale is cut dB.
 Delta plays delayed dry minus wet before output trim. Use it to inspect changes,
 then return to normal monitoring to decide whether the music improved.
 Mix is a linear blend of aligned signals. Bypass keeps the same latency.
 Use Output for matched-level comparison. Spectral attenuation is not a limiter:
 sample peaks can increase even when frequency gains never exceed unity.

-Four starting presets and A/B comparison help explore alternatives. All controls
-are visible. The instrument-style sidebar holds Amount, Mix, and Output; the
-spectrum includes filled energy traces, cut overlays, meter rails, and range
-handles, using the plugin’s cyan/coral/violet palette. Host parameters and window
-size persist; Delta does not. The editor supports numeric entry, keyboard focus, and direct graph editing.
+Four presets and A/B comparison help explore alternatives. Host parameters and
+window size persist; Delta does not.
+
+## How detection works
+
+1. Each analysis frame is grouped into 512 log-spaced bands. Each band holds the
+   mean power of the FFT bins it covers, smoothed over time (about 5 ms rise,
+   40 ms fall) so cuts hold on a stable ring instead of flickering.
+2. Neighbouring peaks are joined in dB, so the gaps between harmonics do not count
+   as the expected level. A plain harmonic tone reads as a smooth envelope.
+3. The envelope is smoothed across frequency by the Sharpness width.
+4. The reference is a robust local straight-line fit over 2–3 octaves: spectral
+   tilt is expected, bumps cannot raise their own reference, and empty regions
+   (below a fundamental, beyond a filter cutoff) are ignored.
+5. Envelope minus reference, above the Selectivity threshold, becomes the cut,
+   limited by Depth, smoothed with Attack/Release, and linked across stereo.

 ## Timing and limits

-Mixing only: 4096-sample analysis windows at 44.1/48 kHz, 8192 at 88.2/96 kHz,
-16384 at 176.4/192 kHz, with eight overlaps. Delay is one window, about 85–93 ms.
+Mixing only: 2048-sample analysis windows at 44.1/48 kHz, 4096 at 88.2/96 kHz,
+8192 at 176.4/192 kHz, with eight overlaps. Delay is one window, about 43–46 ms.
 The plugin reports it for host compensation. Supported layouts are mono and
 linked stereo; supported rates are those six standard rates.

 The engine uses complex RustFFT with supplied scratch buffers, WOLA reconstruction,
-a log-frequency prominence detector, bounded soft-knee cuts, and temporal/frequency
+the envelope/reference detector above, bounded soft-knee cuts, and temporal
 smoothing. Original bin phases are retained. This is not a minimum-phase filter
 bank, a live monitoring effect, a limiter, or an automatic separation of tone and
 unwanted resonance. No external sidechain, Learn, M/S, or pitch detector in v0.1.
@@ -88,17 +109,19 @@ Judge through real patches with matched listening levels: preserve vowel motion,
 snare punch, bass body, and stereo placement. Synthetic tests do not establish
 artistic usefulness.

-Local benchmark: AMD Ryzen 7 PRO 3700U, optimized build, stereo 48 kHz, FFT
-4096/hop 512: five seconds processed in 0.233 seconds (about 4.7% of one
-core in that run). This is not a worst-case multi-instance guarantee.
+Local benchmark, optimized build, stereo 48 kHz, FFT 2048/hop 256: five seconds
+processed in about 0.35–0.45 seconds (7–9% of one core on a laptop CPU). This is
+not a worst-case multi-instance guarantee.


 ## Existing projects and source layout

-The CLAP ID `io.storyboard.resonance-compressor`, parameter IDs, and state
-format are unchanged. Replace the former plugin file with `Patina.clap` and
-rescan; avoid two scanned copies with the same ID. Host project recall still
-needs verification in FL Studio.
+The CLAP ID is now `io.narl.bass-foundry.patina` (earlier builds used
+`io.storyboard.resonance-compressor`). Hosts treat Patina as a new plugin, so
+add it again in projects saved with an earlier build. Version 0.2 replaced
+Amount, Sensitivity, Max cut, Neighborhood, Cut width, and Knee with Depth,
+Sharpness, and Selectivity. Delete the old plugin file, place `Patina.clap`, and
+rescan FL Studio.

 Source is grouped into `plugins/patina/{core,ui,render,plugin}`. See
 [research](research.md), [development](../development.md), and the
@@ -1,49 +1,51 @@
 # Independent plugin releases on Gitea

-Rivet and Patina have independent versions and releases. Workflows live under
-`.gitea/workflows/`.
+Every Bass Foundry plugin has its own version and its own release. The
+workflows are in `.gitea/workflows/`. A plugin's version is the `version` in
+`plugins/<plugin>/plugin/Cargo.toml`, and its release tag is
+`<plugin>-v<version>`.

-| Tag | Gitea release | Windows download |
+| Plugin | Latest tag | Windows download |
 | --- | --- | --- |
-| `rivet-v0.3.0` | Rivet 0.3.0 | `rivet-windows-x86_64-0.3.0.zip` |
-| `patina-v0.1.0` | Patina 0.1.0 | `patina-windows-x86_64-0.1.0.zip` |
+| Rivet | `rivet-v0.5.0` | `rivet-windows-x86_64-0.5.0.zip` |
+| Patina | `patina-v0.3.0` | `patina-windows-x86_64-0.3.0.zip` |
+| Anvil | `anvil-v0.2.0` | `anvil-windows-x86_64-0.2.0.zip` |
+| Crucible | `crucible-v0.2.0` | `crucible-windows-x86_64-0.2.0.zip` |
+| Lathe | `lathe-v0.2.0` | `lathe-windows-x86_64-0.2.0.zip` |
+| Temper | `temper-v0.2.0` | `temper-windows-x86_64-0.2.0.zip` |
+| Weld | `weld-v0.2.0` | `weld-windows-x86_64-0.2.0.zip` |
+| Knurl | `knurl-v0.2.0` | `knurl-windows-x86_64-0.2.0.zip` |

 ## Make a release

-1. Update the selected wrapper's `Cargo.toml` version and its
-   `docs/<product>/CHANGELOG.md`. The wrapper version determines the release
-   version; internal crate versions can evolve separately.
-2. Refresh affected lockfiles, run the product check, and commit/push the change.
-3. Tag the intended commit and push that product's tag.
+1. Set the new version in the plugin's wrapper `Cargo.toml` and add a section
+   with that version to `docs/<plugin>/CHANGELOG.md`. Internal crate versions
+   can change independently.
+2. Refresh the affected lockfiles, run the plugin's check, then commit and push.
+3. Tag the commit and push only that plugin's tag.

-For Rivet:
+For example, Temper 0.2.0:

 ```sh
-python scripts/check-plugin.py --plugin rivet
-git tag -a rivet-v0.3.0 -m "Rivet 0.3.0"
-git push origin rivet-v0.3.0
+python3 scripts/check-plugin.py --plugin temper
+git tag -a temper-v0.2.0 -m "Temper 0.2.0"
+git push origin temper-v0.2.0
 ```

-For Patina:
-
-```sh
-python scripts/check-plugin.py --plugin patina
-git tag -a patina-v0.1.0 -m "Patina 0.1.0"
-git push origin patina-v0.1.0
-```
-
-These are instructions; this change does not create tags or publish a release.
-Tags must exactly match the selected wrapper version and a changelog section.
-Wrong product/version tags fail before building or publishing. Cargo prerelease
-versions such as `patina-v0.2.0-rc.1` are supported and marked as prereleases.
+The tag must match the wrapper version and a changelog section exactly. A wrong
+plugin name or version fails in the `plan` job, before anything is built or
+published. Cargo prerelease versions such as `temper-v0.2.0-rc.1` are supported
+and published as prereleases.

 ## Workflows

 **Check and Windows preview** runs on branch pushes, pull requests, and manual
-dispatch. It checks both products, renders editor previews, and provides a combined
-Windows ZIP as an Actions artifact. It never publishes a release.
+dispatch. It checks every product in a matrix, renders all editor previews, and
+provides the combined `bass-foundry-windows-x86_64.zip` as an Actions artifact.
+It never publishes a release.

-**Independent plugin release** runs on `rivet-v*` or `patina-v*` tag pushes:
+**Independent plugin release** runs when a `<plugin>-v*` tag is pushed, for any
+plugin in the catalog:

 1. `plan` validates the product/version/changelog and exposes the selected plugin.
 2. `build` checks and cross-compiles only that plugin, then packages its Windows
@@ -64,6 +66,24 @@ Node runtime, and a local composite action installs Rust and build dependencies.
 Windows binaries are cross-compiled with MinGW; no Windows runner or Linux release
 binary is required.

+### Build cache
+
+Every Rust job restores two caches through the runner's cache server
+(`actions/cache@v4`, run from the setup composite action):
+
+- **Toolchain:** rustup's stable toolchain, Cargo's binaries, and the registry and
+  git sources, keyed by ISO week, Windows target, and all three `Cargo.lock` files.
+- **Build directories:** each job's target directories (check per plugin,
+  previews, Windows preview, release per plugin), keyed the same way.
+
+A new week or a changed lockfile starts a fresh entry, so stale build output does
+not accumulate and the stable toolchain refreshes weekly. Within a week, pushes
+reuse compiled dependencies and rebuild only this repository's crates. Release
+jobs use their own entries and never reuse branch build output. A cache miss only
+costs time. The runner's cache server must be enabled (`cache.enabled` in
+`act_runner`'s config, the default) and must support post steps of actions
+inside composite actions (current `act_runner` releases do).
+
 The workflows use explicit action URLs and the v3-compatible artifact protocol.
 Only the publish job requests `contents: write`. It authenticates against the
 same Gitea instance using the automatic `secrets.GITEA_TOKEN`; no personal access
@@ -88,7 +108,7 @@ The release tag must already exist in Gitea; the publisher does not create tags.
 The ZIP must contain exactly the selected plugin. Its sidecar and internal file
 checksums are verified before any release write.

-Choose a plugin's named release/tag rather than assuming the repository's global
-latest release refers to both products. Package and API behavior are tested with
-fake transports; an actual runner/tag release on this Gitea instance remains to
-be verified.
+Link to a plugin's own release or tag. The repository's "latest release" is
+only the most recent release of any plugin. Packaging and API behaviour are tested with
+fake transports. Every tag in the table above was published by this workflow on
+the project's Gitea instance.
@@ -1,5 +1,27 @@
 # Rivet changelog

+## 0.5.0
+
+- Change the CLAP ID to `io.narl.bass-foundry.rivet`. Hosts see this as a new
+  plugin: delete the old `.clap` file, rescan, and add the plugin again in
+  existing projects.
+
+## 0.4.0
+
+- Storyboard: a timeline of blocks with roles (statement, answer, departure,
+  return, rest). Rivet writes each block from a motif and joins the seams with a
+  cut, breath, pickup or approach. Templates start a storyboard in one click.
+- Flexible lengths: motifs of 1–8 bars, storyboards up to 32 bars, and the
+  meters 2/4, 3/4, 4/4, 5/4, 6/8, 7/8 and 12/8 for import, writing and export.
+- A motif bin holds up to 16 motifs; locks live on each motif's notes.
+- Per-block options with Another take and Keep replace proposals and pins.
+- Undo/redo for every edit (32 steps) replaces kept history and branches.
+- New editor: motif bin, timeline, one large piano roll, inspector, and tabs
+  for generation, harmony and sound roles. Dark metallic look shared with Patina.
+- Three more scales: Phrygian, harmonic minor and Mixolydian.
+- Queued auditions switch at the next bar line of the session's meter.
+- Sessions from 0.1–0.3 open as a storyboard built from their source motif.
+
 ## 0.3.0

 - Introduce the Rivet name and a dedicated product source/documentation tree.
@@ -1,52 +1,61 @@
 # Rivet

 Rivet joins short motifs into connected musical phrases, like a fastener joining
-individual pieces. Formerly **Motif Storyboard**; current version **0.3.0**.
+individual pieces. Formerly **Motif Storyboard**; current version **0.4.0**.


-A Rust composition companion for an experienced producer developing their own
-melodic ideas. Version 0.3 explores rhythm, space, contour, harmonic arrivals, and
-returns, with reusable gestures, branching ideas, and two sound roles.
+A Rust composition companion for a producer developing their own melodic ideas.
+Version 0.4 is built around a **storyboard**: a timeline of blocks that tell one
+short idea as a story. Each block has a role (statement, answer, departure,
+return, rest) and a length; Rivet writes each block from your motif and joins the
+seams so the result plays as one phrase.

 ![Rivet editor](assets/editor.png)

 ## Write with it

-1. Import a monophonic MIDI motif of up to two bars in 4/4, or load the demo.
-2. Choose a task: **Develop the motif**, **Write an answer**, **Make room**, or
-   **Find a return**. Choose a settled or open ending and a four/eight-bar length.
-3. Decide what defines the idea. **Keep groove** fixes note positions and lengths;
-   **Keep contour** protects the direction of movement, allowing flattened steps
-   at register limits. Click source notes to lock the whole note, pitch only, or
-   rhythm only. Clicking uses the currently selected lock mode. Locks
-   and identity constraints take precedence over the proposed transformations.
-4. Optionally open **Harmony** and import a chord/bass MIDI track (up to eight
-   bars), or create and edit a four-chord progression. Imported overlapping notes
-   become pitch-class regions with the actual lowest held pitch; the tool does
-   not guess chord roots or chord names. Empty regions remain gaps, and short
-   contexts repeat. Harmony guides strong notes and arrivals; the preview plays
-   the melody only. Supplied chord tones may extend beyond the selected scale.
-5. Explore alternatives. A deterministic pool of eight transformation families
-   supplies up to three distinct proposals, selected for the task and differences
-   in rhythm, density, duration, and pitch. Fully constrained motifs may yield
-   fewer than three; cosmetic velocity differences do not count as new ideas.
-6. Select a proposal and pin its two-bar sections. Select another to fill the
-   remaining sections, or explore another take. Preview and export the combined
-   phrase from the fixed bottom toolbar. Keep a combined result to retain it
-   independently of new proposals; undo/redo switches the kept result and its
-   previous value. Individual proposals and kept results can also be exported.
+1. **Bring in a motif.** Import a monophonic MIDI clip of one to eight bars, or
+   press **Demo**. The bin on the left holds up to 16 motifs. When the bin is
+   empty, the file's time signature and tempo become the session's.
+2. **Lock what defines it.** Select the motif; the big roll shows it. Click notes
+   to lock the whole note, its pitch only, or its rhythm only. Locked notes
+   survive into every block.
+3. **Lay out the story.** A new motif starts as an arc: statement, answer,
+   departure, return. **Build from this motif** applies other templates
+   (question and answer, breathe with rests, build with two departures).
+   **Add block** inserts any role after the selected block. Blocks are 1–8 bars;
+   a storyboard holds up to 32 bars in 2/4, 3/4, 4/4, 5/4, 6/8, 7/8 or 12/8.
+4. **Shape each block.** Click a block in the timeline or the roll. The inspector
+   on the right sets its role, motif, length and how it hands over to the next
+   block. It also lists up to three options written for that role; click one to
+   use it, or **Audition** it alone. **Another take** writes three new options
+   for that block only. **Keep** freezes a block so later changes to key, reach
+   or harmony leave it alone.
+5. **Join the seams.** Click the small circle between two blocks to cycle its
+   join: **Cut** (as written), **Breath** (the last note ends early to leave
+   air), **Pickup** (two short notes lead into the next block) or **Approach**
+   (the last note steps next to the next block's first note).
+6. **Play and export.** **Play** (or Space) loops the whole storyboard. While it
+   plays, edits are heard from the next bar line. **Export MIDI…** writes the
+   storyboard to drag into FL Studio. **Undo**/**Redo** (Ctrl+Z, Ctrl+Shift+Z)
+   step back through the last 32 edits.

-The opening quotation stays intact. Later sections use displaced entries,
-repeated pickups, fragments, subtraction, short/long answers, changed endings,
-register contrast, and returns. These are compositional suggestions, not promises
-of an emotion or of commercial originality. Different seeds choose structured
-alternatives; they do not independently randomize every pitch.
+The tabs under the roll hold the less frequent settings:

-Pins survive task/seed/harmony changes and regeneration. Changing the motif,
-its locks, or the phrase length clears pins. Pinned sections override newly
-proposed material. Unsafe boundaries in legacy candidates are rejected instead
-of truncating sustained notes. Changing generation inputs clears current
-proposals while retaining kept work.
+- **Generation**: reach (how far options move from the motif), keep groove,
+  keep contour, a settled or open ending for the last block, the register, the
+  seed, and the audition output.
+- **Harmony**: import a chord or bass MIDI track, or start from an editable
+  progression. Harmony guides strong notes and arrivals; audition plays the
+  melody only. Imported voicings keep their pitch classes; Rivet does not guess
+  chord names.
+- **Sound roles**: split the phrase between two synth parts (see below).
+
+Options come from eight transformation families: displaced groove, fragment,
+room to breathe, short call and long answer, familiar return, changed ending,
+higher peak and held back. Each role prefers the families that fit it, and the
+statement always offers the motif as written. Options are deterministic for a
+given seed, take and position; they are suggestions, not promises of an emotion.

 ## Audition and commit

@@ -54,8 +63,7 @@ proposals while retaining kept work.
 notes and optional CC curves on the configured channels to routed external synths
 and mutes the internal voice. Solo defaults to channel 1.
 Looping is optional and enabled for new sessions. When audition is already
-running, another selection waits until the next two-bar boundary or current
-phrase end. Note-offs precede repeated same-pitch note-ons; stop, replacement,
+running, another selection waits until the next bar line. Note-offs precede repeated same-pitch note-ons; stop, replacement,
 loop boundaries, reset, restoration, and mode changes release active output notes
 on the processing thread. Queued auditions are canceled by Stop.

@@ -66,15 +74,7 @@ Exported MIDI is in musical ticks and carries the local BPM as its tempo event.
 Native OS MIDI drag-out is not implemented; export files to commit a phrase.
 See [FL Studio setup and acceptance checks](fl-studio.md).

-Open **Gestures, moves, and branches** to save a source or selected two-bar
-section with its performance choices. Export/import a gesture library between
-projects. Save a branch before experimenting; restore any branch and make a new
-child with subtraction, a delayed entry, longer gates, or transposition.
-Moves respect pins and locks, reject unsafe overlaps, and report when constraints
-leave nothing to change. Libraries and histories each hold up to 16 entries;
-remove a gesture or a leaf branch to make room.
-
-Open **Sound roles and expressive gestures** to pass existing notes between two
+Open **Sound roles** to pass existing notes between two
 patches: alternate events, alternate question/answer bars, or divide strong beats
 from replies. These modes distribute a monophonic phrase rather than generate
 a second independent melody. Assign separate MIDI channels and explicitly map
@@ -91,12 +91,12 @@ names, channels, and CC curves. Stop resets mapped controllers to their chosen
 stop values. Internal audition does not reproduce mapped timbre.
 See [the theory and producer workflow](theory/README.md).

-Sessions save inside the host project and can be saved/loaded as JSON. Version-1/2
-sessions and the original host field identifier remain supported; older sessions
-retain one-shot audition. New sessions persist harmony, task, lock modes on notes,
-pins, proposals, kept history, gestures, branches, patch profiles, CC curves, and
-audition settings. JSON state is bounded at 16 MiB; gesture libraries at 2 MiB. File export/save refuses to
-silently overwrite an existing file.
+Sessions save inside the host project and can be saved/loaded as JSON. Sessions
+from versions 0.1–0.3 open as a storyboard: the old source motif becomes the
+first motif in the bin, a kept phrase and saved gestures follow it, and an
+eight-bar phrase becomes an arc (a four-bar phrase becomes statement and return).
+Branch history is not carried over; undo replaces it. JSON state is bounded at
+16 MiB. File export/save refuses to silently overwrite an existing file.

 ## Build and offline preview

@@ -110,8 +110,9 @@ cargo run -p rivet-preview -- session saved-session.json /tmp/rendered-session
 python scripts/build-plugin.py --plugin rivet --target x86_64-pc-windows-gnu
 ```

-The preview writes source/candidate MIDI, a session JSON, and WAV using the same
-engine as the plugin. Track indices exclude conductor-only tracks and start at
+The preview builds an arc storyboard from the motif and writes the motif and
+storyboard as MIDI, a session JSON, a WAV render using the same engine as the
+plugin, and a table of blocks with their chosen options. Track indices exclude conductor-only tracks and start at
 zero. Optional harmony arguments accept a separate polyphonic MIDI file.
 See [development](../development.md) for checks, dependencies, architecture, and
 [releases](../releases.md) for independent release tags.
@@ -124,8 +125,9 @@ choices. [Devath reference measurements](research/devath.md) document
 analysis of the seven supplied FLACs, with reproducible plots and explicit limits.
 Original reference audio is excluded from source distribution.

- `rivet-core`: musical model, harmonic context, structured proposals, section
-  composition, session migration, and bounded playback clips.
+- `rivet-core`: meters, motifs, the storyboard (blocks, roles, joins, templates),
+  role-aware option writing, harmonic context, session migration, and bounded
+  playback clips.
 - `rivet-midi`: bounded SMF 0/1 import/export. Rejects SMPTE, unsupported meters,
  incomplete notes, and timing not exactly representable at 960 PPQ. Reports
  ignored controllers/pitch bends. Polyphonic tracks work as harmonic context;
@@ -134,7 +136,8 @@ Original reference audio is excluded from source distribution.
  preview/MIDI scheduling, and Windows/Zenity dialogs.
 - `rivet`: CLAP wrapper, host persistence, editor, and standalone.

-Tests cover musical constraints/diversity, harmony, legacy state, section seams,
+Tests cover musical constraints/diversity, harmony, every meter, storyboard
+limits, joins, kept blocks, legacy state migration,
 MIDI round trips, sample timing, looping, queued switches, note releases, and
 zero allocation/deallocation during rendering and queued clip replacement. The
 CLAP ABI test verifies discovery, note-output port exposure, state restoration,
@@ -142,8 +145,8 @@ and silent startup at several sample rates and buffer sizes.

 ## Existing projects

-The name, Cargo packages, source paths, and output filename have changed.
-The CLAP ID `io.storyboard.motif`, `story-session-v1` host field, and session
-JSON format are preserved. Rescan FL Studio after replacing the old plugin file
-with `Rivet.clap`; remove the old copy from scanned folders to avoid duplicate
-instances with the same ID. Project recall still needs a check in the target host.
+The CLAP ID is now `io.narl.bass-foundry.rivet` (earlier builds used
+`io.storyboard.motif`). Hosts treat Rivet as a new plugin, so add it again in
+projects saved with an earlier build. The `story-session-v1` host field and the
+session JSON format are preserved, so saved sessions still open. Delete the old
+plugin file, place `Rivet.clap`, and rescan FL Studio.
@@ -18,21 +18,23 @@ against FL Studio in this environment.

 - Open and close the editor repeatedly; verify keyboard input and controls work
  at 100%, 150%, and 200% Windows display scaling, with no clipped content.
- Load the demo, generate three continuations, and audition each. The opening
-  must match the source; candidates should be audibly related and differ later.
- Lock a source note, regenerate, and verify pitch, velocity, start, and duration
-  are unchanged at each repeated position. Locks may override register/scale.
- Try four/eight bars, all scales, different seeds, and rhythm preservation.
- Accept candidate A; accept B; undo/redo. Regenerate with a different seed and
-  confirm accepted work remains available.
- Export selected and accepted MIDI separately. Import each into the piano roll
-  of an existing synth and compare note timing, duration, velocity, and length.
+- Load the demo. The storyboard must show statement, answer, departure and
+  return; Play must loop all eight bars. The statement should quote the motif.
+- Lock a motif note and confirm it appears unchanged (pitch, start, length) in
+  every block that develops the motif. Locks may override register/scale.
+- Change a block's role, length (1–8 bars) and motif; try Another take and Keep.
+  Change the key: kept blocks must not change, the others must.
+- Cycle each seam through Cut, Breath, Pickup and Approach and listen at the seam.
+- Try 3/4, 6/8 and 12/8, all scales, and storyboards up to 32 bars.
+- Undo and redo a series of edits, including a template rebuild and a meter change.
+- Export the storyboard. Import it into the piano roll of an existing synth and
+  compare note timing, duration, velocity, length and time signature.

 ## Import and files

 - Import a monophonic MIDI file exported from FL Studio at 96/480/960 PPQ.
 - Import multitrack MIDI and select the intended note track.
- Verify useful errors for chords/overlaps, motifs longer than two bars,
+- Verify useful errors for chords/overlaps, motifs longer than eight bars, a full bin,
  unsupported meters, malformed files, and inaccessible paths.
 - Cancel native dialogs. Try Unicode paths and the manual file-path controls.
 - Export to an existing filename; confirm it is refused and the file is intact.
@@ -46,7 +48,7 @@ against FL Studio in this environment.
  local tempo controls audition speed. Host start must never trigger audition.
 - At 44.1/48/96 kHz and several buffer sizes, confirm stable timing and no clicks
  at ordinary note boundaries, dropouts, or non-finite output.
- Save a project containing locks, candidates, an accepted result, and history.
+- Save a project containing locks, several motifs, kept blocks and joins.
  Reopen it, confirm all state is restored and preview remains stopped.
 - Save/load a JSON session; reject unsupported versions without changing the
  current session. Test multiple plugin instances for independent state.
@@ -64,7 +66,7 @@ piano roll. Native MIDI drag-out is outside this release.
  installed FL Studio version. Keep the MIDI-file export path as fallback.
 - Audition through the actual production patch with the surrounding project loop.
  Host tempo follows BPM only; start audition at the desired point manually.
-  Switching a running audition waits for the next local two-bar boundary or end.
+  Switching a running audition waits for the next bar line.
 - Test Loop on/off, same-pitch repeated notes, changing Internal/MIDI mode while
  playing, rapid queued selections, Stop before a queued switch, host transport
  stop, and project reload. There must be no hanging external notes.
@@ -73,22 +75,14 @@ piano roll. Native MIDI drag-out is outside this release.
 - Test whole-note, pitch-only, and rhythm-only locks. Keep groove must retain
  onset/duration; keep contour must prevent direction reversals except that a
  register limit can flatten a step. Locks override other targets.
- Pin bars 3–4 from proposal A, select B, and preview/export the combined phrase.
-  Regenerate with another seed: pinned notes must remain exact. Change the motif
-  or phrase length: pins clear. Restore a version-1 session and a version-2
-  project with harmony, pins, and kept history.
+- Restore a version-1 session and a version-2/3 project with harmony, pins and
+  kept history: each must open as a storyboard built from its source motif.
 - Evaluate artistic usefulness through the real patch: can the producer choose
-  a meaningful alternative, retain just its useful section, and make it his own?
+  a meaningful option per block, keep just the useful ones, and make it their own?
  Automated diversity metrics do not replace that evaluation.

-## Version 0.3: gestures, branches, roles, and controllers
+## Version 0.3: sound roles and controllers

- Save a named source gesture and a developed two-bar gesture. Export the library
-  and import it into another instance: notes, locks, and performance choices
-  should survive; recalling keeps the destination harmony.
- Save a branch, apply Subtract to bars 3–4, restore the parent, and try Longer
-  gates instead. Both children should remain available. Restore each after
-  saving/reopening the host project. Remove leaves without losing their parent.
 - Try each role mode. Route channels 1 and 2 to separate patch parts (or choose
  other distinct channels). Verify every original note belongs to one role.
  A host configuration must preserve channels; MIDI file export provides named
@@ -109,6 +103,6 @@ piano roll. Native MIDI drag-out is outside this release.
 - Locks protect musical note attributes; attack/release compensation adjusts
  MIDI trigger scheduling for the patch. Judge the audible onset against the
  surrounding groove rather than expecting every trigger to stay on the grid.
- Evaluate whether a saved gesture still feels like the same idea with another
-  patch, and whether branching makes it easy to retain useful exceptions.
+- Evaluate whether the storyboard still feels like the same idea with another
+  patch.
  The internal voices and the automated checks cannot establish artistic quality.
@@ -1,54 +1,64 @@
-# Rivet 0.2 implementation plan
+# Rivet 0.4 implementation notes

 ## Musical intent
-Develop a producer's own motif through audible choices about recognition, space,
-contrast, and return. Offer three distinct compositional proposals rather than
-three randomly shifted versions. Emotional interpretation stays with the producer.
+Tell a producer's own motif as a story. The unit of work is a storyboard of
+blocks; each block has a role that says what it does for the story, and Rivet
+writes the notes for that role from the motif. Emotional interpretation stays
+with the producer.

-## Engine
- Keep an exact opening quotation. Build subsequent two-bar sections as statement,
-  answer, departure, and return (four-bar phrases use statement and return).
- Add tasks Develop, Answer, Make space, and Return. Generate a deterministic pool
-  using rhythmic displacement, fragmentation, call/response, sparse subtraction,
-  a later register peak, changed endings, and harmonic returns; remove duplicates
-  and choose three candidates by task fit and musical distance. Return fewer if
-  locks make three distinct outcomes impossible.
- Preserve groove and contour independently. Per-note locks protect pitch, rhythm,
-  or every attribute. Locked events survive subtraction; rhythm locks keep exact
-  timing and duration. Global constraints and locks take precedence over transforms.
- Optional harmony consists of bounded time regions with pitch-class masks and
-  bass pitch. Accept polyphonic MIDI without claiming chord-root detection. Also
-  provide editable per-bar chord progressions. Guide metrically strong notes and
-  ending targets using the actual harmony at that time. Open endings prefer an
-  available scale tone outside the ending chord; closed endings use chord tones.
- Candidate generation changes note count, spacing, duration, and articulation
-  when constraints allow. Preserve recognizable fragments; avoid overlaps and
-  clipping MIDI values. Keep generated notes within two-bar section boundaries so
-  sections can be combined safely.
+## Model
+- **Meter.** One time signature per session: 2/4, 3/4, 4/4, 5/4, 6/8, 7/8 or
+  12/8. Bar length is `PPQ * 4 * beats / unit`. Compound meters (6/8, 12/8) pulse
+  in dotted quarters; strong positions, pickups and breaths use that pulse.
+- **Motif.** A monophonic phrase of 1–8 whole bars with per-note locks (whole
+  note, pitch, rhythm). The bin holds 16 motifs.
+- **Block.** Motif, role, 1–8 bars, the join into the next block, a take number,
+  up to three realized options, the chosen option, and a keep flag. A storyboard
+  holds 32 blocks and 32 bars.
+- **Roles.** Statement, Answer, Departure, Return and Rest. Each role ranks the
+  transformation families that suit it (statement: quote, displaced groove,
+  changed ending; answer: call/response, changed ending, held back; departure:
+  higher peak, displaced groove, fragment; return: familiar return, quote, room
+  to breathe). The quote is always in the pool, so a statement can play the
+  motif as written. Rest yields one silent option.
+- **Realizing a block.** The motif is tiled to the block length (notes crossing
+  the end are shortened, or dropped when rhythm-locked), then developed. The seed
+  mixes the session seed, the block's take and its position, so options are
+  deterministic and differ between blocks. Harmony is read at the block's
+  absolute position. The last sounding block follows the ending setting; other
+  statements prefer an open last note.
+- **Joins.** Applied when the storyboard is composed, never stored in options.
+  Breath ends the last note at least half a beat before the seam. Approach moves
+  the last note one scale step next to the following first note. Pickup writes
+  two half-beat notes in the last beat that move toward the following first note;
+  it is skipped when anchors occupy that beat. Defaults follow the roles: into a
+  departure a pickup, into a return an approach, around rests a cut, otherwise a
+  breath.
+- **Keep.** Kept blocks are not rewritten when settings, harmony or neighbours
+  change, unless their stored options no longer fit (for example after a meter
+  change).

-## Producer workflow
-Import motif -> choose identity/locks -> optionally import or enter harmony ->
-choose task -> audition alternatives -> pin two-bar sections -> export combined
-MIDI or accept a complete candidate. Retain accepted work during regeneration.
-Pins survive changes to task and seed, and clear when source or phrase length
-changes. Pinned material overrides regenerated sections. Reject unsafe seams
-rather than silently truncate a sustained note.
+## Editor
+Header (key, scale, meter, tempo, play, loop, undo/redo, export), motif bin,
+timeline with role-coloured blocks and clickable seams, one large roll (the
+storyboard, or the selected motif for lock editing), inspector (block or motif),
+and tabs for generation, harmony and sound roles. Edits are synchronous; file
+dialogs run on a worker. Undo keeps the last 32 session states in the editor;
+continuous drags and typing collapse into one step. While the storyboard plays,
+an edit queues the new composition for the next bar line.

-## Audition
-Keep the internal voice and add a MIDI output mode. Preview is explicitly started,
-optionally loops, and switches pending selections at the next two-bar boundary or
-current clip end. Stop, replacement, mode changes, reset, and state restoration
-release emitted notes. Host transport start never auto-starts audition. All clips,
-queues, scheduling, and MIDI event emission remain bounded and allocation-free
-on the audio thread. Validate FL Studio routing manually; retain MIDI file export
-as the reliable commit path. Native OS MIDI drag-out is outside this release.
+## Compatibility
+State version 4. Versions 1–3 are read leniently and upgraded: the source motif,
+a kept phrase and saved gestures enter the bin; an eight-bar phrase becomes an
+arc, a four-bar phrase statement and return. Branch history is dropped. Future
+versions are rejected without changing the current session. The CLAP ID and the
+`story-session-v1` host field are unchanged.

-## Compatibility and verification
-Write state version 2; migrate version-1 JSON and host fields with serde defaults,
-retain legacy strategy names for old candidates, and keep the persisted host field
-identifier. New controls/harmony/pins/audition choices persist. Test timing, locks,
-contour, harmonic targets, candidate diversity, section composition, migration,
-loop boundaries, sample-accurate note events, queued switches, and RT allocation.
-Run existing core/ABI tests and Clippy, render the updated editor, and package
-Windows CLAP plus Linux CLAP/standalone. Do not claim Devath-derived algorithms or
-FL Studio validation without direct evidence.
+## Verification
+Core tests cover role options and diversity, locks, a fully locked motif,
+harmony and endings, all meters, keys and lengths, templates, limits, joins,
+kept blocks, compound meters, motif removal, and v1/v3 migration. MIDI tests
+cover time signatures and compound-meter round trips. App tests cover queued
+switches at the meter's bar line. The CLAP ABI test restores a 6/8 storyboard
+session through host state. FL Studio routing and musical usefulness still need
+checks in the host (see [FL Studio](fl-studio.md)).
@@ -35,12 +35,14 @@ returns; Petals retains more consistent activity through much of its early span.
 These observations motivate exploring both contrast and continuous development.
 They do not identify exact notes, chords, emotional meaning, or melodic roles.

-## Implemented creative model (0.3)
+## Implemented creative model (0.4)

- A reusable gesture stores a short musical phrase and its explicit performance
-  choices. A name records the producer's interpretation; it is not inferred emotion.
- A bounded branching history stores working ideas, ancestry, context, and pinned
-  decisions. Composable moves create children rather than overwrite their parent.
+- A storyboard tells one motif through roles: statement (recognition), answer
+  (reply), departure (contrast: register, rhythm, fragments), return (arrival),
+  and rest (space). This puts the recognition/space/contrast/return findings
+  directly on the timeline instead of hiding them in a task menu.
+- Seams between blocks carry explicit joins (breath, pickup, approach), so
+  connection is a visible decision rather than an accident of concatenation.
 - Two sound roles can share or answer a motif through explicit routing. Each role
  has a separate MIDI channel, gate, velocity response, octave offset, and patch
  timing profile. The roles are user-assigned, not separated from mixed audio.
@@ -56,9 +58,10 @@ They do not identify exact notes, chords, emotional meaning, or melodic roles.

 ## Producer workflow and evaluation

-Import or recall a gesture -> choose context and what to preserve -> explore a
-proposal -> save a branch -> apply a move -> distribute sound roles -> map an
-expressive controller -> audition through real patches -> keep or branch again.
+Import a motif -> lock what defines it -> lay out roles on the storyboard ->
+pick an option per block and set the joins -> keep what works, take again where
+it does not -> distribute sound roles and map controllers -> audition through
+real patches -> export.
 Compare alternatives against the same surrounding loop and listening level.
 The useful outcome is a section the producer can own and develop further.

@@ -68,12 +71,10 @@ universal quality scoring, or a verified melodic transcription of Devath's track

 ## Concrete limits and implementation

-A gesture is at most two bars; a working phrase is four or eight bars.
-Libraries and branch histories each retain up to sixteen entries. A branch
-stores musical settings, source, harmony, the composed phrase, pinned sections,
-and performance choices without recursively copying the history. Importing a
-library merges validated entries with new identifiers. State versions 1 and 2
-migrate to version 3; controller output is disabled by default.
+A motif is 1–8 bars; a storyboard is up to 32 blocks and 32 bars in one of
+seven meters. The bin holds 16 motifs. Each block stores up to three options.
+Sessions from versions 1–3 migrate to version 4; controller output stays
+disabled by default.

 Role assignment partitions existing notes, so it preserves a readable motif
 before sound design. It is not source separation or independent counterpoint.
@@ -85,7 +86,7 @@ Negative attack triggers receive a warmup and a separate repeated-loop schedule.

 Composition and performance compilation run away from the audio callback.
 The callback uses fixed event storage and bounded control queues. Regression
-checks cover history forks, migration, locks, two-role event identity, MIDI
+checks cover storyboard limits and joins, migration, locks, two-role event identity, MIDI
 channels/controller export, warmup/loop timing, mapping resets, and allocation-free
 rendering. Actual patch perception, FL Studio routing, and producer usefulness
 still require listening in the target workflow.
@@ -0,0 +1,20 @@
+# Temper changelog
+
+## 0.2.0
+
+- Change the CLAP ID to `io.narl.bass-foundry.temper`. Hosts see this as a new
+  plugin: delete the old `.clap` file, rescan, and add the plugin again in
+  existing projects.
+
+## 0.1.0
+
+- Introduce Temper, a note-tracked distortion for bass sound design.
+- Normalises each note's level before the shaper, so quiet and loud patches are
+  driven the same.
+- Floor (highpass), Push (one harmonic boosted or cut) and Bright (lowpass) sit
+  at multiples of the played note, so every note keeps the same character.
+- Curves: Soft, Hard, Fold and Tube, with Bias for even harmonics. The shaper runs
+  at 4× oversampling.
+- Auto gain keeps the output at the input loudness while Drive changes.
+- Detect pitch and note starts from the audio with 67 ms lookahead, or follow
+  MIDI notes sent to the effect.
@@ -0,0 +1,66 @@
+# Temper
+
+Temper is a distortion that drives every note the same. Current version **0.1.0**.
+
+A distortion with a fixed tone filter acts differently on each note: a lowpass
+at 2 kHz lets through 45 harmonics of an F1 but only 22 of an F2, and
+a patch that is 6 dB quieter is driven 6 dB less. Across a riddim line that makes
+some notes fizzy and others dull. Temper evens out each note's level before the
+shaper and moves its tone filters with the pitch, so the character stays the same
+on every note.
+
+![Temper](assets/editor.png)
+
+## Install on Windows
+
+Copy `Temper.clap` into `C:\Program Files\Common Files\CLAP\`. In FL Studio
+2024.1 or newer, open Options → Manage plugins, enable Verify plugins, and Find
+installed plugins. Load Temper in a mixer slot of the bass. Keep the font license
+with redistributed packages.
+
+## Work with it
+
+1. Choose a **Curve**:
+   - **Soft**: tanh, smooth and rounded.
+   - **Hard**: clipping with a narrow knee, dense and square-like.
+   - **Fold**: the wave folds back on itself; Drive moves the upper harmonics.
+   - **Tube**: the negative half clips earlier, adding even harmonics.
+2. Set **Drive**. The transfer plot shows the curve over the range a normalised
+   note covers; the **Into shaper** meter shows how far past the knee it goes.
+3. Add **Bias** for asymmetry and even harmonics.
+4. Shape the tone around the shaper, all in multiples of the note:
+   - **Floor** is a highpass before the shaper (0.25–2 × the fundamental; 0 is
+     off). It keeps sub mud out of the distortion. Put Anvil after Temper to add a
+     clean sub back.
+   - **Push** boosts or cuts one harmonic (**Push at**, 1–16) before the shaper,
+     so the distortion bites in the same place on every note.
+   - **Bright** is a lowpass after the shaper at a harmonic number (4–64; 0 is
+     off), so the top end stops at the same harmonic on every note.
+
+Other controls:
+
+- **Normalize** is how far each note's level is evened out before Drive. At 100 %
+  a quiet and a loud patch distort the same; at 0 % Temper acts like a normal
+  distortion.
+- **Auto gain** keeps the output at the input's loudness, so turning up Drive
+  changes the character, not the level.
+- **Gate** is the input level that counts as a note.
+- **Mix** blends with the delayed dry signal; **Output** trims the level.
+
+### Pitch from MIDI
+
+Select **MIDI** and route the bass's MIDI notes to Temper when detection
+struggles. In FL Studio, set the bass channel's MIDI output port and Temper's
+input port to the same number.
+
+## Timing and limits
+
+Detection uses about 67 ms of lookahead; the 4× oversampling filters add under
+1 ms. Both are reported to the host for delay compensation. Pitch range is
+30–500 Hz, one note at a time. Before the first note the tracked filters are off;
+between notes they hold the last tuning.
+
+Aliasing stays below −60 dB for bass material (tested with a 2 kHz tone at 24 dB
+drive and a 440 Hz tone at full drive, on every curve). High-pitched content at
+full drive aliases more: a 5 kHz tone at 36 dB on the Hard curve reaches about
+−31 dB.
@@ -0,0 +1,21 @@
+# Weld changelog
+
+## 0.2.0
+
+- Change the CLAP ID to `io.narl.bass-foundry.weld`. Hosts see this as a new
+  plugin: delete the old `.clap` file, rescan, and add the plugin again in
+  existing projects.
+
+## 0.1.0
+
+- Introduce Weld, a phase aligner for layered bass.
+- Hears the other layer through the sidechain input and fits polarity plus up to
+  four allpass sections, so the layers sum instead of cancelling. No latency;
+  the layer on its own keeps its sound.
+- Modes: Follow (refits only when clearly better), Learn (measure one take,
+  apply on exit), Hold. The alignment is saved with the project.
+- Display: level per band against a perfect alignment (lost and won back),
+  phase before and after, recovered dB, cancellation cost, time offset, and
+  warnings for a late layer, unrelated layers and a missing sidechain.
+- Controls: Mode, Sections, Response, Low, High, Gate, Listen (Layer, Sum,
+  Sum dry), Output, Bypass.
@@ -0,0 +1,110 @@
+# Weld
+
+Weld fuses two bass layers so they add up instead of cancelling. Current version
+**0.1.0**.
+
+Bass patches are layered: a sub, one or more mid growls, a top. Where the layers
+overlap in the mids, they partly cancel. The causes are a polarity difference, a
+small time offset between the layers, and the phase shift of the filters and EQs
+in one chain. The result is a thin, hollow sum that changes with every
+switch-up. Anvil fixes this for the sub band; Weld fixes it for the mids.
+
+Weld sits on one layer and hears the other one through the sidechain input. It
+measures how the two layers line up, then turns the phase of its own layer with
+a polarity flip and up to four allpass filters. An allpass changes only phase,
+so the layer on its own sounds the same; only the sum changes. Weld adds no
+latency.
+
+![Weld](assets/editor.png)
+
+## Install on Windows
+
+Copy `Weld.clap` into `C:\Program Files\Common Files\CLAP\`. In FL Studio 2024.1
+or newer, open Options → Manage plugins, enable Verify plugins, and Find installed
+plugins. Keep the font license with redistributed packages.
+
+## Set up in FL Studio
+
+1. Put each layer on its own mixer track. Load Weld on the track of one layer,
+   the main layer.
+2. Select the other layer's track. Right-click the route arrow under the main
+   layer's track and choose **Sidechain to this track**. The other layer still
+   goes to the master on its own; the sidechain only lets Weld hear it.
+3. In Weld's plugin wrapper, open the settings (gear icon) and set Weld's
+   sidechain input to that track.
+4. Play both layers. The SIDECHAIN meter must move. If the display says "No
+   sidechain signal", check step 3.
+
+## Work with it
+
+1. Leave **Mode** on **FOLLOW** and play the part where both layers sound. After
+   a second or two, Weld shows its alignment: polarity, and the allpass sections
+   with their frequency and Q.
+2. Read the display:
+   - **Recovered** is how much level the sum gains, as an average per band
+     between Low and High. **Cancellation cost** is how much a perfect alignment
+     would gain. When the two numbers are close, Weld got nearly everything.
+   - The upper plot shows each band against a perfectly aligned sum (0 dB). Red
+     is what the unprocessed sum loses to cancellation; pink is the part Weld
+     wins back. The white line is the level with Weld.
+   - The lower plot shows the phase of this layer against the other one, before
+     (grey) and after (pink), and Weld's own phase curve (blue). After alignment
+     the pink line sits near 0°.
+3. Compare by ear: mute the other layer's own route to the master, set
+   **Listen** to **SUM**, then to **SUM DRY**. Set Listen back to **LAYER** and
+   unmute the route for the mix.
+4. When the alignment is right, switch to **HOLD**. It is saved with the project
+   and comes back when the project opens.
+
+For one drop or switch-up, use **LEARN**: press it, play the part, then press
+**HOLD** (or LEARN again). Weld measures the whole take with equal weight and
+applies the result when Learn ends.
+
+## Controls
+
+- **Mode**:
+  - **Follow** keeps measuring and refits only when a new alignment is clearly
+    better (at least 0.3 dB on average), so the filter does not wander.
+  - **Learn** starts a fresh measurement and applies its result when Learn ends.
+  - **Hold** keeps the current alignment. The display keeps measuring.
+- **Sections** (1–4) is the largest number of allpass sections the fit may use.
+  Weld uses fewer when fewer are enough.
+- **Response** (0.3–5 s) is the averaging time in Follow. Longer is steadier.
+- **Low** and **High** set the range the fit listens to. Low defaults to 60 Hz,
+  leaving the sub to Anvil. The allpass still acts below Low, and the display
+  shows that honestly.
+- **Gate** (−70 to −30 dB): moments where either layer is quieter are not
+  measured, so tails and silence do not pull the fit.
+- **Listen**: **Layer** outputs this layer, aligned, for the mix. **Sum** outputs
+  this layer aligned plus the sidechain layer. **Sum dry** outputs both
+  unprocessed.
+- **Output** trims the level; **Bypass** passes this layer unchanged.
+
+## Limits
+
+- **A late layer cannot be moved earlier.** An allpass only delays. If the layer
+  Weld sits on is the later one, the display shows "This layer is late" and the
+  offset in ms. Put Weld on the other layer instead.
+- **Free-running layers cannot be aligned.** Without oscillator retrigger, or
+  with detuned unison, the phase between the layers drifts all the time. Weld
+  marks those bands as *loose* (hatched) and does not fit them. Enable retrigger
+  in the synth if you want Weld to align the layers.
+- **Delays leave a comb.** A time offset between the layers cancels at regular
+  frequencies. A few allpass sections cannot follow a delay all the way up, so
+  Weld aligns the lower range and moves the higher notches rather than removing
+  them. For a large offset, move the layer in time first.
+- **One alignment for the whole patch.** Weld does not change the alignment per
+  note. If switch-ups need different alignments, use Follow, or automate Mode.
+- **The sidechain must arrive.** With no sidechain signal Weld changes nothing.
+
+## How it works
+
+Every 256 samples the audio thread hands mono copies of both layers to a worker
+thread through a lock-free queue. The worker estimates their cross-spectrum
+(Welch, Hann window, about 11.7 Hz per bin, 50 % overlap) and their coherence.
+It fits polarity plus up to four second-order allpass sections so that
+Σ w(f)·Re(S(f)·H(f)) is largest, with w = 1/f so every octave counts, ignoring
+bins where the layers are not coherent, and with a penalty for any band that
+would lose more than 1 dB. A new fit fades in over 40 ms after its filters have
+settled for 40 ms, so there are no clicks. One fit takes about 15 ms on one
+core, twice per second in Follow.
@@ -0,0 +1,12 @@
+[package]
+name = "anvil-core"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+common-dsp = { path = "../../common/dsp" }
+serde = { workspace = true }
+
+[dev-dependencies]
+serde_json = { workspace = true }
@@ -0,0 +1,364 @@
+//! Sub anchor: replaces the band below the split with a clean mono sine that follows the
+//! bass pitch, holds one level for every note and restarts at the same phase on each note.
+//!
+//! The audio path is delayed by a fixed lookahead. Detection runs on the undelayed input, so
+//! a note's pitch is known before its delayed attack leaves the plugin, and the sine starts
+//! exactly on that attack.
+mod settings;
+use common_dsp::tracker::{NoteEvent, Tracker, TrackerConfig};
+use common_dsp::{coefficient, db_to_gain, hz_to_midi, midi_to_hz, Crossover};
+pub use settings::{Settings, Source};
+use std::f32::consts::TAU;
+
+/// Detectable fundamental range. The lowest sets the lookahead (two periods).
+pub const MIN_HZ: f32 = TrackerConfig::SUB.min_hz;
+pub const MAX_HZ: f32 = TrackerConfig::SUB.max_hz;
+pub const SCOPE: usize = 256;
+const ATTACK_MS: f32 = 2.;
+const RELEASE_MS: f32 = 15.;
+const CROSSFADE_MS: f32 = 3.;
+
+#[derive(Clone, Copy, Debug, Default)]
+pub struct Monitor {
+    /// Hear only the generated sub.
+    pub solo: bool,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct AnalyzerFrame {
+    /// Current sub frequency in Hz, 0 when silent.
+    pub hz: f32,
+    /// MIDI note of the current sub, rounded.
+    pub note: Option<u8>,
+    pub low_db: f32,
+    pub sub_db: f32,
+    /// Original low band and new sub, triggered on a rising zero crossing of the sub.
+    pub scope_low: [f32; SCOPE],
+    pub scope_sub: [f32; SCOPE],
+    /// Duration of the scope window in milliseconds.
+    pub scope_ms: f32,
+    pub latency: u32,
+    pub sample_rate: f32,
+}
+impl Default for AnalyzerFrame {
+    fn default() -> Self {
+        Self {
+            hz: 0.,
+            note: None,
+            low_db: -120.,
+            sub_db: -120.,
+            scope_low: [0.; SCOPE],
+            scope_sub: [0.; SCOPE],
+            scope_ms: 60.,
+            latency: 0,
+            sample_rate: 48000.,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+struct Voice {
+    phase: f32,
+    hz: f32,
+    target: f32,
+    amp: f32,
+    releasing: bool,
+}
+
+/// Sine voices and per-note state, driven by tracker events at output time.
+#[derive(Clone, Copy, Debug, Default)]
+struct Synth {
+    voice: Voice,
+    old: Voice,
+    old_gain: f32,
+    note_peak: f32,
+}
+impl Synth {
+    fn event(&mut self, s: &Settings, e: NoteEvent) {
+        match e {
+            NoteEvent::Start { pitch, glide } => self.start(s, pitch, glide),
+            NoteEvent::Move { pitch } => {
+                if !s.snap {
+                    self.voice.target = midi_to_hz(pitch + 12. * s.octave as f32);
+                }
+            }
+            NoteEvent::Stop => self.voice.releasing = true,
+        }
+    }
+    fn start(&mut self, s: &Settings, pitch: f32, glide: bool) {
+        let note = if s.snap { pitch.round() } else { pitch };
+        let hz = midi_to_hz(note + 12. * s.octave as f32);
+        let audible = self.voice.amp > 1e-4 && !self.voice.releasing;
+        if glide && audible {
+            self.voice.target = hz;
+            return;
+        }
+        if s.retrigger || !audible {
+            if self.voice.amp > 1e-4 {
+                // Restarting the phase mid-cycle would click; the old cycle fades out instead.
+                self.old = self.voice;
+                self.old_gain = 1.;
+            }
+            self.voice = Voice {
+                phase: s.phase / 360.,
+                hz,
+                target: hz,
+                amp: 0.,
+                releasing: false,
+            };
+        } else {
+            self.voice.target = hz;
+            self.voice.hz = hz;
+        }
+        self.note_peak = 0.;
+    }
+}
+
+pub struct Engine {
+    rate: f32,
+    channels: usize,
+    settings: Settings,
+    latency: usize,
+    delay: Vec<[f32; 2]>,
+    delay_at: usize,
+    crossover: [Crossover; 2],
+    tracker: Tracker,
+    synth: Synth,
+    glide: f32,
+    low_env: f32,
+    env_coef: f32,
+    smooth: f32,
+    level: f32,
+    keep: f32,
+    output: f32,
+    bypass: f32,
+    meter_coef: f32,
+    low_power: f32,
+    sub_power: f32,
+    scope_low: [f32; 2 * SCOPE],
+    scope_sub: [f32; 2 * SCOPE],
+    scope_at: usize,
+    scope_stride: usize,
+    scope_count: usize,
+}
+
+impl Engine {
+    pub fn new(rate: f32, channels: usize) -> Result<Self, &'static str> {
+        if !(8000.0..=768000.).contains(&rate) {
+            return Err("unsupported sample rate");
+        }
+        if !(1..=2).contains(&channels) {
+            return Err("unsupported channel count");
+        }
+        let tracker = Tracker::new(rate, TrackerConfig::SUB);
+        let latency = tracker.latency();
+        let settings = Settings::default();
+        let mut e = Self {
+            rate,
+            channels,
+            settings,
+            latency,
+            delay: vec![[0.; 2]; latency + 1],
+            delay_at: 0,
+            crossover: [Crossover::new(rate, settings.split); 2],
+            tracker,
+            synth: Synth::default(),
+            glide: 1.,
+            low_env: 0.,
+            env_coef: coefficient(rate, 10.),
+            smooth: coefficient(rate, 10.),
+            level: db_to_gain(settings.level),
+            keep: 0.,
+            output: 1.,
+            bypass: 0.,
+            meter_coef: coefficient(rate, 150.),
+            low_power: 0.,
+            sub_power: 0.,
+            scope_low: [0.; 2 * SCOPE],
+            scope_sub: [0.; 2 * SCOPE],
+            scope_at: 0,
+            scope_stride: ((rate * 0.06) / SCOPE as f32).round().max(1.) as usize,
+            scope_count: 0,
+        };
+        e.set_settings(settings)?;
+        Ok(e)
+    }
+    pub fn latency_samples(&self) -> u32 {
+        self.latency as u32
+    }
+    pub fn channels(&self) -> usize {
+        self.channels
+    }
+    pub fn settings(&self) -> Settings {
+        self.settings
+    }
+    pub fn set_settings(&mut self, s: Settings) -> Result<(), &'static str> {
+        s.validate()?;
+        let old = self.settings;
+        if (s.split - old.split).abs() > 1e-3 {
+            for x in &mut self.crossover {
+                x.retune(self.rate, s.split);
+            }
+        }
+        if self
+            .tracker
+            .set(s.source == Source::Midi, s.gate, s.glide > 0.)
+        {
+            self.synth.voice.releasing = true;
+        }
+        self.glide = if s.glide <= 0. {
+            1.
+        } else {
+            coefficient(self.rate, s.glide / 3.)
+        };
+        self.settings = s;
+        Ok(())
+    }
+    pub fn reset(&mut self) {
+        self.delay.fill([0.; 2]);
+        for x in &mut self.crossover {
+            x.reset();
+        }
+        self.tracker.reset();
+        self.synth = Synth::default();
+        self.low_env = 0.;
+        self.low_power = 0.;
+        self.sub_power = 0.;
+        self.scope_low = [0.; 2 * SCOPE];
+        self.scope_sub = [0.; 2 * SCOPE];
+    }
+    /// MIDI note start at the current input sample. Used when the source is MIDI.
+    pub fn note_on(&mut self, note: u8) {
+        self.tracker.note_on(note);
+    }
+    pub fn note_off(&mut self, note: u8) {
+        self.tracker.note_off(note);
+    }
+    #[inline]
+    fn shape(&self, x: f32) -> f32 {
+        let drive = self.settings.drive * 0.01;
+        if drive <= 0. {
+            return x;
+        }
+        let k = 1. + 6. * drive;
+        (k * x).tanh() / k.tanh()
+    }
+    fn oscillator(&mut self) -> f32 {
+        let attack = 1. / (self.rate * ATTACK_MS * 0.001);
+        let release = 1. / (self.rate * RELEASE_MS * 0.001);
+        let v = &mut self.synth.voice;
+        v.amp = if v.releasing {
+            (v.amp - release).max(0.)
+        } else {
+            (v.amp + attack).min(1.)
+        };
+        v.hz += (v.target - v.hz) * self.glide;
+        let mut out = 0.;
+        if v.amp > 0. {
+            out += (TAU * v.phase).sin() * v.amp;
+            v.phase = (v.phase + v.hz / self.rate).fract();
+        }
+        let s = &mut self.synth;
+        if s.old_gain > 0. {
+            let o = &mut s.old;
+            out += (TAU * o.phase).sin() * o.amp * s.old_gain;
+            o.phase = (o.phase + o.hz / self.rate).fract();
+            s.old_gain = (s.old_gain - 1. / (self.rate * CROSSFADE_MS * 0.001)).max(0.);
+        }
+        self.shape(out)
+    }
+    pub fn process_sample(&mut self, x: [f32; 2], monitor: Monitor) -> [f32; 2] {
+        let mono = if self.channels == 2 {
+            0.5 * (x[0] + x[1])
+        } else {
+            x[0]
+        };
+        let (synth, settings) = (&mut self.synth, &self.settings);
+        self.tracker.process(mono, |e| synth.event(settings, e));
+        let len = self.delay.len();
+        self.delay[self.delay_at] = x;
+        self.delay_at = (self.delay_at + 1) % len;
+        // The slot after the newest write is the oldest: exactly `latency` samples ago.
+        let y = self.delay[self.delay_at];
+        let s = self.settings;
+        let (l0, h0) = self.crossover[0].process(y[0]);
+        let (l1, h1) = if self.channels == 2 {
+            self.crossover[1].process(y[1])
+        } else {
+            (l0, h0)
+        };
+        let low = 0.5 * (l0 + l1);
+        self.low_env += (low * low - self.low_env) * self.env_coef;
+        let env = self.low_env.sqrt();
+        if !self.synth.voice.releasing {
+            self.synth.note_peak = self.synth.note_peak.max(env);
+        }
+        let follow = if self.synth.note_peak > 1e-6 {
+            (env / self.synth.note_peak).min(1.)
+        } else {
+            1.
+        };
+        let dynamics = s.dynamics * 0.01;
+        let shape = 1. - dynamics + dynamics * follow;
+        self.level += (db_to_gain(s.level) - self.level) * self.smooth;
+        self.keep += (s.keep * 0.01 - self.keep) * self.smooth;
+        self.output += (db_to_gain(s.output) - self.output) * self.smooth;
+        self.bypass += (f32::from(s.bypass) - self.bypass) * self.smooth;
+        let sub = self.oscillator() * self.level * shape;
+        self.low_power += (low * low - self.low_power) * self.meter_coef;
+        self.sub_power += (sub * sub - self.sub_power) * self.meter_coef;
+        self.scope_count += 1;
+        if self.scope_count >= self.scope_stride {
+            self.scope_count = 0;
+            self.scope_low[self.scope_at] = low;
+            self.scope_sub[self.scope_at] = sub;
+            self.scope_at = (self.scope_at + 1) % (2 * SCOPE);
+        }
+        let wet = |l: f32, h: f32| {
+            if monitor.solo {
+                sub
+            } else {
+                h + self.keep * l + sub
+            }
+        };
+        let w = [wet(l0, h0), wet(l1, h1)];
+        let mut out = [0.; 2];
+        for c in 0..self.channels {
+            out[c] = (w[c] * self.output) * (1. - self.bypass) + y[c] * self.bypass;
+        }
+        out
+    }
+    pub fn take_analyzer(&self) -> AnalyzerFrame {
+        let mut f = AnalyzerFrame {
+            latency: self.latency as u32,
+            sample_rate: self.rate,
+            low_db: 10. * self.low_power.max(1e-12).log10() + 3.01,
+            sub_db: 10. * self.sub_power.max(1e-12).log10() + 3.01,
+            scope_ms: (self.scope_stride * SCOPE) as f32 / self.rate * 1000.,
+            ..AnalyzerFrame::default()
+        };
+        let v = self.synth.voice;
+        if v.amp > 0. && !v.releasing {
+            f.hz = v.hz;
+            f.note = Some(hz_to_midi(v.hz).round().clamp(0., 127.) as u8);
+        }
+        // Trigger on the latest rising zero crossing that still leaves a full window behind it.
+        let n = 2 * SCOPE;
+        let oldest = self.scope_at;
+        let mut start = oldest;
+        for back in 0..SCOPE {
+            let i = (oldest + SCOPE - back) % n;
+            let prev = (i + n - 1) % n;
+            if self.scope_sub[prev] < 0. && self.scope_sub[i] >= 0. {
+                start = i;
+                break;
+            }
+        }
+        for k in 0..SCOPE {
+            let i = (start + k) % n;
+            f.scope_low[k] = self.scope_low[i];
+            f.scope_sub[k] = self.scope_sub[i];
+        }
+        f
+    }
+}
@@ -0,0 +1,95 @@
+//! Host-independent controls. Levels in dB, times in milliseconds, frequencies in Hz.
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
+pub enum Source {
+    /// Pitch and note starts are detected from the incoming bass.
+    #[default]
+    Audio,
+    /// Notes come from MIDI note input; the audio only supplies the band above the split.
+    Midi,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+pub struct Settings {
+    pub source: Source,
+    /// Peak level of the new sub in dBFS, the same for every note.
+    pub level: f32,
+    /// Crossover frequency: below it the original sub is replaced.
+    pub split: f32,
+    /// 0 % holds a constant level per note; 100 % follows the original low band's shape.
+    pub dynamics: f32,
+    /// Soft saturation of the sine, adding upper harmonics for small speakers.
+    pub drive: f32,
+    pub octave: i32,
+    /// Pitch slide time between overlapping notes.
+    pub glide: f32,
+    /// Start phase in degrees on every note start.
+    pub phase: f32,
+    /// Detection threshold in dBFS for note starts (Audio source).
+    pub gate: f32,
+    /// Amount of the original low band that is kept under the new sub.
+    pub keep: f32,
+    pub output: f32,
+    /// Restart the sine at `phase` on every note, so each note and kick hit lines up the same.
+    pub retrigger: bool,
+    /// Round detected pitch to the nearest semitone.
+    pub snap: bool,
+    pub bypass: bool,
+}
+impl Default for Settings {
+    fn default() -> Self {
+        Self {
+            source: Source::Audio,
+            level: -9.,
+            split: 90.,
+            dynamics: 0.,
+            drive: 0.,
+            octave: 0,
+            glide: 0.,
+            phase: 0.,
+            gate: -42.,
+            keep: 0.,
+            output: 0.,
+            retrigger: true,
+            snap: true,
+            bypass: false,
+        }
+    }
+}
+impl Settings {
+    pub fn validate(&self) -> Result<(), &'static str> {
+        let finite = [
+            self.level,
+            self.split,
+            self.dynamics,
+            self.drive,
+            self.glide,
+            self.phase,
+            self.gate,
+            self.keep,
+            self.output,
+        ]
+        .iter()
+        .all(|v| v.is_finite());
+        if !finite {
+            return Err("non-finite setting");
+        }
+        let ok = (-30.0..=0.).contains(&self.level)
+            && (40.0..=200.).contains(&self.split)
+            && (0.0..=100.).contains(&self.dynamics)
+            && (0.0..=100.).contains(&self.drive)
+            && (-2..=1).contains(&self.octave)
+            && (0.0..=200.).contains(&self.glide)
+            && (0.0..=360.).contains(&self.phase)
+            && (-60.0..=-20.).contains(&self.gate)
+            && (0.0..=100.).contains(&self.keep)
+            && (-12.0..=12.).contains(&self.output);
+        if ok {
+            Ok(())
+        } else {
+            Err("setting out of range")
+        }
+    }
+}
@@ -0,0 +1,213 @@
+use anvil_core::{Engine, Monitor, Settings, Source};
+use common_dsp::Saw;
+
+const RATE: f32 = 48000.;
+
+/// Saw notes (start s, end s, Hz, peak) with 1 ms fades.
+fn notes(list: &[(f32, f32, f32, f32)], total: f32) -> Vec<f32> {
+    let mut x = vec![0.; (total * RATE) as usize];
+    for &(a, b, hz, amp) in list {
+        let (a, b) = ((a * RATE) as usize, (b * RATE) as usize);
+        let mut saw = Saw::new(RATE, hz);
+        let fade = (0.001 * RATE) as usize;
+        for i in a..b.min(x.len()) {
+            let edge = ((i - a).min(b - 1 - i) as f32 / fade as f32).min(1.);
+            x[i] += saw.sample() * amp * edge;
+        }
+    }
+    x
+}
+fn render(e: &mut Engine, x: &[f32], solo: bool) -> Vec<f32> {
+    x.iter()
+        .map(|&s| e.process_sample([s, s], Monitor { solo })[0])
+        .collect()
+}
+fn rms(x: &[f32]) -> f32 {
+    (x.iter().map(|v| v * v).sum::<f32>() / x.len() as f32).sqrt()
+}
+fn db(x: f32) -> f32 {
+    20. * x.max(1e-9).log10()
+}
+/// Frequency from interpolated rising zero crossings.
+fn frequency(x: &[f32]) -> f32 {
+    let mut first = None;
+    let mut last = 0.;
+    let mut count = 0;
+    for i in 1..x.len() {
+        if x[i - 1] < 0. && x[i] >= 0. {
+            let t = (i - 1) as f32 + x[i - 1] / (x[i - 1] - x[i]);
+            if first.is_none() {
+                first = Some(t);
+            } else {
+                count += 1;
+            }
+            last = t;
+        }
+    }
+    count as f32 * RATE / (last - first.unwrap())
+}
+fn seconds(t: f32) -> usize {
+    (t * RATE) as usize
+}
+fn engine(s: Settings) -> (Engine, usize) {
+    let mut e = Engine::new(RATE, 2).unwrap();
+    e.set_settings(s).unwrap();
+    let l = e.latency_samples() as usize;
+    (e, l)
+}
+
+#[test]
+fn every_note_gets_the_same_sub_level() {
+    let (mut e, l) = engine(Settings::default());
+    let x = notes(&[(0.1, 0.6, 55., 0.5), (0.8, 1.3, 55., 0.1)], 1.6);
+    let y = render(&mut e, &x, true);
+    let loud = rms(&y[seconds(0.3) + l..seconds(0.5) + l]);
+    let quiet = rms(&y[seconds(1.0) + l..seconds(1.2) + l]);
+    assert!(
+        (db(loud) - db(quiet)).abs() < 0.5,
+        "{} vs {}",
+        db(loud),
+        db(quiet)
+    );
+    // −9 dBFS peak sine.
+    assert!((db(loud * 2f32.sqrt()) + 9.).abs() < 0.5, "{}", db(loud));
+}
+
+#[test]
+fn sub_follows_the_detected_pitch_and_octave() {
+    for (octave, expect) in [(0, 43.654), (-1, 21.827)] {
+        let (mut e, l) = engine(Settings {
+            octave,
+            ..Settings::default()
+        });
+        let x = notes(&[(0.1, 1.1, 43.65, 0.5)], 1.3);
+        let y = render(&mut e, &x, true);
+        let f = frequency(&y[seconds(0.3) + l..seconds(1.0) + l]);
+        assert!((f / expect - 1.).abs() < 0.005, "octave {octave}: {f}");
+    }
+}
+
+#[test]
+fn a_pitch_change_without_a_gap_is_a_new_note() {
+    let (mut e, l) = engine(Settings::default());
+    let x = notes(&[(0.1, 0.6, 55., 0.5), (0.6, 1.1, 82.41, 0.5)], 1.3);
+    let y = render(&mut e, &x, true);
+    let f = frequency(&y[seconds(0.75) + l..seconds(1.05) + l]);
+    assert!((f / 82.41 - 1.).abs() < 0.005, "{f}");
+}
+
+#[test]
+fn every_note_restarts_at_the_start_phase() {
+    let (mut e, l) = engine(Settings {
+        phase: 90.,
+        ..Settings::default()
+    });
+    let x = notes(&[(0.1, 0.4, 55., 0.5), (0.6, 0.9, 55., 0.3)], 1.1);
+    let y = render(&mut e, &x, true);
+    let period = (RATE / 55.) as usize;
+    let a = &y[seconds(0.1) + l..seconds(0.1) + l + 2 * period];
+    let b = &y[seconds(0.6) + l..seconds(0.6) + l + 2 * period];
+    let peak = y.iter().fold(0f32, |m, v| m.max(v.abs()));
+    let worst = a.iter().zip(b).fold(0f32, |m, (p, q)| m.max((p - q).abs()));
+    assert!(worst < 0.1 * peak, "{worst} of {peak}");
+    // Fit the phase over the second period, after the 2 ms attack.
+    let w = std::f32::consts::TAU * 55. / RATE;
+    let (mut s, mut c) = (0., 0.);
+    for (k, v) in a.iter().enumerate().skip(period) {
+        s += v * (w * k as f32).sin();
+        c += v * (w * k as f32).cos();
+    }
+    let phase = c.atan2(s).to_degrees();
+    assert!((phase - 90.).abs() < 20., "{phase}");
+}
+
+#[test]
+fn midi_notes_set_pitch_and_are_delayed_by_the_latency() {
+    let (mut e, l) = engine(Settings {
+        source: Source::Midi,
+        ..Settings::default()
+    });
+    let mut y = Vec::new();
+    for i in 0..seconds(0.8) {
+        if i == 1000 {
+            e.note_on(33);
+        }
+        if i == seconds(0.6) {
+            e.note_off(33);
+        }
+        y.push(e.process_sample([0.; 2], Monitor { solo: true })[0]);
+    }
+    assert!(y[..1000 + l].iter().all(|v| *v == 0.));
+    assert!(y[1000 + l + 50].abs() > 0.);
+    let f = frequency(&y[seconds(0.2) + l..seconds(0.5)]);
+    assert!((f / 55. - 1.).abs() < 0.001, "{f}");
+    assert!(y[seconds(0.6) + l + seconds(0.05)..]
+        .iter()
+        .all(|v| v.abs() < 1e-6));
+}
+
+#[test]
+fn note_changes_do_not_click() {
+    let (mut e, _) = engine(Settings::default());
+    let x = notes(
+        &[
+            (0.1, 0.4, 55., 0.5),
+            (0.4, 0.7, 73.42, 0.5),
+            (0.7, 1.0, 41.2, 0.5),
+        ],
+        1.3,
+    );
+    let y = render(&mut e, &x, true);
+    let step = y.windows(2).fold(0f32, |m, w| m.max((w[1] - w[0]).abs()));
+    // A −9 dBFS sine at 73 Hz moves at most 0.0034 per sample.
+    assert!(step < 0.012, "{step}");
+}
+
+#[test]
+fn keep_without_notes_is_an_allpass() {
+    let (mut e, _) = engine(Settings {
+        source: Source::Midi,
+        keep: 100.,
+        ..Settings::default()
+    });
+    for hz in [40., 90., 300., 3000.] {
+        e.reset();
+        let x: Vec<f32> = (0..seconds(1.))
+            .map(|i| 0.3 * (std::f32::consts::TAU * hz * i as f32 / RATE).sin())
+            .collect();
+        let y = render(&mut e, &x, false);
+        let d = db(rms(&y[seconds(0.5)..])) - db(rms(&x[seconds(0.5)..]));
+        assert!(d.abs() < 0.1, "{hz}: {d}");
+    }
+}
+
+#[test]
+fn split_removes_original_sub_and_keeps_mids() {
+    let (mut e, l) = engine(Settings {
+        source: Source::Midi,
+        ..Settings::default()
+    });
+    let x: Vec<f32> = (0..seconds(1.))
+        .map(|i| 0.3 * (std::f32::consts::TAU * 40. * i as f32 / RATE).sin())
+        .collect();
+    let y = render(&mut e, &x, false);
+    assert!(db(rms(&y[seconds(0.5) + l..])) < db(0.3) - 18.);
+}
+
+#[test]
+fn settings_are_validated_and_serialise() {
+    let mut e = Engine::new(RATE, 1).unwrap();
+    assert!(e
+        .set_settings(Settings {
+            level: 3.,
+            ..Settings::default()
+        })
+        .is_err());
+    let json = serde_json::to_string(&Settings::default()).unwrap();
+    assert_eq!(
+        serde_json::from_str::<Settings>(&json).unwrap(),
+        Settings::default()
+    );
+    assert!(Engine::new(1000., 2).is_err());
+    assert!(Engine::new(48000., 3).is_err());
+}
@@ -0,0 +1,69 @@
+use anvil_core::{Engine, Monitor, Settings, Source};
+use std::{
+    alloc::{GlobalAlloc, Layout, System},
+    cell::Cell,
+};
+
+struct CheckedAllocator;
+thread_local! {
+    static CHECK:Cell<bool>=const {Cell::new(false)};
+    static OPERATIONS:Cell<usize>=const {Cell::new(0)};
+}
+fn record() {
+    if CHECK.try_with(Cell::get).unwrap_or(false) {
+        let _ = OPERATIONS.try_with(|n| n.set(n.get() + 1));
+    }
+}
+unsafe impl GlobalAlloc for CheckedAllocator {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        record();
+        unsafe { System.alloc(layout) }
+    }
+    unsafe fn dealloc(&self, pointer: *mut u8, layout: Layout) {
+        record();
+        unsafe { System.dealloc(pointer, layout) }
+    }
+    unsafe fn realloc(&self, pointer: *mut u8, layout: Layout, size: usize) -> *mut u8 {
+        record();
+        unsafe { System.realloc(pointer, layout, size) }
+    }
+}
+#[global_allocator]
+static ALLOCATOR: CheckedAllocator = CheckedAllocator;
+
+#[test]
+fn processing_notes_settings_and_analysis_do_not_allocate_or_free() {
+    let mut engine = Engine::new(48000., 2).unwrap();
+    let mut settings = Settings::default();
+    engine.set_settings(settings).unwrap();
+    CHECK.with(|v| v.set(true));
+    for i in 0..96000 {
+        if i % 4800 == 0 {
+            settings.split = 60. + (i % 100) as f32;
+            settings.source = if i > 48000 {
+                Source::Midi
+            } else {
+                Source::Audio
+            };
+            settings.octave = -((i / 4800) % 2);
+            engine.set_settings(settings).unwrap();
+            engine.note_on(30 + (i / 4800 % 12) as u8);
+        }
+        if i % 4800 == 2400 {
+            engine.note_off(30 + (i / 4800 % 12) as u8);
+        }
+        let t = i as f32 / 48000.;
+        let x = if (i / 2400) % 2 == 0 {
+            (std::f32::consts::TAU * 55. * t).sin() * 0.5
+        } else {
+            0.
+        };
+        std::hint::black_box(engine.process_sample([x, x], Monitor { solo: i % 3 == 0 }));
+        if i % 1600 == 0 {
+            std::hint::black_box(engine.take_analyzer());
+        }
+    }
+    engine.reset();
+    CHECK.with(|v| v.set(false));
+    assert_eq!(OPERATIONS.with(Cell::get), 0);
+}
@@ -0,0 +1,25 @@
+[package]
+name = "anvil"
+version = "0.2.0"
+edition = "2021"
+license = "ISC"
+
+[workspace]
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+nih_plug = { git = "https://github.com/robbert-vdh/nih-plug.git", rev = "de421011f41a6d10fc8c7a6084e4f4dee0143683", default-features = false }
+nih_plug_egui = { git = "https://github.com/robbert-vdh/nih-plug.git", rev = "de421011f41a6d10fc8c7a6084e4f4dee0143683" }
+anvil-core = { path = "../core" }
+anvil-ui = { path = "../ui" }
+crossbeam-queue = "0.3"
+
+[dev-dependencies]
+clap-sys = { git = "https://github.com/micahrj/clap-sys.git", rev = "25d7f53fdb6363ad63fbd80049cb7a42a97ac156" }
+serde_json = "1"
+
+[profile.release]
+lto = "thin"
+strip = "symbols"
@@ -0,0 +1,199 @@
+//! CLAP audio effect. All DSP state is owned by the processing thread.
+mod params;
+use anvil_core::{AnalyzerFrame, Engine, Monitor};
+use crossbeam_queue::ArrayQueue;
+use nih_plug::prelude::*;
+use nih_plug_egui::{create_egui_editor, egui};
+use params::AnvilParams;
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc,
+};
+
+struct Shared {
+    analyzer: ArrayQueue<AnalyzerFrame>,
+    solo: AtomicBool,
+}
+struct EditorData {
+    ui: anvil_ui::State,
+    gestures: [bool; 9],
+}
+pub struct Anvil {
+    params: Arc<AnvilParams>,
+    shared: Arc<Shared>,
+    engine: Option<Engine>,
+    publish_count: usize,
+    publish_interval: usize,
+}
+impl Default for Anvil {
+    fn default() -> Self {
+        Self {
+            params: Arc::new(AnvilParams::default()),
+            shared: Arc::new(Shared {
+                analyzer: ArrayQueue::new(2),
+                solo: AtomicBool::new(false),
+            }),
+            engine: None,
+            publish_count: 0,
+            publish_interval: 1600,
+        }
+    }
+}
+impl Plugin for Anvil {
+    const NAME: &'static str = "Anvil";
+    const VENDOR: &'static str = "Bass Foundry";
+    const URL: &'static str = "";
+    const EMAIL: &'static str = "";
+    const VERSION: &'static str = env!("CARGO_PKG_VERSION");
+    const AUDIO_IO_LAYOUTS: &'static [AudioIOLayout] = &[
+        AudioIOLayout {
+            main_input_channels: NonZeroU32::new(2),
+            main_output_channels: NonZeroU32::new(2),
+            ..AudioIOLayout::const_default()
+        },
+        AudioIOLayout {
+            main_input_channels: NonZeroU32::new(1),
+            main_output_channels: NonZeroU32::new(1),
+            ..AudioIOLayout::const_default()
+        },
+    ];
+    const MIDI_INPUT: MidiConfig = MidiConfig::Basic;
+    const SAMPLE_ACCURATE_AUTOMATION: bool = true;
+    type SysExMessage = ();
+    type BackgroundTask = ();
+    fn params(&self) -> Arc<dyn Params> {
+        self.params.clone()
+    }
+    fn editor(&mut self, _: AsyncExecutor<Self>) -> Option<Box<dyn Editor>> {
+        let params = self.params.clone();
+        let shared = self.shared.clone();
+        create_egui_editor(
+            params.editor.clone(),
+            EditorData {
+                ui: anvil_ui::State::default(),
+                gestures: [false; 9],
+            },
+            |ctx, data| {
+                data.ui.solo = false;
+                anvil_ui::style(ctx);
+            },
+            move |ctx, setter, data| {
+                while let Some(frame) = shared.analyzer.pop() {
+                    data.ui.accept_frame(frame);
+                }
+                let before = params.settings();
+                let mut edited = before;
+                nih_plug_egui::resizable_window::ResizableWindow::new("anvil-editor")
+                    .min_size(egui::vec2(
+                        anvil_ui::WIDTH as f32 - 80.,
+                        anvil_ui::HEIGHT as f32 - 40.,
+                    ))
+                    .show(ctx, &params.editor, |ui| {
+                        anvil_ui::show(ui, &mut edited, &mut data.ui)
+                    });
+                params.apply(
+                    setter,
+                    &before,
+                    &edited,
+                    data.ui.gesture_active,
+                    &mut data.gestures,
+                );
+                // Solo is a monitor only: never saved and never left on after the editor closes.
+                shared.solo.store(data.ui.solo, Ordering::Release);
+                if data.ui.analyzer.note.is_some() {
+                    ctx.request_repaint();
+                }
+            },
+        )
+    }
+    fn initialize(
+        &mut self,
+        layout: &AudioIOLayout,
+        config: &BufferConfig,
+        context: &mut impl InitContext<Self>,
+    ) -> bool {
+        let Ok(mut engine) = Engine::new(
+            config.sample_rate,
+            layout.main_input_channels.map_or(0, |v| v.get() as usize),
+        ) else {
+            return false;
+        };
+        if engine.set_settings(self.params.settings()).is_err() {
+            return false;
+        }
+        context.set_latency_samples(engine.latency_samples());
+        self.publish_interval = (config.sample_rate / 30.) as usize;
+        self.engine = Some(engine);
+        self.shared.solo.store(false, Ordering::Release);
+        true
+    }
+    fn reset(&mut self) {
+        if let Some(e) = self.engine.as_mut() {
+            e.reset();
+        }
+        self.publish_count = 0;
+    }
+    fn process(
+        &mut self,
+        buffer: &mut Buffer,
+        _: &mut AuxiliaryBuffers,
+        context: &mut impl ProcessContext<Self>,
+    ) -> ProcessStatus {
+        let Some(engine) = self.engine.as_mut() else {
+            return ProcessStatus::Normal;
+        };
+        let _ = engine.set_settings(self.params.settings());
+        let solo = self.shared.solo.load(Ordering::Acquire) && self.params.editor.is_open();
+        let mut next = context.next_event();
+        for (index, mut sample) in buffer.iter_samples().enumerate() {
+            while let Some(event) = next {
+                if event.timing() as usize > index {
+                    break;
+                }
+                match event {
+                    NoteEvent::NoteOn { note, velocity, .. } if velocity > 0. => {
+                        engine.note_on(note)
+                    }
+                    NoteEvent::NoteOn { note, .. } | NoteEvent::NoteOff { note, .. } => {
+                        engine.note_off(note)
+                    }
+                    NoteEvent::Choke { note, .. } => engine.note_off(note),
+                    _ => {}
+                }
+                next = context.next_event();
+            }
+            let x = [
+                *sample.get_mut(0).unwrap(),
+                if engine.channels() == 2 {
+                    *sample.get_mut(1).unwrap()
+                } else {
+                    0.
+                },
+            ];
+            let out = engine.process_sample(x, Monitor { solo });
+            for (c, value) in sample.into_iter().enumerate() {
+                *value = out[c];
+            }
+            self.publish_count += 1;
+            if self.publish_count >= self.publish_interval {
+                self.shared.analyzer.force_push(engine.take_analyzer());
+                self.publish_count = 0;
+            }
+        }
+        // The lookahead delay and the sub release must drain after input stops.
+        ProcessStatus::KeepAlive
+    }
+}
+impl ClapPlugin for Anvil {
+    const CLAP_ID: &'static str = "io.narl.bass-foundry.anvil";
+    const CLAP_DESCRIPTION: Option<&'static str> =
+        Some("Replace the sub with a clean sine at one level and phase for every note");
+    const CLAP_MANUAL_URL: Option<&'static str> = None;
+    const CLAP_SUPPORT_URL: Option<&'static str> = None;
+    const CLAP_FEATURES: &'static [ClapFeature] = &[
+        ClapFeature::AudioEffect,
+        ClapFeature::Stereo,
+        ClapFeature::Mono,
+    ];
+}
+nih_export_clap!(Anvil);
@@ -0,0 +1,192 @@
+use anvil_core::{Settings, Source};
+use nih_plug::prelude::*;
+use nih_plug_egui::EguiState;
+use std::sync::Arc;
+
+#[derive(Enum, Debug, PartialEq, Eq, Clone, Copy)]
+pub enum SourceParam {
+    #[id = "audio"]
+    Audio,
+    #[id = "midi"]
+    #[name = "MIDI"]
+    Midi,
+}
+fn linear(name: &str, v: f32, min: f32, max: f32, unit: &'static str) -> FloatParam {
+    FloatParam::new(name, v, FloatRange::Linear { min, max }).with_unit(unit)
+}
+#[derive(Params)]
+pub struct AnvilParams {
+    #[persist = "editor"]
+    pub editor: Arc<EguiState>,
+    #[id = "source"]
+    pub source: EnumParam<SourceParam>,
+    #[id = "level"]
+    pub level: FloatParam,
+    #[id = "split"]
+    pub split: FloatParam,
+    #[id = "dynamics"]
+    pub dynamics: FloatParam,
+    #[id = "drive"]
+    pub drive: FloatParam,
+    #[id = "octave"]
+    pub octave: IntParam,
+    #[id = "glide"]
+    pub glide: FloatParam,
+    #[id = "phase"]
+    pub phase: FloatParam,
+    #[id = "gate"]
+    pub gate: FloatParam,
+    #[id = "keep"]
+    pub keep: FloatParam,
+    #[id = "output"]
+    pub output: FloatParam,
+    #[id = "retrigger"]
+    pub retrigger: BoolParam,
+    #[id = "snap"]
+    pub snap: BoolParam,
+    #[id = "bypass"]
+    pub bypass: BoolParam,
+}
+impl Default for AnvilParams {
+    fn default() -> Self {
+        let d = Settings::default();
+        Self {
+            editor: EguiState::from_size(anvil_ui::WIDTH, anvil_ui::HEIGHT),
+            source: EnumParam::new("Pitch source", SourceParam::Audio),
+            level: linear("Sub level", d.level, -30., 0., " dBFS"),
+            split: FloatParam::new(
+                "Split",
+                d.split,
+                FloatRange::Skewed {
+                    min: 40.,
+                    max: 200.,
+                    factor: FloatRange::skew_factor(-1.),
+                },
+            )
+            .with_unit(" Hz"),
+            dynamics: linear("Dynamics", d.dynamics, 0., 100., " %"),
+            drive: linear("Drive", d.drive, 0., 100., " %"),
+            octave: IntParam::new("Octave", d.octave, IntRange::Linear { min: -2, max: 1 }),
+            glide: linear("Glide", d.glide, 0., 200., " ms"),
+            phase: linear("Phase", d.phase, 0., 360., "°"),
+            gate: linear("Gate", d.gate, -60., -20., " dB"),
+            keep: linear("Keep", d.keep, 0., 100., " %"),
+            output: linear("Output", d.output, -12., 12., " dB"),
+            retrigger: BoolParam::new("Retrigger", d.retrigger),
+            snap: BoolParam::new("Snap to semitone", d.snap),
+            bypass: BoolParam::new("Bypass", false).make_bypass(),
+        }
+    }
+}
+impl AnvilParams {
+    pub fn settings(&self) -> Settings {
+        Settings {
+            source: match self.source.value() {
+                SourceParam::Audio => Source::Audio,
+                SourceParam::Midi => Source::Midi,
+            },
+            level: self.level.value(),
+            split: self.split.value(),
+            dynamics: self.dynamics.value(),
+            drive: self.drive.value(),
+            octave: self.octave.value(),
+            glide: self.glide.value(),
+            phase: self.phase.value(),
+            gate: self.gate.value(),
+            keep: self.keep.value(),
+            output: self.output.value(),
+            retrigger: self.retrigger.value(),
+            snap: self.snap.value(),
+            bypass: self.bypass.value(),
+        }
+    }
+    /// Pushes every changed editor value to the host. Continuous controls hold one
+    /// gesture while the pointer is down; switches are set in a single gesture.
+    pub fn apply(
+        &self,
+        setter: &ParamSetter,
+        old: &Settings,
+        new: &Settings,
+        dragging: bool,
+        open: &mut [bool; 9],
+    ) {
+        let floats: [(&FloatParam, f32, f32); 8] = [
+            (&self.level, old.level, new.level),
+            (&self.split, old.split, new.split),
+            (&self.dynamics, old.dynamics, new.dynamics),
+            (&self.drive, old.drive, new.drive),
+            (&self.glide, old.glide, new.glide),
+            (&self.phase, old.phase, new.phase),
+            (&self.gate, old.gate, new.gate),
+            (&self.keep, old.keep, new.keep),
+        ];
+        let mut continuous = |i: usize, changed: bool, set: &dyn Fn()| {
+            if changed {
+                if !open[i] {
+                    open[i] = true;
+                    set_begin(setter, self, i);
+                }
+                set();
+            }
+            if !dragging && open[i] {
+                set_end(setter, self, i);
+                open[i] = false;
+            }
+        };
+        for (i, (p, a, b)) in floats.into_iter().enumerate() {
+            continuous(i, a != b, &|| setter.set_parameter(p, b));
+        }
+        continuous(8, old.output != new.output, &|| {
+            setter.set_parameter(&self.output, new.output)
+        });
+        let once = |changed: bool, f: &dyn Fn()| {
+            if changed {
+                f();
+            }
+        };
+        once(new.octave != old.octave, &|| {
+            setter.begin_set_parameter(&self.octave);
+            setter.set_parameter(&self.octave, new.octave);
+            setter.end_set_parameter(&self.octave);
+        });
+        for (p, a, b) in [
+            (&self.retrigger, old.retrigger, new.retrigger),
+            (&self.snap, old.snap, new.snap),
+            (&self.bypass, old.bypass, new.bypass),
+        ] {
+            once(a != b, &|| {
+                setter.begin_set_parameter(p);
+                setter.set_parameter(p, b);
+                setter.end_set_parameter(p);
+            });
+        }
+        once(new.source != old.source, &|| {
+            let v = match new.source {
+                Source::Audio => SourceParam::Audio,
+                Source::Midi => SourceParam::Midi,
+            };
+            setter.begin_set_parameter(&self.source);
+            setter.set_parameter(&self.source, v);
+            setter.end_set_parameter(&self.source);
+        });
+    }
+    fn continuous(&self, i: usize) -> &FloatParam {
+        [
+            &self.level,
+            &self.split,
+            &self.dynamics,
+            &self.drive,
+            &self.glide,
+            &self.phase,
+            &self.gate,
+            &self.keep,
+            &self.output,
+        ][i]
+    }
+}
+fn set_begin(setter: &ParamSetter, p: &AnvilParams, i: usize) {
+    setter.begin_set_parameter(p.continuous(i));
+}
+fn set_end(setter: &ParamSetter, p: &AnvilParams, i: usize) {
+    setter.end_set_parameter(p.continuous(i));
+}
@@ -0,0 +1,212 @@
+//! Exercise the actual exported CLAP ABI without requiring a GUI or installed DAW.
+use clap_sys::{
+    audio_buffer::*,
+    events::*,
+    ext::{audio_ports::*, latency::*, state::*},
+    factory::plugin_factory::*,
+    host::*,
+    process::*,
+    stream::*,
+    version::*,
+};
+use std::{
+    ffi::{c_char, c_void, CStr},
+    io::{Cursor, Read},
+    ptr,
+};
+
+unsafe extern "C" fn extension(_: *const clap_host, _: *const c_char) -> *const c_void {
+    ptr::null()
+}
+unsafe extern "C" fn request(_: *const clap_host) {}
+unsafe extern "C" fn count(_: *const clap_input_events) -> u32 {
+    0
+}
+unsafe extern "C" fn event(_: *const clap_input_events, _: u32) -> *const clap_event_header {
+    ptr::null()
+}
+unsafe extern "C" fn push(_: *const clap_output_events, _: *const clap_event_header) -> bool {
+    true
+}
+unsafe extern "C" fn write(stream: *const clap_ostream, buffer: *const c_void, size: u64) -> i64 {
+    // SAFETY: The test owns the Vec for the entire synchronous save call.
+    let bytes = unsafe { &mut *((*stream).ctx as *mut Vec<u8>) };
+    bytes.extend_from_slice(unsafe {
+        std::slice::from_raw_parts(buffer as *const u8, size as usize)
+    });
+    size as i64
+}
+unsafe extern "C" fn read(stream: *const clap_istream, buffer: *mut c_void, size: u64) -> i64 {
+    // SAFETY: The test owns the Cursor; the wrapper supplies writable stream storage.
+    let cursor = unsafe { &mut *((*stream).ctx as *mut Cursor<Vec<u8>>) };
+    cursor
+        .read(unsafe { std::slice::from_raw_parts_mut(buffer as *mut u8, size as usize) })
+        .unwrap() as i64
+}
+
+#[test]
+fn effect_ports_state_latency_and_audio_lifecycle() {
+    // SAFETY: All callbacks, strings, streams, buffers, and the host outlive their
+    // synchronous ABI calls. Activation/processing/destruction follow CLAP order.
+    unsafe {
+        let entry = &anvil::clap_entry;
+        assert!(entry.init.unwrap()(c"anvil.clap".as_ptr()));
+        let factory = entry.get_factory.unwrap()(CLAP_PLUGIN_FACTORY_ID.as_ptr())
+            as *const clap_plugin_factory;
+        assert!(!factory.is_null());
+        let factory = &*factory;
+        assert_eq!(factory.get_plugin_count.unwrap()(factory), 1);
+        let descriptor = factory.get_plugin_descriptor.unwrap()(factory, 0);
+        assert!(!descriptor.is_null());
+        assert_eq!(CStr::from_ptr((*descriptor).name), c"Anvil");
+        assert_eq!(
+            CStr::from_ptr((*descriptor).id),
+            c"io.narl.bass-foundry.anvil"
+        );
+        assert!(factory.get_plugin_descriptor.unwrap()(factory, 1).is_null());
+        let host = clap_host {
+            clap_version: CLAP_VERSION,
+            host_data: ptr::null_mut(),
+            name: c"Storyboard test host".as_ptr(),
+            vendor: c"Tests".as_ptr(),
+            url: c"".as_ptr(),
+            version: c"1.0".as_ptr(),
+            get_extension: Some(extension),
+            request_restart: Some(request),
+            request_process: Some(request),
+            request_callback: Some(request),
+        };
+        let plugin = factory.create_plugin.unwrap()(factory, &host, (*descriptor).id);
+        assert!(!plugin.is_null());
+        let p = &*plugin;
+        assert!(p.init.unwrap()(plugin));
+        let ports = p.get_extension.unwrap()(plugin, CLAP_EXT_AUDIO_PORTS.as_ptr())
+            as *const clap_plugin_audio_ports;
+        assert!(!ports.is_null());
+        assert_eq!((*ports).count.unwrap()(plugin, false), 1);
+        assert_eq!((*ports).count.unwrap()(plugin, true), 1);
+        let latency = p.get_extension.unwrap()(plugin, CLAP_EXT_LATENCY.as_ptr())
+            as *const clap_plugin_latency;
+        assert!(!latency.is_null());
+        let state =
+            p.get_extension.unwrap()(plugin, CLAP_EXT_STATE.as_ptr()) as *const clap_plugin_state;
+        assert!(!state.is_null());
+        let state = &*state;
+        let save = || {
+            let mut bytes = Vec::new();
+            let stream = clap_ostream {
+                ctx: &mut bytes as *mut Vec<u8> as *mut c_void,
+                write: Some(write),
+            };
+            assert!(state.save.unwrap()(plugin, &stream));
+            bytes
+        };
+        let mut envelope: nih_plug::prelude::PluginState =
+            serde_json::from_slice(&save()[8..]).unwrap();
+        use nih_plug::wrapper::state::ParamValue;
+        envelope
+            .params
+            .insert("level".into(), ParamValue::F32(-14.));
+        envelope.params.insert("octave".into(), ParamValue::I32(-1));
+        envelope
+            .params
+            .insert("snap".into(), ParamValue::Bool(false));
+        envelope
+            .params
+            .insert("source".into(), ParamValue::String("midi".into()));
+        let encoded = serde_json::to_vec(&envelope).unwrap();
+        let mut framed = (encoded.len() as u64).to_le_bytes().to_vec();
+        framed.extend_from_slice(&encoded);
+        let mut bytes = Cursor::new(framed);
+        let stream = clap_istream {
+            ctx: &mut bytes as *mut Cursor<Vec<u8>> as *mut c_void,
+            read: Some(read),
+        };
+        assert!(state.load.unwrap()(plugin, &stream));
+        let restored: nih_plug::prelude::PluginState =
+            serde_json::from_slice(&save()[8..]).unwrap();
+        assert_eq!(
+            serde_json::to_value(&restored.params).unwrap(),
+            serde_json::to_value(&envelope.params).unwrap()
+        );
+        assert!(!restored.fields.contains_key("solo"));
+        for rate in [44100., 48000., 96000.] {
+            assert!(p.activate.unwrap()(plugin, rate, 1, 512));
+            let delay = (*latency).get.unwrap()(plugin) as usize;
+            // About 80 ms of lookahead: two periods of the lowest detected note.
+            assert!((delay as f64 / rate - 0.08).abs() < 0.01, "{delay}");
+            assert!(p.start_processing.unwrap()(plugin));
+            let total = delay + 9600;
+            let mut position = 0;
+            let (mut energy_in, mut energy_out) = (0f64, 0f64);
+            while position < total {
+                let frames = [1, 127, 512, 31][position % 4].min(total - position);
+                // A 1 kHz tone sits above the split and passes through unchanged.
+                let tone = |n: usize| {
+                    0.25 * (std::f64::consts::TAU * 1000. * n as f64 / rate).sin() as f32
+                };
+                let mut input_left = [0f32; 512];
+                let mut input_right = [0f32; 512];
+                for i in 0..frames {
+                    input_left[i] = tone(position + i);
+                    input_right[i] = -tone(position + i);
+                }
+                let mut left = [0f32; 512];
+                let mut right = [0f32; 512];
+                let mut in_channels = [input_left.as_mut_ptr(), input_right.as_mut_ptr()];
+                let mut out_channels = [left.as_mut_ptr(), right.as_mut_ptr()];
+                let incoming = clap_audio_buffer {
+                    data32: in_channels.as_mut_ptr(),
+                    data64: ptr::null_mut(),
+                    channel_count: 2,
+                    latency: 0,
+                    constant_mask: 0,
+                };
+                let mut outgoing_audio = clap_audio_buffer {
+                    data32: out_channels.as_mut_ptr(),
+                    data64: ptr::null_mut(),
+                    channel_count: 2,
+                    latency: 0,
+                    constant_mask: 0,
+                };
+                let input = clap_input_events {
+                    ctx: ptr::null_mut(),
+                    size: Some(count),
+                    get: Some(event),
+                };
+                let outgoing = clap_output_events {
+                    ctx: ptr::null_mut(),
+                    try_push: Some(push),
+                };
+                let process = clap_process {
+                    steady_time: position as i64,
+                    frames_count: frames as u32,
+                    transport: ptr::null(),
+                    audio_inputs: &incoming,
+                    audio_outputs: &mut outgoing_audio,
+                    audio_inputs_count: 1,
+                    audio_outputs_count: 1,
+                    in_events: &input,
+                    out_events: &outgoing,
+                };
+                assert_ne!(p.process.unwrap()(plugin, &process), CLAP_PROCESS_ERROR);
+                for i in 0..frames {
+                    let n = position + i;
+                    if n < delay {
+                        assert!(left[i].abs() < 1e-6, "output before the lookahead");
+                    } else if n > delay + 4800 {
+                        energy_in += (tone(n - delay) as f64).powi(2);
+                        energy_out += (left[i] as f64).powi(2) + (right[i] as f64).powi(2);
+                    }
+                }
+                position += frames;
+            }
+            let ratio_db = 10. * (energy_out / (2. * energy_in)).log10();
+            assert!(ratio_db.abs() < 0.2, "{ratio_db}");
+            p.stop_processing.unwrap()(plugin);
+            p.deactivate.unwrap()(plugin);
+        }
+        p.destroy.unwrap()(plugin);
+        entry.deinit.unwrap()();
+    }
+}
@@ -0,0 +1,11 @@
+[package]
+name = "anvil-ui"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+egui = "0.31.1"
+anvil-core = { path = "../core" }
+common-ui = { path = "../../common/ui" }
+common-dsp = { path = "../../common/dsp" }
@@ -0,0 +1,350 @@
+//! Anvil editor, shared by the CLAP wrapper and the headless renderer.
+use anvil_core::{AnalyzerFrame, Settings, Source, SCOPE};
+use common_ui::*;
+use egui::{self, Color32, FontId, Pos2, RichText, Sense, Stroke, Vec2};
+
+pub use common_ui::style;
+pub const WIDTH: u32 = 980;
+pub const HEIGHT: u32 = 704;
+
+pub struct State {
+    pub solo: bool,
+    pub analyzer: AnalyzerFrame,
+    /// True while a pointer button is held, so knob drags become one host gesture.
+    pub gesture_active: bool,
+    pub help: String,
+}
+impl Default for State {
+    fn default() -> Self {
+        Self {
+            solo: false,
+            analyzer: AnalyzerFrame::default(),
+            gesture_active: false,
+            help: DEFAULT_HELP.into(),
+        }
+    }
+}
+const DEFAULT_HELP: &str =
+    "Put Anvil on the bass, set Split just above the sub, then set Sub level once for every patch.";
+impl State {
+    pub fn accept_frame(&mut self, frame: AnalyzerFrame) {
+        let old = self.analyzer;
+        self.analyzer = frame;
+        // Meters fall smoothly; the readout and scope stay exact.
+        self.analyzer.low_db = frame.low_db.max(old.low_db - 1.5);
+        self.analyzer.sub_db = frame.sub_db.max(old.sub_db - 1.5);
+    }
+}
+fn hint(r: &egui::Response, state: &mut State, text: &str) {
+    if r.hovered() || r.has_focus() {
+        state.help = text.into();
+    }
+}
+#[allow(clippy::too_many_arguments)]
+fn knob(
+    ui: &mut egui::Ui,
+    state: &mut State,
+    name: &str,
+    value: &mut f32,
+    range: std::ops::RangeInclusive<f32>,
+    default: f32,
+    unit: &str,
+    size: f32,
+    help: &str,
+) {
+    ui.vertical_centered(|ui| {
+        let r = rotary(ui, name, value, range, default, unit, size, ACCENT);
+        hint(&r, state, help);
+    });
+}
+fn toggle(ui: &mut egui::Ui, state: &mut State, on: &mut bool, label: &str, help: &str) {
+    let r = ui.selectable_label(*on, RichText::new(label).size(13.));
+    if r.clicked() {
+        *on = !*on;
+    }
+    hint(&r, state, help);
+}
+fn scope(ui: &mut egui::Ui, frame: &AnalyzerFrame, height: f32) {
+    let (rect, _) = ui.allocate_exact_size(Vec2::new(ui.available_width(), height), Sense::hover());
+    let p = ui.painter_at(rect);
+    p.rect_filled(rect, 2., SCREEN);
+    let mid = rect.center().y;
+    for k in 1..6 {
+        let x = rect.left() + rect.width() * k as f32 / 6.;
+        p.line_segment(
+            [Pos2::new(x, rect.top()), Pos2::new(x, rect.bottom())],
+            Stroke::new(1.0_f32, Color32::from_rgb(24, 26, 30)),
+        );
+    }
+    p.line_segment(
+        [Pos2::new(rect.left(), mid), Pos2::new(rect.right(), mid)],
+        Stroke::new(1.0_f32, EDGE),
+    );
+    let peak = frame
+        .scope_low
+        .iter()
+        .chain(frame.scope_sub.iter())
+        .fold(0.05f32, |m, v| m.max(v.abs()));
+    let scale = rect.height() * 0.42 / peak;
+    for (data, color, width) in [
+        (&frame.scope_low, STEEL, 1.5_f32),
+        (&frame.scope_sub, ACCENT, 2.0_f32),
+    ] {
+        let points: Vec<Pos2> = data
+            .iter()
+            .enumerate()
+            .map(|(i, v)| {
+                Pos2::new(
+                    rect.left() + rect.width() * i as f32 / (SCOPE - 1) as f32,
+                    mid - v * scale,
+                )
+            })
+            .collect();
+        p.add(egui::Shape::line(points, Stroke::new(width, color)));
+    }
+    p.text(
+        rect.left_top() + Vec2::new(10., 8.),
+        egui::Align2::LEFT_TOP,
+        "ORIGINAL LOW BAND",
+        FontId::proportional(11.),
+        STEEL,
+    );
+    p.text(
+        rect.left_top() + Vec2::new(130., 8.),
+        egui::Align2::LEFT_TOP,
+        "NEW SUB",
+        FontId::proportional(11.),
+        ACCENT,
+    );
+    p.text(
+        rect.right_top() + Vec2::new(-10., 8.),
+        egui::Align2::RIGHT_TOP,
+        format!("{:.0} ms", frame.scope_ms),
+        FontId::proportional(11.),
+        MUTED,
+    );
+    p.rect_stroke(
+        rect,
+        2.,
+        Stroke::new(1.0_f32, EDGE),
+        egui::StrokeKind::Inside,
+    );
+}
+
+pub fn show(ui: &mut egui::Ui, settings: &mut Settings, state: &mut State) {
+    backdrop(ui);
+    state.help = DEFAULT_HELP.into();
+    state.gesture_active = ui.input(|i| i.pointer.any_down());
+    ui.add_space(2.);
+    header(ui, "ANVIL", "SUB ANCHOR", |ui| {
+        let r = ui
+            .selectable_label(settings.bypass, RichText::new("BYPASS").size(13.))
+            .on_hover_text("Crossfade to the delayed dry signal.");
+        if r.clicked() {
+            settings.bypass = !settings.bypass;
+        }
+        let r = ui
+            .selectable_label(state.solo, RichText::new("SOLO SUB").size(13.))
+            .on_hover_text("Hear only the generated sub.");
+        if r.clicked() {
+            state.solo = !state.solo;
+        }
+        ui.separator();
+        for (source, label) in [(Source::Midi, "MIDI"), (Source::Audio, "AUDIO")] {
+            let r = ui.selectable_label(settings.source == source, RichText::new(label).size(13.));
+            if r.clicked() {
+                settings.source = source;
+            }
+        }
+        caption(ui, "PITCH FROM");
+    });
+    ui.add_space(6.);
+    let frame = state.analyzer;
+    ui.horizontal_top(|ui| {
+        panel(ui, |ui| {
+            ui.set_width(260.);
+            ui.set_min_height(TOP);
+            ui.vertical(|ui| note_panel(ui, settings, &frame));
+        });
+        ui.add_space(4.);
+        panel(ui, |ui| {
+            ui.set_width(ui.available_width());
+            scope(ui, &frame, TOP);
+        });
+    });
+    ui.add_space(6.);
+    panel(ui, |ui| {
+        ui.set_width(ui.available_width());
+        ui.vertical(|ui| controls(ui, settings, state));
+    });
+    ui.separator();
+    ui.label(RichText::new(&state.help).color(MUTED));
+}
+const TOP: f32 = 196.;
+fn note_panel(ui: &mut egui::Ui, settings: &Settings, frame: &AnalyzerFrame) {
+    caption(ui, "NOTE");
+    let (name, hz) = match frame.note {
+        Some(n) if frame.hz > 0. => (common_dsp::note_name(n), format!("{:.1} Hz", frame.hz)),
+        _ => ("—".into(), "no note".into()),
+    };
+    ui.label(
+        RichText::new(name)
+            .font(FontId::new(54., egui::FontFamily::Name("medium".into())))
+            .color(if frame.note.is_some() { TEXT } else { DIM }),
+    );
+    ui.label(RichText::new(hz).monospace().size(14.).color(MUTED));
+    ui.add_space(10.);
+    meter(ui, "ORIGINAL", frame.low_db, STEEL, 100.);
+    meter(ui, "NEW SUB", frame.sub_db, ACCENT, 100.);
+    ui.add_space(10.);
+    ui.label(
+        RichText::new(format!(
+            "{:.0} ms lookahead · {}",
+            frame.latency as f32 / frame.sample_rate * 1000.,
+            match settings.source {
+                Source::Audio => "detecting pitch",
+                Source::Midi => "following MIDI notes",
+            }
+        ))
+        .size(12.)
+        .color(MUTED),
+    );
+}
+fn controls(ui: &mut egui::Ui, settings: &mut Settings, state: &mut State) {
+    let defaults = Settings::default();
+    ui.columns(4, |c| {
+        knob(
+            &mut c[0],
+            state,
+            "Sub level",
+            &mut settings.level,
+            -30. ..=0.,
+            defaults.level,
+            " dBFS",
+            88.,
+            "Peak level of the new sub. Every note gets exactly this level.",
+        );
+        knob(
+            &mut c[1],
+            state,
+            "Split",
+            &mut settings.split,
+            40. ..=200.,
+            defaults.split,
+            " Hz",
+            88.,
+            "Below this frequency the original sub is replaced.",
+        );
+        knob(
+            &mut c[2],
+            state,
+            "Dynamics",
+            &mut settings.dynamics,
+            0. ..=100.,
+            defaults.dynamics,
+            " %",
+            88.,
+            "0 %: constant level per note. Higher: follow the original's wobble shape.",
+        );
+        knob(
+            &mut c[3],
+            state,
+            "Drive",
+            &mut settings.drive,
+            0. ..=100.,
+            defaults.drive,
+            " %",
+            88.,
+            "Adds upper harmonics so the sub reads on small speakers.",
+        );
+    });
+    ui.add_space(6.);
+    ui.separator();
+    ui.columns(6, |c| {
+        let mut octave = settings.octave as f32;
+        knob(
+            &mut c[0],
+            state,
+            "Octave",
+            &mut octave,
+            -2. ..=1.,
+            0.,
+            "",
+            54.,
+            "Shift the sub against the detected note. −1 for basses played high.",
+        );
+        settings.octave = octave.round() as i32;
+        knob(
+            &mut c[1],
+            state,
+            "Glide",
+            &mut settings.glide,
+            0. ..=200.,
+            defaults.glide,
+            " ms",
+            54.,
+            "Slide time when notes overlap. 0 jumps.",
+        );
+        knob(
+            &mut c[2],
+            state,
+            "Phase",
+            &mut settings.phase,
+            0. ..=360.,
+            defaults.phase,
+            "°",
+            54.,
+            "Start phase of every note. Line it up with your kick.",
+        );
+        knob(
+            &mut c[3],
+            state,
+            "Gate",
+            &mut settings.gate,
+            -60. ..=-20.,
+            defaults.gate,
+            " dB",
+            54.,
+            "Input level that counts as a note. Raise it if tails retrigger.",
+        );
+        knob(
+            &mut c[4],
+            state,
+            "Keep",
+            &mut settings.keep,
+            0. ..=100.,
+            defaults.keep,
+            " %",
+            54.,
+            "Blend some original low band back under the new sub.",
+        );
+        knob(
+            &mut c[5],
+            state,
+            "Output",
+            &mut settings.output,
+            -12. ..=12.,
+            defaults.output,
+            " dB",
+            54.,
+            "Output trim.",
+        );
+    });
+    ui.add_space(4.);
+    ui.horizontal(|ui| {
+        toggle(
+            ui,
+            state,
+            &mut settings.retrigger,
+            "RETRIGGER",
+            "Restart the sine at Phase on every note, so each note and kick hit lines up.",
+        );
+        toggle(
+            ui,
+            state,
+            &mut settings.snap,
+            "SNAP TO SEMITONE",
+            "Round the detected pitch. Turn off for slides and pitch bends.",
+        );
+    });
+}
@@ -6,7 +6,7 @@
    "library": "rivet",
    "documentation": "docs/rivet",
    "standalone": "rivet",
-    "clap_id": "io.storyboard.motif",
+    "clap_id": "io.narl.bass-foundry.rivet",
    "packages": [
      "rivet-core",
      "rivet-midi",
@@ -20,14 +20,115 @@
    "manifest": "plugins/patina/plugin/Cargo.toml",
    "library": "patina",
    "documentation": "docs/patina",
-    "clap_id": "io.storyboard.resonance-compressor",
+    "clap_id": "io.narl.bass-foundry.patina",
    "licenses": {
-      "plugins/patina/ui/assets/OFL.txt": "licenses/Roboto-OFL.txt"
+      "plugins/common/ui/assets/OFL.txt": "licenses/Roboto-OFL.txt"
    },
    "packages": [
+      "common-ui",
      "patina-core",
      "patina-ui",
      "patina-render"
    ]
+  },
+  "anvil": {
+    "name": "Anvil",
+    "description": "Replace the sub with a clean sine at one level and phase for every note",
+    "manifest": "plugins/anvil/plugin/Cargo.toml",
+    "library": "anvil",
+    "documentation": "docs/anvil",
+    "clap_id": "io.narl.bass-foundry.anvil",
+    "licenses": {
+      "plugins/common/ui/assets/OFL.txt": "licenses/Roboto-OFL.txt"
+    },
+    "packages": [
+      "common-ui",
+      "common-dsp",
+      "anvil-core",
+      "anvil-ui"
+    ]
+  },
+  "crucible": {
+    "name": "Crucible",
+    "description": "Capture the last bars, slice them and export clean, key-labelled samples",
+    "manifest": "plugins/crucible/plugin/Cargo.toml",
+    "library": "crucible",
+    "documentation": "docs/crucible",
+    "clap_id": "io.narl.bass-foundry.crucible",
+    "licenses": {
+      "plugins/common/ui/assets/OFL.txt": "licenses/Roboto-OFL.txt"
+    },
+    "packages": [
+      "common-ui",
+      "common-dsp",
+      "crucible-core",
+      "crucible-ui"
+    ]
+  },
+  "lathe": {
+    "name": "Lathe",
+    "description": "EQ the harmonics of the played note: a cut on harmonic 3 stays on harmonic 3",
+    "manifest": "plugins/lathe/plugin/Cargo.toml",
+    "library": "lathe",
+    "documentation": "docs/lathe",
+    "clap_id": "io.narl.bass-foundry.lathe",
+    "licenses": {
+      "plugins/common/ui/assets/OFL.txt": "licenses/Roboto-OFL.txt"
+    },
+    "packages": [
+      "common-ui",
+      "common-dsp",
+      "lathe-core",
+      "lathe-ui"
+    ]
+  },
+  "temper": {
+    "name": "Temper",
+    "description": "Distortion whose drive and tone filters follow the note, so every note distorts the same",
+    "manifest": "plugins/temper/plugin/Cargo.toml",
+    "library": "temper",
+    "documentation": "docs/temper",
+    "clap_id": "io.narl.bass-foundry.temper",
+    "licenses": {
+      "plugins/common/ui/assets/OFL.txt": "licenses/Roboto-OFL.txt"
+    },
+    "packages": [
+      "common-ui",
+      "common-dsp",
+      "temper-core",
+      "temper-ui"
+    ]
+  },
+  "weld": {
+    "name": "Weld",
+    "description": "Align the phase of a bass layer to a sidechain layer so the two sum instead of cancel",
+    "manifest": "plugins/weld/plugin/Cargo.toml",
+    "library": "weld",
+    "documentation": "docs/weld",
+    "clap_id": "io.narl.bass-foundry.weld",
+    "licenses": {
+      "plugins/common/ui/assets/OFL.txt": "licenses/Roboto-OFL.txt"
+    },
+    "packages": [
+      "common-ui",
+      "weld-core",
+      "weld-ui"
+    ]
+  },
+  "knurl": {
+    "name": "Knurl",
+    "description": "Give every cycle of the note its own level, timing and grit",
+    "manifest": "plugins/knurl/plugin/Cargo.toml",
+    "library": "knurl",
+    "documentation": "docs/knurl",
+    "clap_id": "io.narl.bass-foundry.knurl",
+    "licenses": {
+      "plugins/common/ui/assets/OFL.txt": "licenses/Roboto-OFL.txt"
+    },
+    "packages": [
+      "common-ui",
+      "knurl-core",
+      "knurl-ui"
+    ]
  }
 }
@@ -0,0 +1,7 @@
+[package]
+name = "common-dsp"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
@@ -0,0 +1,267 @@
+//! Shared allocation-free DSP building blocks: filters, pitch detection, notes, WAV files.
+pub mod meter;
+pub mod oversample;
+pub mod svf;
+pub mod tracker;
+pub mod wav;
+
+use std::f32::consts::TAU;
+
+/// Transposed direct form II biquad (RBJ cookbook coefficients).
+#[derive(Clone, Copy, Debug, Default)]
+pub struct Biquad {
+    b0: f32,
+    b1: f32,
+    b2: f32,
+    a1: f32,
+    a2: f32,
+    z1: f32,
+    z2: f32,
+}
+impl Biquad {
+    fn from(b: [f32; 3], a: [f32; 3]) -> Self {
+        Self {
+            b0: b[0] / a[0],
+            b1: b[1] / a[0],
+            b2: b[2] / a[0],
+            a1: a[1] / a[0],
+            a2: a[2] / a[0],
+            z1: 0.,
+            z2: 0.,
+        }
+    }
+    pub fn lowpass(rate: f32, hz: f32, q: f32) -> Self {
+        let w = TAU * (hz / rate).clamp(1e-5, 0.49);
+        let (s, c) = w.sin_cos();
+        let alpha = s / (2. * q);
+        Self::from(
+            [(1. - c) / 2., 1. - c, (1. - c) / 2.],
+            [1. + alpha, -2. * c, 1. - alpha],
+        )
+    }
+    pub fn highpass(rate: f32, hz: f32, q: f32) -> Self {
+        let w = TAU * (hz / rate).clamp(1e-5, 0.49);
+        let (s, c) = w.sin_cos();
+        let alpha = s / (2. * q);
+        Self::from(
+            [(1. + c) / 2., -(1. + c), (1. + c) / 2.],
+            [1. + alpha, -2. * c, 1. - alpha],
+        )
+    }
+    /// Peaking EQ; used by tests to model resonant material.
+    pub fn peak(rate: f32, hz: f32, q: f32, gain_db: f32) -> Self {
+        let w = TAU * (hz / rate).clamp(1e-5, 0.49);
+        let (s, c) = w.sin_cos();
+        let a = 10f32.powf(gain_db / 40.);
+        let alpha = s / (2. * q);
+        Self::from(
+            [1. + alpha * a, -2. * c, 1. - alpha * a],
+            [1. + alpha / a, -2. * c, 1. - alpha / a],
+        )
+    }
+    /// Replace the coefficients and keep the filter state, for smooth parameter changes.
+    pub fn retune(&mut self, other: Self) {
+        let (z1, z2) = (self.z1, self.z2);
+        *self = other;
+        self.z1 = z1;
+        self.z2 = z2;
+    }
+    #[inline]
+    pub fn process(&mut self, x: f32) -> f32 {
+        let y = self.b0 * x + self.z1;
+        self.z1 = self.b1 * x - self.a1 * y + self.z2;
+        self.z2 = self.b2 * x - self.a2 * y;
+        y
+    }
+    pub fn reset(&mut self) {
+        self.z1 = 0.;
+        self.z2 = 0.;
+    }
+}
+
+/// Fourth-order Linkwitz–Riley crossover. Low plus high is an allpass: flat magnitude.
+#[derive(Clone, Copy, Debug, Default)]
+pub struct Crossover {
+    low: [Biquad; 2],
+    high: [Biquad; 2],
+}
+impl Crossover {
+    pub fn new(rate: f32, hz: f32) -> Self {
+        let q = std::f32::consts::FRAC_1_SQRT_2;
+        Self {
+            low: [Biquad::lowpass(rate, hz, q); 2],
+            high: [Biquad::highpass(rate, hz, q); 2],
+        }
+    }
+    pub fn retune(&mut self, rate: f32, hz: f32) {
+        let fresh = Self::new(rate, hz);
+        for i in 0..2 {
+            self.low[i].retune(fresh.low[i]);
+            self.high[i].retune(fresh.high[i]);
+        }
+    }
+    /// Returns (low, high).
+    #[inline]
+    pub fn process(&mut self, x: f32) -> (f32, f32) {
+        let low = self.low[0].process(x);
+        let low = self.low[1].process(low);
+        let high = self.high[0].process(x);
+        let high = self.high[1].process(high);
+        // LR4 bands are in phase at the crossover point, so they sum to an allpass.
+        (low, high)
+    }
+    pub fn reset(&mut self) {
+        for f in self.low.iter_mut().chain(self.high.iter_mut()) {
+            f.reset();
+        }
+    }
+}
+
+/// YIN fundamental-frequency estimator with preallocated scratch.
+pub struct Yin {
+    diff: Vec<f32>,
+    pub threshold: f32,
+}
+impl Yin {
+    /// `max_lag` is the longest period in samples that will ever be requested.
+    pub fn new(max_lag: usize) -> Self {
+        Self {
+            diff: vec![0.; max_lag + 2],
+            threshold: 0.15,
+        }
+    }
+    pub fn max_lag(&self) -> usize {
+        self.diff.len() - 2
+    }
+    /// Estimates the fundamental of `x` in Hz with its clarity (1 = perfectly periodic).
+    /// `x` must hold at least twice the longest period. Never allocates.
+    pub fn estimate(
+        &mut self,
+        x: &[f32],
+        rate: f32,
+        min_hz: f32,
+        max_hz: f32,
+    ) -> Option<(f32, f32)> {
+        let hi = ((rate / min_hz).ceil() as usize).min(self.max_lag());
+        let lo = ((rate / max_hz).floor() as usize).max(2);
+        if hi <= lo + 2 || x.len() < hi + 2 {
+            return None;
+        }
+        let window = x.len() - hi - 1;
+        if window < hi {
+            return None;
+        }
+        let energy: f32 = x[..window].iter().map(|v| v * v).sum();
+        if energy < 1e-9 * window as f32 {
+            return None;
+        }
+        let d = &mut self.diff;
+        d[0] = 1.;
+        let mut running = 0.;
+        for tau in 1..=hi + 1 {
+            let mut s = 0.;
+            for j in 0..window {
+                let e = x[j] - x[j + tau];
+                s += e * e;
+            }
+            running += s;
+            // Cumulative-mean normalisation: suppresses the zero-lag dip.
+            d[tau] = if running > 0. {
+                s * tau as f32 / running
+            } else {
+                1.
+            };
+        }
+        let mut best = None;
+        let mut tau = lo;
+        while tau < hi {
+            if d[tau] < self.threshold {
+                while tau + 1 < hi && d[tau + 1] < d[tau] {
+                    tau += 1;
+                }
+                best = Some(tau);
+                break;
+            }
+            tau += 1;
+        }
+        let tau = match best {
+            Some(t) => t,
+            None => {
+                let (t, v) = (lo..hi)
+                    .map(|t| (t, d[t]))
+                    .min_by(|a, b| a.1.total_cmp(&b.1))?;
+                if v > 0.35 {
+                    return None;
+                }
+                t
+            }
+        };
+        let (a, b, c) = (d[tau - 1], d[tau], d[tau + 1]);
+        let denom = a - 2. * b + c;
+        let shift = if denom.abs() > 1e-12 {
+            (0.5 * (a - c) / denom).clamp(-1., 1.)
+        } else {
+            0.
+        };
+        Some((rate / (tau as f32 + shift), (1. - b).clamp(0., 1.)))
+    }
+}
+
+pub fn midi_to_hz(note: f32) -> f32 {
+    440. * 2f32.powf((note - 69.) / 12.)
+}
+pub fn hz_to_midi(hz: f32) -> f32 {
+    69. + 12. * (hz.max(1e-3) / 440.).log2()
+}
+/// Scientific note name: MIDI 60 = C4, 43.65 Hz = F1. FL Studio labels MIDI 60 as C5.
+pub fn note_name(note: u8) -> String {
+    const NAMES: [&str; 12] = [
+        "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B",
+    ];
+    format!("{}{}", NAMES[note as usize % 12], note as i32 / 12 - 1)
+}
+pub fn db_to_gain(db: f32) -> f32 {
+    10f32.powf(db / 20.)
+}
+pub fn gain_to_db(g: f32) -> f32 {
+    20. * g.abs().max(1e-9).log10()
+}
+/// One-pole smoothing coefficient for a time constant in milliseconds.
+pub fn coefficient(rate: f32, ms: f32) -> f32 {
+    if ms <= 0. {
+        1.
+    } else {
+        1. - (-1. / (rate * ms * 0.001)).exp()
+    }
+}
+/// PolyBLEP sawtooth oscillator: cheap and close to band-limited, for tests and previews.
+pub struct Saw {
+    phase: f32,
+    inc: f32,
+}
+impl Saw {
+    pub fn new(rate: f32, hz: f32) -> Self {
+        Self {
+            phase: 0.,
+            inc: hz / rate,
+        }
+    }
+    pub fn sample(&mut self) -> f32 {
+        let t = self.phase;
+        let dt = self.inc;
+        let blep = if t < dt {
+            let x = t / dt;
+            x + x - x * x - 1.
+        } else if t > 1. - dt {
+            let x = (t - 1.) / dt;
+            x * x + x + x + 1.
+        } else {
+            0.
+        };
+        self.phase += dt;
+        if self.phase >= 1. {
+            self.phase -= 1.;
+        }
+        2. * t - 1. - blep
+    }
+}
@@ -0,0 +1,91 @@
+//! Levels of the harmonics of a known fundamental, measured with Hann-windowed Goertzel
+//! filters. Work is spread evenly over the samples, so there is no per-window spike.
+use std::f32::consts::TAU;
+
+pub const HARMONICS: usize = 32;
+
+pub struct HarmonicMeter {
+    rate: f32,
+    window: Vec<f32>,
+    count: usize,
+    hz: f32,
+    coef: [f32; HARMONICS],
+    s1: [f32; HARMONICS],
+    s2: [f32; HARMONICS],
+    levels: [f32; HARMONICS],
+}
+impl HarmonicMeter {
+    /// Window of about `ms`; 85 ms resolves harmonics of fundamentals down to 30 Hz.
+    pub fn new(rate: f32, ms: f32) -> Self {
+        let n = ((rate * ms * 0.001) as usize).max(64);
+        Self {
+            rate,
+            window: (0..n)
+                .map(|i| 0.5 - 0.5 * (TAU * i as f32 / n as f32).cos())
+                .collect(),
+            count: 0,
+            hz: 0.,
+            coef: [0.; HARMONICS],
+            s1: [0.; HARMONICS],
+            s2: [0.; HARMONICS],
+            levels: [-120.; HARMONICS],
+        }
+    }
+    /// Peak level in dBFS of each harmonic (index 0 is the fundamental) from the last
+    /// complete window. Harmonics above 0.45 × the sample rate read −120.
+    pub fn levels(&self) -> &[f32; HARMONICS] {
+        &self.levels
+    }
+    /// Fundamental of the last complete window, 0 if none.
+    pub fn hz(&self) -> f32 {
+        self.hz
+    }
+    /// Feeds one sample. `hz` is read at the start of each window (0 = no note: skip it).
+    /// Returns true when a window completed and `levels` changed.
+    #[inline]
+    pub fn push(&mut self, x: f32, hz: f32) -> bool {
+        if self.count == 0 {
+            self.hz = hz;
+            for k in 0..HARMONICS {
+                let f = hz * (k + 1) as f32;
+                self.coef[k] = if hz > 0. && f < 0.45 * self.rate {
+                    2. * (TAU * f / self.rate).cos()
+                } else {
+                    0.
+                };
+            }
+            self.s1 = [0.; HARMONICS];
+            self.s2 = [0.; HARMONICS];
+        }
+        let w = x * self.window[self.count];
+        for k in 0..HARMONICS {
+            let s = w + self.coef[k] * self.s1[k] - self.s2[k];
+            self.s2[k] = self.s1[k];
+            self.s1[k] = s;
+        }
+        self.count += 1;
+        if self.count < self.window.len() {
+            return false;
+        }
+        self.count = 0;
+        let n = self.window.len() as f32;
+        for k in 0..HARMONICS {
+            let f = self.hz * (k + 1) as f32;
+            self.levels[k] = if self.hz > 0. && f < 0.45 * self.rate {
+                let c = self.coef[k];
+                let p =
+                    self.s1[k] * self.s1[k] + self.s2[k] * self.s2[k] - c * self.s1[k] * self.s2[k];
+                // Hann coherent gain is 0.5: a sine of peak A gives |X| = A·N/4.
+                let amp = 4. * p.max(0.).sqrt() / n;
+                20. * amp.max(1e-6).log10()
+            } else {
+                -120.
+            };
+        }
+        true
+    }
+    pub fn reset(&mut self) {
+        self.count = 0;
+        self.levels = [-120.; HARMONICS];
+    }
+}
@@ -0,0 +1,131 @@
+//! 4× oversampling with two linear-phase half-band FIR stages. The round trip (up, then
+//! down) delays the signal by a whole number of base-rate samples, `latency()`.
+const STAGE1_HALF: usize = 31; // 63 taps at 2×: steep, carries the audio band edge
+const STAGE2_HALF: usize = 11; // 23 taps at 4×: the band edge is far from its images
+const BETA: f32 = 9.;
+
+/// Kaiser-windowed half-band lowpass with gain `gain`, `2 * half + 1` taps.
+fn halfband(half: usize, gain: f32) -> Vec<f32> {
+    fn i0(x: f32) -> f32 {
+        let (mut sum, mut term) = (1f64, 1f64);
+        let y = (x as f64 / 2.).powi(2);
+        for k in 1..50 {
+            term *= y / (k * k) as f64;
+            sum += term;
+        }
+        sum as f32
+    }
+    let n = 2 * half + 1;
+    let norm = i0(BETA);
+    let mut h: Vec<f32> = (0..n)
+        .map(|i| {
+            let m = i as f32 - half as f32;
+            let sinc = if m == 0. {
+                0.5
+            } else {
+                (std::f32::consts::FRAC_PI_2 * m).sin() / (std::f32::consts::PI * m)
+            };
+            let r = m / half as f32;
+            sinc * i0(BETA * (1. - r * r).max(0.).sqrt()) / norm
+        })
+        .collect();
+    let sum: f32 = h.iter().sum();
+    for v in &mut h {
+        *v *= gain / sum;
+    }
+    h
+}
+
+/// FIR with a doubled circular buffer so every convolution reads one contiguous slice.
+struct Fir {
+    taps: Vec<f32>,
+    buf: Vec<f32>,
+    at: usize,
+}
+impl Fir {
+    fn new(taps: Vec<f32>) -> Self {
+        let n = taps.len();
+        Self {
+            taps,
+            buf: vec![0.; 2 * n],
+            at: 0,
+        }
+    }
+    #[inline]
+    fn process(&mut self, x: f32) -> f32 {
+        let n = self.taps.len();
+        self.at = if self.at == 0 { n - 1 } else { self.at - 1 };
+        self.buf[self.at] = x;
+        self.buf[self.at + n] = x;
+        let window = &self.buf[self.at..self.at + n];
+        window.iter().zip(&self.taps).map(|(a, b)| a * b).sum()
+    }
+    fn reset(&mut self) {
+        self.buf.fill(0.);
+        self.at = 0;
+    }
+}
+
+/// One channel of 4× oversampling. Allocation-free after `new`.
+pub struct Oversampler {
+    up1: Fir,
+    up2: Fir,
+    down2: Fir,
+    down1: Fir,
+    /// Two samples at 4× make the round trip a whole number of base samples.
+    pad: [f32; 2],
+}
+impl Default for Oversampler {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl Oversampler {
+    pub const FACTOR: usize = 4;
+    pub fn new() -> Self {
+        Self {
+            up1: Fir::new(halfband(STAGE1_HALF, 2.)),
+            up2: Fir::new(halfband(STAGE2_HALF, 2.)),
+            down2: Fir::new(halfband(STAGE2_HALF, 1.)),
+            down1: Fir::new(halfband(STAGE1_HALF, 1.)),
+            pad: [0.; 2],
+        }
+    }
+    /// Round-trip delay in base-rate samples.
+    pub const fn latency() -> usize {
+        STAGE1_HALF + STAGE2_HALF.div_ceil(2)
+    }
+    #[inline]
+    pub fn up(&mut self, x: f32) -> [f32; 4] {
+        let a = self.up1.process(x);
+        let b = self.up1.process(0.);
+        let mut out = [
+            self.up2.process(a),
+            self.up2.process(0.),
+            self.up2.process(b),
+            self.up2.process(0.),
+        ];
+        // Delay by two 4× samples.
+        let [p0, p1] = self.pad;
+        self.pad = [out[2], out[3]];
+        out = [p0, p1, out[0], out[1]];
+        out
+    }
+    #[inline]
+    pub fn down(&mut self, y: [f32; 4]) -> f32 {
+        let a = self.down2.process(y[0]);
+        self.down2.process(y[1]);
+        let b = self.down2.process(y[2]);
+        self.down2.process(y[3]);
+        let out = self.down1.process(a);
+        self.down1.process(b);
+        out
+    }
+    pub fn reset(&mut self) {
+        self.up1.reset();
+        self.up2.reset();
+        self.down2.reset();
+        self.down1.reset();
+        self.pad = [0.; 2];
+    }
+}
@@ -0,0 +1,106 @@
+//! Trapezoidal state-variable filter (Simper/Cytomic). Stable and click-free under fast
+//! retuning, so it can follow a gliding note. Coefficients are separate from state, so one
+//! set can drive both channels.
+use std::f32::consts::PI;
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct SvfCoef {
+    a1: f32,
+    a2: f32,
+    a3: f32,
+    m0: f32,
+    m1: f32,
+    m2: f32,
+}
+impl Default for SvfCoef {
+    /// Identity: passes the input unchanged.
+    fn default() -> Self {
+        Self::IDENTITY
+    }
+}
+impl SvfCoef {
+    pub const IDENTITY: Self = Self {
+        a1: 1.,
+        a2: 0.,
+        a3: 0.,
+        m0: 1.,
+        m1: 0.,
+        m2: 0.,
+    };
+    fn base(rate: f32, hz: f32, k: f32, warp: f32) -> (f32, f32, f32) {
+        let g = (PI * (hz / rate).clamp(1e-6, 0.49)).tan() * warp;
+        let a1 = 1. / (1. + g * (g + k));
+        let a2 = g * a1;
+        (a1, a2, g * a2)
+    }
+    /// Peaking filter. At 0 dB it is an exact identity.
+    pub fn bell(rate: f32, hz: f32, q: f32, gain_db: f32) -> Self {
+        let a = 10f32.powf(gain_db / 40.);
+        let k = 1. / (q.max(1e-3) * a);
+        let (a1, a2, a3) = Self::base(rate, hz, k, 1.);
+        Self {
+            a1,
+            a2,
+            a3,
+            m0: 1.,
+            m1: k * (a * a - 1.),
+            m2: 0.,
+        }
+    }
+    pub fn lowpass(rate: f32, hz: f32, q: f32) -> Self {
+        let (a1, a2, a3) = Self::base(rate, hz, 1. / q.max(1e-3), 1.);
+        Self {
+            a1,
+            a2,
+            a3,
+            m0: 0.,
+            m1: 0.,
+            m2: 1.,
+        }
+    }
+    pub fn highpass(rate: f32, hz: f32, q: f32) -> Self {
+        let k = 1. / q.max(1e-3);
+        let (a1, a2, a3) = Self::base(rate, hz, k, 1.);
+        Self {
+            a1,
+            a2,
+            a3,
+            m0: 1.,
+            m1: -k,
+            m2: -1.,
+        }
+    }
+    pub fn high_shelf(rate: f32, hz: f32, q: f32, gain_db: f32) -> Self {
+        let a = 10f32.powf(gain_db / 40.);
+        let k = 1. / q.max(1e-3);
+        let (a1, a2, a3) = Self::base(rate, hz, k, a.sqrt());
+        Self {
+            a1,
+            a2,
+            a3,
+            m0: a * a,
+            m1: k * (1. - a) * a,
+            m2: 1. - a * a,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+pub struct Svf {
+    ic1: f32,
+    ic2: f32,
+}
+impl Svf {
+    #[inline]
+    pub fn process(&mut self, c: &SvfCoef, v0: f32) -> f32 {
+        let v3 = v0 - self.ic2;
+        let v1 = c.a1 * self.ic1 + c.a2 * v3;
+        let v2 = self.ic2 + c.a2 * self.ic1 + c.a3 * v3;
+        self.ic1 = 2. * v1 - self.ic1;
+        self.ic2 = 2. * v2 - self.ic2;
+        c.m0 * v0 + c.m1 * v1 + c.m2 * v2
+    }
+    pub fn reset(&mut self) {
+        *self = Self::default();
+    }
+}
@@ -0,0 +1,399 @@
+//! Note tracker with lookahead: pitch and note starts of a monophonic bass, from audio or MIDI.
+//!
+//! Detection runs on the undelayed input. Events are reported at *output* time, `latency()`
+//! samples later, so a host that delays its audio path by the same amount sees each note start
+//! exactly on its attack, with the pitch already known.
+use crate::{coefficient, gain_to_db, hz_to_midi, Biquad, Yin};
+
+const EVENTS: usize = 64;
+const HOP_MS: f32 = 5.;
+const GATE_HOLD_MS: f32 = 20.;
+const GATE_HYSTERESIS_DB: f32 = 6.;
+/// A pitch move this large (semitones) counts as a new note.
+const JUMP: f32 = 0.7;
+const CLARITY: f32 = 0.5;
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct TrackerConfig {
+    /// Lowest detectable fundamental. Sets the lookahead (two periods plus a margin).
+    pub min_hz: f32,
+    pub max_hz: f32,
+    /// Lowpass in front of detection, removing upper harmonics that confuse YIN.
+    pub detect_lowpass: f32,
+    /// Approximate decimated analysis rate.
+    pub detect_rate: f32,
+}
+impl TrackerConfig {
+    /// Sub range: 25–250 Hz.
+    pub const SUB: Self = Self {
+        min_hz: 25.,
+        max_hz: 250.,
+        detect_lowpass: 400.,
+        detect_rate: 3000.,
+    };
+    /// Bass range for harmonic tools: 30–500 Hz.
+    pub const BASS: Self = Self {
+        min_hz: 30.,
+        max_hz: 500.,
+        detect_lowpass: 1000.,
+        detect_rate: 6000.,
+    };
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum NoteEvent {
+    /// A new note. `glide` asks to slide from the previous pitch instead of restarting.
+    Start {
+        pitch: f32,
+        glide: bool,
+    },
+    /// The sounding note's smoothed pitch moved within a semitone (bends, vibrato).
+    Move {
+        pitch: f32,
+    },
+    Stop,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum Kind {
+    Onset,
+    Release,
+    NoteOn(u8),
+    NoteOff(u8),
+}
+#[derive(Clone, Copy, Debug)]
+struct Event {
+    time: u64,
+    kind: Kind,
+}
+
+/// Allocation-free after `new`. Pitches are fractional MIDI notes.
+pub struct Tracker {
+    rate: f32,
+    cfg: TrackerConfig,
+    latency: usize,
+    midi: bool,
+    gate_db: f32,
+    glide: bool,
+    detect: [Biquad; 2],
+    decimate: usize,
+    decimate_count: usize,
+    detect_rate: f32,
+    ring: Vec<f32>,
+    ring_at: usize,
+    scratch: Vec<f32>,
+    yin: Yin,
+    hop: usize,
+    hop_count: usize,
+    gate_env: f32,
+    gate_release: f32,
+    gate_open: bool,
+    gate_hold: usize,
+    clock: u64,
+    events: [Event; EVENTS],
+    event_head: usize,
+    event_len: usize,
+    /// Output-time note state.
+    sounding: bool,
+    pending: bool,
+    tracked: f32,
+    candidate: Option<(f32, u8)>,
+    held: [u8; 16],
+    held_len: usize,
+}
+
+impl Tracker {
+    pub fn new(rate: f32, cfg: TrackerConfig) -> Self {
+        let decimate = (rate / cfg.detect_rate).round().max(1.) as usize;
+        let detect_rate = rate / decimate as f32;
+        let max_lag = (detect_rate / cfg.min_hz).ceil() as usize;
+        // YIN needs one comparison window of at least the longest period after the lags.
+        let analysis = 2 * max_lag + 3;
+        let q = std::f32::consts::FRAC_1_SQRT_2;
+        Self {
+            rate,
+            cfg,
+            latency: analysis * decimate,
+            midi: false,
+            gate_db: -42.,
+            glide: false,
+            detect: [Biquad::lowpass(rate, cfg.detect_lowpass, q); 2],
+            decimate,
+            decimate_count: 0,
+            detect_rate,
+            ring: vec![0.; analysis],
+            ring_at: 0,
+            scratch: vec![0.; analysis],
+            yin: Yin::new(max_lag + 2),
+            hop: ((detect_rate * HOP_MS * 0.001) as usize).max(1),
+            hop_count: 0,
+            gate_env: 0.,
+            gate_release: 1. - coefficient(rate, 30.),
+            gate_open: false,
+            gate_hold: 0,
+            clock: 0,
+            events: [Event {
+                time: 0,
+                kind: Kind::Release,
+            }; EVENTS],
+            event_head: 0,
+            event_len: 0,
+            sounding: false,
+            pending: false,
+            tracked: 0.,
+            candidate: None,
+            held: [0; 16],
+            held_len: 0,
+        }
+    }
+    /// Lookahead in samples. Delay the audio path by exactly this much.
+    pub fn latency(&self) -> usize {
+        self.latency
+    }
+    pub fn config(&self) -> TrackerConfig {
+        self.cfg
+    }
+    /// `midi` selects note input over detection; `gate_db` is the detection threshold;
+    /// `glide` lets legato notes slide. Returns true when the source changed, which drops
+    /// every pending and held note: the caller should release its sound.
+    pub fn set(&mut self, midi: bool, gate_db: f32, glide: bool) -> bool {
+        let changed = midi != self.midi;
+        self.midi = midi;
+        self.gate_db = gate_db;
+        self.glide = glide;
+        if changed {
+            self.release_all();
+        }
+        changed
+    }
+    fn release_all(&mut self) {
+        self.sounding = false;
+        self.pending = false;
+        self.held_len = 0;
+        self.event_len = 0;
+        self.candidate = None;
+    }
+    pub fn reset(&mut self) {
+        for f in &mut self.detect {
+            f.reset();
+        }
+        self.ring.fill(0.);
+        self.decimate_count = 0;
+        self.hop_count = 0;
+        self.gate_env = 0.;
+        self.gate_open = false;
+        self.gate_hold = 0;
+        self.release_all();
+    }
+    /// MIDI note start at the current input sample. Used when the source is MIDI.
+    pub fn note_on(&mut self, note: u8) {
+        self.push(Kind::NoteOn(note.min(127)));
+    }
+    pub fn note_off(&mut self, note: u8) {
+        self.push(Kind::NoteOff(note.min(127)));
+    }
+    /// True while a note sounds at output time.
+    pub fn sounding(&self) -> bool {
+        self.sounding
+    }
+    fn push(&mut self, kind: Kind) {
+        if self.event_len == EVENTS {
+            // Dropping the oldest keeps the newest note state; overflow only happens on floods.
+            self.event_head = (self.event_head + 1) % EVENTS;
+            self.event_len -= 1;
+        }
+        let at = (self.event_head + self.event_len) % EVENTS;
+        self.events[at] = Event {
+            time: self.clock,
+            kind,
+        };
+        self.event_len += 1;
+    }
+    /// Detected pitch of the most recent analysis window, in fractional MIDI notes.
+    fn estimate(&mut self) -> Option<f32> {
+        let n = self.ring.len();
+        for i in 0..n {
+            self.scratch[i] = self.ring[(self.ring_at + i) % n];
+        }
+        let (hz, clarity) = self.yin.estimate(
+            &self.scratch,
+            self.detect_rate,
+            self.cfg.min_hz,
+            self.cfg.max_hz,
+        )?;
+        (clarity >= CLARITY).then(|| hz_to_midi(hz))
+    }
+    fn start(&mut self, pitch: f32, glide: bool, emit: &mut impl FnMut(NoteEvent)) {
+        self.tracked = pitch;
+        self.candidate = None;
+        self.pending = false;
+        self.sounding = true;
+        emit(NoteEvent::Start { pitch, glide });
+    }
+    fn stop(&mut self, emit: &mut impl FnMut(NoteEvent)) {
+        self.sounding = false;
+        self.pending = false;
+        self.candidate = None;
+        emit(NoteEvent::Stop);
+    }
+    fn handle(&mut self, kind: Kind, emit: &mut impl FnMut(NoteEvent)) {
+        let midi = self.midi;
+        match kind {
+            Kind::Onset if !midi => match self.estimate() {
+                Some(p) => self.start(p, false, emit),
+                None => {
+                    self.pending = true;
+                    self.sounding = true;
+                }
+            },
+            Kind::Release if !midi => self.stop(emit),
+            Kind::NoteOn(n) if midi => {
+                let len = self.held_len;
+                if let Some(i) = self.held[..len].iter().position(|h| *h == n) {
+                    self.held.copy_within(i + 1..len, i);
+                    self.held_len -= 1;
+                }
+                if self.held_len == self.held.len() {
+                    self.held.copy_within(1.., 0);
+                    self.held_len -= 1;
+                }
+                let legato = self.held_len > 0;
+                self.held[self.held_len] = n;
+                self.held_len += 1;
+                self.start(n as f32, legato && self.glide, emit);
+            }
+            Kind::NoteOff(n) if midi => {
+                let len = self.held_len;
+                let Some(i) = self.held[..len].iter().position(|h| *h == n) else {
+                    return;
+                };
+                let top = i + 1 == len;
+                self.held.copy_within(i + 1..len, i);
+                self.held_len -= 1;
+                if self.held_len == 0 {
+                    self.stop(emit);
+                } else if top {
+                    let next = self.held[self.held_len - 1];
+                    self.start(next as f32, self.glide, emit);
+                }
+            }
+            _ => {}
+        }
+    }
+    /// Regular analysis; its window starts at the current output time.
+    fn hop_analysis(&mut self, emit: &mut impl FnMut(NoteEvent)) {
+        if self.midi || !self.sounding {
+            return;
+        }
+        let Some(p) = self.estimate() else {
+            return;
+        };
+        if self.pending {
+            self.start(p, false, emit);
+            return;
+        }
+        if (p - self.tracked).abs() >= JUMP {
+            match self.candidate {
+                Some((c, count)) if (c - p).abs() < 0.5 => {
+                    if count + 1 >= 2 {
+                        self.start(p, self.glide, emit);
+                    } else {
+                        self.candidate = Some((p, count + 1));
+                    }
+                }
+                _ => self.candidate = Some((p, 1)),
+            }
+        } else {
+            self.candidate = None;
+            self.tracked += 0.3 * (p - self.tracked);
+            emit(NoteEvent::Move {
+                pitch: self.tracked,
+            });
+        }
+    }
+    /// Feeds one undelayed mono input sample. Events due at output time go to `emit`, in order.
+    pub fn process(&mut self, mono: f32, mut emit: impl FnMut(NoteEvent)) {
+        let d = self.detect[0].process(mono);
+        let d = self.detect[1].process(d);
+        if !self.midi {
+            let a = d.abs();
+            self.gate_env = if a > self.gate_env {
+                a
+            } else {
+                self.gate_env * self.gate_release
+            };
+            let level = gain_to_db(self.gate_env);
+            if level > self.gate_db {
+                self.gate_hold = (self.rate * GATE_HOLD_MS * 0.001) as usize;
+                if !self.gate_open {
+                    self.gate_open = true;
+                    self.push(Kind::Onset);
+                }
+            } else if self.gate_open && level < self.gate_db - GATE_HYSTERESIS_DB {
+                if self.gate_hold == 0 {
+                    self.gate_open = false;
+                    self.push(Kind::Release);
+                } else {
+                    self.gate_hold -= 1;
+                }
+            }
+        }
+        self.decimate_count += 1;
+        if self.decimate_count >= self.decimate {
+            self.decimate_count = 0;
+            self.ring[self.ring_at] = d;
+            self.ring_at = (self.ring_at + 1) % self.ring.len();
+            self.hop_count += 1;
+            if self.hop_count >= self.hop {
+                self.hop_count = 0;
+                self.hop_analysis(&mut emit);
+            }
+        }
+        while self.event_len > 0 {
+            let e = self.events[self.event_head];
+            if e.time + self.latency as u64 > self.clock {
+                break;
+            }
+            self.event_head = (self.event_head + 1) % EVENTS;
+            self.event_len -= 1;
+            self.handle(e.kind, &mut emit);
+        }
+        self.clock += 1;
+    }
+}
+
+/// Fundamental that follows tracker events: jumps on new notes, slides on bends and legato.
+#[derive(Clone, Copy, Debug, Default)]
+pub struct PitchFollower {
+    target: f32,
+    hz: f32,
+    jump: bool,
+}
+impl PitchFollower {
+    pub fn event(&mut self, snap: bool, e: NoteEvent) {
+        match e {
+            NoteEvent::Start { pitch, glide } => {
+                let p = if snap { pitch.round() } else { pitch };
+                self.target = crate::midi_to_hz(p);
+                self.jump |= !glide;
+            }
+            NoteEvent::Move { pitch } if !snap => self.target = crate::midi_to_hz(pitch),
+            // The last pitch is held so tails keep their tuning.
+            _ => {}
+        }
+    }
+    /// Advances one sample with one-pole coefficient `coef`. Returns the frequency, 0 before the
+    /// first note, and whether it jumped this sample (a new note, or the first one).
+    pub fn step(&mut self, coef: f32) -> (f32, bool) {
+        let jump = std::mem::take(&mut self.jump) || (self.hz == 0. && self.target > 0.);
+        if jump {
+            self.hz = self.target;
+        } else {
+            self.hz += (self.target - self.hz) * coef;
+        }
+        (self.hz, jump)
+    }
+    pub fn hz(&self) -> f32 {
+        self.hz
+    }
+}
@@ -0,0 +1,142 @@
+//! Minimal RIFF/WAVE writer and reader: 32-bit float data, sampler root key, Serum wavetable tag.
+use std::{io, path::Path};
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Wave {
+    pub channels: u16,
+    pub rate: u32,
+    /// Interleaved samples.
+    pub samples: Vec<f32>,
+    /// MIDI root key, written as a `smpl` chunk that samplers (FL included) read.
+    pub root: Option<u8>,
+    /// Wavetable frame size, written as Serum's `clm ` chunk.
+    pub frame: Option<u32>,
+}
+
+fn chunk(out: &mut Vec<u8>, id: &[u8; 4], body: &[u8]) {
+    out.extend_from_slice(id);
+    out.extend_from_slice(&(body.len() as u32).to_le_bytes());
+    out.extend_from_slice(body);
+    if body.len() % 2 == 1 {
+        out.push(0);
+    }
+}
+
+pub fn encode(w: &Wave) -> Vec<u8> {
+    let channels = w.channels.max(1);
+    let frames = w.samples.len() / channels as usize;
+    let mut body = Vec::with_capacity(w.samples.len() * 4 + 256);
+    body.extend_from_slice(b"WAVE");
+    let mut fmt = Vec::new();
+    fmt.extend_from_slice(&3u16.to_le_bytes()); // IEEE float
+    fmt.extend_from_slice(&channels.to_le_bytes());
+    fmt.extend_from_slice(&w.rate.to_le_bytes());
+    fmt.extend_from_slice(&(w.rate * 4 * channels as u32).to_le_bytes());
+    fmt.extend_from_slice(&(4 * channels).to_le_bytes());
+    fmt.extend_from_slice(&32u16.to_le_bytes());
+    fmt.extend_from_slice(&0u16.to_le_bytes());
+    chunk(&mut body, b"fmt ", &fmt);
+    chunk(&mut body, b"fact", &(frames as u32).to_le_bytes());
+    if let Some(frame) = w.frame {
+        // Serum reads the frame size from the "<!>NNNN" prefix.
+        chunk(
+            &mut body,
+            b"clm ",
+            format!("<!>{frame} 00000000 wavetable (Crucible)").as_bytes(),
+        );
+    }
+    if let Some(root) = w.root {
+        let mut smpl = Vec::new();
+        let period = (1e9 / w.rate.max(1) as f64).round() as u32;
+        for v in [0, 0, period, root as u32, 0, 0, 0, 0, 0] {
+            smpl.extend_from_slice(&v.to_le_bytes());
+        }
+        chunk(&mut body, b"smpl", &smpl);
+    }
+    let mut data = Vec::with_capacity(w.samples.len() * 4);
+    for s in &w.samples[..frames * channels as usize] {
+        data.extend_from_slice(&s.to_le_bytes());
+    }
+    chunk(&mut body, b"data", &data);
+    let mut out = Vec::with_capacity(body.len() + 8);
+    out.extend_from_slice(b"RIFF");
+    out.extend_from_slice(&(body.len() as u32).to_le_bytes());
+    out.extend_from_slice(&body);
+    out
+}
+
+pub fn write(path: &Path, w: &Wave) -> io::Result<()> {
+    std::fs::write(path, encode(w))
+}
+
+/// Reads float32 or PCM16/24 files written by this module or common tools.
+pub fn decode(b: &[u8]) -> Result<Wave, &'static str> {
+    if b.len() < 12 || &b[..4] != b"RIFF" || &b[8..12] != b"WAVE" {
+        return Err("expected RIFF/WAVE");
+    }
+    let mut w = Wave::default();
+    let (mut format, mut bits) = (0u16, 0u16);
+    let mut at = 12;
+    let mut data = false;
+    let u16_at = |o: usize| u16::from_le_bytes([b[o], b[o + 1]]);
+    let u32_at = |o: usize| u32::from_le_bytes([b[o], b[o + 1], b[o + 2], b[o + 3]]);
+    while at + 8 <= b.len() {
+        let id = &b[at..at + 4];
+        let len = u32_at(at + 4) as usize;
+        let start = at + 8;
+        let end = start
+            .checked_add(len)
+            .filter(|e| *e <= b.len())
+            .ok_or("truncated chunk")?;
+        match id {
+            b"fmt " if len >= 16 => {
+                format = u16_at(start);
+                w.channels = u16_at(start + 2);
+                w.rate = u32_at(start + 4);
+                bits = u16_at(start + 14);
+            }
+            b"smpl" if len >= 16 => w.root = Some(u32_at(start + 12) as u8),
+            b"clm " => {
+                let text = std::str::from_utf8(&b[start..end]).map_err(|_| "bad clm chunk")?;
+                w.frame = text
+                    .strip_prefix("<!>")
+                    .and_then(|t| t.split_whitespace().next())
+                    .and_then(|n| n.parse().ok());
+            }
+            b"data" => {
+                data = true;
+                let d = &b[start..end];
+                w.samples = match (format, bits) {
+                    (3, 32) => d
+                        .as_chunks::<4>()
+                        .0
+                        .iter()
+                        .map(|c| f32::from_le_bytes(*c))
+                        .collect(),
+                    (1, 16) => d
+                        .as_chunks::<2>()
+                        .0
+                        .iter()
+                        .map(|c| i16::from_le_bytes(*c) as f32 / 32768.)
+                        .collect(),
+                    (1, 24) => d
+                        .as_chunks::<3>()
+                        .0
+                        .iter()
+                        .map(|c| (i32::from_le_bytes([0, c[0], c[1], c[2]]) >> 8) as f32 / 8388608.)
+                        .collect(),
+                    _ => return Err("unsupported sample format"),
+                };
+            }
+            _ => {}
+        }
+        at = end + (len % 2);
+    }
+    if w.channels == 0 || w.rate == 0 {
+        return Err("missing fmt chunk");
+    }
+    if !data {
+        return Err("missing data chunk");
+    }
+    Ok(w)
+}
@@ -0,0 +1,225 @@
+use common_dsp::meter::HarmonicMeter;
+use common_dsp::oversample::Oversampler;
+use common_dsp::svf::{Svf, SvfCoef};
+use common_dsp::tracker::{NoteEvent, Tracker, TrackerConfig};
+use common_dsp::{hz_to_midi, Saw};
+use std::f32::consts::TAU;
+
+const RATE: f32 = 48000.;
+
+/// Steady-state gain in dB of a sine at `hz` through `f`.
+fn sine_gain(mut f: impl FnMut(f32) -> f32, hz: f32) -> f32 {
+    let n = (RATE * 0.5) as usize;
+    let (mut pin, mut pout) = (0., 0.);
+    for i in 0..n {
+        let x = (TAU * hz * i as f32 / RATE).sin();
+        let y = f(x);
+        if i > n / 2 {
+            pin += x * x;
+            pout += y * y;
+        }
+    }
+    10. * (pout / pin).log10()
+}
+
+#[test]
+fn svf_bell_hits_its_gain_and_leaves_the_rest() {
+    for (hz, db) in [(130., -12.), (400., 6.), (2000., -24.)] {
+        let c = SvfCoef::bell(RATE, hz, 4., db);
+        let mut s = Svf::default();
+        let g = sine_gain(|x| s.process(&c, x), hz);
+        assert!((g - db).abs() < 0.1, "{hz}: {g}");
+        let mut s = Svf::default();
+        let g = sine_gain(|x| s.process(&c, x), hz * 4.);
+        assert!(g.abs() < 0.3, "{hz} away: {g}");
+    }
+}
+
+#[test]
+fn svf_bell_at_zero_db_is_an_exact_identity() {
+    let c = SvfCoef::bell(RATE, 100., 2., 0.);
+    let mut s = Svf::default();
+    let mut saw = Saw::new(RATE, 55.);
+    for _ in 0..4800 {
+        let x = saw.sample();
+        assert_eq!(s.process(&c, x), x);
+    }
+}
+
+#[test]
+fn svf_survives_retuning_every_sample() {
+    let mut s = Svf::default();
+    let mut saw = Saw::new(RATE, 55.);
+    let mut peak: f32 = 0.;
+    for i in 0..48000 {
+        let hz = 40. + 4000. * (0.5 + 0.5 * (i as f32 * 0.003).sin());
+        let c = SvfCoef::bell(RATE, hz, 8., 12.);
+        let y = s.process(&c, saw.sample());
+        assert!(y.is_finite());
+        peak = peak.max(y.abs());
+    }
+    assert!(peak < 8., "{peak}");
+    let c = SvfCoef::lowpass(RATE, 200., 0.707);
+    let mut s = Svf::default();
+    assert!(sine_gain(|x| s.process(&c, x), 2000.) < -35.);
+    let c = SvfCoef::highpass(RATE, 200., 0.707);
+    let mut s = Svf::default();
+    assert!(sine_gain(|x| s.process(&c, x), 20.) < -35.);
+}
+
+#[test]
+fn oversampler_round_trip_is_a_whole_sample_delay() {
+    let mut o = Oversampler::new();
+    let l = Oversampler::latency();
+    let mut saw = Saw::new(RATE, 97.);
+    let x: Vec<f32> = (0..9600).map(|_| saw.sample() * 0.5).collect();
+    let y: Vec<f32> = x
+        .iter()
+        .map(|&v| {
+            let u = o.up(v);
+            o.down(u)
+        })
+        .collect();
+    // Band-limited content passes; compare after the delay, away from the start.
+    let mut err: f32 = 0.;
+    let mut sig: f32 = 0.;
+    for i in 2000..9600 {
+        let d = y[i] - x[i - l];
+        err += d * d;
+        sig += x[i - l] * x[i - l];
+    }
+    let null = 10. * (err / sig).log10();
+    // The saw has energy above the passband edge, so the null is limited by that, not by timing.
+    assert!(null < -40., "{null}");
+}
+
+#[test]
+fn oversampler_passband_is_flat_and_images_are_removed() {
+    for hz in [50., 1000., 10000., 18000.] {
+        let mut o = Oversampler::new();
+        let g = sine_gain(
+            |x| {
+                let u = o.up(x);
+                o.down(u)
+            },
+            hz,
+        );
+        assert!(g.abs() < 0.1, "{hz}: {g}");
+    }
+    // An image of a 1 kHz tone at 4× would sit at 47 kHz; check the 4× signal there.
+    let mut o = Oversampler::new();
+    let n = 48000;
+    let (mut a, mut b) = (0f64, 0f64);
+    let w = TAU as f64 * 47000. / (4. * RATE as f64);
+    for i in 0..n {
+        let x = (TAU * 1000. * i as f32 / RATE).sin();
+        for (k, v) in o.up(x).into_iter().enumerate() {
+            let t = (4 * i + k) as f64;
+            a += v as f64 * (w * t).cos();
+            b += v as f64 * (w * t).sin();
+        }
+    }
+    let image = 20.
+        * ((a * a + b * b).sqrt() / (2. * n as f64))
+            .max(1e-12)
+            .log10();
+    assert!(image < -85., "{image}");
+}
+
+#[test]
+fn harmonic_meter_reads_saw_harmonics() {
+    let hz = 55.;
+    let mut m = HarmonicMeter::new(RATE, 85.);
+    let mut saw = Saw::new(RATE, hz);
+    let mut done = 0;
+    for _ in 0..48000 {
+        if m.push(saw.sample(), hz) {
+            done += 1;
+        }
+    }
+    assert!(done >= 5);
+    // A saw's k-th harmonic has peak 2/(πk).
+    for k in 1..=16 {
+        let want = 20. * (2. / (std::f32::consts::PI * k as f32)).log10();
+        let got = m.levels()[k - 1];
+        assert!((got - want).abs() < 0.5, "harmonic {k}: {got} vs {want}");
+    }
+}
+
+#[test]
+fn tracker_reports_notes_at_output_time() {
+    let mut t = Tracker::new(RATE, TrackerConfig::BASS);
+    t.set(false, -42., false);
+    let l = t.latency();
+    assert!(l < (0.08 * RATE) as usize, "{l}");
+    let onset = 4800;
+    let mut events = vec![];
+    let mut saw_a = Saw::new(RATE, 87.31);
+    let mut saw_b = Saw::new(RATE, 220.);
+    for i in 0..onset + 48000 {
+        let x = if i < onset {
+            0.
+        } else if i < onset + 24000 {
+            0.5 * saw_a.sample()
+        } else {
+            0.5 * saw_b.sample()
+        };
+        t.process(x, |e| events.push((i, e)));
+    }
+    let starts: Vec<_> = events
+        .iter()
+        .filter_map(|(i, e)| match e {
+            NoteEvent::Start { pitch, .. } => Some((*i, *pitch)),
+            _ => None,
+        })
+        .collect();
+    assert_eq!(starts.len(), 2, "{starts:?}");
+    assert!(
+        (starts[0].0 as i64 - (onset + l) as i64).abs() <= 24,
+        "{starts:?}"
+    );
+    assert!((starts[0].1 - hz_to_midi(87.31)).abs() < 0.2);
+    assert!((starts[1].1 - hz_to_midi(220.)).abs() < 0.2);
+}
+
+#[test]
+fn tracker_delays_midi_by_the_latency() {
+    let mut t = Tracker::new(RATE, TrackerConfig::BASS);
+    assert!(t.set(true, -42., true));
+    let l = t.latency();
+    let mut events = vec![];
+    for i in 0..l + 2000 {
+        if i == 100 {
+            t.note_on(41);
+        }
+        if i == 600 {
+            t.note_on(43);
+        }
+        if i == 900 {
+            // Releasing the lower held note first leaves the top note; then the top ends it.
+            t.note_off(41);
+            t.note_off(43);
+        }
+        t.process(0., |e| events.push((i, e)));
+    }
+    assert_eq!(
+        events,
+        vec![
+            (
+                100 + l,
+                NoteEvent::Start {
+                    pitch: 41.,
+                    glide: false
+                }
+            ),
+            (
+                600 + l,
+                NoteEvent::Start {
+                    pitch: 43.,
+                    glide: true
+                }
+            ),
+            (900 + l, NoteEvent::Stop),
+        ]
+    );
+}
@@ -0,0 +1,82 @@
+use common_dsp::{hz_to_midi, midi_to_hz, note_name, wav, Crossover, Saw, Yin};
+
+fn cents(a: f32, b: f32) -> f32 {
+    1200. * (a / b).log2()
+}
+
+#[test]
+fn yin_tracks_bass_fundamentals_within_two_cents() {
+    let rate = 48000.;
+    let mut yin = Yin::new(2400);
+    for hz in [43.65, 55., 110., 220.] {
+        let mut saw = Saw::new(rate, hz);
+        let x: Vec<f32> = (0..6000).map(|_| saw.sample()).collect();
+        let (got, clarity) = yin.estimate(&x, rate, 25., 1000.).unwrap();
+        assert!(cents(got, hz).abs() < 2., "{hz}: {got}");
+        assert!(clarity > 0.8);
+    }
+}
+
+#[test]
+fn yin_rejects_silence_and_noise() {
+    let mut yin = Yin::new(2400);
+    assert!(yin.estimate(&[0.; 6000], 48000., 25., 1000.).is_none());
+    let mut seed = 1u32;
+    let noise: Vec<f32> = (0..6000)
+        .map(|_| {
+            seed = seed.wrapping_mul(1664525).wrapping_add(1013904223);
+            (seed >> 8) as f32 / (1u32 << 24) as f32 - 0.5
+        })
+        .collect();
+    assert!(yin.estimate(&noise, 48000., 25., 1000.).is_none());
+}
+
+#[test]
+fn crossover_bands_sum_to_flat_magnitude() {
+    let rate = 48000.;
+    for hz in [20., 45., 90., 180., 1000., 8000., 18000.] {
+        let mut x = Crossover::new(rate, 90.);
+        let (mut a, mut b) = (0f64, 0f64);
+        let n = 96000;
+        for i in 0..n {
+            let s = (std::f32::consts::TAU * hz * i as f32 / rate).sin();
+            let (l, h) = x.process(s);
+            if i > n / 2 {
+                a += (s as f64).powi(2);
+                b += ((l + h) as f64).powi(2);
+            }
+        }
+        let db = 10. * (b / a).log10();
+        assert!(db.abs() < 0.1, "{hz} Hz: {db} dB");
+    }
+}
+
+#[test]
+fn notes_round_trip() {
+    assert!((midi_to_hz(29.) - 43.65).abs() < 0.01);
+    assert!((hz_to_midi(440.) - 69.).abs() < 1e-4);
+    assert_eq!(note_name(29), "F1");
+    assert_eq!(note_name(61), "C#4");
+}
+
+#[test]
+fn wave_round_trip_keeps_root_and_wavetable_chunks() {
+    let w = wav::Wave {
+        channels: 2,
+        rate: 44100,
+        samples: (0..999)
+            .map(|i| (i as f32 * 0.01).sin())
+            .collect::<Vec<_>>()[..998]
+            .to_vec(),
+        root: Some(29),
+        frame: Some(2048),
+    };
+    let bytes = wav::encode(&w);
+    assert_eq!(&bytes[..4], b"RIFF");
+    assert_eq!(
+        u32::from_le_bytes(bytes[4..8].try_into().unwrap()) as usize,
+        bytes.len() - 8
+    );
+    assert_eq!(wav::decode(&bytes).unwrap(), w);
+    assert!(wav::decode(&bytes[..40]).is_err());
+}
@@ -0,0 +1,8 @@
+[package]
+name = "common-ui"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+egui = "0.31.1"
@@ -0,0 +1,320 @@
+//! Shared hardware look for every plugin editor: palette, fonts, knobs, panels.
+use egui::{self, Color32, FontId, Pos2, Rect, RichText, Sense, Stroke, Vec2};
+
+// Dark anodized hardware: graphite surfaces, one signal colour, steel data traces.
+pub const BG: Color32 = Color32::from_rgb(14, 15, 17);
+pub const PANEL: Color32 = Color32::from_rgb(25, 27, 31);
+pub const PANEL_TOP: Color32 = Color32::from_rgb(34, 36, 41);
+pub const EDGE: Color32 = Color32::from_rgb(44, 47, 53);
+pub const SCREEN: Color32 = Color32::from_rgb(9, 10, 11);
+pub const TEXT: Color32 = Color32::from_rgb(232, 233, 236);
+pub const MUTED: Color32 = Color32::from_rgb(140, 146, 156);
+pub const DIM: Color32 = Color32::from_rgb(70, 74, 82);
+/// Signal colour: cuts, active states, value arcs.
+pub const ACCENT: Color32 = Color32::from_rgb(255, 1, 96);
+/// Measured input and neutral data.
+pub const STEEL: Color32 = Color32::from_rgb(184, 192, 204);
+/// Focus / protect curve, distinct from cuts without competing with them.
+pub const FOCUS: Color32 = Color32::from_rgb(126, 167, 216);
+pub fn style(ctx: &egui::Context) {
+    let mut fonts = egui::FontDefinitions::default();
+    fonts.font_data.insert(
+        "regular".into(),
+        egui::FontData::from_static(include_bytes!("../assets/RobotoCondensed-Regular.ttf")).into(),
+    );
+    fonts.font_data.insert(
+        "medium".into(),
+        egui::FontData::from_static(include_bytes!("../assets/RobotoCondensed-Medium.ttf")).into(),
+    );
+    fonts
+        .families
+        .get_mut(&egui::FontFamily::Proportional)
+        .unwrap()
+        .insert(0, "regular".into());
+    fonts.families.insert(
+        egui::FontFamily::Name("medium".into()),
+        vec![
+            "medium".into(),
+            "Ubuntu-Light".into(),
+            "NotoEmoji-Regular".into(),
+            "emoji-icon-font".into(),
+        ],
+    );
+    ctx.set_fonts(fonts);
+    let mut s = (*ctx.style()).clone();
+    let v = &mut s.visuals;
+    *v = egui::Visuals::dark();
+    v.panel_fill = BG;
+    v.window_fill = PANEL;
+    v.extreme_bg_color = SCREEN;
+    v.faint_bg_color = PANEL;
+    v.override_text_color = Some(TEXT);
+    v.selection.bg_fill = Color32::from_rgb(110, 6, 46);
+    v.selection.stroke = Stroke::new(1.0_f32, ACCENT);
+    v.hyperlink_color = ACCENT;
+    v.window_stroke = Stroke::new(1.0_f32, EDGE);
+    for (w, fill, stroke) in [
+        (&mut v.widgets.noninteractive, PANEL, EDGE),
+        (&mut v.widgets.inactive, Color32::from_rgb(35, 38, 43), EDGE),
+        (
+            &mut v.widgets.hovered,
+            Color32::from_rgb(45, 48, 54),
+            Color32::from_rgb(78, 82, 90),
+        ),
+        (&mut v.widgets.active, Color32::from_rgb(58, 18, 34), ACCENT),
+        (&mut v.widgets.open, Color32::from_rgb(35, 38, 43), EDGE),
+    ] {
+        w.bg_fill = fill;
+        w.weak_bg_fill = fill;
+        w.bg_stroke = Stroke::new(1.0_f32, stroke);
+        w.corner_radius = 3.into();
+    }
+    v.widgets.noninteractive.fg_stroke = Stroke::new(1.0_f32, TEXT);
+    v.widgets.inactive.fg_stroke = Stroke::new(1.0_f32, TEXT);
+    v.slider_trailing_fill = true;
+    s.spacing.item_spacing = Vec2::new(10., 8.);
+    s.spacing.button_padding = Vec2::new(12., 6.);
+    s.text_styles
+        .insert(egui::TextStyle::Body, FontId::proportional(16.));
+    s.text_styles
+        .insert(egui::TextStyle::Button, FontId::proportional(16.));
+    ctx.set_style(s);
+}
+/// Disc with a vertical light-to-dark gradient, like brushed metal lit from above.
+pub fn metal_disc(p: &egui::Painter, center: Pos2, radius: f32, top: Color32, bottom: Color32) {
+    let mut mesh = egui::Mesh::default();
+    let mix = |t: f32| {
+        let l = |a: u8, b: u8| (a as f32 + (b as f32 - a as f32) * t).round() as u8;
+        Color32::from_rgb(
+            l(top.r(), bottom.r()),
+            l(top.g(), bottom.g()),
+            l(top.b(), bottom.b()),
+        )
+    };
+    mesh.colored_vertex(center, mix(0.5));
+    let n = 48;
+    for i in 0..=n {
+        let a = std::f32::consts::TAU * i as f32 / n as f32;
+        let point = center + Vec2::angled(a) * radius;
+        mesh.colored_vertex(point, mix((point.y - (center.y - radius)) / (2. * radius)));
+        if i > 0 {
+            mesh.add_triangle(0, i, i + 1);
+        }
+    }
+    p.add(egui::Shape::mesh(mesh));
+}
+#[allow(clippy::too_many_arguments)]
+pub fn rotary(
+    ui: &mut egui::Ui,
+    name: &str,
+    value: &mut f32,
+    range: std::ops::RangeInclusive<f32>,
+    default: f32,
+    unit: &str,
+    size: f32,
+    color: Color32,
+) -> egui::Response {
+    let low = *range.start();
+    let high = *range.end();
+    let (rect, response) = ui.allocate_exact_size(Vec2::splat(size), Sense::click_and_drag());
+    if response.drag_started() {
+        response.request_focus();
+    }
+    if response.dragged() {
+        let delta = ui.input(|i| i.pointer.delta().y);
+        let fine = if ui.input(|i| i.modifiers.shift) {
+            0.1
+        } else {
+            1.
+        };
+        *value = (*value - delta * (high - low) / 180. * fine).clamp(low, high);
+    }
+    if response.double_clicked() {
+        *value = default;
+    }
+    if response.has_focus() {
+        let step = if ui.input(|i| i.modifiers.shift) {
+            0.1
+        } else {
+            1.
+        };
+        if ui.input(|i| i.key_pressed(egui::Key::ArrowUp) || i.key_pressed(egui::Key::ArrowRight)) {
+            *value = (*value + step).min(high);
+        }
+        if ui.input(|i| i.key_pressed(egui::Key::ArrowDown) || i.key_pressed(egui::Key::ArrowLeft))
+        {
+            *value = (*value - step).max(low);
+        }
+    }
+    let center = rect.center();
+    let radius = size * 0.46;
+    let p = ui.painter();
+    let start = std::f32::consts::PI * 0.75;
+    let span = std::f32::consts::PI * 1.5;
+    let normalized = ((*value - low) / (high - low)).clamp(0., 1.);
+    // Scale track and value arc around the knob.
+    for (fraction, stroke) in [
+        (1., Stroke::new(2.5_f32, DIM)),
+        (normalized, Stroke::new(2.5_f32, color)),
+    ] {
+        // A zero-length polyline tessellates to NaN vertices.
+        if fraction < 1e-3 {
+            continue;
+        }
+        let points: Vec<_> = (0..=64)
+            .map(|i| {
+                let a = start + span * fraction * i as f32 / 64.;
+                center + Vec2::angled(a) * (radius - 1.5)
+            })
+            .collect();
+        p.add(egui::Shape::line(points, stroke));
+    }
+    // Machined body: drop shadow, brushed gradient skirt, flat cap.
+    let body = radius - 7.;
+    p.circle_filled(
+        center + Vec2::new(0., 2.),
+        body + 1.,
+        Color32::from_black_alpha(140),
+    );
+    metal_disc(
+        p,
+        center,
+        body,
+        Color32::from_rgb(78, 82, 90),
+        Color32::from_rgb(28, 30, 34),
+    );
+    p.circle_stroke(
+        center,
+        body,
+        Stroke::new(1.0_f32, Color32::from_rgb(10, 11, 12)),
+    );
+    let cap = body * 0.74;
+    metal_disc(
+        p,
+        center,
+        cap,
+        Color32::from_rgb(44, 47, 52),
+        Color32::from_rgb(33, 35, 40),
+    );
+    p.circle_stroke(
+        center,
+        cap,
+        Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(255, 255, 255, 22)),
+    );
+    let angle = start + span * normalized;
+    p.line_segment(
+        [
+            center + Vec2::angled(angle) * (cap * 0.35),
+            center + Vec2::angled(angle) * (cap - 2.),
+        ],
+        Stroke::new(2.0_f32, TEXT),
+    );
+    if response.has_focus() {
+        p.circle_stroke(center, radius + 2., Stroke::new(1.0_f32, color));
+    }
+    ui.label(
+        RichText::new(name.to_uppercase())
+            .size(if size > 100. { 14. } else { 12. })
+            .color(MUTED),
+    );
+    ui.add(
+        egui::DragValue::new(value)
+            .range(range)
+            .speed(0.1)
+            .suffix(unit),
+    );
+    response
+}
+/// Vertical gradient rectangle, used for panel faces.
+pub fn gradient(rect: Rect, top: Color32, bottom: Color32) -> egui::Shape {
+    let mut mesh = egui::Mesh::default();
+    for (pos, color) in [
+        (rect.left_top(), top),
+        (rect.right_top(), top),
+        (rect.right_bottom(), bottom),
+        (rect.left_bottom(), bottom),
+    ] {
+        mesh.colored_vertex(pos, color);
+    }
+    mesh.add_triangle(0, 1, 2);
+    mesh.add_triangle(0, 2, 3);
+    egui::Shape::mesh(mesh)
+}
+/// Raised hardware panel: graphite face, hairline edge, faint top highlight.
+pub fn panel<R>(ui: &mut egui::Ui, add: impl FnOnce(&mut egui::Ui) -> R) -> R {
+    let face = ui.painter().add(egui::Shape::Noop);
+    let inner = egui::Frame::new()
+        .inner_margin(14.)
+        .stroke(Stroke::new(1.0_f32, EDGE))
+        .show(ui, add);
+    let r = inner.response.rect;
+    ui.painter().set(face, gradient(r, PANEL_TOP, PANEL));
+    ui.painter().line_segment(
+        [
+            r.left_top() + Vec2::new(1., 1.),
+            r.right_top() + Vec2::new(-1., 1.),
+        ],
+        Stroke::new(1.0_f32, Color32::from_rgba_unmultiplied(255, 255, 255, 16)),
+    );
+    inner.inner
+}
+pub fn caption(ui: &mut egui::Ui, text: &str) {
+    ui.label(RichText::new(text).size(11.).color(MUTED));
+}
+/// Small labelled hardware-style readout.
+pub fn readout(ui: &mut egui::Ui, label: &str, value: String, color: Color32) {
+    ui.label(RichText::new(label).size(11.).color(MUTED));
+    ui.label(RichText::new(value).monospace().size(13.).color(color));
+    ui.add_space(10.);
+}
+/// Product header: accent mark, product name, subtitle, then right-aligned controls.
+pub fn header(ui: &mut egui::Ui, name: &str, subtitle: &str, right: impl FnOnce(&mut egui::Ui)) {
+    ui.horizontal(|ui| {
+        let (mark, _) = ui.allocate_exact_size(Vec2::new(4., 26.), Sense::hover());
+        ui.painter().rect_filled(mark, 1., ACCENT);
+        ui.label(
+            RichText::new(name)
+                .font(FontId::new(26., egui::FontFamily::Name("medium".into())))
+                .color(TEXT),
+        );
+        ui.label(RichText::new(subtitle).size(12.).color(MUTED));
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), right);
+    });
+}
+/// Full-window backdrop gradient used behind every editor.
+pub fn backdrop(ui: &egui::Ui) {
+    ui.painter()
+        .add(gradient(ui.max_rect(), Color32::from_rgb(20, 21, 24), BG));
+}
+/// Horizontal level bar in dBFS (−60..0) with a hairline frame.
+pub fn meter(ui: &mut egui::Ui, label: &str, db: f32, color: Color32, width: f32) {
+    ui.horizontal(|ui| {
+        ui.add_sized(
+            Vec2::new(70., 16.),
+            egui::Label::new(RichText::new(label).size(11.).color(MUTED)),
+        );
+        let (rect, _) = ui.allocate_exact_size(Vec2::new(width, 10.), Sense::hover());
+        let p = ui.painter();
+        p.rect_filled(rect, 1., SCREEN);
+        let t = ((db + 60.) / 60.).clamp(0., 1.);
+        let mut fill = rect;
+        fill.set_width(rect.width() * t);
+        p.rect_filled(fill, 1., color);
+        p.rect_stroke(
+            rect,
+            1.,
+            Stroke::new(1.0_f32, EDGE),
+            egui::StrokeKind::Inside,
+        );
+        ui.label(
+            RichText::new(if db <= -60. {
+                "−∞".to_string()
+            } else {
+                format!("{db:.1} dB")
+            })
+            .monospace()
+            .size(12.)
+            .color(TEXT),
+        );
+    });
+}
@@ -0,0 +1,13 @@
+[package]
+name = "crucible-core"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+common-dsp = { path = "../../common/dsp" }
+crossbeam-queue = "0.3"
+serde = { workspace = true }
+
+[dev-dependencies]
+serde_json = { workspace = true }
@@ -0,0 +1,93 @@
+//! Writes a take as ready-to-use files: the full loop, one file per slice and a wavetable.
+use crate::settings::Settings;
+use crate::take::{render, wavetable, Take, TABLE};
+use common_dsp::{note_name, wav};
+use std::path::{Path, PathBuf};
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Exported {
+    pub folder: PathBuf,
+    pub files: usize,
+    /// Why no wavetable was written although one was requested.
+    pub wavetable_skipped: Option<&'static str>,
+}
+
+/// UTC date and time for folder names, from the Unix time in seconds.
+pub fn stamp(unix: u64) -> String {
+    let days = (unix / 86400) as i64;
+    let secs = unix % 86400;
+    // Civil-from-days (H. Hinnant), proleptic Gregorian calendar.
+    let z = days + 719468;
+    let era = z.div_euclid(146097);
+    let doe = z - era * 146097;
+    let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+    let mp = (5 * doy + 2) / 153;
+    let day = doy - (153 * mp + 2) / 5 + 1;
+    let month = if mp < 10 { mp + 3 } else { mp - 9 };
+    let year = yoe + era * 400 + i64::from(month <= 2);
+    format!(
+        "{year:04}-{month:02}-{day:02}_{:02}{:02}{:02}",
+        secs / 3600,
+        secs / 60 % 60,
+        secs % 60
+    )
+}
+
+pub fn export(
+    take: &Take,
+    settings: &Settings,
+    selected: Option<usize>,
+    root: &Path,
+    unix: u64,
+) -> std::io::Result<Exported> {
+    let folder = root.join(format!("{}_{:.0}bpm", stamp(unix), take.tempo()));
+    std::fs::create_dir_all(&folder)?;
+    let rate = take.rate.round() as u32;
+    let stereo = |samples: Vec<f32>, root: Option<u8>| wav::Wave {
+        channels: 2,
+        rate,
+        samples,
+        root,
+        frame: None,
+    };
+    wav::write(&folder.join("loop.wav"), &stereo(take.audio.clone(), None))?;
+    let mut files = 1;
+    for (i, s) in take.slices.iter().enumerate().filter(|(_, s)| s.enabled) {
+        let name = match s.root {
+            Some(n) => format!("s{:02}_{}.wav", i + 1, note_name(n)),
+            None => format!("s{:02}.wav", i + 1),
+        };
+        wav::write(
+            &folder.join(name),
+            &stereo(render(take, s, settings), s.root),
+        )?;
+        files += 1;
+    }
+    let mut wavetable_skipped = None;
+    if settings.wavetable {
+        let source = selected
+            .and_then(|i| take.slices.get(i))
+            .or_else(|| take.slices.iter().find(|s| s.enabled && s.root.is_some()));
+        match source.map(|s| wavetable(&take.mono(s.start, s.end), take.rate)) {
+            Some(Some(table)) => {
+                let w = wav::Wave {
+                    channels: 1,
+                    rate,
+                    samples: table,
+                    root: None,
+                    frame: Some(TABLE as u32),
+                };
+                wav::write(&folder.join("wavetable.wav"), &w)?;
+                files += 1;
+            }
+            Some(None) => wavetable_skipped = Some("the slice has no clear pitch"),
+            None => wavetable_skipped = Some("no slice selected"),
+        }
+    }
+    Ok(Exported {
+        folder,
+        files,
+        wavetable_skipped,
+    })
+}
@@ -0,0 +1,18 @@
+//! Resampler: always records the input, captures the newest bars on request, slices them,
+//! cleans each slice and writes ready-to-use files.
+mod export;
+mod player;
+mod ring;
+mod settings;
+mod take;
+pub use export::{export, stamp, Exported};
+pub use player::{Clip, Player, Queues};
+pub use ring::{Marker, Recorder, Ring, Transport, MARKERS};
+pub use settings::{default_folder, Division, Mode, Settings};
+pub use take::{
+    capture, render, root_key, transients, wavetable, Segment, Slice, Take, FALLBACK_TEMPO,
+    OVERVIEW, TABLE, TABLE_FRAMES,
+};
+
+/// Seconds of history: 16 bars at 60 BPM in 4/4, plus slack for the capture copy.
+pub const HISTORY: f32 = 72.;
@@ -0,0 +1,73 @@
+//! Audition of slices on the audio thread without allocating or freeing there.
+use crossbeam_queue::ArrayQueue;
+use std::sync::Arc;
+
+pub type Clip = Arc<[f32]>;
+
+/// Shared queues. The GUI sends clips and drains finished ones, so all frees happen there.
+pub struct Queues {
+    incoming: ArrayQueue<Option<Clip>>,
+    finished: ArrayQueue<Clip>,
+}
+impl Default for Queues {
+    fn default() -> Self {
+        Self {
+            incoming: ArrayQueue::new(4),
+            finished: ArrayQueue::new(16),
+        }
+    }
+}
+impl Queues {
+    /// Plays an interleaved stereo clip, replacing the current one.
+    pub fn play(&self, clip: Clip) {
+        self.drain();
+        let _ = self.incoming.force_push(Some(clip));
+    }
+    pub fn stop(&self) {
+        let _ = self.incoming.force_push(None);
+    }
+    /// Frees finished clips. Call regularly from the GUI thread.
+    pub fn drain(&self) {
+        while self.finished.pop().is_some() {}
+    }
+}
+
+#[derive(Default)]
+pub struct Player {
+    clip: Option<Clip>,
+    at: usize,
+}
+impl Player {
+    fn retire(&mut self, queues: &Queues) {
+        if let Some(old) = self.clip.take() {
+            // The GUI drains this queue every frame; a full queue only happens with no editor.
+            if let Err(old) = queues.finished.push(old) {
+                std::mem::forget(old);
+            }
+        }
+    }
+    /// Call once per block.
+    pub fn block(&mut self, queues: &Queues) {
+        while let Some(next) = queues.incoming.pop() {
+            self.retire(queues);
+            self.clip = next;
+            self.at = 0;
+        }
+    }
+    #[inline]
+    pub fn next(&mut self, queues: &Queues) -> [f32; 2] {
+        let Some(clip) = &self.clip else {
+            return [0.; 2];
+        };
+        if self.at + 1 >= clip.len() {
+            self.retire(queues);
+            return [0.; 2];
+        }
+        let out = [clip[self.at], clip[self.at + 1]];
+        self.at += 2;
+        out
+    }
+    pub fn playing(&self) -> bool {
+        self.clip.is_some()
+    }
+}
@@ -0,0 +1,206 @@
+//! Lock-free history of the input plus the host transport, shared by the audio and GUI threads.
+//!
+//! The audio thread writes samples with relaxed stores and publishes the frame count with a
+//! release store. The GUI thread reads the count with acquire, copies, then checks the count
+//! again: anything the writer may have overwritten during the copy is reported, never returned.
+use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
+
+/// Transport markers kept for alignment; one is written at least every half second.
+pub const MARKERS: usize = 512;
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Transport {
+    pub playing: bool,
+    pub tempo: f64,
+    /// Song position in quarter notes at the first sample of the block.
+    pub beats: f64,
+    pub numerator: u32,
+    pub denominator: u32,
+}
+impl Transport {
+    /// Bar length in quarter notes.
+    pub fn bar(&self) -> f64 {
+        self.numerator.max(1) as f64 * 4. / self.denominator.max(1) as f64
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Marker {
+    /// Absolute recorded frame index.
+    pub frame: u64,
+    pub transport: Transport,
+}
+impl Marker {
+    /// Song position at `frame`, extrapolated at this marker's tempo.
+    pub fn beats_at(&self, frame: f64, rate: f64) -> f64 {
+        self.transport.beats + (frame - self.frame as f64) / rate * self.transport.tempo / 60.
+    }
+    pub fn frame_at(&self, beats: f64, rate: f64) -> f64 {
+        self.frame as f64 + (beats - self.transport.beats) * 60. / self.transport.tempo * rate
+    }
+}
+
+pub struct Ring {
+    rate: f32,
+    frames: usize,
+    data: Box<[AtomicU32]>,
+    written: AtomicU64,
+    markers: Box<[[AtomicU64; 4]]>,
+    marker_count: AtomicU64,
+    peak: AtomicU32,
+}
+impl Ring {
+    /// Stereo history of `seconds` at `rate`.
+    pub fn new(rate: f32, seconds: f32) -> Self {
+        let frames = (rate * seconds).ceil().max(1.) as usize;
+        Self {
+            rate,
+            frames,
+            data: (0..frames * 2).map(|_| AtomicU32::new(0)).collect(),
+            written: AtomicU64::new(0),
+            markers: (0..MARKERS)
+                .map(|_| std::array::from_fn(|_| AtomicU64::new(0)))
+                .collect(),
+            marker_count: AtomicU64::new(0),
+            peak: AtomicU32::new(0),
+        }
+    }
+    pub fn rate(&self) -> f32 {
+        self.rate
+    }
+    pub fn capacity(&self) -> usize {
+        self.frames
+    }
+    pub fn written(&self) -> u64 {
+        self.written.load(Ordering::Acquire)
+    }
+    /// Input peak since the last call, for the editor meter.
+    pub fn take_peak(&self) -> f32 {
+        f32::from_bits(self.peak.swap(0, Ordering::AcqRel))
+    }
+    /// Markers that are certainly intact, oldest first.
+    pub fn markers(&self) -> Vec<Marker> {
+        let count = self.marker_count.load(Ordering::Acquire);
+        // A margin keeps slots the writer may be refilling during this read out of the result.
+        let first = count.saturating_sub(MARKERS as u64 - 8);
+        let mut out: Vec<Marker> = (first..count)
+            .map(|i| {
+                let s = &self.markers[(i % MARKERS as u64) as usize];
+                let meta = s[3].load(Ordering::Relaxed);
+                Marker {
+                    frame: s[0].load(Ordering::Relaxed),
+                    transport: Transport {
+                        beats: f64::from_bits(s[1].load(Ordering::Relaxed)),
+                        tempo: f64::from_bits(s[2].load(Ordering::Relaxed)),
+                        numerator: (meta & 0xffff) as u32,
+                        denominator: ((meta >> 16) & 0xffff) as u32,
+                        playing: meta >> 32 & 1 == 1,
+                    },
+                }
+            })
+            .collect();
+        let after = self.marker_count.load(Ordering::Acquire);
+        let safe = after.saturating_sub(MARKERS as u64 - 8);
+        out.drain(..(safe.saturating_sub(first) as usize).min(out.len()));
+        out
+    }
+    /// Copies frames `[start, end)` as interleaved stereo. Fails if any were overwritten.
+    pub fn copy(&self, start: u64, end: u64) -> Result<Vec<f32>, &'static str> {
+        let written = self.written();
+        if end > written || start > end {
+            return Err("Capture range is not recorded yet.");
+        }
+        if written - start > self.frames as u64 {
+            return Err("Capture is longer than the recording buffer.");
+        }
+        let mut out = Vec::with_capacity(((end - start) * 2) as usize);
+        for f in start..end {
+            let at = (f % self.frames as u64) as usize * 2;
+            out.push(f32::from_bits(self.data[at].load(Ordering::Relaxed)));
+            out.push(f32::from_bits(self.data[at + 1].load(Ordering::Relaxed)));
+        }
+        if self.written() - start > self.frames as u64 {
+            return Err("Capture was overwritten while copying. Try again.");
+        }
+        Ok(out)
+    }
+}
+
+/// Audio-thread writer. Never allocates.
+pub struct Recorder {
+    last: Option<Marker>,
+    frame: u64,
+    since_marker: u64,
+    peak: f32,
+}
+impl Default for Recorder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl Recorder {
+    pub fn new() -> Self {
+        Self {
+            last: None,
+            frame: 0,
+            since_marker: 0,
+            peak: 0.,
+        }
+    }
+    /// Call at the start of every block with the host transport.
+    pub fn block(&mut self, ring: &Ring, transport: Option<Transport>) {
+        let Some(t) =
+            transport.filter(|t| t.tempo.is_finite() && t.tempo > 1. && t.beats.is_finite())
+        else {
+            return;
+        };
+        let rate = ring.rate as f64;
+        let changed = match self.last {
+            None => true,
+            Some(m) => {
+                let expected = m.beats_at(self.frame as f64, rate);
+                m.transport.playing != t.playing
+                    || (m.transport.tempo - t.tempo).abs() > 1e-6
+                    || m.transport.numerator != t.numerator
+                    || m.transport.denominator != t.denominator
+                    || (t.playing && (expected - t.beats).abs() > 0.01)
+            }
+        };
+        if changed || self.since_marker as f64 >= rate * 0.5 {
+            let m = Marker {
+                frame: self.frame,
+                transport: t,
+            };
+            let count = ring.marker_count.load(Ordering::Relaxed);
+            let s = &ring.markers[(count % MARKERS as u64) as usize];
+            s[0].store(m.frame, Ordering::Relaxed);
+            s[1].store(t.beats.to_bits(), Ordering::Relaxed);
+            s[2].store(t.tempo.to_bits(), Ordering::Relaxed);
+            let meta = (t.numerator as u64 & 0xffff)
+                | (t.denominator as u64 & 0xffff) << 16
+                | (t.playing as u64) << 32;
+            s[3].store(meta, Ordering::Relaxed);
+            ring.marker_count.store(count + 1, Ordering::Release);
+            self.last = Some(m);
+            self.since_marker = 0;
+        }
+    }
+    #[inline]
+    pub fn push(&mut self, ring: &Ring, frame: [f32; 2]) {
+        let at = (self.frame % ring.frames as u64) as usize * 2;
+        ring.data[at].store(frame[0].to_bits(), Ordering::Relaxed);
+        ring.data[at + 1].store(frame[1].to_bits(), Ordering::Relaxed);
+        self.frame += 1;
+        self.since_marker += 1;
+        self.peak = self.peak.max(frame[0].abs()).max(frame[1].abs());
+    }
+    /// Makes the frames pushed so far visible to the GUI thread. Call at the end of a block.
+    pub fn publish(&mut self, ring: &Ring) {
+        ring.written.store(self.frame, Ordering::Release);
+        let old = f32::from_bits(ring.peak.load(Ordering::Relaxed));
+        if self.peak > old {
+            ring.peak.store(self.peak.to_bits(), Ordering::Relaxed);
+        }
+        self.peak = 0.;
+    }
+}
@@ -0,0 +1,120 @@
+//! Persisted editor choices. Takes are not part of plugin state; exported files are.
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
+pub enum Mode {
+    /// Cut on the bar/beat grid.
+    #[default]
+    Grid,
+    /// Cut where a new hit starts.
+    Transient,
+}
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
+pub enum Division {
+    Quarter,
+    Eighth,
+    #[default]
+    Sixteenth,
+    EighthTriplet,
+    SixteenthTriplet,
+}
+impl Division {
+    pub const ALL: [Division; 5] = [
+        Division::Quarter,
+        Division::Eighth,
+        Division::Sixteenth,
+        Division::EighthTriplet,
+        Division::SixteenthTriplet,
+    ];
+    /// Slices per quarter note.
+    pub fn per_quarter(self) -> u32 {
+        match self {
+            Division::Quarter => 1,
+            Division::Eighth => 2,
+            Division::Sixteenth => 4,
+            Division::EighthTriplet => 3,
+            Division::SixteenthTriplet => 6,
+        }
+    }
+    pub fn label(self) -> &'static str {
+        match self {
+            Division::Quarter => "1/4",
+            Division::Eighth => "1/8",
+            Division::Sixteenth => "1/16",
+            Division::EighthTriplet => "1/8T",
+            Division::SixteenthTriplet => "1/16T",
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(default)]
+pub struct Settings {
+    pub bars: u32,
+    pub mode: Mode,
+    pub division: Division,
+    /// Transient sensitivity, 0–100 %.
+    pub sensitivity: f32,
+    /// Fade length at both slice edges in milliseconds.
+    pub declick: f32,
+    /// Peak-normalise each slice to −0.3 dBFS.
+    pub normalize: bool,
+    /// Remove leading silence below −60 dBFS.
+    pub trim: bool,
+    /// Also write a wavetable from the selected slice.
+    pub wavetable: bool,
+    /// Export folder; empty selects the default.
+    pub folder: String,
+}
+impl Default for Settings {
+    fn default() -> Self {
+        Self {
+            bars: 4,
+            mode: Mode::Grid,
+            division: Division::Sixteenth,
+            sensitivity: 50.,
+            declick: 2.,
+            normalize: true,
+            trim: true,
+            wavetable: false,
+            folder: String::new(),
+        }
+    }
+}
+impl Settings {
+    pub const BARS: [u32; 5] = [1, 2, 4, 8, 16];
+    /// Clamps values from old or hand-edited state into their ranges.
+    pub fn sanitize(&mut self) {
+        if !Self::BARS.contains(&self.bars) {
+            self.bars = 4;
+        }
+        self.sensitivity = if self.sensitivity.is_finite() {
+            self.sensitivity.clamp(0., 100.)
+        } else {
+            50.
+        };
+        self.declick = if self.declick.is_finite() {
+            self.declick.clamp(0., 20.)
+        } else {
+            2.
+        };
+    }
+    pub fn folder(&self) -> PathBuf {
+        if !self.folder.trim().is_empty() {
+            return PathBuf::from(self.folder.trim());
+        }
+        default_folder()
+    }
+}
+pub fn default_folder() -> PathBuf {
+    if cfg!(windows) {
+        if let Some(home) = std::env::var_os("USERPROFILE") {
+            return PathBuf::from(home).join("Documents").join("Crucible");
+        }
+    }
+    match std::env::var_os("HOME") {
+        Some(home) => PathBuf::from(home).join("Crucible"),
+        None => PathBuf::from("Crucible"),
+    }
+}
@@ -0,0 +1,478 @@
+//! Captured audio with its tempo map, slice boundaries and per-slice cleanup.
+use crate::ring::{Marker, Ring, Transport};
+use crate::settings::{Division, Mode, Settings};
+use common_dsp::{hz_to_midi, Yin};
+
+/// Used when the host reports no tempo.
+pub const FALLBACK_TEMPO: f64 = 140.;
+/// Waveform overview resolution.
+pub const OVERVIEW: usize = 2048;
+
+/// One constant-tempo stretch of the take, relative to the take start.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Segment {
+    pub frame: f64,
+    pub quarters: f64,
+    pub tempo: f64,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Slice {
+    pub start: usize,
+    pub end: usize,
+    pub enabled: bool,
+    pub root: Option<u8>,
+}
+
+#[derive(Clone, Debug)]
+pub struct Take {
+    pub rate: f32,
+    /// Interleaved stereo.
+    pub audio: Vec<f32>,
+    pub bars: u32,
+    pub numerator: u32,
+    pub denominator: u32,
+    /// True when aligned to the host's bar lines; false when the transport was stopped.
+    pub synced: bool,
+    pub segments: Vec<Segment>,
+    /// Slice boundaries in frames, sorted, starting at 0 and ending at the take length.
+    pub cuts: Vec<usize>,
+    pub slices: Vec<Slice>,
+    /// Min/max per overview bucket of the mono sum.
+    pub overview: Vec<[f32; 2]>,
+}
+
+impl Take {
+    pub fn frames(&self) -> usize {
+        self.audio.len() / 2
+    }
+    pub fn tempo(&self) -> f64 {
+        self.segments.first().map_or(FALLBACK_TEMPO, |s| s.tempo)
+    }
+    pub fn bar_quarters(&self) -> f64 {
+        self.numerator.max(1) as f64 * 4. / self.denominator.max(1) as f64
+    }
+    pub fn quarters(&self) -> f64 {
+        self.bars as f64 * self.bar_quarters()
+    }
+    /// Frame at a position in quarter notes from the take start.
+    pub fn frame_at(&self, quarters: f64) -> f64 {
+        let s = self
+            .segments
+            .iter()
+            .rev()
+            .find(|s| s.quarters <= quarters + 1e-9)
+            .or(self.segments.first());
+        match s {
+            Some(s) => s.frame + (quarters - s.quarters) * 60. / s.tempo * self.rate as f64,
+            None => quarters * 60. / FALLBACK_TEMPO * self.rate as f64,
+        }
+    }
+    pub fn mono(&self, start: usize, end: usize) -> Vec<f32> {
+        self.audio[start * 2..end * 2]
+            .as_chunks::<2>()
+            .0
+            .iter()
+            .map(|f| 0.5 * (f[0] + f[1]))
+            .collect()
+    }
+    fn build_overview(&mut self) {
+        let n = self.frames();
+        self.overview = (0..OVERVIEW)
+            .map(|b| {
+                let (a, z) = (
+                    b * n / OVERVIEW,
+                    ((b + 1) * n / OVERVIEW).max(b * n / OVERVIEW + 1),
+                );
+                let mut mm = [0f32, 0f32];
+                for f in a..z.min(n) {
+                    let v = 0.5 * (self.audio[2 * f] + self.audio[2 * f + 1]);
+                    mm[0] = mm[0].min(v);
+                    mm[1] = mm[1].max(v);
+                }
+                mm
+            })
+            .collect();
+    }
+    pub fn from_audio(
+        rate: f32,
+        audio: Vec<f32>,
+        bars: u32,
+        transport: Transport,
+        segments: Vec<Segment>,
+        synced: bool,
+    ) -> Self {
+        let mut t = Take {
+            rate,
+            audio,
+            bars,
+            numerator: transport.numerator.max(1),
+            denominator: transport.denominator.max(1),
+            synced,
+            segments,
+            cuts: Vec::new(),
+            slices: Vec::new(),
+            overview: Vec::new(),
+        };
+        t.build_overview();
+        let n = t.frames();
+        t.cuts = vec![0, n];
+        t.rebuild_slices();
+        t
+    }
+    /// Re-cuts the take from the settings, replacing manual edits.
+    pub fn slice(&mut self, settings: &Settings) {
+        let n = self.frames();
+        let mut cuts = match settings.mode {
+            Mode::Grid => grid(self, settings.division),
+            Mode::Transient => transients(&self.mono(0, n), self.rate, settings.sensitivity),
+        };
+        cuts.push(0);
+        cuts.push(n);
+        cuts.sort_unstable();
+        cuts.dedup();
+        cuts.retain(|c| *c <= n);
+        self.cuts = cuts;
+        self.rebuild_slices();
+    }
+    /// Adds a cut; returns false if it is too close to an existing one.
+    pub fn add_cut(&mut self, frame: usize) -> bool {
+        let min = (self.rate * 0.005) as usize;
+        if frame == 0 || frame >= self.frames() || self.cuts.iter().any(|c| c.abs_diff(frame) < min)
+        {
+            return false;
+        }
+        let at = self.cuts.partition_point(|c| *c < frame);
+        self.cuts.insert(at, frame);
+        self.rebuild_slices();
+        true
+    }
+    /// Removes the inner cut nearest to `frame`.
+    pub fn remove_cut(&mut self, frame: usize) -> bool {
+        let inner = 1..self.cuts.len().saturating_sub(1);
+        let Some(i) = inner.min_by_key(|i| self.cuts[*i].abs_diff(frame)) else {
+            return false;
+        };
+        self.cuts.remove(i);
+        self.rebuild_slices();
+        true
+    }
+    fn rebuild_slices(&mut self) {
+        let old = std::mem::take(&mut self.slices);
+        let mut yin = Yin::new((self.rate / 35.) as usize + 4);
+        self.slices = self
+            .cuts
+            .windows(2)
+            .map(|w| {
+                // Manual include/exclude choices survive a re-cut when the slice keeps its start.
+                let enabled = old
+                    .iter()
+                    .find(|s| s.start == w[0])
+                    .is_none_or(|s| s.enabled);
+                let mono = self.mono(w[0], w[1]);
+                Slice {
+                    start: w[0],
+                    end: w[1],
+                    enabled,
+                    root: root_key(&mut yin, &mono, self.rate),
+                }
+            })
+            .collect();
+    }
+    pub fn slice_at(&self, frame: usize) -> Option<usize> {
+        self.slices
+            .iter()
+            .position(|s| frame >= s.start && frame < s.end)
+    }
+}
+
+fn grid(take: &Take, division: Division) -> Vec<usize> {
+    let per = division.per_quarter() as f64;
+    let steps = (take.quarters() * per).round() as usize;
+    (1..steps)
+        .map(|k| take.frame_at(k as f64 / per).round() as usize)
+        .collect()
+}
+
+/// Onsets where a window's high-frequency weighted energy jumps above the window before it.
+/// Windows span 40 ms, longer than one cycle of the lowest bass note, so the edges inside a
+/// distorted bass cycle never count as hits. Each onset is refined to its first loud sample.
+pub fn transients(x: &[f32], rate: f32, sensitivity: f32) -> Vec<usize> {
+    let hop = ((rate / 375.) as usize).max(32);
+    let window = ((rate * 0.04) as usize / hop).max(1) * hop;
+    if x.len() < 2 * window + hop {
+        return Vec::new();
+    }
+    // Prefix sums of weighted energy, in f64 so long takes keep their precision.
+    let mut sums = Vec::with_capacity(x.len() + 1);
+    sums.push(0f64);
+    let mut prev = 0f32;
+    for v in x {
+        let d = v - prev;
+        prev = *v;
+        let e = (v * v + 4. * d * d) as f64;
+        sums.push(sums.last().unwrap() + e);
+    }
+    let level = |end: usize| {
+        let e = (sums[end] - sums[end - window]) / window as f64;
+        10. * (e + 1e-10).log10() as f32
+    };
+    let rise_db = 14. - 0.11 * sensitivity.clamp(0., 100.);
+    let floor = -55.;
+    let gap = (0.04 * rate) as usize;
+    let mut cuts: Vec<usize> = Vec::new();
+    let mut end = 2 * window;
+    while end <= x.len() {
+        let now = level(end);
+        if now > floor && now - level(end - window) >= rise_db {
+            let from = end - window;
+            let to = (end + hop).min(x.len());
+            let peak = x[from..to].iter().fold(0f32, |m, v| m.max(v.abs()));
+            let first = x[from..to]
+                .iter()
+                .position(|v| v.abs() >= 0.3 * peak)
+                .unwrap_or(0);
+            // Start slightly before the first loud sample so the attack stays whole.
+            let onset = (from + first).saturating_sub((rate * 0.0005) as usize);
+            if cuts.last().is_none_or(|c| onset >= c + gap) {
+                cuts.push(onset);
+                // Skip past this attack so it is not found again as the window slides on.
+                end = onset + window + gap;
+            }
+        }
+        end += hop;
+    }
+    cuts
+}
+
+/// Root note of a slice, if it is clearly pitched.
+pub fn root_key(yin: &mut Yin, mono: &[f32], rate: f32) -> Option<u8> {
+    let window = (2 * yin.max_lag() + 2).min(mono.len());
+    if window < (rate / 1000.) as usize * 4 || mono.len() < window {
+        return None;
+    }
+    // Skip the attack: the body of a hit carries its pitch.
+    let mut notes: Vec<f32> = Vec::new();
+    let start = (mono.len() / 5).min(mono.len() - window);
+    let step = (window / 2).max(1);
+    let mut at = start;
+    while at + window <= mono.len() && notes.len() < 6 {
+        if let Some((hz, clarity)) = yin.estimate(&mono[at..at + window], rate, 35., 1000.) {
+            if clarity > 0.7 {
+                notes.push(hz_to_midi(hz));
+            }
+        }
+        at += step;
+    }
+    if notes.is_empty() {
+        return None;
+    }
+    notes.sort_by(f32::total_cmp);
+    let n = notes[notes.len() / 2].round();
+    (0. ..=127.).contains(&n).then_some(n as u8)
+}
+
+/// Builds a take from the newest `bars` complete bars, or from the newest audio when stopped.
+pub fn capture(ring: &Ring, bars: u32) -> Result<Take, &'static str> {
+    let rate = ring.rate() as f64;
+    let written = ring.written();
+    let markers = ring.markers();
+    let last = markers.iter().rev().find(|m| m.frame <= written).copied();
+    let fallback = Transport {
+        playing: false,
+        tempo: FALLBACK_TEMPO,
+        beats: 0.,
+        numerator: 4,
+        denominator: 4,
+    };
+    let t = last.map_or(fallback, |m| m.transport);
+    let bar = t.bar();
+    let quarters = bars as f64 * bar;
+    let (start, end, segments, synced) = match last {
+        Some(m) if m.transport.playing => {
+            let now = m.beats_at(written as f64, rate);
+            let end_beats = (now / bar + 1e-9).floor() * bar;
+            let start_beats = end_beats - quarters;
+            let end = frame_for(&markers, end_beats, rate);
+            let start = frame_for(&markers, start_beats, rate);
+            let segments = segments(&markers, start_beats, end_beats, start, rate);
+            (start, end, segments, true)
+        }
+        _ => {
+            let length = quarters * 60. / t.tempo * rate;
+            let segments = vec![Segment {
+                frame: 0.,
+                quarters: 0.,
+                tempo: t.tempo,
+            }];
+            (written as f64 - length, written as f64, segments, false)
+        }
+    };
+    if start < 0. {
+        return Err("Not enough audio recorded yet. Play the section first.");
+    }
+    let (start, end) = (start.round() as u64, end.round() as u64);
+    if end - start > ring.capacity() as u64 {
+        return Err("Too long for the recording buffer. Capture fewer bars.");
+    }
+    let audio = ring.copy(start, end)?;
+    Ok(Take::from_audio(
+        ring.rate(),
+        audio,
+        bars,
+        t,
+        segments,
+        synced,
+    ))
+}
+
+/// Frame of a song position, from the marker whose stretch contains it.
+fn frame_for(markers: &[Marker], beats: f64, rate: f64) -> f64 {
+    let m = markers
+        .iter()
+        .rev()
+        .find(|m| m.transport.playing && m.transport.beats <= beats + 1e-9)
+        .or_else(|| markers.iter().find(|m| m.transport.playing));
+    m.map_or(0., |m| m.frame_at(beats, rate))
+}
+
+fn segments(markers: &[Marker], from: f64, to: f64, origin: f64, rate: f64) -> Vec<Segment> {
+    let mut out: Vec<Segment> = Vec::new();
+    for m in markers.iter().filter(|m| m.transport.playing) {
+        let q = m.transport.beats - from;
+        if m.transport.beats >= to {
+            break;
+        }
+        let tempo = m.transport.tempo;
+        if q <= 0. {
+            out.clear();
+            out.push(Segment {
+                frame: m.frame_at(from, rate) - origin,
+                quarters: 0.,
+                tempo,
+            });
+        } else if out.last().is_none_or(|s| (s.tempo - tempo).abs() > 1e-6) {
+            out.push(Segment {
+                frame: m.frame as f64 - origin,
+                quarters: q,
+                tempo,
+            });
+        }
+    }
+    if out.is_empty() {
+        out.push(Segment {
+            frame: 0.,
+            quarters: 0.,
+            tempo: FALLBACK_TEMPO,
+        });
+    }
+    out
+}
+
+/// A cleaned-up slice ready to save: trimmed, faded and optionally normalised.
+pub fn render(take: &Take, slice: &Slice, settings: &Settings) -> Vec<f32> {
+    let mut start = slice.start;
+    let end = slice.end;
+    if settings.trim {
+        let threshold = 10f32.powf(-60. / 20.);
+        if let Some(i) = take.audio[start * 2..end * 2]
+            .as_chunks::<2>()
+            .0
+            .iter()
+            .position(|f| f[0].abs().max(f[1].abs()) > threshold)
+        {
+            // Keep a short pre-roll so the attack is not cut into.
+            start += i.saturating_sub((take.rate * 0.001) as usize);
+        }
+    }
+    let mut out = take.audio[start * 2..end * 2].to_vec();
+    let frames = out.len() / 2;
+    let fade = ((settings.declick * 0.001 * take.rate) as usize).min(frames / 2);
+    for i in 0..fade {
+        let g = i as f32 / fade as f32;
+        for c in 0..2 {
+            out[2 * i + c] *= g;
+            out[2 * (frames - 1 - i) + c] *= g;
+        }
+    }
+    if settings.normalize {
+        let peak = out.iter().fold(0f32, |m, v| m.max(v.abs()));
+        if peak > 1e-6 {
+            let g = 10f32.powf(-0.3 / 20.) / peak;
+            out.iter_mut().for_each(|v| *v *= g);
+        }
+    }
+    out
+}
+
+pub const TABLE: usize = 2048;
+pub const TABLE_FRAMES: usize = 256;
+
+/// Single-cycle frames from a pitched slice. Each frame starts on a rising zero crossing,
+/// so neighbouring frames stay in phase and morph smoothly in a wavetable synth.
+pub fn wavetable(mono: &[f32], rate: f32) -> Option<Vec<f32>> {
+    let mut yin = Yin::new((rate / 30.) as usize + 4);
+    let window = 2 * yin.max_lag() + 2;
+    let probe = &mono[(mono.len() / 5).min(mono.len().saturating_sub(window))..];
+    let (hz, _) = yin.estimate(&probe[..window.min(probe.len())], rate, 30., 2000.)?;
+    let period = rate as f64 / hz as f64;
+    let rising = |i: usize| mono[i - 1] < 0. && mono[i] >= 0.;
+    let crossing = |i: usize| (i - 1) as f64 + mono[i - 1] as f64 / (mono[i - 1] - mono[i]) as f64;
+    let mut starts = Vec::new();
+    let mut at = (1..mono.len()).find(|i| rising(*i))?;
+    starts.push(crossing(at));
+    loop {
+        let expect = starts.last().unwrap() + period;
+        let tolerance = period * 0.2;
+        let lo = (expect - tolerance).max(1.) as usize;
+        let hi = ((expect + tolerance) as usize).min(mono.len() - 1);
+        if lo >= hi {
+            break;
+        }
+        // The rising crossing nearest one period on; slight drift and detune are followed.
+        let Some(next) = (lo..=hi).filter(|i| rising(*i)).min_by(|a, b| {
+            (crossing(*a) - expect)
+                .abs()
+                .total_cmp(&(crossing(*b) - expect).abs())
+        }) else {
+            // No crossing: skip one period and look again.
+            at = (expect as usize).min(mono.len() - 1);
+            match (at..mono.len()).find(|i| rising(*i)) {
+                Some(i) => {
+                    starts.push(crossing(i));
+                    continue;
+                }
+                None => break,
+            }
+        };
+        starts.push(crossing(next));
+    }
+    let cycles: Vec<(f64, f64)> = starts
+        .windows(2)
+        .map(|w| (w[0], w[1]))
+        .filter(|(a, b)| (b - a - period).abs() < period * 0.25)
+        .collect();
+    if cycles.is_empty() {
+        return None;
+    }
+    let count = cycles.len().min(TABLE_FRAMES);
+    let mut table = Vec::with_capacity(count * TABLE);
+    for k in 0..count {
+        let (a, b) = cycles[k * cycles.len() / count];
+        for j in 0..TABLE {
+            let pos = a + (b - a) * j as f64 / TABLE as f64;
+            let i = pos.floor() as usize;
+            let frac = (pos - i as f64) as f32;
+            let x0 = mono[i.min(mono.len() - 1)];
+            let x1 = mono[(i + 1).min(mono.len() - 1)];
+            table.push(x0 + (x1 - x0) * frac);
+        }
+    }
+    let peak = table.iter().fold(0f32, |m, v| m.max(v.abs()));
+    if peak < 1e-6 {
+        return None;
+    }
+    let g = 10f32.powf(-0.3 / 20.) / peak;
+    table.iter_mut().for_each(|v| *v *= g);
+    Some(table)
+}
@@ -0,0 +1,258 @@
+use common_dsp::{wav, Saw};
+use crucible_core::*;
+
+const RATE: f32 = 48000.;
+
+fn playing(tempo: f64, beats: f64) -> Transport {
+    Transport {
+        playing: true,
+        tempo,
+        beats,
+        numerator: 4,
+        denominator: 4,
+    }
+}
+/// Records `frames` of a ramp (sample value = frame index) in blocks, with transport.
+fn record(ring: &Ring, rec: &mut Recorder, from: u64, frames: u64, tempo: f64, beats0: f64) {
+    let block = 480u64;
+    let mut f = 0;
+    while f < frames {
+        let beats = beats0 + f as f64 / RATE as f64 * tempo / 60.;
+        rec.block(ring, Some(playing(tempo, beats)));
+        for i in 0..block.min(frames - f) {
+            let v = (from + f + i) as f32;
+            rec.push(ring, [v, -v]);
+        }
+        rec.publish(ring);
+        f += block;
+    }
+}
+
+#[test]
+fn ring_copy_is_exact_across_the_wrap_and_detects_overwrites() {
+    let ring = Ring::new(RATE, 1.);
+    let mut rec = Recorder::new();
+    record(&ring, &mut rec, 0, 70000, 120., 0.);
+    let got = ring.copy(60000, 70000).unwrap();
+    for (k, f) in got.chunks(2).enumerate() {
+        assert_eq!(f[0], (60000 + k) as f32);
+        assert_eq!(f[1], -((60000 + k) as f32));
+    }
+    assert!(ring.copy(10000, 20000).is_err());
+    assert!(ring.copy(69000, 71000).is_err());
+}
+
+#[test]
+fn capture_ends_on_the_last_bar_line() {
+    let ring = Ring::new(RATE, HISTORY);
+    let mut rec = Recorder::new();
+    // 120 BPM: one beat = 24000 frames, one 4/4 bar = 96000 frames. Stop mid bar 4.
+    record(&ring, &mut rec, 0, 96000 * 3 + 30000, 120., 0.);
+    let take = capture(&ring, 2).unwrap();
+    assert!(take.synced);
+    assert_eq!(take.frames(), 2 * 96000);
+    assert_eq!(take.audio[0], 96000.);
+    assert_eq!(take.audio[take.audio.len() - 2], (3 * 96000 - 1) as f32);
+    assert!(capture(&ring, 4).is_err(), "only three full bars exist");
+}
+
+#[test]
+fn capture_follows_tempo_changes() {
+    let ring = Ring::new(RATE, HISTORY);
+    let mut rec = Recorder::new();
+    // 4 beats at 120 BPM (96000 frames), then 60 BPM (48000 frames per beat).
+    record(&ring, &mut rec, 0, 96000, 120., 0.);
+    record(&ring, &mut rec, 96000, 5 * 48000 + 1000, 60., 4.);
+    let take = capture(&ring, 2).unwrap();
+    // Bars 1–2 end at beat 8 = 96000 + 4 × 48000.
+    assert_eq!(take.frames(), 96000 + 4 * 48000);
+    assert_eq!(take.audio[0], 0.);
+    assert_eq!(take.segments.len(), 2);
+    assert!((take.frame_at(4.) - 96000.).abs() < 1.);
+    assert!((take.frame_at(6.) - (96000. + 2. * 48000.)).abs() < 1.);
+}
+
+#[test]
+fn stopped_transport_captures_the_newest_audio() {
+    let ring = Ring::new(RATE, HISTORY);
+    let mut rec = Recorder::new();
+    for _ in 0..500 {
+        rec.block(
+            &ring,
+            Some(Transport {
+                playing: false,
+                ..playing(150., 0.)
+            }),
+        );
+        for _ in 0..480 {
+            rec.push(&ring, [0.1, 0.1]);
+        }
+        rec.publish(&ring);
+    }
+    let take = capture(&ring, 1).unwrap();
+    assert!(!take.synced);
+    // One bar at 150 BPM = 1.6 s.
+    assert_eq!(take.frames(), 76800);
+}
+
+fn take_of(mono: Vec<f32>, tempo: f64, bars: u32) -> Take {
+    let audio = mono.iter().flat_map(|v| [*v, *v]).collect();
+    Take::from_audio(
+        RATE,
+        audio,
+        bars,
+        playing(tempo, 0.),
+        vec![Segment {
+            frame: 0.,
+            quarters: 0.,
+            tempo,
+        }],
+        true,
+    )
+}
+
+#[test]
+fn grid_slices_straight_and_triplet() {
+    let mut take = take_of(vec![0.; 96000], 120., 1);
+    let mut s = Settings {
+        division: Division::Sixteenth,
+        ..Settings::default()
+    };
+    take.slice(&s);
+    assert_eq!(take.slices.len(), 16);
+    assert_eq!(take.cuts[1], 6000);
+    s.division = Division::EighthTriplet;
+    take.slice(&s);
+    assert_eq!(take.slices.len(), 12);
+    assert_eq!(take.cuts[1], 8000);
+}
+
+#[test]
+fn transients_find_hits_within_two_milliseconds() {
+    let mut x = vec![0.; 96000];
+    let hits = [4800usize, 20000, 31111, 60000, 80000];
+    for &h in &hits {
+        for i in 0..2000 {
+            x[h + i] = (i as f32 * 0.3).sin() * (-(i as f32) / 400.).exp() * 0.8;
+        }
+    }
+    let found = transients(&x, RATE, 50.);
+    assert_eq!(found.len(), hits.len(), "{found:?}");
+    for (f, h) in found.iter().zip(hits) {
+        assert!(f.abs_diff(h) < 96, "{f} vs {h}");
+    }
+    let mut take = take_of(x, 120., 1);
+    take.slice(&Settings {
+        mode: Mode::Transient,
+        ..Settings::default()
+    });
+    assert_eq!(take.slices.len(), hits.len() + 1);
+}
+
+#[test]
+fn manual_cuts_add_and_remove() {
+    let mut take = take_of(vec![0.; 48000], 120., 1);
+    assert!(take.add_cut(12000));
+    assert!(!take.add_cut(12010), "too close");
+    assert_eq!(take.slices.len(), 2);
+    take.slices[1].enabled = false;
+    assert!(take.add_cut(30000));
+    assert!(!take.slices[1].enabled, "choice survives a re-cut");
+    assert!(take.remove_cut(29000));
+    assert_eq!(take.cuts, vec![0, 12000, 48000]);
+}
+
+#[test]
+fn render_trims_fades_and_normalises() {
+    let mut x = vec![0.; 4800];
+    x[1000..]
+        .iter_mut()
+        .enumerate()
+        .for_each(|(i, v)| *v = 0.25 * (i as f32 * 0.05).sin().signum());
+    let take = take_of(x, 120., 1);
+    let out = render(&take, &take.slices[0], &Settings::default());
+    let frames = out.len() / 2;
+    // Leading silence gone except a 1 ms pre-roll.
+    assert_eq!(frames, 3800 + 48);
+    assert_eq!(out[0], 0.);
+    assert_eq!(out[out.len() - 1], 0.);
+    let peak = out.iter().fold(0f32, |m, v| m.max(v.abs()));
+    assert!((20. * peak.log10() + 0.3).abs() < 0.01);
+}
+
+#[test]
+fn root_key_is_detected_per_slice() {
+    let mut saw = Saw::new(RATE, 43.65);
+    let take = take_of((0..48000).map(|_| saw.sample() * 0.5).collect(), 120., 1);
+    assert_eq!(take.slices[0].root, Some(29));
+    let silent = take_of(vec![0.; 48000], 120., 1);
+    assert_eq!(silent.slices[0].root, None);
+}
+
+#[test]
+fn wavetable_frames_start_on_rising_zero_crossings_and_match() {
+    let mut saw = Saw::new(RATE, 110.);
+    let x: Vec<f32> = (0..192000).map(|_| saw.sample() * 0.5).collect();
+    let table = wavetable(&x, RATE).unwrap();
+    let frames = table.len() / TABLE;
+    assert_eq!(frames, TABLE_FRAMES);
+    for f in table.chunks(TABLE) {
+        assert!(f[0].abs() < 0.02 && f[1] > f[0], "{} {}", f[0], f[1]);
+        let a = &table[..TABLE];
+        let dot: f32 = a.iter().zip(f).map(|(p, q)| p * q).sum();
+        let na: f32 = a.iter().map(|v| v * v).sum();
+        let nb: f32 = f.iter().map(|v| v * v).sum();
+        assert!(dot / (na * nb).sqrt() > 0.99);
+    }
+    assert!(wavetable(&vec![0.; 48000], RATE).is_none());
+}
+
+#[test]
+fn export_writes_loop_slices_and_wavetable() {
+    let dir = std::env::temp_dir().join(format!("crucible-test-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    let mut saw = Saw::new(RATE, 55.);
+    let mut take = take_of((0..96000).map(|_| saw.sample() * 0.5).collect(), 120., 1);
+    let settings = Settings {
+        division: Division::Quarter,
+        wavetable: true,
+        ..Settings::default()
+    };
+    take.slice(&settings);
+    take.slices[3].enabled = false;
+    let done = export(&take, &settings, Some(0), &dir, 1_700_000_000).unwrap();
+    assert_eq!(done.files, 1 + 3 + 1);
+    assert!(done.folder.ends_with("2023-11-14_221320_120bpm"));
+    let read = |name: &str| wav::decode(&std::fs::read(done.folder.join(name)).unwrap()).unwrap();
+    assert_eq!(read("loop.wav").samples.len(), 192000);
+    assert_eq!(read("s01_A1.wav").root, Some(33));
+    assert_eq!(read("wavetable.wav").frame, Some(2048));
+    assert!(!done.folder.join("s04_A1.wav").exists());
+    std::fs::remove_dir_all(&dir).unwrap();
+}
+
+#[test]
+fn audition_plays_and_returns_clips_for_freeing() {
+    let q = Queues::default();
+    let mut p = Player::default();
+    q.play(std::sync::Arc::from(vec![0.5f32, -0.5, 0.25, -0.25]));
+    p.block(&q);
+    assert_eq!(p.next(&q), [0.5, -0.5]);
+    assert_eq!(p.next(&q), [0.25, -0.25]);
+    assert_eq!(p.next(&q), [0., 0.]);
+    assert!(!p.playing());
+    q.drain();
+}
+
+#[test]
+fn settings_survive_json_and_are_sanitised() {
+    let mut s: Settings =
+        serde_json::from_str(r#"{"bars":3,"declick":99,"sensitivity":-5}"#).unwrap();
+    s.sanitize();
+    assert_eq!((s.bars, s.declick, s.sensitivity), (4, 20., 0.));
+    let json = serde_json::to_string(&Settings::default()).unwrap();
+    assert_eq!(
+        serde_json::from_str::<Settings>(&json).unwrap(),
+        Settings::default()
+    );
+}
@@ -0,0 +1,68 @@
+use crucible_core::{Player, Queues, Recorder, Ring, Transport};
+use std::sync::Arc;
+use std::{
+    alloc::{GlobalAlloc, Layout, System},
+    cell::Cell,
+};
+
+struct CheckedAllocator;
+thread_local! {
+    static CHECK:Cell<bool>=const {Cell::new(false)};
+    static OPERATIONS:Cell<usize>=const {Cell::new(0)};
+}
+fn record() {
+    if CHECK.try_with(Cell::get).unwrap_or(false) {
+        let _ = OPERATIONS.try_with(|n| n.set(n.get() + 1));
+    }
+}
+unsafe impl GlobalAlloc for CheckedAllocator {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        record();
+        unsafe { System.alloc(layout) }
+    }
+    unsafe fn dealloc(&self, pointer: *mut u8, layout: Layout) {
+        record();
+        unsafe { System.dealloc(pointer, layout) }
+    }
+    unsafe fn realloc(&self, pointer: *mut u8, layout: Layout, size: usize) -> *mut u8 {
+        record();
+        unsafe { System.realloc(pointer, layout, size) }
+    }
+}
+#[global_allocator]
+static ALLOCATOR: CheckedAllocator = CheckedAllocator;
+
+#[test]
+fn recording_transport_and_audition_do_not_allocate_or_free() {
+    let ring = Ring::new(48000., 4.);
+    let queues = Queues::default();
+    let mut recorder = Recorder::new();
+    let mut player = Player::default();
+    let clips: Vec<Arc<[f32]>> = (0..4).map(|i| Arc::from(vec![0.1; 2000 + i])).collect();
+    CHECK.with(|v| v.set(true));
+    for block in 0..2000u32 {
+        if block % 300 == 0 {
+            // Sending only moves the Arc; freeing happens on drain, outside the check.
+            queues.play(clips[(block / 300) as usize % 4].clone());
+        }
+        recorder.block(
+            &ring,
+            Some(Transport {
+                playing: block % 700 < 600,
+                tempo: if block < 1000 { 140. } else { 150. },
+                beats: block as f64 * 0.1,
+                numerator: 4,
+                denominator: 4,
+            }),
+        );
+        player.block(&queues);
+        for i in 0..256 {
+            let a = player.next(&queues);
+            recorder.push(&ring, [i as f32 * 1e-3 + a[0], a[1]]);
+        }
+        recorder.publish(&ring);
+    }
+    CHECK.with(|v| v.set(false));
+    assert_eq!(OPERATIONS.with(Cell::get), 0);
+    queues.drain();
+}
@@ -0,0 +1,24 @@
+[package]
+name = "crucible"
+version = "0.2.0"
+edition = "2021"
+license = "ISC"
+
+[workspace]
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+nih_plug = { git = "https://github.com/robbert-vdh/nih-plug.git", rev = "de421011f41a6d10fc8c7a6084e4f4dee0143683", default-features = false }
+nih_plug_egui = { git = "https://github.com/robbert-vdh/nih-plug.git", rev = "de421011f41a6d10fc8c7a6084e4f4dee0143683" }
+crucible-core = { path = "../core" }
+crucible-ui = { path = "../ui" }
+
+[dev-dependencies]
+clap-sys = { git = "https://github.com/micahrj/clap-sys.git", rev = "25d7f53fdb6363ad63fbd80049cb7a42a97ac156" }
+serde_json = "1"
+
+[profile.release]
+lto = "thin"
+strip = "symbols"
@@ -0,0 +1,200 @@
+//! CLAP audio effect. Audio passes through unchanged; the input is recorded continuously.
+use crucible_core::{Player, Queues, Recorder, Ring, Settings, Transport, HISTORY};
+use nih_plug::prelude::*;
+use nih_plug_egui::{create_egui_editor, egui, EguiState};
+use std::sync::{Arc, Mutex, RwLock};
+
+#[derive(Params)]
+pub struct CrucibleParams {
+    #[persist = "editor"]
+    pub editor: Arc<EguiState>,
+    #[persist = "crucible-settings"]
+    pub settings: RwLock<Settings>,
+    #[id = "bypass"]
+    pub bypass: BoolParam,
+}
+impl Default for CrucibleParams {
+    fn default() -> Self {
+        Self {
+            editor: EguiState::from_size(crucible_ui::WIDTH, crucible_ui::HEIGHT),
+            settings: RwLock::new(Settings::default()),
+            bypass: BoolParam::new("Bypass", false).make_bypass(),
+        }
+    }
+}
+
+struct Shared {
+    /// Replaced on activation; the editor clones the Arc briefly, never the audio thread.
+    ring: Mutex<Option<Arc<Ring>>>,
+    queues: Arc<Queues>,
+}
+pub struct Crucible {
+    params: Arc<CrucibleParams>,
+    shared: Arc<Shared>,
+    ring: Option<Arc<Ring>>,
+    recorder: Recorder,
+    player: Player,
+}
+impl Default for Crucible {
+    fn default() -> Self {
+        Self {
+            params: Arc::new(CrucibleParams::default()),
+            shared: Arc::new(Shared {
+                ring: Mutex::new(None),
+                queues: Arc::new(Queues::default()),
+            }),
+            ring: None,
+            recorder: Recorder::new(),
+            player: Player::default(),
+        }
+    }
+}
+impl Plugin for Crucible {
+    const NAME: &'static str = "Crucible";
+    const VENDOR: &'static str = "Bass Foundry";
+    const URL: &'static str = "";
+    const EMAIL: &'static str = "";
+    const VERSION: &'static str = env!("CARGO_PKG_VERSION");
+    const AUDIO_IO_LAYOUTS: &'static [AudioIOLayout] = &[
+        AudioIOLayout {
+            main_input_channels: NonZeroU32::new(2),
+            main_output_channels: NonZeroU32::new(2),
+            ..AudioIOLayout::const_default()
+        },
+        AudioIOLayout {
+            main_input_channels: NonZeroU32::new(1),
+            main_output_channels: NonZeroU32::new(1),
+            ..AudioIOLayout::const_default()
+        },
+    ];
+    const SAMPLE_ACCURATE_AUTOMATION: bool = false;
+    type SysExMessage = ();
+    type BackgroundTask = ();
+    fn params(&self) -> Arc<dyn Params> {
+        self.params.clone()
+    }
+    fn editor(&mut self, _: AsyncExecutor<Self>) -> Option<Box<dyn Editor>> {
+        let params = self.params.clone();
+        let shared = self.shared.clone();
+        create_egui_editor(
+            params.editor.clone(),
+            crucible_ui::State::default(),
+            |ctx, _| crucible_ui::style(ctx),
+            move |ctx, _setter, state| {
+                let link = crucible_ui::Link {
+                    ring: shared.ring.lock().ok().and_then(|r| r.clone()),
+                    queues: shared.queues.clone(),
+                };
+                let mut settings = params
+                    .settings
+                    .read()
+                    .map(|s| s.clone())
+                    .unwrap_or_default();
+                let before = settings.clone();
+                nih_plug_egui::resizable_window::ResizableWindow::new("crucible-editor")
+                    .min_size(egui::vec2(
+                        crucible_ui::WIDTH as f32 - 80.,
+                        crucible_ui::HEIGHT as f32 - 40.,
+                    ))
+                    .show(ctx, &params.editor, |ui| {
+                        crucible_ui::show(ui, &mut settings, state, &link)
+                    });
+                if settings != before {
+                    if let Ok(mut s) = params.settings.write() {
+                        *s = settings;
+                    }
+                }
+                // Meters and the transport readout follow the audio.
+                ctx.request_repaint_after(std::time::Duration::from_millis(50));
+            },
+        )
+    }
+    fn initialize(
+        &mut self,
+        _: &AudioIOLayout,
+        config: &BufferConfig,
+        _: &mut impl InitContext<Self>,
+    ) -> bool {
+        if let Ok(mut s) = self.params.settings.write() {
+            s.sanitize();
+        }
+        let ring = Arc::new(Ring::new(config.sample_rate, HISTORY));
+        self.ring = Some(ring.clone());
+        self.recorder = Recorder::new();
+        self.player = Player::default();
+        if let Ok(mut slot) = self.shared.ring.lock() {
+            *slot = Some(ring);
+        }
+        true
+    }
+    fn reset(&mut self) {
+        self.player = Player::default();
+    }
+    fn process(
+        &mut self,
+        buffer: &mut Buffer,
+        _: &mut AuxiliaryBuffers,
+        context: &mut impl ProcessContext<Self>,
+    ) -> ProcessStatus {
+        let Some(ring) = self.ring.as_deref() else {
+            return ProcessStatus::Normal;
+        };
+        let bypass = self.params.bypass.value();
+        let t = context.transport();
+        let transport = match (t.tempo, t.pos_beats()) {
+            (Some(tempo), Some(beats)) => Some(Transport {
+                playing: t.playing,
+                tempo,
+                beats,
+                numerator: t.time_sig_numerator.unwrap_or(4).clamp(1, 64) as u32,
+                denominator: t.time_sig_denominator.unwrap_or(4).clamp(1, 64) as u32,
+            }),
+            _ => None,
+        };
+        if !bypass {
+            self.recorder.block(ring, transport);
+        }
+        self.player.block(&self.shared.queues);
+        let channels = buffer.channels();
+        for mut sample in buffer.iter_samples() {
+            let left = *sample.get_mut(0).unwrap();
+            let right = if channels > 1 {
+                *sample.get_mut(1).unwrap()
+            } else {
+                left
+            };
+            if bypass {
+                continue;
+            }
+            self.recorder.push(ring, [left, right]);
+            // Auditioned slices are added to the output, never recorded.
+            let a = self.player.next(&self.shared.queues);
+            if self.player.playing() || a != [0.; 2] {
+                *sample.get_mut(0).unwrap() += if channels > 1 {
+                    a[0]
+                } else {
+                    0.5 * (a[0] + a[1])
+                };
+                if channels > 1 {
+                    *sample.get_mut(1).unwrap() += a[1];
+                }
+            }
+        }
+        self.recorder.publish(ring);
+        ProcessStatus::Normal
+    }
+}
+impl ClapPlugin for Crucible {
+    const CLAP_ID: &'static str = "io.narl.bass-foundry.crucible";
+    const CLAP_DESCRIPTION: Option<&'static str> =
+        Some("Capture the last bars, slice them and export clean, key-labelled samples");
+    const CLAP_MANUAL_URL: Option<&'static str> = None;
+    const CLAP_SUPPORT_URL: Option<&'static str> = None;
+    const CLAP_FEATURES: &'static [ClapFeature] = &[
+        ClapFeature::AudioEffect,
+        ClapFeature::Utility,
+        ClapFeature::Stereo,
+        ClapFeature::Mono,
+    ];
+}
+nih_export_clap!(Crucible);
@@ -0,0 +1,208 @@
+//! Exercise the actual exported CLAP ABI without requiring a GUI or installed DAW.
+use clap_sys::{
+    audio_buffer::*,
+    events::*,
+    ext::{audio_ports::*, latency::*, state::*},
+    factory::plugin_factory::*,
+    host::*,
+    process::*,
+    stream::*,
+    version::*,
+};
+use std::{
+    ffi::{c_char, c_void, CStr},
+    io::{Cursor, Read},
+    ptr,
+};
+
+unsafe extern "C" fn extension(_: *const clap_host, _: *const c_char) -> *const c_void {
+    ptr::null()
+}
+unsafe extern "C" fn request(_: *const clap_host) {}
+unsafe extern "C" fn count(_: *const clap_input_events) -> u32 {
+    0
+}
+unsafe extern "C" fn event(_: *const clap_input_events, _: u32) -> *const clap_event_header {
+    ptr::null()
+}
+unsafe extern "C" fn push(_: *const clap_output_events, _: *const clap_event_header) -> bool {
+    true
+}
+unsafe extern "C" fn write(stream: *const clap_ostream, buffer: *const c_void, size: u64) -> i64 {
+    // SAFETY: The test owns the Vec for the entire synchronous save call.
+    let bytes = unsafe { &mut *((*stream).ctx as *mut Vec<u8>) };
+    bytes.extend_from_slice(unsafe {
+        std::slice::from_raw_parts(buffer as *const u8, size as usize)
+    });
+    size as i64
+}
+unsafe extern "C" fn read(stream: *const clap_istream, buffer: *mut c_void, size: u64) -> i64 {
+    // SAFETY: The test owns the Cursor; the wrapper supplies writable stream storage.
+    let cursor = unsafe { &mut *((*stream).ctx as *mut Cursor<Vec<u8>>) };
+    cursor
+        .read(unsafe { std::slice::from_raw_parts_mut(buffer as *mut u8, size as usize) })
+        .unwrap() as i64
+}
+
+#[test]
+fn effect_ports_state_latency_and_audio_lifecycle() {
+    // SAFETY: All callbacks, strings, streams, buffers, and the host outlive their
+    // synchronous ABI calls. Activation/processing/destruction follow CLAP order.
+    unsafe {
+        let entry = &crucible::clap_entry;
+        assert!(entry.init.unwrap()(c"crucible.clap".as_ptr()));
+        let factory = entry.get_factory.unwrap()(CLAP_PLUGIN_FACTORY_ID.as_ptr())
+            as *const clap_plugin_factory;
+        assert!(!factory.is_null());
+        let factory = &*factory;
+        assert_eq!(factory.get_plugin_count.unwrap()(factory), 1);
+        let descriptor = factory.get_plugin_descriptor.unwrap()(factory, 0);
+        assert!(!descriptor.is_null());
+        assert_eq!(CStr::from_ptr((*descriptor).name), c"Crucible");
+        assert_eq!(
+            CStr::from_ptr((*descriptor).id),
+            c"io.narl.bass-foundry.crucible"
+        );
+        assert!(factory.get_plugin_descriptor.unwrap()(factory, 1).is_null());
+        let host = clap_host {
+            clap_version: CLAP_VERSION,
+            host_data: ptr::null_mut(),
+            name: c"Storyboard test host".as_ptr(),
+            vendor: c"Tests".as_ptr(),
+            url: c"".as_ptr(),
+            version: c"1.0".as_ptr(),
+            get_extension: Some(extension),
+            request_restart: Some(request),
+            request_process: Some(request),
+            request_callback: Some(request),
+        };
+        let plugin = factory.create_plugin.unwrap()(factory, &host, (*descriptor).id);
+        assert!(!plugin.is_null());
+        let p = &*plugin;
+        assert!(p.init.unwrap()(plugin));
+        let ports = p.get_extension.unwrap()(plugin, CLAP_EXT_AUDIO_PORTS.as_ptr())
+            as *const clap_plugin_audio_ports;
+        assert!(!ports.is_null());
+        assert_eq!((*ports).count.unwrap()(plugin, false), 1);
+        assert_eq!((*ports).count.unwrap()(plugin, true), 1);
+        let latency = p.get_extension.unwrap()(plugin, CLAP_EXT_LATENCY.as_ptr())
+            as *const clap_plugin_latency;
+        assert!(!latency.is_null());
+        let state =
+            p.get_extension.unwrap()(plugin, CLAP_EXT_STATE.as_ptr()) as *const clap_plugin_state;
+        assert!(!state.is_null());
+        let state = &*state;
+        let save = || {
+            let mut bytes = Vec::new();
+            let stream = clap_ostream {
+                ctx: &mut bytes as *mut Vec<u8> as *mut c_void,
+                write: Some(write),
+            };
+            assert!(state.save.unwrap()(plugin, &stream));
+            bytes
+        };
+        let mut envelope: nih_plug::prelude::PluginState =
+            serde_json::from_slice(&save()[8..]).unwrap();
+        use nih_plug::wrapper::state::ParamValue;
+        assert!(envelope.fields.contains_key("crucible-settings"));
+        envelope
+            .params
+            .insert("bypass".into(), ParamValue::Bool(false));
+        let settings = crucible_core::Settings {
+            bars: 8,
+            declick: 5.,
+            wavetable: true,
+            folder: "D:/Samples/Crucible".into(),
+            ..Default::default()
+        };
+        envelope.fields.insert(
+            "crucible-settings".into(),
+            serde_json::to_string(&settings).unwrap(),
+        );
+        let encoded = serde_json::to_vec(&envelope).unwrap();
+        let mut framed = (encoded.len() as u64).to_le_bytes().to_vec();
+        framed.extend_from_slice(&encoded);
+        let mut bytes = Cursor::new(framed);
+        let stream = clap_istream {
+            ctx: &mut bytes as *mut Cursor<Vec<u8>> as *mut c_void,
+            read: Some(read),
+        };
+        assert!(state.load.unwrap()(plugin, &stream));
+        let restored: nih_plug::prelude::PluginState =
+            serde_json::from_slice(&save()[8..]).unwrap();
+        assert_eq!(
+            serde_json::to_value(&restored.params).unwrap(),
+            serde_json::to_value(&envelope.params).unwrap()
+        );
+        let restored_settings: crucible_core::Settings =
+            serde_json::from_str(&restored.fields["crucible-settings"]).unwrap();
+        assert_eq!(restored_settings, settings);
+        for rate in [44100., 48000., 96000.] {
+            assert!(p.activate.unwrap()(plugin, rate, 1, 512));
+            let delay = (*latency).get.unwrap()(plugin) as usize;
+            assert_eq!(delay, 0);
+            assert!(p.start_processing.unwrap()(plugin));
+            let mut position = 0;
+            while position < delay + 1024 {
+                let frames = [1, 127, 512, 31][position % 4].min(delay + 1024 - position);
+                let mut input_left = [0f32; 512];
+                let mut input_right = [0f32; 512];
+                for i in 0..frames {
+                    let x = if position + i == 0 { 0.5 } else { 0. };
+                    input_left[i] = x;
+                    input_right[i] = -x;
+                }
+                let mut left = [0f32; 512];
+                let mut right = [0f32; 512];
+                let mut in_channels = [input_left.as_mut_ptr(), input_right.as_mut_ptr()];
+                let mut out_channels = [left.as_mut_ptr(), right.as_mut_ptr()];
+                let incoming = clap_audio_buffer {
+                    data32: in_channels.as_mut_ptr(),
+                    data64: ptr::null_mut(),
+                    channel_count: 2,
+                    latency: 0,
+                    constant_mask: 0,
+                };
+                let mut outgoing_audio = clap_audio_buffer {
+                    data32: out_channels.as_mut_ptr(),
+                    data64: ptr::null_mut(),
+                    channel_count: 2,
+                    latency: 0,
+                    constant_mask: 0,
+                };
+                let input = clap_input_events {
+                    ctx: ptr::null_mut(),
+                    size: Some(count),
+                    get: Some(event),
+                };
+                let outgoing = clap_output_events {
+                    ctx: ptr::null_mut(),
+                    try_push: Some(push),
+                };
+                let process = clap_process {
+                    steady_time: position as i64,
+                    frames_count: frames as u32,
+                    transport: ptr::null(),
+                    audio_inputs: &incoming,
+                    audio_outputs: &mut outgoing_audio,
+                    audio_inputs_count: 1,
+                    audio_outputs_count: 1,
+                    in_events: &input,
+                    out_events: &outgoing,
+                };
+                assert_ne!(p.process.unwrap()(plugin, &process), CLAP_PROCESS_ERROR);
+                for i in 0..frames {
+                    // Audio passes through untouched.
+                    let expected = if position + i == 0 { 0.5 } else { 0. };
+                    assert!((left[i] - expected).abs() < 1e-6);
+                    assert!((right[i] + expected).abs() < 1e-6);
+                }
+                position += frames;
+            }
+            p.stop_processing.unwrap()(plugin);
+            p.deactivate.unwrap()(plugin);
+        }
+        p.destroy.unwrap()(plugin);
+        entry.deinit.unwrap()();
+    }
+}
@@ -0,0 +1,11 @@
+[package]
+name = "crucible-ui"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+egui = "0.31.1"
+crucible-core = { path = "../core" }
+common-ui = { path = "../../common/ui" }
+common-dsp = { path = "../../common/dsp" }
@@ -0,0 +1,567 @@
+//! Crucible editor, shared by the CLAP wrapper and the headless renderer.
+use common_ui::*;
+use crucible_core::{
+    capture, export, render, Division, Exported, Mode, Queues, Ring, Settings, Take, Transport,
+    OVERVIEW,
+};
+use egui::{self, Color32, FontId, Pos2, Rect, RichText, Sense, Stroke, Vec2};
+use std::sync::{Arc, Mutex};
+
+pub use common_ui::style;
+pub const WIDTH: u32 = 1040;
+pub const HEIGHT: u32 = 680;
+const MAX_TAKES: usize = 8;
+const DEFAULT_HELP: &str =
+    "Play your bass, press Capture, then drag the exported files from FL's browser.";
+
+/// Connection to the audio thread.
+pub struct Link {
+    pub ring: Option<Arc<Ring>>,
+    pub queues: Arc<Queues>,
+}
+
+pub struct State {
+    pub takes: Vec<Take>,
+    pub take: Option<usize>,
+    pub slice: Option<usize>,
+    pub status: String,
+    pub help: String,
+    pub peak: f32,
+    pub transport: Option<Transport>,
+    pub folder: String,
+    counter: usize,
+    names: Vec<String>,
+    /// Filled by the export thread when it finishes.
+    job: Option<Arc<Mutex<Option<std::io::Result<Exported>>>>>,
+    last_export: Option<std::path::PathBuf>,
+}
+impl Default for State {
+    fn default() -> Self {
+        Self {
+            takes: Vec::new(),
+            take: None,
+            slice: None,
+            status: String::new(),
+            help: DEFAULT_HELP.into(),
+            peak: 0.,
+            transport: None,
+            folder: String::new(),
+            counter: 0,
+            names: Vec::new(),
+            job: None,
+            last_export: None,
+        }
+    }
+}
+impl State {
+    /// Adds a take (newest first) and slices it with the current settings.
+    pub fn add(&mut self, mut take: Take, settings: &Settings) {
+        take.slice(settings);
+        self.counter += 1;
+        self.names.insert(
+            0,
+            format!(
+                "Take {} · {} bar{} · {:.0} BPM",
+                self.counter,
+                take.bars,
+                if take.bars == 1 { "" } else { "s" },
+                take.tempo()
+            ),
+        );
+        self.takes.insert(0, take);
+        self.takes.truncate(MAX_TAKES);
+        self.names.truncate(MAX_TAKES);
+        self.take = Some(0);
+        self.slice = None;
+    }
+    fn current(&mut self) -> Option<&mut Take> {
+        self.take.and_then(|i| self.takes.get_mut(i))
+    }
+}
+
+fn hint(r: &egui::Response, state: &mut State, text: &str) {
+    if r.hovered() {
+        state.help = text.into();
+    }
+}
+fn chip(ui: &mut egui::Ui, on: bool, label: &str) -> egui::Response {
+    ui.selectable_label(on, RichText::new(label).size(13.))
+}
+fn unix_now() -> u64 {
+    std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map_or(0, |d| d.as_secs())
+}
+fn open_folder(path: &std::path::Path) {
+    let program = if cfg!(windows) {
+        "explorer"
+    } else {
+        "xdg-open"
+    };
+    let _ = std::process::Command::new(program).arg(path).spawn();
+}
+
+fn audition(link: &Link, take: &Take, index: usize, settings: &Settings) {
+    if let Some(slice) = take.slices.get(index) {
+        link.queues.play(Arc::from(render(take, slice, settings)));
+    }
+}
+
+pub fn show(ui: &mut egui::Ui, settings: &mut Settings, state: &mut State, link: &Link) {
+    backdrop(ui);
+    link.queues.drain();
+    state.help = DEFAULT_HELP.into();
+    if let Some(ring) = &link.ring {
+        let p = ring.take_peak();
+        state.peak = p.max(state.peak * 0.9);
+        if let Some(m) = ring.markers().last() {
+            state.transport = Some(m.transport);
+        }
+    }
+    let finished = state
+        .job
+        .as_ref()
+        .and_then(|job| job.lock().ok().and_then(|mut slot| slot.take()));
+    if let Some(result) = finished {
+        state.job = None;
+        state.status = match result {
+            Ok(done) => {
+                let mut s = format!("Exported {} files to {}", done.files, done.folder.display());
+                if let Some(why) = done.wavetable_skipped {
+                    s += &format!(" (no wavetable: {why})");
+                }
+                state.last_export = Some(done.folder);
+                s
+            }
+            Err(e) => format!("Export failed: {e}"),
+        };
+    }
+    ui.add_space(2.);
+    header(ui, "CRUCIBLE", "RESAMPLER", |ui| {
+        let db = 20. * state.peak.max(1e-6).log10();
+        ui.label(
+            RichText::new(if db < -90. {
+                "—".into()
+            } else {
+                format!("{db:.1} dB")
+            })
+            .monospace()
+            .size(12.)
+            .color(if db > -0.1 { ACCENT } else { MUTED }),
+        );
+        caption(ui, "INPUT");
+    });
+    ui.add_space(6.);
+    panel(ui, |ui| {
+        ui.set_width(ui.available_width());
+        ui.horizontal(|ui| capture_row(ui, settings, state, link));
+    });
+    ui.add_space(6.);
+    let body = 300.;
+    ui.horizontal_top(|ui| {
+        panel(ui, |ui| {
+            ui.set_width(190.);
+            ui.set_min_height(body);
+            ui.vertical(|ui| takes(ui, state));
+        });
+        ui.add_space(4.);
+        panel(ui, |ui| {
+            ui.set_width(ui.available_width());
+            waveform(ui, settings, state, link, body);
+        });
+    });
+    ui.add_space(6.);
+    panel(ui, |ui| {
+        ui.set_width(ui.available_width());
+        ui.vertical(|ui| controls(ui, settings, state, link));
+    });
+    ui.separator();
+    let line = if state.status.is_empty() || state.help != DEFAULT_HELP {
+        state.help.clone()
+    } else {
+        state.status.clone()
+    };
+    ui.label(RichText::new(line).color(MUTED));
+}
+
+fn capture_row(ui: &mut egui::Ui, settings: &mut Settings, state: &mut State, link: &Link) {
+    let button = egui::Button::new(
+        RichText::new("CAPTURE")
+            .font(FontId::new(17., egui::FontFamily::Name("medium".into())))
+            .color(Color32::WHITE),
+    )
+    .fill(Color32::from_rgb(150, 0, 56))
+    .stroke(Stroke::new(1.0_f32, ACCENT))
+    .min_size(Vec2::new(130., 34.));
+    let r = ui.add_enabled(link.ring.is_some(), button);
+    hint(
+        &r,
+        state,
+        "Grab the newest complete bars. While stopped, grabs the newest audio instead.",
+    );
+    if r.clicked() {
+        if let Some(ring) = &link.ring {
+            match capture(ring, settings.bars) {
+                Ok(take) => {
+                    let synced = take.synced;
+                    state.add(take, settings);
+                    state.status = if synced {
+                        format!("Captured {} bars on the bar grid.", settings.bars)
+                    } else {
+                        "Transport stopped: captured the newest audio at the last tempo.".into()
+                    };
+                }
+                Err(e) => state.status = e.into(),
+            }
+        }
+    }
+    ui.add_space(10.);
+    caption(ui, "BARS");
+    for bars in Settings::BARS {
+        if chip(ui, settings.bars == bars, &bars.to_string()).clicked() {
+            settings.bars = bars;
+        }
+    }
+    ui.add_space(10.);
+    ui.separator();
+    let text = match state.transport {
+        Some(t) => format!(
+            "{:.1} BPM · {}/{} · {}",
+            t.tempo,
+            t.numerator,
+            t.denominator,
+            if t.playing { "playing" } else { "stopped" }
+        ),
+        None if link.ring.is_some() => "No host tempo yet · 140 BPM assumed".into(),
+        None => "Audio engine inactive".into(),
+    };
+    ui.label(RichText::new(text).monospace().size(13.).color(STEEL));
+    ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+        if let Some(ring) = &link.ring {
+            ui.label(
+                RichText::new(format!(
+                    "{:.0} s history",
+                    ring.capacity() as f32 / ring.rate()
+                ))
+                .size(12.)
+                .color(MUTED),
+            );
+        }
+    });
+}
+
+fn takes(ui: &mut egui::Ui, state: &mut State) {
+    caption(ui, "TAKES");
+    if state.takes.is_empty() {
+        ui.label(RichText::new("Nothing captured yet.").color(DIM));
+    }
+    let mut pick = None;
+    for (i, name) in state.names.iter().enumerate() {
+        let r = ui.add_sized(
+            Vec2::new(ui.available_width(), 26.),
+            egui::SelectableLabel::new(state.take == Some(i), RichText::new(name).size(13.)),
+        );
+        if r.clicked() {
+            pick = Some(i);
+        }
+    }
+    if let Some(i) = pick {
+        state.take = Some(i);
+        state.slice = None;
+    }
+    if let Some(i) = state.take {
+        ui.add_space(8.);
+        if ui.button(RichText::new("REMOVE TAKE").size(12.)).clicked() {
+            state.takes.remove(i);
+            state.names.remove(i);
+            state.take = (!state.takes.is_empty()).then_some(0);
+            state.slice = None;
+        }
+    }
+}
+
+fn waveform(ui: &mut egui::Ui, settings: &Settings, state: &mut State, link: &Link, height: f32) {
+    let (rect, response) =
+        ui.allocate_exact_size(Vec2::new(ui.available_width(), height), Sense::click());
+    let p = ui.painter_at(rect);
+    p.rect_filled(rect, 2., SCREEN);
+    let Some(ti) = state.take.filter(|i| *i < state.takes.len()) else {
+        p.text(
+            rect.center(),
+            egui::Align2::CENTER_CENTER,
+            "Play the part you want to resample, then press CAPTURE",
+            FontId::proportional(15.),
+            DIM,
+        );
+        return;
+    };
+    let take = &state.takes[ti];
+    let frames = take.frames().max(1) as f32;
+    let label_band = 18.;
+    let wave = Rect::from_min_max(rect.min + Vec2::new(0., label_band), rect.max);
+    let x_of = |frame: usize| wave.left() + wave.width() * frame as f32 / frames;
+    // Slices: tint, disabled dimming, selection.
+    for (i, s) in take.slices.iter().enumerate() {
+        let r = Rect::from_min_max(
+            Pos2::new(x_of(s.start), wave.top()),
+            Pos2::new(x_of(s.end), wave.bottom()),
+        );
+        let fill = if state.slice == Some(i) {
+            Color32::from_rgba_unmultiplied(255, 1, 96, 28)
+        } else if !s.enabled {
+            Color32::from_rgba_unmultiplied(0, 0, 0, 120)
+        } else {
+            Color32::TRANSPARENT
+        };
+        p.rect_filled(r, 0., fill);
+        if r.width() > 26. {
+            let text = s.root.map_or("·".into(), common_dsp::note_name);
+            p.text(
+                Pos2::new(r.center().x, rect.top() + 3.),
+                egui::Align2::CENTER_TOP,
+                text,
+                FontId::proportional(11.),
+                if s.enabled { STEEL } else { DIM },
+            );
+        }
+    }
+    // Bar and beat grid.
+    let quarters = take.quarters();
+    let bar = take.bar_quarters();
+    let mut q = 0.;
+    while q <= quarters + 1e-6 {
+        let x = x_of(take.frame_at(q).round() as usize);
+        let is_bar = ((q / bar).round() * bar - q).abs() < 1e-6;
+        p.line_segment(
+            [Pos2::new(x, wave.top()), Pos2::new(x, wave.bottom())],
+            Stroke::new(
+                1.0_f32,
+                if is_bar {
+                    Color32::from_rgb(60, 64, 72)
+                } else {
+                    Color32::from_rgb(28, 30, 34)
+                },
+            ),
+        );
+        q += 1.;
+    }
+    // Overview waveform.
+    let mid = wave.center().y;
+    let half = wave.height() * 0.46;
+    let peak = take
+        .overview
+        .iter()
+        .fold(0.01f32, |m, v| m.max(v[0].abs()).max(v[1].abs()));
+    let columns = wave.width().max(1.) as usize;
+    for c in 0..columns {
+        let a = c * OVERVIEW / columns;
+        let z = ((c + 1) * OVERVIEW / columns).max(a + 1).min(OVERVIEW);
+        let (mut lo, mut hi) = (0f32, 0f32);
+        for v in &take.overview[a..z] {
+            lo = lo.min(v[0]);
+            hi = hi.max(v[1]);
+        }
+        let x = wave.left() + c as f32 + 0.5;
+        p.line_segment(
+            [
+                Pos2::new(x, mid - hi / peak * half),
+                Pos2::new(x, mid - lo / peak * half + 0.5),
+            ],
+            Stroke::new(1.0_f32, STEEL),
+        );
+    }
+    // Cuts.
+    for c in &take.cuts[1..take.cuts.len().saturating_sub(1)] {
+        let x = x_of(*c);
+        p.line_segment(
+            [Pos2::new(x, rect.top()), Pos2::new(x, rect.bottom())],
+            Stroke::new(1.0_f32, ACCENT),
+        );
+    }
+    p.rect_stroke(
+        rect,
+        2.,
+        Stroke::new(1.0_f32, EDGE),
+        egui::StrokeKind::Inside,
+    );
+    let frame_at =
+        |pos: Pos2| (((pos.x - wave.left()) / wave.width()).clamp(0., 1.) * frames) as usize;
+    if response.hovered() {
+        state.help =
+            "Click a slice to hear it. Double-click to add a cut, right-click to remove the nearest."
+                .into();
+    }
+    let pointer = response.interact_pointer_pos();
+    if response.double_clicked() {
+        if let Some(pos) = pointer {
+            let f = frame_at(pos);
+            if let Some(t) = state.current() {
+                if t.add_cut(f) {
+                    state.slice = state.takes[ti].slice_at(f);
+                }
+            }
+        }
+    } else if response.clicked() {
+        if let Some(pos) = pointer {
+            let f = frame_at(pos);
+            state.slice = state.takes[ti].slice_at(f);
+            if let Some(i) = state.slice {
+                audition(link, &state.takes[ti], i, settings);
+            }
+        }
+    } else if response.secondary_clicked() {
+        if let Some(pos) = pointer {
+            let f = frame_at(pos);
+            if let Some(t) = state.current() {
+                t.remove_cut(f);
+            }
+            state.slice = None;
+        }
+    }
+}
+
+fn controls(ui: &mut egui::Ui, settings: &mut Settings, state: &mut State, link: &Link) {
+    let before = settings.clone();
+    ui.horizontal(|ui| {
+        caption(ui, "SLICE BY");
+        for (mode, label) in [(Mode::Grid, "GRID"), (Mode::Transient, "TRANSIENTS")] {
+            if chip(ui, settings.mode == mode, label).clicked() {
+                settings.mode = mode;
+            }
+        }
+        ui.add_space(8.);
+        match settings.mode {
+            Mode::Grid => {
+                for d in Division::ALL {
+                    if chip(ui, settings.division == d, d.label()).clicked() {
+                        settings.division = d;
+                    }
+                }
+            }
+            Mode::Transient => {
+                caption(ui, "SENSITIVITY");
+                let r = ui.add(
+                    egui::Slider::new(&mut settings.sensitivity, 0. ..=100.)
+                        .suffix(" %")
+                        .clamping(egui::SliderClamping::Always),
+                );
+                hint(&r, state, "Higher finds quieter hits.");
+            }
+        }
+        ui.separator();
+        caption(ui, "DECLICK");
+        let r = ui.add(
+            egui::Slider::new(&mut settings.declick, 0. ..=20.)
+                .suffix(" ms")
+                .clamping(egui::SliderClamping::Always),
+        );
+        hint(
+            &r,
+            state,
+            "Fade at both ends of every slice, so cuts never click.",
+        );
+    });
+    ui.horizontal(|ui| {
+        let r = chip(ui, settings.trim, "TRIM SILENCE");
+        if r.clicked() {
+            settings.trim = !settings.trim;
+        }
+        hint(&r, state, "Remove silence before the first sound of a slice.");
+        let r = chip(ui, settings.normalize, "NORMALIZE");
+        if r.clicked() {
+            settings.normalize = !settings.normalize;
+        }
+        hint(&r, state, "Peak every slice at −0.3 dBFS.");
+        let r = chip(ui, settings.wavetable, "WAVETABLE");
+        if r.clicked() {
+            settings.wavetable = !settings.wavetable;
+        }
+        hint(
+            &r,
+            state,
+            "Also write wavetable.wav from the selected slice: 2048-sample frames for Serum or Vital.",
+        );
+        ui.separator();
+        let take = state.take;
+        let slice = state.slice;
+        match (take.and_then(|t| state.takes.get_mut(t)), slice) {
+            (Some(t), Some(i)) if i < t.slices.len() => {
+                let s = &mut t.slices[i];
+                let seconds = (s.end - s.start) as f32 / t.rate;
+                ui.label(
+                    RichText::new(format!(
+                        "SLICE {} · {} · {:.2} s",
+                        i + 1,
+                        s.root.map_or("no pitch".into(), common_dsp::note_name),
+                        seconds
+                    ))
+                    .size(13.)
+                    .color(TEXT),
+                );
+                ui.checkbox(&mut s.enabled, "Export");
+                if ui.small_button("▶").clicked() {
+                    audition(link, t, i, settings);
+                }
+            }
+            _ => {
+                ui.label(RichText::new("No slice selected").size(13.).color(DIM));
+            }
+        }
+    });
+    let recut = settings.mode != before.mode
+        || settings.division != before.division
+        || (settings.mode == Mode::Transient && settings.sensitivity != before.sensitivity);
+    if recut {
+        if let Some(t) = state.current() {
+            t.slice(settings);
+        }
+        state.slice = None;
+    }
+    ui.add_space(4.);
+    ui.separator();
+    ui.horizontal(|ui| {
+        caption(ui, "FOLDER");
+        if state.folder.is_empty() {
+            state.folder = settings.folder().display().to_string();
+        }
+        let r = ui.add(egui::TextEdit::singleline(&mut state.folder).desired_width(420.));
+        if r.changed() {
+            settings.folder = state.folder.clone();
+        }
+        hint(
+            &r,
+            state,
+            "Add this folder to FL's browser once; exports then appear there for dragging.",
+        );
+        let can = state.take.is_some() && state.job.is_none();
+        let export_button =
+            egui::Button::new(RichText::new("EXPORT").size(14.).color(Color32::WHITE))
+                .fill(Color32::from_rgb(150, 0, 56))
+                .stroke(Stroke::new(1.0_f32, ACCENT));
+        if ui.add_enabled(can, export_button).clicked() {
+            if let Some(take) = state.take.and_then(|i| state.takes.get(i)).cloned() {
+                let slot = Arc::new(Mutex::new(None));
+                let done = slot.clone();
+                let settings = settings.clone();
+                let selected = state.slice;
+                std::thread::spawn(move || {
+                    let folder = settings.folder();
+                    let result = export(&take, &settings, selected, &folder, unix_now());
+                    if let Ok(mut slot) = done.lock() {
+                        *slot = Some(result);
+                    }
+                });
+                state.job = Some(slot);
+                state.status = "Exporting…".into();
+            }
+        }
+        if ui.button(RichText::new("OPEN FOLDER").size(13.)).clicked() {
+            let path = state
+                .last_export
+                .clone()
+                .unwrap_or_else(|| settings.folder());
+            let _ = std::fs::create_dir_all(&path);
+            open_folder(&path);
+        }
+    });
+}
@@ -0,0 +1,12 @@
+[package]
+name = "knurl-core"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+common-dsp = { path = "../../common/dsp" }
+serde = { workspace = true }
+
+[dev-dependencies]
+serde_json = { workspace = true }
@@ -0,0 +1,406 @@
+//! Knurl: texture per cycle of the played note. A cycle clock follows the tracked pitch and
+//! restarts at every note; each cycle gets its own step gain (a repeating pattern that
+//! makes subharmonics), a random level and timing, and a noise burst tuned to the note.
+//! Every amount is counted in cycles, so the texture has the same grain on every note.
+//!
+//! The audio path is delayed by the tracker lookahead plus the timing-jitter headroom, so
+//! the clock already knows each note when its attack leaves the plugin. Allocation-free
+//! after `new`; mono-safe (both channels get the same treatment).
+mod settings;
+use common_dsp::svf::{Svf, SvfCoef};
+use common_dsp::tracker::{PitchFollower, Tracker, TrackerConfig};
+use common_dsp::{coefficient, db_to_gain, hz_to_midi};
+pub use settings::{Seed, Settings, Source, GRIT_OFF, PATTERNS, STEPS, STEP_MIN};
+
+/// Cycles kept for the editor's scope, and points per cycle.
+pub const SCOPE_CYCLES: usize = 8;
+pub const SCOPE_POINTS: usize = 64;
+/// Timing jitter can move a cycle by at most this share of the lowest period.
+const JITTER_HEADROOM: f32 = 0.125;
+/// Effects fade in and out with the note over this time.
+const FADE_MS: f32 = 20.;
+/// The grit filter is retuned this often, in samples.
+const RETUNE: usize = 16;
+/// Level follower for scaling the grit to the input.
+const LEVEL_MS: f32 = 30.;
+
+#[derive(Clone, Copy, Debug)]
+pub struct AnalyzerFrame {
+    /// Fundamental the clock follows, 0 before the first note.
+    pub hz: f32,
+    /// Sounding note, rounded; None between notes.
+    pub note: Option<u8>,
+    /// Pattern step of the newest cycle.
+    pub step: usize,
+    /// Output of the last `SCOPE_CYCLES` cycles, oldest first, each resampled to
+    /// `SCOPE_POINTS` points.
+    pub scope: [[f32; SCOPE_POINTS]; SCOPE_CYCLES],
+    /// True when the scope holds cycles of a sounding note.
+    pub scope_valid: bool,
+    pub input_db: f32,
+    pub output_db: f32,
+    pub latency: u32,
+    pub sample_rate: f32,
+}
+impl Default for AnalyzerFrame {
+    fn default() -> Self {
+        Self {
+            hz: 0.,
+            note: None,
+            step: 0,
+            scope: [[0.; SCOPE_POINTS]; SCOPE_CYCLES],
+            scope_valid: false,
+            input_db: -120.,
+            output_db: -120.,
+            latency: 0,
+            sample_rate: 48000.,
+        }
+    }
+}
+
+/// Deterministic per-cycle randomness: a hash of (stream, note seed, cycle).
+fn hash(stream: u64, seed: u64, cycle: u64) -> u64 {
+    let mut z = stream
+        .wrapping_mul(0x9E37_79B9_7F4A_7C15)
+        .wrapping_add(seed.wrapping_mul(0xBF58_476D_1CE4_E5B9))
+        .wrapping_add(cycle.wrapping_mul(0x94D0_49BB_1331_11EB));
+    z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
+    z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
+    z ^ (z >> 31)
+}
+fn uniform(stream: u64, seed: u64, cycle: u64) -> f32 {
+    (hash(stream, seed, cycle) >> 40) as f32 / (1u64 << 24) as f32
+}
+/// Approximately normal, clamped to ±3 (sum of four uniforms, unit variance).
+fn normal(stream: u64, seed: u64, cycle: u64) -> f32 {
+    let s: f32 = (0..4).map(|i| uniform(stream, seed, cycle * 4 + i)).sum();
+    ((s - 2.) * 3f32.sqrt()).clamp(-3., 3.)
+}
+/// Raised-cosine weight of the next cycle's value: 0 until `1 − width` of the cycle, then
+/// rising to 1 at the boundary.
+fn edge(frac: f32, width: f32) -> f32 {
+    let t = ((frac - (1. - width)) / width).clamp(0., 1.);
+    0.5 - 0.5 * (std::f32::consts::PI * t).cos()
+}
+
+const LEVEL: u64 = 1;
+const TIME: u64 = 2;
+const NOISE: u64 = 3;
+
+/// What the clock needs, delayed by the jitter headroom so it lines up with the audio.
+#[derive(Clone, Copy, Default)]
+struct Pitch {
+    hz: f32,
+    start: bool,
+    sounding: bool,
+}
+
+pub struct Engine {
+    rate: f32,
+    channels: usize,
+    settings: Settings,
+    /// Tracker lookahead.
+    lookahead: usize,
+    /// Largest timing offset in samples, either way.
+    headroom: usize,
+    tracker: Tracker,
+    pitch: PitchFollower,
+    pitch_line: Vec<Pitch>,
+    pitch_at: usize,
+    audio: Vec<[f32; 2]>,
+    audio_at: usize,
+    // Cycle clock.
+    phase: f64,
+    cycle: u64,
+    note_seed: u64,
+    notes: u64,
+    noise_at: u64,
+    amount: f32,
+    fade: f32,
+    // Grit.
+    grit_coef: SvfCoef,
+    grit_filter: Svf,
+    countdown: usize,
+    level: f32,
+    level_coef: f32,
+    // Smoothed controls.
+    smooth: f32,
+    mix: f32,
+    output: f32,
+    bypass: f32,
+    fresh: bool,
+    // Editor.
+    scope: [[f32; SCOPE_POINTS]; SCOPE_CYCLES],
+    scope_valid: bool,
+    meter_in: f64,
+    meter_out: f64,
+    meter_count: usize,
+}
+
+impl Engine {
+    pub fn new(rate: f32, channels: usize) -> Result<Self, &'static str> {
+        if !(rate.is_finite() && (8000.0..=768000.).contains(&rate)) {
+            return Err("unsupported sample rate");
+        }
+        if !(1..=2).contains(&channels) {
+            return Err("unsupported channel count");
+        }
+        let tracker = Tracker::new(rate, TrackerConfig::BASS);
+        let lookahead = tracker.latency();
+        let headroom = (JITTER_HEADROOM * rate / TrackerConfig::BASS.min_hz).ceil() as usize;
+        let settings = Settings::default();
+        let mut e = Self {
+            rate,
+            channels,
+            settings,
+            lookahead,
+            headroom,
+            tracker,
+            pitch: PitchFollower::default(),
+            pitch_line: vec![Pitch::default(); headroom + 1],
+            pitch_at: 0,
+            // Reads reach `lookahead + 2·headroom` back, plus the interpolation taps.
+            audio: vec![[0.; 2]; lookahead + 2 * headroom + 4],
+            audio_at: 0,
+            phase: 0.,
+            cycle: 0,
+            note_seed: 0,
+            notes: 0,
+            noise_at: 0,
+            amount: 0.,
+            fade: coefficient(rate, FADE_MS),
+            grit_coef: SvfCoef::IDENTITY,
+            grit_filter: Svf::default(),
+            countdown: 0,
+            level: 0.,
+            level_coef: coefficient(rate, LEVEL_MS),
+            smooth: coefficient(rate, 10.),
+            mix: 1.,
+            output: 1.,
+            bypass: 0.,
+            fresh: true,
+            scope: [[0.; SCOPE_POINTS]; SCOPE_CYCLES],
+            scope_valid: false,
+            meter_in: 0.,
+            meter_out: 0.,
+            meter_count: 0,
+        };
+        e.set_settings(settings)?;
+        e.fresh = true;
+        Ok(e)
+    }
+    pub fn latency_samples(&self) -> u32 {
+        (self.lookahead + self.headroom) as u32
+    }
+    pub fn channels(&self) -> usize {
+        self.channels
+    }
+    pub fn settings(&self) -> Settings {
+        self.settings
+    }
+    pub fn set_settings(&mut self, s: Settings) -> Result<(), &'static str> {
+        s.validate()?;
+        self.tracker.set(s.source == Source::Midi, s.gate, false);
+        self.settings = s;
+        if std::mem::take(&mut self.fresh) {
+            self.mix = s.mix * 0.01;
+            self.output = db_to_gain(s.output);
+            self.bypass = f32::from(s.bypass);
+        }
+        Ok(())
+    }
+    pub fn reset(&mut self) {
+        self.audio.fill([0.; 2]);
+        self.pitch_line.fill(Pitch::default());
+        self.pitch = PitchFollower::default();
+        self.tracker.reset();
+        self.grit_filter.reset();
+        self.phase = 0.;
+        self.cycle = 0;
+        self.notes = 0;
+        self.note_seed = 0;
+        self.noise_at = 0;
+        self.amount = 0.;
+        self.level = 0.;
+        self.countdown = 0;
+        self.scope_valid = false;
+        self.fresh = true;
+    }
+    pub fn note_on(&mut self, note: u8) {
+        self.tracker.note_on(note);
+    }
+    pub fn note_off(&mut self, note: u8) {
+        self.tracker.note_off(note);
+    }
+    /// The audio `back` samples (fractional) before the newest one, cubic Hermite.
+    #[inline]
+    fn read(&self, back: f32) -> [f32; 2] {
+        let len = self.audio.len();
+        let whole = back.floor();
+        let t = back - whole;
+        let base = whole as usize;
+        let at = |back: usize| self.audio[(self.audio_at + len - back % len) % len];
+        // y0 is one sample newer than y1; y2 and y3 are older.
+        let (newer, p1, p2, p3) = (at(base.max(1) - 1), at(base), at(base + 1), at(base + 2));
+        let mut out = [0.; 2];
+        for c in 0..2 {
+            let (y0, y1, y2, y3) = (newer[c], p1[c], p2[c], p3[c]);
+            let c1 = 0.5 * (y2 - y0);
+            let c2 = y0 - 2.5 * y1 + 2. * y2 - 0.5 * y3;
+            let c3 = 0.5 * (y3 - y0) + 1.5 * (y1 - y2);
+            out[c] = ((c3 * t + c2) * t + c1) * t + y1;
+        }
+        out
+    }
+    pub fn process_sample(&mut self, x: [f32; 2]) -> [f32; 2] {
+        let mono = if self.channels == 2 {
+            0.5 * (x[0] + x[1])
+        } else {
+            x[0]
+        };
+        let (pitch, snap) = (&mut self.pitch, self.settings.snap);
+        self.tracker.process(mono, |e| pitch.event(snap, e));
+        let (hz, jump) = self.pitch.step(1.);
+        // Tracker events are timed for `lookahead`; the audio leaves `headroom` later.
+        let len = self.pitch_line.len();
+        self.pitch_line[self.pitch_at] = Pitch {
+            hz,
+            start: jump,
+            sounding: self.tracker.sounding(),
+        };
+        self.pitch_at = (self.pitch_at + 1) % len;
+        let p = self.pitch_line[self.pitch_at];
+
+        let len = self.audio.len();
+        self.audio_at = (self.audio_at + 1) % len;
+        self.audio[self.audio_at] = x;
+        let centre = (self.lookahead + self.headroom) as f32;
+        let dry = self.read(centre);
+
+        // Cycle clock.
+        if p.start {
+            self.phase = 0.;
+            self.cycle = 0;
+            self.notes += 1;
+            self.noise_at = 0;
+            self.note_seed = match self.settings.seed {
+                Seed::Same => 0,
+                Seed::Free => self.notes,
+            };
+            self.countdown = 0;
+        }
+        let active = p.sounding && p.hz > 0.;
+        self.amount += (f32::from(active) - self.amount) * self.fade;
+        let s = self.settings;
+        let frac = self.phase.fract() as f32;
+        let c = self.cycle;
+        let seed = self.note_seed;
+        let step = |k: u64| (k % s.steps as u64) as usize;
+
+        // Pattern and level jitter, crossfaded into the next cycle.
+        let w = edge(frac, s.edge * 0.01);
+        let jitter_w = edge(frac, 0.5);
+        let pattern = |k: u64| db_to_gain(s.pattern[step(k)]);
+        let wobble = |k: u64| db_to_gain(s.level_jitter * normal(LEVEL, seed, k));
+        let gain = (pattern(c) * (1. - w) + pattern(c + 1) * w)
+            * (wobble(c) * (1. - jitter_w) + wobble(c + 1) * jitter_w);
+        let gain = 1. + self.amount * (gain - 1.);
+
+        // Timing jitter: an offset per cycle, blended across the whole cycle.
+        let period = if p.hz > 0. { self.rate / p.hz } else { 0. };
+        let shift = |k: u64| normal(TIME, seed, k) * s.time_jitter * 0.01 * period;
+        let tw = edge(frac, 1.);
+        let offset = (shift(c) * (1. - tw) + shift(c + 1) * tw) * self.amount;
+        let offset = offset.clamp(-(self.headroom as f32), self.headroom as f32);
+        let moved = if offset == 0. {
+            dry
+        } else {
+            self.read(centre + offset)
+        };
+
+        // Grit: noise above `tone` harmonics, in a sin² window at `position` of each cycle.
+        let mut grit = 0.;
+        if s.grit > GRIT_OFF && p.hz > 0. && s.grit_steps[step(c)] {
+            if self.countdown == 0 {
+                let f = (s.tone * p.hz).min(0.45 * self.rate);
+                self.grit_coef = SvfCoef::highpass(self.rate, f, std::f32::consts::FRAC_1_SQRT_2);
+                self.countdown = RETUNE;
+            }
+            self.countdown -= 1;
+            self.noise_at = self.noise_at.wrapping_add(1);
+            let n = 2. * uniform(NOISE, seed, self.noise_at) - 1.;
+            let hp = self.grit_filter.process(&self.grit_coef, n * 3f32.sqrt());
+            let d = (frac - s.position * 0.01).rem_euclid(1.);
+            let l = s.length * 0.01;
+            if d < l {
+                let window = (std::f32::consts::PI * d / l).sin().powi(2);
+                grit = hp * window * self.level.sqrt() * db_to_gain(s.grit) * self.amount;
+            }
+        }
+        let m = if self.channels == 2 {
+            0.5 * (dry[0] + dry[1])
+        } else {
+            dry[0]
+        };
+        self.level += (m * m - self.level) * self.level_coef;
+        // Advance the clock.
+        if p.hz > 0. {
+            self.phase += (p.hz / self.rate) as f64;
+            let whole = self.phase.floor() as u64;
+            if whole > 0 {
+                self.phase -= whole as f64;
+                self.cycle += whole;
+                self.scope
+                    .rotate_left(whole.min(SCOPE_CYCLES as u64) as usize);
+                self.scope[SCOPE_CYCLES - 1] = [0.; SCOPE_POINTS];
+            }
+        }
+
+        self.mix += (s.mix * 0.01 - self.mix) * self.smooth;
+        self.output += (db_to_gain(s.output) - self.output) * self.smooth;
+        self.bypass += (f32::from(s.bypass) - self.bypass) * self.smooth;
+        let mut out = [0.; 2];
+        for ch in 0..self.channels {
+            let wet = moved[ch] * gain + grit;
+            let mixed = (self.mix * wet + (1. - self.mix) * dry[ch]) * self.output;
+            out[ch] = mixed * (1. - self.bypass) + dry[ch] * self.bypass;
+        }
+        let o = if self.channels == 2 {
+            0.5 * (out[0] + out[1])
+        } else {
+            out[0]
+        };
+        if active {
+            let i = ((frac * SCOPE_POINTS as f32) as usize).min(SCOPE_POINTS - 1);
+            self.scope[SCOPE_CYCLES - 1][i] = o;
+            self.scope_valid = true;
+        }
+        self.meter_in += (m * m) as f64;
+        self.meter_out += (o * o) as f64;
+        self.meter_count += 1;
+        out
+    }
+    /// Editor data; levels are averaged since the previous call.
+    pub fn take_analyzer(&mut self) -> AnalyzerFrame {
+        let n = self.meter_count.max(1) as f64;
+        let db = |p: f64| (10. * (p / n).max(1e-12).log10()).max(-120.) as f32;
+        let mut f = AnalyzerFrame {
+            hz: self.pitch.hz(),
+            note: None,
+            step: (self.cycle % self.settings.steps as u64) as usize,
+            scope: self.scope,
+            scope_valid: self.scope_valid,
+            input_db: db(self.meter_in),
+            output_db: db(self.meter_out),
+            latency: self.latency_samples(),
+            sample_rate: self.rate,
+        };
+        if self.tracker.sounding() && f.hz > 0. {
+            f.note = Some(hz_to_midi(f.hz).round().clamp(0., 127.) as u8);
+        }
+        self.meter_in = 0.;
+        self.meter_out = 0.;
+        self.meter_count = 0;
+        f
+    }
+}
@@ -0,0 +1,166 @@
+//! Host-independent controls. Gains in dB; amounts relative to one cycle in percent.
+use serde::{Deserialize, Serialize};
+
+/// Pattern steps: one per cycle, repeating.
+pub const STEPS: usize = 16;
+pub const STEP_MIN: f32 = -24.;
+/// Grit at or below this level is off.
+pub const GRIT_OFF: f32 = -60.;
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
+pub enum Source {
+    /// Pitch and note starts are detected from the incoming bass.
+    #[default]
+    Audio,
+    /// Notes come from MIDI note input.
+    Midi,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
+pub enum Seed {
+    /// Every note gets the same random sequence, so identical notes sound identical.
+    #[default]
+    Same,
+    /// The random sequences keep running from note to note.
+    Free,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+pub struct Settings {
+    pub source: Source,
+    /// Gain per pattern step, 0 down to `STEP_MIN`.
+    pub pattern: [f32; STEPS],
+    /// Steps that get a grit burst.
+    pub grit_steps: [bool; STEPS],
+    /// Pattern length in cycles, 1..=STEPS.
+    pub steps: usize,
+    /// Crossfade into the next step, as a share of a cycle.
+    pub edge: f32,
+    /// Random level per cycle, standard deviation in dB.
+    pub level_jitter: f32,
+    /// Random timing per cycle, standard deviation in percent of a period.
+    pub time_jitter: f32,
+    /// Grit burst level relative to the input, dB; `GRIT_OFF` or lower is off.
+    pub grit: f32,
+    /// Grit highpass, in harmonics of the note.
+    pub tone: f32,
+    /// Where in the cycle the grit burst sits, percent.
+    pub position: f32,
+    /// Grit burst length, percent of a cycle.
+    pub length: f32,
+    pub seed: Seed,
+    /// Detection threshold in dBFS for note starts (Audio source).
+    pub gate: f32,
+    /// Round detected pitch to the nearest semitone.
+    pub snap: bool,
+    pub mix: f32,
+    pub output: f32,
+    pub bypass: bool,
+}
+
+/// Named step patterns: (name, help, gains). Missing steps are 0 dB.
+pub const PATTERNS: [(&str, &str, &[f32]); 6] = [
+    ("Off", "Every cycle at full level.", &[0.]),
+    (
+        "Double",
+        "Every second cycle quieter: a sub-octave growl.",
+        &[0., -9.],
+    ),
+    (
+        "Triple",
+        "One loud cycle, two quiet: a growl an octave and a fifth down.",
+        &[0., -12., -12.],
+    ),
+    (
+        "Fry",
+        "Uneven four-cycle pattern: vocal-fry rattle.",
+        &[0., -14., -5., -14.],
+    ),
+    (
+        "Gallop",
+        "Loud, quiet, loud, then three quiet: a rolling gallop.",
+        &[0., -18., 0., -18., -18., -18.],
+    ),
+    (
+        "Stutter",
+        "Bursts of cycles with gaps: a gated stutter.",
+        &[0., 0., -24., -24., 0., -24., -24., -24.],
+    ),
+];
+
+impl Settings {
+    /// Applies a named pattern: its gains, its length, grit on every step.
+    pub fn apply_pattern(&mut self, gains: &[f32]) {
+        self.pattern = [0.; STEPS];
+        for (p, g) in self.pattern.iter_mut().zip(gains) {
+            *p = *g;
+        }
+        self.steps = gains.len().clamp(1, STEPS);
+    }
+}
+
+impl Default for Settings {
+    fn default() -> Self {
+        let mut s = Self {
+            source: Source::Audio,
+            pattern: [0.; STEPS],
+            grit_steps: [true; STEPS],
+            steps: 1,
+            edge: 15.,
+            level_jitter: 1.,
+            time_jitter: 3.,
+            grit: -9.,
+            tone: 12.,
+            position: 10.,
+            length: 12.,
+            seed: Seed::Same,
+            gate: -42.,
+            snap: true,
+            mix: 100.,
+            output: 0.,
+            bypass: false,
+        };
+        s.apply_pattern(PATTERNS[3].2);
+        s
+    }
+}
+impl Settings {
+    pub fn validate(&self) -> Result<(), &'static str> {
+        let finite = [
+            self.edge,
+            self.level_jitter,
+            self.time_jitter,
+            self.grit,
+            self.tone,
+            self.position,
+            self.length,
+            self.gate,
+            self.mix,
+            self.output,
+        ]
+        .iter()
+        .chain(self.pattern.iter())
+        .all(|v| v.is_finite());
+        if !finite {
+            return Err("non-finite setting");
+        }
+        let ok = self.pattern.iter().all(|g| (STEP_MIN..=0.).contains(g))
+            && (1..=STEPS).contains(&self.steps)
+            && (5.0..=50.).contains(&self.edge)
+            && (0.0..=6.).contains(&self.level_jitter)
+            && (0.0..=10.).contains(&self.time_jitter)
+            && (GRIT_OFF..=0.).contains(&self.grit)
+            && (4.0..=64.).contains(&self.tone)
+            && (0.0..=100.).contains(&self.position)
+            && (2.0..=50.).contains(&self.length)
+            && (-60.0..=-20.).contains(&self.gate)
+            && (0.0..=100.).contains(&self.mix)
+            && (-12.0..=12.).contains(&self.output);
+        if ok {
+            Ok(())
+        } else {
+            Err("setting out of range")
+        }
+    }
+}
@@ -0,0 +1,232 @@
+use common_dsp::{midi_to_hz, Saw};
+use knurl_core::{Engine, Seed, Settings, Source, GRIT_OFF, PATTERNS};
+
+const RATE: f32 = 48000.;
+
+/// A tanh saw bass at `note`, as the prototype used.
+fn bass(note: u8, n: usize) -> Vec<f32> {
+    let mut saw = Saw::new(RATE, midi_to_hz(note as f32));
+    (0..n).map(|_| (2.2 * saw.sample()).tanh() * 0.5).collect()
+}
+fn plain() -> Settings {
+    let mut s = Settings {
+        source: Source::Midi,
+        level_jitter: 0.,
+        time_jitter: 0.,
+        grit: GRIT_OFF,
+        ..Settings::default()
+    };
+    s.apply_pattern(PATTERNS[0].2);
+    s
+}
+/// Runs one held note from sample 0 and returns the output, aligned to the input.
+fn run(settings: Settings, note: u8, input: &[f32]) -> Vec<f32> {
+    let mut engine = Engine::new(RATE, 1).unwrap();
+    engine.set_settings(settings).unwrap();
+    let latency = engine.latency_samples() as usize;
+    engine.note_on(note);
+    let mut out: Vec<f32> = input
+        .iter()
+        .chain(std::iter::repeat_n(&0., latency))
+        .map(|&x| engine.process_sample([x, 0.])[0])
+        .collect();
+    out.drain(..latency);
+    out
+}
+/// Level of the component at `hz` (single-bin DFT with a Hann window), dB.
+fn level(x: &[f32], hz: f32) -> f64 {
+    let n = x.len();
+    let (mut re, mut im) = (0f64, 0f64);
+    for (i, &v) in x.iter().enumerate() {
+        let w = 0.5 - 0.5 * (std::f64::consts::TAU * i as f64 / n as f64).cos();
+        let a = std::f64::consts::TAU * hz as f64 * i as f64 / RATE as f64;
+        re += w * v as f64 * a.cos();
+        im -= w * v as f64 * a.sin();
+    }
+    10. * (re * re + im * im).max(1e-30).log10()
+}
+fn subharmonic(out: &[f32], note: u8, divisor: f32) -> f64 {
+    let f = midi_to_hz(note as f32);
+    let seg = &out[4800..out.len() - 4800];
+    level(seg, f / divisor) - level(seg, f)
+}
+fn max_step(x: &[f32]) -> f32 {
+    x.windows(2).map(|w| (w[1] - w[0]).abs()).fold(0., f32::max)
+}
+
+#[test]
+fn everything_off_is_the_delayed_input() {
+    let input = bass(29, 24000);
+    let out = run(plain(), 29, &input);
+    assert_eq!(out, input);
+}
+
+#[test]
+fn patterns_make_tuned_subharmonics_without_clicks() {
+    let input = bass(29, 48000);
+    let base = run(plain(), 29, &input);
+    assert!(subharmonic(&base, 29, 2.) < -50.);
+    for (pattern, divisor, expected) in [(1, 2., -8.2), (2, 3., -10.7)] {
+        let mut s = plain();
+        s.apply_pattern(PATTERNS[pattern].2);
+        let out = run(s, 29, &input);
+        let sub = subharmonic(&out, 29, divisor);
+        assert!(
+            (sub - expected).abs() < 0.5,
+            "{}: {sub}",
+            PATTERNS[pattern].0
+        );
+        assert!(
+            max_step(&out) <= 1.05 * max_step(&input),
+            "{}",
+            PATTERNS[pattern].0
+        );
+    }
+}
+
+#[test]
+fn the_texture_is_the_same_on_every_note() {
+    let mut s = plain();
+    s.apply_pattern(PATTERNS[1].2);
+    let low = run(s, 29, &bass(29, 48000));
+    let high = run(s, 36, &bass(36, 48000));
+    let (a, b) = (subharmonic(&low, 29, 2.), subharmonic(&high, 36, 2.));
+    assert!((a - b).abs() < 0.3, "F1 {a} C2 {b}");
+}
+
+#[test]
+fn same_seed_repeats_every_note_and_free_does_not() {
+    for (seed, identical) in [(Seed::Same, true), (Seed::Free, false)] {
+        let s = Settings {
+            source: Source::Midi,
+            seed,
+            ..Settings::default()
+        };
+        let mut engine = Engine::new(RATE, 2).unwrap();
+        engine.set_settings(s).unwrap();
+        let latency = engine.latency_samples() as usize;
+        let note = bass(29, 12000);
+        let mut out = Vec::new();
+        let starts = [0, 36000];
+        for i in 0..72000 + latency {
+            if starts.contains(&i) {
+                engine.note_on(29);
+            }
+            if i == starts[0] + 12000 || i == starts[1] + 12000 {
+                engine.note_off(29);
+            }
+            let k = starts
+                .iter()
+                .filter(|&&s| i >= s)
+                .map(|&s| i - s)
+                .min()
+                .unwrap();
+            let x = note.get(k).copied().unwrap_or(0.);
+            out.push(engine.process_sample([x, x])[0]);
+        }
+        let first = &out[latency..latency + 12000];
+        let second = &out[starts[1] + latency..starts[1] + latency + 12000];
+        let largest = first
+            .iter()
+            .zip(second)
+            .map(|(a, b)| (a - b).abs())
+            .fold(0f32, f32::max);
+        if identical {
+            assert!(largest < 1e-4, "{seed:?}: {largest}");
+        } else {
+            assert!(largest > 1e-2, "{seed:?}: {largest}");
+        }
+        assert!(out.iter().all(|v| v.is_finite()));
+    }
+}
+
+#[test]
+fn grit_follows_the_input_level_and_stops_with_the_note() {
+    let mut s = plain();
+    s.grit = -6.;
+    let input = bass(29, 24000);
+    let out = run(s, 29, &input);
+    let noise: f64 = out
+        .iter()
+        .zip(&input)
+        .skip(4800)
+        .map(|(o, i)| ((o - i) as f64).powi(2))
+        .sum::<f64>()
+        / (out.len() - 4800) as f64;
+    let signal: f64 = input
+        .iter()
+        .skip(4800)
+        .map(|v| (*v as f64).powi(2))
+        .sum::<f64>()
+        / (out.len() - 4800) as f64;
+    let ratio = 10. * (noise / signal).log10();
+    // −6 dB bursts over 12 % of each cycle; the sin² window keeps 3/8 of the power:
+    // −6 + 10·log10(0.12 · 0.375) = −19.5 dB.
+    assert!((ratio + 19.5).abs() < 1.5, "{ratio}");
+
+    // Silence in, silence out: no grit without a note, and no NaN.
+    let mut engine = Engine::new(RATE, 2).unwrap();
+    engine.set_settings(Settings::default()).unwrap();
+    for _ in 0..48000 {
+        let out = engine.process_sample([0., 0.]);
+        assert_eq!(out, [0., 0.]);
+    }
+}
+
+#[test]
+fn audio_source_finds_the_note_and_reports_latency() {
+    let mut s = plain();
+    s.source = Source::Audio;
+    s.apply_pattern(PATTERNS[1].2);
+    let mut engine = Engine::new(RATE, 1).unwrap();
+    engine.set_settings(s).unwrap();
+    let latency = engine.latency_samples() as usize;
+    // About 67 ms of lookahead plus 4.2 ms of jitter headroom.
+    assert!((latency as f32 / RATE - 0.071).abs() < 0.005, "{latency}");
+    let input = bass(29, 48000);
+    let mut out: Vec<f32> = input
+        .iter()
+        .map(|&x| engine.process_sample([x, 0.])[0])
+        .collect();
+    out.drain(..latency);
+    let frame = engine.take_analyzer();
+    assert_eq!(frame.note, Some(29));
+    assert!(frame.scope_valid);
+    let sub = subharmonic(&out[..out.len() - 4800], 29, 2.);
+    assert!(sub > -14., "{sub}");
+}
+
+#[test]
+fn invalid_settings_are_rejected() {
+    let mut engine = Engine::new(RATE, 2).unwrap();
+    for bad in [
+        Settings {
+            steps: 0,
+            ..Settings::default()
+        },
+        Settings {
+            edge: 60.,
+            ..Settings::default()
+        },
+        Settings {
+            grit: f32::NAN,
+            ..Settings::default()
+        },
+        Settings {
+            time_jitter: 11.,
+            ..Settings::default()
+        },
+    ] {
+        assert!(engine.set_settings(bad).is_err());
+    }
+    let mut s = Settings::default();
+    s.pattern[3] = -30.;
+    assert!(engine.set_settings(s).is_err());
+    assert!(Engine::new(1000., 2).is_err());
+    assert!(Engine::new(48000., 3).is_err());
+    let json = serde_json::to_string(&Settings::default()).unwrap();
+    assert_eq!(
+        serde_json::from_str::<Settings>(&json).unwrap(),
+        Settings::default()
+    );
+}
@@ -0,0 +1,70 @@
+use knurl_core::{Engine, Seed, Settings, Source, PATTERNS};
+use std::{
+    alloc::{GlobalAlloc, Layout, System},
+    cell::Cell,
+};
+
+struct CheckedAllocator;
+thread_local! {
+    static CHECK:Cell<bool>=const {Cell::new(false)};
+    static OPERATIONS:Cell<usize>=const {Cell::new(0)};
+}
+fn record() {
+    if CHECK.try_with(Cell::get).unwrap_or(false) {
+        let _ = OPERATIONS.try_with(|n| n.set(n.get() + 1));
+    }
+}
+unsafe impl GlobalAlloc for CheckedAllocator {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        record();
+        unsafe { System.alloc(layout) }
+    }
+    unsafe fn dealloc(&self, pointer: *mut u8, layout: Layout) {
+        record();
+        unsafe { System.dealloc(pointer, layout) }
+    }
+    unsafe fn realloc(&self, pointer: *mut u8, layout: Layout, size: usize) -> *mut u8 {
+        record();
+        unsafe { System.realloc(pointer, layout, size) }
+    }
+}
+#[global_allocator]
+static ALLOCATOR: CheckedAllocator = CheckedAllocator;
+
+#[test]
+fn notes_patterns_grit_and_jitter_do_not_allocate_or_free() {
+    let mut engine = Engine::new(48000., 2).unwrap();
+    let mut settings = Settings::default();
+    engine.set_settings(settings).unwrap();
+    CHECK.with(|v| v.set(true));
+    for i in 0..96000 {
+        if i % 4800 == 0 {
+            settings.apply_pattern(PATTERNS[(i / 4800) % PATTERNS.len()].2);
+            settings.seed = if i > 48000 { Seed::Free } else { Seed::Same };
+            settings.source = if (i / 4800) % 3 == 0 {
+                Source::Midi
+            } else {
+                Source::Audio
+            };
+            settings.time_jitter = ((i / 4800) % 10) as f32;
+            engine.set_settings(settings).unwrap();
+            engine.note_on(30 + (i / 4800 % 12) as u8);
+        }
+        if i % 4800 == 2400 {
+            engine.note_off(30 + (i / 4800 % 12) as u8);
+        }
+        let t = i as f32 / 48000.;
+        let x = if (i / 2400) % 2 == 0 {
+            (std::f32::consts::TAU * 55. * t).sin() * 0.5
+        } else {
+            0.
+        };
+        std::hint::black_box(engine.process_sample([x, x]));
+        if i % 1600 == 0 {
+            std::hint::black_box(engine.take_analyzer());
+        }
+    }
+    engine.reset();
+    CHECK.with(|v| v.set(false));
+    assert_eq!(OPERATIONS.with(Cell::get), 0);
+}
@@ -0,0 +1,26 @@
+[package]
+name = "knurl"
+version = "0.2.0"
+edition = "2021"
+license = "ISC"
+
+[workspace]
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+nih_plug = { git = "https://github.com/robbert-vdh/nih-plug.git", rev = "de421011f41a6d10fc8c7a6084e4f4dee0143683", default-features = false }
+nih_plug_egui = { git = "https://github.com/robbert-vdh/nih-plug.git", rev = "de421011f41a6d10fc8c7a6084e4f4dee0143683" }
+knurl-core = { path = "../core" }
+knurl-ui = { path = "../ui" }
+crossbeam-queue = "0.3"
+serde = { version = "1", features = ["derive"] }
+
+[dev-dependencies]
+clap-sys = { git = "https://github.com/micahrj/clap-sys.git", rev = "25d7f53fdb6363ad63fbd80049cb7a42a97ac156" }
+serde_json = "1"
+
+[profile.release]
+lto = "thin"
+strip = "symbols"
@@ -0,0 +1,195 @@
+//! CLAP audio effect. All DSP state is owned by the processing thread.
+mod params;
+use crossbeam_queue::ArrayQueue;
+use knurl_core::{AnalyzerFrame, Engine};
+use nih_plug::prelude::*;
+use nih_plug_egui::{create_egui_editor, egui};
+use params::{KnurlParams, Pattern, GESTURES};
+use std::sync::Arc;
+
+struct EditorData {
+    ui: knurl_ui::State,
+    gestures: [bool; GESTURES],
+}
+pub struct Knurl {
+    params: Arc<KnurlParams>,
+    analyzer: Arc<ArrayQueue<AnalyzerFrame>>,
+    engine: Option<Engine>,
+    pattern: Pattern,
+    publish_count: usize,
+    publish_interval: usize,
+}
+impl Default for Knurl {
+    fn default() -> Self {
+        Self {
+            params: Arc::new(KnurlParams::default()),
+            analyzer: Arc::new(ArrayQueue::new(2)),
+            engine: None,
+            pattern: Pattern::default(),
+            publish_count: 0,
+            publish_interval: 1600,
+        }
+    }
+}
+impl Plugin for Knurl {
+    const NAME: &'static str = "Knurl";
+    const VENDOR: &'static str = "Bass Foundry";
+    const URL: &'static str = "";
+    const EMAIL: &'static str = "";
+    const VERSION: &'static str = env!("CARGO_PKG_VERSION");
+    const AUDIO_IO_LAYOUTS: &'static [AudioIOLayout] = &[
+        AudioIOLayout {
+            main_input_channels: NonZeroU32::new(2),
+            main_output_channels: NonZeroU32::new(2),
+            ..AudioIOLayout::const_default()
+        },
+        AudioIOLayout {
+            main_input_channels: NonZeroU32::new(1),
+            main_output_channels: NonZeroU32::new(1),
+            ..AudioIOLayout::const_default()
+        },
+    ];
+    const MIDI_INPUT: MidiConfig = MidiConfig::Basic;
+    const SAMPLE_ACCURATE_AUTOMATION: bool = false;
+    type SysExMessage = ();
+    type BackgroundTask = ();
+    fn params(&self) -> Arc<dyn Params> {
+        self.params.clone()
+    }
+    fn editor(&mut self, _: AsyncExecutor<Self>) -> Option<Box<dyn Editor>> {
+        let params = self.params.clone();
+        let analyzer = self.analyzer.clone();
+        create_egui_editor(
+            params.editor.clone(),
+            EditorData {
+                ui: knurl_ui::State::default(),
+                gestures: [false; GESTURES],
+            },
+            |ctx, _| knurl_ui::style(ctx),
+            move |ctx, setter, data| {
+                while let Some(frame) = analyzer.pop() {
+                    data.ui.accept_frame(frame);
+                }
+                let current = params.pattern();
+                let before = params.settings(&current);
+                let mut edited = before;
+                nih_plug_egui::resizable_window::ResizableWindow::new("knurl-editor")
+                    .min_size(egui::vec2(
+                        knurl_ui::WIDTH as f32 - 80.,
+                        knurl_ui::HEIGHT as f32 - 40.,
+                    ))
+                    .show(ctx, &params.editor, |ui| {
+                        knurl_ui::show(ui, &mut edited, &mut data.ui)
+                    });
+                params.apply(
+                    setter,
+                    &before,
+                    &edited,
+                    data.ui.gesture_active,
+                    &mut data.gestures,
+                );
+                // The scope follows the audio.
+                ctx.request_repaint_after(std::time::Duration::from_millis(40));
+            },
+        )
+    }
+    fn initialize(
+        &mut self,
+        layout: &AudioIOLayout,
+        config: &BufferConfig,
+        context: &mut impl InitContext<Self>,
+    ) -> bool {
+        let Ok(mut engine) = Engine::new(
+            config.sample_rate,
+            layout.main_input_channels.map_or(0, |v| v.get() as usize),
+        ) else {
+            return false;
+        };
+        let settings = self.params.settings(&self.pattern);
+        self.pattern = Pattern {
+            gains: settings.pattern,
+            grit: settings.grit_steps,
+        };
+        if engine.set_settings(settings).is_err() {
+            return false;
+        }
+        context.set_latency_samples(engine.latency_samples());
+        self.publish_interval = (config.sample_rate / 30.) as usize;
+        self.engine = Some(engine);
+        true
+    }
+    fn reset(&mut self) {
+        if let Some(e) = self.engine.as_mut() {
+            e.reset();
+        }
+        self.publish_count = 0;
+    }
+    fn process(
+        &mut self,
+        buffer: &mut Buffer,
+        _: &mut AuxiliaryBuffers,
+        context: &mut impl ProcessContext<Self>,
+    ) -> ProcessStatus {
+        let Some(engine) = self.engine.as_mut() else {
+            return ProcessStatus::Normal;
+        };
+        let settings = self.params.settings(&self.pattern);
+        self.pattern = Pattern {
+            gains: settings.pattern,
+            grit: settings.grit_steps,
+        };
+        let _ = engine.set_settings(settings);
+        let mut next = context.next_event();
+        for (index, mut sample) in buffer.iter_samples().enumerate() {
+            while let Some(event) = next {
+                if event.timing() as usize > index {
+                    break;
+                }
+                match event {
+                    NoteEvent::NoteOn { note, velocity, .. } if velocity > 0. => {
+                        engine.note_on(note)
+                    }
+                    NoteEvent::NoteOn { note, .. } | NoteEvent::NoteOff { note, .. } => {
+                        engine.note_off(note)
+                    }
+                    NoteEvent::Choke { note, .. } => engine.note_off(note),
+                    _ => {}
+                }
+                next = context.next_event();
+            }
+            let x = [
+                *sample.get_mut(0).unwrap(),
+                if engine.channels() == 2 {
+                    *sample.get_mut(1).unwrap()
+                } else {
+                    0.
+                },
+            ];
+            let out = engine.process_sample(x);
+            for (c, value) in sample.into_iter().enumerate() {
+                *value = out[c];
+            }
+            self.publish_count += 1;
+            if self.publish_count >= self.publish_interval {
+                self.analyzer.force_push(engine.take_analyzer());
+                self.publish_count = 0;
+            }
+        }
+        // The lookahead delay and filter tails must drain after input stops.
+        ProcessStatus::KeepAlive
+    }
+}
+impl ClapPlugin for Knurl {
+    const CLAP_ID: &'static str = "io.narl.bass-foundry.knurl";
+    const CLAP_DESCRIPTION: Option<&'static str> =
+        Some("Texture per cycle of the played note: patterns, jitter and grit that fit every note");
+    const CLAP_MANUAL_URL: Option<&'static str> = None;
+    const CLAP_SUPPORT_URL: Option<&'static str> = None;
+    const CLAP_FEATURES: &'static [ClapFeature] = &[
+        ClapFeature::AudioEffect,
+        ClapFeature::Distortion,
+        ClapFeature::Stereo,
+        ClapFeature::Mono,
+    ];
+}
+nih_export_clap!(Knurl);
@@ -0,0 +1,255 @@
+use knurl_core::{Seed, Settings, Source, GRIT_OFF, STEPS, STEP_MIN};
+use nih_plug::prelude::*;
+use nih_plug_egui::EguiState;
+use std::sync::{Arc, RwLock};
+
+#[derive(Enum, Debug, PartialEq, Eq, Clone, Copy)]
+pub enum SourceParam {
+    #[id = "audio"]
+    Audio,
+    #[id = "midi"]
+    #[name = "MIDI"]
+    Midi,
+}
+#[derive(Enum, Debug, PartialEq, Eq, Clone, Copy)]
+pub enum SeedParam {
+    #[id = "same"]
+    #[name = "Same every note"]
+    Same,
+    #[id = "free"]
+    Free,
+}
+fn linear(name: &str, v: f32, min: f32, max: f32, unit: &'static str) -> FloatParam {
+    FloatParam::new(name, v, FloatRange::Linear { min, max }).with_unit(unit)
+}
+/// Continuous controls, in the order of the gesture slots.
+const FLOATS: usize = 10;
+pub const GESTURES: usize = FLOATS;
+
+/// The drawn pattern: step gains and grit switches. Saved with the project, not automation.
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct Pattern {
+    pub gains: [f32; STEPS],
+    pub grit: [bool; STEPS],
+}
+impl Default for Pattern {
+    fn default() -> Self {
+        let d = Settings::default();
+        Self {
+            gains: d.pattern,
+            grit: d.grit_steps,
+        }
+    }
+}
+
+#[derive(Params)]
+pub struct KnurlParams {
+    #[persist = "editor"]
+    pub editor: Arc<EguiState>,
+    #[persist = "knurl-pattern"]
+    pub pattern: RwLock<Pattern>,
+    #[id = "source"]
+    pub source: EnumParam<SourceParam>,
+    #[id = "seed"]
+    pub seed: EnumParam<SeedParam>,
+    #[id = "steps"]
+    pub steps: IntParam,
+    #[id = "edge"]
+    pub edge: FloatParam,
+    #[id = "level-jitter"]
+    pub level_jitter: FloatParam,
+    #[id = "time-jitter"]
+    pub time_jitter: FloatParam,
+    #[id = "grit"]
+    pub grit: FloatParam,
+    #[id = "tone"]
+    pub tone: FloatParam,
+    #[id = "position"]
+    pub position: FloatParam,
+    #[id = "length"]
+    pub length: FloatParam,
+    #[id = "gate"]
+    pub gate: FloatParam,
+    #[id = "mix"]
+    pub mix: FloatParam,
+    #[id = "output"]
+    pub output: FloatParam,
+    #[id = "snap"]
+    pub snap: BoolParam,
+    #[id = "bypass"]
+    pub bypass: BoolParam,
+}
+impl Default for KnurlParams {
+    fn default() -> Self {
+        let d = Settings::default();
+        Self {
+            editor: EguiState::from_size(knurl_ui::WIDTH, knurl_ui::HEIGHT),
+            pattern: RwLock::new(Pattern::default()),
+            source: EnumParam::new("Pitch source", SourceParam::Audio),
+            seed: EnumParam::new("Random", SeedParam::Same),
+            steps: IntParam::new(
+                "Steps",
+                d.steps as i32,
+                IntRange::Linear {
+                    min: 1,
+                    max: STEPS as i32,
+                },
+            ),
+            edge: linear("Edge", d.edge, 5., 50., " %"),
+            level_jitter: linear("Level jitter", d.level_jitter, 0., 6., " dB"),
+            time_jitter: linear("Time jitter", d.time_jitter, 0., 10., " %"),
+            grit: linear("Grit", d.grit, GRIT_OFF, 0., " dB").with_value_to_string(Arc::new(|v| {
+                if v <= GRIT_OFF {
+                    "Off".into()
+                } else {
+                    format!("{v:.1}")
+                }
+            })),
+            tone: FloatParam::new(
+                "Tone",
+                d.tone,
+                FloatRange::Skewed {
+                    min: 4.,
+                    max: 64.,
+                    factor: FloatRange::skew_factor(-1.),
+                },
+            )
+            .with_unit(" ×f0"),
+            position: linear("Position", d.position, 0., 100., " %"),
+            length: linear("Length", d.length, 2., 50., " %"),
+            gate: linear("Gate", d.gate, -60., -20., " dB"),
+            mix: linear("Mix", d.mix, 0., 100., " %"),
+            output: linear("Output", d.output, -12., 12., " dB"),
+            snap: BoolParam::new("Snap to semitone", d.snap),
+            bypass: BoolParam::new("Bypass", false).make_bypass(),
+        }
+    }
+}
+impl KnurlParams {
+    /// Current settings. The pattern falls back to `last` when the editor holds the lock,
+    /// so the audio thread never waits.
+    pub fn settings(&self, last: &Pattern) -> Settings {
+        let pattern = self.pattern.try_read().map(|p| *p).unwrap_or(*last);
+        Settings {
+            source: match self.source.value() {
+                SourceParam::Audio => Source::Audio,
+                SourceParam::Midi => Source::Midi,
+            },
+            pattern: pattern.gains.map(|g| {
+                if g.is_finite() {
+                    g.clamp(STEP_MIN, 0.)
+                } else {
+                    0.
+                }
+            }),
+            grit_steps: pattern.grit,
+            steps: self.steps.value().clamp(1, STEPS as i32) as usize,
+            edge: self.edge.value(),
+            level_jitter: self.level_jitter.value(),
+            time_jitter: self.time_jitter.value(),
+            grit: self.grit.value(),
+            tone: self.tone.value(),
+            position: self.position.value(),
+            length: self.length.value(),
+            seed: match self.seed.value() {
+                SeedParam::Same => Seed::Same,
+                SeedParam::Free => Seed::Free,
+            },
+            gate: self.gate.value(),
+            snap: self.snap.value(),
+            mix: self.mix.value(),
+            output: self.output.value(),
+            bypass: self.bypass.value(),
+        }
+    }
+    pub fn pattern(&self) -> Pattern {
+        self.pattern.read().map(|p| *p).unwrap_or_default()
+    }
+    fn floats(&self) -> [&FloatParam; FLOATS] {
+        [
+            &self.edge,
+            &self.level_jitter,
+            &self.time_jitter,
+            &self.grit,
+            &self.tone,
+            &self.position,
+            &self.length,
+            &self.gate,
+            &self.mix,
+            &self.output,
+        ]
+    }
+    /// Pushes every changed editor value to the host. Continuous controls hold one gesture
+    /// while the pointer is down; switches are set in a single gesture. The pattern is
+    /// stored directly.
+    pub fn apply(
+        &self,
+        setter: &ParamSetter,
+        old: &Settings,
+        new: &Settings,
+        dragging: bool,
+        open: &mut [bool; FLOATS],
+    ) {
+        if new.pattern != old.pattern || new.grit_steps != old.grit_steps {
+            if let Ok(mut p) = self.pattern.write() {
+                *p = Pattern {
+                    gains: new.pattern,
+                    grit: new.grit_steps,
+                };
+            }
+        }
+        let values = [
+            (old.edge, new.edge),
+            (old.level_jitter, new.level_jitter),
+            (old.time_jitter, new.time_jitter),
+            (old.grit, new.grit),
+            (old.tone, new.tone),
+            (old.position, new.position),
+            (old.length, new.length),
+            (old.gate, new.gate),
+            (old.mix, new.mix),
+            (old.output, new.output),
+        ];
+        for (i, (p, (a, b))) in self.floats().into_iter().zip(values).enumerate() {
+            if a != b {
+                if !open[i] {
+                    open[i] = true;
+                    setter.begin_set_parameter(p);
+                }
+                setter.set_parameter(p, b);
+            }
+            if !dragging && open[i] {
+                setter.end_set_parameter(p);
+                open[i] = false;
+            }
+        }
+        fn switch<P: Param>(setter: &ParamSetter, p: &P, v: P::Plain) {
+            setter.begin_set_parameter(p);
+            setter.set_parameter(p, v);
+            setter.end_set_parameter(p);
+        }
+        if new.steps != old.steps {
+            switch(setter, &self.steps, new.steps as i32);
+        }
+        if new.snap != old.snap {
+            switch(setter, &self.snap, new.snap);
+        }
+        if new.bypass != old.bypass {
+            switch(setter, &self.bypass, new.bypass);
+        }
+        if new.source != old.source {
+            let v = match new.source {
+                Source::Audio => SourceParam::Audio,
+                Source::Midi => SourceParam::Midi,
+            };
+            switch(setter, &self.source, v);
+        }
+        if new.seed != old.seed {
+            let v = match new.seed {
+                Seed::Same => SeedParam::Same,
+                Seed::Free => SeedParam::Free,
+            };
+            switch(setter, &self.seed, v);
+        }
+    }
+}
@@ -0,0 +1,227 @@
+//! Exercise the actual exported CLAP ABI without requiring a GUI or installed DAW.
+use clap_sys::{
+    audio_buffer::*,
+    events::*,
+    ext::{audio_ports::*, latency::*, state::*},
+    factory::plugin_factory::*,
+    host::*,
+    process::*,
+    stream::*,
+    version::*,
+};
+use std::{
+    ffi::{c_char, c_void, CStr},
+    io::{Cursor, Read},
+    ptr,
+};
+
+unsafe extern "C" fn extension(_: *const clap_host, _: *const c_char) -> *const c_void {
+    ptr::null()
+}
+unsafe extern "C" fn request(_: *const clap_host) {}
+unsafe extern "C" fn count(_: *const clap_input_events) -> u32 {
+    0
+}
+unsafe extern "C" fn event(_: *const clap_input_events, _: u32) -> *const clap_event_header {
+    ptr::null()
+}
+unsafe extern "C" fn push(_: *const clap_output_events, _: *const clap_event_header) -> bool {
+    true
+}
+unsafe extern "C" fn write(stream: *const clap_ostream, buffer: *const c_void, size: u64) -> i64 {
+    // SAFETY: The test owns the Vec for the entire synchronous save call.
+    let bytes = unsafe { &mut *((*stream).ctx as *mut Vec<u8>) };
+    bytes.extend_from_slice(unsafe {
+        std::slice::from_raw_parts(buffer as *const u8, size as usize)
+    });
+    size as i64
+}
+unsafe extern "C" fn read(stream: *const clap_istream, buffer: *mut c_void, size: u64) -> i64 {
+    // SAFETY: The test owns the Cursor; the wrapper supplies writable stream storage.
+    let cursor = unsafe { &mut *((*stream).ctx as *mut Cursor<Vec<u8>>) };
+    cursor
+        .read(unsafe { std::slice::from_raw_parts_mut(buffer as *mut u8, size as usize) })
+        .unwrap() as i64
+}
+
+#[test]
+fn effect_ports_state_latency_and_audio_lifecycle() {
+    // SAFETY: All callbacks, strings, streams, buffers, and the host outlive their
+    // synchronous ABI calls. Activation/processing/destruction follow CLAP order.
+    unsafe {
+        let entry = &knurl::clap_entry;
+        assert!(entry.init.unwrap()(c"knurl.clap".as_ptr()));
+        let factory = entry.get_factory.unwrap()(CLAP_PLUGIN_FACTORY_ID.as_ptr())
+            as *const clap_plugin_factory;
+        assert!(!factory.is_null());
+        let factory = &*factory;
+        assert_eq!(factory.get_plugin_count.unwrap()(factory), 1);
+        let descriptor = factory.get_plugin_descriptor.unwrap()(factory, 0);
+        assert!(!descriptor.is_null());
+        assert_eq!(CStr::from_ptr((*descriptor).name), c"Knurl");
+        assert_eq!(
+            CStr::from_ptr((*descriptor).id),
+            c"io.narl.bass-foundry.knurl"
+        );
+        assert!(factory.get_plugin_descriptor.unwrap()(factory, 1).is_null());
+        let host = clap_host {
+            clap_version: CLAP_VERSION,
+            host_data: ptr::null_mut(),
+            name: c"Storyboard test host".as_ptr(),
+            vendor: c"Tests".as_ptr(),
+            url: c"".as_ptr(),
+            version: c"1.0".as_ptr(),
+            get_extension: Some(extension),
+            request_restart: Some(request),
+            request_process: Some(request),
+            request_callback: Some(request),
+        };
+        let plugin = factory.create_plugin.unwrap()(factory, &host, (*descriptor).id);
+        assert!(!plugin.is_null());
+        let p = &*plugin;
+        assert!(p.init.unwrap()(plugin));
+        let ports = p.get_extension.unwrap()(plugin, CLAP_EXT_AUDIO_PORTS.as_ptr())
+            as *const clap_plugin_audio_ports;
+        assert!(!ports.is_null());
+        assert_eq!((*ports).count.unwrap()(plugin, false), 1);
+        assert_eq!((*ports).count.unwrap()(plugin, true), 1);
+        let latency = p.get_extension.unwrap()(plugin, CLAP_EXT_LATENCY.as_ptr())
+            as *const clap_plugin_latency;
+        assert!(!latency.is_null());
+        let state =
+            p.get_extension.unwrap()(plugin, CLAP_EXT_STATE.as_ptr()) as *const clap_plugin_state;
+        assert!(!state.is_null());
+        let state = &*state;
+        let save = || {
+            let mut bytes = Vec::new();
+            let stream = clap_ostream {
+                ctx: &mut bytes as *mut Vec<u8> as *mut c_void,
+                write: Some(write),
+            };
+            assert!(state.save.unwrap()(plugin, &stream));
+            bytes
+        };
+        let mut envelope: nih_plug::prelude::PluginState =
+            serde_json::from_slice(&save()[8..]).unwrap();
+        use nih_plug::wrapper::state::ParamValue;
+        envelope.params.insert("edge".into(), ParamValue::F32(30.));
+        envelope.params.insert("steps".into(), ParamValue::I32(3));
+        envelope
+            .params
+            .insert("seed".into(), ParamValue::String("free".into()));
+        envelope
+            .params
+            .insert("source".into(), ParamValue::String("midi".into()));
+        // Pitch from MIDI and no note arrives, so the audio check below sees the dry input
+        // even with a pattern set.
+        envelope
+            .params
+            .insert("level-jitter".into(), ParamValue::F32(0.));
+        envelope
+            .params
+            .insert("time-jitter".into(), ParamValue::F32(0.));
+        envelope.params.insert("grit".into(), ParamValue::F32(-60.));
+        let (gains, grit) = ([-6f32; 16], [true; 16]);
+        let mut pattern = serde_json::json!({ "gains": gains, "grit": grit });
+        pattern["grit"][5] = false.into();
+        envelope
+            .fields
+            .insert("knurl-pattern".into(), pattern.to_string());
+        let encoded = serde_json::to_vec(&envelope).unwrap();
+        let mut framed = (encoded.len() as u64).to_le_bytes().to_vec();
+        framed.extend_from_slice(&encoded);
+        let mut bytes = Cursor::new(framed);
+        let stream = clap_istream {
+            ctx: &mut bytes as *mut Cursor<Vec<u8>> as *mut c_void,
+            read: Some(read),
+        };
+        assert!(state.load.unwrap()(plugin, &stream));
+        let restored: nih_plug::prelude::PluginState =
+            serde_json::from_slice(&save()[8..]).unwrap();
+        assert_eq!(
+            serde_json::to_value(&restored.params).unwrap(),
+            serde_json::to_value(&envelope.params).unwrap()
+        );
+        let saved: serde_json::Value =
+            serde_json::from_str(&restored.fields["knurl-pattern"]).unwrap();
+        assert_eq!(saved, pattern);
+        for rate in [44100., 48000., 96000.] {
+            assert!(p.activate.unwrap()(plugin, rate, 1, 512));
+            let delay = (*latency).get.unwrap()(plugin) as usize;
+            // About 67 ms lookahead plus 4.2 ms of timing-jitter headroom.
+            assert!((delay as f64 / rate - 0.071).abs() < 0.01, "{delay}");
+            assert!(p.start_processing.unwrap()(plugin));
+            let total = delay + 9600;
+            let mut position = 0;
+            let (mut energy_in, mut energy_out) = (0f64, 0f64);
+            while position < total {
+                let frames = [1, 127, 512, 31][position % 4].min(total - position);
+                // With no MIDI note and every effect off, a tone passes through unchanged.
+                let tone = |n: usize| {
+                    0.25 * (std::f64::consts::TAU * 1000. * n as f64 / rate).sin() as f32
+                };
+                let mut input_left = [0f32; 512];
+                let mut input_right = [0f32; 512];
+                for i in 0..frames {
+                    input_left[i] = tone(position + i);
+                    input_right[i] = -tone(position + i);
+                }
+                let mut left = [0f32; 512];
+                let mut right = [0f32; 512];
+                let mut in_channels = [input_left.as_mut_ptr(), input_right.as_mut_ptr()];
+                let mut out_channels = [left.as_mut_ptr(), right.as_mut_ptr()];
+                let incoming = clap_audio_buffer {
+                    data32: in_channels.as_mut_ptr(),
+                    data64: ptr::null_mut(),
+                    channel_count: 2,
+                    latency: 0,
+                    constant_mask: 0,
+                };
+                let mut outgoing_audio = clap_audio_buffer {
+                    data32: out_channels.as_mut_ptr(),
+                    data64: ptr::null_mut(),
+                    channel_count: 2,
+                    latency: 0,
+                    constant_mask: 0,
+                };
+                let input = clap_input_events {
+                    ctx: ptr::null_mut(),
+                    size: Some(count),
+                    get: Some(event),
+                };
+                let outgoing = clap_output_events {
+                    ctx: ptr::null_mut(),
+                    try_push: Some(push),
+                };
+                let process = clap_process {
+                    steady_time: position as i64,
+                    frames_count: frames as u32,
+                    transport: ptr::null(),
+                    audio_inputs: &incoming,
+                    audio_outputs: &mut outgoing_audio,
+                    audio_inputs_count: 1,
+                    audio_outputs_count: 1,
+                    in_events: &input,
+                    out_events: &outgoing,
+                };
+                assert_ne!(p.process.unwrap()(plugin, &process), CLAP_PROCESS_ERROR);
+                for i in 0..frames {
+                    let n = position + i;
+                    if n < delay {
+                        assert!(left[i].abs() < 1e-6, "output before the lookahead");
+                    } else if n > delay + 4800 {
+                        energy_in += (tone(n - delay) as f64).powi(2);
+                        energy_out += (left[i] as f64).powi(2) + (right[i] as f64).powi(2);
+                    }
+                }
+                position += frames;
+            }
+            let ratio_db = 10. * (energy_out / (2. * energy_in)).log10();
+            assert!(ratio_db.abs() < 0.2, "{ratio_db}");
+            p.stop_processing.unwrap()(plugin);
+            p.deactivate.unwrap()(plugin);
+        }
+        p.destroy.unwrap()(plugin);
+        entry.deinit.unwrap()();
+    }
+}
@@ -0,0 +1,11 @@
+[package]
+name = "knurl-ui"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+egui = "0.31.1"
+knurl-core = { path = "../core" }
+common-ui = { path = "../../common/ui" }
+common-dsp = { path = "../../common/dsp" }
@@ -0,0 +1,501 @@
+//! Knurl editor, shared by the CLAP wrapper and the headless renderer.
+use common_ui::*;
+use egui::{self, Color32, FontId, Pos2, Rect, RichText, Sense, Stroke, Vec2};
+use knurl_core::{
+    AnalyzerFrame, Seed, Settings, Source, GRIT_OFF, PATTERNS, SCOPE_CYCLES, SCOPE_POINTS, STEPS,
+    STEP_MIN,
+};
+
+pub use common_ui::style;
+pub const WIDTH: u32 = 1040;
+pub const HEIGHT: u32 = 650;
+
+const GRID: Color32 = Color32::from_rgb(24, 26, 30);
+const TOP: f32 = 316.;
+
+pub struct State {
+    pub analyzer: AnalyzerFrame,
+    /// True while a pointer button is held, so knob drags become one host gesture.
+    pub gesture_active: bool,
+    pub help: String,
+}
+impl Default for State {
+    fn default() -> Self {
+        Self {
+            analyzer: AnalyzerFrame::default(),
+            gesture_active: false,
+            help: DEFAULT_HELP.into(),
+        }
+    }
+}
+const DEFAULT_HELP: &str =
+    "Every cycle of the note gets its own level, timing and grit. Counted in cycles, so it fits every note.";
+impl State {
+    pub fn accept_frame(&mut self, frame: AnalyzerFrame) {
+        let old = self.analyzer;
+        self.analyzer = frame;
+        self.analyzer.input_db = frame.input_db.max(old.input_db - 3.);
+        self.analyzer.output_db = frame.output_db.max(old.output_db - 3.);
+        // Keep the last scope between notes.
+        if !frame.scope_valid && old.scope_valid {
+            self.analyzer.scope = old.scope;
+            self.analyzer.scope_valid = true;
+        }
+    }
+}
+fn hint(r: &egui::Response, state: &mut State, text: &str) {
+    if r.hovered() || r.has_focus() {
+        state.help = text.into();
+    }
+}
+#[allow(clippy::too_many_arguments)]
+fn knob(
+    ui: &mut egui::Ui,
+    state: &mut State,
+    name: &str,
+    value: &mut f32,
+    range: std::ops::RangeInclusive<f32>,
+    default: f32,
+    unit: &str,
+    help: &str,
+) {
+    ui.vertical_centered(|ui| {
+        let r = rotary(ui, name, value, range, default, unit, 58., ACCENT);
+        hint(&r, state, help);
+    });
+}
+
+pub fn show(ui: &mut egui::Ui, settings: &mut Settings, state: &mut State) {
+    backdrop(ui);
+    state.help = DEFAULT_HELP.into();
+    state.gesture_active = ui.input(|i| i.pointer.any_down());
+    ui.add_space(2.);
+    header(ui, "KNURL", "CYCLE TEXTURE", |ui| {
+        let r = ui
+            .selectable_label(settings.bypass, RichText::new("BYPASS").size(13.))
+            .on_hover_text("Crossfade to the delayed dry signal.");
+        if r.clicked() {
+            settings.bypass = !settings.bypass;
+        }
+        ui.separator();
+        for (source, label) in [(Source::Midi, "MIDI"), (Source::Audio, "AUDIO")] {
+            let r = ui.selectable_label(settings.source == source, RichText::new(label).size(13.));
+            if r.clicked() {
+                settings.source = source;
+            }
+        }
+        caption(ui, "PITCH FROM");
+    });
+    ui.add_space(6.);
+    ui.horizontal_top(|ui| {
+        panel(ui, |ui| {
+            ui.set_width(210.);
+            ui.set_min_height(TOP);
+            ui.vertical(|ui| note_panel(ui, settings, state));
+        });
+        ui.add_space(4.);
+        panel(ui, |ui| {
+            ui.set_width(ui.available_width());
+            ui.vertical(|ui| {
+                let frame = state.analyzer;
+                scope(ui, &frame, 140.);
+                ui.add_space(4.);
+                pattern_editor(ui, settings, state, TOP - 144.);
+            });
+        });
+    });
+    ui.add_space(6.);
+    panel(ui, |ui| {
+        ui.set_width(ui.available_width());
+        ui.vertical(|ui| controls(ui, settings, state));
+    });
+    ui.separator();
+    ui.label(RichText::new(&state.help).color(MUTED));
+}
+
+fn note_panel(ui: &mut egui::Ui, settings: &mut Settings, state: &mut State) {
+    let frame = state.analyzer;
+    caption(ui, "NOTE");
+    let (name, hz) = match frame.note {
+        Some(n) if frame.hz > 0. => (common_dsp::note_name(n), format!("{:.1} Hz", frame.hz)),
+        _ if frame.hz > 0. => ("—".into(), format!("holding {:.1} Hz", frame.hz)),
+        _ => ("—".into(), "no note yet".into()),
+    };
+    ui.label(
+        RichText::new(name)
+            .font(FontId::new(54., egui::FontFamily::Name("medium".into())))
+            .color(if frame.note.is_some() { TEXT } else { DIM }),
+    );
+    ui.label(RichText::new(hz).size(13.).color(MUTED));
+    if frame.hz > 0. {
+        ui.label(
+            RichText::new(format!("one cycle = {:.1} ms", 1000. / frame.hz))
+                .size(12.)
+                .color(DIM),
+        );
+    }
+    ui.add_space(10.);
+    meter(ui, "IN", frame.input_db, STEEL, 110.);
+    meter(ui, "OUT", frame.output_db, ACCENT, 110.);
+    ui.add_space(10.);
+    caption(ui, "RANDOM");
+    ui.horizontal(|ui| {
+        for (seed, label, help) in [
+            (
+                Seed::Same,
+                "SAME EVERY NOTE",
+                "Every note gets the same random sequence: identical notes sound identical.",
+            ),
+            (
+                Seed::Free,
+                "FREE",
+                "The random sequences keep running, so every note differs.",
+            ),
+        ] {
+            let r = ui.selectable_label(settings.seed == seed, RichText::new(label).size(12.));
+            if r.clicked() {
+                settings.seed = seed;
+            }
+            hint(&r, state, help);
+        }
+    });
+    ui.add_space(6.);
+    let r = ui.checkbox(
+        &mut settings.snap,
+        RichText::new("Snap to semitone").size(12.),
+    );
+    hint(
+        &r,
+        state,
+        "Round the detected pitch. Turn it off for slides.",
+    );
+}
+
+/// The last cycles of the output, overlaid; the newest is brightest.
+fn scope(ui: &mut egui::Ui, frame: &AnalyzerFrame, height: f32) {
+    let (outer, _) =
+        ui.allocate_exact_size(Vec2::new(ui.available_width(), height), Sense::hover());
+    let p = ui.painter_at(outer);
+    p.rect_filled(outer, 2., SCREEN);
+    p.text(
+        outer.left_top() + Vec2::new(8., 5.),
+        egui::Align2::LEFT_TOP,
+        format!("LAST {SCOPE_CYCLES} CYCLES, OVERLAID"),
+        FontId::proportional(10.),
+        MUTED,
+    );
+    let plot = Rect::from_min_max(
+        outer.left_top() + Vec2::new(10., 20.),
+        outer.right_bottom() - Vec2::new(10., 8.),
+    );
+    for t in [0.25f32, 0.5, 0.75] {
+        let x = plot.left() + plot.width() * t;
+        p.line_segment(
+            [Pos2::new(x, plot.top()), Pos2::new(x, plot.bottom())],
+            Stroke::new(1.0_f32, GRID),
+        );
+    }
+    p.line_segment(
+        [
+            Pos2::new(plot.left(), plot.center().y),
+            Pos2::new(plot.right(), plot.center().y),
+        ],
+        Stroke::new(1.0_f32, EDGE),
+    );
+    if !frame.scope_valid {
+        p.text(
+            plot.center(),
+            egui::Align2::CENTER_CENTER,
+            "play a note",
+            FontId::proportional(12.),
+            DIM,
+        );
+        return;
+    }
+    let peak = frame
+        .scope
+        .iter()
+        .flatten()
+        .fold(1e-6f32, |m, v| m.max(v.abs()));
+    // The newest cycle is still being written; draw the complete ones.
+    for (age, cycle) in frame.scope[..SCOPE_CYCLES - 1].iter().enumerate() {
+        let alpha = 0.2 + 0.8 * age as f32 / (SCOPE_CYCLES - 2) as f32;
+        let color = if age == SCOPE_CYCLES - 2 {
+            ACCENT
+        } else {
+            STEEL.gamma_multiply(alpha * 0.6)
+        };
+        let points: Vec<Pos2> = cycle
+            .iter()
+            .enumerate()
+            .map(|(i, v)| {
+                Pos2::new(
+                    plot.left() + plot.width() * i as f32 / (SCOPE_POINTS - 1) as f32,
+                    plot.center().y - plot.height() * 0.48 * v / peak,
+                )
+            })
+            .collect();
+        p.add(egui::Shape::line(
+            points,
+            Stroke::new(
+                if age == SCOPE_CYCLES - 2 {
+                    2.0_f32
+                } else {
+                    1.0
+                },
+                color,
+            ),
+        ));
+    }
+}
+
+fn step_y(rect: Rect, db: f32) -> f32 {
+    rect.top() + rect.height() * (db / STEP_MIN).clamp(0., 1.)
+}
+
+/// One bar per step: drag to set its level, double-click to reset; the square below a bar
+/// switches its grit burst.
+fn pattern_editor(ui: &mut egui::Ui, settings: &mut Settings, state: &mut State, height: f32) {
+    let (outer, response) = ui.allocate_exact_size(
+        Vec2::new(ui.available_width(), height),
+        Sense::click_and_drag(),
+    );
+    let p = ui.painter_at(outer);
+    p.rect_filled(outer, 2., SCREEN);
+    p.text(
+        outer.left_top() + Vec2::new(8., 5.),
+        egui::Align2::LEFT_TOP,
+        "PATTERN: LEVEL PER CYCLE",
+        FontId::proportional(10.),
+        MUTED,
+    );
+    let bars = Rect::from_min_max(
+        outer.left_top() + Vec2::new(34., 22.),
+        Pos2::new(outer.right() - 10., outer.bottom() - 26.),
+    );
+    let toggles_y = outer.bottom() - 16.;
+    let col = bars.width() / STEPS as f32;
+    let column =
+        |x: f32| (((x - bars.left()) / col).floor() as isize).clamp(0, STEPS as isize - 1) as usize;
+    if response.hovered() {
+        state.help = "Drag a bar to set the level of that cycle; double-click resets it. The squares switch grit per step.".into();
+    }
+    if let Some(pos) = response.interact_pointer_pos() {
+        let k = column(pos.x);
+        if pos.y > bars.bottom() + 2. {
+            if response.clicked() {
+                settings.grit_steps[k] = !settings.grit_steps[k];
+            }
+        } else if response.double_clicked() {
+            settings.pattern[k] = 0.;
+        } else if response.dragged() || response.clicked() {
+            let t = ((pos.y - bars.top()) / bars.height()).clamp(0., 1.);
+            let db = t * STEP_MIN;
+            settings.pattern[k] = if db > -0.5 { 0. } else { db.round() };
+            if k >= settings.steps {
+                settings.steps = k + 1;
+            }
+        }
+    }
+    for db in [0f32, -6., -12., -18., -24.] {
+        let y = step_y(bars, db);
+        p.line_segment(
+            [Pos2::new(bars.left(), y), Pos2::new(bars.right(), y)],
+            Stroke::new(1.0_f32, GRID),
+        );
+        p.text(
+            Pos2::new(outer.left() + 6., y),
+            egui::Align2::LEFT_CENTER,
+            if db == 0. {
+                "0".into()
+            } else {
+                format!("{db:.0}")
+            },
+            FontId::proportional(10.),
+            DIM,
+        );
+    }
+    let current = state.analyzer.step;
+    let playing = state.analyzer.note.is_some();
+    for k in 0..STEPS {
+        let on = k < settings.steps;
+        let x0 = bars.left() + k as f32 * col + 3.;
+        let x1 = x0 + col - 6.;
+        let top = step_y(bars, settings.pattern[k]);
+        let color = if !on {
+            DIM.gamma_multiply(0.5)
+        } else if playing && k == current {
+            TEXT
+        } else {
+            ACCENT
+        };
+        p.rect_filled(
+            Rect::from_min_max(
+                Pos2::new(x0, top.min(bars.bottom() - 2.)),
+                Pos2::new(x1, bars.bottom()),
+            ),
+            1.,
+            color.gamma_multiply(if on { 0.85 } else { 0.4 }),
+        );
+        let grit = settings.grit_steps[k] && settings.grit > GRIT_OFF;
+        let square = Rect::from_center_size(Pos2::new((x0 + x1) / 2., toggles_y), Vec2::splat(9.));
+        if settings.grit_steps[k] {
+            p.rect_filled(square, 1., if grit && on { FOCUS } else { DIM });
+        } else {
+            p.rect_stroke(
+                square,
+                1.,
+                Stroke::new(1.0_f32, DIM),
+                egui::StrokeKind::Inside,
+            );
+        }
+    }
+    p.text(
+        Pos2::new(outer.left() + 6., toggles_y),
+        egui::Align2::LEFT_CENTER,
+        "grit",
+        FontId::proportional(10.),
+        DIM,
+    );
+}
+
+fn controls(ui: &mut egui::Ui, settings: &mut Settings, state: &mut State) {
+    let d = Settings::default();
+    ui.horizontal(|ui| {
+        caption(ui, "PATTERN");
+        for (name, help, gains) in PATTERNS {
+            let selected = settings.steps == gains.len()
+                && settings.pattern[..gains.len()]
+                    .iter()
+                    .zip(gains)
+                    .all(|(a, b)| a == b);
+            let r = ui.selectable_label(selected, RichText::new(name.to_uppercase()).size(13.));
+            if r.clicked() {
+                settings.apply_pattern(gains);
+            }
+            hint(&r, state, help);
+        }
+        ui.add_space(24.);
+        caption(ui, "STEPS");
+        let minus = ui.button(RichText::new("−").size(14.));
+        if minus.clicked() && settings.steps > 1 {
+            settings.steps -= 1;
+        }
+        ui.label(
+            RichText::new(format!("{:>2}", settings.steps))
+                .monospace()
+                .size(14.)
+                .color(TEXT),
+        );
+        let plus = ui.button(RichText::new("+").size(14.));
+        if plus.clicked() && settings.steps < STEPS {
+            settings.steps += 1;
+        }
+        let help = "Pattern length in cycles. 2 makes a sub-octave, 3 an octave and a fifth down.";
+        hint(&minus, state, help);
+        hint(&plus, state, help);
+    });
+    ui.add_space(4.);
+    ui.columns(10, |c| {
+        knob(
+            &mut c[0],
+            state,
+            "Edge",
+            &mut settings.edge,
+            5. ..=50.,
+            d.edge,
+            " %",
+            "How soft each step change is, as a share of a cycle. Low is sharper and buzzier.",
+        );
+        knob(
+            &mut c[1],
+            state,
+            "Level",
+            &mut settings.level_jitter,
+            0. ..=6.,
+            d.level_jitter,
+            " dB",
+            "Random level per cycle: a rough, living surface.",
+        );
+        knob(
+            &mut c[2],
+            state,
+            "Time",
+            &mut settings.time_jitter,
+            0. ..=10.,
+            d.time_jitter,
+            " %",
+            "Random timing per cycle, in percent of a period: rattle and scrape.",
+        );
+        knob(
+            &mut c[3],
+            state,
+            "Grit",
+            &mut settings.grit,
+            GRIT_OFF..=0.,
+            d.grit,
+            " dB",
+            "Level of the noise burst in each cycle, relative to the input. Fully left is off.",
+        );
+        knob(
+            &mut c[4],
+            state,
+            "Tone",
+            &mut settings.tone,
+            4. ..=64.,
+            d.tone,
+            " ×f0",
+            "Lowest frequency of the grit, in harmonics of the note.",
+        );
+        knob(
+            &mut c[5],
+            state,
+            "Position",
+            &mut settings.position,
+            0. ..=100.,
+            d.position,
+            " %",
+            "Where in the cycle the grit burst sits.",
+        );
+        knob(
+            &mut c[6],
+            state,
+            "Length",
+            &mut settings.length,
+            2. ..=50.,
+            d.length,
+            " %",
+            "Length of the grit burst, as a share of a cycle.",
+        );
+        knob(
+            &mut c[7],
+            state,
+            "Gate",
+            &mut settings.gate,
+            -60. ..=-20.,
+            d.gate,
+            " dB",
+            "Input level that counts as a note (AUDIO). Raise it if tails retrigger.",
+        );
+        knob(
+            &mut c[8],
+            state,
+            "Mix",
+            &mut settings.mix,
+            0. ..=100.,
+            d.mix,
+            " %",
+            "Blend with the delayed dry signal.",
+        );
+        knob(
+            &mut c[9],
+            state,
+            "Output",
+            &mut settings.output,
+            -12. ..=12.,
+            d.output,
+            " dB",
+            "Output trim.",
+        );
+    });
+}
@@ -0,0 +1,12 @@
+[package]
+name = "lathe-core"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+common-dsp = { path = "../../common/dsp" }
+serde = { workspace = true }
+
+[dev-dependencies]
+serde_json = { workspace = true }
@@ -0,0 +1,258 @@
+//! Harmonic EQ: bands sit on the harmonics of the played note instead of fixed frequencies,
+//! so a cut on harmonic 3 stays on harmonic 3 on every note.
+//!
+//! The audio path is delayed by the tracker's lookahead, so the filters are already tuned to
+//! a note when its attack leaves the plugin.
+mod settings;
+use common_dsp::meter::HarmonicMeter;
+use common_dsp::svf::{Svf, SvfCoef};
+use common_dsp::tracker::{PitchFollower, Tracker, TrackerConfig};
+use common_dsp::{coefficient, db_to_gain, hz_to_midi};
+pub use settings::{Settings, Source, GAIN_MAX, GAIN_MIN, HARMONICS};
+
+pub const MIN_HZ: f32 = TrackerConfig::BASS.min_hz;
+pub const MAX_HZ: f32 = TrackerConfig::BASS.max_hz;
+/// Harmonic bands plus the bands halfway between them.
+const BANDS: usize = 2 * HARMONICS;
+/// Filter coefficients are recomputed this often, in samples.
+const RETUNE: usize = 16;
+const GAIN_MS: f32 = 20.;
+
+#[derive(Clone, Copy, Debug)]
+pub struct AnalyzerFrame {
+    /// Fundamental the filters are tuned to, 0 before the first note.
+    pub hz: f32,
+    /// Sounding note, rounded; None between notes.
+    pub note: Option<u8>,
+    /// Harmonic levels in dBFS of the delayed input and of the output (index 0 = fundamental).
+    pub input: [f32; HARMONICS],
+    pub output: [f32; HARMONICS],
+    pub latency: u32,
+    pub sample_rate: f32,
+}
+impl Default for AnalyzerFrame {
+    fn default() -> Self {
+        Self {
+            hz: 0.,
+            note: None,
+            input: [-120.; HARMONICS],
+            output: [-120.; HARMONICS],
+            latency: 0,
+            sample_rate: 48000.,
+        }
+    }
+}
+
+pub struct Engine {
+    rate: f32,
+    channels: usize,
+    settings: Settings,
+    latency: usize,
+    delay: Vec<[f32; 2]>,
+    delay_at: usize,
+    tracker: Tracker,
+    pitch: PitchFollower,
+    hz: f32,
+    hz_coef: f32,
+    countdown: usize,
+    coefs: [SvfCoef; BANDS],
+    active: [bool; BANDS],
+    gains: [f32; BANDS],
+    state: [[Svf; BANDS]; 2],
+    gain_coef: f32,
+    smooth: f32,
+    mix: f32,
+    output: f32,
+    bypass: f32,
+    meter_in: HarmonicMeter,
+    meter_out: HarmonicMeter,
+    /// Smoothed controls start at the next settings instead of gliding from defaults.
+    fresh: bool,
+}
+
+impl Engine {
+    pub fn new(rate: f32, channels: usize) -> Result<Self, &'static str> {
+        if !(8000.0..=768000.).contains(&rate) {
+            return Err("unsupported sample rate");
+        }
+        if !(1..=2).contains(&channels) {
+            return Err("unsupported channel count");
+        }
+        let tracker = Tracker::new(rate, TrackerConfig::BASS);
+        let latency = tracker.latency();
+        let settings = Settings::default();
+        let mut e = Self {
+            rate,
+            channels,
+            settings,
+            latency,
+            delay: vec![[0.; 2]; latency + 1],
+            delay_at: 0,
+            tracker,
+            pitch: PitchFollower::default(),
+            hz: 0.,
+            hz_coef: 1.,
+            countdown: 0,
+            coefs: [SvfCoef::IDENTITY; BANDS],
+            active: [false; BANDS],
+            gains: [0.; BANDS],
+            state: [[Svf::default(); BANDS]; 2],
+            gain_coef: coefficient(rate / RETUNE as f32, GAIN_MS),
+            smooth: coefficient(rate, 10.),
+            mix: 1.,
+            output: 1.,
+            bypass: 0.,
+            meter_in: HarmonicMeter::new(rate, 85.),
+            meter_out: HarmonicMeter::new(rate, 85.),
+            fresh: true,
+        };
+        e.set_settings(settings)?;
+        e.fresh = true;
+        Ok(e)
+    }
+    pub fn latency_samples(&self) -> u32 {
+        self.latency as u32
+    }
+    pub fn channels(&self) -> usize {
+        self.channels
+    }
+    pub fn settings(&self) -> Settings {
+        self.settings
+    }
+    pub fn set_settings(&mut self, s: Settings) -> Result<(), &'static str> {
+        s.validate()?;
+        self.tracker
+            .set(s.source == Source::Midi, s.gate, s.smooth > 0.);
+        self.hz_coef = coefficient(self.rate, s.smooth / 3.);
+        self.settings = s;
+        if std::mem::take(&mut self.fresh) {
+            self.mix = s.mix * 0.01;
+            self.output = db_to_gain(s.output);
+            self.bypass = f32::from(s.bypass);
+            self.gains = self.targets();
+        }
+        Ok(())
+    }
+    pub fn reset(&mut self) {
+        self.delay.fill([0.; 2]);
+        self.tracker.reset();
+        for ch in &mut self.state {
+            for f in ch.iter_mut() {
+                f.reset();
+            }
+        }
+        self.meter_in.reset();
+        self.meter_out.reset();
+        self.countdown = 0;
+        self.fresh = true;
+    }
+    pub fn note_on(&mut self, note: u8) {
+        self.tracker.note_on(note);
+    }
+    pub fn note_off(&mut self, note: u8) {
+        self.tracker.note_off(note);
+    }
+    /// Gain targets in dB of every band for the current settings.
+    fn targets(&self) -> [f32; BANDS] {
+        let s = &self.settings;
+        let mut t = [0.; BANDS];
+        for k in 1..=s.harmonics as usize {
+            t[k - 1] = s.effective(k);
+            t[HARMONICS + k - 1] = s.between;
+        }
+        t
+    }
+    fn retune(&mut self, jump: bool) {
+        let s = self.settings;
+        let targets = self.targets();
+        let width = s.width * 0.01;
+        for b in 0..BANDS {
+            self.gains[b] = if jump {
+                targets[b]
+            } else {
+                self.gains[b] + (targets[b] - self.gains[b]) * self.gain_coef
+            };
+            if (self.gains[b] - targets[b]).abs() < 1e-4 {
+                self.gains[b] = targets[b];
+            }
+            let order = if b < HARMONICS {
+                (b + 1) as f32
+            } else {
+                (b - HARMONICS + 1) as f32 + 0.5
+            };
+            let centre = order * self.hz;
+            let audible = self.hz > 0. && centre < 0.45 * self.rate;
+            if audible && !self.active[b] {
+                for ch in &mut self.state {
+                    ch[b].reset();
+                }
+            }
+            self.active[b] = audible && self.gains[b] != 0.;
+            if self.active[b] {
+                self.coefs[b] = SvfCoef::bell(self.rate, centre, order / width, self.gains[b]);
+            }
+        }
+    }
+    pub fn process_sample(&mut self, x: [f32; 2]) -> [f32; 2] {
+        let mono = if self.channels == 2 {
+            0.5 * (x[0] + x[1])
+        } else {
+            x[0]
+        };
+        let (pitch, snap) = (&mut self.pitch, self.settings.snap);
+        self.tracker.process(mono, |e| pitch.event(snap, e));
+        let len = self.delay.len();
+        self.delay[self.delay_at] = x;
+        self.delay_at = (self.delay_at + 1) % len;
+        let y = self.delay[self.delay_at];
+
+        let first = self.hz == 0.;
+        let (hz, jump) = self.pitch.step(self.hz_coef);
+        let first = first && jump;
+        self.hz = hz;
+        if jump || self.countdown == 0 {
+            self.retune(first);
+            self.countdown = RETUNE;
+        }
+        self.countdown -= 1;
+
+        let s = self.settings;
+        self.mix += (s.mix * 0.01 - self.mix) * self.smooth;
+        self.output += (db_to_gain(s.output) - self.output) * self.smooth;
+        self.bypass += (f32::from(s.bypass) - self.bypass) * self.smooth;
+        let mut out = [0.; 2];
+        for c in 0..self.channels {
+            let mut v = y[c];
+            for b in 0..BANDS {
+                if self.active[b] {
+                    v = self.state[c][b].process(&self.coefs[b], v);
+                }
+            }
+            let wet = (self.mix * v + (1. - self.mix) * y[c]) * self.output;
+            out[c] = wet * (1. - self.bypass) + y[c] * self.bypass;
+        }
+        let hz = if self.tracker.sounding() { self.hz } else { 0. };
+        let (dry, wet) = if self.channels == 2 {
+            (0.5 * (y[0] + y[1]), 0.5 * (out[0] + out[1]))
+        } else {
+            (y[0], out[0])
+        };
+        self.meter_in.push(dry, hz);
+        self.meter_out.push(wet, hz);
+        out
+    }
+    pub fn take_analyzer(&self) -> AnalyzerFrame {
+        let mut f = AnalyzerFrame {
+            hz: self.hz,
+            latency: self.latency as u32,
+            sample_rate: self.rate,
+            input: *self.meter_in.levels(),
+            output: *self.meter_out.levels(),
+            ..AnalyzerFrame::default()
+        };
+        if self.tracker.sounding() && self.hz > 0. {
+            f.note = Some(hz_to_midi(self.hz).round().clamp(0., 127.) as u8);
+        }
+        f
+    }
+}
@@ -0,0 +1,106 @@
+//! Host-independent controls. Gains in dB, times in milliseconds.
+use serde::{Deserialize, Serialize};
+
+/// Editable harmonics: the fundamental is harmonic 1.
+pub const HARMONICS: usize = 32;
+pub const GAIN_MIN: f32 = -24.;
+pub const GAIN_MAX: f32 = 12.;
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
+pub enum Source {
+    /// Pitch and note starts are detected from the incoming bass.
+    #[default]
+    Audio,
+    /// Notes come from MIDI note input.
+    Midi,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+pub struct Settings {
+    pub source: Source,
+    /// Gain per harmonic, index 0 = fundamental.
+    pub gains: [f32; HARMONICS],
+    /// dB per octave of harmonic number, added on top of `gains`. Harmonic 1 is the pivot.
+    pub tilt: f32,
+    /// Positive lifts odd harmonics and lowers even ones by half this amount each.
+    pub odd_even: f32,
+    /// Gain of the regions halfway between harmonics: noise, beating, inharmonic grit.
+    pub between: f32,
+    /// Bandwidth of every band as a percentage of the fundamental.
+    pub width: f32,
+    /// Number of harmonics that are shaped; higher ones pass unchanged.
+    pub harmonics: u32,
+    /// Retune time when the pitch slides or bends.
+    pub smooth: f32,
+    /// Detection threshold in dBFS for note starts (Audio source).
+    pub gate: f32,
+    /// Round detected pitch to the nearest semitone.
+    pub snap: bool,
+    pub mix: f32,
+    pub output: f32,
+    pub bypass: bool,
+}
+impl Default for Settings {
+    fn default() -> Self {
+        Self {
+            source: Source::Audio,
+            gains: [0.; HARMONICS],
+            tilt: 0.,
+            odd_even: 0.,
+            between: 0.,
+            width: 20.,
+            harmonics: 24,
+            smooth: 10.,
+            gate: -42.,
+            snap: true,
+            mix: 100.,
+            output: 0.,
+            bypass: false,
+        }
+    }
+}
+impl Settings {
+    pub fn validate(&self) -> Result<(), &'static str> {
+        let finite = [
+            self.tilt,
+            self.odd_even,
+            self.between,
+            self.width,
+            self.smooth,
+            self.gate,
+            self.mix,
+            self.output,
+        ]
+        .iter()
+        .chain(self.gains.iter())
+        .all(|v| v.is_finite());
+        if !finite {
+            return Err("non-finite setting");
+        }
+        let ok = self.gains.iter().all(|g| (GAIN_MIN..=GAIN_MAX).contains(g))
+            && (-12.0..=12.).contains(&self.tilt)
+            && (-12.0..=12.).contains(&self.odd_even)
+            && (-24.0..=12.).contains(&self.between)
+            && (5.0..=50.).contains(&self.width)
+            && (8..=HARMONICS as u32).contains(&self.harmonics)
+            && (0.0..=100.).contains(&self.smooth)
+            && (-60.0..=-20.).contains(&self.gate)
+            && (0.0..=100.).contains(&self.mix)
+            && (-12.0..=12.).contains(&self.output);
+        if ok {
+            Ok(())
+        } else {
+            Err("setting out of range")
+        }
+    }
+    /// Gain applied to harmonic `k` (1-based), with tilt and odd/even included.
+    pub fn effective(&self, k: usize) -> f32 {
+        if k == 0 || k > self.harmonics as usize || k > HARMONICS {
+            return 0.;
+        }
+        let parity = if k % 2 == 1 { 0.5 } else { -0.5 };
+        (self.gains[k - 1] + self.tilt * (k as f32).log2() + self.odd_even * parity)
+            .clamp(-30., 18.)
+    }
+}
@@ -0,0 +1,139 @@
+use common_dsp::meter::HarmonicMeter;
+use common_dsp::Saw;
+use lathe_core::{Engine, Settings, Source};
+
+const RATE: f32 = 48000.;
+
+fn engine(s: Settings) -> (Engine, usize) {
+    let mut e = Engine::new(RATE, 2).unwrap();
+    e.set_settings(s).unwrap();
+    let l = e.latency_samples() as usize;
+    (e, l)
+}
+fn saw(hz: f32, seconds: f32, amp: f32) -> Vec<f32> {
+    let mut s = Saw::new(RATE, hz);
+    (0..(seconds * RATE) as usize)
+        .map(|_| s.sample() * amp)
+        .collect()
+}
+fn render(e: &mut Engine, x: &[f32]) -> Vec<f32> {
+    x.iter().map(|&v| e.process_sample([v, v])[0]).collect()
+}
+/// Harmonic levels of the last complete window of `x`.
+fn harmonics(x: &[f32], hz: f32) -> [f32; 32] {
+    let mut m = HarmonicMeter::new(RATE, 85.);
+    for &v in x {
+        m.push(v, hz);
+    }
+    *m.levels()
+}
+
+#[test]
+fn a_cut_on_harmonic_three_stays_on_harmonic_three_on_every_note() {
+    let mut s = Settings::default();
+    s.gains[2] = -12.;
+    for hz in [43.65, 65.41, 130.81] {
+        let x = saw(hz, 1., 0.5);
+        let (mut e, l) = engine(s);
+        let y = render(&mut e, &x);
+        let a = harmonics(&x[..x.len() - l], hz);
+        let b = harmonics(&y[l..], hz);
+        let d: Vec<f32> = (0..6).map(|k| b[k] - a[k]).collect();
+        assert!((d[2] + 12.).abs() < 0.7, "{hz}: {d:?}");
+        for k in [0, 1, 3, 4] {
+            assert!(d[k].abs() < 1., "{hz} harmonic {}: {d:?}", k + 1);
+        }
+    }
+}
+
+#[test]
+fn a_flat_map_passes_the_delayed_input_exactly() {
+    let x = saw(55., 0.5, 0.5);
+    let (mut e, l) = engine(Settings::default());
+    let y = render(&mut e, &x);
+    for i in l..x.len() {
+        assert_eq!(y[i], x[i - l]);
+    }
+}
+
+#[test]
+fn odd_even_balances_the_harmonic_series() {
+    let s = Settings {
+        odd_even: 6.,
+        ..Settings::default()
+    };
+    let hz = 55.;
+    let x = saw(hz, 1., 0.5);
+    let (mut e, l) = engine(s);
+    let y = render(&mut e, &x);
+    let a = harmonics(&x[..x.len() - l], hz);
+    let b = harmonics(&y[l..], hz);
+    for k in 1..8 {
+        let want = if k % 2 == 1 { 3. } else { -3. };
+        let got = b[k - 1] - a[k - 1];
+        assert!((got - want).abs() < 0.8, "harmonic {k}: {got}");
+    }
+}
+
+#[test]
+fn note_changes_do_not_click() {
+    let mut s = Settings::default();
+    s.gains[1] = 12.;
+    s.gains[3] = -24.;
+    s.tilt = -3.;
+    let mut x = saw(43.65, 0.5, 0.5);
+    x.extend(saw(58.27, 0.5, 0.5));
+    x.extend(saw(87.31, 0.5, 0.5));
+    let (mut e, _) = engine(s);
+    let y = render(&mut e, &x);
+    let step = y
+        .windows(2)
+        .map(|w| (w[1] - w[0]).abs())
+        .fold(0f32, f32::max);
+    let in_step = x
+        .windows(2)
+        .map(|w| (w[1] - w[0]).abs())
+        .fold(0f32, f32::max);
+    assert!(y.iter().all(|v| v.is_finite()));
+    // A saw has its own jumps; the filtered output must not jump much further than that.
+    assert!(step < 2. * in_step, "{step} vs {in_step}");
+}
+
+#[test]
+fn midi_source_tunes_the_bands_at_the_delayed_note_time() {
+    let mut s = Settings {
+        source: Source::Midi,
+        ..Settings::default()
+    };
+    s.gains[0] = -24.;
+    let (mut e, l) = engine(s);
+    // 43.65 Hz is MIDI 29. Notes arrive at sample 0; the bands must be tuned by sample l.
+    e.note_on(29);
+    let x = saw(43.65, 1., 0.5);
+    let y = render(&mut e, &x);
+    let a = harmonics(&x[..x.len() - l], 43.65);
+    let b = harmonics(&y[l..], 43.65);
+    assert!(b[0] - a[0] < -20., "{}", b[0] - a[0]);
+    let f = e.take_analyzer();
+    assert_eq!(f.note, Some(29));
+    assert!((f.hz - 43.65).abs() < 0.05);
+}
+
+#[test]
+fn settings_are_validated_and_serialise() {
+    let s = Settings::default();
+    let json = serde_json::to_string(&s).unwrap();
+    assert_eq!(serde_json::from_str::<Settings>(&json).unwrap(), s);
+    let mut bad = s;
+    bad.gains[5] = 40.;
+    assert!(bad.validate().is_err());
+    bad = s;
+    bad.harmonics = 4;
+    assert!(bad.validate().is_err());
+    bad = s;
+    bad.width = f32::NAN;
+    assert!(bad.validate().is_err());
+    let mut e = Engine::new(RATE, 2).unwrap();
+    assert!(e.set_settings(bad).is_err());
+    assert_eq!(e.settings(), s);
+}
@@ -0,0 +1,69 @@
+use lathe_core::{Engine, Settings, Source};
+use std::{
+    alloc::{GlobalAlloc, Layout, System},
+    cell::Cell,
+};
+
+struct CheckedAllocator;
+thread_local! {
+    static CHECK:Cell<bool>=const {Cell::new(false)};
+    static OPERATIONS:Cell<usize>=const {Cell::new(0)};
+}
+fn record() {
+    if CHECK.try_with(Cell::get).unwrap_or(false) {
+        let _ = OPERATIONS.try_with(|n| n.set(n.get() + 1));
+    }
+}
+unsafe impl GlobalAlloc for CheckedAllocator {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        record();
+        unsafe { System.alloc(layout) }
+    }
+    unsafe fn dealloc(&self, pointer: *mut u8, layout: Layout) {
+        record();
+        unsafe { System.dealloc(pointer, layout) }
+    }
+    unsafe fn realloc(&self, pointer: *mut u8, layout: Layout, size: usize) -> *mut u8 {
+        record();
+        unsafe { System.realloc(pointer, layout, size) }
+    }
+}
+#[global_allocator]
+static ALLOCATOR: CheckedAllocator = CheckedAllocator;
+
+#[test]
+fn processing_notes_settings_and_analysis_do_not_allocate_or_free() {
+    let mut engine = Engine::new(48000., 2).unwrap();
+    let mut settings = Settings::default();
+    engine.set_settings(settings).unwrap();
+    CHECK.with(|v| v.set(true));
+    for i in 0..96000 {
+        if i % 4800 == 0 {
+            settings.gains[(i / 4800) % 32] = -6.;
+            settings.tilt = ((i / 4800) % 5) as f32 - 2.;
+            settings.source = if i > 48000 {
+                Source::Midi
+            } else {
+                Source::Audio
+            };
+            engine.set_settings(settings).unwrap();
+            engine.note_on(30 + (i / 4800 % 12) as u8);
+        }
+        if i % 4800 == 2400 {
+            engine.note_off(30 + (i / 4800 % 12) as u8);
+        }
+        let t = i as f32 / 48000.;
+        let x = if (i / 2400) % 2 == 0 {
+            (std::f32::consts::TAU * 55. * t).sin() * 0.5
+        } else {
+            0.
+        };
+        std::hint::black_box(engine.process_sample([x, x]));
+        if i % 1600 == 0 {
+            std::hint::black_box(engine.take_analyzer());
+        }
+    }
+    engine.reset();
+    CHECK.with(|v| v.set(false));
+    assert_eq!(OPERATIONS.with(Cell::get), 0);
+}
@@ -0,0 +1,25 @@
+[package]
+name = "lathe"
+version = "0.2.0"
+edition = "2021"
+license = "ISC"
+
+[workspace]
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+nih_plug = { git = "https://github.com/robbert-vdh/nih-plug.git", rev = "de421011f41a6d10fc8c7a6084e4f4dee0143683", default-features = false }
+nih_plug_egui = { git = "https://github.com/robbert-vdh/nih-plug.git", rev = "de421011f41a6d10fc8c7a6084e4f4dee0143683" }
+lathe-core = { path = "../core" }
+lathe-ui = { path = "../ui" }
+crossbeam-queue = "0.3"
+
+[dev-dependencies]
+clap-sys = { git = "https://github.com/micahrj/clap-sys.git", rev = "25d7f53fdb6363ad63fbd80049cb7a42a97ac156" }
+serde_json = "1"
+
+[profile.release]
+lto = "thin"
+strip = "symbols"
@@ -0,0 +1,189 @@
+//! CLAP audio effect. All DSP state is owned by the processing thread.
+mod params;
+use crossbeam_queue::ArrayQueue;
+use lathe_core::{AnalyzerFrame, Engine, HARMONICS};
+use nih_plug::prelude::*;
+use nih_plug_egui::{create_egui_editor, egui};
+use params::LatheParams;
+use std::sync::Arc;
+
+struct EditorData {
+    ui: lathe_ui::State,
+    gestures: [bool; 8],
+}
+pub struct Lathe {
+    params: Arc<LatheParams>,
+    analyzer: Arc<ArrayQueue<AnalyzerFrame>>,
+    engine: Option<Engine>,
+    gains: [f32; HARMONICS],
+    publish_count: usize,
+    publish_interval: usize,
+}
+impl Default for Lathe {
+    fn default() -> Self {
+        Self {
+            params: Arc::new(LatheParams::default()),
+            analyzer: Arc::new(ArrayQueue::new(2)),
+            engine: None,
+            gains: [0.; HARMONICS],
+            publish_count: 0,
+            publish_interval: 1600,
+        }
+    }
+}
+impl Plugin for Lathe {
+    const NAME: &'static str = "Lathe";
+    const VENDOR: &'static str = "Bass Foundry";
+    const URL: &'static str = "";
+    const EMAIL: &'static str = "";
+    const VERSION: &'static str = env!("CARGO_PKG_VERSION");
+    const AUDIO_IO_LAYOUTS: &'static [AudioIOLayout] = &[
+        AudioIOLayout {
+            main_input_channels: NonZeroU32::new(2),
+            main_output_channels: NonZeroU32::new(2),
+            ..AudioIOLayout::const_default()
+        },
+        AudioIOLayout {
+            main_input_channels: NonZeroU32::new(1),
+            main_output_channels: NonZeroU32::new(1),
+            ..AudioIOLayout::const_default()
+        },
+    ];
+    const MIDI_INPUT: MidiConfig = MidiConfig::Basic;
+    const SAMPLE_ACCURATE_AUTOMATION: bool = false;
+    type SysExMessage = ();
+    type BackgroundTask = ();
+    fn params(&self) -> Arc<dyn Params> {
+        self.params.clone()
+    }
+    fn editor(&mut self, _: AsyncExecutor<Self>) -> Option<Box<dyn Editor>> {
+        let params = self.params.clone();
+        let analyzer = self.analyzer.clone();
+        create_egui_editor(
+            params.editor.clone(),
+            EditorData {
+                ui: lathe_ui::State::default(),
+                gestures: [false; 8],
+            },
+            |ctx, _| lathe_ui::style(ctx),
+            move |ctx, setter, data| {
+                while let Some(frame) = analyzer.pop() {
+                    data.ui.accept_frame(frame);
+                }
+                let current = params.gains.read().map(|g| *g).unwrap_or([0.; HARMONICS]);
+                let before = params.settings(&current);
+                let mut edited = before;
+                nih_plug_egui::resizable_window::ResizableWindow::new("lathe-editor")
+                    .min_size(egui::vec2(
+                        lathe_ui::WIDTH as f32 - 80.,
+                        lathe_ui::HEIGHT as f32 - 40.,
+                    ))
+                    .show(ctx, &params.editor, |ui| {
+                        lathe_ui::show(ui, &mut edited, &mut data.ui)
+                    });
+                params.apply(
+                    setter,
+                    &before,
+                    &edited,
+                    data.ui.gesture_active,
+                    &mut data.gestures,
+                );
+                // Harmonic levels follow the audio.
+                ctx.request_repaint_after(std::time::Duration::from_millis(40));
+            },
+        )
+    }
+    fn initialize(
+        &mut self,
+        layout: &AudioIOLayout,
+        config: &BufferConfig,
+        context: &mut impl InitContext<Self>,
+    ) -> bool {
+        let Ok(mut engine) = Engine::new(
+            config.sample_rate,
+            layout.main_input_channels.map_or(0, |v| v.get() as usize),
+        ) else {
+            return false;
+        };
+        let settings = self.params.settings(&self.gains);
+        self.gains = settings.gains;
+        if engine.set_settings(settings).is_err() {
+            return false;
+        }
+        context.set_latency_samples(engine.latency_samples());
+        self.publish_interval = (config.sample_rate / 30.) as usize;
+        self.engine = Some(engine);
+        true
+    }
+    fn reset(&mut self) {
+        if let Some(e) = self.engine.as_mut() {
+            e.reset();
+        }
+        self.publish_count = 0;
+    }
+    fn process(
+        &mut self,
+        buffer: &mut Buffer,
+        _: &mut AuxiliaryBuffers,
+        context: &mut impl ProcessContext<Self>,
+    ) -> ProcessStatus {
+        let Some(engine) = self.engine.as_mut() else {
+            return ProcessStatus::Normal;
+        };
+        let settings = self.params.settings(&self.gains);
+        self.gains = settings.gains;
+        let _ = engine.set_settings(settings);
+        let mut next = context.next_event();
+        for (index, mut sample) in buffer.iter_samples().enumerate() {
+            while let Some(event) = next {
+                if event.timing() as usize > index {
+                    break;
+                }
+                match event {
+                    NoteEvent::NoteOn { note, velocity, .. } if velocity > 0. => {
+                        engine.note_on(note)
+                    }
+                    NoteEvent::NoteOn { note, .. } | NoteEvent::NoteOff { note, .. } => {
+                        engine.note_off(note)
+                    }
+                    NoteEvent::Choke { note, .. } => engine.note_off(note),
+                    _ => {}
+                }
+                next = context.next_event();
+            }
+            let x = [
+                *sample.get_mut(0).unwrap(),
+                if engine.channels() == 2 {
+                    *sample.get_mut(1).unwrap()
+                } else {
+                    0.
+                },
+            ];
+            let out = engine.process_sample(x);
+            for (c, value) in sample.into_iter().enumerate() {
+                *value = out[c];
+            }
+            self.publish_count += 1;
+            if self.publish_count >= self.publish_interval {
+                self.analyzer.force_push(engine.take_analyzer());
+                self.publish_count = 0;
+            }
+        }
+        // The lookahead delay and filter tails must drain after input stops.
+        ProcessStatus::KeepAlive
+    }
+}
+impl ClapPlugin for Lathe {
+    const CLAP_ID: &'static str = "io.narl.bass-foundry.lathe";
+    const CLAP_DESCRIPTION: Option<&'static str> =
+        Some("EQ the harmonics of the played note: a cut on harmonic 3 stays on harmonic 3");
+    const CLAP_MANUAL_URL: Option<&'static str> = None;
+    const CLAP_SUPPORT_URL: Option<&'static str> = None;
+    const CLAP_FEATURES: &'static [ClapFeature] = &[
+        ClapFeature::AudioEffect,
+        ClapFeature::Equalizer,
+        ClapFeature::Stereo,
+        ClapFeature::Mono,
+    ];
+}
+nih_export_clap!(Lathe);
@@ -0,0 +1,186 @@
+use lathe_core::{Settings, Source, HARMONICS};
+use nih_plug::prelude::*;
+use nih_plug_egui::EguiState;
+use std::sync::{Arc, RwLock};
+
+#[derive(Enum, Debug, PartialEq, Eq, Clone, Copy)]
+pub enum SourceParam {
+    #[id = "audio"]
+    Audio,
+    #[id = "midi"]
+    #[name = "MIDI"]
+    Midi,
+}
+fn linear(name: &str, v: f32, min: f32, max: f32, unit: &'static str) -> FloatParam {
+    FloatParam::new(name, v, FloatRange::Linear { min, max }).with_unit(unit)
+}
+/// Continuous controls, in the order of the gesture slots.
+const FLOATS: usize = 8;
+
+#[derive(Params)]
+pub struct LatheParams {
+    #[persist = "editor"]
+    pub editor: Arc<EguiState>,
+    /// Drawn per-harmonic gains. Saved with the project, not exposed as automation lanes.
+    #[persist = "lathe-gains"]
+    pub gains: RwLock<[f32; HARMONICS]>,
+    #[id = "source"]
+    pub source: EnumParam<SourceParam>,
+    #[id = "tilt"]
+    pub tilt: FloatParam,
+    #[id = "odd-even"]
+    pub odd_even: FloatParam,
+    #[id = "between"]
+    pub between: FloatParam,
+    #[id = "width"]
+    pub width: FloatParam,
+    #[id = "smooth"]
+    pub smooth: FloatParam,
+    #[id = "gate"]
+    pub gate: FloatParam,
+    #[id = "mix"]
+    pub mix: FloatParam,
+    #[id = "output"]
+    pub output: FloatParam,
+    #[id = "harmonics"]
+    pub harmonics: IntParam,
+    #[id = "snap"]
+    pub snap: BoolParam,
+    #[id = "bypass"]
+    pub bypass: BoolParam,
+}
+impl Default for LatheParams {
+    fn default() -> Self {
+        let d = Settings::default();
+        Self {
+            editor: EguiState::from_size(lathe_ui::WIDTH, lathe_ui::HEIGHT),
+            gains: RwLock::new(d.gains),
+            source: EnumParam::new("Pitch source", SourceParam::Audio),
+            tilt: linear("Tilt", d.tilt, -12., 12., " dB/oct"),
+            odd_even: linear("Odd/Even", d.odd_even, -12., 12., " dB"),
+            between: linear("Between", d.between, -24., 12., " dB"),
+            width: linear("Width", d.width, 5., 50., " %"),
+            smooth: linear("Smooth", d.smooth, 0., 100., " ms"),
+            gate: linear("Gate", d.gate, -60., -20., " dB"),
+            mix: linear("Mix", d.mix, 0., 100., " %"),
+            output: linear("Output", d.output, -12., 12., " dB"),
+            harmonics: IntParam::new(
+                "Harmonics",
+                d.harmonics as i32,
+                IntRange::Linear {
+                    min: 8,
+                    max: HARMONICS as i32,
+                },
+            ),
+            snap: BoolParam::new("Snap to semitone", d.snap),
+            bypass: BoolParam::new("Bypass", false).make_bypass(),
+        }
+    }
+}
+impl LatheParams {
+    /// Current settings. `gains` falls back to `last` when the editor holds the lock, so the
+    /// audio thread never waits.
+    pub fn settings(&self, last: &[f32; HARMONICS]) -> Settings {
+        let gains = self.gains.try_read().map(|g| *g).unwrap_or(*last);
+        Settings {
+            source: match self.source.value() {
+                SourceParam::Audio => Source::Audio,
+                SourceParam::Midi => Source::Midi,
+            },
+            gains: gains.map(|g| {
+                if g.is_finite() {
+                    g.clamp(lathe_core::GAIN_MIN, lathe_core::GAIN_MAX)
+                } else {
+                    0.
+                }
+            }),
+            tilt: self.tilt.value(),
+            odd_even: self.odd_even.value(),
+            between: self.between.value(),
+            width: self.width.value(),
+            harmonics: self.harmonics.value() as u32,
+            smooth: self.smooth.value(),
+            gate: self.gate.value(),
+            snap: self.snap.value(),
+            mix: self.mix.value(),
+            output: self.output.value(),
+            bypass: self.bypass.value(),
+        }
+    }
+    fn floats(&self) -> [&FloatParam; FLOATS] {
+        [
+            &self.tilt,
+            &self.odd_even,
+            &self.between,
+            &self.width,
+            &self.smooth,
+            &self.gate,
+            &self.mix,
+            &self.output,
+        ]
+    }
+    /// Pushes every changed editor value to the host. Continuous controls hold one gesture
+    /// while the pointer is down; switches are set in a single gesture. Gains are stored
+    /// directly.
+    pub fn apply(
+        &self,
+        setter: &ParamSetter,
+        old: &Settings,
+        new: &Settings,
+        dragging: bool,
+        open: &mut [bool; FLOATS],
+    ) {
+        if new.gains != old.gains {
+            if let Ok(mut g) = self.gains.write() {
+                *g = new.gains;
+            }
+        }
+        let values = [
+            (old.tilt, new.tilt),
+            (old.odd_even, new.odd_even),
+            (old.between, new.between),
+            (old.width, new.width),
+            (old.smooth, new.smooth),
+            (old.gate, new.gate),
+            (old.mix, new.mix),
+            (old.output, new.output),
+        ];
+        for (i, (p, (a, b))) in self.floats().into_iter().zip(values).enumerate() {
+            if a != b {
+                if !open[i] {
+                    open[i] = true;
+                    setter.begin_set_parameter(p);
+                }
+                setter.set_parameter(p, b);
+            }
+            if !dragging && open[i] {
+                setter.end_set_parameter(p);
+                open[i] = false;
+            }
+        }
+        if new.harmonics != old.harmonics {
+            setter.begin_set_parameter(&self.harmonics);
+            setter.set_parameter(&self.harmonics, new.harmonics as i32);
+            setter.end_set_parameter(&self.harmonics);
+        }
+        for (p, a, b) in [
+            (&self.snap, old.snap, new.snap),
+            (&self.bypass, old.bypass, new.bypass),
+        ] {
+            if a != b {
+                setter.begin_set_parameter(p);
+                setter.set_parameter(p, b);
+                setter.end_set_parameter(p);
+            }
+        }
+        if new.source != old.source {
+            let v = match new.source {
+                Source::Audio => SourceParam::Audio,
+                Source::Midi => SourceParam::Midi,
+            };
+            setter.begin_set_parameter(&self.source);
+            setter.set_parameter(&self.source, v);
+            setter.end_set_parameter(&self.source);
+        }
+    }
+}
Author	SHA1	Message	Date
nvrl	444b9d93da	feat!: change CLAP IDs to io.narl.bass-foundry.<product>, release all plugins Check and Windows preview / check (anvil) (push) Successful in 2m11s Details Check and Windows preview / check (crucible) (push) Successful in 1m43s Details Check and Windows preview / check (knurl) (push) Successful in 1m37s Details Check and Windows preview / check (lathe) (push) Successful in 1m39s Details Check and Windows preview / check (patina) (push) Successful in 2m25s Details Check and Windows preview / check (rivet) (push) Successful in 1m50s Details Check and Windows preview / check (temper) (push) Successful in 1m45s Details Check and Windows preview / check (weld) (push) Successful in 3m9s Details Check and Windows preview / previews (push) Successful in 1m50s Details Check and Windows preview / windows (push) Successful in 2m46s Details Independent plugin release / publish (push) Successful in 9s Details Independent plugin release / plan (push) Successful in 8s Details Independent plugin release / build (push) Successful in 2m10s Details The io.storyboard.* IDs were a leftover from Motif Storyboard and named old functions (motif, sub-anchor, layer-align) instead of the products. Every plugin now uses io.narl.bass-foundry.<product>, and IDs are frozen from here on, even across renames. Hosts see the new IDs as different plugins: delete the old .clap files, rescan, and add the plugins again in existing projects. Rivet session JSON and Patina parameter IDs are unchanged. - Rivet 0.5.0, Patina 0.3.0; Anvil, Crucible, Lathe, Temper, Weld and Knurl 0.2.0. - Docs, changelogs and the release table describe the change. - Website: upgrade note in the Install section.	2026-11-06 11:51:11 +01:00
nvrl	7e1776bb04	feat(website): add the fl.narl.io site Check and Windows preview / check (anvil) (push) Successful in 49s Details Check and Windows preview / check (crucible) (push) Successful in 48s Details Check and Windows preview / check (knurl) (push) Successful in 40s Details Check and Windows preview / check (lathe) (push) Successful in 41s Details Check and Windows preview / check (patina) (push) Successful in 56s Details Check and Windows preview / check (rivet) (push) Successful in 45s Details Check and Windows preview / check (temper) (push) Successful in 43s Details Check and Windows preview / check (weld) (push) Successful in 1m20s Details Check and Windows preview / previews (push) Successful in 1m15s Details Check and Windows preview / windows (push) Successful in 2m31s Details Astro site for the suite: a home page with the plugin cards, install steps, principles, the metalwork names and the ideas on the bench, one page per plugin, and the Impressum and privacy policy. Plugin names, versions, download links and editor previews come from the catalog, the wrapper manifests and docs/*/assets at build time. Served by unprivileged nginx in Docker behind Traefik on fl.narl.io, the same setup as proton.narl.io: no access logs, CSP 'self', no JavaScript, legal pages filled from the environment at start.	2026-11-06 11:30:12 +01:00
nvrl	5cc3770737	feat(knurl): add Knurl cycle texture Check and Windows preview / check (anvil) (push) Successful in 2m1s Details Check and Windows preview / check (crucible) (push) Successful in 1m31s Details Check and Windows preview / check (knurl) (push) Successful in 2m4s Details Check and Windows preview / check (lathe) (push) Successful in 1m27s Details Check and Windows preview / check (patina) (push) Successful in 1m54s Details Check and Windows preview / check (rivet) (push) Successful in 1m30s Details Check and Windows preview / check (temper) (push) Successful in 1m31s Details Check and Windows preview / check (weld) (push) Successful in 2m31s Details Check and Windows preview / previews (push) Successful in 1m26s Details Independent plugin release / plan (push) Successful in 7s Details Check and Windows preview / windows (push) Successful in 2m26s Details Independent plugin release / build (push) Successful in 3m0s Details Independent plugin release / publish (push) Successful in 8s Details Knurl follows the played note and treats every cycle of the wave on its own: a repeating level pattern over 1-16 cycles makes subharmonics in tune with every note, random level and timing per cycle add rattle, and a noise burst per cycle, highpassed at a multiple of f0, adds grit. Amounts are counted in cycles, so the texture is the same on F1 and on C2. - Cycle clock from the shared note tracker, restarted at each note; the audio is delayed by the lookahead plus 4.2 ms of timing-jitter headroom. - Per-cycle randomness from a hash of the cycle number: Same every note or Free. - Patterns Off, Double, Triple, Fry (default), Gallop, Stutter or drawn; grit switchable per step. Pattern persisted as knurl-pattern. - Editor: last eight cycles overlaid, pattern bars with the playing step. - Tests match the prototype: Double gives f0/2 at -8.19 dB, Triple f0/3 at -10.68 dB, equal on F1 and C2, no added clicks, bit-exact when off, no allocation on the audio thread.	2026-11-06 08:49:11 +01:00
nvrl	f4c0a833e6	ci: check editor-check formatting in the product check Check and Windows preview / check (anvil) (push) Successful in 39s Details Check and Windows preview / check (crucible) (push) Successful in 44s Details Check and Windows preview / check (lathe) (push) Successful in 40s Details Check and Windows preview / check (patina) (push) Successful in 55s Details Check and Windows preview / check (rivet) (push) Successful in 46s Details Check and Windows preview / check (temper) (push) Successful in 44s Details Check and Windows preview / check (weld) (push) Successful in 1m18s Details Check and Windows preview / previews (push) Successful in 55s Details Check and Windows preview / windows (push) Successful in 1m24s Details Every product adds a fixture to tools/editor-check, but only the CI previews job checked its formatting, so an unformatted fixture passed the local product check and failed CI.	2026-11-06 08:34:14 +01:00
nvrl	9b3ddeaf56	feat(weld): phase alignment for layered bass, release 0.1.0 Check and Windows preview / check (anvil) (push) Successful in 2m0s Details Check and Windows preview / check (crucible) (push) Successful in 1m29s Details Check and Windows preview / check (lathe) (push) Successful in 1m27s Details Check and Windows preview / check (patina) (push) Successful in 1m53s Details Check and Windows preview / check (rivet) (push) Successful in 1m29s Details Check and Windows preview / check (temper) (push) Successful in 1m29s Details Check and Windows preview / check (weld) (push) Successful in 2m38s Details Check and Windows preview / previews (push) Successful in 1m28s Details Independent plugin release / plan (push) Successful in 8s Details Check and Windows preview / windows (push) Successful in 3m14s Details Independent plugin release / build (push) Successful in 3m50s Details Independent plugin release / publish (push) Successful in 9s Details Weld hears the other bass layer through the sidechain and fits polarity plus up to four RBJ allpass sections to the measured cross-spectrum, so the layers sum instead of cancelling. No latency; the layer on its own keeps its sound. - Worker thread: Welch cross-spectrum and coherence, Nelder-Mead fit with 1/f weighting, a per-band loss penalty and model selection by share of the achievable gain; GCC-PHAT lag detection flags a late layer. - Audio thread: allocation-free chain with a 40 ms warm-up and 40 ms crossfade per new fit; mono blocks go to the worker through a lock-free queue. - Follow / Learn / Hold; the fit is persisted and restored without a crossfade. - Editor: per-band loss and recovery against a perfect alignment, phase before and after, recovered dB, time offset and status. - Tests for flat magnitude, crossfade, fit targets, Follow hysteresis, Learn, silence, realtime allocation and the persisted fit in the host.	2026-11-06 08:31:41 +01:00
nvrl	0a0917ac56	chore: rename the suite to Bass Foundry Check and Windows preview / check (anvil) (push) Successful in 2m5s Details Check and Windows preview / check (crucible) (push) Successful in 2m11s Details Check and Windows preview / check (lathe) (push) Successful in 2m22s Details Check and Windows preview / check (patina) (push) Successful in 2m50s Details Check and Windows preview / check (rivet) (push) Successful in 46s Details Check and Windows preview / check (temper) (push) Successful in 41s Details Check and Windows preview / check (weld) (push) Successful in 39s Details Check and Windows preview / previews (push) Failing after 24s Details Check and Windows preview / windows (push) Skipped Details Set the CLAP vendor of all seven plugins to "Bass Foundry" and name the combined preview ZIP bass-foundry-windows-x86_64.zip. CLAP IDs and saved state stay unchanged. Bring development.md and releases.md up to date with all seven products, the shared crates, the test types, the steps to add a product and the published releases. Add texture problems and seven texture plugin ideas to ideas.md.	2026-11-06 08:01:02 +01:00
nvrl	6a4ec3d372	docs: rework the main README Check and Windows preview / check (patina) (push) Successful in 2m8s Details Check and Windows preview / check (anvil) (push) Successful in 2m1s Details Check and Windows preview / check (crucible) (push) Successful in 1m32s Details Check and Windows preview / check (lathe) (push) Successful in 1m26s Details Check and Windows preview / check (rivet) (push) Successful in 2m40s Details Check and Windows preview / check (temper) (push) Successful in 2m7s Details Check and Windows preview / check (weld) (push) Successful in 2m4s Details Check and Windows preview / previews (push) Failing after 24s Details Check and Windows preview / windows (push) Skipped Details Name the suite, add a plugin table with placement and latency, an editor gallery, install and build steps, the CI quality checks, the repository layout and the release flow. List Weld as in development.	2026-11-06 07:53:35 +01:00
nvrl	e3286f9094	feat(weld): add sidechain test build Weld will phase-align a bass layer to another layer it hears through the sidechain. This first build only checks that FL Studio delivers the sidechain to a CLAP aux port: it passes the main layer through unchanged, meters the sidechain and offers Layer/Sum/Sum dry listening. No latency.	2026-11-06 07:53:20 +01:00
nvrl	b3ebe4d952	feat: add Lathe harmonic EQ and Temper tracked distortion Check and Windows preview / check (anvil) (push) Successful in 2m8s Details Check and Windows preview / check (crucible) (push) Successful in 1m32s Details Check and Windows preview / check (lathe) (push) Successful in 2m13s Details Check and Windows preview / check (patina) (push) Successful in 2m5s Details Check and Windows preview / check (rivet) (push) Successful in 1m34s Details Check and Windows preview / check (temper) (push) Successful in 2m12s Details Check and Windows preview / previews (push) Successful in 1m19s Details Check and Windows preview / windows (push) Successful in 2m13s Details Independent plugin release / publish (push) Successful in 8s Details Independent plugin release / plan (push) Successful in 6s Details Independent plugin release / build (push) Successful in 2m57s Details Lathe places EQ bands on harmonics 1-32 of the played note, so a cut on harmonic 3 stays on harmonic 3 on every note. Temper normalises each note's level before an oversampled shaper and tunes its floor, push and bright filters to the note, so every note distorts the same. The note tracker moves from Anvil into common-dsp, together with a state-variable filter, 4x oversampler and harmonic meter. Anvil's behaviour and editor render are unchanged. docs/ideas.md collects all plugin ideas and their status.	2026-11-06 06:08:51 +01:00
nvrl	f36ff0780c	feat: add Anvil sub anchor and Crucible resampler Check and Windows preview / check (anvil) (push) Successful in 2m41s Details Check and Windows preview / check (crucible) (push) Successful in 2m7s Details Check and Windows preview / check (patina) (push) Successful in 2m5s Details Check and Windows preview / check (rivet) (push) Successful in 1m33s Details Check and Windows preview / previews (push) Successful in 1m10s Details Check and Windows preview / windows (push) Successful in 2m2s Details Independent plugin release / publish (push) Successful in 8s Details Independent plugin release / plan (push) Successful in 7s Details Independent plugin release / build (push) Successful in 3m3s Details Two new CLAP effects aimed at riddim and dubstep production, plus shared crates so all four plugins keep one look and reuse DSP. Anvil 0.1.0 (io.storyboard.sub-anchor): - Replaces the band below Split with a clean mono sine. Every note gets the same peak level and restarts at the same phase, so switch-ups keep their weight and kick hits line up. - Pitch and note starts come from the audio (YIN, 80 ms lookahead reported to the host) or from MIDI notes sent to the effect. - Dynamics, Drive, Octave, Glide, Phase, Gate and Keep; Solo sub monitor, note readout, level meters and a low-band oscilloscope. Crucible 0.1.0 (io.storyboard.resampler): - Records its input continuously in a lock-free ring with host transport markers. Capture takes the newest 1-16 complete bars on the bar grid, following tempo changes, or the newest audio when stopped. - Grid (straight and triplet) or transient slicing, manual cuts, slice audition without audio-thread allocation. - Export writes the loop, trimmed, declicked and normalised slices named and tagged with their root note, and an optional 2048-sample wavetable for Serum and Vital. Shared: - common-ui holds the palette, fonts, knobs and panels taken from Patina; Patina renders identically. Rotary knobs at their minimum no longer tessellate a zero-length arc into NaN vertices. - common-dsp holds biquads, a Linkwitz-Riley crossover, YIN, note helpers and a float WAV writer with sampler root and Serum frame chunks. - Catalog, CI matrix, release tags, editor previews and docs cover both plugins; a script test keeps the catalog and workflows in step.	2026-11-06 03:22:00 +01:00
nvrl	f1366280ff	feat(rivet): storyboard composition with flexible lengths and meters Check and Windows preview / check (patina) (push) Successful in 3m59s Details Check and Windows preview / check (rivet) (push) Successful in 2m2s Details Check and Windows preview / previews (push) Successful in 1m8s Details Independent plugin release / plan (push) Successful in 7s Details Check and Windows preview / windows (push) Successful in 2m41s Details Independent plugin release / build (push) Successful in 3m0s Details Independent plugin release / publish (push) Successful in 9s Details Rivet 0.4.0 tells a motif as a story. A timeline of blocks with roles (statement, answer, departure, return, rest) replaces tasks, pins and branches. Rivet writes each block from a motif and joins the seams with a cut, breath, pickup or approach. - Motifs of 1-8 bars in a bin of 16; storyboards up to 32 bars. - Meters 2/4, 3/4, 4/4, 5/4, 6/8, 7/8 and 12/8 for import, writing, audition and export. Phrygian, harmonic minor and Mixolydian scales. - Per-block options, Another take and Keep; templates for new boards. - Editor rebuilt: motif bin, timeline, large piano roll, inspector, tabs for generation, harmony and sound roles, 32-step undo/redo. - Sessions from 0.1-0.3 open as a storyboard from their source motif.	2026-11-06 02:15:18 +01:00
nvrl	abd37fd4fe	ci: cache Rust toolchain, registry and build directories Every Rust job restores the stable toolchain, Cargo registry and its own target directories from the runner cache. Keys combine the ISO week and all Cargo.lock files, so dependencies are reused across pushes while stale build output and old toolchains expire weekly. Release jobs keep separate entries per plugin.	2026-11-06 01:43:17 +01:00
nvrl	17c6fe3ab9	feat(patina): rebuild resonance detector, simplify controls, new look Check and Windows preview / check (patina) (push) Successful in 1m48s Details Check and Windows preview / check (rivet) (push) Successful in 1m26s Details Check and Windows preview / previews (push) Successful in 55s Details Independent plugin release / plan (push) Successful in 7s Details Check and Windows preview / windows (push) Successful in 1m41s Details Independent plugin release / build (push) Successful in 2m28s Details Independent plugin release / publish (push) Successful in 7s Details Patina 0.2.0. The old detector compared raw FFT bins with a one-octave dB mean, so every harmonic of a tonal sound looked like a resonance and real harsh bumps were barely touched. The new detector: - averages power over each log band and smooths it over time - joins harmonic tops into an envelope, smoothed by Sharpness - compares it with a robust, tilt-aware local line fit that ignores empty regions and cannot be lifted by the bump itself Six overlapping controls become Depth, Sharpness and Selectivity; focus points now read "up cuts more, down protects". The analysis window is halved to 2048 samples (about 43 ms delay). Behaviour tests cover plain harmonic tones, resonant bumps, narrow rings, level independence, flicker on noise and high sample rates. Both editors get a dark metallic look with #FF0160 as the single accent colour; screenshots and docs are updated. Projects saved with Patina 0.1 load the new controls at their defaults.	2026-11-06 01:38:17 +01:00