renderAuthLifetimeBadge(state.user),60000);
}
function clearClientAuthState(){
if(state.poll){clearInterval(state.poll);state.poll=null;}
if(state.validationPoll){clearInterval(state.validationPoll);state.validationPoll=null;}
if(state.authLifetimeTimer){clearInterval(state.authLifetimeTimer);state.authLifetimeTimer=null;}
state.user=null;
state.bucketReady=false;
state.bucketSource=null;
state.runsCache=[];
state.runId=null;
state.validationRunId=null;
state.activeLinks={};
clearSavedRun();
}
function handleLogoutClick(){
clearClientAuthState();
}
function configureAuthAnchor(anchor,href,{newTab=false}={}){
if(!anchor)return;
if(href)anchor.href=href;
if(newTab){
anchor.target='_blank';
anchor.rel='noopener noreferrer';
}else{
anchor.removeAttribute('target');
anchor.removeAttribute('rel');
}
}
function authLoginUrl(){return '/oauth/huggingface/login'}
function authRefreshLoginUrl(){return '/auth/refresh-login'}
function authResetLocalUrl(){return '/auth/logout-local'}
function authLogoutUrl(){return '/auth/logout-local'}
function normalizeModelInput(value){return String(value||'').trim().replace('https://huggingface.co/','').split('?')[0].split('#')[0].replace(/^\/+|\/+$/g,'')}
function modelScanMatchesCurrent(){return state.modelScan?.ok&&normalizeModelInput(state.modelScan.model_id)===normalizeModelInput(formValue('modelId'))}
function scanVerdictClass(verdict){verdict=String(verdict||'').toLowerCase();if(verdict==='safe')return'success';if(verdict==='caution')return'warn';if(verdict==='risky'||verdict==='unsupported')return'error';if(verdict==='scanning')return'running';return'neutral'}
function outputTypeFromModelScan(scan={}){
const value=String(scan.expected_output_type||scan.metadata?.expected_output_type||'').toLowerCase();
return ['text','image','video','audio','any'].includes(value)?value:'';
}
function syncExpectedOutputFromModelScan(scan={}){
const inferred=outputTypeFromModelScan(scan);
const select=$('buildExpectedOutput');
if(!inferred||!select)return false;
const previous=select.value;
select.value=inferred;
select.dataset.prescanOutput=inferred;
select.dataset.prescanPreviousOutput=previous||'';
select.dispatchEvent(new Event('change',{bubbles:true}));
return previous!==inferred;
}
function normalizeBuildRiskLevel(level){
const clean=String(level||'low').toLowerCase().replace(/\s+/g,'_');
if(['very_high','high','medium','low'].includes(clean))return clean;
return 'low';
}
function buildRiskFromModelScan(scan={}){return scan?.build_risk||scan?.metadata?.build_risk||null}
function kernelStrategyFromModelScan(scan={}){return scan?.kernel_strategy||scan?.metadata?.kernel_strategy||null}
function buildPreScanTechnicalSections(scan={}){
const good=(scan.good_signals||[]).filter(Boolean);
const risk=(scan.risk_signals||[]).filter(Boolean);
const recs=(scan.recommendations||[]).filter(Boolean);
const buildRisk=buildRiskFromModelScan(scan);
const kernel=kernelStrategyFromModelScan(scan);
const sections=[
{title:'Checks passed',items:good},
{title:'Scan signals',items:risk},
{title:'Recommendations',items:recs},
];
if(buildRisk){
sections.push({title:'Build hints',items:[
buildRisk.label||'',
...(buildRisk.signals||[]),
...(buildRisk.mitigations||buildRisk.recommendations||[]),
].filter(Boolean)});
}
if(kernel&&kernel.native_kernel_risk){
sections.push({title:'Runtime hints',items:[
...(kernel.signals||[]),
...(kernel.candidate_backends||[]).map(x=>`Candidate backend: ${x}`),
kernel.policy||'Prefer runtime-compatible backends before source-built native packages.',
].filter(Boolean)});
}
return sections;
}
function buildPreScanViewModel(scan=null){
const model=normalizeModelInput(formValue('modelId'));
const isTransient=scan&&scan.transient===true;
const matches=scan&&((scan.ok&&normalizeModelInput(scan.model_id)===model)||isTransient);
if(!scan||!matches){
return {
mode:'required',tone:'neutral',badgeLabel:'Required',headline:'Pre-scan required',
summary:'Run a quick metadata check before launching. Pi will use the result to prepare an autonomous build plan.',
facts:[{icon:'↗',label:'Scan type',value:'Metadata only'},{icon:'◇',label:'Weights',value:'No download'}],
automationNote:'This keeps the launch gate lightweight while the worker performs deeper runtime checks during the Job.',
actionWarnings:[],technicalSections:[],isScanning:false,ctaLabel:'Scan model',empty:true,
};
}
const verdict=String(scan.verdict||'caution').toLowerCase();
const tone=scanVerdictClass(verdict);
const output=outputTypeFromModelScan(scan);
const buildRisk=buildRiskFromModelScan(scan);
const kernel=kernelStrategyFromModelScan(scan);
const level=normalizeBuildRiskLevel(buildRisk?.level);
const minutes=Number(buildRisk?.recommended_session_minutes||Math.ceil(Number(buildRisk?.recommended_session_seconds||0)/60)||0);
const longBuild=minutes>=60||['medium','high','very_high'].includes(level);
const score=scan.score!==undefined&&scan.score!==null&&verdict!=='scanning'&&verdict!=='error'?`Metadata score ${scan.score}`:'';
const auth=authAwareBuildGate(scan,state.user);
const manualSignals=[...(scan.risk_signals||[]),...(buildRisk?.signals||[])].map(x=>String(x).toLowerCase());
const mayNeedManualGpu=manualSignals.some(x=>x.includes('manual gpu')||x.includes('manual hardware')||x.includes('hardware selection')||x.includes('48gb')||x.includes('multi-gpu'));
const badgeMap={safe:'Ready',caution:'Review',risky:'Risky',unsupported:'Unsupported',scanning:'Scanning',error:'Scan failed'};
let headline='Review before build';
let summary=scan.summary||'Model metadata scan completed.';
if(verdict==='safe'){
headline=longBuild?'Ready, longer build expected':'Ready to build';
summary=longBuild?'This model looks compatible with an autonomous Space build, but the session may take longer than usual.':'This model looks compatible with an autonomous Space build.';
}else if(verdict==='caution'){
headline=mayNeedManualGpu?'Ready, hardware may need review':'Ready, review before launch';
summary='Pi can start the build, but review the visible launch expectations before continuing.';
}else if(verdict==='risky'){
headline='Review before build';
summary='This model may need manual setup or additional validation. Confirm the risk acknowledgement before launching.';
}else if(verdict==='unsupported'){
headline='Not recommended for autonomous build';
summary='This model is likely to need manual setup before a reliable autonomous build.';
}else if(verdict==='scanning'){
headline='Scanning model metadata';
summary='Analyzing model card, Hub metadata and small config files. No model weights are downloaded.';
}else if(verdict==='error'){
headline='Pre-scan could not complete';
summary='Try the scan again, or fix the issue before launching a Job.';
}
const estimate=minutes?`${level==='low'?'Quick':level==='medium'?'Medium':level==='high'?'Long':'Very long'} · ${formatRecommendedMinutes(minutes)}+ possible`:(longBuild?'Longer session possible':'Standard session');
const facts=[];
if(output)facts.push({icon:'↳',label:'Output',value:output.charAt(0).toUpperCase()+output.slice(1)});
if(scan.pipeline_tag)facts.push({icon:'◈',label:'Pipeline',value:scan.pipeline_tag});
facts.push({icon:'⌁',label:'Build estimate',value:verdict==='scanning'?'Checking…':estimate});
if(score)facts.push({icon:'✓',label:'Pre-scan',value:score});
const actionWarnings=[];
if(mayNeedManualGpu)actionWarnings.push('May require manual GPU or hardware review.');
if(auth?.message&&(auth.reason==='auth_short_for_model_risk'||auth.reason==='auth_unknown_for_risky_model'||auth.blocking))actionWarnings.push(auth.message);
if(verdict==='unsupported')actionWarnings.push('Autonomous launch is blocked for unsupported pre-scan verdicts.');
if(verdict==='error'&&scan.error)actionWarnings.push(scan.error);
const automationNote=verdict==='scanning'
?'Pi will use this signal to prepare the worker strategy.'
:'Pi will adapt runtime settings and fallback strategies during the build.';
return {
mode:verdict,tone,badgeLabel:badgeMap[verdict]||'Review',headline,summary,
facts:facts.slice(0,4),automationNote,actionWarnings,
technicalSections:buildPreScanTechnicalSections(scan),isScanning:verdict==='scanning',
ctaLabel:verdict==='scanning'?'Scanning…':(verdict==='error'?'Try scan again':'Scan again'),
};
}
function renderPreScanFactCards(facts=[]){
if(!facts.length)return'';
return `${facts.map(f=>`${escapeHtml(f.icon||'◇')}${escapeHtml(f.label||'Info')}${escapeHtml(String(f.value||''))}`).join('')}
`;
}
function renderPreScanWarnings(items=[]){
const clean=(items||[]).filter(Boolean);
if(!clean.length)return'';
return `${clean.slice(0,3).map(item=>`
!${escapeHtml(item)}
`).join('')}
';
}
function renderModelPreScan(scan=null){
const card=$('modelPreScanCard'),badge=$('modelPreScanBadge'),signals=$('modelPreScanSignals'),ackWrap=$('modelRiskAckWrap');
if(!card)return;
const vm=buildPreScanViewModel(scan);
const cls=vm.tone||'neutral';
card.className=`model-prescan-card prescan-decision-card ${cls}${vm.isScanning?' is-scanning':''}${vm.mode==='required'?' required':''}`;
card.setAttribute('aria-busy',vm.isScanning?'true':'false');
setText('modelPreScanTitle',vm.headline);
setText('modelPreScanSummary',vm.summary);
if(badge){badge.textContent=vm.badgeLabel;badge.className='badge '+cls}
if(signals){
signals.hidden=false;
const body=[
renderPreScanFactCards(vm.facts),
vm.isScanning?renderPreScanSkeleton():'',
vm.automationNote?`Automation${escapeHtml(vm.automationNote)}
`:'',
renderPreScanWarnings(vm.actionWarnings),
renderPreScanTechnicalDetails(vm.technicalSections),
].filter(Boolean).join('');
signals.innerHTML=body||'◇No extra metadata found.
';
}
if(ackWrap)ackWrap.hidden=!(String(scan?.verdict||'').toLowerCase()==='risky');
const scanButton=$('scanModel');
if(scanButton&&!scanButton.disabled)scanButton.textContent=vm.ctaLabel||'Scan model';
renderAuthLifetimeBadge(state.user);
}
function resetModelPreScan(){state.modelScan=null;const ack=$('modelRiskAck');if(ack)ack.checked=false;renderModelPreScan(null);setBuildLaunchEnabled()}
function setBuildLaunchEnabled(){const btn=$('launchBuild');const err=validateBuildForm();const gate=authAwareBuildGate(state.modelScan,state.user);if(btn){btn.disabled=state.busy||Boolean(err);btn.title=err||((gate.reason==='auth_short_for_model_risk'||gate.reason==='auth_unknown_for_risky_model')?gate.message:'');}if($('buildGateText'))setText('buildGateText',err||((gate.reason==='auth_short_for_model_risk'||gate.reason==='auth_unknown_for_risky_model')?gate.message:'Bucket and model pre-scan ready. You can launch builds.'))}
async function scanModel(){
const model=formValue('modelId');
if(!model){showMessage('Enter a model card URL or model ID before scanning.',true);return}
setButtonBusy('scanModel',true,'Scanning…');
renderModelPreScan({ok:true,transient:true,model_id:model,verdict:'scanning',summary:'Reading the model card, Hub metadata and small config files. We do not download model weights.'});
try{
const result=await apiPost('/api/models/pre-scan',{model_id:model});
state.modelScan=result;
syncExpectedOutputFromModelScan(result);
const ack=$('modelRiskAck');if(ack)ack.checked=false;
renderModelPreScan(result);
setBuildLaunchEnabled();
showMessage(`Model pre-scan: ${result.verdict} (${result.score}/100)`,result.verdict==='safe'?'success':(result.verdict==='unsupported'||result.verdict==='risky'?true:'warning'));
}catch(e){state.modelScan=null;renderModelPreScan({ok:true,transient:true,model_id:model,verdict:'error',summary:'The model pre-scan could not complete. Fix the issue or try again before launching a Job.',error:e.message});showMessage(e.message,true)}
finally{setButtonBusy('scanModel',false);setBuildLaunchEnabled()}
}
function validateBuildForm(){if(!state.bucketReady)return'Create or check your private run bucket before launching a build.';if(!formValue('modelId'))return'Enter a model card URL or model ID.';if(!formValue('piModel'))return'Enter the Pi model to use.';if(!modelScanMatchesCurrent())return'Run the model pre-scan before launching this build.';const authGate=authAwareBuildGate(state.modelScan,state.user);if(authGate.blocking)return authGate.message||'Refresh HF sign-in before launching.';const verdict=String(state.modelScan?.verdict||'').toLowerCase();if(verdict==='unsupported')return'This model pre-scan marked the repo as unsupported for automatic build.';if(verdict==='risky'&&!$('modelRiskAck')?.checked)return'Review the model pre-scan risk signals and confirm before launching.';return''}
function parseJsonField(id,fallback){const raw=formValue(id);if(!raw)return fallback;return JSON.parse(raw)}
function prettyJson(value){return JSON.stringify(value,null,2)}
function validationTimeoutValue(){const raw=formValue('validateTimeout');if(!raw)return 60;const value=Number(raw);if(!Number.isFinite(value))return NaN;return Math.max(30,Math.min(3600,Math.round(value)))}
function validationPayloadSizeError(){const enc=typeof TextEncoder!=='undefined'?new TextEncoder():null;for(const [id,label] of [['testArgs','Test args'],['testKwargs','Test kwargs']]){const text=$(id)?.value||'';const bytes=enc?enc.encode(text).length:text.length;if(bytes>16000)return`${label} JSON is too large for this version (${bytes} bytes). Keep validation payloads under 16 KB and avoid pasted base64/files.`}return''}
function validateValidationForm(){
const resolved=resolveLinkedValidationPayload();
return resolved.launchable?'':(resolved.error||'Space Test is not ready to launch.');
}
function setValidationLaunchEnabled(){const btn=$('launchValidate');if(!btn)return;const running=state.validationMode==='running'||Boolean(state.validationRunId&&state.validationDetail&&validationCanonicalStatus(state.validationDetail)==='running');const error=validateValidationForm();btn.disabled=Boolean(state.busy||running||error);btn.title=error||'';renderSpaceTestReadiness();}
function validationIsTerminalStatus(status){const canonical=String(status||'').toLowerCase();return ['full_inference_success','partial_validation','manual_hardware_required','technical_blocker','technical_blocker_boot_only','failed','stale','stopped','auth_refresh_required'].includes(canonical)}
function validationIsNonTerminalStatus(status){const canonical=String(status||'').toLowerCase();return !canonical||['running','pending','waiting','started','queued','building','unknown'].includes(canonical)}
function validationDetailRunId(detail={}){return detail.run_id||detail.summary?.run_id||detail.state?.run_id||detail.launch?.run_id||''}
function rememberTerminalValidation(detail={}){const runId=validationDetailRunId(detail)||state.validationRunId;const canonical=validationCanonicalStatus(detail);if(runId&&validationIsTerminalStatus(canonical)){state.validationTerminalByRun=state.validationTerminalByRun||{};state.validationTerminalByRun[runId]={canonical,detail:{...detail,_terminalLocked:true}};}return canonical}
function terminalValidationForRun(runId=state.validationRunId){return runId&&state.validationTerminalByRun?state.validationTerminalByRun[runId]||null:null}
function mergeValidationWithTerminalLock(incoming={},runId=state.validationRunId){const terminal=terminalValidationForRun(runId);if(!terminal)return incoming;const incomingCanonical=validationCanonicalStatus(incoming);if(validationIsNonTerminalStatus(incomingCanonical)){return {...(terminal.detail||{}),_refreshing:true,_ignoredIncomingStatus:incomingCanonical};}return incoming;}
function shouldIgnoreValidationUpdate(incoming={},runId=state.validationRunId){const incomingCanonical=validationCanonicalStatus(incoming);const terminal=terminalValidationForRun(runId);if(terminal&&incomingCanonical==='running')return true;return Boolean(terminal&&validationIsNonTerminalStatus(incomingCanonical));}
function extractEffectiveValidationPayload(detail={}){const smoke=detail.generation_smoke||detail.summary?.generation_smoke||detail.state?.generation_smoke||{};const payload=detail.validation_payload||detail.tests?.validation_payload||detail.summary?.validation_payload||{};const args=firstArrayPath(detail.effective_args,smoke.effective_args,payload.effective_args,smoke.test_args,payload.test_args);const kwargs=firstObjectPath(detail.effective_kwargs,smoke.effective_kwargs,payload.effective_kwargs,smoke.test_kwargs,payload.test_kwargs);const source=detail.args_source||smoke.args_source||payload.args_source||'';return {args,kwargs,source,argsWereAutofilled:Boolean(detail.args_were_autofilled||smoke.args_were_autofilled||payload.args_were_autofilled||source==='gradio_schema_auto_fill')};}
function applyEffectiveValidationArgs(detail={}){const payload=extractEffectiveValidationPayload(detail);if(!payload.argsWereAutofilled||!Array.isArray(payload.args))return;if(state.validationArgsDirty)return;setInputValue('testArgs',prettyJson(payload.args));if(payload.kwargs&&typeof payload.kwargs==='object'&&!Array.isArray(payload.kwargs))setInputValue('testKwargs',prettyJson(payload.kwargs));const note=$('spaceTestArgsNote');if(note){note.hidden=false;note.textContent='Arguments filled from discovered Gradio schema.';} }
function setBuildModeNew(){const panel=$('buildModePanel');if(panel){panel.classList.remove('inspecting');panel.innerHTML='Preparing a new buildThis form launches new builds. Existing runs can be inspected in the Runs Explorer on the right.
'}const launch=$('launchResultPanel');if(launch)launch.hidden=true;const status=$('progressStatus');if(status){status.textContent='Idle';status.className='badge neutral'}setText('progressTitle','No run selected')}
function setBuildModeInspecting(runId){const panel=$('buildModePanel');if(panel){panel.classList.add('inspecting');panel.innerHTML=`Inspecting selected runYou are viewing run ${escapeHtml(runId||'')}. The build form is unchanged and the active run panel is now tracking it.
`}}
function renderActiveRunEmptyState(){
const timeline=$('timeline');
if(timeline){timeline.dataset.signature='empty';timeline.className='timeline empty-timeline';timeline.innerHTML='No active run selectedLaunch a build or select a run from Runs Explorer. The timeline will appear once a run starts.
';if(timeline.style?.removeProperty)timeline.style.removeProperty('--timeline-phase-count');}
const note=$('timelineTraceNote');if(note){note.hidden=true;note.innerHTML='';note.className='timeline-trace-note';}
const details=$('timelinePhaseDetails');if(details){details.hidden=true;details.innerHTML='';details.className='timeline-phase-details';}
}
function resetRunDetails(){
const cancel=$('cancelRun');if(cancel)cancel.disabled=true;
if(typeof elapsedClock!=='undefined')elapsedClock.isRunning=false;if(typeof resetProgressStability==='function')resetProgressStability(null);
if(typeof activityFeedState!=='undefined'){activityFeedState.lastItems=[];activityFeedState.runId=null}
for(const [id,value] of [
['detailRunId','—'],['detailJobStatus','—'],['detailGateStatus','—'],['detailSpace','—'],['detailHardware','—'],['detailTargetGpu','—'],['detailFallbackGpu','—'],['detailExpectedOutput','—'],['detailPiAssistant','—'],['detailTraces','—'],
['homeRunDetailStatus','No run'],['selectedModelId','—'],['progressTitle','No run selected'],['progressStatus','Idle'],
['currentStep','—'],['lastEvent','Select a run from the explorer or launch a new build.'],['elapsed','—'],['lastPolled','—'],
['progressPercent','0%']
])setText(id,value);
setText('activeLatencyValue','—');setText('activeZeroGpuDuration','—');setText('activeLatencySource','waiting for live smoke test');const latencyCard=$('activeLatencyCard');if(latencyCard){latencyCard.classList.remove('has-latency');latencyCard.classList.add('is-loading')}
const status=$('progressStatus');if(status)status.className='badge neutral';
const fill=$('progressFill');if(fill){fill.style.width='0%';fill.classList.remove('is-running','progress-bump','is-success','is-warn','is-error','is-running-state','is-stopped','is-neutral')}const cap=$('progressCaptionLabel');if(cap)cap.textContent='Overall progress';const sem=$('progressSemantics');if(sem){sem.hidden=true;sem.innerHTML=''}const bar=$('progressBar');if(bar)bar.setAttribute('aria-valuenow','0')
setQuickLinks({});
const full=$('reportPreview');if(full)full.textContent='No report selected.';
const manual=$('manualActionPanel');if(manual)manual.hidden=true;
const activity=$('activityFeed');if(activity){activity.dataset.signature='';activity.classList.remove('show-all');activity.innerHTML='No activity yet.
'}
const events=$('eventsPanel');if(events)events.textContent='No events yet.';
const artifacts=$('artifactList');if(artifacts)artifacts.textContent='No artifacts indexed yet.';
const recovery=$('agentRecoveryCard');if(recovery){recovery.hidden=true;const body=$('agentRecoveryBody');if(body)body.innerHTML='';const badge=$('agentRecoveryBadge');if(badge){badge.textContent='Not needed';badge.className='badge neutral'}}
const docs=$('runDocumentsDock');if(docs)docs.innerHTML='Run documents will appear as files are written to the bucket.
';
const blockers=$('selectedBlockers');if(blockers){blockers.hidden=true;blockers.innerHTML=''}
if(typeof clearEvalArchiveStatus==='function')clearEvalArchiveStatus('active-run-reset');
for(const id of ['deleteActiveRun','activePrefillSpaceTest','deleteValidationRun']){const btn=$(id);if(btn)btn.disabled=true}
// legacy anchor: renderTimeline(DEFAULT_TIMELINE,'idle')
renderActiveRunEmptyState();
} function prepareNewBuild(){if(state.poll){clearInterval(state.poll);state.poll=null}state.runId=null;state.activeRunProgress=null;state.selectedRunDetail=null;state.documentCache={};state.latencyCache={};state.activeLinks={};state.pollErrors=0;clearSavedRun();document.querySelectorAll('.run-row').forEach(r=>r.classList.remove('selected'));setBuildModeNew();resetRunDetails();setText('progressPercent','0%');const cap=$('progressCaptionLabel');if(cap)cap.textContent='Overall progress';const sem=$('progressSemantics');if(sem){sem.hidden=true;sem.innerHTML=''}const fill=$('progressFill');if(fill)fill.style.width='0%';setText('currentStep','Ready');setText('lastEvent','Choose a model card and launch a build.');setText('elapsed','—');if(typeof elapsedClock!=='undefined')elapsedClock.isRunning=false;setText('lastPolled','—');setText('hardwarePlan',hardwarePlanLabel());renderMetrics({});showMessage('New build mode ready.','info')}
function renderQuietLaunchState(result={}){setText('progressTitle','Starting build Job…');setText('progressStatus','Running');const statusEl=$('progressStatus');if(statusEl)statusEl.className='badge '+statusClass('running');setText('progressPercent','1%');const fill=$('progressFill');if(fill)fill.style.width='1%';setText('lastEvent','Build Job launched; waiting for the first canonical run snapshot.');setText('elapsed','—');setText('lastPolled','—');const timeline=$('timeline');if(timeline){timeline.innerHTML='Waiting for first run snapshot…
';timeline.classList.remove('timeline-canonical');timeline.style.gridTemplateColumns=''}const note=$('timelineTraceNote');if(note){note.hidden=true;note.innerHTML=''}const details=$('timelinePhaseDetails');if(details){details.hidden=true;details.innerHTML='';details.className='timeline-phase-details'}}
function resetSpaceTestForNewBuild(runId=''){
if(typeof stopValidationPolling==='function')stopValidationPolling();
state.validationRequestSeq=(state.validationRequestSeq||0)+1;
state.validationPollToken=null;
state.validationRunId=null;
state.validationDetail=null;
state.validationMode='idle';
state.validationPollErrors=0;
state.validationPrefillDraft=null;
state.linkedValidationParent=null;
state.validationArgsDirty=false;
const note=$('spaceTestArgsNote');if(note)note.hidden=true;
const readiness=$('spaceTestLaunchReadiness');if(readiness){readiness.hidden=false;readiness.className='validation-args-note launch-readiness blocked';readiness.textContent='Space Test will be available after this build reaches a final Space state.';}
setInputValue('validateSpace','');
setInputValue('validateApi','');
setInputValue('testArgs',prettyJson(defaultValidationArgs(formValue('buildExpectedOutput')||'image')));
setInputValue('testKwargs','{}');
setText('spaceTestEndpoint','—');
setText('spaceTestOutput','Not launched');
setText('validationStartedAt','Not launched');
setText('spaceTestLatency','—');
setText('spaceTestVerdict',runId?`Waiting for Build Run ${runId} to finish.`:'Waiting for a Build Run to finish.');
const badge=$('spaceTestStatus');if(badge){badge.textContent='Blocked';badge.className='badge neutral';}
const tabDot=$('spaceTestTabDot');if(tabDot)tabDot.className='tab-status-dot neutral';
const timeline=$('spaceTestTimeline');if(timeline){timeline.hidden=true;timeline.innerHTML='';}
setValidationProgressVisible(false);
const deleteBtn=$('deleteValidationRun');if(deleteBtn)deleteBtn.disabled=true;
const launchBtn=$('launchValidate');if(launchBtn){launchBtn.textContent='Run linked validation';launchBtn.disabled=true;launchBtn.title='Available after the build reaches a final Space state.';}
const endpoints=$('spaceTestEndpoints');if(endpoints){endpoints.innerHTML='Space TestWaiting for current Build Run to finish
';}
}
function clearValidationRunStateForBuildContext(parentRunId='',reason='build_selection'){
if(typeof stopValidationPolling==='function')stopValidationPolling();
state.validationRequestSeq=(state.validationRequestSeq||0)+1;
state.validationPollToken=null;
state.validationRunId=null;
state.validationDetail=null;
state.validationMode='idle';
state.validationPollErrors=0;
state.validationArgsDirty=false;
state.validationPrefillDraft=null;
state.linkedValidationParent=parentRunId||null;
const note=$('spaceTestArgsNote');if(note)note.hidden=true;
setText('spaceTestOutput','Not launched');
setText('validationStartedAt','Not launched');
setText('spaceTestLatency','—');
setText('spaceTestVerdict',parentRunId?`Linked to Build Run ${parentRunId}. No validation run launched yet.`:'Select a Build Run to prepare Space Test.');
setText('spaceTestEndpoint','—');
const timeline=$('spaceTestTimeline');if(timeline){timeline.hidden=true;timeline.innerHTML='';timeline.dataset.parentRunId=parentRunId||'';}
setValidationProgressVisible(false);
const deleteBtn=$('deleteValidationRun');if(deleteBtn){deleteBtn.disabled=true;deleteBtn.onclick=null;}
const tabDot=$('spaceTestTabDot');if(tabDot){tabDot.className='tab-status-dot neutral';tabDot.title='No active linked validation';}
const badge=$('spaceTestStatus');if(badge){badge.textContent='Preparing';badge.className='badge neutral';}
const card=$('spaceTestPreview');if(card){card.classList.remove('validation-running','validation-success','validation-error');card.classList.add('space-test-context-only');}
const readiness=$('spaceTestLaunchReadiness');if(readiness){readiness.hidden=false;readiness.className='validation-args-note launch-readiness blocked';readiness.textContent='Preparing Space Test context for the selected Build Run.';}
return true;
}
function requestSpaceTestContextResetForBuild(runId){
state.spaceTestContextResetForRun=runId||true;
}
function setActiveRun(result){if(state.poll){clearInterval(state.poll);state.poll=null}resetSpaceTestForNewBuild(result?.run_id||'');resetRunDetails();state.documentCache={};state.latencyCache={};state.runId=result.run_id;state.spaceLinksUnlockedFor=null;if(Array.isArray(state.runsCache)&&typeof sortRunsNewestFirst==='function'){state.runsCache=sortRunsNewestFirst([{...result,run_id:result.run_id,status:result.status||'running',created_at:result.created_at||new Date().toISOString()},...state.runsCache.filter(r=>r.run_id!==result.run_id)]);renderRunsFromCache();if(typeof renderRunStats==='function')renderRunStats();}if(result.bucket_source)state.bucketSource=result.bucket_source;setText('detailRunId',result.run_id);setText('detailJobStatus',result.status||'RUNNING');setText('detailGateStatus',result.kind||'running');setText('detailSpace',result.target_space||'—');setText('detailHardware',result.selected_hardware||result.preferred_space_hardware||'—');renderActiveRunMeta({summary:result,state:result,launch:result});renderQuietLaunchState(result);setText('homeRunDetailStatus',result.status||'Running');setBuildModeInspecting(result.run_id);setQuickLinks({...result.links,bucket_source:result.bucket_source,run_id:result.run_id,job_id:result.job_id,job_owner:state.user?.username,target_space_url:result.target_space_url},result);saveActiveRun();markPendingActiveFields();startPolling(result.run_id)}
function startPolling(runId,options={}){
if(!runId)return;
const sameRun=state.runId===runId;
if(sameRun&&state.poll)return;
if(!sameRun){
state.spaceLinksUnlockedFor=null;
const blockers=$('selectedBlockers');if(blockers){blockers.hidden=true;blockers.innerHTML=''}
}
state.runId=runId;
state.pollErrors=0;
state.lastJobLogPoll=0;
if(typeof resetProgressStability==='function')resetProgressStability(runId);
if(state.poll)clearInterval(state.poll);
saveActiveRun();
if(!options.deferFirstTick)refreshProgress();
else setTimeout(()=>{if(state.runId===runId)refreshProgress()},80);
state.poll=setInterval(refreshProgress,1500);
}
async function bootstrapRunRecovery(){return restoreActiveRun()}
async function restoreActiveRun(){try{const resumable=await apiGet(`/api/runs/resumable?bucket_name=${encodeURIComponent(state.bucketName)}`);if(resumable?.run?.run_id){state.runId=resumable.run.run_id;if(resumable.bucket_source)state.bucketSource=resumable.bucket_source;setBuildModeInspecting(state.runId);if(resumable.view)renderRunViewModel(resumable.view,{progress:0,events:[]});setQuickLinks(resumable.view?.links||{},resumable.view||{});startPolling(state.runId);return true}}catch(e){console.warn('resumable lookup failed',e)}try{const raw=localStorage.getItem('asf.activeRun');if(!raw)return false;const saved=JSON.parse(raw);if(saved?.bucketName)state.bucketName=saved.bucketName;if(saved?.runId){state.runId=saved.runId;setText('detailRunId',saved.runId);setQuickLinks(saved.links||{},{});setBuildModeInspecting(saved.runId);startPolling(saved.runId);return true}}catch(_){}return false}
async function refreshAnonymousEvalStatus(){
try{
const anonymous_eval=await apiGet('/api/eval-archive/status');
renderAnonymousEvalStatus({anonymous_eval});
return anonymous_eval;
}catch(e){
renderAnonymousEvalStatus({anonymous_eval:{enabled:false,reason:'status_unavailable',managed_by:'instance owner'}});
return null;
}
}
function isAuthExpiredError(error){return /expired|oauth_expired|session expired/i.test(String(error?.message||error||''))}
async function loadAppInfo(){setOperation('Checking sign-in and run storage…','loading');setBucketFeedback('checking','Checking private bucket access…');try{const me=await apiGet('/api/me');state.user=me;startAuthLifetimeTicker();renderAnonymousEvalStatus(me);setText('userChip','@'+me.username);configureAuthAnchor($('userChip'),`https://huggingface.co/${me.username}`);const logout=$('logoutLink');if(logout){logout.hidden=false;logout.textContent='Reset auth';configureAuthAnchor(logout,me.logout_url||authLogoutUrl(),{newTab:false})}state.bucketSource=me.username+'/'+state.bucketName;setText('bucketInlineLabel',state.bucketSource);renderAuthWarnings(me);renderBillingPanel(me);loadBillingStatus().catch(()=>{});await checkBucket(false);await loadRuns(true);clearSavedRun();if(!state.bucketReady)setOperation('Create your private run bucket before launching builds.','warning');else setOperation('')}catch(e){const expired=isAuthExpiredError(e);clearClientAuthState();await refreshAnonymousEvalStatus();setText('userChip',expired?'Refresh sign-in':'Sign in');configureAuthAnchor($('userChip'),expired?authRefreshLoginUrl():authLoginUrl(),{newTab:expired});const logout=$('logoutLink');if(logout){logout.hidden=false;logout.textContent='Reset auth';configureAuthAnchor(logout,authResetLocalUrl(),{newTab:false})}renderSignedOut({expired});renderBillingPanel(null);setBucketReady(false,expired?'HF OAuth expired. Refresh sign-in before continuing.':'Sign in with Hugging Face first.');showMessage(expired?'HF OAuth expired. Use Refresh sign-in to reconnect cleanly.':'Please sign in with Hugging Face to continue.',true)}}
function renderSignedOut({expired=false}={}){const auth=$('authPanel');if(!auth)return;auth.hidden=false;auth.className='auth-panel warning';if(expired){auth.innerHTML=`HF Auth expiredYour Hugging Face OAuth session expired or is stale. Refresh sign-in clears the local OAuth session first, then starts a fresh authorization. Use Reset auth if the browser is still stuck.
Refresh sign-inReset local auth`;return}auth.innerHTML=`Sign in requiredUse Hugging Face OAuth before launching Jobs or reading your Bucket.
Sign in with Hugging FaceReset local auth`}
function renderAuthWarnings(me){const auth=$('authPanel');if(!auth)return;const missing=me.missing_scopes||[];const warnings=[...(me.warnings||[])];const lifetime=authLifetimeFromUser(me);if(['warning','critical','expired'].includes(lifetime.status))warnings.push(lifetime.recommendation||authLifetimeLabel(lifetime));if(!missing.length&&!warnings.length){auth.hidden=true;auth.innerHTML='';return}auth.hidden=false;auth.className='auth-panel warning';const refresh=String(lifetime.status||'')==='expired'?authRefreshLoginUrl():authRefreshLoginUrl();auth.innerHTML=`OAuth session warning${escapeHtml([...warnings,missing.length?'Missing scopes: '+missing.join(', '):''].filter(Boolean).join(' • '))}
Refresh sign-inReset local auth`}
function renderBillingPanel(info){
// Open HF Billing: Live quotas, spend and compute usage remain in the HF Billing dashboard.
const badge=$('billingStatusBadge');
const canPay=info?.can_pay===true||info?.payment_ready===true;
if(badge){
badge.textContent=canPay?'Billing ready':'Check billing';
badge.className='badge '+(canPay?'success':'warn');
}
const billing=$('openBilling');
if(billing)billing.href=info?.links?.billing||'https://huggingface.co/settings/billing';
}
async function loadBillingStatus(){
try{const data=await apiGet('/api/billing/status');renderBillingPanel({...state.user,...data});return data}catch(e){console.warn('billing status failed',e);return null}
}
async function enableEvalArchive(){
const me=state.user;
const cfg=me?.anonymous_eval||{};
const bucketSource=cfg.proposed_bucket_source||(me?.username?`${me.username}/agentic-space-factory-evals`:null);
if(!bucketSource){showMessage('Sign in before enabling the eval archive.',true);return}
setButtonBusy('enableEvalArchive',true,'Enabling…');
try{
const result=await apiPost('/api/eval-archive/activate',{bucket_source:bucketSource,bucket_path:cfg.default_bucket_path||'evals',mount_path:cfg.default_mount_path||'/evals'});
state.user={...(state.user||{}),anonymous_eval:result};
renderAnonymousEvalStatus(state.user);
showMessage(result.message||`Eval archive enabled: ${bucketSource}`,'success');
}catch(e){showMessage(e.message,true)}
finally{setButtonBusy('enableEvalArchive',false)}
}
async function verifyEvalArchive(){
setButtonBusy('verifyEvalArchive',true,'Verifying…');
try{
const result=await apiGet('/api/eval-archive/status');
state.user={...(state.user||{}),anonymous_eval:result};
renderAnonymousEvalStatus(state.user);
showMessage(result.enabled?'Eval archive configuration verified.':'Eval archive is not enabled.',result.enabled?'success':'warning');
}catch(e){showMessage(e.message,true)}
finally{setButtonBusy('verifyEvalArchive',false)}
}
async function disableEvalArchive(){
const ok=window.confirm('Disable anonymous eval publishing for this ASF instance? Existing archived records will not be deleted.');
if(!ok)return;
setButtonBusy('disableEvalArchive',true,'Disabling…');
try{
const result=await apiPost('/api/eval-archive/disable',{});
state.user={...(state.user||{}),anonymous_eval:result};
renderAnonymousEvalStatus(state.user);
showMessage(result.message||'Eval archive disabled.','success');
}catch(e){showMessage(e.message,true)}
finally{setButtonBusy('disableEvalArchive',false)}
}
async function flushEvalArchive(){
const ok=window.confirm('Delete all anonymized eval archive records from the mounted operator bucket? This preserves the eval archive configuration but cannot be undone.');
if(!ok)return;
setButtonBusy('flushEvalArchive',true,'Flushing…');
try{
const result=await apiPost('/api/eval-archive/flush',{});
state.user={...(state.user||{}),anonymous_eval:result};
renderAnonymousEvalStatus(state.user);
showMessage(result.message||'Eval archive records flushed.',result.partial_flush?'warning':'success');
}catch(e){showMessage(e.message,true)}
finally{setButtonBusy('flushEvalArchive',false)}
}
async function checkBucket(noisy=true){setButtonBusy('checkBucket',true,'Checking…');setBucketFeedback('checking','Checking private bucket access…');try{const data=await apiGet(`/api/bucket/status?bucket_name=${encodeURIComponent(state.bucketName)}`);const source=data.bucket_source||state.bucketName;state.bucketSource=source;setText('bucketInlineLabel',source);setBucketReady(Boolean(data.ok),data.error||'Create your private run bucket before launching builds.');if(noisy)showMessage(data.ok?`Bucket ready: ${source}`:`Bucket not ready: ${data.error||'not found'}`,!data.ok);return data}catch(e){setBucketReady(false,e.message);if(noisy)showMessage(e.message,true);throw e}finally{setButtonBusy('checkBucket',false)}}
async function createBucket(){setButtonBusy('createBucket',true,'Creating…');setBucketFeedback('creating','Creating private bucket…');try{const data=await apiPost('/api/bucket/create',{bucket_name:state.bucketName});const source=data.bucket_source||state.bucketName;state.bucketSource=source;setText('bucketInlineLabel',source);setBucketReady(Boolean(data.ok),data.error||'Could not create bucket.');showMessage(data.ok?`Created/ready: ${source}`:`Could not create bucket: ${data.error}`,!data.ok);if(data.ok)loadRuns(true)}catch(e){setBucketReady(false,e.message);showMessage(e.message,true)}finally{setButtonBusy('createBucket',false)}}
function switchCenterTab(tab='active',options={}){
const next=tab==='validate'?'validate':'active';
if(options&&options.source==='user'){
state.centerTabUserTouchedAt=Date.now();
state.centerTabUserTouchedSelectionSeq=state.runSelectionSeq||0;
}
state.centerTab=next;
document.querySelectorAll('[data-center-tab]').forEach(btn=>{
const active=btn.dataset.centerTab===next;
btn.classList.toggle('active',active);
btn.setAttribute('aria-selected',active?'true':'false');
});
document.querySelectorAll('[data-center-panel]').forEach(panel=>{
const active=panel.dataset.centerPanel===next;
panel.classList.toggle('active',active);
panel.hidden=!active;
});
}
function renderManualAction(p={}){const panel=$('manualActionPanel');if(!panel)return;const view=p.view||{};const sm=view.status_model||{};const status=String(p.status||p.state?.status||p.inference_gate?.status||sm.global_status||'');const manual=Boolean(sm.requires_manual_action||p.manual_hardware_required||p.inference_gate?.manual_hardware_required||p.hardware_strategy?.manual_action_required||status.includes('manual_hardware_required')||status.includes('generated_needs_manual_hardware')||status.includes('waiting_manual_action'));panel.hidden=!manual;if(!manual)return;setText('manualActionTitle','Manual hardware required');setText('manualActionText','Automatic hardware selection was not available. Open Space settings, choose the recommended GPU, then run Space Test.');setLink('manualOpenSettings',(p.links||view.links||state.activeLinks||{}).target_space_settings_url)}
function defaultValidationArgs(expected='text'){
const kind=String(expected||'text').toLowerCase();
if(kind==='image')return ["a cinematic robot cat astronaut, detailed, studio lighting"];
if(kind==='video')return ["a short cinematic shot of a robot cat astronaut walking on the moon"];
if(kind==='audio')return ["A calm voice saying hello from Agentic Space Factory."];
return ["Explain the concept of agentic AI in one paragraph."];
}
function normalizeApiName(value){
value=String(value||'').trim();
if(!value)return'/generate';
return value.startsWith('/')?value:'/'+value;
}
function firstPositiveNumber(...values){
for(const value of values.flat()){
const n=Number(value);
if(Number.isFinite(n)&&n>0)return n;
}
return null;
}
function formatLatencySeconds(value){
const n=Number(value);
if(!Number.isFinite(n)||n<=0)return'—';
if(n<10)return`${n.toFixed(2).replace(/\.00$/,'')}s`;
if(n<60)return`${n.toFixed(1).replace(/\.0$/,'')}s`;
return fmtSeconds(Math.round(n));
}
function parsedJsonOrNull(value){
if(value==null||value==='')return null;
try{return typeof value==='string'?JSON.parse(value):value}catch(_){return null}
}
function firstArrayPath(...values){
for(const value of values){
if(Array.isArray(value))return value;
const parsed=parsedJsonOrNull(value);
if(Array.isArray(parsed))return parsed;
}
return null;
}
function firstObjectPath(...values){
for(const value of values){
if(value&&typeof value==='object'&&!Array.isArray(value))return value;
const parsed=parsedJsonOrNull(value);
if(parsed&&typeof parsed==='object'&&!Array.isArray(parsed))return parsed;
}
return null;
}
function testPayloadFromEndpointParameters(parameters=[],expected='text'){
if(!Array.isArray(parameters)||!parameters.length)return null;
const args=[];
for(const param of parameters){
const name=String(param?.name||param?.parameter_name||param?.label||'').toLowerCase();
const component=String(param?.component||param?.component_type||param?.type||'').toLowerCase();
const choices=Array.isArray(param?.choices)?param.choices:(Array.isArray(param?.options)?param.options:[]);
if(name.includes('negative'))args.push('');
else if(name.includes('prompt'))args.push(defaultValidationArgs(expected)[0]);
else if(name.includes('resolution')&&choices.length)args.push(String(choices[0]));
else if(name.includes('height'))args.push(Number(param?.default||1024));
else if(name.includes('width'))args.push(Number(param?.default||1024));
else if(name.includes('step'))args.push(Number(param?.default||9));
else if(name.includes('guidance'))args.push(Number(param?.default||0));
else if(name.includes('seed')&&component.includes('checkbox'))args.push(Boolean(param?.default??true));
else if(name.includes('random')&&name.includes('seed'))args.push(Boolean(param?.default??true));
else if(name.includes('seed'))args.push(Number(param?.default??42));
else if(choices.length)args.push(String(choices[0]));
else if(component.includes('checkbox'))args.push(Boolean(param?.default??false));
else if(component.includes('number')||component.includes('slider'))args.push(Number(param?.default??0));
else args.push(param?.default??'');
}
return args.length?args:null;
}
function validationPrefillFromDetail(detail={}){
const progress=(state.activeRunProgress&&((state.activeRunProgress.run_id||state.activeRunProgress.summary?.run_id)===(detail.run_id||detail.summary?.run_id||state.runId)))?state.activeRunProgress:{};
const summary={...(detail.summary||{}),...(progress.summary||{})};
const gate={...(detail.inference_gate||{}),...(progress.inference_gate||{})};
const gateSmoke=gate.generation_smoke&&typeof gate.generation_smoke==='object'?gate.generation_smoke:{};
const smoke={...(detail.state?.generation_smoke||{}),...(detail.tests?.generation_smoke||{}),...(detail.generation_smoke||{}),...(progress.generation_smoke||{}),...(progress.state?.generation_smoke||{}),...gateSmoke};
const smokePayload=firstObjectPath(
detail.generation_smoke_payload_retry,
detail.tests?.generation_smoke_payload_retry,
progress.generation_smoke_payload_retry,
progress.tests?.generation_smoke_payload_retry,
detail.generation_smoke_payload,
detail.tests?.generation_smoke_payload,
progress.generation_smoke_payload,
progress.tests?.generation_smoke_payload
)||{};
const launch={...(detail.launch||{}),...(progress.launch||{})};
const stateObj={...(detail.state||{}),...(progress.state||{})};
const expected=smoke.expected_output_type||gate.expected_output_type||launch.expected_output_type||summary.expected_output_type||stateObj.expected_output_type||formValue('buildExpectedOutput')||'text';
const endpointParameters=smoke.parameters||smoke.endpoint_parameters||gate.endpoint_parameters||gate.smoke_parameters||[];
let args=firstArrayPath(smoke.effective_args,smoke.test_args,smoke.args,smokePayload.effective_args,smokePayload.test_args,smokePayload.args,gate.effective_args,gate.test_args,gateSmoke.effective_args,gateSmoke.test_args,launch.test_args_json,summary.test_args_json);
if(!Array.isArray(args))args=testPayloadFromEndpointParameters(endpointParameters,expected);
let kwargs=firstObjectPath(smoke.effective_kwargs,smoke.test_kwargs,smoke.kwargs,smokePayload.effective_kwargs,smokePayload.test_kwargs,smokePayload.kwargs,gate.effective_kwargs,gate.test_kwargs,gateSmoke.effective_kwargs,gateSmoke.test_kwargs,launch.test_kwargs_json,summary.test_kwargs_json);
if(!Array.isArray(args))args=defaultValidationArgs(expected);
if(!kwargs||Array.isArray(kwargs)||typeof kwargs!=='object')kwargs={};
const policy=detail.space_test_policy||detail.view?.space_test_policy||detail.space_test?.policy||progress.view?.space_test_policy||progress.view?.space_test?.policy||{};
const target=policy.target_space||summary.target_space||stateObj.target_space||launch.target_space||progress.target_space||$('detailSpace')?.textContent||'';
const parentBuildRunId=policy.parent_build_run_id||detail.run_id||detail.summary?.run_id||state.runId||progress.run_id||'';
const automaticSmokePassed=Boolean(smoke.ok||smoke.status==='success'||policy.mode==='replay'||policy.allow_replay||policy.automatic_smoke_passed||policy.reason==='automatic_smoke_passed'||gate.strong_full_inference_success||summary.generation_smoke_passed||stateObj.generation_smoke_passed);
const smokeArtifactHasPayload=Boolean(smokePayload.effective_args||smokePayload.test_args||smokePayload.args||smoke.effective_args||smoke.test_args||smoke.args);
const policyContext={automaticSmokePassed,smokeArtifactPayloadAvailable:smokeArtifactHasPayload};
const api=spaceTestPolicyBlocksGeneration(policy,policyContext)?'':(policy.requires_endpoint_discovery?'':normalizeApiName(policy.endpoint||smoke.api_name||gate.api_name||launch.api_name||gateSmoke.api_name||stateObj.primary_api_name||stateObj.promise_validation?.primary_api_name||progress.api_name||'/generate'));
const requiresEndpointDiscovery=Boolean(policy.requires_endpoint_discovery&&!spaceTestPolicyRuntimeProofAllowsGeneration(policy,policyContext));
const payloadSource=requiresEndpointDiscovery?'endpoint_discovery_first':((smoke.effective_args||smoke.test_args||smoke.args||smokeArtifactHasPayload||automaticSmokePassed)?'automatic_smoke_artifact':(endpointParameters.length?'gradio_schema_defaults':'default_payload'));
return {target,api,expected,args,kwargs,parentBuildRunId,sourceRunId:parentBuildRunId,linkedTargetSpace:target,automaticSmokePassed,smokeLatency:smoke.latency_seconds||smoke.observed_latency_seconds||summary.latency_seconds||stateObj.latency_seconds,spaceTestPolicy:policy,requiresEndpointDiscovery,payloadSource,smokeArtifactPayloadAvailable:smokeArtifactHasPayload};
}
function setValidationProgressVisible(visible){
const show=Boolean(visible);
const caption=(document.querySelector?document.querySelector('.validation-progress-caption'):null);
const bar=(document.querySelector?document.querySelector('.validation-progress-bar'):null);
const timeline=$('spaceTestTimeline');
if(caption)caption.hidden=!show;
if(bar)bar.hidden=!show;
if(timeline)timeline.hidden=!show;
}
function spaceTestLaunchLabel(prefill={}){
const policy=prefill.spaceTestPolicy||prefill.space_test_policy||{};
if(spaceTestPolicyDisabledByStaleBlocker(policy,prefill))return policy.label||'Space Test blocked';
if(spaceTestPolicyAuthRecovery(policy))return'Retry linked validation';
if((prefill.requiresEndpointDiscovery||policy.requires_endpoint_discovery)&&!spaceTestPolicyRuntimeProofAllowsGeneration(policy,prefill))return'Discover endpoints and validate';
const mode=String(policy.mode||'').toLowerCase();
if(mode==='replay'||prefill.automaticSmokePassed)return'Re-run linked validation';
if(mode==='recover')return'Run recovery validation';
return'Run linked validation';
}
function smokeLatencyLabel(value){
return value?`${formatLatencySeconds(value)} from automatic smoke`:'—';
}
function spaceTestPolicyRuntimeProofAllowsGeneration(policy={},context={}){
const reason=String(policy.reason||'').toLowerCase();
const mode=String(policy.mode||'').toLowerCase();
return Boolean(context.automaticSmokePassed||context.smokeArtifactPayloadAvailable||policy.allow_replay||policy.automatic_smoke_passed||policy.runtime_proof_authoritative||mode==='replay'||reason==='automatic_smoke_passed'||reason==='manual_validation_already_passed');
}
function spaceTestPolicyBlocksGeneration(policy={},context={}){
const reason=String(policy.reason||'').toLowerCase();
if(spaceTestPolicyRuntimeProofAllowsGeneration(policy,context))return false;
return Boolean(policy.no_generation_endpoint||reason==='no_generation_endpoint_by_contract'||reason==='contract_declared_no_full_inference');
}
function spaceTestPolicyDisabledByStaleBlocker(policy={},context={}){
if(policy.enabled!==false)return false;
const reason=String(policy.reason||'').toLowerCase();
if(spaceTestPolicyRuntimeProofAllowsGeneration(policy,context)&&(reason==='no_generation_endpoint_by_contract'||reason==='contract_declared_no_full_inference'))return false;
return true;
}
function spaceTestPolicyAuthRecovery(policy={}){
const reason=String(policy.reason||'').toLowerCase();
return Boolean(reason==='auth_refresh_required'||reason==='repair_validation_inconclusive_auth');
}
function linkedValidationPayloadError(message,meta={}){
return {launchable:false,error:message,...meta};
}
function resolveLinkedValidationPayload(options={}){
const draft=state.validationPrefillDraft||{};
const policy=draft.spaceTestPolicy||draft.space_test_policy||{};
const parentBuildRunId=draft.parentBuildRunId||draft.sourceRunId||state.linkedValidationParent||'';
if(!parentBuildRunId)return linkedValidationPayloadError('Select a completed Build Run before launching Space Test. Standalone validation is not supported.');
const target=(formValue('validateSpace')||draft.target||draft.linkedTargetSpace||'').trim();
if(!target)return linkedValidationPayloadError('This linked Space Test has no target Space. Select a Build Run with a generated Space first.',{parentBuildRunId});
const linkedTarget=draft.target||draft.linkedTargetSpace||'';
if(linkedTarget&&target!==linkedTarget)return linkedValidationPayloadError('This Space Test is locked to the selected Build Run target Space. Standalone validation is not supported.',{parentBuildRunId,target});
if(spaceTestPolicyDisabledByStaleBlocker(policy,draft))return linkedValidationPayloadError(policy.message||'This Build Run is not eligible for linked Space Test yet.',{parentBuildRunId,target,policy});
if(state.user?.username&&target.includes('/')&&target.split('/')[0]!==state.user.username)return linkedValidationPayloadError(`For now, Space Test can only validate Spaces in your own namespace (${state.user.username}/...).`,{parentBuildRunId,target});
const requiresEndpointDiscovery=Boolean((draft.requiresEndpointDiscovery||policy.requires_endpoint_discovery)&&!spaceTestPolicyRuntimeProofAllowsGeneration(policy,draft));
const rawApi=(formValue('validateApi')||draft.api||policy.endpoint||'').trim();
const apiName=requiresEndpointDiscovery?'':normalizeApiName(rawApi||'/generate');
if(!requiresEndpointDiscovery&&!apiName)return linkedValidationPayloadError('No endpoint is selected for this linked validation.',{parentBuildRunId,target});
const timeout=validationTimeoutValue();
if(!Number.isFinite(timeout))return linkedValidationPayloadError('Timeout must be a number of seconds.',{parentBuildRunId,target});
const sizeError=validationPayloadSizeError();
if(sizeError)return linkedValidationPayloadError(sizeError,{parentBuildRunId,target});
let args,kwargs;
try{
args=parseJsonField('testArgs',Array.isArray(draft.args)?draft.args:[]);
kwargs=parseJsonField('testKwargs',(draft.kwargs&&typeof draft.kwargs==='object'&&!Array.isArray(draft.kwargs))?draft.kwargs:{});
}catch(e){return linkedValidationPayloadError(`Invalid JSON payload: ${e.message}`,{parentBuildRunId,target});}
if(!Array.isArray(args))return linkedValidationPayloadError('Test args must be a JSON array because they are passed as positional arguments to gradio_client.predict(...).',{parentBuildRunId,target});
if(!kwargs||Array.isArray(kwargs)||typeof kwargs!=='object')return linkedValidationPayloadError('Test kwargs must be a JSON object because they are passed as keyword arguments.',{parentBuildRunId,target});
const expectedOutputType=formValue('expectedOutput')||draft.expected||'any';
const validationMode=String(policy.mode||draft.validationMode||'complete').toLowerCase();
const payloadSource=draft.payloadSource||(requiresEndpointDiscovery?'endpoint_discovery_first':(draft.automaticSmokePassed?'automatic_smoke':'linked_payload'));
return {launchable:true,parentBuildRunId,targetSpaceId:target,apiName,expectedOutputType,args,kwargs,timeout,validationMode,payloadSource,requiresEndpointDiscovery,policy};
}
function renderSpaceTestReadiness(){
const note=$('spaceTestLaunchReadiness');
if(!note)return;
if(!state.validationPrefillDraft){note.hidden=true;note.textContent='';return;}
const resolved=resolveLinkedValidationPayload();
note.hidden=false;
note.className='validation-args-note launch-readiness '+(resolved.launchable?'ready':'blocked');
if(resolved.launchable){
const discovery=resolved.requiresEndpointDiscovery?'Endpoint discovery will run before validation.':'Payload ready.';
note.textContent=`${discovery} Source: ${String(resolved.payloadSource||'linked_payload').replace(/_/g,' ')}.`;
}else{
note.textContent=resolved.error||'Space Test is not ready to launch.';
}
}
function renderValidationStatus(data={}){
const candidateRunId=validationDetailRunId(data)||state.validationRunId;
data=mergeValidationWithTerminalLock(data||state.validationDetail||{},candidateRunId);
state.validationDetail=data||state.validationDetail;
const summary=data.summary||{};
const smoke=data.generation_smoke||data.summary?.generation_smoke||data.state?.generation_smoke||{};
const canonical=validationCanonicalStatus(data);
const displayStatus={idle:'idle',full_inference_success:'full inference success',partial_validation:'partial validation',manual_hardware_required:'manual action required',failed:'failed',stale:'stale',stopped:'stopped',auth_refresh_required:'auth refresh required',running:'running'}[canonical]||canonical;
const klass=statusClass(displayStatus);
const isRunning=canonical==='running';
const isIdle=canonical==='idle';
const runIdForState=validationDetailRunId(data)||state.validationRunId;
if(runIdForState)rememberTerminalValidation(data);
applyEffectiveValidationArgs(data);
const badge=$('spaceTestStatus');
if(badge){badge.textContent=badgeLabel(displayStatus);badge.className='badge '+klass}
const tabDot=$('spaceTestTabDot');
if(tabDot)tabDot.className='tab-status-dot '+(isRunning?'running':klass);
const card=$('spaceTestPreview');
if(card)card.classList.toggle('is-validating',isRunning);
const runId=data.run_id||summary.run_id||state.validationRunId||'—';
const endpoint=normalizeApiName(data.api_name||summary.api_name||smoke.api_name||data.state?.api_name||state.validationPrefillDraft?.api||formValue('validateApi')||'')||'—';
setText('spaceTestEndpoint',isIdle?'—':endpoint);
setText('spaceTestOutput',isIdle?'Not launched':runId);
setText('validationStartedAt',isIdle?'Not launched':formatTime(data.updated_at||summary.updated_at||data.state?.updated_at||data.created_at||summary.created_at||new Date().toISOString()));
const latency=firstPositiveNumber(smoke.latency_seconds,smoke.observed_latency_seconds,summary.latency_seconds,summary.observed_latency_seconds,data.latency_seconds,data.observed_latency_seconds);
setText('spaceTestLatency',isIdle?'—':(latency?formatLatencySeconds(latency):(canonical==='running'?'—':'Not recorded')));
const diagnosis=data.validation_failure_diagnosis||data.summary?.validation_failure_diagnosis||data.state?.validation_failure_diagnosis||smoke.validation_failure_diagnosis||{};
const diagnosisMsg=diagnosis.message||diagnosis.error||diagnosis.failure_reason||diagnosis.failure_type||smoke.error||summary.error||data.error||'';
const verdictText=isIdle?(data.message||'No validation run selected.'):data._refreshing?`${badgeLabel(displayStatus)} · Refreshing…`:(canonical==='failed'&&diagnosisMsg?`Failed · ${String(diagnosisMsg).slice(0,220)}`:badgeLabel(displayStatus));
setText('spaceTestVerdict',verdictText);
const launchBtn=$('launchValidate');
if(launchBtn&&!(launchBtn.classList?.contains&&launchBtn.classList.contains('is-busy'))){
const draft=state.validationPrefillDraft||{};
launchBtn.textContent=runId&&runId!=='—'&&!isRunning&&!isIdle?'Re-run linked validation':(draft.parentBuildRunId?spaceTestLaunchLabel(draft):'Launch validation');
}
setValidationLaunchEnabled();
const deleteBtn=$('deleteValidationRun');
if(deleteBtn){deleteBtn.disabled=isIdle||!(runId&&runId!=='—')||isRunning;deleteBtn.onclick=(!deleteBtn.disabled)?()=>deleteRunById(runId,{kind:'validation',detail:data}):null;}
// Legacy invariant: deleteBtn.onclick=()=>deleteRunById is still owned by renderValidationStatus, not bindActions.
const percent=validationProgressPercent(data);
setText('spaceTestProgressPercent',isIdle?'0%':`${Math.round(percent)}%`);
const fill=$('spaceTestProgressFill');
if(fill){
fill.style.width=isIdle?'0%':`${Math.max(0,Math.min(100,percent))}%`;
fill.className='validation-progress-fill '+(isRunning?'is-running':klass);
}
setValidationProgressVisible(!isIdle);
if(isIdle){const timeline=$('spaceTestTimeline');if(timeline)timeline.innerHTML='No validation run selected.
';const endpoints=$('spaceTestEndpoints');if(endpoints)endpoints.innerHTML='Endpoint schema will appear after a validation run.
';}else{renderValidationTimeline(data);renderValidationEndpoints(data);}
}
function resetValidationRunView({reason='idle'}={}){
stopValidationPolling();
state.validationMode='idle';
state.validationRunId=null;
state.validationDetail=null;
state.validationPrefillDraft=null;
state.linkedValidationParent=null;
renderValidationStatus({status:'idle',run_id:'—',events:[],message:reason==='deleted'?'Validation run deleted.':'No validation run selected.'});
const readiness=$('spaceTestLaunchReadiness');if(readiness){readiness.hidden=true;readiness.textContent='';}
setValidationLaunchEnabled();
}
function renderValidationLaunchResult(result={}){
state.validationRunId=result.run_id;
renderValidationStatus({...result,status:result.status||'running'});
}
function renderValidationTimeline(detail={}){
const root=$('spaceTestTimeline');
if(!root)return;
const items=validationTimelineItems(detail);
root.innerHTML=items.map((item,idx)=>{
const st=statusClass(item.status||'pending');
const label=item.label||String(item.step||`Step ${idx+1}`).replace(/_/g,' ');
return `${escapeHtml(label)}${escapeHtml(badgeLabel(item.status||'pending'))}
`;
}).join('')||'No validation events yet.
';
}
function showValidationRunDetail(detail={}){
const incomingRunId=detail.run_id||detail.summary?.run_id||state.validationRunId;
state.validationRunId=incomingRunId;
detail=mergeValidationWithTerminalLock(detail,incomingRunId);
state.validationMode='view';
state.validationDetail=detail;
state.validationPrefillDraft=null;
rememberTerminalValidation(detail);
stopValidationPolling();
renderValidationStatus(detail);
applyValidationPrefill(detail,'validation run',{preserveSelection:true});
switchCenterTab('validate');
if(state.validationRunId&&validationCanonicalStatus(detail)==='running')startValidationPolling(state.validationRunId);
}
function linkedValidationParentFromDetail(detail={}){
return firstNonEmpty(
detail.parent_build_run_id,
detail.summary?.parent_build_run_id,
detail.state?.parent_build_run_id,
detail.launch?.parent_build_run_id,
state.linkedValidationParent,
state.validationPrefillDraft?.parentBuildRunId,
state.validationPrefillDraft?.sourceRunId
);
}
async function refreshLinkedValidationParentAfterTerminal(detail={}){
const parentId=linkedValidationParentFromDetail(detail);
if(!parentId)return;
try{
const snapshot=await fetchRunViewSnapshotOnce(parentId,{includeJobLogs:false});
if(snapshot){
if(typeof rememberRunDetail==='function')rememberRunDetail(parentId,snapshot,true);
if(typeof upsertRunExplorerFromProgress==='function')upsertRunExplorerFromProgress(snapshot);
if(state.runId===parentId&&typeof renderRunViewSnapshot==='function')renderRunViewSnapshot(snapshot);
if(typeof renderRunStats==='function')renderRunStats(state.runsCache||[]);
}
}catch(err){console.warn('linked validation parent refresh failed',err)}
try{await loadRuns(true)}catch(err){console.warn('linked validation runs refresh failed',err)}
}
function stopValidationPolling(){
if(state.validationPoll){clearInterval(state.validationPoll);state.validationPoll=null}
state.validationPollToken=null;
}
async function refreshValidationProgress(pollToken=state.validationPollToken){
const requestedRunId=state.validationRunId;
if(!requestedRunId)return;
try{
const p=await apiGet(`/api/runs/${encodeURIComponent(requestedRunId)}/progress?bucket_name=${encodeURIComponent(state.bucketName)}&include_job_logs=1`);
if(pollToken!==state.validationPollToken||requestedRunId!==state.validationRunId)return;
if(shouldIgnoreValidationUpdate(p,requestedRunId)){const terminal=terminalValidationForRun(requestedRunId);if(terminal){renderValidationStatus({...terminal.detail,_refreshing:true});stopValidationPolling();await refreshLinkedValidationParentAfterTerminal(terminal.detail);}return;}
state.validationPollErrors=0;
renderValidationStatus(p);
if(typeof upsertRunExplorerFromProgress==='function')upsertRunExplorerFromProgress(p);
const canonical=validationCanonicalStatus(p);
if(validationIsTerminalStatus(canonical)){state.validationMode='view';rememberTerminalValidation(p);stopValidationPolling();showMessage(`Validation finished: ${badgeLabel(canonical)}`,statusClass(canonical)==='success'?'success':statusClass(canonical)==='error'?'error':'warning');await refreshLinkedValidationParentAfterTerminal(p)}
}catch(e){
if(pollToken!==state.validationPollToken||requestedRunId!==state.validationRunId)return;
state.validationPollErrors+=1;
console.warn('validation polling failed',e);
if(state.validationPollErrors<=2)showMessage(`Validation polling failed. Retrying…`,'warning');
}
}
function startValidationPolling(runId){
const terminal=terminalValidationForRun(runId);
if(terminal){stopValidationPolling();state.validationMode='view';state.validationRunId=runId;renderValidationStatus({...terminal.detail,_refreshing:true});refreshLinkedValidationParentAfterTerminal(terminal.detail);return;}
stopValidationPolling();
state.validationMode='running';
state.validationRunId=runId;
state.validationPollToken=`${runId}:${Date.now()}:${++state.validationRequestSeq}`;
switchCenterTab('validate');
refreshValidationProgress(state.validationPollToken);
state.validationPoll=setInterval(()=>refreshValidationProgress(state.validationPollToken),2000);
}
function renderValidationPrefillDraft(prefill={},sourceLabel='selected Space'){
stopValidationPolling();
state.validationMode='draft';
state.validationRunId=null;
state.validationDetail=null;
state.validationArgsDirty=false;
state.validationPrefillDraft={...prefill,sourceLabel,parentBuildRunId:prefill.parentBuildRunId||prefill.sourceRunId||state.runId||'',sourceRunId:prefill.sourceRunId||prefill.parentBuildRunId||state.runId||'',linkedTargetSpace:prefill.linkedTargetSpace||prefill.target||''};
state.linkedValidationParent=state.validationPrefillDraft.parentBuildRunId||'';
const policy=state.validationPrefillDraft.spaceTestPolicy||{};
const policyMode=String(policy.mode||'').toLowerCase();
const policyLabel=policy.label||spaceTestLaunchLabel(prefill).replace(/^Re-run /,'Replay ').replace(/^Run /,'');
const badge=$('spaceTestStatus');
if(badge){badge.textContent=policyLabel;badge.className='badge '+(spaceTestPolicyDisabledByStaleBlocker(policy,prefill)?'neutral':statusClass(policyMode||'info'))}
const tabDot=$('spaceTestTabDot');
if(tabDot)tabDot.className='tab-status-dot '+(spaceTestPolicyDisabledByStaleBlocker(policy,prefill)?'neutral':statusClass(policyMode||'info'));
const card=$('spaceTestPreview');
if(card)card.classList.remove('is-validating');
setText('spaceTestEndpoint',prefill.requiresEndpointDiscovery?'Discovery first':(prefill.api||'—'));
setText('spaceTestOutput','Not launched');
setText('validationStartedAt','Not launched');
setText('spaceTestLatency',prefill.automaticSmokePassed?smokeLatencyLabel(prefill.smokeLatency):'—');
setText('spaceTestVerdict',policy.message|| (prefill.automaticSmokePassed?`Automatic smoke test passed. You can replay the validated request.`:`Linked to ${sourceLabel}`));
setText('spaceTestProgressPercent','0%');
const fill=$('spaceTestProgressFill');
if(fill){fill.style.width='0%';fill.className='validation-progress-fill neutral'}
setValidationProgressVisible(false);
const timeline=$('spaceTestTimeline');
if(timeline){timeline.innerHTML='No linked validation launched yet.
';}
const title=$('spaceTestContextTitle');
const hint=$('spaceTestContextHint');
if(title)title.textContent='Linked validation context';
if(hint)hint.textContent=spaceTestPolicyDisabledByStaleBlocker(policy,prefill)?'blocked by parent verdict':(spaceTestPolicyAuthRecovery(policy)?'refresh sign-in, then retry':(prefill.requiresEndpointDiscovery?'endpoint discovery first':'ready to replay or validate'));
const endpoints=$('spaceTestEndpoints');
if(endpoints){
const modeLabel=escapeHtml(policyLabel|| (prefill.automaticSmokePassed?'Replay automatic smoke':'Linked Space Test'));
const endpointLine=spaceTestPolicyBlocksGeneration(policy,prefill)?'No generation endpoint exists.':(prefill.requiresEndpointDiscovery?'Endpoints will be discovered before validation.':`${escapeHtml(prefill.api||'—')}`);
const targetLine=prefill.target?`${escapeHtml(prefill.target)}`:'—';
const latencyLine=prefill.automaticSmokePassed&&prefill.smokeLatency?escapeHtml(smokeLatencyLabel(prefill.smokeLatency)):'—';
const payloadSource=escapeHtml(String(prefill.payloadSource||'linked_payload').replace(/_/g,' '));
const readiness=spaceTestPolicyDisabledByStaleBlocker(policy,prefill)?'Blocked':(spaceTestPolicyAuthRecovery(policy)?'Ready after sign-in refresh':(prefill.requiresEndpointDiscovery?'Discovery first':'Ready to launch'));
endpoints.innerHTML=`Linked Build Run${escapeHtml(state.validationPrefillDraft.parentBuildRunId||'—')}Target Space${targetLine}Mode${modeLabel}Endpoint${endpointLine}Payload source${payloadSource}Automatic smoke${latencyLine}Launch readiness${escapeHtml(readiness)}
`;
}
const note=$('spaceTestArgsNote');
if(note){note.hidden=false;note.textContent=spaceTestPolicyDisabledByStaleBlocker(policy,prefill)?(policy.message||'Space Test is blocked by the parent Build Run verdict.'):(spaceTestPolicyAuthRecovery(policy)?'Refresh sign-in, then retry linked validation.':`Payload source: ${String(prefill.payloadSource||'linked_payload').replace(/_/g,' ')}.`);}
const launchBtn=$('launchValidate');
if(launchBtn&&!launchBtn.classList.contains('is-busy'))launchBtn.textContent=spaceTestLaunchLabel(prefill);
setValidationLaunchEnabled();
const deleteBtn=$('deleteValidationRun');
if(deleteBtn){deleteBtn.disabled=true;deleteBtn.onclick=null;}
if(typeof renderRunsFromCache==='function')renderRunsFromCache();
}
function applyValidationPrefill(detail={},sourceLabel='selected Space',options={}){
const prefill=validationPrefillFromDetail(detail);
if(prefill.target&&prefill.target!=='—')setInputValue('validateSpace',prefill.target);
setInputValue('expectedOutput',prefill.expected);
setInputValue('validateApi',prefill.api);
setInputValue('testArgs',prettyJson(prefill.args));
setInputValue('testKwargs',prettyJson(prefill.kwargs));
state.validationArgsDirty=false;
const note=$('spaceTestArgsNote');if(note)note.hidden=true;
switchCenterTab('validate');
if(!options.preserveSelection)renderValidationPrefillDraft(prefill,sourceLabel);
showMessage(`Prepared validation form for ${prefill.target||sourceLabel}.`,'info');
}
function prepareValidationFromActiveRun(){
const selected=((state.selectedRunDetail?.run_id===state.runId||state.selectedRunDetail?.summary?.run_id===state.runId)?state.selectedRunDetail:{});
const activeDetail={...selected,...(state.activeRunProgress||{}),summary:{...(selected.summary||{}),...(state.activeRunProgress?.summary||{})}};
applyValidationPrefill(activeDetail,'active run',{preserveSelection:false});
}
function contextualizeSpaceTestFromBuildRun(detail={}){
if(!detail||typeof detail!=='object')return;
if(typeof isValidationRunDetail==='function'&&isValidationRunDetail(detail))return;
const prefill=validationPrefillFromDetail(detail);
if(!prefill.parentBuildRunId||!prefill.target||prefill.target==='—')return;
const nextParent=String(prefill.parentBuildRunId||'');
const currentParent=String(state.linkedValidationParent||state.validationPrefillDraft?.parentBuildRunId||'');
const explicitReset=state.spaceTestContextResetForRun===true||state.spaceTestContextResetForRun===nextParent;
const parentChanged=Boolean(currentParent&&nextParent&¤tParent!==nextParent);
if(explicitReset||parentChanged){
clearValidationRunStateForBuildContext(nextParent,'build_selection');
state.spaceTestContextResetForRun=null;
}else if(state.validationMode==='running'&¤tParent===nextParent){
return;
}
state.validationPrefillDraft={...prefill,sourceLabel:'selected Build Run',parentBuildRunId:prefill.parentBuildRunId,sourceRunId:prefill.parentBuildRunId,linkedTargetSpace:prefill.target};
state.linkedValidationParent=prefill.parentBuildRunId;
state.validationArgsDirty=false;
setInputValue('validateSpace',prefill.target);
setInputValue('expectedOutput',prefill.expected);
setInputValue('validateApi',prefill.api);
setInputValue('testArgs',prettyJson(prefill.args));
setInputValue('testKwargs',prettyJson(prefill.kwargs));
const note=$('spaceTestArgsNote');if(note){note.hidden=false;note.textContent=`Payload source: ${String(prefill.payloadSource||'linked_payload').replace(/_/g,' ')}.`;}
if(state.centerTab==='validate'){
renderValidationPrefillDraft(prefill,'selected Build Run');
}else{
const title=$('spaceTestContextTitle');
const hint=$('spaceTestContextHint');
if(title)title.textContent='Linked validation context';
if(hint)hint.textContent=spaceTestPolicyDisabledByStaleBlocker(prefill.spaceTestPolicy||{},prefill)?'blocked by parent verdict':(spaceTestPolicyAuthRecovery(prefill.spaceTestPolicy||{})?'refresh sign-in, then retry':(prefill.requiresEndpointDiscovery?'endpoint discovery first':'ready to replay or validate'));
const endpoints=$('spaceTestEndpoints');
if(endpoints){
const modeLabel=escapeHtml(prefill.spaceTestPolicy?.label|| (prefill.automaticSmokePassed?'Replay automatic smoke':'Linked Space Test'));
const endpointLine=spaceTestPolicyBlocksGeneration(prefill.spaceTestPolicy||{},prefill)?'No generation endpoint exists.':(prefill.requiresEndpointDiscovery?'Endpoints will be discovered before validation.':`${escapeHtml(prefill.api||'—')}`);
endpoints.innerHTML=`Linked Build Run${escapeHtml(prefill.parentBuildRunId)}Mode${modeLabel}Endpoint${endpointLine}
`;
}
}
setValidationLaunchEnabled();
}
function prepareValidationFromSelectedRun(){
applyValidationPrefill(state.selectedRunDetail||{},'selected run',{preserveSelection:false});
}
async function launchBuild(){const formError=validateBuildForm();if(formError){showMessage(formError,true);return}setBusy(true,'Launching build Job…');setButtonBusy('launchBuild',true,'Launching…');try{setText('hardwarePlan',hardwarePlanLabel());const payload={bucket_name:state.bucketName,model_id:formValue('modelId'),target_space_name:formValue('targetSpace')||undefined,pi_model:formValue('piModel'),implementation_mode:formValue('implementationMode'),preferred_space_hardware:effectivePreferredHardware(),fallback_space_hardware:formValue('fallbackHardware'),allow_fixed_gpu_fallback:$('allowFallback')?.checked??true,try_zero_gpu_first:$('tryZeroGpu')?.checked??true,expected_output_type:formValue('buildExpectedOutput')};const result=await apiPost('/api/build',payload);setActiveRun(result);showMessage(`Build launched: ${result.run_id}`,'success');loadRuns(true)}catch(e){showMessage(e.message,true)}finally{setBusy(false);setButtonBusy('launchBuild',false)}}
async function launchValidate(){
const resolved=resolveLinkedValidationPayload();
if(!resolved.launchable){showMessage(resolved.error||'Space Test is not ready to launch.',true);setValidationLaunchEnabled();return}
setBusy(true,'Launching validation Job…');
setButtonBusy('launchValidate',true,'Launching…');
try{
const payload={
bucket_name:state.bucketName,
parent_build_run_id:resolved.parentBuildRunId,
target_space_id:resolved.targetSpaceId,
api_name:resolved.apiName,
expected_output_type:resolved.expectedOutputType,
test_args_json:prettyJson(resolved.args),
test_kwargs_json:prettyJson(resolved.kwargs),
live_timeout_seconds:resolved.timeout,
validation_mode:resolved.validationMode,
payload_source:resolved.payloadSource,
ui_payload_arg_count:Array.isArray(resolved.args)?resolved.args.length:0,
ui_payload_kwargs_keys:resolved.kwargs&&typeof resolved.kwargs==='object'?Object.keys(resolved.kwargs):[]
};
const result=await apiPost('/api/validate',payload);
state.validationArgsDirty=false;
state.validationMode='running';
state.validationRunId=result.run_id;
renderValidationLaunchResult(result);
startValidationPolling(result.run_id);
showMessage(`Validation launched: ${result.run_id}`,'success');
loadRuns(true);
}catch(e){
showMessage(e.message,true);
}finally{
setBusy(false);
setButtonBusy('launchValidate',false);
setValidationLaunchEnabled();
}
}
async function refreshRunReportPreview(runId){
if(!runId)return;
try{
const detail=await apiGet(`/api/runs/${encodeURIComponent(runId)}?bucket_name=${encodeURIComponent(state.bucketName)}`);
if(detail.bucket_source)state.bucketSource=detail.bucket_source;
state.selectedRunDetail=detail;
if(typeof renderRunDetail==='function')renderRunDetail(detail);
if(typeof renderActiveRunActions==='function')renderActiveRunActions(detail.summary||{},detail);
if(typeof renderRunDocuments==='function')renderRunDocuments(detail);
if(typeof renderMetrics==='function')renderMetrics({...detail,summary:detail.summary||{}});
if(typeof renderBlockers==='function')renderBlockers(detail);markPendingActiveFields();
if(typeof renderRunDetail!=='function'){
const reportText=(detail.report||'No report available.').slice(0,8000);
const report=$('reportPreview');
if(report)report.textContent=reportText;
}
}catch(e){
console.warn('report refresh failed',e);
}
}
async function refreshProgress(){if(!state.runId||state.progressPollInFlight)return;state.progressPollInFlight=true;try{const now=Date.now();const includeLogs=!state.lastJobLogPoll||now-state.lastJobLogPoll>8000;if(includeLogs)state.lastJobLogPoll=now;const requestedRunId=state.runId;const p=await apiGet(`/api/runs/${encodeURIComponent(requestedRunId)}/progress?bucket_name=${encodeURIComponent(state.bucketName)}${includeLogs?'&include_job_logs=1':''}`);if(requestedRunId!==state.runId)return;if((p.run_id||p.summary?.run_id)&&state.runId&&(p.run_id||p.summary?.run_id)!==state.runId)return;state.activeRunProgress=p;state.pollErrors=0;if(p.bucket_source)state.bucketSource=p.bucket_source;try{if(typeof renderRunViewSnapshot==='function')renderRunViewSnapshot(p);else renderProgress(p);}catch(renderErr){console.warn('renderRunViewSnapshot failed; keeping events visible',renderErr);try{renderProgress(p)}catch(_){}}renderEvents(p.view?.activity||p.events_recent||p.events||[]);renderMetrics(p);if(typeof upsertRunExplorerFromProgress==='function')upsertRunExplorerFromProgress(p);if(typeof renderRunStats==='function')renderRunStats();if(typeof renderActiveRunActions==='function')renderActiveRunActions({...p.summary,bucket_source:p.bucket_source},p);if(typeof renderRunDocuments==='function')renderRunDocuments({...p,summary:{...p.summary,bucket_source:p.bucket_source}});if(typeof renderAgentRecovery==='function')renderAgentRecovery(p);if(typeof renderBlockers==='function')renderBlockers(p);if(p.view){setText('detailRunId',p.view.run_id||p.run_id);setText('selectedModelId',p.view.header?.model||p.summary?.model_id||'—')}else{setText('detailRunId',p.run_id||state.runId)}renderActiveRunMeta(p);if(p.state){setText('detailSpace',p.state.target_space||p.summary?.target_space||'—');const mode=runImplementationMode(p.summary||{},p);setText('detailImplementationMode',mode?implementationModeLabel(mode):'—');const modeEl=$('detailImplementationMode');if(modeEl&&mode)modeEl.title=implementationModeDescription(mode);setText('detailHardware',p.state.selected_hardware||p.summary?.selected_hardware||'—')}const canonicalUi=typeof canonicalRunUiState==='function'?canonicalRunUiState(p):{label:badgeLabel(p.view?.header?.status||p.status||p.state?.status||'running'),status:p.view?.header?.status||p.status||p.state?.status||'running'};setText('detailJobStatus',canonicalUi.label||badgeLabel(canonicalUi.status||'running'));setText('detailGateStatus',p.inference_gate?.status||p.summary?.gate_status||'—');setText('detailTraces',Array.isArray(p.events)?String(p.events.length)+' events':'—');setText('homeRunDetailStatus',canonicalUi.label||badgeLabel(canonicalUi.status||'running'));setQuickLinks({...p.links,...p.view?.links,...p.space_link_state,...p.view?.space_link_state,target_space_url:p.summary?.target_space_url||p.state?.target_space_url||p.links?.target_space_url||p.view?.links?.target_space_url,target_space:p.summary?.target_space||p.state?.target_space||p.links?.target_space||p.view?.links?.target_space,bucket_source:p.bucket_source,run_id:p.run_id},{...p,space_identity:p.space_identity||p.view?.space_link_state||p.space_link_state||{},space_link_state:p.space_link_state||p.view?.space_link_state||{},events:p.events||[]});saveActiveRun();const modelProgress=p.view?.timeline_model?.progress||{};const terminalSnapshot=modelProgress.terminal===true||p.view?.status_model?.is_terminal===true;const canonicalForTerminal=typeof canonicalRunUiState==='function'?canonicalRunUiState(p):null;const status=String(canonicalForTerminal?.status||p.view?.header?.status||p.status||p.state?.status||'').toLowerCase();if((terminalSnapshot||TERMINAL_STATUSES.has(status))&&state.poll){clearInterval(state.poll);state.poll=null;if(state.lastReportRefreshRunId!==state.runId){
state.lastReportRefreshRunId=state.runId;
const finalRunId=state.runId;
setTimeout(()=>{if(state.runId===finalRunId)refreshRunReportPreview(finalRunId)},120);
setTimeout(()=>{if(state.runId===finalRunId)refreshRunReportPreview(finalRunId)},900);
setTimeout(()=>{if(state.runId===finalRunId)refreshRunReportPreview(finalRunId)},2200);
setTimeout(()=>{if(state.runId===finalRunId&&state.documentCache)state.documentCache[finalRunId]=mergeStableRunDocuments(finalRunId,state.documentCache[finalRunId]||[])},2250);
setTimeout(()=>loadRuns(true),160);
setTimeout(()=>loadRuns(true),980);
setTimeout(()=>loadRuns(true),2300);
}{const visual=String(modelProgress.visual_status||'').toLowerCase();const type=visual==='success'?'success':visual==='error'?'error':(status.includes('success')||status.includes('succeed')?'success':status.includes('failed')||status.includes('blocker')?'error':'warning');setOperation(`Run finished with status: ${badgeLabel(modelProgress.verdict||status)}`,type)}}markPendingActiveFields();if(now-(state.lastRunsRefreshFromPoll||0)>15000){state.lastRunsRefreshFromPoll=now;loadRuns(false)}}catch(e){state.pollErrors+=1;console.warn(e);setOperation(`Progress polling failed ${state.pollErrors} time${state.pollErrors===1?'':'s'}. Retrying automatically…`,'warning')}finally{state.progressPollInFlight=false}} // compatibility anchor: setTimeout(()=>refreshRunReportPreview(state.runId),120)
function numberFromEvents(events=[],keys=[]){
const rows=Array.isArray(events)?events:[];
for(let i=rows.length-1;i>=0;i--){
const event=rows[i]||{};
const data=event.data||{};
for(const key of keys){
const direct=Number(event[key]);
if(Number.isFinite(direct)&&direct>0)return direct;
const nested=Number(data[key]);
if(Number.isFinite(nested)&&nested>0)return nested;
}
}
return null;
}
function readRunLatencyPayload(p={}){
const metrics=p.validation_metrics||p.view?.validation_metrics||p.summary?.validation_metrics||{};
const smoke=p.generation_smoke||p.tests?.generation_smoke||p.summary?.generation_smoke||p.state?.generation_smoke||{};
const gate=p.inference_gate||p.summary?.inference_gate||{};
const summary=p.summary||{};
const manual=p.manual_validation_status||summary.manual_validation_status||p.view?.manual_validation||{};
const validation=gate.validation||summary.validation||{};
const eventLatency=numberFromEvents(p.events||[],['latency_seconds','observed_latency_seconds']);
const eventDuration=numberFromEvents(p.events||[],['recommended_zerogpu_duration_seconds','recommended_zero_gpu_duration_seconds','recommended_duration_seconds','zero_gpu_duration_recommendation']);
const latency=firstPositiveNumber(metrics.latency_seconds,metrics.observed_latency_seconds,smoke.latency_seconds,smoke.observed_latency_seconds,summary.latency_seconds,summary.observed_latency_seconds,p.latency_seconds,p.observed_latency_seconds,manual.latency_seconds,manual.observed_latency_seconds,eventLatency);
const duration=firstPositiveNumber(metrics.recommended_zero_gpu_duration_seconds,metrics.recommended_zerogpu_duration_seconds,smoke.recommended_zerogpu_duration_seconds,smoke.recommended_zero_gpu_duration_seconds,smoke.recommended_duration_seconds,summary.recommended_zerogpu_duration_seconds,summary.recommended_zero_gpu_duration_seconds,summary.recommended_duration_seconds,manual.recommended_zero_gpu_duration_seconds,gate.recommended_zerogpu_duration_seconds,gate.recommended_zero_gpu_duration_seconds,gate.zero_gpu_duration_recommendation,eventDuration);
const source=metrics.source||smoke.recommendation_source||summary.recommendation_source||manual.recommendation_source||gate.recommendation_source||(manual.status==='success'?'linked Space Test':'')||(eventLatency?'generation_smoke event':'');
const hardware=metrics.hardware_used_for_validation||metrics.recommendation_hardware||manual.hardware_used_for_validation||manual.recommendation_hardware||summary.hardware_used_for_validation||summary.recommendation_hardware||p.hardware_used_for_validation||p.recommendation_hardware||p.state?.selected_hardware||summary.selected_hardware||'';
const failureType=smoke.failure_type||validation.failure_type||gate.failure_type||'';
const failureOwner=smoke.failure_owner||validation.failure_owner||gate.failure_owner||'';
const missingArgument=smoke.missing_argument||validation.missing_argument||gate.missing_argument||'';
const error=smoke.error||smoke.message||validation.failure_reason||gate.message||'';
return {smoke,gate,metrics,latency,duration,source,hardware,failureType,failureOwner,missingArgument,error};
}
function smokeFailureLatencyNote({smoke={},failureType='',failureOwner='',missingArgument='',error=''}={}){
const status=String(smoke.status||'').toLowerCase();
if(!status||status==='success')return '';
if(missingArgument){
return `Not measured because generation smoke failed before inference started. Missing required argument: ${missingArgument}.`;
}
if(failureType==='validator_request_error'||failureOwner==='factory_validator'){
return 'Not measured because ASF sent an invalid smoke-test request before live inference could start.';
}
if(failureType==='app_runtime_error'||failureOwner==='generated_space'){
return 'Not measured because the generated Space raised an error during the live generation smoke test.';
}
if(String(error||'').trim()){
return `Not measured because generation smoke failed: ${shortText(error,120)}`;
}
return 'Not measured because the generation smoke test did not produce a verified output.';
}
function renderActiveLatency(p={}){
const card=$('activeLatencyCard');
if(!card)return;
const runId=String(p.run_id||p.summary?.run_id||state.runId||'');
state.latencyCache=state.latencyCache||{};
const payload=readRunLatencyPayload(p);
const {latency,duration,source,hardware}=payload;
const hasLatency=Number.isFinite(latency)&&latency>0;
const hasDuration=Number.isFinite(duration)&&duration>0;
const cached=state.latencyCache[runId]||{};
const stableLatency=hasLatency?latency:cached.latency;
const stableDuration=hasDuration?duration:cached.duration;
const runStatus=String(p.status||p.state?.status||p.summary?.status||p.view?.header?.status||'').toLowerCase();
const finalBlocker=p.build_error_observation?' Final blocker: build error after repair.':'';
const failedWithoutSmoke=(runStatus==='failed'||runStatus==='error')&&!hasLatency;
const failureNote=smokeFailureLatencyNote(payload)||(failedWithoutSmoke?`Not measured because live validation did not reach a successful generation smoke test.${finalBlocker}`:'');
const hardwareSuffix=hardware&&String(hardware).toLowerCase()!=='unknown'?` on ${hardware}`:'';
const stableSource=hasLatency?`${source||'live smoke test'}${hardwareSuffix}`:(failureNote?'not measured: smoke failed':(cached.source||'measured when smoke test passes'));
if(hasLatency||hasDuration)state.latencyCache[runId]={latency:stableLatency,duration:stableDuration,source:stableSource};
const finalHasLatency=Number.isFinite(stableLatency)&&stableLatency>0;
const finalHasDuration=Number.isFinite(stableDuration)&&stableDuration>0;
setText('activeLatencyValue',finalHasLatency?formatLatencySeconds(stableLatency):'—');
setText('activeZeroGpuDuration',finalHasDuration?fmtSeconds(Math.round(stableDuration)):'—');
setText('activeLatencySource',stableSource);
const note=$('activeLatencyNote');
if(note){
note.textContent=finalHasDuration
? `This measured latency is normally used to tune the \`@spaces.GPU(duration=...)\` decorator for ZeroGPU when the generated Space uses ZeroGPU. Source hardware: ${hardware||'not recorded'}.`
: (failureNote||'When available, the live smoke-test latency is used to recommend the `@spaces.GPU(duration=...)` value for ZeroGPU apps.');
}
card.classList.toggle('has-latency',finalHasLatency);
card.classList.toggle('is-loading',!finalHasLatency);
}
function runHardwareMeta(p={}){
const summary=p.summary||{};
const stateObj=p.state||{};
const launch=p.launch||{};
const hardware=p.hardware_strategy||summary.hardware_strategy||{};
const target=summary.preferred_space_hardware||summary.target_gpu||stateObj.preferred_space_hardware||stateObj.target_gpu||launch.preferred_space_hardware||hardware.preferred||hardware.target||summary.selected_hardware||stateObj.selected_hardware||'—';
const fallback=summary.fallback_space_hardware||summary.fallback_gpu||stateObj.fallback_space_hardware||stateObj.fallback_gpu||launch.fallback_space_hardware||hardware.fallback||'—';
const output=summary.expected_output_type||stateObj.expected_output_type||launch.expected_output_type||p.generation_smoke?.expected_output_type||p.inference_gate?.expected_output_type||'—';
return {target,fallback,output};
}
function shortModelLabel(value){
const raw=String(value||'').trim();
if(!raw)return '—';
return raw.length>30?raw.split('/').slice(-1)[0]||raw:raw;
}
function piAssistantResolution(p={}){
const summary=p.summary||{};
const stateObj=p.state||{};
const launch=p.launch||{};
const resolution=p.pi_model_resolution||stateObj.pi_model_resolution||summary.pi_model_resolution||{};
const requested=resolution.requested_model||stateObj.pi_model||launch.pi_model||summary.pi_model||'';
const effective=resolution.effective_model||resolution.configured_model||requested||'';
const mismatch=Boolean(resolution.mismatch&&effective&&requested&&normalizeComparableModelName(effective)!==normalizeComparableModelName(requested));
return {requested,effective,mismatch,provider:resolution.provider||'huggingface',source:resolution.source||''};
}
function normalizeComparableModelName(value){
const raw=String(value||'').trim().toLowerCase();
const tail=raw.includes('/')?raw.split('/').pop():raw;
return tail.replace(/[^a-z0-9]+/g,'');
}
function renderPiAssistantMeta(p={}){
const el=$('detailPiAssistant');
if(!el)return;
const info=piAssistantResolution(p);
const requested=shortModelLabel(info.requested);
const effective=shortModelLabel(info.effective);
el.textContent=info.mismatch?`${requested} → ${effective}`:(effective||requested||'—');
el.title=info.mismatch?`Requested ${info.requested||'—'}; effective provider model ${info.effective||'—'}`:`Requested/effective assistant: ${info.effective||info.requested||'—'}`;
el.classList.toggle('warn-text',Boolean(info.mismatch));
}
function renderActiveRunMeta(p={}){
const meta=runHardwareMeta(p);
setText('detailTargetGpu',meta.target||'—');
setText('detailFallbackGpu',meta.fallback||'—');
setText('detailExpectedOutput',meta.output||'—');
renderPiAssistantMeta(p);
}
function markPendingActiveFields(){
['detailRunId','detailSpace','selectedModelId','detailTargetGpu','detailFallbackGpu','detailExpectedOutput','detailPiAssistant','currentStep','elapsed'].forEach(id=>{
const el=$(id);
if(!el)return;
const pending=!String(el.textContent||'').trim()||String(el.textContent||'').trim()==='—';
el.classList.toggle('is-pending',pending);
});
}
function renderMetrics(p){const root=$('metricsList');const {smoke,gate,latency,duration,source,hardware}=readRunLatencyPayload(p);const health=(gate.implementation_signals&&gate.implementation_signals.health_passed)||smoke.health_passed;const smokeOk=smoke.ok||smoke.status==='success';renderActiveLatency(p);if(!root)return;const provenance=[source||'',hardware?`hardware ${hardware}`:''].filter(Boolean).join(' · ');root.innerHTML=`/health${health?'passed':'pending'}/generate smoke test${smokeOk?'passed':(smoke.status||'pending')}Latency${Number.isFinite(latency)&&latency>0?formatLatencySeconds(latency):'—'}Recommended ZeroGPU duration${Number.isFinite(duration)&&duration>0?fmtSeconds(Math.round(duration)):'—'}${provenance?`${escapeHtml(provenance)}`:''}`}
function renderEvents(events){const root=$('eventsPanel');if(!root)return;try{const rows=Array.isArray(events)?events:[];root.textContent=rows.slice(-30).map(e=>`${e?.ts||e?.time||''} ${e?.step||e?.phase||''} ${e?.status||''} ${e?.message||e?.title||''}`).join('\n')||'No events yet. The run may still be scheduling.'}catch(e){console.warn('renderEvents failed',e);root.textContent='Events could not be rendered.'}}
async function cancelActiveRun(){
if(!state.runId){showMessage('Select a running run before cancelling.', 'warning');return}
if(!confirm(`Cancel Job for run ${state.runId}?`))return;
setButtonBusy('cancelRun',true,'Cancelling…');
try{
const result=await apiPost(`/api/runs/${encodeURIComponent(state.runId)}/cancel?bucket_name=${encodeURIComponent(state.bucketName)}`,{});
showMessage(`Cancelled Job ${result.job_id||''}`,'success');
if(state.poll){clearInterval(state.poll);state.poll=null}
await refreshProgress();
await loadRuns(true);
}catch(e){
showMessage(e.message,true);
}finally{
setButtonBusy('cancelRun',false);
}
}
function switchView(view){state.currentView=view;document.querySelectorAll('.nav-item').forEach(b=>b.classList.toggle('active',b.dataset.view===view));document.querySelectorAll('[data-section]').forEach(s=>s.hidden=s.dataset.section!==view);setOperation('');if(view==='progress')loadRuns(false);if(view==='validate')switchCenterTab('validate');if(view==='active')switchCenterTab('active');const targetMap={build:'newBuildCard',progress:'runsExplorerPanel',validate:'spaceTestSection',active:'activeRunPanel'};const target=$(targetMap[view]||'');if(target)target.scrollIntoView({behavior:'smooth',block:'start'})}
function bindNavigation(){
bindAllOnce('.nav-item','click','navItem',e=>switchView(e.currentTarget.dataset.view||'build'));
bindAllOnce('[data-view-target]','click','viewTarget',e=>switchView(e.currentTarget.dataset.viewTarget||'build'));
bindAllOnce('[data-center-tab]','click','centerTab',e=>switchCenterTab(e.currentTarget.dataset.centerTab||'active',{source:'user'}));
}
function bindRunFilters(){
bindAllOnce('.filter[data-status]','click','runStatusFilter',e=>{
state.runStatusFilter=e.currentTarget.dataset.status||'all';
state.runPage=0;
renderRunsFromCache();
});
for(const id of ['runSearch','runSearchFull'])bindOnce($(id),'input',`runSearch${id}`,e=>{
state.runSearch=e.target.value||'';
state.runPage=0;
for(const other of ['runSearch','runSearchFull'])if($(other)&&$(other)!==e.target)$(other).value=state.runSearch;
clearTimeout(state.runSearchTimer);
state.runSearchTimer=setTimeout(renderRunsFromCache,80);
});
}
function bindValidationDraftInputs(){
for(const id of ['testArgs','testKwargs'])bindOnce($(id),'input',`validationArgsDirty${id}`,()=>{state.validationArgsDirty=true;const note=$('spaceTestArgsNote');if(note)note.hidden=true;setValidationLaunchEnabled();});
for(const id of ['validateSpace','validateApi','expectedOutput','validateTimeout'])bindOnce($(id),'input',`validationForm${id}`,setValidationLaunchEnabled);
}
function bindActions(){
$('launchBuild')?.setAttribute('data-requires-bucket','true');
$('launchBuild')?.setAttribute('data-action-button','true');
$('launchValidate')?.setAttribute('data-action-button','true');
bindOnce($('logoutLink'),'click','logoutClientState',handleLogoutClick);
const actions={
launchBuild:launchBuild,
scanModel:scanModel,
launchValidate:launchValidate,
prepareNewBuild:prepareNewBuild,
manualGoValidate:prepareValidationFromActiveRun,
activePrefillSpaceTest:prepareValidationFromActiveRun,
checkBucket:()=>checkBucket(true),
createBucket:createBucket,
enableEvalArchive:enableEvalArchive,
verifyEvalArchive:verifyEvalArchive,
disableEvalArchive:disableEvalArchive,
flushEvalArchive:flushEvalArchive,
refreshRuns:()=>loadRuns(true),
refreshRunsHome:()=>loadRuns(true),
cancelRun:cancelActiveRun,
};
Object.entries(actions).forEach(([id,handler])=>bindOnce($(id),'click',`action${id}`,handler));
bindOnce($('modelId'),'input','modelPreScanReset',resetModelPreScan);
bindOnce($('modelRiskAck'),'change','modelRiskAck',setBuildLaunchEnabled);
['tryZeroGpu','preferredHardware','fallbackHardware','allowFallback'].forEach(id=>bindOnce($(id),'change',`hardware${id}`,()=>setText('hardwarePlan',hardwarePlanLabel())));
bindOnce($('implementationMode'),'change','implementationModeHelp',updateImplementationModeHelp);
}
bindNavigation();bindActions();bindRunFilters();bindValidationDraftInputs();setText('hardwarePlan',hardwarePlanLabel());updateImplementationModeHelp();setBuildModeNew();renderActiveRunEmptyState();resetValidationRunView();loadAppInfo();
// Pass 47 intentionally removed automatic switchView('progress') after launch and run selection.
// Compatibility note for v108 regression: implementationMode')?.addEventListener('change',updateImplementationModeHelp is now bound through bindOnce().
// Live quotas, spend and compute usage remain in the HF Billing dashboard; Open HF Billing for numeric values.
// Legacy endpoint picker wording kept for tests: API name used for validation / Set API name.
// Legacy status copy kept for regression tests only, not displayed:
// 'Eval archive off · set env vars'
// Anonymous project eval archive enabled:
// Env override remains supported for backend publishing: ASF_EVAL_ENABLED=true, ASF_EVAL_BUCKET_SOURCE=/, ASF_EVAL_BUCKET_PATH=evals, ASF_EVAL_BUCKET_MOUNT=/evals.
/* v190.20 legacy invariant strings:
setText('spaceTestOutput',prefill.automaticSmokePassed?'Replay linked smoke test':'New linked validation')
parent_build_run_id:(state.validationPrefillDraft||{}).parentBuildRunId
*/
// v190.3 compatibility anchor: setText('spaceTestOutput',prefill.automaticSmokePassed?'Replay linked smoke test':'New linked validation') · Linked to Build Run
// v190.17 compatibility anchor: Linked to selected Build Run
// v190.24 compatibility anchors retained for release regression tests:
// Open a completed Build Run and use Prefill Space Test
// draft.requiresEndpointDiscovery?'':normalizeApiName
// live_timeout_seconds:validationTimeoutValue()
// v71 compatibility anchor: setText('detailJobStatus',p.status||p.state?.status
// v71 compatibility anchor: setText('homeRunDetailStatus',badgeLabel(p.status
// v186/v191 compatibility anchors for regression tests after v192.2 compacting:
// goodPreview=(verdict!=='safe'
// recommended session
// Refresh sign-in before launching
// v192.12 terminal reconciliation compatibility anchors:
// setTimeout(()=>refreshRunReportPreview(state.runId),120)
// refreshRunReportPreview(state.runId)
// v194 legacy regression anchors for older compact pre-scan tests:
// prescan-spinner prescan-decision-line allGood.length No risk signals Output',outputType prescan-meta Library