0hmX/am3352

scripts/plan-ddr-d3-inner2-exit.ts

/** One bounded existing-winding experiment against the actual composite copper. */
import {readFileSync,writeFileSync,mkdirSync} from 'node:fs'
import {createHash} from 'node:crypto'
import {resolve} from 'node:path'
import {verifyDdrCapture} from './ddr-capture-provenance'
import {loadAcceptedDq7Context,auditCompositeHostTopology} from './ddr-composite-routing-context'
import {supportCopperObstacles} from './ddr-support-routing-context'
import {applyFacingExitReplacements} from './ddr-facing-context'
import {explicitFacingViaContinuation} from './ddr-facing-via-continuation'
import {objectHash,validateDeclaredDdrReplacements} from './improve-ddr-a9-power-launches'
import {verifyDdrSystemCopper,auditDdrTraceJunctions} from './check-ddr-system-copper'
import {auditRouteAngles} from './check-route-angles'
import {auditDdrLocalEscapeContacts} from './audit-ddr-local-escape-contacts'
const [capture,parentDir,orderedDir,routeDir,dq7Dir,finalDir,out,yArg='-8.6']=process.argv.slice(2)
const signal='DDR_D3'
if(!capture||!parentDir||!orderedDir||!routeDir||!dq7Dir||!finalDir||!out||!Number.isFinite(Number(yArg)))throw Error('Usage: capture composite output signal exit-y')
const base=await loadAcceptedDq7Context(capture,parentDir,orderedDir,routeDir,dq7Dir)
const bound=new Map<string,string>(),fh=(p:string)=>createHash('sha256').update(readFileSync(p)).digest('hex'),read=(p:string)=>{p=resolve(p);bound.set(p,fh(p));return JSON.parse(readFileSync(p,'utf8'))}
const actual=read(resolve(finalDir,'candidate.circuit.json')),actualHost=read(resolve(finalDir,'host-bundle.json')),actualInput=read(resolve(finalDir,'routing-input.json')),actualReport=read(resolve(finalDir,'report.json')),manifest=read(resolve(finalDir,'original-copper-replacements.json')),intermediate=read(resolve(manifest.parentDirectory,'candidate.circuit.json'))
if(actualReport.captureHash!==base.captureHash||manifest.captureHash!==base.captureHash||actualReport.candidateCircuitSha256!==objectHash(actual)||actualReport.hostTracesSha256!==objectHash(actualHost.traces))throw Error('Final eleven-host board provenance differs')
const priorWitness={...manifest.priorAssemblyManifest,replacements:manifest.priorAssemblyManifest.replacements.map((r:any)=>({...r,id:r.id??`${r.before.type}:${r.before[`${r.before.type}_id`]}`,beforeSha256:r.beforeSha256??objectHash(r.before),afterSha256:r.afterSha256??objectHash(r.after)}))}
const priorPreservation=validateDeclaredDdrReplacements(base.candidate,intermediate,priorWitness),finalPreservation=validateDeclaredDdrReplacements(intermediate,actual,manifest)
const baselineTopology=auditCompositeHostTopology(actual,actualHost.traces,actualInput.connections)
if(actualHost.traces.length!==11||!baselineTopology.valid||!auditRouteAngles(actual.filter((e:any)=>e.type==='pcb_trace')).valid||!auditDdrTraceJunctions(actual,actualInput.connections).valid)throw Error('Actual final baseline fails')
const hostIds=new Set(actualHost.traces.map((t:any)=>t.pcb_trace_id)),assertUnchanged=()=>{base.assertUnchanged();for(const[p,h]of bound)if(fh(p)!==h)throw Error('Final board changed during experiment')}
const context={...base,candidate:actual,host:actualHost,input:actualInput,fixed:actual.filter((e:any)=>!hostIds.has(e.pcb_trace_id)),assertUnchanged,evidence:{...base.evidence,priorPreservation,finalPreservation,actualInputHashes:Object.fromEntries(bound),baselineTopology}}, {candidate,host,input,map,captureHash}=context
const entry=map.find((m:any)=>m.cpuSignal===signal),connection=input.connections.find((c:any)=>c.source_trace_id===entry?.sourceTraceId)
if(connection?.pointsToConnect[1]?.layer!=='inner2')throw Error('D3 CPU exit must share inner2')
if(!connection||connection.ramByte!==0||!['DM','DQ1','DQ3','DQ5','DQ7'].includes(connection.ramTerminal))throw Error('Expected byte0 odd/data mask')
const invalidated=host.traces.filter((t:any)=>t.connection_name===connection.name)
if(invalidated.length!==0||host.traces.length!==11)throw Error('Expected unhosted D3 and eleven retained hosts')
const invalidatedIds=new Set(invalidated.map((t:any)=>t.pcb_trace_id)),retained=host.traces.filter((t:any)=>!invalidatedIds.has(t.pcb_trace_id))
const ram=connection.pointsToConnect[0],exit=candidate.find((e:any)=>e.pcb_breakout_point_id===ram.pointId),old=candidate.find((e:any)=>e.type==='pcb_trace'&&e.source_trace_id===exit.source_trace_id),viaIndex=old.route.findIndex((p:any)=>p.route_type==='via')
if(viaIndex<0||old.route.filter((p:any)=>p.route_type==='via').length!==1)throw Error('Expected one retained via')
const via={...old.route[viaIndex],to_layer:'inner2'},source={...old.route[0],pointId:ram.pointId},target={x:-6.040077,y:Number(yArg),layer:'inner2'}
const removedObstacleIds=[`post-via-tail:${old.pcb_trace_id}`]
const padPort=old.route[0].start_pcb_port_id
const obstacles=context.fixed.filter((e:any)=>['pcb_trace','pcb_via','pcb_smtpad'].includes(e.type)).flatMap((element:any)=>{
 const isTrace=element.type==='pcb_trace'&&element.pcb_trace_id===old.pcb_trace_id
 const e=isTrace?{...element,route:element.route.slice(0,viaIndex+1)}:element
 const isPad=e.type==='pcb_smtpad'&&e.pcb_port_id===padPort
 const isVia=e.type==='pcb_via'&&e.pcb_trace_id===old.pcb_trace_id&&Math.hypot(e.x-via.x,e.y-via.y)<1e-7
 return supportCopperObstacles([e]).map(o=>({...o,...((e.type==='pcb_smtpad'&&e.shape==='circle')||e.type==='pcb_via'||o.obstacleId.startsWith('fixed_via_')||o.obstacleId.endsWith('_cap')?{shape:'circle'}:{}),connectedTo:isTrace||isPad||isVia?[connection.name]:[`reserved:${e[`${e.type}_id`]}`]}))
})
const srj={...input,obstacles,traces:retained},sourceObstacle=obstacles.find((o:any)=>o.connectedTo.includes(connection.name)&&o.layers.includes('top')&&Math.abs(o.center.x-source.x)<=o.width/2+1e-7&&Math.abs(o.center.y-source.y)<=o.height/2+1e-7)
if(!sourceObstacle)throw Error('Missing actual source obstacle')
const localConnection={...connection,pointsToConnect:[source,target]},prepared:any={connection:localConnection,connectionIndex:0,sourcePoint:source,sourcePointIndex:0,sourceLayer:'top',sourceObstacle,targetPoint:target}
const bounds={minX:-18,maxX:target.x,minY:-13,maxY:-3}
if(target.y<bounds.minY||target.y>bounds.maxY)throw Error('Outside unchanged local bounds')
const bus:any={busId:signal,direction:'right',exitEdge:'right',termination:{type:'boundary'},connections:[prepared],componentId:'RAM-facing-escape',componentObstacles:[sourceObstacle],componentBounds:bounds,sharedBoundary:bounds,xCoordinates:[via.x],yCoordinates:[via.y],pitchX:.8,pitchY:.8}
const {routeViaMinimalWindingAlternativesSteps}=await import(resolve('node_modules/@tscircuit/fanout-solver/lib/route-via-minimal-winding.ts'))
const params:any={srj,bus,targetLayer:'inner2',terminals:[{connection:prepared,viaPoint:via,exitPoint:target}],acceptedPlans:[],layerNames:['top',...Array.from({length:8},(_,i)=>`inner${i+1}`),'bottom'],traceWidth:.12,viaDiameter:via.via_diameter,viaHoleDiameter:via.via_hole_diameter,clearance:.1016,allowBlindAndBuriedVias:false,allowSourceLayerRouting:true,gridStep:.1,maximumRouteOrderAttempts:1,maximumSearchStates:300000,heuristicWeight:1.2,sourceEscapePaths:new Map([[0,old.route.slice(0,viaIndex).map((p:any)=>({x:p.x,y:p.y}))]])}
mkdirSync(out,{recursive:true});const write=(p:string,x:any)=>writeFileSync(resolve(out,p),JSON.stringify(x,null,2)+'\n')
write('input-evidence.json',{...context.evidence,signal,connection,target,source,via,bounds,removedObstacleIds,invalidatedHostTraces:invalidated,retainedHostCount:retained.length,obstacleCount:obstacles.length,retainedDQ7ObstacleCount:obstacles.filter((o:any)=>o.obstacleId.includes('saved_fanout_pcb_group_3_39')).length})
const started=Date.now(),steps=routeViaMinimalWindingAlternativesSteps(params,1),progress:any[]=[];let result:any[]=[],finished=false
while(Date.now()-started<55000){const s=steps.next();if(s.done){result=s.value;finished=true;break}progress.push({...s.value,visualization:undefined});write('progress.json',progress)}if(!finished)steps.return([])
const raw=result[0]?.[0]?.trace
let envelope:any
const {snapshot}=verifyDdrCapture(capture),placement=snapshot.placements[0],modulePoints=snapshot.pathsByByte[0].flatMap((p:any)=>p.route.map((q:any)=>({x:placement.pcbX-q.x,y:placement.pcbY-q.y}))),moduleBounds={minX:Math.min(...modulePoints.map((p:any)=>p.x)),maxX:Math.max(...modulePoints.map((p:any)=>p.x)),minY:Math.min(...modulePoints.map((p:any)=>p.y)),maxY:Math.max(...modulePoints.map((p:any)=>p.y))}
let accepted=false,physical:any,allAngles:any,allJunctions:any,lengthBudget:any,changes:any,updated:any,interpretation:any,topology:any,localContacts:any
if(raw){
 write('raw.json',raw);interpretation=explicitFacingViaContinuation(old,raw,'inner2')
 const after=interpretation.after,last=after.route.at(-1),previous=[...after.route].reverse().find((p:any)=>p.route_type==='wire'&&p.layer===target.layer&&Math.hypot(p.x-target.x,p.y-target.y)>1e-7)
 if(last.layer!==target.layer||Math.hypot(last.x-target.x,last.y-target.y)>1e-7||!previous||last.x<=previous.x)throw Error('Wrong exit/tangent')
 envelope={bounds:moduleBounds,paddingChangeMm:0,valid:after.route.every((p:any)=>p.x>=moduleBounds.minX-1e-7&&p.x<=moduleBounds.maxX+1e-7&&p.y>=moduleBounds.minY-1e-7&&p.y<=moduleBounds.maxY+1e-7)}
 changes={traces:[{before:old,after}],breakoutPoints:[{before:exit,after:{...exit,...target}}]}
 updated=applyFacingExitReplacements(candidate.filter((e:any)=>!invalidatedIds.has(e.pcb_trace_id)),changes)
 const connections=input.connections.map((c:any)=>({...c,pointsToConnect:c.pointsToConnect.map((p:any)=>p.pointId===ram.pointId?{...p,...target}:p)})),fresh=[...retained,after],freshIds=new Set(fresh.map((t:any)=>t.pcb_trace_id))
 physical=verifyDdrSystemCopper(updated.filter((e:any)=>!freshIds.has(e.pcb_trace_id)),fresh,connections,{})
 topology=auditCompositeHostTopology(updated,retained,connections)
 localContacts=auditDdrLocalEscapeContacts(updated,after,connections)
 allAngles=auditRouteAngles(updated.filter((e:any)=>e.type==='pcb_trace'));allJunctions=auditDdrTraceJunctions(updated,connections)
 const planar=(r:any[])=>r.reduce((s:number,p:any,i:number)=>{const q=r[i-1];return s+(p.route_type==='wire'&&q?.route_type==='wire'&&p.layer===q.layer?Math.hypot(p.x-q.x,p.y-q.y):0)},0)
 const cpu=connection.pointsToConnect[1],cpuExit=candidate.find((e:any)=>e.pcb_breakout_point_id===cpu.pointId),cpuTrace=candidate.find((e:any)=>e.type==='pcb_trace'&&e.source_trace_id===cpuExit.source_trace_id),dx=Math.abs(cpu.x-target.x),dy=Math.abs(cpu.y-target.y)
 lengthBudget={ramEscapeMm:planar(after.route),cpuEscapeMm:planar(cpuTrace.route),hostFloorMm:Math.max(dx,dy)+(Math.SQRT2-1)*Math.min(dx,dy),nominalMm:context.nominal.bytes.find((b:any)=>b.byte===0).dqlmPairedDataMaximumMm,optimisticTotalMm:0}
 lengthBudget.optimisticTotalMm=lengthBudget.ramEscapeMm+lengthBudget.cpuEscapeMm+lengthBudget.hostFloorMm
 accepted=envelope.valid&&topology.valid&&localContacts.valid&&!physical.errors.length&&!physical.violations.length&&physical.angles.valid&&!physical.joinedBends.length&&allAngles.valid&&allJunctions.valid&&retained.every((t:any)=>physical.connectivity.some((c:any)=>c.name===t.connection_name&&c.connected)&&objectHash(updated.find((e:any)=>e.pcb_trace_id===t.pcb_trace_id))===objectHash(t))&&lengthBudget.optimisticTotalMm<=lengthBudget.nominalMm+1e-7
}
context.assertUnchanged();write('report.json',{captureHash,accepted,finished,alternatives:result.length,elapsedSeconds:(Date.now()-started)/1000,physical,allAngles,allJunctions,topology,localContacts,envelope,lengthBudget,parentCircuitSha256:objectHash(candidate),invalidatedHostTraces:invalidated,retainedHostCount:retained.length,interpretation,scope:'Actual accepted ordered-DM composite obstacles retained. Only D3 post-via escape replaced on inner2; eleven endpoint-only hosts preserved. No complete DDR or D3 host qualification.'})
if(changes)write('replacements.json',{...changes,invalidatedHostTraces:invalidated})
if(accepted){write('candidate.circuit.json',updated);write('host-bundle.json',{...host,traces:retained});write('routing-input.json',{...input,obstacles:undefined,connections:input.connections.map((c:any)=>({...c,pointsToConnect:c.pointsToConnect.map((p:any)=>p.pointId===ram.pointId?{...p,...target}:p)}))})}
console.log(JSON.stringify({accepted,finished,alternatives:result.length,lengthBudget,violations:physical?.violations.length}));if(!accepted)process.exitCode=1