NassScript — the whole surface

const rows = objs.map(o => {
  const g = o.mesh.geometry;
  const tri = g.index ? g.index.count / 3 : g.attributes.position.count / 3;
  o.mesh.updateMatrixWorld(true);
  const s = new THREE.Box3().setFromObject(o.mesh).getSize(new THREE.Vector3());
  return [
    String(o.id).padStart(4),
    o.name.padEnd(26).slice(0, 26),
    (o.genType || o.type).padEnd(10),
    (Math.round(tri) + ' tri').padStart(12),
    `${s.x.toFixed(1)}×${s.y.toFixed(1)}×${s.z.toFixed(1)} mm`,
    o.isHole ? '  hole' : ''
  ].join('  ');
});
scriptLog(rows.join('\n'));

const byKind = {};
objs.forEach(o => { const k = o.genType || o.type; byKind[k] = (byKind[k] || 0) + 1; });
scriptLog('\n— breakdown —', byKind);
return objs.length + ' objects';

// densities in g/cm³, keyed on NASSCAD material ids
const RHO = {alu:2.70, inox:7.90, acier:7.85, laiton:8.50, cuivre:8.96,
             or:19.30, titane:4.51, 'abs-noir':1.04, 'abs-blanc':1.04,
             caoutchouc:1.20, carbone:1.60, verre:2.50};

function volumeMm3(mesh){
  mesh.updateMatrixWorld(true);
  const g = mesh.geometry, p = g.attributes.position.array;
  const ix = g.index ? g.index.array : null;
  const n = ix ? ix.length / 3 : p.length / 9;
  const m = mesh.matrixWorld;
  const a = new THREE.Vector3(), b = new THREE.Vector3(), c = new THREE.Vector3();
  let v = 0;
  for(let i = 0; i < n; i++){
    const i0 = (ix ? ix[i*3] : i*3) * 3;
    const i1 = (ix ? ix[i*3+1] : i*3+1) * 3;
    const i2 = (ix ? ix[i*3+2] : i*3+2) * 3;
    a.set(p[i0], p[i0+1], p[i0+2]).applyMatrix4(m);
    b.set(p[i1], p[i1+1], p[i1+2]).applyMatrix4(m);
    c.set(p[i2], p[i2+1], p[i2+2]).applyMatrix4(m);
    v += a.dot(b.clone().cross(c)) / 6;   // signed tetrahedron (O,a,b,c)
  }
  return Math.abs(v);
}

let total = 0;
(selObjs.length ? selObjs : objs).forEach(o => {
  const mm3 = volumeMm3(o.mesh);
  const rho = RHO[o.matId] ?? 1.0;
  const g = mm3 / 1000 * rho;           // mm³ → cm³ → g
  total += g;
  scriptLog(`${o.name.padEnd(24)} ${(mm3/1000).toFixed(2).padStart(10)} cm³ `
    + `${g.toFixed(1).padStart(9)} g   ${o.matId || '(no material, ρ=1)'}`);
});
return 'total mass: ' + (total/1000).toFixed(3) + ' kg';

const D = 6, PITCH = 20, MARGIN = 12;        // hole Ø, spacing, edge margin (mm)

const plate = selObjs[selObjs.length - 1];
if(!plate) throw new Error('Select the plate first');
if(!await _medusaProbe(2000)) throw new Error('MEDUSA offline — the subtraction would fail');

await undoPush('hole grid');
plate.mesh.updateMatrixWorld(true);
const bb = new THREE.Box3().setFromObject(plate.mesh);
const thk = bb.max.y - bb.min.y;
const cy  = (bb.max.y + bb.min.y) / 2;

setHoleMode(true);
const holes = [];
for(let x = bb.min.x + MARGIN; x <= bb.max.x - MARGIN + 1e-6; x += PITCH){
  for(let z = bb.min.z + MARGIN; z <= bb.max.z - MARGIN + 1e-6; z += PITCH){
    scriptCheckStop();
    addPrimitive('cylinder');
    const t = objs[objs.length - 1];
    t.mesh.scale.set(D / PS, (thk + 4) / PS, D / PS);   // base is Ø20 × h20 = PS
    t.mesh.position.set(x, cy, z);
    _invalidateBbox(t.mesh);
    holes.push(t);
  }
}
setHoleMode(false);

