@thedecipherist/claude-packs 1.0.0 → 1.1.0

package/packs/rust/checks/rust-unsafe-needs-safety.json

@@ -0,0 +1,31 @@
+{
+  "id": "rust-unsafe-needs-safety",
+  "why": "An unsafe block with no stated reason cannot be reviewed.",
+  "rule": ".claude/rules/rust-unsafe-is-proved.md",
+  "globs": [
+    "**/*.rs"
+  ],
+  "exclude": [
+    "**/tests/**",
+    "**/test/**",
+    "**/benches/**",
+    "**/examples/**",
+    "**/fixtures/**",
+    "**/test_data/**",
+    "**/testdata/**",
+    "**/fuzz/**",
+    "**/xtask/**",
+    "**/target/**",
+    "**/vendor/**",
+    "**/build.rs",
+    "**/tests.rs",
+    "**/test.rs",
+    "**/*_test.rs",
+    "**/*_tests.rs",
+    "**/test_*.rs"
+  ],
+  "pattern": "^(?<!(?:^|\\n)[ \\t]*//[^\\n]*[Ss][Aa][Ff][Ee][Tt][Yy][^\\n]*\\n(?:[ \\t]*//[^\\n]*\\n)*)(?![ \\t]*//)(?![^\\n]*//[^\\n]*SAFETY)[^\\n]*\\bunsafe\\s*\\{",
+  "flags": "m",
+  "bad": "fn f(p: *const u8) -> u8 {\n    unsafe { *p }\n}",
+  "good": "fn f(p: *const u8) -> u8 {\n    // SAFETY: the caller passes a live pointer, checked in new().\n    unsafe { *p }\n}"
+}

package/packs/rust/checks/rust-unwrap-in-library.json

@@ -0,0 +1,34 @@
+{
+  "id": "rust-unwrap-in-library",
+  "why": "A failure the caller could handle becomes a panic with no reason. Return it with `?`, or say why it cannot happen with `.expect(\"...\")`.",
+  "rule": ".claude/rules/rust-errors-are-returned.md",
+  "globs": [
+    "**/*.rs"
+  ],
+  "exclude": [
+    "**/tests/**",
+    "**/test/**",
+    "**/benches/**",
+    "**/examples/**",
+    "**/fixtures/**",
+    "**/test_data/**",
+    "**/testdata/**",
+    "**/fuzz/**",
+    "**/xtask/**",
+    "**/target/**",
+    "**/vendor/**",
+    "**/build.rs",
+    "**/tests.rs",
+    "**/test.rs",
+    "**/*_test.rs",
+    "**/*_tests.rs",
+    "**/test_*.rs",
+    "**/main.rs",
+    "**/bin/**"
+  ],
+  "language": "rust",
+  "notInTests": true,
+  "pattern": "(?<!\\.lock\\(\\)|\\.read\\(\\)|\\.write\\(\\))\\.unwrap\\(\\)",
+  "bad": "let n = text.parse::<u32>().unwrap();",
+  "good": "let n = text.parse::<u32>()?;"
+}

package/packs/rust/checks/rust-wildcard-dependency.json

@@ -0,0 +1,16 @@
+{
+  "id": "rust-wildcard-dependency",
+  "why": "A * version takes whatever is newest, and crates.io refuses it.",
+  "rule": ".claude/rules/rust-lints-are-the-gate.md",
+  "globs": [
+    "**/Cargo.toml"
+  ],
+  "exclude": [
+    "**/target/**",
+    "**/vendor/**"
+  ],
+  "pattern": "(?:^[ \\t]*[\\w-]+\\s*=\\s*|\\bversion\\s*=\\s*)\"\\*\"",
+  "flags": "m",
+  "bad": "serde = \"*\"",
+  "good": "serde = \"1.0\""
+}

package/packs/rust/clippy.toml

@@ -0,0 +1,5 @@
+# Unit tests live in the file they test: the lints that hold library code leave them alone.
+allow-unwrap-in-tests = true
+allow-expect-in-tests = true
+allow-dbg-in-tests = true
+allow-panic-in-tests = true

package/packs/rust/pack.json

