fractal-midi 0.1.0-alpha.0

package/dist/axe-fx-ii/blockTypes.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Axe-Fx II block ID dictionary (generated).
+ *
+ * Source: Fractal Audio Wiki "MIDI_SysEx" page, "Axe-Fx II MIDI SysEx:
+ * Block IDs" table, cached at
+ * `docs/_private/wiki-cache/axe-fx-ii-midi-sysex.html`.
+ *
+ * Wire context: the Axe-Fx II family addresses each block by its
+ * 14-bit `effectId` in the GET/SET_BLOCK_PARAMETER_VALUE message
+ * (function `0x02`). Multiple instances of the same block group
+ * (e.g. Amp 1 + Amp 2) have distinct ids but share the parameter
+ * table — see `KNOWN_PARAMS` in `./params.ts`, keyed by group code.
+ *
+ * **DO NOT EDIT BY HAND** — regenerate via:
+ *   npx tsx scripts/extract-axe-fx-ii-params.ts
+ *
+ * Status: 🟢 hardware-verified on Q8.02 (2026-05-10). HW-076 read
+ * the active preset's grid layout (12 blocks across 4 rows × 12
+ * columns) and the resolved block IDs matched the device's front-
+ * panel display + AxeEdit's rendering. HW-075 then wrote params to
+ * Amp 1 and Reverb 1 by ID + saw the audible/visible result — block
+ * ID resolution proven end to end. Factory bank file references
+ * (`samples/factory/Axe-Fx-II_XL+_Bank-{A,B,C}_Q8p02.syx`) line up
+ * with the registry as expected.
+ */
+export interface AxeFxIIBlock {
+    /** 14-bit `effectId` used in GET/SET_BLOCK_PARAMETER_VALUE. */
+    readonly id: number;
+    /** Display name (e.g. "Amp 1", "Reverb 2"). */
+    readonly name: string;
+    /** 3-letter group code shared by all instances (e.g. "AMP"). */
+    readonly groupCode: string;
+    /** Whether the block exposes a bypass toggle. */
+    readonly canBypass: boolean;
+    /** Whether the AX8 floorboard exposes this block. */
+    readonly availableOnAX8: boolean;
+}
+export declare const AXE_FX_II_BLOCKS: readonly AxeFxIIBlock[];
+/** Reverse lookup: effectId → block. */
+export declare const BLOCK_BY_ID: Readonly<Record<number, AxeFxIIBlock>>;
+/** Group code → list of effectIds (in order). e.g. AMP → [106, 107]. */
+export declare const IDS_BY_GROUP: Readonly<Record<string, readonly number[]>>;
+/** Resolve a user-supplied block reference (id or name) to its block. */
+export declare function resolveBlock(input: string | number): AxeFxIIBlock | undefined;
+//# sourceMappingURL=blockTypes.d.ts.map

package/dist/axe-fx-ii/blockTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockTypes.d.ts","sourceRoot":"","sources":["../../src/axe-fx-ii/blockTypes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,MAAM,WAAW,YAAY;IACzB,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gEAAgE;IAChE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,iDAAiD;IACjD,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,qDAAqD;IACrD,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;CACpC;AAED,eAAO,MAAM,gBAAgB,EAAE,SAAS,YAAY,EAwE1C,CAAC;AAEX,wCAAwC;AACxC,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CACc,CAAC;AAE9E,wEAAwE;AACxE,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAUjE,CAAC;AAOL,yEAAyE;AACzE,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,YAAY,GAAG,SAAS,CAG7E"}

package/dist/axe-fx-ii/blockTypes.js