selObjs = [plate, ...holes];
updProps(); updOList(); updCSG();
await doCSG('subtract');
return holes.length + ' holes Ø' + D + ' mm';

const N = 8, PCD = 80, D = 8, H = 30;   // count, pitch circle Ø, hole Ø, height

await undoPush('bolt circle');
setHoleMode(true);
const made = [];
for(let i = 0; i < N; i++){
  scriptCheckStop();
  const a = i * 2 * Math.PI / N;
  addPrimitive('cylinder');
  const t = objs[objs.length - 1];
  t.mesh.scale.set(D / PS, H / PS, D / PS);
  t.mesh.position.set(PCD/2 * Math.cos(a), 0, PCD/2 * Math.sin(a));
  _invalidateBbox(t.mesh);
  made.push(t);
}
setHoleMode(false);
selObjs = made; updProps(); updOList(); updStats();
return `${N} holes Ø${D} on Ø${PCD}`;

// extrude a convex polygon [[x,z],…] to height h, base at Y=0
function extrude(poly, h){
  const v = [];
  const tri = (...p) => v.push(...p);
  const n = poly.length;
  for(let i = 0; i < n; i++){                // side walls
    const a = poly[i], b = poly[(i+1) % n];
    tri(a[0],0,a[1], b[0],0,b[1], b[0],h,b[1]);
    tri(a[0],0,a[1], b[0],h,b[1], a[0],h,a[1]);
  }
  for(let i = 1; i < n - 1; i++){            // caps (triangle fan)
    tri(poly[0][0],0,poly[0][1], poly[i+1][0],0,poly[i+1][1], poly[i][0],0,poly[i][1]);
    tri(poly[0][0],h,poly[0][1], poly[i][0],h,poly[i][1], poly[i+1][0],h,poly[i+1][1]);
  }
  const g = new THREE.BufferGeometry();
  g.setAttribute('position', new THREE.Float32BufferAttribute(v, 3));
  g.computeVertexNormals(); g.computeBoundingBox();
  return g;
}

const AF = 30, TH = 12;                       // across flats, thickness
const R = AF / 2 / Math.cos(Math.PI / 6);
const hex = Array.from({length: 6}, (_, i) => {
  const a = i * Math.PI / 3 + Math.PI / 6;
  return [R * Math.cos(a), R * Math.sin(a)];
});

const obj = _finalizeGenToScene({
  label: 'NassScript prism',
  geo: await postProcessCSGGeo(extrude(hex, TH)),   // weld + crease normals
  name: n => `hex${AF}_${n}`,
  genType: 'script',
  genParams: {acrossFlats: AF, thickness: TH},
  hideDialogFn: () => {}
});
return obj.name;

globalThis._stepExportConfig = {fusionMode:'ROBUST', apVersion:'AP242', logStats:false};

const targets = selObjs.length ? [...selObjs] : [...objs];
const written = [];
for(const o of targets){
  scriptCheckStop();
  const text = await _expSTEPRun([o], {returnText:true, silent:true});
  written.push({name: o.name, bytes: text.length});

  // comment this block out for a dry-run inventory
  const url = URL.createObjectURL(new Blob([text], {type:'application/step'}));
  const a = Object.assign(document.createElement('a'),
    {href:url, download: o.name.replace(/[^\w.-]/g, '_') + '.stp'});
  a.click(); URL.revokeObjectURL(url);
  await new Promise(r => setTimeout(r, 350));   // let the browser breathe
}
scriptLog(written);
return written.length + ' STEP files';

const saved = [...objs];
const targets = selObjs.length ? [...selObjs] : [...objs];
try {
  for(const o of targets){
    scriptCheckStop();
    objs = [o];                       // ← objs is a reassignable global
    scriptLog('exporting ' + o.name);
    await expSTL();                   // opens the save picker
  }
} finally {
  objs = saved;                       // ← non-negotiable
  updOList(); updStats(); updProps();
}
return targets.length + ' parts exported';

