Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
20 changes: 20 additions & 0 deletions tests/approved_native_cold_start_smoke.py
Original file line number Diff line number Diff line change
Expand Up @@ -84,8 +84,28 @@ def main():
'enabledInputs':[0],'enabledOutputs':[0,1],
'rate':48000,'buffer':480,
'rates':[48000],'buffers':[480]}}
# MV-2: a combined JUCE backend has one physical endpoint for
# both directions. Changing Output must automatically synchronize
# Input; never carry verified pins from the previous driver.
io_inventory['types'].append({
'name':'ASIO','separate':False,
'inputs':['Unified A','Unified B'],
'outputs':['Unified A','Unified B']})
emit(page,'arMixAudioDeviceInventory',io_inventory)
backend_select=page.locator('.armix-audio-dialog [data-audio-field="backend"]')
capture_select=page.locator('.armix-audio-dialog [data-audio-field="capture"]')
playback_select=page.locator('.armix-audio-dialog [data-audio-field="playback"]')
backend_select.select_option(value='ASIO')
assert capture_select.input_value()=='Unified A'
playback_select.select_option(value='Unified B')
assert capture_select.input_value()=='Unified B'
assert page.locator('[data-audio-main-pins]').is_hidden()
assert page.locator('[data-audio-field="rate"]').is_disabled()
assert page.locator('[data-audio-field="buffer"]').is_disabled()
assert page.locator('[data-audio-apply]').is_enabled()
# Return to the previous Windows device without applying the
# speculative ASIO draft or changing native physical hardware.
backend_select.select_option(value='Windows Audio')
capture_select.select_option(value='')
assert capture_select.input_value()==''
assert page.locator('.armix-audio-dialog [data-audio-apply]').is_enabled()
Expand Down
125 changes: 124 additions & 1 deletion tests/approved_native_m2_contract.test.cjs
Original file line number Diff line number Diff line change
Expand Up @@ -1619,7 +1619,16 @@ test("P0 output-only Audio I/O is a real native configuration, never blocked by
assert.match(apply,/out\.countNumberOfSetBits\(\)<2/);
assert.doesNotMatch(cpp,/opened->getActiveInputChannels\(\)\.countNumberOfSetBits\(\)<1/);
assert.match(bridge,/No hardware input \(Player \/ FX\)/);
assert.match(bridge,/t\?\.separate\?\["",\.\.\.\(t\.inputs\|\|\[\]\)\]/);
const inventory={active:{open:true,backend:"Windows Audio",captureDevice:"",
playbackDevice:"Speakers",deviceGeneration:4,enabledInputs:[],
enabledOutputs:[0,1]},types:[{name:"Windows Audio",separate:true,
inputs:["Mic"],outputs:["Speakers"]}]};
const outputOnly=deviceVM.setupInitialDraft(inventory);
assert.equal(outputOnly.capture,"");
assert.deepEqual(deviceVM.setupUiModel(inventory,outputOnly,
deviceVM.setupInitial()).captureChoices,["","Mic"],
"pure selector preserves explicit zero-input option");
assert.match(bridge,/deviceVM\.setupUiModel\(deviceInventory,deviceChoice,deviceState\)/);
assert.doesNotMatch(bridge,/ack\.active\.enabledInputs\.length>0/);
assert.match(read("web/approved-device-view-model.js"),/Mixer ready · Output muted/);
});
Expand Down Expand Up @@ -2389,6 +2398,120 @@ function nativeDeviceSetupFixture() {
enabledOutputs:[0,1],outputArmed:true}};
return {active,inventory,draft,begin,ack,readback};
}
test("MV-2 Device Setup draft keeps verified output-only selection and never invents pins",()=>{
const active={backend:"Windows Audio",captureDevice:"",playbackDevice:"Speakers",
open:true,authorized:true,deviceGeneration:19,rate:48000,buffer:480,
enabledInputs:[],enabledOutputs:[0,1],inputNames:[],
outputNames:["L","R"],rates:[48000],buffers:[480]};
const inventory={active,types:[{name:"Windows Audio",separate:true,
inputs:["Studio Mic"],outputs:["Speakers"]}]};
const frozen=clone(inventory);
const draft=deviceVM.setupInitialDraft(inventory);
assert.equal(draft.capture,"");
assert.equal(draft.playback,"Speakers");
assert.deepEqual(draft.inputPins,[]);
assert.deepEqual(draft.outputPins,[0,1]);
const ui=deviceVM.setupUiModel(inventory,draft,deviceVM.setupInitial());
assert.deepEqual(ui.selectedInputPins,[]);
assert.deepEqual(ui.selectedOutputPins,[0,1]);
assert.match(ui.activeText,/ACTIVE · Windows Audio · 48000 Hz/);
assert.deepEqual(ui.captureChoices,["","Studio Mic"]);
assert.deepEqual(ui.rateChoices,["0","48000"]);
assert.equal(ui.canApply,true);
assert.equal(ui.canAssignMain,true);
assert.equal(deviceVM.setupBegin(deviceVM.setupInitial(),{
inventory,draft,requestId:"mv2-out"}).request.config.captureDevice,"");
assert.deepEqual(inventory,frozen,"draft is not an accepted device mutation");
});

