Made of little things.

import assert from 'node:assert/strict';
import test from 'node:test';
import {readFileSync} from 'node:fs';
import {resolve,dirname} from 'node:path';
import {runInNewContext} from 'node:vm';
import ts from 'typescript';
import * as three from 'three';
const cache=new Map();
function load(file){
 const path=resolve(file);if(cache.has(path))return cache.get(path).exports;
 const module={exports:{}};cache.set(path,module);
 runInNewContext(ts.transpileModule(readFileSync(path,'utf8'),{compilerOptions:{module:ts.ModuleKind.CommonJS,target:ts.ScriptTarget.ES2022}}).outputText,{module,exports:module.exports,TextEncoder,TextDecoder,require:name=>name==='three'?three:load(resolve(dirname(path),name.replace(/\.js$/,'.ts')))});return module.exports;
}
const {decodeAtlas}=load('src/atlas-data.ts');
const {muscleCatalog,organCatalog}=load('src/atlas-catalog.ts');
const {SkinModel,decodeSkin}=load('src/skin-model.ts'),{decodeSkeleton}=load('src/skeleton-data.ts');
const {draftString,parseDraft,casePayload}=load('src/case-record.ts'),{parseSession,sessionString}=load('src/session-record.ts');
const {profile,makeConcern}=load('src/case.ts'),{skeletonCatalog}=load('src/skeleton-catalog.ts');
const bytes=file=>{const b=readFileSync(file);return b.buffer.slice(b.byteOffset,b.byteOffset+b.byteLength);};
const data=decodeSkin(bytes('assets/skin/body-skin.bin')),skeleton=decodeSkeleton(bytes('assets/skeleton/skeleton.bin'));
const muscles=decodeAtlas(bytes('assets/anatomy/muscles.bin'),'bp3d-muscles-1'),organs=decodeAtlas(bytes('assets/anatomy/organs.bin'),'bp3d-organs-1');
const {MeshStandardMaterial,Vector3,Raycaster,Triangle}=three;
function model(){const m=new SkinModel(data,new MeshStandardMaterial(),skeleton,[muscles,organs]);m.setLayer('skeleton');m.update();return m;}
function pick(m,label){
 const asset=m.layer==='muscles'?muscles:m.layer==='organs'?organs:skeleton;
 const info=asset.parts.find(p=>p.label===label),mesh=m.surfaces.find(s=>s.name===info.id);
 const positions=mesh.geometry.getAttribute('position'),indices=mesh.geometry.index;
 mesh.geometry.computeBoundingBox();const target=mesh.geometry.boundingBox.getCenter(new Vector3());let face=0,distance=Infinity;
 for(let i=0;i<indices.count;i+=3){const center=[0,1,2].reduce((v,k)=>v.add(new Vector3().fromBufferAttribute(positions,indices.getX(i+k))),new Vector3()).multiplyScalar(1/3);const d=center.distanceToSquared(target);if(d<distance){distance=d;face=i;}}
 const verts=[0,1,2].map(i=>mesh.localToWorld(mesh.getVertexPosition(indices.getX(face+i),new Vector3())));
 const center=verts.reduce((p,v)=>p.add(v),new Vector3()).multiplyScalar(1/3),normal=Triangle.getNormal(...verts,new Vector3());
 const hit=new Raycaster(center.clone().addScaledVector(normal,.003),normal.clone().negate(),0,.006).intersectObject(mesh,false)[0];
 assert.ok(hit,label);return m.mark(hit,.012,1);
}
const {BodyInspection}=load('src/body-inspection.ts');
const {parseInspection}=load('src/inspection-record.ts');
const {anatomyTree,anatomyLeaves,descendants,flattenAnatomy,visibilityState}=load('src/anatomy-tree.ts');
const view=(layer,target)=>({version:2,layer,target,hidden:[],yaw:.8,pitch:-.3,distance:.4});
test('isolated fingers use original triangles and follow posing and body shape',()=>{
 const m=model();m.setLayer('skin');const inspect=new BodyInspection(m);
 assert.ok(inspect.options().some(p=>p.id==='region:left-index'));
 for(const side of ['left','right']){
  assert.ok(inspect.set(`region:${side}-index`));inspect.setVisible('region:body',false);inspect.setVisible(`region:${side}-index`,true);
  const bounds=inspect.bounds(),center=bounds.getCenter(new Vector3());
  assert.ok(bounds.getSize(new Vector3()).length()<.2);assert.ok(side==='left'?center.x>0:center.x<0);
  const hits=new Raycaster(center.clone().add(new Vector3(0,0,1)),new Vector3(0,0,-1)).intersectObjects(inspect.surfaces,false);
  const hit=hits.find(h=>inspect.accepts(h));assert.ok(hit,'isolated finger can be picked even with original skin hidden');
  const {mark}=m.mark(hit,.003,1),serialized=JSON.stringify(mark),before=m.group.localToWorld(m.anchor(mark).point.clone());
  assert.match(mark.surface.label,/index finger/i);assert.ok(inspect.includesMark(mark));
  m.joints.get(`${side}-elbow`).rotation.x=-1.2;m.shape(190,125,'Female');m.update();
  const after=m.group.localToWorld(m.anchor(mark).point.clone());
  assert.ok(after.distanceTo(before)>.1);assert.ok(inspect.bounds().containsPoint(after));assert.equal(JSON.stringify(mark),serialized);
  inspect.clear();assert.ok(m.mesh.visible);assert.ok(m.anchor(mark));
 }
 inspect.dispose();m.dispose();
});
test('visibility and focus are independent; hidden structures retain anchors and materials',()=>{
 const m=model();m.setLayer('organs');const inspect=new BodyInspection(m),original=m.surfaces.map(s=>[s,s.material,s.visible]);
 const id=organCatalog.find(p=>p.label==='Stomach').id,other=pick(m,'Left kidney').mark,mark=pick(m,'Stomach').mark;
 assert.ok(inspect.set(`structure:${id}`));assert.equal(inspect.surfaces.length,m.surfaces.length,'focus leaves every structure visible');
 const before=inspect.bounds().clone();inspect.setVisible('region:body',false);inspect.setVisible(`structure:${id}`,true);
 assert.equal(inspect.surfaces.length,1);assert.ok(inspect.bounds().equals(before),'visibility leaves the focus pivot unchanged');
 assert.ok(inspect.includesMark(mark));assert.ok(!inspect.includesMark(other));assert.ok(m.anchor(other));
 const hidden=JSON.stringify(inspect.hidden);inspect.set(null);assert.equal(JSON.stringify(inspect.hidden),hidden,'whole-body focus does not reveal anything');
 inspect.set(`structure:${other.surface.zone}`);assert.ok(inspect.bounds(),'hidden anatomy can be focused without unhiding');assert.equal(JSON.stringify(inspect.hidden),hidden);
 inspect.setVisible('region:body',true);for(const [mesh,material,visible] of original){assert.equal(mesh.material,material);assert.equal(mesh.visible,visible);}
 inspect.dispose();m.dispose();
});
test('checkbox hierarchy propagates through both arms, hands, fingers and segments on every available layer',()=>{
 const m=model(),inspect=new BodyInspection(m);
 for(const layer of ['skin','skeleton','muscles','organs']){
  inspect.clear();m.setLayer(layer);
  const tree=inspect.tree(),leaves=anatomyLeaves(tree);assert.equal(new Set(leaves).size,leaves.length,'leaves have exactly one parent');
  for(const mesh of m.surfaces.filter(mesh=>mesh!==m.mesh))assert.ok(leaves.includes(`structure:${mesh.name}`),`${layer}: ${mesh.name}`);
  if(layer==='organs')continue;
  for(const side of ['left','right']){
   const hand=flattenAnatomy(tree).find(n=>n.id===`region:${side}-hand`),arm=flattenAnatomy(tree).find(n=>n.id===`region:${side}-arm`);
   inspect.setVisible(arm.id,false);assert.equal(visibilityState(hand,new Set(inspect.hidden)),'unchecked');
   assert.ok(anatomyLeaves(hand).every(id=>inspect.hidden.includes(id)));
   inspect.setVisible(hand.id,true);assert.equal(visibilityState(arm,new Set(inspect.hidden)),'mixed');
   const leaf=anatomyLeaves(hand)[0];inspect.setVisible(leaf,false);assert.equal(visibilityState(hand,new Set(inspect.hidden)),'mixed');
   inspect.setVisible(arm.id,true);assert.equal(inspect.hidden.length,0);assert.equal(visibilityState(hand,new Set(inspect.hidden)),'checked');
  }
 }
 inspect.dispose();m.dispose();
});
test('skin leaf partition covers every original triangle and filters picking without changing addresses',()=>{
 const m=model();m.setLayer('skin');const inspect=new BodyInspection(m),original=Array.from(m.data.indices);
 const leaves=anatomyLeaves(inspect.tree()),valid=new Set(leaves);assert.ok(inspect.triangleLeaves.every(id=>valid.has(id)));
 inspect.setVisible('region:left-hand',false);
 const hiddenTriangle=inspect.triangleLeaves.findIndex(id=>descendants('skin','region:left-hand').includes(id));
 assert.ok(!inspect.accepts({object:m.mesh,faceIndex:hiddenTriangle}));
 const torso=inspect.triangleLeaves.findIndex(id=>id==='region:torso');assert.ok(inspect.accepts({object:m.mesh,faceIndex:torso}));
 inspect.set('region:left-index');assert.ok(!inspect.accepts({object:m.mesh,faceIndex:hiddenTriangle}));
 inspect.setVisible('region:left-arm',true);assert.ok(inspect.accepts({object:m.mesh,faceIndex:hiddenTriangle}));
 assert.deepEqual(Array.from(m.data.indices),original);assert.ok(m.mesh.visible);
 inspect.dispose();m.dispose();
});
test('focus options respect anatomy and unavailable targets restore normal display',()=>{
 const m=model();m.setLayer('organs');m.shape(172,70,'Male');const inspect=new BodyInspection(m);
 const id=organCatalog.find(p=>/uterus/i.test(p.label)).id;
 assert.ok(!inspect.options().some(p=>p.id===`structure:${id}`));assert.equal(inspect.set(`structure:${id}`),false);assert.equal(inspect.hidden.length,0);
 m.shape(172,70,'Female');assert.ok(inspect.options().some(p=>p.id===`structure:${id}`));assert.ok(inspect.set(`structure:${id}`));
 inspect.clear();m.setLayer('skin');m.shape(172,70,'Male');assert.ok(inspect.set('structure:shaft'));assert.ok(inspect.options().some(p=>p.id==='structure:glans'),'display hiding must not erase applicable options');
 inspect.dispose();m.dispose();
});
test('observation and session views round-trip independently; legacy records and invalid cameras are handled',()=>{
 const c=makeConcern(1,'Finger','standing');c.inspection=view('skin','region:right-index');
 const saved=parseDraft(draftString(profile,[c]));assert.equal(JSON.stringify(saved.concerns[0].inspection),JSON.stringify(c.inspection));
 const session={version:1,draft:saved,view:{page:'map',panel:'body',selectedId:1,pose:'standing',layer:'skin',exampleAttachment:false,inspection:view('skin','region:left-hand','fade')}};
 assert.equal(parseSession(sessionString(session)).view.inspection.target,'region:left-hand');
 const initial=casePayload(profile,[c]);c.inspection.yaw+=.1;assert.notEqual(initial.bodyMapRevision,casePayload(profile,[c]).bodyMapRevision);
 assert.match(initial.concerns[0].inspectionDisplay.meaning,/display choice/);
 for(const change of [v=>v.yaw=Infinity,v=>v.distance=0,v=>v.pitch=2,v=>v.target='region:tooth',v=>v.hidden=['region:tooth'],v=>v.hidden=['region:head','region:head'],v=>v.layer='organs']){
  const v={...c.inspection};change(v);assert.throws(()=>parseInspection(v,'skin'));
 }
 const legacy={version:1,layer:'skin',target:'region:left-hand',context:'isolate',yaw:0,pitch:0,distance:.4};
 const migrated=parseInspection(legacy);assert.equal(migrated.version,2);assert.ok(migrated.hidden.includes('region:head'));assert.ok(descendants('skin','region:left-hand').every(id=>!migrated.hidden.includes(id)));
 assert.equal(parseInspection({...legacy,context:'fade'}).hidden.length,0);
 const before=casePayload(profile,[c]).bodyMapRevision;c.inspection.hidden=['region:head'];assert.notEqual(before,casePayload(profile,[c]).bodyMapRevision);
 delete c.inspection;assert.equal(parseDraft(draftString(profile,[c])).concerns[0].inspection,undefined);
});