@hatiolab/figure-model 0.1.29 → 0.1.31

package/docs/prototypes/v3-feature-pattern.test.mjs

@@ -0,0 +1,131 @@
+import fs from 'node:fs'
+import assert from 'node:assert/strict'
+import {test} from 'node:test'
+import {resolve,point,DesignError} from './v3-kernel.mjs'
+
+const seeds=JSON.parse(fs.readFileSync(new URL('../../../operato-application/packages/operato-figure/server/seed/figure-samples.json',import.meta.url)))
+const src=t=>seeds.find(s=>s.type===t).source
+const part=(s,n)=>s.parts.find(p=>p.name===n)
+const add=(...args)=>({op:'add',args}),mul=(...args)=>({op:'mul',args})
+const near=(a,b)=>assert.ok(Number.isFinite(a)&&Math.abs(a-b)<1e-7,`${a} != ${b}`)
+const same=(a,b)=>a.forEach((x,i)=>near(x,b[i]))
+const fid=(p,i,n)=>JSON.stringify(['pattern',p,i,'frame',n])
+const gid=(p,i,n)=>JSON.stringify(['pattern',p,i,'geometry',n])
+const instance=(r,p,i,n)=>r.instances.find(g=>g.source===gid(p,i,n))
+const limits=(min,max)=>({min,max})
+
+function tray() {
+  const s=src('FORMATION_TRAY'),cell=part(s,'cell'),contact=part(s,'contact')
+  const c=cell.transform,t=contact.transform
+  return {inputs:{scale:limits(.5,2),angle:limits(-180,180)},
+    frames:{assembly:{position:[mul(-3.5*cell.repeat.pitch,'scale'),c.position.y,0],orientation:{axis:[0,1,0],angle:'angle'}}},
+    patterns:{slots:{parent:'assembly',repeat:{mode:'fixed',count:8,pitch:mul(cell.repeat.pitch,'scale'),axis:[1,0,0],limit:32},
+      frames:{cell:{},contact:{feature:{geometry:'cell',point:'y+'},position:[0,t.position.y-c.position.y-c.size.y/2,0]}},
+      geometry:{cell:{frame:'cell',kind:'box',dimensions:{width:mul(c.size.x,'scale'),height:c.size.y,depth:c.size.z}},contact:{frame:'contact',kind:'box',dimensions:{width:mul(t.size.x,'scale'),height:t.size.y,depth:t.size.z}}}}}}
+}
+function charger() {
+  const s=src('FORMATION_CHARGER'),shelf=part(s,'shelf'),lamp=part(s,'channel-lamp')
+  return {inputs:{height:limits(600,8000),depth:limits(300,1200),angle:limits(-180,180)},values:{shelfDepth:add('depth',-140)},
+    frames:{cabinet:{orientation:{axis:[0,0,1],angle:'angle'}},start:{parent:'cabinet',position:[0,200,shelf.transform.position.z]}},
+    patterns:{levels:{parent:'start',repeat:{mode:'pitch',span:add('height',-400),pitch:shelf.repeat.pitch,axis:[0,1,0],limit:20},
+      frames:{shelf:{},lamp:{feature:{geometry:'shelf',point:'z+'},position:[lamp.transform.position.x,0,15]}},
+      geometry:{shelf:{frame:'shelf',kind:'box',dimensions:{width:1400,height:40,depth:'shelfDepth'}},lamp:{frame:'lamp',kind:'box',dimensions:{width:90,height:60,depth:40}}}}}}
+}
+function conveyor() {
+  const p=part(src('CONVEYOR'),'roller')
+  return {inputs:{width:limits(300,15000),depth:limits(100,1200),spin:limits(-360,360)},
+    frames:{row:{position:[add(mul(-.5,'width'),75),p.transform.position.y,0]}},
+    patterns:{rollers:{parent:'row',repeat:{mode:'pitch',span:'width',pitch:p.repeat.pitch,axis:[1,0,0],limit:100},
+      frames:{roller:{orientation:{axis:[1,0,0],angle:90},joint:{type:'hinge',axis:[0,1,0],value:'spin'}},end:{feature:{geometry:'roller',point:'end'}}},
+      geometry:{roller:{frame:'roller',kind:'cylinder',dimensions:{radius:48,length:add('depth',-80)}}}}}}
+}
+
+test('fixed paired tray: 5 widths × 5 poses, actual cell/contact rest offset shared',()=>{
+  const model=tray(),before=JSON.stringify(model)
+  for(const scale of [.5,.75,1,1.5,2])for(const angle of [-90,-30,0,45,180]) {
+    const out=resolve(model,{scale,angle});assert.equal(out.instances.length,16)
+    for(let i=0;i<8;i++) {
+      const cell=instance(out,'slots',i,'cell'),contact=instance(out,'slots',i,'contact')
+      same(contact.frame.position,point(cell.frame,[0,90,0]))
+      near(contact.frame.position[1]-contact.dimensions.height/2-(cell.frame.position[1]+cell.dimensions.height/2),-2)
+      if(i)near(Math.hypot(...cell.frame.position.map((x,a)=>x-instance(out,'slots',i-1,'cell').frame.position[a])),68*scale)
+    }
+  }
+  assert.equal(JSON.stringify(model),before)
+})
+
+test('feature uses changed geometry dimension once, not an independent stale attachment value',()=>{
+  const m=tray();m.inputs.cellHeight=limits(50,300);m.patterns.slots.geometry.cell.dimensions.height='cellHeight'
+  for(const cellHeight of [50,140,300]) {
+    const out=resolve(m,{scale:1,angle:0,cellHeight})
+    for(let i=0;i<8;i++)near(instance(out,'slots',i,'contact').frame.position[1]-instance(out,'slots',i,'cell').frame.position[1],cellHeight/2+20)
+  }
+})
+
+test('pitch paired shelves: 5 count boundaries × 3 depths × 3 poses',()=>{
+  const m=charger()
+  for(const height of [2799.99,2800,2800.01,3200,5600])for(const depth of [300,700,1200])for(const angle of [-30,0,90]) {
+    const out=resolve(m,{height,depth,angle}),count=Math.floor((height-400)/400)
+    assert.equal(out.instances.length,count*2)
+    for(let i=0;i<count;i++) {
+      const shelf=instance(out,'levels',i,'shelf'),lamp=instance(out,'levels',i,'lamp')
+      same(lamp.frame.position,point(shelf.frame,[-620,0,shelf.dimensions.depth/2+15]))
+      if(angle===0){near(shelf.frame.position[1],200+i*400);near(lamp.frame.position[2],20+(depth-140)/2+15)}
+    }
+  }
+})
+
+test('pattern conveyor: actual child hinges now spin without moving repetition centers',()=>{
+  const m=conveyor()
+  for(const width of [1200,2400,4800])for(const depth of [300,600,1200])for(const spin of [-180,-90,0,90,180]) {
+    const out=resolve(m,{width,depth,spin})
+    for(let i=0;i<out.instances.length;i++) {
+      const g=instance(out,'rollers',i,'roller')
+      same(g.frame.position,[-width/2+75+i*150,500,0])
+      same(out.frames[fid('rollers',i,'end')].position,[-width/2+75+i*150,500,(depth-80)/2])
+    }
+  }
+})
+
+test('grow/shrink/regrow: retained ids and placement stable; removed references fail explicitly',()=>{
+  const m=charger(),args={depth:700,angle:0},small=resolve(m,{...args,height:2799.99}),big=resolve(m,{...args,height:2800})
+  assert.equal(small.instances.length,10);assert.equal(big.instances.length,12)
+  for(const g of small.instances)assert.deepEqual(big.instances.find(h=>h.id===g.id),g)
+  assert.deepEqual(resolve(m,{...args,height:2799.99}).instances,small.instances)
+  assert.deepEqual(resolve(m,{...args,height:2800}).instances,big.instances)
+  const referenced=structuredClone(m)
+  referenced.frames.target={parent:fid('levels',5,'shelf')}
+  resolve(referenced,{...args,height:2800})
+  assert.throws(()=>resolve(referenced,{...args,height:2799.99}),e=>e.code==='UNKNOWN_FRAME')
+  // This experiment rejects dangling references, it does not implement automatic rebinding.
+})
+
+test('feature includes shape-local rotation as well as owner motion',()=>{
+  const m={inputs:{spin:limits(-180,180)},frames:{base:{position:[1,2,3],joint:{type:'hinge',axis:[0,0,1],value:'spin'}},tip:{feature:{geometry:'beam',point:'end'}}},
+    geometry:{beam:{frame:'base',kind:'cylinder',dimensions:{radius:5,length:100},orientation:{axis:[1,0,0],angle:90}}}}
+  for(const spin of [-90,0,90]) {
+    const r=resolve(m,{spin});same(r.frames.tip.position,point(r.instances[0].frame,[0,50,0]))
+  }
+})
+
+test('invalid feature cycles, unknown labels, ambiguous repeats, local escape and duplicate parents reject',()=>{
+  const base=tray(),args={scale:1,angle:0}
+  const cases=[]
+  let m=structuredClone(base);m.patterns.slots.frames.cell={feature:{geometry:'cell',point:'y+'}};cases.push([m,'FRAME_CYCLE'])
+  m=structuredClone(base);m.patterns.slots.frames.contact.feature.point='not-a-face';cases.push([m,'UNKNOWN_FEATURE'])
+  m=structuredClone(base);m.patterns.slots.frames.contact.parent='cell';cases.push([m,'DUPLICATE_PARENT'])
+  m=structuredClone(base);m.patterns.slots.frames.contact={parent:'outside'};cases.push([m,'PATTERN_REFERENCE'])
+  m=structuredClone(base);m.patterns.slots.repeat.count=1.5;cases.push([m,'REPEAT_DOMAIN'])
+  m=structuredClone(base);m.patterns.slots.geometry.cell.repeat={};cases.push([m,'NESTED_REPEAT'])
+  for(const [model,code] of cases)assert.throws(()=>resolve(model,args),e=>e instanceof DesignError&&e.code===code)
+  const repeated={frames:{base:{},tip:{feature:{geometry:'beam',point:'end'}}},geometry:{beam:{frame:'base',kind:'cylinder',dimensions:{radius:5,length:10},repeat:{mode:'fixed',count:2,pitch:20,axis:[1,0,0],limit:5}}}}
+  assert.throws(()=>resolve(repeated,{}),e=>e.code==='AMBIGUOUS_FEATURE')
+})
+
+test('declaration order is irrelevant across geometry feature and repeated frame dependencies',()=>{
+  const m=tray(),args={scale:1.5,angle:45},expected=resolve(m,args)
+  const reverse=o=>Object.fromEntries(Object.entries(o).reverse())
+  m.patterns.slots.frames=reverse(m.patterns.slots.frames);m.patterns.slots.geometry=reverse(m.patterns.slots.geometry)
+  const sort=r=>r.instances.toSorted((a,b)=>a.id.localeCompare(b.id))
+  assert.deepEqual(sort(resolve(m,args)),sort(expected))
+})

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