@@ -0,0 +1,116 @@
+/**
+ * Axe-Fx II block ID dictionary (generated).
+ *
+ * Source: Fractal Audio Wiki "MIDI_SysEx" page, "Axe-Fx II MIDI SysEx:
+ * Block IDs" table, cached at
+ * `docs/_private/wiki-cache/axe-fx-ii-midi-sysex.html`.
+ *
+ * Wire context: the Axe-Fx II family addresses each block by its
+ * 14-bit `effectId` in the GET/SET_BLOCK_PARAMETER_VALUE message
+ * (function `0x02`). Multiple instances of the same block group
+ * (e.g. Amp 1 + Amp 2) have distinct ids but share the parameter
+ * table — see `KNOWN_PARAMS` in `./params.ts`, keyed by group code.
+ *
+ * **DO NOT EDIT BY HAND** — regenerate via:
+ *   npx tsx scripts/extract-axe-fx-ii-params.ts
+ *
+ * Status: 🟢 hardware-verified on Q8.02 (2026-05-10). HW-076 read
+ * the active preset's grid layout (12 blocks across 4 rows × 12
+ * columns) and the resolved block IDs matched the device's front-
+ * panel display + AxeEdit's rendering. HW-075 then wrote params to
+ * Amp 1 and Reverb 1 by ID + saw the audible/visible result — block
+ * ID resolution proven end to end. Factory bank file references
+ * (`samples/factory/Axe-Fx-II_XL+_Bank-{A,B,C}_Q8p02.syx`) line up
+ * with the registry as expected.
+ */
+export const AXE_FX_II_BLOCKS = [
+    { id: 100, name: "Compressor 1", groupCode: "CPR", canBypass: true, availableOnAX8: true },
+    { id: 101, name: "Compressor 2", groupCode: "CPR", canBypass: true, availableOnAX8: false },
+    { id: 102, name: "Graphic EQ 1", groupCode: "GEQ", canBypass: true, availableOnAX8: true },
+    { id: 103, name: "Graphic EQ 2", groupCode: "GEQ", canBypass: true, availableOnAX8: true },
+    { id: 104, name: "Parametric EQ 1", groupCode: "PEQ", canBypass: true, availableOnAX8: true },
+    { id: 105, name: "Parametric EQ 2", groupCode: "PEQ", canBypass: true, availableOnAX8: true },
+    { id: 106, name: "Amp 1", groupCode: "AMP", canBypass: true, availableOnAX8: true },
+    { id: 107, name: "Amp 2", groupCode: "AMP", canBypass: true, availableOnAX8: false },
+    { id: 108, name: "Cab 1", groupCode: "CAB", canBypass: true, availableOnAX8: true },
+    { id: 109, name: "Cab 2", groupCode: "CAB", canBypass: true, availableOnAX8: false },
+    { id: 110, name: "Reverb 1", groupCode: "REV", canBypass: true, availableOnAX8: true },
+    { id: 111, name: "Reverb 2", groupCode: "REV", canBypass: true, availableOnAX8: false },
+    { id: 112, name: "Delay 1", groupCode: "DLY", canBypass: true, availableOnAX8: true },
+    { id: 113, name: "Delay 2", groupCode: "DLY", canBypass: true, availableOnAX8: true },
+    { id: 114, name: "Multi Delay 1", groupCode: "MTD", canBypass: true, availableOnAX8: true },
+    { id: 115, name: "Multi Delay 2", groupCode: "MTD", canBypass: true, availableOnAX8: false },
+    { id: 116, name: "Chorus 1", groupCode: "CHO", canBypass: true, availableOnAX8: true },
+    { id: 117, name: "Chorus 2", groupCode: "CHO", canBypass: true, availableOnAX8: false },
+    { id: 118, name: "Flanger 1", groupCode: "FLG", canBypass: true, availableOnAX8: true },
+    { id: 119, name: "Flanger 2", groupCode: "FLG", canBypass: true, availableOnAX8: false },
+    { id: 120, name: "Rotary Speaker 1", groupCode: "ROT", canBypass: true, availableOnAX8: true },
+    { id: 121, name: "Rotary Speaker 2", groupCode: "ROT", canBypass: true, availableOnAX8: false },
+    { id: 122, name: "Phaser 1", groupCode: "PHA", canBypass: true, availableOnAX8: true },
+    { id: 123, name: "Phaser 2", groupCode: "PHA", canBypass: true, availableOnAX8: false },
+    { id: 124, name: "Wah 1", groupCode: "WAH", canBypass: true, availableOnAX8: true },
+    { id: 125, name: "Wah 2", groupCode: "WAH", canBypass: true, availableOnAX8: false },
+    { id: 126, name: "Formant", groupCode: "FRM", canBypass: true, availableOnAX8: true },
+    { id: 127, name: "Volume/Pan 1", groupCode: "VOL", canBypass: true, availableOnAX8: true },
+    { id: 128, name: "Tremolo/Panner 1", groupCode: "TRM", canBypass: true, availableOnAX8: true },
+    { id: 129, name: "Tremolo/Panner 2", groupCode: "TRM", canBypass: true, availableOnAX8: false },
+    { id: 130, name: "Pitch 1", groupCode: "PIT", canBypass: true, availableOnAX8: true },
+    { id: 131, name: "Filter 1", groupCode: "FIL", canBypass: true, availableOnAX8: true },
+    { id: 132, name: "Filter 2", groupCode: "FIL", canBypass: true, availableOnAX8: true },
+    { id: 133, name: "Drive 1", groupCode: "DRV", canBypass: true, availableOnAX8: true },
+    { id: 134, name: "Drive 2", groupCode: "DRV", canBypass: true, availableOnAX8: true },
+    { id: 135, name: "Enhancer", groupCode: "ENH", canBypass: true, availableOnAX8: true },
+    { id: 136, name: "FX Loop", groupCode: "FXL", canBypass: true, availableOnAX8: true },
+    { id: 137, name: "Mixer", groupCode: "MIX", canBypass: false, availableOnAX8: false },
+    { id: 138, name: "Mixer 2", groupCode: "MIX", canBypass: false, availableOnAX8: false },
+    { id: 139, name: "Input Noise Gate", groupCode: "INPUT", canBypass: false, availableOnAX8: true },
+    { id: 140, name: "Output", groupCode: "OUTPUT", canBypass: false, availableOnAX8: true },
+    { id: 141, name: "Controllers", groupCode: "CONTROLLERS", canBypass: false, availableOnAX8: true },
+    { id: 142, name: "Feedback Send", groupCode: "SND", canBypass: false, availableOnAX8: false },
+    { id: 143, name: "Feedback Return", groupCode: "RTN", canBypass: false, availableOnAX8: false },
+    { id: 144, name: "Synth 1", groupCode: "SYN", canBypass: true, availableOnAX8: true },
+    { id: 145, name: "Synth 2", groupCode: "SYN", canBypass: true, availableOnAX8: false },
+    { id: 146, name: "Vocoder", groupCode: "VOC", canBypass: true, availableOnAX8: false },
+    { id: 147, name: "Megatap Delay", groupCode: "MGT", canBypass: true, availableOnAX8: false },
+    { id: 148, name: "Crossover 1", groupCode: "XVR", canBypass: true, availableOnAX8: false },
+    { id: 149, name: "Crossover 2", groupCode: "XVR", canBypass: true, availableOnAX8: false },
+    { id: 150, name: "Gate Expander", groupCode: "GTE", canBypass: true, availableOnAX8: true },
+    { id: 151, name: "Gate Expander 2", groupCode: "GTE", canBypass: true, availableOnAX8: false },
+    { id: 152, name: "Ring Modulator", groupCode: "RNG", canBypass: true, availableOnAX8: true },
+    { id: 153, name: "Pitch 2", groupCode: "PIT", canBypass: true, availableOnAX8: false },
+    { id: 154, name: "Multiband Compressor 1", groupCode: "MBC", canBypass: true, availableOnAX8: false },
+    { id: 155, name: "Multiband Compressor 2", groupCode: "MBC", canBypass: true, availableOnAX8: false },
+    { id: 156, name: "Quad Chorus 1", groupCode: "QCH", canBypass: true, availableOnAX8: false },
+    { id: 157, name: "Quad Chorus 2", groupCode: "QCH", canBypass: true, availableOnAX8: false },
+    { id: 158, name: "Resonator 1", groupCode: "RES", canBypass: true, availableOnAX8: false },
+    { id: 159, name: "Resonator 2", groupCode: "RES", canBypass: true, availableOnAX8: false },
+    { id: 160, name: "Graphic EQ 3", groupCode: "GEQ", canBypass: true, availableOnAX8: false },
+    { id: 161, name: "Graphic EQ 4", groupCode: "GEQ", canBypass: true, availableOnAX8: false },
+    { id: 162, name: "Parametric EQ 3", groupCode: "PEQ", canBypass: true, availableOnAX8: false },
+    { id: 163, name: "Parametric EQ 4", groupCode: "PEQ", canBypass: true, availableOnAX8: false },
+    { id: 164, name: "Filter 3", groupCode: "FIL", canBypass: true, availableOnAX8: false },
+    { id: 165, name: "Filter 4", groupCode: "FIL", canBypass: true, availableOnAX8: false },
+    { id: 166, name: "Volume/Pan 2", groupCode: "VOL", canBypass: true, availableOnAX8: true },
+    { id: 167, name: "Volume/Pan 3", groupCode: "VOL", canBypass: true, availableOnAX8: false },
+    { id: 168, name: "Volume/Pan 4", groupCode: "VOL", canBypass: true, availableOnAX8: false },
+    { id: 169, name: "Looper", groupCode: "LPR", canBypass: true, availableOnAX8: true },
+    { id: 170, name: "Tone Match", groupCode: "TMA", canBypass: true, availableOnAX8: false },
+];
+/** Reverse lookup: effectId → block. */
+export const BLOCK_BY_ID = Object.freeze(Object.fromEntries(AXE_FX_II_BLOCKS.map((b) => [b.id, b])));
+/** Group code → list of effectIds (in order). e.g. AMP → [106, 107]. */
+export const IDS_BY_GROUP = (() => {
+    const out = {};
+    for (const b of AXE_FX_II_BLOCKS) {
+        (out[b.groupCode] ??= []).push(b.id);
+    }
+    return Object.freeze(Object.fromEntries(Object.entries(out).map(([k, v]) => [k, Object.freeze(v.slice())])));
+})();
+/** Block name (e.g. "Amp 1") → block. Case-insensitive. */
+const NAMES_BY_LOWER = Object.fromEntries(AXE_FX_II_BLOCKS.map((b) => [b.name.toLowerCase(), b]));
+/** Resolve a user-supplied block reference (id or name) to its block. */
+export function resolveBlock(input) {
+    if (typeof input === 'number')
+        return BLOCK_BY_ID[input];
+    return NAMES_BY_LOWER[input.trim().toLowerCase()];
+}

