@hatiolab/figure-model 0.6.6 → 0.7.0

package/docs/prototypes/full-conveyor.test.mjs

@@ -1,61 +0,0 @@
-import {test} from 'node:test'
-import assert from 'node:assert/strict'
-import {seed,defaults,fullModel,evaluateFull,geometryOf,sourceGeometry} from './full-conveyor.mjs'
-import {compile} from './typed-plan.mjs'
-import {meshAudit} from './dryroom-mesh.mjs'
-const near=(a,b)=>assert.ok(Math.abs(a-b)<.001,`${a} != ${b}`)
-const vertices=g=>{const a=g.attributes.position;return Array.from({length:a.count},(_,i)=>[a.getX(i),a.getY(i),a.getZ(i)])}
-const deviation=(a,b)=>Math.max(...a.map(p=>Math.min(...b.map(q=>Math.hypot(...p.map((v,i)=>v-q[i]))))))
-test('all 17 source part types represented; 16 nonrepeated shapes reproduce seed',()=>{
- const result=evaluateFull();assert.equal(new Set(result.map(g=>g.sourceName)).size,17)
- for(const p of seed.parts.filter(p=>!p.repeat)){
-  const item=result.find(g=>g.id===p.name);assert.deepEqual(item.material,p.material)
-  const a=sourceGeometry(p),b=geometryOf(item),av=vertices(a),bv=vertices(b)
-  near(Math.max(deviation(av,bv),deviation(bv,av)),0);a.dispose();b.dispose()
- }
- const rollers=result.filter(g=>g.sourceName==='roller');assert.equal(rollers.length,14)
- // Deliberate layout correction: old first roller overlaps the end roller by 108mm.
- near(75+48-Math.abs(-1125-(-1140)),108)
- near(rollers[0].pose.t[0],-975);near(rollers.at(-1).pose.t[0],975)
- const rollerSource=sourceGeometry(seed.parts.find(p=>p.name==='roller'))
- for(const r of rollers){const g=geometryOf(r);g.translate(-r.pose.t[0],0,0);near(Math.max(deviation(vertices(g),vertices(rollerSource)),deviation(vertices(rollerSource),vertices(g))),0);g.dispose()}
- rollerSource.dispose()
-})
-test('whole conveyor: dimensions × motion; feet/legs/frames stay joined and roller clearances hold',()=>{
- let cases=0,meshes=0
- for(const length of [900,2400,6000])for(const width of [400,600,1200])for(const rollerHeight of [400,500,1200])for(const angle of [-180,-37,0,73,180]){
-  const result=evaluateFull({length,width,rollerHeight,angle}),by=Object.fromEntries(result.filter(g=>!g.key).map(g=>[g.id,g]))
-  for(const end of ['head','tail'])for(const side of ['left','right']){
-   const l=by[`leg-${end}-${side}`],f=by[`foot-${end}`],frame=by[`frame-${side}`]
-   near(l.pose.t[1]-l.shape.dimensions.height/2,f.pose.t[1]+f.shape.dimensions.height/2)
-   near(l.pose.t[1]+l.shape.dimensions.height/2,frame.pose.t[1]-frame.shape.dimensions.height/2)
-   near(l.pose.t[0],f.pose.t[0]);near(l.pose.t[2]+(side==='left'?-32:32),frame.pose.t[2]+(side==='left'?6:-6))
-  }
-  const rollers=result.filter(g=>g.key);const count=1+Math.floor((length-290-96)/150);assert.equal(rollers.length,count)
-  for(const [i,r] of rollers.entries()){
-   near(r.pose.t[1],rollerHeight);near(r.pose.t[2],0);near(r.shape.dimensions.length,width-80)
-   // Rotation must preserve the cylinder axle direction, including non-quarter angles.
-   near(r.pose.r[0][1],0);near(r.pose.r[1][1],0);near(r.pose.r[2][1],1)
-   if(i)near(r.pose.t[0]-rollers[i-1].pose.t[0],150)
-  }
-  assert.ok(rollers[0].pose.t[0]-48-(by['roller-head'].pose.t[0]+75)>=10-1e-6)
-  assert.ok(by['roller-tail'].pose.t[0]-75-(rollers.at(-1).pose.t[0]+48)>=10-1e-6)
-  for(const item of result){const g=geometryOf(item),a=meshAudit(g);assert.equal(a.badEdges,0);assert.equal(a.euler,2);assert.ok(a.volume>0&&a.minArea>0);g.dispose();meshes++}
-  cases++
- }
- assert.equal(cases,135);console.log({wholeConveyorCases:cases,meshChecks:meshes})
-})
-test('resize preserves repeat identities; motion cannot affect topology; rejected input does not corrupt next evaluation',()=>{
- const p=compile(fullModel()),base=p.evaluate(defaults),large=p.evaluate({...defaults,length:3000})
- const old=base.geometry.filter(g=>g.key),next=large.geometry.filter(g=>g.key);old.forEach((g,i)=>assert.equal(g.id,next[i].id))
- for(const angle of [-360,37,360])assert.deepEqual(p.evaluate({...defaults,angle}).geometry.map(g=>g.id),base.geometry.map(g=>g.id))
- assert.throws(()=>p.evaluate({...defaults,width:0}),e=>e.code==='INPUT_RANGE');assert.deepEqual(p.evaluate(defaults),base)
-})
-test('full model crosses a repeat count boundary without violating reserved end space',()=>{
- for(const [length,count] of [[985.999,4],[986,5],[986.001,5]]){
-  const r=evaluateFull({...defaults,length}),rollers=r.filter(g=>g.key)
-  assert.equal(rollers.length,count)
-  assert.ok(rollers[0].pose.t[0]-48-(-length/2+60+75)>=10-1e-6)
-  assert.ok(length/2-60-75-rollers.at(-1).pose.t[0]-48>=10-1e-6)
- }
-})

package/docs/prototypes/full-dryroom.mjs

