From 0c41f5691ce96950693ba5b796d0acbf2b6dc0b4 Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Wed, 11 Nov 2026 06:13:52 +0700 Subject: [PATCH 01/17] H2: verified JUCE hosted VST3 parameter-ID policy, fail-closed browse and normalized control --- src/NativeFxParameterHotkey.h | 97 +++++++++++++++++++++++++++++++++++ 1 file changed, 97 insertions(+) create mode 100644 src/NativeFxParameterHotkey.h diff --git a/src/NativeFxParameterHotkey.h b/src/NativeFxParameterHotkey.h new file mode 100644 index 000000000..f6c8f9832 --- /dev/null +++ b/src/NativeFxParameterHotkey.h @@ -0,0 +1,97 @@ +// SPDX-License-Identifier: AGPL-3.0-only +#pragma once +#include +#include +#include +#include + +// H2 host-side parameter identity: never persist JUCE parameter array indexes. +// JUCE's HostedAudioProcessorParameter::getParameterID() is the VST3 host's +// stable vendor-facing parameter ID; plugins without this surface cannot be +// safely mapped, even if their GUI displays a recognizable knob. +namespace armix::hotkey { +struct FxParameterTarget final { + juce::String id,name; + int index=-1,steps=0; + bool toggle=false; + float normalized=0.f; +}; +class FxParameterPolicy final { +public: + static constexpr int maxParameters=512; + static constexpr int maxIdLength=96; + static bool validId(const juce::String& value) noexcept { + return value.isNotEmpty() && value.length()<=maxIdLength && + !value.containsAnyOf("\r\n\t"); + } + static juce::String hostedId(const juce::AudioProcessorParameter* parameter) { + if(!parameter||!parameter->isAutomatable()||parameter->isMetaParameter()) + return {}; + const auto* hosted=dynamic_cast(parameter); + if(!hosted)return {}; + const auto id=hosted->getParameterID(); + return validId(id)?id:juce::String{}; + } + static bool isToggle(const juce::AudioProcessorParameter& parameter) { + return parameter.isDiscrete()&¶meter.getNumSteps()==2; + } + static bool operationAllowed(const juce::AudioProcessorParameter& parameter, + const juce::String& operation) { + if(!parameter.isAutomatable()||parameter.isMetaParameter())return false; + if(operation=="SET_FX_PARAM_TOGGLE")return isToggle(parameter); + if(operation=="SET_FX_PARAM_UP"||operation=="SET_FX_PARAM_DOWN") + return !isToggle(parameter); + return false; + } + // The caller supplies a verified, leased live processor. Each candidate ID + // must be unique; duplicate / missing stable IDs are never matched by index. + static juce::AudioProcessorParameter* find( + const juce::Array& parameters, + const juce::String& id, int* position=nullptr) { + if(!validId(id)||parameters.size()>maxParameters)return nullptr; + juce::AudioProcessorParameter* found=nullptr; + int foundIndex=-1; + for(int i=0;i browse( + const juce::Array& parameters) { + std::vector result; + if(parameters.size()>maxParameters)return result; + result.reserve(static_cast(parameters.size())); + for(int i=0;igetValue(); + if(!std::isfinite(value)||value<0.f||value>1.f)continue; + result.push_back({id,p->getName(100),i,p->getNumSteps(), + isToggle(*p),value}); + } + return result; + } + // Continuous controls take 5% of the *normalized* vendor range per key + // press; discrete controls take one actual vendor step. No key held repeat. + static bool desired(const juce::AudioProcessorParameter& p, + const juce::String& operation,float& next) { + if(!operationAllowed(p,operation))return false; + const float before=p.getValue(); + if(!std::isfinite(before)||before<0.f||before>1.f)return false; + if(operation=="SET_FX_PARAM_TOGGLE") + next=before>=0.5f?0.f:1.f; + else { + const int n=p.getNumSteps(); + const float step=p.isDiscrete()&&n>2 && n<100000? + 1.f/static_cast(n-1):0.05f; + next=std::clamp(before+(operation=="SET_FX_PARAM_UP"?step:-step),0.f,1.f); + } + return std::isfinite(next); + } +}; +} // namespace armix::hotkey From e207484024c18c4e8d23be6f3d772150c77fa7c2 Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Wed, 11 Nov 2026 06:14:09 +0700 Subject: [PATCH 02/17] H2: capture genuine plugin begin-gesture last-touched index without realtime allocation --- engine/core/LiveChannelFxGraph.h | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/engine/core/LiveChannelFxGraph.h b/engine/core/LiveChannelFxGraph.h index 0c32f3edb..1ca1d5c53 100644 --- a/engine/core/LiveChannelFxGraph.h +++ b/engine/core/LiveChannelFxGraph.h @@ -40,6 +40,10 @@ class LiveChannelFxGraph final { const juce::String instanceId; // stable through MOVE; never a slot index const int latencySamples; std::atomic latencyChanged{false}; + // Vendor editor beginChangeGesture -> atomic index; never allocate, + // call JS or touch the JUCE message loop from a parameter callback. + std::atomic lastTouchedParameter{-1}; + std::atomic hostHotkeyWrite{false}; armix::dsp::StereoLatencyDelay dryDelay; std::atomic bypassRequested{false}; armix::dsp::FxBypassEnvelope bypassFade; // RT exclusive state @@ -101,6 +105,11 @@ class LiveChannelFxGraph final { } } void audioProcessorParameterChanged(juce::AudioProcessor*,int,float) override {} + void audioProcessorParameterChangeGestureBegin( + juce::AudioProcessor*,int parameterIndex) override { + if(!hostHotkeyWrite.load(std::memory_order_acquire)) + lastTouchedParameter.store(parameterIndex,std::memory_order_release); + } void audioProcessorChanged(juce::AudioProcessor* p, const juce::AudioProcessorListener::ChangeDetails& details) override { if(details.latencyChanged && p && p->getLatencySamples()!=latencySamples) From b8ee52d19d02f67b3321c0fa49da73a20a233f8c Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Wed, 11 Nov 2026 06:14:38 +0700 Subject: [PATCH 03/17] H2: store real vendor hosted ParamID + FX catalog/instance identity in native hotkey journal and .smix --- src/NativeHotkeyRegistry.h | 46 ++++++++++++++++++++++++++++++-------- 1 file changed, 37 insertions(+), 9 deletions(-) diff --git a/src/NativeHotkeyRegistry.h b/src/NativeHotkeyRegistry.h index 08df695cf..47048bab4 100644 --- a/src/NativeHotkeyRegistry.h +++ b/src/NativeHotkeyRegistry.h @@ -35,6 +35,8 @@ struct Mapping final { // Preserve the exact plugin instance, not merely the positional slot. int slot=-1; juce::String insertId; + // H2: real hosted VST3 identity. Index/slot are discovery hints only. + juce::String catalogId,paramId; }; class Registry final { public: @@ -52,13 +54,22 @@ class Registry final { const bool chord=(m.modifiers&~7)==0 && (m.modifiers&3)!=0; // global chords need Ctrl or Alt const bool fxSlot=m.operation=="SET_FX_SLOT_BYPASS"; + const bool fxParam=m.operation=="SET_FX_PARAM_TOGGLE"|| + m.operation=="SET_FX_PARAM_UP"|| + m.operation=="SET_FX_PARAM_DOWN"; const bool command=m.operation=="PANIC_MUTE" || m.operation=="SET_MUTE"||m.operation=="SET_SOLO"|| - m.operation=="SET_FX_RACK_BYPASS"||fxSlot; - const bool target=fxSlot? - m.slot>=0 && m.slot<8 && m.insertId.isNotEmpty() && - m.insertId.length()<=128: - m.slot==-1 && m.insertId.isEmpty(); + m.operation=="SET_FX_RACK_BYPASS"||fxSlot||fxParam; + const bool hasInsert=m.slot>=0 && m.slot<8 && m.insertId.isNotEmpty() && + m.insertId.length()<=128; + const bool paramTarget=fxParam && hasInsert && + m.catalogId.isNotEmpty() && m.catalogId.length()<=512 && + m.paramId.isNotEmpty() && m.paramId.length()<=96 && + !m.paramId.containsAnyOf("\r\n\t"); + const bool target=fxParam?paramTarget: + fxSlot?(hasInsert&&m.catalogId.isEmpty()&&m.paramId.isEmpty()): + (m.slot==-1&&m.insertId.isEmpty()&& + m.catalogId.isEmpty()&&m.paramId.isEmpty()); const bool app=m.scope=="APP" && m.operation=="PANIC_MUTE" && m.channelId.isEmpty() && m.sessionId.isEmpty(); const bool session=m.scope=="SESSION" && m.operation!="PANIC_MUTE" && @@ -76,9 +87,14 @@ class Registry final { o->setProperty("channelId",m.channelId); o->setProperty("operation",m.operation); o->setProperty("vk",m.vk);o->setProperty("modifiers",m.modifiers); - if(m.operation=="SET_FX_SLOT_BYPASS") { + if(m.operation=="SET_FX_SLOT_BYPASS"|| + m.operation.startsWith("SET_FX_PARAM_")) { o->setProperty("slot",m.slot); o->setProperty("insertId",m.insertId); + if(m.operation.startsWith("SET_FX_PARAM_")) { + o->setProperty("catalogId",m.catalogId); + o->setProperty("paramId",m.paramId); + } } return out; } @@ -94,14 +110,26 @@ class Registry final { !field("sessionId",m.sessionId)||!field("channelId",m.channelId)|| !field("operation",m.operation)||!vk.isInt()||!mods.isInt())return false; m.vk=static_cast(vk);m.modifiers=static_cast(mods); - m.slot=-1;m.insertId.clear(); // old H1 documents remain readable - if(m.operation=="SET_FX_SLOT_BYPASS") { + m.slot=-1;m.insertId.clear();m.catalogId.clear();m.paramId.clear(); + const bool fxParam=m.operation.startsWith("SET_FX_PARAM_"); + if(m.operation=="SET_FX_SLOT_BYPASS"||fxParam) { const auto slot=v.getProperty("slot",{}),token=v.getProperty("insertId",{}); if(!slot.isInt()||!token.isString()||token.toString().length()>128) return false; m.slot=static_cast(slot);m.insertId=token.toString(); + if(fxParam) { + const auto catalog=v.getProperty("catalogId",{}); + const auto parameter=v.getProperty("paramId",{}); + if(!catalog.isString()||!parameter.isString() || + catalog.toString().length()>512|| + parameter.toString().length()>96)return false; + m.catalogId=catalog.toString();m.paramId=parameter.toString(); + }else if(!v.getProperty("catalogId",{}).isVoid() || + !v.getProperty("paramId",{}).isVoid())return false; } else if(!v.getProperty("slot",{}).isVoid() || - !v.getProperty("insertId",{}).isVoid())return false; + !v.getProperty("insertId",{}).isVoid()|| + !v.getProperty("catalogId",{}).isVoid()|| + !v.getProperty("paramId",{}).isVoid())return false; return valid(m); } void setHandler(std::function handler) { From e85892e124536668633670ef7f47c5f63923ea6b Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Wed, 11 Nov 2026 06:16:36 +0700 Subject: [PATCH 04/17] H2: native hosted VST3 ParamID inspection, exact live lease validation and safe background parameter shortcuts --- src/Main.cpp | 176 +++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 172 insertions(+), 4 deletions(-) diff --git a/src/Main.cpp b/src/Main.cpp index 8fd58c156..8c4fc2fa0 100644 --- a/src/Main.cpp +++ b/src/Main.cpp @@ -39,6 +39,7 @@ #include "NativeMixerSessionSaveWorker.h" #include "NativeLogicalMixerControl.h" #include "NativeHotkeyRegistry.h" +#include "NativeFxParameterHotkey.h" #include "NativeDeviceApplyCoordinator.h" #include #include @@ -280,6 +281,9 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr .withEventListener ("arMixHotkeyCapture", [this] (juce::var args) { hotkeys_.setCaptureMode(args.getProperty("enabled",false)==juce::var(true)); }) + .withEventListener ("arMixFxParameterHotkeyInspect", [this] (juce::var args) { + inspectFxParameterHotkey(args); + }) .withEventListener ("arMixConsoleSubscribe", [this] (juce::var) { // G0 real-device native producer, NEVER a synthetic ChannelId callback. consoleSubscribed_ = true; @@ -1252,6 +1256,154 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr reply("Offline FX settings could not be saved"); } + // H2: verify real live VST3 lease and class identity. The positional slot + // is a GUI hint only; moves resolve by the exact FX instance token. + struct FxHotkeyLease final { + armix::mixer::LiveChannelFxGraph::InstanceLease owner; + juce::AudioPluginInstance* plugin=nullptr; + int slot=-1; + }; + FxHotkeyLease resolveFxHotkey(const juce::String& channelId, + const juce::String& insertId,const juce::String& catalogId) { + FxHotkeyLease target; + if(channelId.isEmpty()||insertId.isEmpty()||catalogId.isEmpty()|| + deviceApply_.busy()||nativeShowBusy_||studioBackupBusy_|| + engine_.independentClockActive()||engine_.isGraphSwitchPending()) + return target; + const auto snapshot=approvedNativeSnapshot(); + const auto graph=snapshot.getProperty("graph",{}); + if(!static_cast(graph.getProperty("capabilities",{}) + .getProperty("callbackOwnsChannelIds",false)))return target; + std::uint64_t id=0,epoch=0,revision=0; + if(!armix::console::approvedNativeId(juce::var(channelId),id)|| + !armix::console::approvedNativeId( + snapshot.getProperty("device",{}).getProperty("epoch",{}),epoch)|| + !armix::console::approvedNativeId( + graph.getProperty("revision",{}),revision))return target; + const auto rows=graph.getProperty("channels",{}); + if(!rows.isArray())return target; + for(const auto& row:*rows.getArray()) { + if(row.getProperty("id","").toString()!=channelId || + (row.getProperty("role","").toString()!="INPUT" && + row.getProperty("role","").toString()!="GROUP" && + row.getProperty("role","").toString()!="FX_RETURN"))continue; + const auto inserts=row.getProperty("inserts",{}); + if(!inserts.isArray())return target; + const auto* all=inserts.getArray(); + for(int slot=0;slotsize();++slot) { + const auto entry=all->getReference(slot); + if(entry.getProperty("id","").toString()!=insertId || + entry.getProperty("catalogId","").toString()!=catalogId) + continue; + auto owner=engine_.leaseNativeVst3Editor(epoch,revision, + armix::mixer::ChannelId{id},static_cast(slot),insertId); + if(!owner||owner->instanceId!=insertId|| + owner->catalogId!=catalogId||!owner->processor)return target; + auto* plugin=dynamic_cast(owner->processor.get()); + if(!plugin)return target; + juce::PluginDescription description; + plugin->fillInPluginDescription(description); + if(!description.pluginFormatName.equalsIgnoreCase("VST3"))return target; + target.owner=std::move(owner); + target.plugin=plugin; + target.slot=slot; + return target; + } + break; + } + return target; + } + bool fxParameterHotkeyAdmitted(const armix::hotkey::Mapping& mapping) { + auto target=resolveFxHotkey(mapping.channelId,mapping.insertId,mapping.catalogId); + if(!target.plugin)return false; + auto* parameter=armix::hotkey::FxParameterPolicy::find( + target.plugin->getParameters(),mapping.paramId); + return parameter&&armix::hotkey::FxParameterPolicy::operationAllowed( + *parameter,mapping.operation); + } + bool applyFxParameterHotkey(const armix::hotkey::Mapping& mapping) { + auto target=resolveFxHotkey(mapping.channelId,mapping.insertId,mapping.catalogId); + if(!target.plugin)return false; + auto* parameter=armix::hotkey::FxParameterPolicy::find( + target.plugin->getParameters(),mapping.paramId); + float next=0.f; + if(!parameter || + !armix::hotkey::FxParameterPolicy::desired(*parameter,mapping.operation,next)) + return false; + // Call JUCE's notifying setter only on CONTROL, never on PCM callback. + // Host-written beginChangeGesture is not mistaken for vendor Last Touched. + target.owner->hostHotkeyWrite.store(true,std::memory_order_release); + bool applied=false; + try { + parameter->beginChangeGesture(); + parameter->setValueNotifyingHost(next); + parameter->endChangeGesture(); + applied=true; + } catch(...) { + try {parameter->endChangeGesture();}catch(...){} + } + target.owner->hostHotkeyWrite.store(false,std::memory_order_release); + if(applied) + diagnostics_.record("NATIVE_FX_PARAM_HOTKEY", + mapping.channelId+" / "+mapping.insertId+" / "+mapping.paramId); + return applied; + } + void inspectFxParameterHotkey(const juce::var& request) { + const auto requestId=request.getProperty("requestId","").toString(); + const auto channelId=request.getProperty("channelId","").toString(); + const auto insertId=request.getProperty("insertId","").toString(); + const auto catalogId=request.getProperty("catalogId","").toString(); + const auto observed=approvedNativeSnapshot(); + const auto graph=observed.getProperty("graph",{}); + auto response=juce::var(new juce::DynamicObject()); + auto* result=response.getDynamicObject(); + result->setProperty("requestId",requestId); + result->setProperty("channelId",channelId); + result->setProperty("insertId",insertId); + result->setProperty("catalogId",catalogId); + result->setProperty("ok",false); + result->setProperty("error","HOTKEY_FX_STALE_OR_UNAVAILABLE"); + const bool current=requestId.isNotEmpty()&&requestId.length()<=96 && + request.getProperty("deviceEpoch","").toString()== + observed.getProperty("device",{}).getProperty("epoch","").toString() && + request.getProperty("revision","").toString()== + graph.getProperty("revision","").toString() && + request.getProperty("rosterRevision","").toString()== + graph.getProperty("rosterRevision","").toString(); + if(current) { + auto target=resolveFxHotkey(channelId,insertId,catalogId); + if(target.plugin) { + const auto info=armix::hotkey::FxParameterPolicy::browse( + target.plugin->getParameters()); + juce::Array listed; + const auto touched=target.owner->lastTouchedParameter.load( + std::memory_order_acquire); + juce::String lastTouchedId; + for(const auto& p:info) { + auto item=juce::var(new juce::DynamicObject()); + auto* o=item.getDynamicObject(); + o->setProperty("id",p.id); + o->setProperty("name",p.name); + o->setProperty("index",p.index); // UI hint, never saved + o->setProperty("toggle",p.toggle); + o->setProperty("steps",p.steps); + o->setProperty("value",p.normalized); + listed.add(item); + if(touched==p.index)lastTouchedId=p.id; + } + result->setProperty("parameters",juce::var(listed)); + result->setProperty("lastTouchedId",lastTouchedId); + result->setProperty("slot",target.slot); + result->setProperty("name",target.plugin->getName()); + result->setProperty("ok",!info.empty()); + result->setProperty("error",info.empty()? + "VST3_STABLE_PARAMETER_IDS_UNAVAILABLE":"NONE"); + } + } + if(browser_.loaded) + browser_.emitEventIfBrowserIsVisible("arMixFxParameterHotkeyState",response); + } + // Native hotkeys share the accepted ChannelId mixer control path. // WM_HOTKEY is delivered on the JUCE message thread even while the // WebView is minimized, and never synthesizes a browser mouse click. @@ -1289,7 +1441,14 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr } break; } - const bool fx=op=="SET_FX_RACK_BYPASS"||op=="SET_FX_SLOT_BYPASS"; + const bool fxParam=op.startsWith("SET_FX_PARAM_"); + if(fxParam) { + armix::hotkey::Mapping mapping; + if(armix::hotkey::Registry::decode(row,mapping)) + fxAvailable=fxParameterHotkeyAdmitted(mapping); + } + const bool fx=op=="SET_FX_RACK_BYPASS"|| + op=="SET_FX_SLOT_BYPASS"||fxParam; const juce::String status= !admitted?"WAITING_NATIVE_AUDIO": !found?"NEEDS_REMAP": @@ -1332,7 +1491,8 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr const auto scope=supplied.getProperty("scope","").toString(); auto cleaned=juce::var(new juce::DynamicObject()); for(const char* field:{"id","scope","sessionId","channelId", - "operation","vk","modifiers","slot","insertId"}) { + "operation","vk","modifiers","slot","insertId", + "catalogId","paramId"}) { const auto value=supplied.getProperty(field,{}); if(!value.isVoid())cleaned.getDynamicObject()->setProperty(field,value); } @@ -1345,6 +1505,7 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr const auto op=supplied.getProperty("operation","").toString(); const bool fxRack=op=="SET_FX_RACK_BYPASS"; const bool fxSlot=op=="SET_FX_SLOT_BYPASS"; + const bool fxParam=op.startsWith("SET_FX_PARAM_"); bool found=false,fxAvailable=false; if(static_cast(caps.getProperty("callbackOwnsChannelIds",false)) && channels.isArray())for(const auto& c:*channels.getArray()) { @@ -1372,10 +1533,10 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr error="HOTKEY_FX_INSTANCE_NOT_ADMITTED"; const auto ops=caps.getProperty("supportedOps",{}); const auto* allowed=ops.getArray(); - if(error.isEmpty() && !fxRack && !fxSlot && + if(error.isEmpty() && !fxRack && !fxSlot && !fxParam && op!="SET_MUTE" && op!="SET_SOLO") error="HOTKEY_ACTION_UNSUPPORTED"; - if(error.isEmpty() && !fxRack && !fxSlot && + if(error.isEmpty() && !fxRack && !fxSlot && !fxParam && (!allowed || !allowed->contains(juce::var(op)))) error="HOTKEY_ACTION_NOT_ADMITTED"; if(error.isEmpty()) { @@ -1389,6 +1550,9 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr armix::hotkey::Mapping mapping; if(error.isEmpty() && !armix::hotkey::Registry::decode(cleaned,mapping)) error="INVALID_HOTKEY_MAPPING"; + if(error.isEmpty()&&mapping.operation.startsWith("SET_FX_PARAM_")&& + !fxParameterHotkeyAdmitted(mapping)) + error="HOTKEY_PARAMETER_ID_OR_INSTANCE_UNAVAILABLE"; if(error.isEmpty())error=hotkeys_.upsert(std::move(mapping)); } else error="UNSUPPORTED_HOTKEY_OPERATION"; } @@ -1420,6 +1584,10 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr match=&ch;break; } if(!match)return; + if(mapping.operation.startsWith("SET_FX_PARAM_")) { + (void)applyFxParameterHotkey(mapping); + return; + } const bool fxRack=mapping.operation=="SET_FX_RACK_BYPASS"; const bool fxSlot=mapping.operation=="SET_FX_SLOT_BYPASS"; if(fxRack||fxSlot) { From 6f2d24246047c6c75eb28ce1cea68cc10824de47 Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Wed, 11 Nov 2026 06:18:12 +0700 Subject: [PATCH 05/17] H2 native GUI: FX-header Browse Parameters and Last Touched fallback, exact ParamID shortcut capture --- web/approved-native-context-menu.js | 177 ++++++++++++++++++++++++++-- 1 file changed, 168 insertions(+), 9 deletions(-) diff --git a/web/approved-native-context-menu.js b/web/approved-native-context-menu.js index cf0ae12a9..5a23bffd6 100644 --- a/web/approved-native-context-menu.js +++ b/web/approved-native-context-menu.js @@ -18,7 +18,16 @@ "#armixOrbit .head{display:flex;align-items:center;justify-content:space-between;gap:8px;margin-bottom:8px;font-size:14px;font-weight:550;cursor:grab;touch-action:none}", "#armixOrbit .head:active{cursor:grabbing}", "#armixContext button:disabled{opacity:.35;cursor:default}", - "#armixHotkeyCard[hidden],#armixHotkeyRegister[hidden]{display:none!important}", + "#armixHotkeyCard[hidden],#armixHotkeyRegister[hidden],#armixFxParamBrowse[hidden]{display:none!important}", + "#armixFxParamBrowse{position:fixed;z-index:10026;width:355px;max-width:calc(100vw - 16px);max-height:76vh;box-sizing:border-box;display:flex;flex-direction:column;overflow:hidden;padding:11px;border:1px solid #507584;border-radius:7px;background:#142933;box-shadow:0 15px 35px #000b;color:#e0edf2;font:12px Inter,system-ui,sans-serif}", + "#armixFxParamBrowse input{width:100%;box-sizing:border-box;height:29px;padding:5px 8px;background:#0d202a;color:#e5f4f6;border:1px solid #426a7b;border-radius:4px}", + "#armixFxParamBrowse .armix-param-list{overflow-y:auto;min-height:64px;margin-top:8px}", + "#armixFxParamBrowse .armix-param-row{padding:8px 2px;border-bottom:1px solid #304c5b;display:flex;align-items:center;gap:5px;justify-content:space-between}", + "#armixFxParamBrowse .armix-param-name{min-width:0;flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}", + "#armixFxParamBrowse .armix-param-actions{display:flex;flex-shrink:0;gap:4px}", + "#armixFxParamBrowse button{cursor:pointer;border:1px solid #426c7d;border-radius:4px;background:#225061;color:#e4f5f7;padding:4px 7px;font:11px Inter,system-ui,sans-serif}", + "#armixFxParamBrowse .armix-param-row span small{display:block;color:#88aebc;font-size:10px}", + "#armixHotkeyCard,#armixHotkeyRegister{position:fixed;z-index:10028;box-sizing:border-box;max-width:calc(100vw - 16px);padding:12px;border:1px solid #4b7180;border-radius:7px;background:#132731;color:#dbeef4;box-shadow:0 14px 35px #000c;font:12px Inter,system-ui,sans-serif}", "#armixHotkeyCard{width:286px}#armixHotkeyRegister{width:580px;max-height:76vh;display:flex;flex-direction:column}", ".armix-hk-head{display:flex;justify-content:space-between;align-items:center;gap:10px;cursor:grab;touch-action:none;font-weight:550;font-size:12px;margin-bottom:10px}", @@ -84,6 +93,18 @@ '
'+ '
'; document.body.appendChild(hotkeyRegister); + const fxParamPanel=document.createElement("section"); + fxParamPanel.id="armixFxParamBrowse";fxParamPanel.hidden=true; + fxParamPanel.setAttribute("role","dialog"); + fxParamPanel.setAttribute("aria-label","Assign Parameter Hotkey"); + fxParamPanel.innerHTML= + '
VST3 PARAMETERS
'+ + '
'+ + ''+ + '
Reading VST3 parameters…
'+ + '
'; + document.body.appendChild(fxParamPanel); + let fxParamSelection=null,fxParamStatus=null,fxParamRequest=""; const moreTools=document.querySelector("#moreTools .more-tools-panel"); if(moreTools){ const openButton=document.createElement("button"); @@ -144,6 +165,13 @@ '':'')+ ''; } + }else if(kind==="fx"){ + menu.innerHTML= + ''+ + ''+ + (hooks.orbitTarget(menuTrack,menuSlot)? + '':'')+ + ''; }else if(kind==="hotkey"){ const existing=hotkeyEntries.find(m=>sameHotkeyTarget(m,menuTarget)); menu.innerHTML='