test("MV-2 combined driver output picker follows same physical input and discards old pin/rate draft",()=>{
const f=nativeDeviceSetupFixture();
f.inventory.types[0].inputs=["ASIO Test","ASIO Two"];
f.inventory.types[0].outputs=["ASIO Test","ASIO Two"];
const first=deviceVM.setupInitialDraft(f.inventory);
const same=deviceVM.setupEditDraft(f.inventory,first,{field:"playback",value:"ASIO Test"});
assert.equal(same,first,"unchanged selection cannot create another state");
const edit=deviceVM.setupEditDraft(f.inventory,first,
{field:"playback",value:"ASIO Two"});
assert.equal(edit.capture,"ASIO Two","combined driver input/output identities match");
assert.equal(edit.playback,"ASIO Two");
assert.equal(edit.inputPins,null);
assert.equal(edit.outputPins,null);
assert.equal(edit.rate,0);assert.equal(edit.buffer,0);
assert.equal(deviceVM.setupUiModel(f.inventory,edit,deviceVM.setupInitial()).canApply,true);
assert.equal(deviceVM.setupUiModel(f.inventory,edit,deviceVM.setupInitial()).same,false);
assert.equal(deviceVM.setupEditDraft(f.inventory,edit,
{field:"playback",value:"Ghost output"}),edit);
const request=deviceVM.setupBegin(deviceVM.setupInitial(),
{inventory:f.inventory,draft:edit,requestId:"mv2-combined"});
assert.ok(request);
assert.equal(request.request.config.captureDevice,"ASIO Two");
assert.equal(request.request.config.playbackDevice,"ASIO Two");
assert.deepEqual(request.request.config.enabledOutputs,[],
"uninspected pins cannot travel to another physical endpoint");
assert.equal(first.playback,"ASIO Test","prior UI draft must be immutable");
});