@@ -1,67 +0,0 @@
-import * as THREE from '../../../things-scene/node_modules/three/build/three.module.js'
-import {seed} from './dryroom-mesh.mjs'
-import {compile} from './typed-plan.mjs'
-export {seed,THREE}
-const c=(id,value,unit='mm')=>({id,value,unit})
-const n=(id,op,args,outputs,params)=>({id,op,args,outputs,...(params?{params}:{})})
-export function fullModel(){
-  const m={version:'r3-spatial-1',inputs:[['width',3000,6000],['height',2400,4500],['depth',4000,9000],['bottom',-60,500],['lampLift',-100,100]].map(([id,min,max])=>({id,unit:'mm',min,max})),constants:[c('zero',0),c('a0',0,'rad'),c('turn',90,'deg')],nodes:[]}
-  const constant=(id,v,u='mm')=>{m.constants.push(c(id,v,u));return id}
-  const calc=(id,op,a,b)=>{m.nodes.push(n(id,op,[a,b],{value:id}));return id}
-  const half=constant('half',.5,'ratio'),minus=constant('minus',-1,'ratio')
-  calc('halfHeight','mul@1','height',half);calc('halfDepth','mul@1','depth',half)
-  calc('top','add@1','height',constant('topGap',-100));calc('openingTop','add@1','height',constant('openingGap',-800))
-  calc('right','mul@1','width',constant('outerRatio',.325,'ratio'));calc('left','mul@1','right',minus)
-  calc('ir','mul@1','width',constant('innerRatio',.175,'ratio'));calc('il','mul@1','ir',minus)
-  calc('portalZ','add@1','halfDepth',constant('portalOverhang',50));calc('backZ','mul@1','portalZ',minus)
-  const rigid=(id,from,xyz,rotation=['a0','a0','a0'],to='world')=>m.nodes.push(n(id,'rigid@1',[...xyz,...rotation],{pose:id},{from,to}))
-  const place=(name,shape,pose)=>m.nodes.push(n(name,'place@1',[shape,pose],{placed:`${name}Placed`}))
-  m.nodes.push(n('shellShape','box-shape@1',['width','height','depth'],{shape:'shellShape'},{frame:'shell'}));rigid('shellPose','shell',['zero','halfHeight','zero']);place('shell','shellShape','shellPose')
-  for(const side of ['in','out']){
-    const portal=`portal-${side}`,lamp=`lamp-${side}`,pf=`${portal}Front`
-    m.nodes.push(n(`${portal}Shape`,'portal-profile@1',['left','right','bottom','top','il','ir','openingTop',constant(`${portal}Depth`,300)],{shape:`${portal}Shape`},{frame:portal}))
-    rigid(`${portal}Pose`,portal,['zero','zero',side==='in'?'portalZ':'backZ']);place(portal,`${portal}Shape`,`${portal}Pose`)
-    m.nodes.push(n(pf,'feature@1',[`${portal}Shape`],{pose:pf},{frame:pf,name:'frontTop'}),n(`${pf}World`,'compose@1',[`${portal}Pose`,pf],{pose:`${pf}World`}))
-    calc(`${lamp}OffsetY`,'add@1','lampLift',constant(`${lamp}Drop`,-300))
-    m.nodes.push(n(`${lamp}Shape`,'cylinder-shape@1',[constant(`${lamp}Radius`,150),constant(`${lamp}Length`,160)],{shape:`${lamp}Shape`},{frame:lamp}))
-    rigid(`${lamp}Offset`,lamp,['zero',`${lamp}OffsetY`,constant(`${lamp}OffsetZ`,side==='in'?-30:-270)],['turn','a0','a0'],pf)
-    m.nodes.push(n(`${lamp}Pose`,'compose@1',[`${pf}World`,`${lamp}Offset`],{pose:`${lamp}Pose`}));place(lamp,`${lamp}Shape`,`${lamp}Pose`)
-  }
-  const d=seed.parts.find(p=>p.name==='readout')
-  m.nodes.push(n('readoutShape','rounded-box@1',['x','y','z'].map(a=>constant(`readout${a}`,d.transform.size[a])).concat(constant('readoutRound',d.shape.round)),{shape:'readoutShape'},{frame:'readout'}))
-  calc('readoutX','mul@1','width',constant('readoutRatio',.25,'ratio'))
-  rigid('readoutOffset','readout',['readoutX',constant('readoutDrop',-1150),constant('readoutOffsetZ',20)],undefined,'portal-inFront')
-  m.nodes.push(n('readoutPose','compose@1',['portal-inFrontWorld','readoutOffset'],{pose:'readoutPose'}));place('readout','readoutShape','readoutPose')
-  return m
-}
-export const defaults={width:4000,height:3000,depth:6000,bottom:-60,lampLift:0}
-export function evaluateFull(args=defaults){const r=compile(fullModel()).evaluate(args);return r.geometry.map(g=>({...g,material:structuredClone(seed.parts.find(p=>p.name===g.id).material)}))}
-// Match current product XZ rounded profile construction, including quadratic curves sampled at 8.
-export function rounded(width,depth,r){
-  const x=-width/2,y=-depth/2,p=new THREE.Path()
-  p.moveTo(x+r,y);p.lineTo(x+width-r,y);p.quadraticCurveTo(x+width,y,x+width,y+r)
-  p.lineTo(x+width,y+depth-r);p.quadraticCurveTo(x+width,y+depth,x+width-r,y+depth)
-  p.lineTo(x+r,y+depth);p.quadraticCurveTo(x,y+depth,x,y+depth-r)
-  p.lineTo(x,y+r);p.quadraticCurveTo(x,y,x+r,y)
-  return new THREE.Shape(p.getPoints(8))
-}
-export function geometryOf(item){
-  const d=item.shape.dimensions;let g
-  if(item.shape.provider==='box')g=new THREE.BoxGeometry(d.width,d.height,d.depth)
-  else if(item.shape.provider==='roundedBox'){g=new THREE.ExtrudeGeometry(rounded(d.width,d.depth,d.round),{depth:d.height,steps:1,bevelEnabled:false});g.rotateX(Math.PI/2);g.translate(0,d.height/2,0)}
-  else if(item.shape.provider==='cylinder')g=new THREE.CylinderGeometry(d.radius,d.radius,d.length,16)
-  else {const p=item.shape.profile,s=new THREE.Shape(p.map(v=>new THREE.Vector2(v.x,v.y)));g=new THREE.ExtrudeGeometry(s,{depth:d.depth,steps:1,bevelEnabled:false});g.translate(0,0,-d.depth/2)}
-  const r=item.pose.r,t=item.pose.t;g.applyMatrix4(new THREE.Matrix4().set(...r[0],t[0],...r[1],t[1],...r[2],t[2],0,0,0,1))
-  return g.index?g.toNonIndexed():g
-}
-export function sourceGeometry(p){
-  const d=p.transform.size;let g
-  if(p.primitive==='wall')g=new THREE.BoxGeometry(d.x,d.y,d.z)
-  else if(p.primitive==='cylinder')g=new THREE.CylinderGeometry(d.x/2,d.z/2,d.y,p.segments)
-  else {
-    const s=p.primitive==='polygon'?new THREE.Shape(p.shape.path.map(v=>new THREE.Vector2(v.x,v.y))):rounded(d.x,d.z,p.shape.round)
-    g=new THREE.ExtrudeGeometry(s,{depth:d.y,steps:1,bevelEnabled:false});g.rotateX(Math.PI/2);g.translate(0,d.y/2,0)
-  }
-  const r=p.transform.rotation??{};g.rotateZ((r.z??0)*Math.PI/180);g.rotateY((r.y??0)*Math.PI/180);g.rotateX((r.x??0)*Math.PI/180)
-  const t=p.transform.position;g.translate(t.x,t.y,t.z);return g.index?g.toNonIndexed():g
-}