package/dist/axe-fx-ii/index.d.ts

@@ -0,0 +1,5 @@
+export * from './params.js';
+export * from './blockTypes.js';
+export * from './paramAliases.js';
+export * from './setParam.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/axe-fx-ii/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/axe-fx-ii/index.ts"],"names":[],"mappings":"AAeA,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC"}

package/dist/axe-fx-ii/index.js

@@ -0,0 +1,18 @@
+// Barrel for fractal-midi/axe-fx-ii.
+//
+// Public surface for Axe-Fx II family data + codec. The II family uses
+// a different wire envelope from the AM4 (function 0x02 GET/SET_BLOCK_
+// PARAMETER_VALUE with 16-bit values packed across three 7-bit septets,
+// vs. the AM4's function 0x01 with 14-bit pidLow/pidHigh + 32-bit float
+// payload). The codec is independent — don't expect AM4 builders to
+// interoperate.
+//
+// Hardware-verified on Axe-Fx II XL+ firmware Quantum 8.02.
+//
+// We re-export everything from each underlying module so this barrel
+// can grow without churn as new helpers land. Curate later if a name
+// conflict surfaces.
+export * from './params.js';
+export * from './blockTypes.js';
+export * from './paramAliases.js';
+export * from './setParam.js';

package/dist/axe-fx-ii/paramAliases.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Axe-Fx II — param-name fuzzy resolution.
+ *
+ * Single source of truth for every code path that resolves a user-typed
+ * param name to the device's canonical wire param. Three layers, tried
+ * in order:
+ *
+ *   1. **Exact canonical match** — `name === userInput.toLowerCase()`.
+ *      Fast path; hits 90%+ of well-formed agent calls.
+ *
+ *   2. **Normalized fuzzy match against display fields.** User input is
+ *      normalized to lowercase snake_case (`"Input Drive"`, `"INPUT
+ *      DRIVE"`, `"input-drive"` all → `"input_drive"`); then compared
+ *      against each param's canonical `name`, plus the human-display
+ *      fields `wikiName` (e.g. `"INPUT DRIVE"`), `xmlLabel` (e.g.
+ *      `"Input Drive"`), and `parameterName` (firmware name, e.g.
+ *      `"DISTORT_DRIVE"`). Free coverage for anyone who types what they
+ *      see in AxeEdit.
+ *
+ *   3. **Per-group hardcoded English aliases.** For the cases where the
+ *      common English word doesn't match any of the device's labels —
+ *      `"gain"` on amp (canonical `input_drive`), `"master"`
+ *      (`master_volume`), `"mid"` (`middle`).
+ *
+ * Used by both the legacy `axefx2_*` tool surface (`tools/shared.ts`,
+ * `tools/applyExecutor.ts`) and the unified-surface descriptor
+ * (`descriptor/writer.ts`, `descriptor/reader.ts`). Updating this file
+ * updates both surfaces — no cross-module sync drift.
+ */
+import { type AxeFxIIParam } from './params.js';
+import type { AxeFxIIBlock } from './blockTypes.js';
+/**
+ * Per-block-group aliases for common English param names that don't
+ * appear in any of the device's own labels. Add an entry here ONLY when
+ * the canonical word the user reaches for is genuinely absent from the
+ * param's `name` / `wikiName` / `xmlLabel` / `parameterName` — fuzzy
+ * normalization covers most cases for free.
+ *
+ * Scoped per group code so the same English word can resolve differently
+ * across blocks. "gain" on AMP → `input_drive`, but "gain" on DRV is
+ * already the canonical name (no alias entry needed there).
+ */
+export declare const PARAM_ALIASES_AXEFX2: Readonly<Record<string, Readonly<Record<string, string>>>>;
+/**
+ * Resolve a user-supplied param name (string) to its `AxeFxIIParam`
+ * within the given block's group, applying the three-layer cascade
+ * above. Returns `undefined` if nothing matches at any layer.
+ *
+ * `block` is the resolved `AxeFxIIBlock` (e.g. Amp 1), not a raw string;
+ * the group code drives both the candidate filter and the alias-table
+ * key.
+ */
+export declare function findParamFuzzy(block: AxeFxIIBlock, userInput: string): AxeFxIIParam | undefined;
+//# sourceMappingURL=paramAliases.d.ts.map