@@ -0,0 +1,27 @@
+{
+  "name": "rust",
+  "version": "1.0.0",
+  "description": "Rust: errors returned, unsafe proved, async never blocks, clippy as the gate. What clippy reads better stays with clippy.",
+  "type": "stock",
+  "author": "claude-packs",
+  "license": "MIT",
+  "homepage": "https://github.com/TheDecipherist/claude-packs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TheDecipherist/claude-packs.git",
+    "directory": "packs/rust"
+  },
+  "keywords": [
+    "rust",
+    "cargo",
+    "clippy"
+  ],
+  "engines": {
+    "claude-packs": ">=1.1.0"
+  },
+  "concepts": {
+    "rust": [
+      "**/*.rs"
+    ]
+  }
+}

package/packs/rust/rules/rust-async-never-blocks.md

@@ -0,0 +1,20 @@
+---
+paths:
+  - "**/*.rs"
+---
+
+# An async function never blocks its thread
+
+<constraints>
+Always do:
+- Hand blocking work to `spawn_blocking`, or use the runtime's own `fs`, `process` and `time`.
+- Drop a `std::sync` guard before an `.await`. Use the runtime's own mutex when the lock must span one.
+- Give every spawned task a way to stop, and a place its error lands.
+
+Never do:
+- Call `std::thread::sleep`, `std::fs` or `std::process::Command` in an `async fn`.
+- Hold a lock across `.await`: clippy's `await_holding_lock` reads this, and the gate holds it.
+</constraints>
+
+## Check
+`rust-blocking-in-async`.

package/packs/rust/rules/rust-borrow-before-you-clone.md

@@ -0,0 +1,19 @@
+---
+paths:
+  - "**/*.rs"
+---
+
+# Borrow first: a clone is a decision, never a way past the borrow checker
+
+<constraints>
+Always do:
+- Take `&str`, `&[T]` and `&Path` in a parameter, and own only what is kept.
+- When the borrow checker refuses, change who owns the value, or shorten the borrow.
+- Use `impl Trait` or a generic before `Box<dyn Trait>`, unless the types differ at run time.
+- Walk with iterators. Let lifetimes be elided where the compiler allows it.
+- Give a value its own type (a newtype, an enum) in place of a bare `String` or a `bool` flag.
+
+Never do:
+- Add `.clone()`, `Rc` or `RefCell` only to make an error go away.
+- Write a function again in another crate: `template-law` reads Rust. The `rust-extract-template` skill has the forms.
+</constraints>

package/packs/rust/rules/rust-errors-are-returned.md

@@ -0,0 +1,22 @@
+---
+paths:
+  - "**/*.rs"
+---
+
+# An error is returned; a panic states why it cannot happen
+
+<constraints>
+Always do:
+- Return `Result` from anything that can fail, and pass it up with `?`.
+- Give a library its own error type, by hand or with `thiserror`, so a caller can match on it.
+- In an application, use `anyhow` with `.context(...)` saying what was being attempted.
+- Write `.expect("why this cannot fail")` for a true invariant. The message is the proof.
+
+Never do:
+- `.unwrap()` in library code. Tests, `main.rs` and `src/bin/` may.
+- Return `Result<T, String>` or `Box<dyn Error>` from a public function.
+- Drop a `Result` with `let _ =` on a state change.
+</constraints>
+
+## Check
+`rust-unwrap-in-library`, `rust-string-as-error`.

package/packs/rust/rules/rust-lints-are-the-gate.md

@@ -0,0 +1,23 @@
+---
+paths:
+  - "**/*.rs"
+---
+
+# `cargo clippy -D warnings` and `cargo fmt --check` are the gate
+
+Clippy reads types, so what it can judge stays with it. The lesson checks stop only what is cheaper to stop at the write.
+
+<constraints>
+Always do:
+- Take the lint set in `.claude/tools/rust-lints.toml` into `Cargo.toml`, and keep the installed `clippy.toml` at the root.
+- Run `cargo fmt --check`, then `cargo clippy --all-targets --all-features -- -D warnings`, before landing.
+- Turn a lint off with `#[expect(lint, reason = "...")]`, on the smallest item. `reason` needs Rust 1.81; on an older toolchain, disable `checks/rust-allow-needs-reason.json` in `layout.json`.
+- Commit `Cargo.lock` for an application.
+
+Never do:
+- Leave `todo!()` or `dbg!()` in code that lands. `unimplemented!()` is a decision, and may stay.
+- Depend on a `*` version.
+</constraints>
+
+## Check
+`rust-allow-needs-reason`, `rust-stub-left-in`, `rust-wildcard-dependency`.