package/docs/prototypes/full-dryroom.test.mjs

@@ -1,54 +0,0 @@
-import assert from 'node:assert/strict'
-import {test} from 'node:test'
-import {performance} from 'node:perf_hooks'
-import {fullModel,evaluateFull,geometryOf,sourceGeometry,seed,defaults} from './full-dryroom.mjs'
-import {compile} from './typed-plan.mjs'
-import {meshAudit} from './dryroom-mesh.mjs'
-const near=(a,b,tol=1e-3)=>assert.ok(Math.abs(a-b)<tol,`${a} != ${b}`)
-const vertices=g=>{const a=g.attributes.position;return Array.from({length:a.count},(_,i)=>[a.getX(i),a.getY(i),a.getZ(i)])}
-function deviation(a,b){return Math.max(...a.map(p=>Math.min(...b.map(q=>Math.hypot(...p.map((x,i)=>x-q[i]))))))}
-test('whole seed: all six actual shapes, material descriptors and surface vertices reproduced',()=>{
-  const result=evaluateFull();assert.equal(result.length,seed.parts.length)
-  for(const p of seed.parts){
-    const item=result.find(g=>g.id===p.name);assert.deepEqual(item.material,p.material)
-    const a=sourceGeometry(p),b=geometryOf(item),av=vertices(a),bv=vertices(b)
-    const delta=Math.max(deviation(av,bv),deviation(bv,av))
-    assert.ok(delta<.001,`${p.name}: max vertex-set deviation ${delta}mm`)
-    const x=meshAudit(a),y=meshAudit(b)
-    near(x.volume,y.volume,2);assert.equal(y.badEdges,0);assert.equal(y.euler,2)
-    console.log(JSON.stringify({part:p.name,triangles:y.faces,maxVertexDeviationMm:delta}))
-    a.dispose();b.dispose()
-  }
-})
-test('whole model 27 dimensions × two bottom edits × three lamp edits',()=>{
-  const plan=compile(fullModel());let cases=0
-  for(const width of [3000,4000,6000])for(const height of [2400,3000,4500])for(const depth of [4000,6000,9000])for(const bottom of [-60,0])for(const lampLift of [-100,0,100]){
-    const r=plan.evaluate({width,height,depth,bottom,lampLift}),by=Object.fromEntries(r.geometry.map(g=>[g.id,g]))
-    assert.equal(r.geometry.length,6)
-    near(by.shell.shape.dimensions.width,width)
-    for(const side of ['in','out']){
-      const p=by[`portal-${side}`],l=by[`lamp-${side}`],sign=side==='in'?1:-1
-      near(p.shape.dimensions.bottom,bottom);near(p.shape.dimensions.top,height-100)
-      near(p.shape.dimensions.openingTop,height-800);near(p.pose.t[2],sign*(depth/2+50))
-      near(l.pose.t[1],height-400+lampLift);near(l.pose.t[2],sign*(depth/2+170))
-      near(l.shape.dimensions.radius,150)
-    }
-    near(by.readout.pose.t[0],width/4);near(by.readout.pose.t[1],height-1250);near(by.readout.pose.t[2],depth/2+220)
-    assert.equal(by.readout.shape.dimensions.round,12)
-    for(const g of r.geometry){const mesh=geometryOf(g),audit=meshAudit(mesh);assert.equal(audit.badEdges,0);assert.ok(audit.volume>0);mesh.dispose()}
-    cases++
-  }
-  assert.equal(cases,162);console.log(JSON.stringify({fullModelCases:cases,meshChecks:cases*6}))
-})
-test('independent repeated evaluation after invalid input; source is immutable',()=>{
-  const original=JSON.stringify(seed),p=compile(fullModel()),baseline=p.evaluate(defaults)
-  assert.throws(()=>p.evaluate({...defaults,height:100}),e=>e.code==='INPUT_RANGE')
-  assert.deepEqual(p.evaluate(defaults),baseline);assert.equal(JSON.stringify(seed),original)
-})
-test('local CPU timings are measurements, not product performance guarantees',()=>{
-  const m=fullModel(),stats={},run=(name,count,fn)=>{const times=[];for(let i=0;i<count;i++){const t=performance.now();fn();times.push(performance.now()-t)}times.sort((a,b)=>a-b);stats[name]={runs:count,p50ms:times[Math.floor(count*.5)],p95ms:times[Math.floor(count*.95)]}}
-  const p=compile(m);for(let i=0;i<50;i++)p.evaluate(defaults)
-  run('compile',100,()=>compile(m));run('resolve',500,()=>p.evaluate(defaults))
-  run('sixMeshes',100,()=>p.evaluate(defaults).geometry.forEach(item=>geometryOf(item).dispose()))
-  console.log(JSON.stringify({cpuBenchmark:stats,node:process.version}))
-})

