diff --git a/integration/ApprovedNativeRuntimeSnapshot.h b/integration/ApprovedNativeRuntimeSnapshot.h index eaafd93b0..8c0fa82f0 100644 --- a/integration/ApprovedNativeRuntimeSnapshot.h +++ b/integration/ApprovedNativeRuntimeSnapshot.h @@ -82,6 +82,70 @@ inline bool publishVerifiedFirstSoundState(juce::var& snapshot, boolIs(route,"hasAcceptedRoute",true)); firstSound->setProperty("routingRevision",physicalReady ?juce::String(static_cast(revision)):juce::String("0")); + // The default GUI IN selector must reflect the ACTUAL accepted or + // verified prepared M4 topology, never the Pages demo route string. + // All ten lanes are independently selectable (including sparse ASIO pins). + if(physicalReady) { + const auto topology=boolIs(route,"hasAcceptedRoute",true) + ?route.getProperty("acceptedRoute",{}) + :route.getProperty("preparedM4Route",{}); + const auto sourceRows=topology.getProperty("channels",{}); + const auto* entries=sourceRows.getArray(); + bool valid=entries && entries->size()==10; + if(valid)for(const auto& row:*entries) { + const auto mode=row.getProperty("mode",{}).toString(); + if(!row.isObject()|| + (mode!="NONE"&&mode!="MONO"&&mode!="STEREO"&&mode!="BUS")) { + valid=false;break; + } + if(mode=="MONO"||mode=="STEREO") { + const auto left=row.getProperty("left",{}),right=row.getProperty("right",{}); + if(!left.isInt() && !left.isInt64()){valid=false;break;} + if(mode=="STEREO" && !right.isInt() && !right.isInt64()) { + valid=false;break; + } + } + } + if(valid)firstSound->setProperty("channelSources",sourceRows); + } + // G0 may still have the genuine 10-strip M4 DSP callback. Export its + // existing atomic control readback without falsely admitting ChannelId. + // A fresh/unpatched device must NEVER display pseudo-active controls. + if(physicalReady && boolIs(route,"hasAcceptedRoute",true) && + !boolIs(route,"nativeChannelIdPcmActive",true)) { + const auto controls=route.getProperty("channelControls",{}); + const auto levelsL=route.getProperty("channelPeaksL",{}); + const auto levelsR=route.getProperty("channelPeaksR",{}); + const auto* ctl=controls.getArray(); + const auto* left=levelsL.getArray(); + const auto* right=levelsR.getArray(); + bool valid=ctl && left && right && ctl->size()==10 && + left->size()==10 && right->size()==10; + if(valid)for(int i=0;i<10;++i) { + const auto c=ctl->getReference(i); + double db=0.,pan=0.,peakL=0.,peakR=0.; + if(!c.isObject()|| + !nativeV8Number(c.getProperty("db",{}),db) || + !nativeV8Number(c.getProperty("pan",{}),pan) || + !nativeV8Number(left->getReference(i),peakL) || + !nativeV8Number(right->getReference(i),peakR) || + db < -60.01 || db > 10.01 || pan < -100.01 || pan > 100.01 || + peakL < 0. || peakR < 0. || + !c.getProperty("mute",{}).isBool() || + !c.getProperty("solo",{}).isBool()) {valid=false;break;} + } + if(valid) { + firstSound->setProperty("channelControls",controls); + firstSound->setProperty("channelPeaksL",levelsL); + firstSound->setProperty("channelPeaksR",levelsR); + double masterDb=0.; + if(nativeV8Number(live.getProperty("masterDb",{}),masterDb) && + masterDb>=-60.01 && masterDb<=12.01) + firstSound->setProperty("masterDb",masterDb); + const auto muted=live.getProperty("masterMute",{}); + if(muted.isBool())firstSound->setProperty("masterMute",muted); + } + } // Do not write the route to the graph or change native capability flags. snapshot.getDynamicObject()->setProperty("legacyM4",juce::var(firstSound.release())); return physicalReady; diff --git a/tests/approved_native_m2_contract.test.cjs b/tests/approved_native_m2_contract.test.cjs index 2b584dd09..d044deddf 100644 --- a/tests/approved_native_m2_contract.test.cjs +++ b/tests/approved_native_m2_contract.test.cjs @@ -114,6 +114,29 @@ test("native signal evidence is produced from measured engine fields, never JS s assert.doesNotMatch(transport,/setProperty \("rawCapturePeak", 0\.0\)/); assert.match(bridge,/protocol\.diagnoseFirstSound/); }); +test("DAW-style all-channel IN / M4 fader mute pan use real native control and readback, never mock PCM",()=>{ + const bridge=read("web/approved-native-bridge.js"); + const io=read("web/mixer-io.js"); + const producer=read("integration/ApprovedNativeRuntimeSnapshot.h"); + const engine=read("src/LiveDryRoutingLab.h"); + const nativeMain=read("src/Main.cpp"); + assert.match(bridge,/select\[data-field="input"\]/); + assert.match(bridge,/function chooseNativeStripInput\(select\)/); + assert.match(bridge,/field==="input"/); + assert.match(bridge,/chooseNativeStripInput\(el\)/); + assert.match(bridge,/function paintM4Readback\(next\)/); + assert.match(bridge,/channelControls/); + assert.match(bridge,/parameter,channel:channel\+1,value/); + assert.match(bridge,/routeEpoch:safeNativeCounter/); + assert.match(bridge,/m4StripIndex\(event\.target\)>=0/); + assert.match(producer,/firstSound->setProperty\("channelControls",controls\)/); + assert.match(producer,/firstSound->setProperty\("channelPeaksL",levelsL\)/); + assert.match(engine,/publisher_\.updateActiveControl\(expectedEpoch,expectedRevision/); + assert.match(nativeMain,/engine_\.setDryRoutingLabParameter\(channel-1,epoch,revision/); + assert.doesNotMatch(bridge,/const audioContext=new AudioContext/); + assert.doesNotMatch(bridge,/function synthesizePCM/); + assert.match(bridge,/action:"audioSetup"/); +}); test("strict producer rejects JS Number identities, invalid hardware pins and fake LIVE",()=>{ const cases=[ s=>{s.device.epoch=69;}, @@ -433,7 +456,9 @@ test("native Windows operator can explicitly patch first physical input, arm and const main=read("src/Main.cpp"); const engine=read("src/LiveAudioEngine.h"); assert.match(js,/REAL AUDIO · FIRST SOUND/); - assert.match(js,/action:"audioSetup"/); + assert.match(js,/function installNativeIo\(/); + assert.match(js,/action:"audioDeviceApply"/); + assert.match(js,/backend\.emitEvent\("arMixAction",\{action:"audioSetup"\}\)/); assert.match(js,/d\.inputEndpoints\.filter\(p=>/); assert.match(js,/d\.enabledInputs\.includes\(p\.port\)/); assert.match(js,/action:"routingSourceSwitch",requestId:pendingSourceId/); @@ -443,8 +468,8 @@ test("native Windows operator can explicitly patch first physical input, arm and assert.match(js,/expectedEpoch:epoch,expectedRevision:revision/); assert.match(js,/arMixSourceSwitchAck/); assert.match(js,/arMixAudioArmAck/); - assert.match(js,/if\(ack\.ok===true\)/); - assert.match(js,/NATIVE PATCH REJECTED:/); + assert.match(js,/ack\?\.ok===true/); + assert.match(js,/INPUT REJECTED/); assert.match(js,/NO VERIFIED AUDIO DEVICE/); assert.match(js,/NATIVE PCM · HARDWARE FAT PENDING/); assert.match(js,/MAIN ARMED · PCM NOT YET ADMITTED/); diff --git a/tests/approved_native_v8_projection_test.cpp b/tests/approved_native_v8_projection_test.cpp index 335593c5a..40b854d65 100644 --- a/tests/approved_native_v8_projection_test.cpp +++ b/tests/approved_native_v8_projection_test.cpp @@ -457,6 +457,61 @@ static void firstSoundMeasuredSignalEvidenceRegression() { assert(!static_cast(signal(live,true,true).getProperty("captureObserved",true))); } +// G0 must expose actual installed M4 controls (not imaginary ChannelId) +// only while a verified direct, routed ten-channel callback exists. +static void firstSoundM4ConsoleControlsRegression() { + auto snap=canonicalSnapshot(); + auto* dev=snap.getProperty("device",{}).getDynamicObject(); + dev->setProperty("epoch","7"); + dev->setProperty("sampleRate",48000.0); + dev->setProperty("bufferFrames",128); + juce::Array in,out; + in.add(0);out.add(0);out.add(1); + dev->setProperty("enabledInputs",juce::var(in)); + dev->setProperty("enabledOutputs",juce::var(out)); + auto live=parse(R"JSON({ + "connected":true,"directRouteAuthorized":true,"adaptiveClockActive":false, + "masterDb":-6.0,"masterMute":false, + "dryRoutingLab":{"active":true,"ready":true,"topologyFault":false, + "hasAcceptedRoute":true,"nativeChannelIdPcmActive":false, + "epoch":7,"revision":12,"channelControls":[], + "channelPeaksL":[],"channelPeaksR":[]} + })JSON"); + auto route=live.getProperty("dryRoutingLab",{}); + juce::Array controls,left,right; + for(int i=0;i<10;++i) { + auto* c=new juce::DynamicObject; + c->setProperty("db",i==4?-12.0:0.0); + c->setProperty("pan",0.0); + c->setProperty("mute",false); + c->setProperty("solo",false); + controls.add(juce::var(c));left.add(0.2);right.add(0.1); + } + route.getDynamicObject()->setProperty("channelControls",juce::var(controls)); + route.getDynamicObject()->setProperty("channelPeaksL",juce::var(left)); + route.getDynamicObject()->setProperty("channelPeaksR",juce::var(right)); + assert(publishVerifiedFirstSoundState(snap,live)); + auto m4=snap.getProperty("legacyM4",{}); + assert(m4.getProperty("channelControls",{}).getArray()->size()==10); + assert(static_cast(m4.getProperty("channelControls",{})[4] + .getProperty("db",{}))==-12.0); + assert(static_cast(m4.getProperty("masterDb",{}))==-6.0); + assert(!static_cast(snap.getProperty("graph",{}) + .getProperty("capabilities",{}).getProperty("callbackOwnsChannelIds",true))); + // Bad controls are not published despite a prepared device. + controls.removeLast(); + route.getDynamicObject()->setProperty("channelControls",juce::var(controls)); + assert(publishVerifiedFirstSoundState(snap,live)); + assert(snap.getProperty("legacyM4",{}) + .getProperty("channelControls",{}).isVoid()); + // Hotplug/stale epoch removes all previously displayed live controls. + controls.add(juce::var(new juce::DynamicObject)); + route.getDynamicObject()->setProperty("epoch",8); + assert(!publishVerifiedFirstSoundState(snap,live)); + assert(snap.getProperty("legacyM4",{}) + .getProperty("channelControls",{}).isVoid()); +} + int main() { auto snap=canonicalSnapshot(); auto bus=realBusReadbackFixture(); @@ -490,6 +545,7 @@ int main() { controlIntentTranslationCases(snap,bus); installedCallbackAdmissionRegression(bus); firstSoundRouteAdmissionRegression(); + firstSoundM4ConsoleControlsRegression(); firstSoundMeasuredSignalEvidenceRegression(); auto missingMain=realBusReadbackFixture(); diff --git a/web/approved-native-bridge.js b/web/approved-native-bridge.js index 7e548a6e3..149f846f8 100644 --- a/web/approved-native-bridge.js +++ b/web/approved-native-bridge.js @@ -208,6 +208,180 @@ "No verified hardware PCM readback available."; } } + // The approved Windows GUI is built from /preview/ (NOT web/mixer-io). + // A single compact device preference panel uses the existing JUCE + // AudioDeviceManager inventory/APPLY ACK. All controls stay off the DSP RT. + let ioInventory=null,ioDraft=null,ioPanel=null,ioRequest=null,ioAfterMute=null; + const virtualOutput=name=>/cable input|virtual cable|vb.audio|virtual audio/i.test(String(name||"")); + const cableFeedbackPair=()=>{ + const d=hardware?.device; + return /cable output/i.test(String(d?.captureDevice||"")) && + /cable input/i.test(String(d?.playbackDevice||"")) && + /vb.audio/i.test(String(d?.captureDevice||"")+" "+String(d?.playbackDevice||"")); + }; + const ioType=()=>ioInventory?.types?.find(t=>t.name===ioDraft?.backend); + function paintNativeIo(){ + if(!ioPanel||ioPanel.hidden||!ioInventory)return; + const active=ioInventory.active||{},types=ioInventory.types||[]; + if(!ioDraft)ioDraft={backend:active.backend||types[0]?.name||"", + captureDevice:active.captureDevice||"",playbackDevice:active.playbackDevice||"", + sampleRate:0,bufferSize:0}; + const setOptions=(id,values,current)=>{ + const sel=ioPanel.querySelector('[data-native-io="'+id+'"]'); + if(!sel)return; + const previous=sel.value,signature=JSON.stringify(values); + if(sel.dataset.options!==signature){ + sel.replaceChildren(...values.map(([value,label])=>new Option(label,value))); + sel.dataset.options=signature; + } + if(current!==undefined)sel.value=current; + else if(values.some(v=>v[0]===previous))sel.value=previous; + }; + setOptions("backend",types.map(t=>[t.name,t.name]),ioDraft.backend); + const type=ioType()||{}; + const outputs=type.outputs||[],inputs=type.separate?(type.inputs||[]):outputs; + if(!outputs.includes(ioDraft.playbackDevice))ioDraft.playbackDevice=outputs[0]||""; + if(!inputs.includes(ioDraft.captureDevice))ioDraft.captureDevice= + type.separate?inputs[0]||"":ioDraft.playbackDevice; + if(!type.separate)ioDraft.captureDevice=ioDraft.playbackDevice; + setOptions("capture",inputs.map(n=>[n,n]),ioDraft.captureDevice); + setOptions("playback",outputs.map(n=>[n,n]),ioDraft.playbackDevice); + const same=active.open&&active.backend===ioDraft.backend&& + active.captureDevice===ioDraft.captureDevice&& + active.playbackDevice===ioDraft.playbackDevice; + const rates=same?(active.rates||[]):[],buffers=same?(active.buffers||[]):[]; + setOptions("rate",[[0,"Auto"],...rates.map(n=>[n,Math.round(n)+" Hz"])], + ioDraft.sampleRate||0); + setOptions("buffer",[[0,"Auto"],...buffers.map(n=>[n,n+" samples"])], + ioDraft.bufferSize||0); + const selected=ioDraft.playbackDevice; + const hint=ioPanel.querySelector('[data-native-io="hint"]'); + if(hint)hint.textContent= + "Current: "+(active.open?active.backend+" · "+active.playbackDevice:"No audio device")+ + " · "+(active.rate||0)+" Hz / "+(active.buffer||0)+" samples. "+ + (virtualOutput(selected)? + "Selected output appears virtual: this is NOT a physical headphone/speaker. Choose a real playback device to listen.": + "Output: "+(selected||"not selected")+". Keep headphone volume low."); + const apply=ioPanel.querySelector('[data-native-io="apply"]'); + if(apply)apply.disabled=!!ioRequest||!ioDraft.captureDevice||!ioDraft.playbackDevice; + } + function installNativeIo(){ + if(!connected||ioPanel||typeof document.createElement!=="function")return; + const css=document.createElement("style"); + css.textContent=` + .armix-native-io{position:fixed;inset:0;z-index:200000;background:#0009; + display:grid;place-items:center;font:12px Inter,Arial,sans-serif;color:#d8eaf0} + .armix-native-io[hidden]{display:none} + .armix-native-io-panel{width:min(560px,calc(100vw - 32px)); + max-height:calc(100vh - 40px);overflow:auto;background:#142630; + border:1px solid #45616d;border-radius:8px;box-shadow:0 20px 70px #0009;padding:18px} + .armix-native-io-header{display:flex;align-items:center;justify-content:space-between; + gap:14px;margin-bottom:13px;font-size:15px;font-weight:500} + .armix-native-io-field{display:grid;grid-template-columns:105px minmax(0,1fr); + align-items:center;gap:12px;margin:8px 0} + .armix-native-io select{min-width:0;width:100%;box-sizing:border-box; + background:#0c1c25;color:#d8eaf0;border:1px solid #4a6672; + border-radius:4px;padding:8px;font:inherit} + .armix-native-io button{background:#25414d;color:#e2f3f5; + border:1px solid #4a6875;border-radius:4px;padding:7px 13px;cursor:pointer;font:inherit} + .armix-native-io button:disabled{opacity:.45;cursor:default} + .armix-native-io-hint{color:#a7c7d0;line-height:1.5;font-size:11px;margin:13px 0} + .armix-native-io-footer{display:flex;justify-content:flex-end;gap:8px;margin-top:15px} + .armix-native-io [data-native-io="apply"]{background:#245b61;border-color:#488f8e} + .armix-native-io details{margin-top:12px} + `; + document.head.appendChild(css); + ioPanel=document.createElement("div");ioPanel.className="armix-native-io";ioPanel.hidden=true; + ioPanel.innerHTML=``; + document.body.appendChild(ioPanel); + const open=()=>{ + ioPanel.hidden=false;ioDraft=null;ioInventory=null; + ioPanel.querySelector('[data-native-io="hint"]').textContent="Reading actual installed drivers..."; + backend.emitEvent("arMixAction",{action:"audioDeviceInventory"}); + }; + const close=()=>{if(!ioRequest)ioPanel.hidden=true;}; + const bar=document.querySelector(".command-bar"); + const btn=document.createElement("button");btn.className="tool"; + btn.type="button";btn.textContent="Audio I/O"; + btn.title="Choose hardware driver, input and output once"; + bar?.insertBefore(btn,document.getElementById("moreTools")); + btn.addEventListener("click",open); + ioPanel.addEventListener("click",event=>{ + const action=event.target.closest?.("[data-native-io]")?.dataset.nativeIo; + if(action==="close"||action==="cancel"){close();return;} + if(action!=="apply"||ioRequest||!ioDraft)return; + const active=ioInventory?.active; + if(!active){return;} + const same=active.open&&active.backend===ioDraft.backend&& + active.captureDevice===ioDraft.captureDevice&&active.playbackDevice===ioDraft.playbackDevice; + const config={...ioDraft, + enabledInputs:same?active.enabledInputs:null, + enabledOutputs:same?active.enabledOutputs:null}; + ioRequest={requestId:"daw-io-"+(++sourceSerial),config, + expectedDeviceGeneration:Number(active.deviceGeneration)||0}; + ioPanel.querySelector('[data-native-io="hint"]').textContent="Applying driver (native readback required)..."; + if(hardware?.device?.outputArmed){ + ioAfterMute=ioRequest; + backend.emitEvent("arMixAction",{action:"monitor",value:false}); + }else sendNativeIoApply(); + }); + ioPanel.addEventListener("change",event=>{ + const field=event.target.dataset.nativeIo; + if(!ioDraft||!["backend","capture","playback","rate","buffer"].includes(field))return; + const value=event.target.value; + if(field==="backend"){ + ioDraft={backend:value,captureDevice:"",playbackDevice:"",sampleRate:0,bufferSize:0}; + }else if(field==="capture")ioDraft.captureDevice=value; + else if(field==="playback")ioDraft.playbackDevice=value; + else if(field==="rate")ioDraft.sampleRate=Number(value)||0; + else if(field==="buffer")ioDraft.bufferSize=Number(value)||0; + paintNativeIo(); + }); + ioPanel.addEventListener("click",event=>{if(event.target===ioPanel)close();}); + backend.addEventListener("arMixAudioDeviceInventory",data=>{ + ioInventory=data; + if(!ioPanel.hidden)paintNativeIo(); + }); + backend.addEventListener("arMixAudioDeviceApplyAck",ack=>{ + if(!ioRequest||ack?.requestId!==ioRequest.requestId)return; + ioRequest=null;ioAfterMute=null; + if(ack?.ok===true&&ack?.active?.open){ + ioPanel.hidden=true;controller?.subscribe(); + status("AUDIO I/O READY · choose IN directly on any mixer channel"); + }else{ + ioPanel.querySelector('[data-native-io="hint"]').textContent= + "Driver rejected: "+String(ack?.error||"device not ready"); + paintNativeIo(); + } + }); + backend.addEventListener("arMixAudioArmAck",ack=>{ + if(!ioAfterMute)return; + if(ack?.ok===true&&ack?.armed===false)sendNativeIoApply(); + else{ + ioAfterMute=null;ioRequest=null; + ioPanel.querySelector('[data-native-io="hint"]').textContent= + "Cannot change driver safely while output is active"; + } + }); + } + function sendNativeIoApply(){ + if(!ioRequest)return; + backend.emitEvent("arMixAction",{ + action:"audioDeviceApply",...ioRequest}); + } function installFirstSoundMenu() { const menu=document.querySelector?.("#moreTools .more-tools-panel"); if(!menu || typeof document.createElement!=="function")return; @@ -219,9 +393,11 @@ }; const caption=item("span","more-tools-caption","REAL AUDIO · FIRST SOUND"); const setup=item("button","tool","Audio Setup"); + // Device preferences remain a one-time JUCE owner. The approved Pages + // WebView does NOT load legacy mixer-io.js; never call its absent overlay. setup.addEventListener("click",()=>{ backend.emitEvent("arMixAction",{action:"audioSetup"}); - status("NATIVE: select actual ASIO/WASAPI input + output in Audio Setup."); + status("Choose hardware driver/input/output once; then select IN on each strip."); }); inputSelect=item("select","toolbar-select",""); inputSelect.setAttribute("aria-label","JUCE physical input for CH1"); @@ -263,10 +439,149 @@ }); hardwareNote=item("span","more-tools-caption","Device not initialized"); hardwareNote.style.whiteSpace="normal"; - menu.append(caption,setup,inputSelect,routeBtn,armBtn,muteBtn,hardwareNote); + // Do not expose a second patch/ARM wizard as the normal mixer workflow. + // Retain hardware FAT and panic diagnostics in a collapsed expert-only + // section, while existing strip IN selects and routes audio in one action. + const advanced=document.createElement("details"); + advanced.className="arNativeFirstSoundAdvanced"; + const summary=document.createElement("summary"); + summary.textContent="Advanced · hardware diagnostics"; + advanced.append(summary,caption,inputSelect,routeBtn,armBtn,muteBtn,hardwareNote); + menu.append(setup,advanced); updateHardwarePanel(hardware); } + // The installed M4 renderer already has ten real native strip setters. + // Before ChannelId migration, show its ACCEPTED readback rather than + // disabling fader/PAN/MUTE/SOLO or inventing an optimistic demo state. + // User's one IN selection is the entire normal patch+monitor gesture. + // A real ACK/epoch/accepted row must precede any guarded output resume. + let pendingStripSource=null; + function chooseNativeStripInput(select) { + const n=m4StripIndex(select),d=hardware?.device,m=legacy(); + const epoch=safeNativeCounter(d?.epoch),revision=safeNativeCounter(m?.routingRevision); + const parts=String(select.value).split(":"); + const mode=parts[0],left=Number(parts[1]),right=mode==="STEREO"?Number(parts[2]):-1; + const active=new Set((d?.inputEndpoints||[]).filter(x=>x.active===true).map(x=>x.port)); + if(!deviceReady()||n<0||n>=10||pendingSourceId|| + epoch===null||revision===null||!["MONO","STEREO"].includes(mode)|| + !Number.isInteger(left)||!active.has(left)|| + (mode==="STEREO"&&(!Number.isInteger(right)||right===left||!active.has(right)))) { + status("INPUT NOT CHANGED · select a verified active mono/stereo input"); + paintM4Inputs(hardware);return; + } + pendingSourceId=++sourceSerial; + pendingStripSource={requestId:pendingSourceId,channel:n,mode,left,right,epoch}; + backend.emitEvent("arMixAction",{ + action:"routingSourceSwitch",requestId:pendingSourceId, + channel:n,mode,left,right,deviceEpoch:epoch,revision + }); + status("CH "+(n+1)+" · connecting input (native ACK)"); + paintM4Inputs(hardware); + } + function paintM4Inputs(next) { + if(!Array.isArray(scope?.tracks))return; + const d=next?.device,m=next?.raw?.legacyM4; + const active=Array.isArray(d?.inputEndpoints)?d.inputEndpoints.filter(p=> + p?.active===true && d.enabledInputs?.includes(p.port)):[]; + const options=[]; + // NONE is displayed as state, not offered as a nonfunctional patch. + options.push(["NONE","No input"]); + for(const pin of active)options.push(["MONO:"+pin.port, + "Mono · "+pin.label]); + for(let i=0;io[0]===value)) + list.push([value,"Previous input · not active"]); + const signature=JSON.stringify(list); + if(select.dataset.nativeOptions!==signature){ + select.replaceChildren(...list.map(([v,label])=>new Option(label,v))); + select.dataset.nativeOptions=signature; + } + if(select.value!==value)select.value=value; + select.disabled=!deviceReady()||pendingSourceId!==0||!Array.isArray(m?.channelSources); + select.title="CH "+(i+1)+" · verified hardware IN · native route ACK"; + } + } + function m4Verified(){ + const m=legacy(),d=hardware?.device; + return m?.active===true&&m.routeAccepted===true && + Array.isArray(m.channelControls)&&m.channelControls.length===10 && + safeNativeCounter(d?.epoch)!==null && + safeNativeCounter(m.routingRevision)!==null; + } + function m4StripIndex(el){ + // /preview/ uses stable view-local data-id, NOT the retired data-strip. + const root=el?.closest?.('.strip[data-id]'); + if(!root || !Array.isArray(scope?.tracks))return -1; + const index=scope.tracks.findIndex(t=>String(t.id)===root.dataset.id); + return index>=0&&index<10?index:-1; + } + function m4Send(parameter,channel,value){ + if(!m4Verified()||channel<0||channel>=10)return false; + if(typeof value!=="boolean"&&!(Number.isFinite(value)))return false; + backend.emitEvent("arMixParameter",{ + parameter,channel:channel+1,value, + routeEpoch:safeNativeCounter(hardware.device.epoch), + routeRevision:safeNativeCounter(legacy().routingRevision) + }); + // 12Hz native snapshots are authoritative; never update Pages model here. + return true; + } + function paintM4Readback(next) { + const m=next?.raw?.legacyM4,controls=m?.channelControls; + if(!m?.active||!m.routeAccepted||!Array.isArray(controls)|| + controls.length!==10||!scope?.render||!Array.isArray(scope?.tracks))return; + let change=false; + for(let i=0;i<10;i++){ + const ctl=controls[i],track=scope.tracks[i]; + if(!ctl||!track||track.kind!=="audio"|| + !Number.isFinite(ctl.db)||!Number.isFinite(ctl.pan)|| + typeof ctl.mute!=="boolean"||typeof ctl.solo!=="boolean")return; + if(Math.abs(track.level-ctl.db)>.015){track.level=ctl.db;change=true;} + if(Math.abs(track.pan-ctl.pan)>.015){track.pan=ctl.pan;change=true;} + if(track.mute!==ctl.mute){track.mute=ctl.mute;change=true;} + if(track.solo!==ctl.solo){track.solo=ctl.solo;change=true;} + } + if(scope.master && Number.isFinite(m.masterDb) && + Math.abs(scope.master.level-m.masterDb)>.015){ + scope.master.level=m.masterDb;change=true; + } + if(scope.master && typeof m.masterMute==="boolean" && + scope.master.mute!==m.masterMute){ + scope.master.mute=m.masterMute;change=true; + } + if(change)scope.render(); + paintM4Inputs(next); + const l=m.channelPeaksL,r=m.channelPeaksR; + if(!Array.isArray(l)||!Array.isArray(r)||!scope.displayMeterDbfs)return; + const now=performance.now(); + for(let i=0;i<10;i++){ + const root=document.querySelector('.strip[data-id="'+scope.tracks[i]?.id+'"]'); + if(!root)continue; + for(const [side,v] of [["left",l[i]],["right",r[i]]]){ + if(!Number.isFinite(v)||v<0)continue; + const fill=root.querySelector('.meter-fill.'+side); + if(fill)scope.displayMeterDbfs(fill,v===0?-90: + Math.max(-90,Math.min(6,20*Math.log10(v))),now, + "m4:"+i+":"+side); + } + } + } function onNativeReadback(next) { updateHardwarePanel(next); const caps=next?.graph?.capabilities; @@ -275,7 +590,11 @@ flags.productionCallbackLive=false;flags.acceptedGraphConnected=false; lastPaintedSignature=""; stopDemo(); - status("NATIVE G0 · PATCH CH1/ARM tersedia pada device terverifikasi; kontrol ChannelId/WIRE menunggu PCM native."); + paintM4Readback(next); + if(!m4Verified())paintM4Inputs(next); + status(m4Verified()? + "LIVE 10CH MIXER · INPUT/FADER/PAN/MUTE native · ChannelId migration pending": + "NATIVE DEVICE · select real IN on channel; output remains safe until native route"); return; } // Control readback may change at the SAME structural graph revision. @@ -321,12 +640,35 @@ backend.addEventListener("arMixConsoleAck", ack=>controller.onAck(ack)); backend.addEventListener("arMixSourceSwitchAck", ack=>{ if(!pendingSourceId||ack?.requestId!==pendingSourceId)return; - pendingSourceId=0; - if(ack.ok===true) { - status("NATIVE: CH1 PATCH accepted by JUCE; validating later readback."); - controller.subscribe(); - }else status("NATIVE PATCH REJECTED: "+(ack?.error||"stale physical route")); + const selected=pendingStripSource; + pendingSourceId=0;pendingStripSource=null; + const result=ack?.state,channels=result?.acceptedRoute?.channels; + const row=selected&&Array.isArray(channels)?channels[selected.channel]:null; + const verified=!!selected&&ack?.ok===true&&result?.ready===true && + result?.hasAcceptedRoute===true&& + Number(result.epoch)===selected.epoch&& + Number(hardware?.device?.epoch)===selected.epoch&& + Number.isSafeInteger(Number(result.revision))&&Number(result.revision)>0&& + row?.mode===selected.mode&&row?.left===selected.left&& + (selected.mode!=="STEREO"||row.right===selected.right); + if(verified){ + status("CH "+(selected.channel+1)+" · INPUT CONNECTED · native ACK"); + // Avoid directly feeding VB-Cable playback back into its own + // recording endpoint. A physical output or a deliberate independent + // stream must be selected before software monitoring that loop. + if(cableFeedbackPair()) + status("INPUT CONNECTED · VB-Cable feedback loop blocked; choose headphones in Audio I/O"); + else if(hardware?.device?.outputArmed!==true) + backend.emitEvent("arMixAction",{ + action:"monitor",value:true, + expectedEpoch:selected.epoch, + expectedRevision:Number(result.revision) + }); + }else if(ack?.ok!==true)status("INPUT REJECTED · "+(ack?.error||"device changed")); + else if(selected)status("INPUT UNVERIFIED · source readback changed; MAIN remains safe"); + controller.subscribe(); // Never assume ACK alone is audible PCM. updateHardwarePanel(hardware); + paintM4Inputs(hardware); }); backend.addEventListener("arMixAudioArmAck", ack=>{ if(ack?.ok===true){ @@ -344,10 +686,37 @@ if (!field)return false; const t=scope?.findTrack?.(el) || null; if (!t)return true; + // Approved /preview/ IN selects from actual JUCE callback pins. + // The installed M4 native graph owns the ten physical source switches. + // This is the SAME engine route used by the live PCM callback. + if(field==="input"){ + if(event.type==="change")chooseNativeStripInput(el); + return true; + } if (!flags.acceptedGraphConnected) { - if (field==="level")el.value=String(t.level); - else if (field==="pan")el.value=String(t.pan); - status("NATIVE: ChannelId PCM not admitted; control unchanged"); + if(m4Verified()&&t.kind==="master"&&field==="level"){ + if(event.type==="change"&&Number.isFinite(Number(el.value))) + backend.emitEvent("arMixParameter",{ + parameter:"masterGain",channel:-1,value:Number(el.value), + routeEpoch:safeNativeCounter(hardware.device.epoch), + routeRevision:safeNativeCounter(legacy().routingRevision)}); + return true; + } + const n=m4StripIndex(el); + if(m4Verified()&&n>=0&&(field==="level"||field==="pan")){ + if(event.type!=="change")return true; // cap preview, native control on commit + const numeric=Number(el.value); + const value=field==="pan"? + (!el.dataset.panKeyboard&&!el.dataset.panAltPointer&&Math.abs(numeric)<=12?0:numeric): + numeric; + const parameter=field==="level"?"faderDb":"pan"; + if(!m4Send(parameter,n,value)) + status("NATIVE M4: control rejected; waiting real readback"); + return true; + } + if(field==="level")el.value=String(t.level); + else if(field==="pan")el.value=String(t.pan); + status("NATIVE: route not yet accepted; control unchanged"); return true; } // During a native pointer drag move the approved fader *cap* only. @@ -387,6 +756,22 @@ if (["wireExpand","wireSource","wireRoute","editIdentity","rename"].includes(action)) return !["wireExpand","wireSource","wireRoute"].includes(action); if (action==="mute"||action==="solo") { + if(!flags.acceptedGraphConnected && m4Verified()&& + t.kind==="master"&&action==="mute"){ + backend.emitEvent("arMixParameter",{ + parameter:"masterMute",channel:-1,value:!t.mute, + routeEpoch:safeNativeCounter(hardware.device.epoch), + routeRevision:safeNativeCounter(legacy().routingRevision)}); + return true; + } + if(!flags.acceptedGraphConnected && m4Verified()){ + const n=m4StripIndex(btn); + if(n>=0) { + if(!m4Send(action,n,!t[action])) + status("Native M4 control rejected; waiting readback"); + return true; + } + } const key=action==="mute"?"SET_MUTE":"SET_SOLO"; intent(key,t,{value:!t[action],enabled:!t[action]});return true; } @@ -464,6 +849,9 @@ // Presentation-only bank/selection remains available. document.addEventListener("pointerdown",event=>{ if (flags.acceptedGraphConnected) return; + if (m4Verified()&& + (m4StripIndex(event.target)>=0|| + scope?.findTrack?.(event.target)?.kind==="master"))return; if (!event.target.closest?.(".fader-box,.center-pan")) return; event.preventDefault();event.stopImmediatePropagation(); status("NATIVE G0: physical gain/pan unavailable until engine graph admission"); @@ -481,6 +869,7 @@ // window.pointerup listener would run after that handler clears the gesture. const ready=()=>{ installFirstSoundMenu(); + installNativeIo(); updateHardwarePanel(null); stopDemo(); status("NATIVE: subscribed · waiting for true device and accepted ChannelId graph");