package/packs/rust/rules/rust-repeats-become-templates.md

@@ -0,0 +1,28 @@
+---
+paths:
+  - "**/*.rs"
+---
+
+# Anything repeated in Rust becomes one template: pick the form that fits the repeat
+
+<constraints>
+Always do:
+- Match the repeat to its form. The `rust-extract-template` skill has each with an example:
+  - A block with other names: one function, with what differs as parameters.
+  - The same code over several types: a generic with a trait bound.
+  - The same method on many types: a trait with a default method.
+  - The same `impl` for many types, where a generic cannot do it: one `macro_rules!`.
+  - One call repeated with other arguments: a `const` table and one loop.
+  - The same code in two crates: the crate both depend on.
+- Give an enum its own methods for what varies by variant: `state.label()`, in the enum's impl. A table of values on an enum belongs with the enum.
+- Match every variant by name, so a new variant is a compile error in each place that must decide. `clippy::wildcard_enum_match_arm` holds this.
+- Use `#[derive(...)]` and `thiserror`'s `#[from]` in place of hand-written impls.
+
+Never do:
+- Write `_ =>` on your own enum: it hides the next variant from the compiler.
+- Write a macro where a function or a generic does the job, or a trait with one implementor.
+- Treat a trait method as a copy: `from_str` on two types is the trait doing its job.
+</constraints>
+
+## Check
+`template-law` refuses a copy, a near copy, a table written as calls and a function made again. `dispatch-once` refuses a second lookup table on one enum outside the enum's own file. `once-only` refuses a copy as written. `rust-if-chain-is-a-match` refuses three `==` branches on one value.

package/packs/rust/rules/rust-unsafe-is-proved.md

@@ -0,0 +1,21 @@
+---
+paths:
+  - "**/*.rs"
+---
+
+# Every unsafe block says why it is sound
+
+<constraints>
+Always do:
+- Put a `// SAFETY:` comment directly above each `unsafe` block, naming the invariant and what upholds it.
+- Keep a block to one unsafe operation, and wrap it in a safe function that checks what it needs.
+- Give every `unsafe fn` a `# Safety` section in its docs.
+- Run `cargo miri test` on code with `unsafe`, where it can run.
+
+Never do:
+- Use `static mut`: use an atomic, `OnceLock` or a `Mutex`.
+- Use `unsafe` for speed with no measurement showing the safe form is too slow.
+</constraints>
+
+## Check
+`rust-unsafe-needs-safety`, `rust-static-mut`.

package/packs/rust/skills/rust-extract-template/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: rust-extract-template
+description: Use when template-law refuses Rust code, when scan lists repeated Rust, or when copying a Rust function, impl or module to change it.
+---
+
+# Extract a Rust repeat into one template (one job: pick the Rust form, and move every copy to it)
+
+Follow `make-it-a-template`. This skill is its Rust forms.
+
+<constraints>
+Always do:
+1. A repeated block: one function, with what differs as parameters. A difference in behaviour is a closure parameter.
+2. The same code over several types: a generic with a trait bound.
+   ```rust
+   fn total<T: Priced>(items: &[T]) -> u64 {
+       items.iter().map(Priced::price).sum()
+   }
+   ```
+3. The same method on many types: a trait with a default method.
+4. The same `impl` written for many types: one `macro_rules!`, and only when a generic cannot do it.
+   ```rust
+   macro_rules! impl_id { ($($t:ident),*) => { $(impl Id for $t { fn raw(&self) -> u64 { self.0 } })* } }
+   impl_id!(UserId, OrderId);
+   ```
+5. One call with other arguments: a `const` table and one loop.
+   ```rust
+   const ROUTES: &[(&str, Handler)] = &[("/users", users), ("/orders", orders)];
+   for (path, handler) in ROUTES {
+       app.route(path, *handler);
+   }
+   ```
+6. A table of values on an enum: a method on the enum, in its own impl, with every variant named. `dispatch-once` refuses a second table outside it.
+   ```rust
+   impl State {
+       pub fn colour(&self) -> u32 {
+           match self {
+               State::Open => 1,
+               State::Closed => 4,
+           }
+       }
+   }
+   ```
+7. Fields that travel together: a struct, with `#[derive(...)]` in place of hand-written impls. A run of `impl From<X> for MyError`: `thiserror`'s `#[from]`.
+8. The same code in two crates: move it to the crate both depend on.
+9. Run what the change reaches: `cargo test -p <crate>`. Then search for the old names: none is left.
+
+Never do:
+- Write a macro where a function or a generic does the job.
+- Add a trait with one implementor.
+</constraints>