package/docs/prototypes/full-forklift.mjs

@@ -1,40 +0,0 @@
-import fs from 'node:fs'
-import {compile} from './typed-plan.mjs'
-import {geometryOf,sourceGeometry as primitiveGeometry} from './full-conveyor.mjs'
-export {geometryOf}
-export const seed=JSON.parse(fs.readFileSync(new URL('../../../operato-application/packages/operato-figure/server/seed/figure-samples.json',import.meta.url))).find(s=>s.type==='FORKLIFT').source
-export const defaults={forkLength:850,lift:0,reach:0,drive:0}
-export function fullModel(){
- const m={version:'r3-spatial-1',inputs:[{id:'forkLength',unit:'mm',min:425,max:1700},...['lift','reach'].map(id=>({id,unit:'mm',min:0,max:id==='lift'?2000:400,role:'state'})),{id:'drive',unit:'deg',min:-360,max:360,role:'state'}],constants:[],nodes:[]}
- const c=(id,value,unit='mm')=>{m.constants.push({id,value,unit});return id}
- const n=(id,op,args,outputs,params)=>m.nodes.push({id,op,args,outputs,...(params?{params}:{})})
- c('zero',0);c('a0',0,'deg');c('half',.5,'ratio')
- n('halfLift','mul@1',['lift','half'],{value:'halfLift'})
- n('halfFork','mul@1',['forkLength','half'],{value:'halfFork'});n('forkZ','add@1',['halfFork',c('forkRear',360)],{value:'forkZ'})
- const rigid=(id,from,to,xyz,rot=['a0','a0','a0'])=>n(id,'rigid@1',[...xyz,...rot],{pose:id},{from,to})
- rigid('mastPose','mast','world',['zero','zero','reach'])
- rigid('stageLocal','stage','mast',['zero','halfLift','zero']);n('stagePose','compose@1',['mastPose','stageLocal'],{pose:'stagePose'})
- rigid('carriageLocal','carriageFrame','stage',['zero','halfLift','zero']);n('carriagePose','compose@1',['stagePose','carriageLocal'],{pose:'carriagePose'})
- for(const p of seed.parts){
-  const id=p.name,d=p.transform.size,t=p.transform.position,shape=id+'Shape',pose=id+'PartPose'
-  const isFork=id.startsWith('fork-'),group=isFork||id==='carriage'?'carriage':id.startsWith('stage-')?'stage':id.startsWith('mast-')?'mast':null
-  const dims=['x','y','z'].map(a=>isFork&&a==='z'?'forkLength':c(id+'Size'+a,d[a]))
-  if(p.primitive==='cylinder')n(shape,'cylinder-shape@1',[c(id+'Radius',d.x/2),dims[1]],{shape},{frame:id})
-  else if(p.shape?.round)n(shape,'rounded-box@1',[...dims,c(id+'Round',p.shape.round)],{shape},{frame:id})
-  else n(shape,'box-shape@1',dims,{shape},{frame:id})
-  const xyz=['x','y','z'].map(a=>isFork&&a==='z'?'forkZ':c(id+'Pos'+a,t[a]))
-  const rot=['x','y','z'].map(a=>c(id+'Rot'+a,p.transform.rotation?.[a]??0,'deg'))
-  const frame=group==='carriage'?'carriageFrame':group??'world'
-  rigid(id+'Rest',id,frame,xyz,rot)
-  let local=id+'Rest'
-  if(id==='wheel-left'||id==='wheel-right'){
-   rigid(id+'Spin',id,id,['zero','zero','zero'],['a0','drive','a0'])
-   n(id+'Moving','compose@1',[local,id+'Spin'],{pose:id+'Moving'});local=id+'Moving'
-  }
-  if(group){n(pose,'compose@1',[group+'Pose',local],{pose});local=pose}
-  n(id,'place@1',[shape,local],{placed:id+'Placed'})
- }
- return m
-}
-export function evaluateFull(args=defaults){return compile(fullModel()).evaluate(args).geometry.map(g=>{const p=seed.parts.find(p=>p.name===g.id);return {...g,segments:p.segments??8,material:structuredClone(p.material)}})}
-export const sourceGeometry=p=>primitiveGeometry({...p,...(p.primitive==='rect'&&!p.shape?.round?{primitive:'cube'}:{})})

package/docs/prototypes/full-forklift.test.mjs