package/dist/axe-fx-ii/paramAliases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paramAliases.d.ts","sourceRoot":"","sources":["../../src/axe-fx-ii/paramAliases.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAgB,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CA6C3F,CAAC;AAkBF;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CA+B/F"}

package/dist/axe-fx-ii/paramAliases.js

@@ -0,0 +1,146 @@
+/**
+ * Axe-Fx II — param-name fuzzy resolution.
+ *
+ * Single source of truth for every code path that resolves a user-typed
+ * param name to the device's canonical wire param. Three layers, tried
+ * in order:
+ *
+ *   1. **Exact canonical match** — `name === userInput.toLowerCase()`.
+ *      Fast path; hits 90%+ of well-formed agent calls.
+ *
+ *   2. **Normalized fuzzy match against display fields.** User input is
+ *      normalized to lowercase snake_case (`"Input Drive"`, `"INPUT
+ *      DRIVE"`, `"input-drive"` all → `"input_drive"`); then compared
+ *      against each param's canonical `name`, plus the human-display
+ *      fields `wikiName` (e.g. `"INPUT DRIVE"`), `xmlLabel` (e.g.
+ *      `"Input Drive"`), and `parameterName` (firmware name, e.g.
+ *      `"DISTORT_DRIVE"`). Free coverage for anyone who types what they
+ *      see in AxeEdit.
+ *
+ *   3. **Per-group hardcoded English aliases.** For the cases where the
+ *      common English word doesn't match any of the device's labels —
+ *      `"gain"` on amp (canonical `input_drive`), `"master"`
+ *      (`master_volume`), `"mid"` (`middle`).
+ *
+ * Used by both the legacy `axefx2_*` tool surface (`tools/shared.ts`,
+ * `tools/applyExecutor.ts`) and the unified-surface descriptor
+ * (`descriptor/writer.ts`, `descriptor/reader.ts`). Updating this file
+ * updates both surfaces — no cross-module sync drift.
+ */
+import { KNOWN_PARAMS } from './params.js';
+/**
+ * Per-block-group aliases for common English param names that don't
+ * appear in any of the device's own labels. Add an entry here ONLY when
+ * the canonical word the user reaches for is genuinely absent from the
+ * param's `name` / `wikiName` / `xmlLabel` / `parameterName` — fuzzy
+ * normalization covers most cases for free.
+ *
+ * Scoped per group code so the same English word can resolve differently
+ * across blocks. "gain" on AMP → `input_drive`, but "gain" on DRV is
+ * already the canonical name (no alias entry needed there).
+ */
+export const PARAM_ALIASES_AXEFX2 = {
+    AMP: {
+        gain: 'input_drive',
+        master: 'master_volume',
+        mid: 'middle',
+    },
+    DRV: {
+        // The Drive block's gain knob is `gain` on Axe-Fx II, `drive` on
+        // AM4. Cross-device users (and any agent who learned the AM4 naming
+        // first) reach for "drive" on the Drive block — accept it as an
+        // alias here. Also `level` → `volume` (common pedal-output naming).
+        drive: 'gain',
+        level: 'volume',
+    },
+    REV: {
+        // Reverb decay/length both map to time (canonical Fractal name).
+        // Mirrors AM4's PARAM_ALIASES entries.
+        decay: 'time',
+        length: 'time',
+        // Axe-Fx II's canonical name is the unspaced "predelay" — the
+        // alias direction here covers users who type "pre_delay" (which
+        // would normalize to "pre_delay" and not match) or "Pre Delay".
+        pre_delay: 'predelay',
+    },
+    DLY: {
+        // Strymon/Eventide convention: "repeats" instead of "feedback".
+        repeats: 'feedback',
+        length: 'time',
+    },
+    CHO: {
+        // Boss/MXR convention for modulation rate.
+        speed: 'rate',
+    },
+    FLG: {
+        speed: 'rate',
+    },
+    PHA: {
+        speed: 'rate',
+    },
+    TRM: {
+        speed: 'rate',
+    },
+    // Reverb/Delay/Chorus canonical-name knobs (mix, level, time, etc.)
+    // are already common English — fuzzy normalization handles capitalization
+    // and separators ("Mix" → "mix", "PRE DELAY" → "pre_delay").
+};
+/**
+ * Normalize a param-name candidate for fuzzy matching. Lower-cases,
+ * collapses any run of non-alphanumeric characters to a single `_`, and
+ * trims leading/trailing underscores.
+ *
+ * Examples:
+ *   "Input Drive"       → "input_drive"
+ *   "INPUT DRIVE"       → "input_drive"
+ *   "input-drive"       → "input_drive"
+ *   "Speaker\nDrive"    → "speaker_drive"  (xmlLabel for speaker_drive)
+ *   "DISTORT_DRIVE"     → "distort_drive"
+ */
+function normalize(s) {
+    return s.trim().toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '');
+}
+/**
+ * Resolve a user-supplied param name (string) to its `AxeFxIIParam`
+ * within the given block's group, applying the three-layer cascade
+ * above. Returns `undefined` if nothing matches at any layer.
+ *
+ * `block` is the resolved `AxeFxIIBlock` (e.g. Amp 1), not a raw string;
+ * the group code drives both the candidate filter and the alias-table
+ * key.
+ */
+export function findParamFuzzy(block, userInput) {
+    const groupUpper = block.groupCode.toUpperCase();
+    const candidates = [];
+    for (const p of Object.values(KNOWN_PARAMS)) {
+        if (p.groupCode === groupUpper)
+            candidates.push(p);
+    }
+    // Layer 1: exact canonical match (fast path).
+    const lower = userInput.trim().toLowerCase();
+    for (const p of candidates) {
+        if (p.name === lower)
+            return p;
+    }
+    // Layer 2: normalized fuzzy match against display fields.
+    const normalizedInput = normalize(userInput);
+    for (const p of candidates) {
+        if (normalize(p.name) === normalizedInput)
+            return p;
+        if (p.wikiName && normalize(p.wikiName) === normalizedInput)
+            return p;
+        if (p.xmlLabel && normalize(p.xmlLabel) === normalizedInput)
+            return p;
+        if (p.parameterName && normalize(p.parameterName) === normalizedInput)
+            return p;
+    }
+    // Layer 3: per-group hardcoded English alias.
+    const aliasTarget = PARAM_ALIASES_AXEFX2[groupUpper]?.[lower];
+    if (aliasTarget !== undefined) {
+        for (const p of candidates) {
+            if (p.name === aliasTarget)
+                return p;
+        }
+    }
+    return undefined;
+}