package/packs/rust/skills/rust-port/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: rust-port
+description: Use when porting code to Rust from another language, or rewriting a module in Rust.
+---
+
+# Port to Rust (one job: the same behaviour, in Rust's own shapes)
+
+<constraints>
+Always do:
+1. Pin the behaviour first: tests or recorded input and output from the old code, kept as the proof.
+2. Write down who owns each piece of state. A shared mutable object becomes one owner that lends, or a message to the task that owns it.
+3. Map each failure the old code can have to a variant of an error type. An exception becomes a `Result`; a null becomes an `Option`.
+4. Map an inheritance tree to an enum when the set of kinds is closed, and to a trait when it is open.
+5. Port one module at a time behind the same interface, and run the pinned tests after each.
+6. Keep a behaviour the old code has even if it looks wrong, and list it. Change it in its own step.
+7. Compare speed only after it is correct, on a release build.
+
+Never do:
+- Translate line by line: a class with getters and shared pointers everywhere is the old language in Rust's syntax.
+- Reach for `Rc<RefCell<T>>` or `unsafe` to keep the old shape.
+- Change behaviour and language in the same step.
+</constraints>

package/packs/rust/skills/rust-review/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: rust-review
+description: Use when reviewing Rust code, a Rust diff or a crate before it lands, or when asked whether Rust code is sound or idiomatic.
+---
+
+# Review Rust (one job: find what the compiler and clippy cannot)
+
+Run the gate first, so the review spends nothing on what tools already say: `cargo fmt --check`, `cargo clippy --all-targets --all-features -- -D warnings`, `cargo test`.
+
+<constraints>
+Always do:
+1. Ownership: is each `.clone()`, `Rc`, `Arc` and `RefCell` needed, or was it a way past a borrow error? Could the caller keep the value and lend it?
+2. Errors: can a caller tell the failures apart? Is every `.expect` message a true invariant? Does a `?` lose what was being attempted?
+3. `unsafe`: does each `SAFETY` comment name a real invariant, and does the code around it uphold that? Read the callers. Check aliasing, alignment, initialization, and that a panic in the block leaves nothing half done.
+4. Concurrency: what happens when a future is dropped at each `.await`? Is state left half written? Is a channel unbounded? Is `Ordering::Relaxed` proved enough?
+5. Public API: would a new field or variant break a caller (`#[non_exhaustive]`)? Is an internal type exposed? Are `Send` and `Sync` what the caller needs?
+6. Numbers and text: an `as` cast that truncates, an overflow in release builds, a byte index into a `&str`.
+7. Tests: does a test fail without the change? Is an error path covered, not only the happy one?
+8. Report each finding with the file, the symbol and the input that breaks it. A finding you cannot give an input for is a question.
+
+Never do:
+- Report what clippy or `rustfmt` already says.
+- Ask for a lifetime, a trait or a generic the code does not need.
+</constraints>

package/packs/rust/tools/rust-lints.toml

@@ -0,0 +1,19 @@
+# The gate's lint set: paste it into Cargo.toml. In a workspace, write [workspace.lints.rust] and [workspace.lints.clippy]
+# at the root, and `[lints] workspace = true` in each crate. An application can drop unwrap_used from main.rs with an
+# `#[expect(clippy::unwrap_used, reason = "...")]`. `reason` needs Rust 1.81.
+[lints.rust]
+unsafe_op_in_unsafe_fn = "deny"
+
+[lints.clippy]
+all = { level = "deny", priority = -1 }
+unwrap_used = "deny"
+todo = "deny"
+dbg_macro = "deny"
+allow_attributes_without_reason = "deny"
+undocumented_unsafe_blocks = "deny"
+multiple_unsafe_ops_per_block = "deny"
+panic_in_result_fn = "deny"
+redundant_clone = "deny"
+clone_on_ref_ptr = "deny"
+fn_params_excessive_bools = "deny"
+wildcard_enum_match_arm = "deny"