@@ -1,37 +0,0 @@
-import {test} from 'node:test'
-import assert from 'node:assert/strict'
-import {seed,defaults,fullModel,evaluateFull,geometryOf,sourceGeometry} from './full-forklift.mjs'
-import {compile} from './typed-plan.mjs'
-import {meshAudit} from './dryroom-mesh.mjs'
-const near=(a,b,tol=1e-6)=>assert.ok(Math.abs(a-b)<tol,`${a} != ${b}`)
-const vertices=g=>{const a=g.attributes.position;return Array.from({length:a.count},(_,i)=>[a.getX(i),a.getY(i),a.getZ(i)])}
-const deviation=(a,b)=>Math.max(...a.map(p=>Math.min(...b.map(q=>Math.hypot(...p.map((v,i)=>v-q[i]))))))
-test('all 20 original part shapes and materials reproduced at rest',()=>{
- const result=evaluateFull();assert.equal(result.length,20)
- for(const p of seed.parts){const item=result.find(g=>g.id===p.name),a=sourceGeometry(p),b=geometryOf(item);near(Math.max(deviation(vertices(a),vertices(b)),deviation(vertices(b),vertices(a))),0,.001);assert.deepEqual(item.material,p.material);a.dispose();b.dispose()}
-})
-test('full forklift: dimensions + simultaneous lift/reach/drive, compared against seed channels',()=>{
- let states=0,meshes=0
- for(const forkLength of [425,850,1700])for(const lift of [0,500,1000,1500,2000])for(const reach of [0,200,400])for(const drive of [-180,-37,0,73,180]){
-  const result=evaluateFull({forkLength,lift,reach,drive}),by=Object.fromEntries(result.map(g=>[g.id,g]))
-  for(const p of seed.parts){
-   const item=by[p.name],expected={...p.transform.position}
-   // Read original channel endpoints, not the implementation's assembly/group mapping.
-   for(const param of seed.parameters){const ch=param.clip.channels.find(c=>c.target===p.name);if(!ch)continue;const fraction=({lift,reach}[param.name]-param.range.min)/(param.range.max-param.range.min);for(const a of ['x','y','z'])expected[a]+=ch.keys[0].value[a]+fraction*(ch.keys.at(-1).value[a]-ch.keys[0].value[a])}
-   if(p.name.startsWith('fork-'))expected.z+=(forkLength-850)/2
-   for(const [i,a] of ['x','y','z'].entries())near(item.pose.t[i],expected[a])
-   if(p.name.startsWith('fork-')){near(item.shape.dimensions.depth,forkLength);near(item.pose.t[2]-forkLength/2,360+reach)}
-   if(p.name.startsWith('wheel-')){near(item.pose.r[0][1],-1);near(item.pose.r[1][1],0);near(item.pose.r[2][1],0);near(item.pose.t[1],item.shape.dimensions.radius)}
-   const g=geometryOf(item),audit=meshAudit(g);assert.equal(audit.badEdges,0);assert.equal(audit.euler,2);assert.ok(audit.volume>0&&audit.minArea>0);g.dispose();meshes++
-  }
-  near(by['fork-high-left'].pose.t[1]-by['fork-low-left'].pose.t[1],400)
-  near(by.carriage.pose.t[1]-by['fork-low-left'].pose.t[1],218)
-  states++
- }
- assert.equal(states,225);console.log({wholeForkliftCases:states,meshChecks:meshes})
-})
-test('invalid state rejected, no stale result; full declaration reorder independent',()=>{
- const m=fullModel(),p=compile(m),initial=p.evaluate(defaults)
- for(const change of [{lift:2001},{reach:-1},{forkLength:0},{drive:361}])assert.throws(()=>p.evaluate({...defaults,...change}),e=>e.code==='INPUT_RANGE')
- assert.deepEqual(p.evaluate(defaults),initial);m.nodes.reverse();const sort=r=>r.geometry.sort((a,b)=>a.id.localeCompare(b.id));assert.deepEqual(sort(compile(m).evaluate(defaults)),sort(initial))
-})

package/docs/prototypes/full-robot.mjs

@@ -1,35 +0,0 @@
-import fs from 'node:fs'
-import {compile} from './typed-plan.mjs'
-import {geometryOf,sourceGeometry as primitiveGeometry} from './full-conveyor.mjs'
-export {geometryOf}
-export const seed=JSON.parse(fs.readFileSync(new URL('../../src/fixtures/robot-arm-6dof.json',import.meta.url)))
-export const defaults={upperLength:420,foreLength:380,gripper:0,...Object.fromEntries(seed.joints.map(j=>[j.name,0]))}
-export function fullModel(){
- const m={version:'r3-spatial-1',inputs:[{id:'upperLength',unit:'mm',min:210,max:840},{id:'foreLength',unit:'mm',min:190,max:760},{id:'gripper',unit:'percent',min:0,max:100,role:'state'},...seed.joints.map(j=>({id:j.name,unit:'deg',min:j.limits?.min??-360,max:j.limits?.max??360,role:'state'}))],constants:[],nodes:[]}
- const c=(id,value,unit='mm')=>{m.constants.push({id,value,unit});return id}
- const n=(id,op,args,outputs,params)=>m.nodes.push({id,op,args,outputs,...(params?{params}:{})})
- c('zero',0);c('a0',0,'deg');c('stroke',20);c('neg',-1,'ratio')
- n('strokeValue','mul@1',['gripper','stroke'],{value:'strokeValue'});n('negativeStroke','mul@1',['strokeValue','neg'],{value:'negativeStroke'})
- n('leftX','add@1',[c('leftRest',-35),'strokeValue'],{value:'leftX'});n('rightX','add@1',[c('rightRest',35),'negativeStroke'],{value:'rightX'})
- for(const p of seed.parts){
-  const id=p.name,d=p.transform.size,shape=id+'Shape',pose=id+'Pose'
-  const height=id==='upper-arm'?'upperLength':id==='forearm'?'foreLength':c(id+'Height',d.y)
-  if(p.primitive==='cylinder')n(shape,'cylinder-shape@1',[c(id+'Radius',d.x/2),height],{shape},{frame:id})
-  else n(shape,'box-shape@1',[c(id+'Width',d.x),height,c(id+'Depth',d.z)],{shape},{frame:id})
-  for(const face of ['top','bottom'])n(id+face,'feature@1',[shape],{pose:id+face},{frame:id+face,name:p.primitive==='cylinder'?(face==='top'?'end':'start'):face})
-  if(!p.parent)n(pose,'rigid@1',['zero',c('baseCenter',50),'zero','a0','a0','a0'],{pose},{from:id,to:'world'})
-  else{
-   const j=seed.joints.find(j=>j.child===id),rot=['a0','a0','a0']
-   if(j)rot[['x','y','z'].findIndex(a=>j.axis[a]===1)]=j.name
-   const x=id==='finger-left'?'leftX':id==='finger-right'?'rightX':'zero'
-   n(id+'Connection','rigid@1',[x,'zero','zero',...rot],{pose:id+'Connection'},{from:id+'bottom',to:p.parent+'top'})
-   n(pose,'attach@1',[p.parent+'WorldTop',id+'Connection',id+'bottom'],{pose})
-  }
-  n(id+'WorldTop','compose@1',[pose,id+'top'],{pose:id+'WorldTop'})
-  n(id+'WorldBottom','compose@1',[pose,id+'bottom'],{pose:id+'WorldBottom'})
-  n(id,'place@1',[shape,pose],{placed:id+'Placed'})
- }
- return m
-}
-export function evaluateFull(args=defaults){return compile(fullModel()).evaluate(args).geometry.map(g=>{const p=seed.parts.find(p=>p.name===g.id);return {...g,segments:p.segments??8,material:structuredClone(p.material??{token:'palette.neutral'}),...(p.capability?{capability:structuredClone(p.capability)}:{})}})}
-export const sourceGeometry=p=>primitiveGeometry({...p,segments:p.segments??8})