@@ -0,0 +1,60 @@
+import fs from 'node:fs'
+import {compile} from './v3-typed-plan.mjs'
+import {THREE,rounded} from './v3-full-dryroom.mjs'
+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==='CONVEYOR').source
+export const defaults={length:2400,width:600,rollerHeight:500,angle:0}
+export function fullModel(){
+ const m={version:'r3-spatial-1',inputs:[['length',900,6000],['width',400,1200],['rollerHeight',400,1200]].map(([id,min,max])=>({id,unit:'mm',min,max})).concat({id:'angle',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}:{})})
+ const calc=(id,op,a,b)=>{n(id,op,[a,b],{value:id});return id}
+ c('zero',0);c('a0',0,'deg');c('quarter',90,'deg');c('half',.5,'ratio');c('negative',-1,'ratio')
+ const add=(id,a,v)=>calc(id,'add@1',a,c(id+'Offset',v))
+ calc('halfLength','mul@1','length','half');calc('halfWidth','mul@1','width','half')
+ add('endX','halfLength',-60);add('legX','halfLength',-260);add('frameZ','halfWidth',-18);add('guardZ','halfWidth',-8);add('legZ','halfWidth',-56)
+ add('frameY','rollerHeight',-54);add('guardY','rollerHeight',52);add('deckY','rollerHeight',-110)
+ add('legHeight','rollerHeight',-144);calc('halfLeg','mul@1','legHeight','half');add('legY','halfLeg',42)
+ add('rollerLength','width',-80);add('endLength','width',-40);add('deckWidth','width',-100);add('footWidth','width',20)
+ add('motorZ','halfWidth',40);add('gearZ','halfWidth',-48);add('driveY','rollerHeight',-170);add('controlY','rollerHeight',-270)
+ const neg=id=>{const key='neg'+id;if(!m.nodes.some(n=>n.id===key))calc(key,'mul@1',id,'negative');return key}
+ const rigid=(id,from,to,xyz,rot=['a0','a0','a0'])=>n(id,'rigid@1',[...xyz,...rot],{pose:id},{from,to})
+ for(const p of seed.parts){
+  const id=p.name,d=p.transform.size;let xyz=['zero','zero','zero'],dims=['x','y','z'].map(a=>c(id+a,d[a]))
+  if(id==='deck'){dims=['length',dims[1],'deckWidth'];xyz=['zero','deckY','zero']}
+  else if(id.startsWith('frame-')||id.startsWith('guard-')){const family=id.split('-')[0];dims[0]='length';xyz=['zero',family+'Y',id.endsWith('left')?neg(family+'Z'):family+'Z']}
+  else if(id.startsWith('leg-')){dims[1]='legHeight';xyz=[id.includes('head')?neg('legX'):'legX','legY',id.endsWith('left')?neg('legZ'):'legZ']}
+  else if(id.startsWith('foot-')){dims[2]='footWidth';xyz=[id.endsWith('head')?neg('legX'):'legX',c(id+'Y',24),'zero']}
+  else if(id.startsWith('roller')){dims[1]=id==='roller'?'rollerLength':'endLength';xyz=[id==='roller'?'zero':id.endsWith('head')?neg('endX'):'endX','rollerHeight','zero']}
+  else if(id==='motor'||id==='gearbox')xyz=[neg('endX'),'driveY',id==='motor'?'motorZ':'gearZ']
+  else if(id==='control-box')xyz=['legX','controlY','halfWidth']
+  else throw Error('Unmapped part '+id)
+  const shape=id+'Shape',pose=id+'Pose'
+  if(p.primitive==='cylinder')n(shape,'cylinder-shape@1',[c(id+'Radius',d.x/2),dims[1]],{shape},{frame:id})
+  else if(p.primitive==='rect')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})
+  rigid(pose,id,id==='roller'?'rollerItem':'world',xyz,p.primitive==='cylinder'?['quarter',id==='roller'?'angle':'a0','a0']:undefined)
+  n(id,id==='roller'?'member@1':'place@1',[shape,pose],{placed:id+'Placed'})
+ }
+ // End roller center is 60mm from the edge, radius 75mm; reserve an additional 10mm gap.
+ n('layout','fit-pitch@1',['length',c('margin',145),'margin',c('extent',96),c('pitch',150),c('align',.5,'ratio'),c('limit',100,'count')],{layout:'layout'})
+ n('assembly','assembly@1',['rollerPlaced'],{assembly:'assembly'})
+ rigid('repeatRoot','rollerItem','world',[neg('halfLength'),'zero','zero'])
+ n('rollers','repeat@1',['layout','assembly','repeatRoot'],{collection:'rollers'},{axis:'x'})
+ return m
+}
+export function evaluateFull(args=defaults){return compile(fullModel()).evaluate(args).geometry.map(g=>{const p=seed.parts.find(p=>p.name===(g.key?'roller':g.id));return {...g,sourceName:p.name,segments:p.segments,material:structuredClone(p.material)}})}
+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 g=new THREE.CylinderGeometry(d.radius,d.radius,d.length,item.segments)
+ 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==='cube')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{g=new THREE.ExtrudeGeometry(rounded(d.x,d.z,p.shape.round),{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
+}
+export function sourceItems(){return seed.parts.flatMap(p=>{const count=p.repeat?Math.floor(seed.base.x/p.repeat.pitch):1;return Array.from({length:count},(_,i)=>{const geometry=sourceGeometry(p);if(p.repeat)geometry.translate((i-(count-1)/2)*p.repeat.pitch,0,0);return {id:p.name+'-'+i,material:p.material,geometry}})})}

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

@@ -0,0 +1,61 @@
+import {test} from 'node:test'
+import assert from 'node:assert/strict'
+import {seed,defaults,fullModel,evaluateFull,geometryOf,sourceGeometry} from './v3-full-conveyor.mjs'
+import {compile} from './v3-typed-plan.mjs'
+import {meshAudit} from './v3-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/v3-full-dryroom.mjs

@@ -0,0 +1,67 @@
+import * as THREE from '../../../things-scene/node_modules/three/build/three.module.js'
+import {seed} from './v3-dryroom-mesh.mjs'
+import {compile} from './v3-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/v3-full-dryroom.test.mjs

@@ -0,0 +1,54 @@
+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 './v3-full-dryroom.mjs'
+import {compile} from './v3-typed-plan.mjs'
+import {meshAudit} from './v3-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/v3-full-forklift.mjs

@@ -0,0 +1,40 @@
+import fs from 'node:fs'
+import {compile} from './v3-typed-plan.mjs'
+import {geometryOf,sourceGeometry as primitiveGeometry} from './v3-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/v3-full-forklift.test.mjs

@@ -0,0 +1,37 @@
+import {test} from 'node:test'
+import assert from 'node:assert/strict'
+import {seed,defaults,fullModel,evaluateFull,geometryOf,sourceGeometry} from './v3-full-forklift.mjs'
+import {compile} from './v3-typed-plan.mjs'
+import {meshAudit} from './v3-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/v3-full-robot.mjs

@@ -0,0 +1,35 @@
+import fs from 'node:fs'
+import {compile} from './v3-typed-plan.mjs'
+import {geometryOf,sourceGeometry as primitiveGeometry} from './v3-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/v3-full-robot.test.mjs

@@ -0,0 +1,68 @@
+import {test} from 'node:test'
+import assert from 'node:assert/strict'
+import {seed,defaults,fullModel,evaluateFull,geometryOf,sourceGeometry} from './v3-full-robot.mjs'
+import {THREE} from './v3-full-dryroom.mjs'
+import {compile} from './v3-typed-plan.mjs'
+import {meshAudit} from './v3-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)}
+ }
+})