package/packs/sound-design/skills/bounce-a-plugin/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: bounce-a-plugin
+description: Use when audio has to be rendered from a VST3 with no DAW, when comparing an engine with another plugin or an emulator, when fitting a law against a plugin, or when a plugin will not load in a JUCE host or plays silence.
+---
+
+# Bounce a plugin (one job: a known input through a plugin, and the audio out, repeatable)
+
+`.claude/tools/vst3host/` is an offline VST3 renderer: no DAW, no audio device, no window, faster than real time. It does not link JUCE, on purpose: a JUCE host cannot load every JUCE plugin.
+
+```
+bash .claude/tools/vst3host/build.sh            # once, after the project's first configure; macOS and Linux
+R=out/vst3host/render
+$R --vst3 <plugin> --list                       # every parameter, with its id
+$R --vst3 <plugin> --out a.wav --note 60 --vel 100 --hold 1.5 --tail 0.6
+$R --vst3 <plugin> --param 12=0.75 --sweep 38:9 --dir out/   # one note per value of 38, 12 frozen
+$R --vst3 <plugin> --program 5 --bank 0:1 --out a.wav        # the same factory patch a machine was recorded on
+$R --vst3 <plugin> --sysex patch.syx --dump-params           # send a patch, and read whether it was taken
+```
+
+The WAV is 32-bit float, so a plugin that peaks over 1.0 is measured, never clipped. For a Roland machine, `--dt1-head "41 10 00 06" --dt1-base 1004000` sends DT1: `--dt1 OFF=VAL` pins a value, `--sweep-dt1 OFF:STEPS[:MAX]` and a repeated `--axis` sweep, `--probe LO-HI[:V1,V2]` finds which offset is a control, and `--map LO-HI[:VAL]` asks the plugin which parameter an offset is.
+
+<constraints>
+Always do:
+1. Run `--list` first. `--param` and `--sweep` take the id, never the row number. A wrong id is ignored, and the sweep renders the same sound with no complaint.
+2. Prove the bounce before you trust it. Render twice: same bytes means the plugin is repeatable, and you can compare exactly. If it is not (a free-running oscillator, modelled drift), compare averages of several bounces, and say so.
+3. Prove a control reaches the audio: sweep it, and measure that the audio moves. Two renders that match byte for byte mean the control did nothing.
+4. Render one note per value. Move a control between notes, never under one.
+5. Give a firmware emulator its boot: `--boot 12`. The emulated processor needs real samples before it answers a note, and a short boot reads as a silent plugin.
+6. When parameters do nothing, try sysex. A firmware emulator may ignore host automation and answer only the machine's own messages. The renderer sets both the controller and the processor's queue, and if the audio is still byte-identical, sysex is the way in.
+7. Ask whether a dump was taken: `--dump-params` before and after. A rejected dump and an accepted one that sounds alike cannot be told apart in a WAV. Identical output means the patches never arrived, whatever the spectra look like.
+8. Fix everything else: patch, note, velocity, sample rate, effects off. To fit one control, move only that control. A factory-patch recording cannot fit a law, since a performance has its chorus on.
+9. To compare two engines, render both with the same patch and the same notes, and name in the report what the other engine is. An emulation is a reference, not the machine: tag it as what it is, and record where it disagrees with the schematic rather than choosing quietly.
+
+Never do:
+- Open an audio device, or route through a loopback, to capture a plugin. On macOS a permission denial returns silence, not an error.
+- Load a plugin in a JUCE host to measure it and trust a crash as the plugin's fault: an allocator clash across the boundary aborts inside the plugin's own loader.
+- Read one output bus as all of them. The renderer gives every bus a buffer and keeps bus 0: a plugin with several may send a part elsewhere.
+- Commit a render: it is a build output, and a plugin's sound may be someone else's. Keep the numbers.
+- Run a cracked or unlicensed plugin. Use the maker's trial.
+</constraints>