package/docs/prototypes/full-robot.test.mjs

@@ -1,68 +0,0 @@
-import {test} from 'node:test'
-import assert from 'node:assert/strict'
-import {seed,defaults,fullModel,evaluateFull,geometryOf,sourceGeometry} from './full-robot.mjs'
-import {THREE} from './full-dryroom.mjs'
-import {compile} from './typed-plan.mjs'
-import {meshAudit} from './dryroom-mesh.mjs'
-const near=(a,b,tol=1e-7)=>assert.ok(Math.abs(a-b)<tol,`${a} != ${b}`)
-const vec=(a,b)=>a.forEach((v,i)=>near(v,b[i]))
-const vertices=g=>{const a=g.attributes.position;return Array.from({length:a.count},(_,i)=>[a.getX(i),a.getY(i),a.getZ(i)])}
-const deviation=(a,b)=>Math.max(...a.map(p=>Math.min(...b.map(q=>Math.hypot(...p.map((v,i)=>v-q[i]))))))
-const length=(p,args)=>p.name==='upper-arm'?args.upperLength:p.name==='forearm'?args.foreLength:p.transform.size.y
-// Independent Three.js matrix FK, without compiler/feature/attachment helpers.
-function oracle(args){
- const matrices={}
- for(const p of seed.parts){
-  const h=length(p,args),parent=seed.parts.find(x=>x.name===p.parent),j=seed.joints.find(j=>j.child===p.name)
-  const m=parent?matrices[parent.name].clone().multiply(new THREE.Matrix4().makeTranslation(0,length(parent,args)/2,0)):new THREE.Matrix4()
-  if(j)m.multiply(new THREE.Matrix4().makeRotationAxis(new THREE.Vector3(j.axis.x,j.axis.y,j.axis.z),args[j.name]*Math.PI/180))
-  const x=p.name==='finger-left'?-35+args.gripper*.2:p.name==='finger-right'?35-args.gripper*.2:0
-  matrices[p.name]=m.multiply(new THREE.Matrix4().makeTranslation(x,h/2,0))
- }
- return matrices
-}
-test('all ten parts: original rest vertices, materials and tool capability preserved',()=>{
- const out=evaluateFull();assert.equal(out.length,10)
- for(const p of seed.parts){
-  const item=out.find(g=>g.id===p.name),a=sourceGeometry(p),b=geometryOf(item)
-  near(Math.max(deviation(vertices(a),vertices(b)),deviation(vertices(b),vertices(a))),0,.001)
-  if(p.material)assert.deepEqual(item.material,p.material)
-  if(p.capability)assert.deepEqual(item.capability,p.capability)
-  a.dispose();b.dispose()
- }
-})
-test('whole robot: independent link lengths × simultaneous six-joint states × gripper',()=>{
- const plan=compile(fullModel());let cases=0,meshes=0,pivots=0
- for(const upperLength of [210,420,840])for(const foreLength of [190,380,760])for(let k=0;k<32;k++)for(const gripper of [0,50,100]){
-  const args={...defaults,upperLength,foreLength,gripper,...Object.fromEntries(seed.joints.map((j,i)=>[j.name,k===0?0:(j.limits?.min??-360)+(k*(i+1)%31)/30*((j.limits?.max??360)-(j.limits?.min??-360))]))}
-  const r=plan.evaluate(args),expected=oracle(args);assert.equal(r.geometry.length,10)
-  for(const item of r.geometry){
-   const p=seed.parts.find(p=>p.name===item.id),matrix=expected[p.name],t=new THREE.Vector3().setFromMatrixPosition(matrix);vec(item.pose.t,t.toArray())
-   const e=matrix.elements;item.pose.r.forEach((row,i)=>row.forEach((v,j)=>near(v,e[j*4+i])))
-   if(seed.joints.some(j=>j.child===p.name)){vec(r.values[p.name+'WorldBottom'].t,r.values[p.parent+'WorldTop'].t);pivots++}
-   const g=geometryOf({...item,segments:8}),a=meshAudit(g);assert.equal(a.badEdges,0);assert.equal(a.euler,2);assert.ok(a.volume>0&&a.minArea>0);g.dispose();meshes++
-  }
-  const a=r.values['finger-leftPose'].t,b=r.values['finger-rightPose'].t
-  near(Math.hypot(...a.map((v,i)=>v-b[i])),70-gripper*.4)
-  cases++
- }
- assert.equal(cases,864);console.log({wholeRobotCases:cases,meshChecks:meshes,pivotChecks:pivots})
-})
-test('joint limits and length errors reject, recovery and declaration order deterministic',()=>{
- const m=fullModel(),p=compile(m),r=p.evaluate(defaults)
- for(const j of seed.joints){const max=j.limits?.max??360;assert.throws(()=>p.evaluate({...defaults,[j.name]:max+1}),e=>e.code==='INPUT_RANGE')}
- assert.throws(()=>p.evaluate({...defaults,upperLength:0}),e=>e.code==='INPUT_RANGE');assert.deepEqual(p.evaluate(defaults),r)
- const original=JSON.stringify(seed);m.nodes.reverse();const reversed=compile(m).evaluate(defaults)
- const sort=x=>[...x.geometry].sort((a,b)=>a.id.localeCompare(b.id));assert.deepEqual(sort(reversed),sort(r));assert.equal(JSON.stringify(seed),original)
-})
-test('known source defect: gripper intersects tool-seat beyond 45 percent; not a collision-free certificate',()=>{
- // All three boxes share flange orientation, so exact local interval intersection suffices.
- for(const gripper of [0,45,50,100]){
-  const gap=58-.4*gripper,seatWidth=seed.parts.find(p=>p.name==='tool-seat').transform.size.x
-  const fingerCenter=35-.2*gripper
-  const overlapX=Math.max(0,Math.min(fingerCenter+6,seatWidth/2)-Math.max(fingerCenter-6,-seatWidth/2))
-  const overlapY=20,overlapZ=24
-  assert.equal(overlapX*overlapY*overlapZ>0,gripper>45)
-  if(gripper===100){near(gap,18);near(overlapX,11)}
- }
-})