test("MV-2 pin/rate edits reject phantom endpoints and do not reset native ACK state",()=>{
const f=nativeDeviceSetupFixture();
f.inventory.active.inputNames=["Mic"];
f.inventory.active.outputNames=["L","R","Spare"];
f.inventory.active.rates=[44100,48000];
f.inventory.active.buffers=[128,256];
const original=deviceVM.setupInitialDraft(f.inventory);
const pins=deviceVM.setupEditDraft(f.inventory,original,
{pinSide:"output",pinIndex:2,checked:true});
assert.deepEqual(pins.outputPins,[0,1,2]);
assert.deepEqual(original.outputPins,[0,1]);
const deselected=deviceVM.setupEditDraft(f.inventory,pins,
{pinSide:"output",pinIndex:1,checked:false});
assert.deepEqual(deselected.outputPins,[0,2]);
const single=deviceVM.setupEditDraft(f.inventory,original,
{pinSide:"output",pinIndex:1,checked:false});
assert.deepEqual(single.outputPins,[0]);
assert.equal(deviceVM.setupUiModel(f.inventory,single,
deviceVM.setupInitial()).canApply,false,
"UI cannot send an impossible one-pin stereo output transaction");
assert.equal(deviceVM.setupBegin(deviceVM.setupInitial(),{
inventory:f.inventory,draft:single,requestId:"mv2-one-pin"}),null,
"same pure safety rule gates presentation and command creation");
assert.equal(deviceVM.setupUiModel(f.inventory,original,
deviceVM.setupInitial()).canApply,true);
assert.equal(deviceVM.setupEditDraft(f.inventory,pins,
{pinSide:"output",pinIndex:29,checked:true}),pins);
assert.equal(deviceVM.setupEditDraft(f.inventory,pins,
{pinSide:"input",pinIndex:-1,checked:true}),pins);
const unplugged={...f.inventory,active:{...f.inventory.active,
deviceGeneration:20,captureDevice:"Disconnected endpoint"}};
assert.equal(deviceVM.setupUiModel(unplugged,pins,
deviceVM.setupInitial()).same,false);
assert.equal(deviceVM.setupEditDraft(unplugged,pins,
{pinSide:"output",pinIndex:2,checked:true}),pins,
"old physical pins cannot be retargeted against a new inventory");
const vmText=read("web/approved-device-view-model.js");
assert.doesNotMatch(vmText,/AudioContext|AudioWorklet|document\\.|window\\.|localStorage/,
"pure device selector has no DOM or audio authority");
assert.equal(deviceVM.setupEditDraft(f.inventory,pins,
{field:"rate",value:"96000"}),pins);
const sample=deviceVM.setupEditDraft(f.inventory,pins,
{field:"rate",value:"44100"});
assert.equal(sample.rate,44100);
const buffer=deviceVM.setupEditDraft(f.inventory,sample,
{field:"buffer",value:"128"});
assert.equal(buffer.buffer,128);
const verifying=deviceVM.setupAck(f.begin("mv2-await").state,f.ack("mv2-await"));
assert.equal(deviceVM.setupUiModel(f.inventory,buffer,verifying).canApply,false);
assert.equal(deviceVM.setupUiModel(f.inventory,buffer,verifying).canAssignMain,false);
assert.equal(deviceVM.setupEditDraft(f.inventory,buffer,{field:"invalid",value:"X"}),buffer);
const src=read("web/approved-native-bridge.js");
assert.match(src,/deviceVM\.setupEditDraft\(deviceInventory,deviceChoice,edit\)/);
assert.match(src,/deviceVM\.setupUiModel\(deviceInventory,deviceChoice,deviceState\)/);
const handler=src.slice(src.indexOf('devicePanel.addEventListener("change"'),
src.indexOf('devicePanel.querySelector("[data-audio-apply]").onclick'));
assert.doesNotMatch(handler,/deviceChoice\.backend\s*=|deviceChoice\.outputPins\s*=/,
"bridge must no longer duplicate draft reducer rules");
});