package/packs/sound-design/tools/vst3host/build.sh

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+# Builds the offline VST3 renderer on macOS or Linux. It links the VST3 SDK a project's JUCE already holds, and must not link JUCE itself: that is the
+# whole point, since a JUCE host cannot load every JUCE plugin. Run it from the project root, after the project's first configure has fetched JUCE.
+#   bash .claude/tools/vst3host/build.sh [out-dir]      VST3_SDK=<dir> names the SDK; otherwise it is looked for under JUCE
+# The source list took finding, so it is written here: the SDK inside JUCE is trimmed, and each of these has to be named.
+set -euo pipefail
+
+here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+out="${1:-out/vst3host}"
+
+find_sdk() {
+  local root module
+  if [[ -n "${VST3_SDK:-}" ]]; then
+    printf '%s\n' "$VST3_SDK"
+    return 0
+  fi
+  for root in out/*/_deps/juce-src build/_deps/juce-src build/*/_deps/juce-src cmake-build-*/_deps/juce-src JUCE third_party/JUCE; do
+    for module in juce_audio_processors_headless juce_audio_processors; do
+      if [[ -d "$root/modules/$module/format_types/VST3_SDK/public.sdk" ]]; then
+        printf '%s\n' "$PWD/$root/modules/$module/format_types/VST3_SDK"
+        return 0
+      fi
+    done
+  done
+  return 1
+}
+
+if ! sdk="$(find_sdk)"; then
+  echo "build.sh: no VST3 SDK found. Configure the project so JUCE is fetched, or set VST3_SDK to the folder." >&2
+  exit 1
+fi
+
+sources=(
+  public.sdk/source/vst/hosting/module.cpp
+  public.sdk/source/vst/hosting/hostclasses.cpp
+  public.sdk/source/vst/hosting/pluginterfacesupport.cpp
+  public.sdk/source/vst/vstinitiids.cpp
+  public.sdk/source/vst/utility/stringconvert.cpp
+  public.sdk/source/common/commonstringconvert.cpp
+  public.sdk/source/common/memorystream.cpp
+  pluginterfaces/base/funknown.cpp
+  pluginterfaces/base/coreiids.cpp
+  pluginterfaces/base/conststringtable.cpp
+  pluginterfaces/base/ustring.cpp
+  base/source/fobject.cpp
+  base/source/fstring.cpp
+  base/source/fdebug.cpp
+  base/source/fbuffer.cpp
+  base/source/baseiids.cpp
+  base/source/fstreamer.cpp
+  base/thread/source/flock.cpp
+)
+paths=()
+for source in "${sources[@]}"; do
+  paths+=("$sdk/$source")
+done
+
+mkdir -p "$out"
+flags=(-std=c++17 -O2 -DRELEASE=1 -I"$sdk" -I"$here")
+case "$(uname -s)" in
+  Darwin)
+    clang++ "${flags[@]}" -fobjc-arc -c "$sdk/public.sdk/source/vst/hosting/module_mac.mm" -o "$out/module_mac.o"
+    clang++ "${flags[@]}" "$here/render.cpp" "$out/module_mac.o" "${paths[@]}" -framework CoreFoundation -framework Foundation -o "$out/render"
+    ;;
+  Linux)
+    "${CXX:-g++}" "${flags[@]}" "$here/render.cpp" "$sdk/public.sdk/source/vst/hosting/module_linux.cpp" "${paths[@]}" -ldl -lpthread -o "$out/render"
+    ;;
+  *)
+    echo "build.sh: macOS and Linux only. On Windows, build render.cpp with module_win32.cpp and the same sources." >&2
+    exit 1
+    ;;
+esac
+echo "built $out/render"

package/packs/sound-design/tools/vst3host/host_events.h