const report = [];

const medusa = await _medusaProbe(2500);
report.push((medusa ? '✓' : '✗') + ' MEDUSA '
  + (medusa ? 'reachable' : 'OFFLINE — no boolean will run'));

const nonManifold = objs.filter(o => o.isManifold === false);
report.push((nonManifold.length ? '⚠' : '✓') + ' non-manifold: '
  + (nonManifold.map(o => o.name).join(', ') || 'none'));

const heavy = objs.map(o => {
  const g = o.mesh.geometry;
  return {n: o.name, t: g.index ? g.index.count/3 : g.attributes.position.count/3};
}).filter(x => x.t > 50000);
report.push((heavy.length ? '⚠' : '✓') + ' over 50k triangles: '
  + (heavy.map(x => `${x.n} (${Math.round(x.t)})`).join(', ') || 'none'));

const s = GeometryPool.initialized ? GeometryPool.stats() : null;
if(s) report.push(`· pool ${Math.round(s.geoUsedMo + s.snapUsedMo)} / ${Math.round(s.totalMo)} MB`
  + `, ${s.slots}/${s.maxSlots} slots`);

report.push(`· ${objs.length} objects, ${objs.filter(o => o.isHole).length} hole(s)`);
scriptLog(report.join('\n'));
return medusa ? 'ready' : 'blocked';

// 1. dump every generated part's parameters as JSON you can keep
const sheet = objs.filter(o => o.genType).map(o => ({
  name: o.name, genType: o.genType, params: o.genParams,
  at: [+o.mesh.position.x.toFixed(3), +o.mesh.position.y.toFixed(3), +o.mesh.position.z.toFixed(3)],
  rot: [+o.mesh.rotation.x.toFixed(4), +o.mesh.rotation.y.toFixed(4), +o.mesh.rotation.z.toFixed(4)]
}));
scriptLog(JSON.stringify(sheet, null, 1));

// 2. rebuild a family of gears from one existing gear's parameters
const ref = objs.find(o => o.genType === 'gear');
if(ref){
  await undoPush('gear family');
  for(const z of [12, 18, 24, 36]){
    scriptCheckStop();
    const p = {...ref.genParams, gearTeeth: z, gearPair: false};
    const {vPos, tris} = _gearBuild(p);
    const g = new THREE.BufferGeometry();
    g.setAttribute('position', new THREE.Float32BufferAttribute(new Float32Array(vPos), 3));
    if(tris) g.setIndex(Array.from(tris));
    g.computeVertexNormals(); g.computeBoundingBox();
    _finalizeGenToScene({label:'Gear.Gen (script)', geo:g,
      name: n => `gear_z${z}_${n}`, genType:'gear', genParams:p,
      hideDialogFn: () => {}, shininess: 12, specular: 0x2a2a2a});
  }
}
return sheet.length + ' generated parts catalogued';

openSketcher();                       // draw a closed contour first, then run this

const ents = SK.getEntities();
if(!ents.length) throw new Error('Empty sketch — draw a closed contour first');

scriptLog(`${ents.length} entities`);
const kinds = {};
ents.forEach(e => kinds[e.type] = (kinds[e.type] || 0) + 1);
scriptLog(kinds);

// bounding box of the sketch, in sketch units
const xs = [], ys = [];
ents.forEach(e => {
  [[e.x1, e.y1], [e.x2, e.y2], [e.cx, e.cy]].forEach(([x, y]) => {
    if(typeof x === 'number') xs.push(x);
    if(typeof y === 'number') ys.push(y);
  });
});
scriptLog(`extent ${(Math.max(...xs)-Math.min(...xs)).toFixed(2)}`
        + ` × ${(Math.max(...ys)-Math.min(...ys)).toFixed(2)}`);

// nudge one entity numerically, then extrude
// SK.updateProp(ents[0].id, 'x2', 45);
SK.extrude();
return objs.at(-1).name;