test("Device Setup VM requires matching ACK AND later installed v6 readback, never ACK-only LIVE",()=>{
const f=nativeDeviceSetupFixture();
const begun=f.begin("approved-io-42");
Expand Down
150 changes: 140 additions & 10 deletions web/approved-device-view-model.js
Original file line number Diff line number Diff line change
Expand Up @@ -89,6 +89,142 @@
return {match,state,value,marker,title};
}

// One disposable draft for the current native hardware inventory.
// No selectors own a real device, a PCM graph, or persistent .smix state.
function setupType(inventory,backend) {
return Array.isArray(inventory?.types)?
inventory.types.find(t=>t?.name===backend):undefined;
}
function setupValidSelection(inventory,draft) {
const t=setupType(inventory,draft?.backend);
if(!inventory?.active||!t||!draft?.playback||
!Array.isArray(t.outputs)||!t.outputs.includes(draft.playback))
return false;
// Existing hardware pin masks must remain a verified stereo pair.
// A new endpoint has no inspected pins yet; native opens it with safe
// defaults and publishes a fresh inventory before individual pin edits.
if(setupSameEndpoint(inventory,draft)&&Array.isArray(draft.outputPins)&&
draft.outputPins.length<2)return false;
if(t.separate===true)
return draft.capture==="" ||
(Array.isArray(t.inputs)&&t.inputs.includes(draft.capture));
return Array.isArray(t.inputs)&&t.inputs.includes(draft.capture)&&
draft.capture===draft.playback;
}
function setupSameEndpoint(inventory,draft) {
const active=inventory?.active;
return active?.open===true&&
active.backend===draft?.backend&&
active.captureDevice===draft?.capture&&
active.playbackDevice===draft?.playback;
}
function setupInitialDraft(inventory) {
if(!inventory?.active)return null;
const active=inventory.active;
const backend=active.backend||inventory.types?.[0]?.name||"";
const type=setupType(inventory,backend);
// Keep a verified output-only endpoint output-only on reopen.
const capture=active.open===true?String(active.captureDevice||""):
active.captureDevice||type?.inputs?.[0]||"";
return {backend,capture,
playback:active.playbackDevice||
(type?.separate?type?.outputs?.[0]:capture)||"",
inputPins:Array.isArray(active.enabledInputs)?active.enabledInputs.slice():null,
outputPins:Array.isArray(active.enabledOutputs)?active.enabledOutputs.slice():null,
rate:0,buffer:0};
}
function setupEditDraft(inventory,draft,edit) {
if(!draft||!edit||!inventory?.active)return draft;
const t=setupType(inventory,draft.backend);
if(edit.pinSide==="input"||edit.pinSide==="output"){
if(!setupSameEndpoint(inventory,draft))return draft;
const input=edit.pinSide==="input";
const key=input?"inputPins":"outputPins";
const names=input?inventory.active.inputNames:inventory.active.outputNames;
const index=edit.pinIndex;
if(!Array.isArray(names)||!Array.isArray(draft[key])||
!Number.isSafeInteger(index)||index<0||index>=names.length||
typeof edit.checked!=="boolean")return draft;
const old=draft[key],has=old.includes(index);
if(has===edit.checked)return draft;
const pins=edit.checked?[...old,index]:old.filter(n=>n!==index);
return {...draft,[key]:[...new Set(pins)].sort((a,b)=>a-b)};
}
const field=edit.field,value=edit.value;
if(typeof value!=="string")return draft;
if(field==="backend"){
if(value===draft.backend)return draft;
const nextType=setupType(inventory,value);
if(!nextType)return draft;
const capture=nextType.inputs?.[0]||"";
return {...draft,backend:value,capture,
playback:nextType.separate===true?nextType.outputs?.[0]||"":capture,
inputPins:null,outputPins:null,rate:0,buffer:0};
}
if(!t)return draft;
if(field==="capture"){
if(value===draft.capture)return draft;
if(value!==""&&!t.inputs?.includes(value)||
value===""&&t.separate!==true)return draft;
return {...draft,capture:value,
playback:t.separate===true?draft.playback:value,
inputPins:null,outputPins:null,rate:0,buffer:0};
}
if(field==="playback"){
if(value===draft.playback)return draft;
if(!t.outputs?.includes(value)||
t.separate!==true&&!t.inputs?.includes(value))return draft;
// A combined (non-separate) JUCE driver has ONE endpoint identity;
// changing Output must follow it on Input or Apply becomes impossible.
return {...draft,playback:value,
capture:t.separate===true?draft.capture:value,
inputPins:null,outputPins:null,rate:0,buffer:0};
}
if(field==="rate"||field==="buffer"){
const number=Number(value);
const choices=field==="rate"?inventory.active.rates:inventory.active.buffers;
if(!setupSameEndpoint(inventory,draft)||!Number.isSafeInteger(number)||
number<0||(number!==0&&
(!Array.isArray(choices)||!choices.includes(number))))return draft;
if(draft[field]===number)return draft;
return {...draft,[field]:number};
}
return draft;
}
function setupUiModel(inventory,draft,state) {
const type=setupType(inventory,draft?.backend);
const same=setupSameEndpoint(inventory,draft);
const active=inventory?.active||{};
const busy=!!state?.pending;
const mainPins=Array.isArray(active.mainOutputs)?active.mainOutputs
.map(pin=>active.outputNames?.[pin]).filter(Boolean):[];
// Device status is presentation only. Hardware approval remains native.
const activeText=state?.message||(active.open?
"ACTIVE · "+active.backend+" · "+active.rate+" Hz / "+active.buffer+" samples"+
(mainPins.length===2?" · MAIN "+mainPins.join(" / "):""):
"No verified audio device. Select a supported input and output.");
const selectedPins=(draftPins,enabled)=>Array.isArray(draftPins)?
draftPins:Array.isArray(enabled)?enabled:[];
return {
activeText,
selectedInputPins:selectedPins(draft?.inputPins,active.enabledInputs),
selectedOutputPins:selectedPins(draft?.outputPins,active.enabledOutputs),
backendChoices:(inventory?.types||[]).map(t=>t.name),
captureChoices:type?.separate===true?["",...(type.inputs||[])]:
type?.inputs||[],
playbackChoices:type?.outputs||[],
rateChoices:["0",...(same?active.rates||[]:[]).map(String)],
bufferChoices:["0",...(same?active.buffers||[]:[]).map(String)],
same,busy,
asio4allHint:draft?.backend==="ASIO"&&
/asio4all/i.test(draft.capture||""),
canApply:!busy&&setupValidSelection(inventory,draft),
canAssignMain:!busy&&same&&draft?.outputPins?.length===2,
canRemap:!busy&&same&&state?.remapGeneration!==null&&
state?.remapGeneration===active.deviceGeneration
};
}

// Device Setup UI transaction: pure presentation only. The native
// coordinator remains the sole device apply/rollback and output authority.
// Never treat a successful ACK as installed hardware readback.
Expand All @@ -102,15 +238,8 @@
const active=inventory.active;
const generation=active.deviceGeneration;
if(!Number.isSafeInteger(generation)||generation<0)return null;
const type=inventory.types?.find(x=>x.name===draft.backend);
if(!type||!draft.backend||!draft.playback||
!type.outputs?.includes(draft.playback)||
(!type.separate&&!type.inputs?.includes(draft.capture))||
(type.separate&&draft.capture&&!type.inputs?.includes(draft.capture))||
(!type.separate&&draft.capture!==draft.playback))return null;
const same=active.open===true&&active.backend===draft.backend&&
active.captureDevice===draft.capture&&
active.playbackDevice===draft.playback;
if(!setupValidSelection(inventory,draft))return null;
const same=setupSameEndpoint(inventory,draft);
if(confirmRetainedPinMapping &&
(!same||state.remapGeneration!==generation))return null;
if(assignMain&&(!same||draft.outputPins?.length!==2))return null;
Expand Down Expand Up @@ -219,6 +348,7 @@
return {...state,phase:"IDLE",message:"",remapGeneration:null};
}
return Object.freeze({activeInputPins,inputChoices,inputLabel,outputChoices,
externalPresentation,setupInitial,setupBegin,setupAck,setupReadback,
externalPresentation,setupInitialDraft,setupEditDraft,setupUiModel,
setupInitial,setupBegin,setupAck,setupReadback,
setupTimeout,setupClearResult});
});
Loading
Loading