package/docs/prototypes/kernel.mjs

@@ -1,147 +0,0 @@
-// Experimental executable contract. No product imports and no model-name branches.
-// Scalars are numeric in documented fixture units, NOT statically unit checked yet.
-export class DesignError extends Error {
-  constructor(code, path, detail) { super(`${code}: ${path}: ${detail}`); this.code=code; this.path=path }
-}
-const fail=(code,path,detail)=>{throw new DesignError(code,path,detail)}
-const finite=(x,path)=>{if(!Number.isFinite(x))fail('NON_FINITE',path,String(x));return x}
-const add=(a,b)=>a.map((v,i)=>v+b[i])
-const sub=(a,b)=>a.map((v,i)=>v-b[i])
-const dot=(a,b)=>a.reduce((s,v,i)=>s+v*b[i],0)
-const I=()=>[[1,0,0],[0,1,0],[0,0,1]]
-const mv=(r,v)=>r.map(row=>dot(row,v))
-const mm=(a,b)=>a.map(row=>[0,1,2].map(i=>dot(row,b.map(r=>r[i]))))
-export const point=(f,p)=>add(mv(f.rotation,p),f.position)
-function rot(axis,degrees,path) {
-  const norm=Math.hypot(...axis)
-  if(Math.abs(norm-1)>1e-10)fail('AXIS',path,'unit axis required')
-  const [x,y,z]=axis,c=Math.cos(degrees*Math.PI/180),s=Math.sin(degrees*Math.PI/180),k=1-c
-  return [[c+x*x*k,x*y*k-z*s,x*z*k+y*s],[y*x*k+z*s,c+y*y*k,y*z*k-x*s],[z*x*k-y*s,z*y*k+x*s,c+z*z*k]]
-}
-
-export function resolve(model,inputs) {
-  const values={},active=new Set(),defs=model.values??{},spec=model.inputs??{}
-  for(const k of Object.keys(inputs))if(!Object.hasOwn(spec,k))fail('UNKNOWN_INPUT',k,'not declared')
-  for(const [k,s] of Object.entries(spec)) {
-    if(Object.hasOwn(defs,k))fail('DUPLICATE_WRITER',k,'input and derived')
-    const x=finite(inputs[k],k)
-    if(x<s.min||x>s.max)fail('INPUT_RANGE',k,`${x} outside [${s.min},${s.max}]`)
-    values[k]=x
-  }
-  function expression(e,path='expression') {
-    if(typeof e==='number')return finite(e,path)
-    if(typeof e==='string')return value(e)
-    if(!e||!Array.isArray(e.args))fail('EXPRESSION',path,'expected number, reference or operator')
-    const a=e.args.map(x=>expression(x,path))
-    if(e.op==='add')return finite(a.reduce((s,x)=>s+x,0),path)
-    if(e.op==='mul'&&a.length===2)return finite(a[0]*a[1],path)
-    fail('EXPRESSION',path,'unsupported operator/arity')
-  }
-  function value(k) {
-    if(Object.hasOwn(values,k))return values[k]
-    if(!Object.hasOwn(defs,k))fail('UNKNOWN_REFERENCE',k,'no definition')
-    if(active.has(k))fail('VALUE_CYCLE',k,[...active,k].join(' -> '))
-    active.add(k);values[k]=expression(defs[k],k);active.delete(k);return values[k]
-  }
-  for(const k of Object.keys(defs))value(k)
-  for(const c of model.assertions??[]) {
-    const left=expression(c.left,c.id),right=expression(c.right,c.id)
-    if(c.op!=='gte')fail('ASSERTION_OPERATOR',c.id,c.op)
-    if(left<right)fail('ASSERTION',c.id,`${left} < ${right}; deficit=${right-left}`)
-  }
-  const frames={},visiting=new Set(),nodes={...model.frames},geometry={...model.geometry},shapeCache={}
-  function vector(v,path) {
-    if(!Array.isArray(v)||v.length!==3)fail('VECTOR',path,'three coordinates required')
-    return v.map(e=>expression(e,path))
-  }
-  function repeatPlan(r,id) {
-    const pitch=expression(r.pitch,id),axis=vector(r.axis,id)
-    if(!(pitch>0)||Math.abs(Math.hypot(...axis)-1)>1e-10)fail('REPEAT_DOMAIN',id,'positive pitch and unit axis')
-    const count=r.mode==='fixed'?expression(r.count,id):r.mode==='pitch'?Math.floor(expression(r.span,id)/pitch):NaN
-    if(!Number.isInteger(count)||count<1||!Number.isInteger(r.limit)||count>r.limit)fail('REPEAT_DOMAIN',id,`count=${count}, limit=${r.limit}`)
-    return {count,pitch,axis}
-  }
-  // Lower one-level repeated assemblies into the SAME frame/geometry evaluator.
-  // No index-dependent scripting, cross-instance references or nested patterns yet.
-  for(const [name,p] of Object.entries(model.patterns??{})) {
-    const {count,pitch,axis}=repeatPlan(p.repeat,name)
-    const localFrames=p.frames??{},localShapes=p.geometry??{}
-    for(let i=0;i<count;i++) {
-      const prefix=kind=>id=>JSON.stringify(['pattern',name,i,kind,id])
-      const fid=prefix('frame'),gid=prefix('geometry'),root=fid('$root')
-      const insert=(target,id,value)=>{if(Object.hasOwn(target,id))fail('DUPLICATE_ID',id,'expanded pattern');target[id]=value}
-      if(Object.hasOwn(localFrames,'$root'))fail('RESERVED_ID',name,'$root')
-      insert(nodes,root,{parent:p.parent,position:axis.map(x=>x*i*pitch)})
-      for(const [id,n] of Object.entries(localFrames)) {
-        if(n.feature&&n.parent)fail('DUPLICATE_PARENT',id,'feature and parent')
-        if(n.parent&&!Object.hasOwn(localFrames,n.parent))fail('PATTERN_REFERENCE',name,n.parent)
-        if(n.feature&&!Object.hasOwn(localShapes,n.feature.geometry))fail('PATTERN_REFERENCE',name,n.feature.geometry)
-        insert(nodes,fid(id),{...n,parent:n.feature?undefined:n.parent?fid(n.parent):root,
-          ...(n.feature?{feature:{...n.feature,geometry:gid(n.feature.geometry)}}:{})})
-      }
-      for(const [id,g] of Object.entries(localShapes)) {
-        if(!Object.hasOwn(localFrames,g.frame))fail('PATTERN_REFERENCE',name,g.frame)
-        if(g.repeat)fail('NESTED_REPEAT',name,id)
-        insert(geometry,gid(id),{...g,frame:fid(g.frame)})
-      }
-    }
-  }
-  function shape(id) {
-    if(Object.hasOwn(shapeCache,id))return shapeCache[id]
-    if(!Object.hasOwn(geometry,id))fail('UNKNOWN_GEOMETRY',id,'no definition')
-    const g=geometry[id],dimensions=Object.fromEntries(Object.entries(g.dimensions).map(([k,v])=>[k,expression(v,id)]))
-    const required=g.kind==='box'?['width','height','depth']:g.kind==='cylinder'?['radius','length']:null
-    if(!required||Object.keys(dimensions).length!==required.length||required.some(k=>!(dimensions[k]>0)))fail('GEOMETRY_DOMAIN',id,'positive provider dimensions required')
-    return shapeCache[id]={g,dimensions,orientation:g.orientation?rot(vector(g.orientation.axis,id),expression(g.orientation.angle,id),id):I()}
-  }
-  function featureFrame(feature,id) {
-    const {g,dimensions:d,orientation}=shape(feature.geometry)
-    if(g.repeat)fail('AMBIGUOUS_FEATURE',id,'use a pattern instance, not a repeated primitive')
-    const owner=frame(g.frame),shapeFrame={position:owner.position,rotation:mm(owner.rotation,orientation)}
-    // Named points retain provider axes. These are NOT normal-oriented attachment frames.
-    const points=g.kind==='box'?{'x-':[-d.width/2,0,0],'x+':[d.width/2,0,0],'y-':[0,-d.height/2,0],'y+':[0,d.height/2,0],'z-':[0,0,-d.depth/2],'z+':[0,0,d.depth/2]}:
-      {'start':[0,-d.length/2,0],'end':[0,d.length/2,0]}
-    if(!Object.hasOwn(points,feature.point))fail('UNKNOWN_FEATURE',id,feature.point)
-    return {position:point(shapeFrame,points[feature.point]),rotation:shapeFrame.rotation}
-  }
-  function frame(id) {
-    if(Object.hasOwn(frames,id))return frames[id]
-    const node=nodes[id]
-    if(!Object.hasOwn(nodes,id))fail('UNKNOWN_FRAME',id,'no definition')
-    if(visiting.has(id))fail('FRAME_CYCLE',id,[...visiting,id].join(' -> '))
-    visiting.add(id)
-    if(node.feature&&node.parent)fail('DUPLICATE_PARENT',id,'feature and parent')
-    const parent=node.feature?featureFrame(node.feature,id):node.parent?frame(node.parent):{position:[0,0,0],rotation:I()}
-    const offset=vector(node.position??[0,0,0],id)
-    const rest=node.orientation?rot(vector(node.orientation.axis,id),expression(node.orientation.angle),id):I()
-    let localOffset=offset,localRotation=rest
-    if(node.joint) {
-      const j=node.joint,axis=vector(j.axis,id),q=expression(j.value,id)
-      if(Math.abs(Math.hypot(...axis)-1)>1e-10)fail('AXIS',id,'unit axis required')
-      if(j.type==='slide')localOffset=add(offset,mv(rest,axis.map(x=>x*q)))
-      else if(j.type==='hinge') {
-        const pivot=vector(j.pivot??[0,0,0],id),r=rot(axis,q,id)
-        localOffset=add(offset,mv(rest,sub(pivot,mv(r,pivot))));localRotation=mm(rest,r)
-      } else fail('JOINT',id,j.type)
-    }
-    frames[id]={position:point(parent,localOffset),rotation:mm(parent.rotation,localRotation)}
-    if(![...frames[id].position,...frames[id].rotation.flat()].every(Number.isFinite))fail('NON_FINITE',id,'frame')
-    visiting.delete(id);return frames[id]
-  }
-  for(const id of Object.keys(nodes))frame(id)
-  const instances=[]
-  for(const [id,g] of Object.entries(geometry)) {
-    const owner=frame(g.frame),{dimensions,orientation}=shape(id)
-    let count=1,pitch=0,axis=[1,0,0]
-    if(g.repeat) {
-      ;({count,pitch,axis}=repeatPlan(g.repeat,id))
-    }
-    // Shape-local orientation follows placement. It does not rotate the repetition row.
-    for(let i=0;i<count;i++) {
-      // Start-anchored identity policy for this experiment. Not approved migration semantics.
-      instances.push({id:JSON.stringify([id,i]),source:id,index:i,kind:g.kind,dimensions:{...dimensions},
-        frame:{rotation:mm(owner.rotation,orientation),position:point(owner,axis.map(x=>x*i*pitch))}})
-    }
-  }
-  return {values,frames,instances}
-}