@@ -0,0 +1,101 @@
+// What a VST3 host must supply and the SDK inside JUCE leaves out: the parameter and event lists, and the wire between a plugin's two halves.
+#pragma once
+
+#include "pluginterfaces/vst/ivstevents.h"
+#include "pluginterfaces/vst/ivstmessage.h"
+#include "pluginterfaces/vst/ivstparameterchanges.h"
+
+#include <utility>
+#include <vector>
+
+namespace vst3host {
+
+using namespace Steinberg;
+
+// One parameter's points for one block.
+class ParamQueue final : public Vst::IParamValueQueue {
+public:
+    explicit ParamQueue (Vst::ParamID id) : pid (id) {}
+    Vst::ParamID PLUGIN_API getParameterId() override { return pid; }
+    int32 PLUGIN_API getPointCount() override { return (int32) points.size(); }
+    tresult PLUGIN_API getPoint (int32 i, int32& offset, Vst::ParamValue& value) override {
+        if (i < 0 || i >= (int32) points.size()) return kResultFalse;
+        offset = points[(size_t) i].first;
+        value = points[(size_t) i].second;
+        return kResultOk;
+    }
+    tresult PLUGIN_API addPoint (int32 offset, Vst::ParamValue value, int32& i) override {
+        points.emplace_back (offset, value);
+        i = (int32) points.size() - 1;
+        return kResultOk;
+    }
+    DECLARE_FUNKNOWN_METHODS
+private:
+    Vst::ParamID pid;
+    std::vector<std::pair<int32, Vst::ParamValue>> points;
+};
+IMPLEMENT_FUNKNOWN_METHODS (ParamQueue, Vst::IParamValueQueue, Vst::IParamValueQueue::iid)
+
+class ParamChanges final : public Vst::IParameterChanges {
+public:
+    ~ParamChanges() { clear(); }
+    int32 PLUGIN_API getParameterCount() override { return (int32) queues.size(); }
+    Vst::IParamValueQueue* PLUGIN_API getParameterData (int32 i) override {
+        return (i >= 0 && i < (int32) queues.size()) ? queues[(size_t) i] : nullptr;
+    }
+    Vst::IParamValueQueue* PLUGIN_API addParameterData (const Vst::ParamID& id, int32& i) override {
+        for (size_t k = 0; k < queues.size(); ++k) {
+            if (queues[k]->getParameterId() != id) continue;
+            i = (int32) k;
+            return queues[k];
+        }
+        auto* queue = new ParamQueue (id);
+        queue->addRef();
+        queues.push_back (queue);
+        i = (int32) queues.size() - 1;
+        return queue;
+    }
+    void clear() {
+        for (auto* queue : queues) queue->release();
+        queues.clear();
+    }
+    DECLARE_FUNKNOWN_METHODS
+private:
+    std::vector<ParamQueue*> queues;
+};
+IMPLEMENT_FUNKNOWN_METHODS (ParamChanges, Vst::IParameterChanges, Vst::IParameterChanges::iid)
+
+class EventList final : public Vst::IEventList {
+public:
+    int32 PLUGIN_API getEventCount() override { return (int32) events.size(); }
+    tresult PLUGIN_API getEvent (int32 i, Vst::Event& e) override {
+        if (i < 0 || i >= (int32) events.size()) return kResultFalse;
+        e = events[(size_t) i];
+        return kResultOk;
+    }
+    tresult PLUGIN_API addEvent (Vst::Event& e) override {
+        events.push_back (e);
+        return kResultOk;
+    }
+    void clear() { events.clear(); }
+    DECLARE_FUNKNOWN_METHODS
+private:
+    std::vector<Vst::Event> events;
+};
+IMPLEMENT_FUNKNOWN_METHODS (EventList, Vst::IEventList, Vst::IEventList::iid)
+
+// A plugin's component and controller talk through connection points, and the host is the wire. Some plugins build their parameter list
+// on the controller only after the component tells them to: without this a controller reports no parameters.
+class ConnectionProxy final : public Vst::IConnectionPoint {
+public:
+    explicit ConnectionProxy (Vst::IConnectionPoint* target) : other (target) {}
+    tresult PLUGIN_API connect (Vst::IConnectionPoint*) override { return kResultOk; }
+    tresult PLUGIN_API disconnect (Vst::IConnectionPoint*) override { return kResultOk; }
+    tresult PLUGIN_API notify (Vst::IMessage* message) override { return other ? other->notify (message) : kResultFalse; }
+    DECLARE_FUNKNOWN_METHODS
+private:
+    Vst::IConnectionPoint* other;
+};
+IMPLEMENT_FUNKNOWN_METHODS (ConnectionProxy, Vst::IConnectionPoint, Vst::IConnectionPoint::iid)
+
+} // namespace vst3host