axstack 0.36.0 → 0.37.0

package/skills/axstack-anatomy/scripts/audit-affine-bounds.test.mjs

@@ -0,0 +1,54 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import test from "node:test";
+import * as A from "../kit/audit.mjs";
+import { turning } from "../kit/turn-build.mjs";
+const P = { origin: [0, 0], scale: 1, azimuth: 45, elevation: 30 };
+const fixtures = [
+  ["rotated rectangle", '<rect width="10" height="10" transform="rotate(45)"/>'],
+  ["rotated circle", '<circle r="10" transform="rotate(45)"/>'],
+  ["rotated ellipse", '<ellipse rx="10" ry="2" transform="rotate(45)"/>'],
+  ["nested affine ellipse", '<g transform="translate(10 5) scale(2 .5)"><ellipse cx="2" cy="3" rx="7" ry="2" transform="rotate(30)"/></g>'],
+  ["horizontal skew", '<rect x="2" y="3" width="10" height="10" transform="skewX(45)"/>'],
+  ["vertical skew", '<rect x="2" y="3" width="10" height="10" transform="skewY(-30)"/>'],
+  ["ordinary rectangle", '<rect x="2" y="3" width="10" height="4"/>'],
+  ["ordinary circle", '<circle cx="2" cy="3" r="4"/>'],
+  ["ordinary transformed line", '<line x1="2" y1="3" x2="10" y2="7" transform="rotate(30)"/>'],
+];
+let native;
+const directory = await mkdtemp(join(tmpdir(), "anatomy-affine-bounds-"));
+try {
+  const page = join(directory, "figure.html");
+  await writeFile(page, `<!doctype html><div class="iso-plate"><svg width="400" height="400">${fixtures.map(([,markup],i)=>`<g id="fixture-${i}">${markup}</g>`).join("")}</svg></div>`);
+  const expression = `Array.from({length:${fixtures.length}},(_,i)=>{const group=document.querySelector('#fixture-'+i),shape=group.querySelector('rect,circle,ellipse,line'),matrix=shape.getCTM(),points=[];if(shape.tagName==='rect'){const b=shape.getBBox();for(const [x,y] of [[b.x,b.y],[b.x+b.width,b.y],[b.x+b.width,b.y+b.height],[b.x,b.y+b.height]])points.push(new DOMPoint(x,y).matrixTransform(matrix));}else{const length=shape.getTotalLength();for(let j=0;j<=4096;j++)points.push(shape.getPointAtLength(length*j/4096).matrixTransform(matrix));}const b=group.getBBox();return{geometry:[Math.min(...points.map(p=>p.x)),Math.min(...points.map(p=>p.y)),Math.max(...points.map(p=>p.x)),Math.max(...points.map(p=>p.y))],groupBox:[b.x,b.y,b.x+b.width,b.y+b.height]}})`;
+  const result = await promisify(execFile)(process.execPath, ["scripts/drive.mjs", page, JSON.stringify([["eval",expression]])], { timeout: 30000 });
+  const observations = JSON.parse(result.stdout.match(/eval: (.*)/)[1]);
+  console.log("native SVG group bounds:", JSON.stringify(observations.map(v=>v.groupBox)));
+  native = observations.map(v=>v.geometry);
+} finally { await rm(directory, { recursive: true, force: true }); }
+fixtures.forEach(([name,markup],i)=>test(`public bounds and fixed parts match native SVG geometry for ${name}`,()=>{
+  const expected = native[i];
+  const observed = A.markupBox(markup);
+  for(let j=0;j<4;j++)assert.ok(Math.abs(observed[j]-expected[j])<.002, `${name} bound ${j}: ${observed[j]} != ${expected[j]}`);
+  const T = turning(P);T.layer("figure");
+  const part = T.fixed({name:"authored",svg:markup,anchor:[0,0,0],shapes:[A.ball([0,0,0],20)]});
+  for(let j=0;j<4;j++)assert.ok(Math.abs(part.spec.box[j]-(expected[j]+(j<2?-.5:.5)))<.002);
+}));
+test("coverage rejects a narrow stand-in for a rotated rectangle",()=>{
+  const cam=A.cameraBasis(P);
+  const end=cam.D.map(v=>v*Math.sqrt(200)/cam.k);
+  const standIn=A.tube([[0,0,0],end],.15);
+  const item={name:"plate",svg:fixtures[0][1],shapes:[standIn]};
+  const result=A.coverage([item],P,{pad:0});
+  assert.equal(result.length,1);assert.ok(result[0].share<.1);
+  assert.equal(A.coverage([{...item,shapes:[A.ball([0,0,0],20)]}],P,{pad:0}).length,0);
+});
+test("transformed rectangular clips keep every corner",()=>{
+  const clipped='<defs><clipPath id="cut"><rect width="10" height="10"/></clipPath></defs><g transform="rotate(45)" clip-path="url(#cut)"><rect x="-100" y="-100" width="200" height="200"/></g>';
+  const observed=A.markupBox(clipped),root=Math.sqrt(50);
+  for(const [i,v] of [-root,0,root,2*root].entries())assert.ok(Math.abs(observed[i]-v)<1e-8);
+});

package/skills/axstack-anatomy/scripts/audit-cache.test.mjs

@@ -0,0 +1,37 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import * as A from "../kit/audit.mjs";
+
+function fixture(move = [1, 0, 0]) {
+  return [
+    A.box([0, 0, 0], [2, 2, 2], { name: "moving", move, piece: "moving" }),
+    A.box([1.7, 0.6, 0.6], [2.2, 1.4, 1.4], { name: "fixed" }),
+  ];
+}
+const inspect = (shapes, options = {}) => A.solidClearances(shapes, { state: 1, sunk: 0.05, ...options });
+test("rebuilds the surface grid when the opted-in cell size changes", () => {
+  const shapes = fixture();
+  assert.equal(inspect(shapes, { cell: 0.1 }).length, 1);
+  const cached = inspect(shapes);
+  const fresh = inspect(fixture());
+  assert.equal(cached.length, 1);
+  assert.deepEqual(cached, fresh);
+  assert.ok(Math.abs(cached[0].clearance + 0.8) < 1e-12);
+});
+test("refines surface samples when the opted-in spacing changes", () => {
+  const shapes = fixture(); inspect(shapes, { spacing: 2 });
+  const refined = inspect(shapes, { spacing: 0.1 });
+  const fresh = inspect(fixture(), { spacing: 0.1 });
+  assert.deepEqual(refined, fresh);
+  assert.ok(Math.abs(refined[0].clearance + 0.8) < 1e-12);
+});
+test("preserves repeated default audits of the same moving overlap", () => {
+  const shapes = fixture(); const first = inspect(shapes);
+  assert.equal(first.length, 1); assert.deepEqual(inspect(shapes), first);
+});
+test("keeps a separated motion clear across sampling options", () => {
+  const shapes = fixture([-1, 0, 0]);
+  assert.deepEqual(inspect(shapes, { cell: 0.1 }), []);
+  assert.deepEqual(inspect(shapes), []);
+  assert.deepEqual(inspect(shapes, { spacing: 0.1 }), []);
+});

package/skills/axstack-anatomy/scripts/audit-clearance-envelope.test.mjs

@@ -0,0 +1,39 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import * as A from "../kit/audit.mjs";
+const route = (x, r, name) => A.tube([[x, 0, 0], [x, 0, 200]], r, { name, owner: name });
+const run = (tubes, solids, options = {}) => A.clearances(tubes, solids, { spacing: 10, mounts: new Map(), ...options });
+test("large pipe detects the required clearance to a real solid", () => {
+  const tube = route(0,20,"pipe"),solid = A.ball([29,0,100],1,{name:"solid"});
+  assert.equal(A.sdf(solid,[20,0,100]),8);
+  const result = run([tube],[solid]);
+  assert.equal(result.length,1);assert.equal(result[0].kind,"close");assert.equal(result[0].need,10);assert.ok(Math.abs(result[0].clearance-8)<1e-8);
+});
+test("large parallel pipes detect required clearance in either order", () => {
+  const tubes = [route(0,20,"first"),route(48,20,"second")];
+  for(const input of [tubes,[...tubes].reverse()]){
+    const result = run(input,[]);assert.equal(result.length,1);assert.equal(result[0].need,10);assert.equal(result[0].clearance,8);
+  }
+});
+test("explicit least clearance also controls both broad phases", () => {
+  const tube=route(0,1,"pipe"),solid=A.ball([10,0,100],1,{name:"solid"});
+  assert.equal(run([tube],[solid],{least:10})[0]?.clearance,8);
+  assert.equal(run([tube,route(10,1,"other")],[],{least:10})[0]?.clearance,8);
+});
+test("posed pipes retain their authored required clearance", () => {
+  const tube={...route(0,20,"pipe"),move:[5,0,0],ride:"pipe"};
+  const solid=A.ball([34,0,100],1,{name:"solid"});
+  const result=run([tube],[solid],{state:{shares:{pipe:1},label:"apart"}});
+  assert.equal(result.length,1);assert.equal(result[0].clearance,8);assert.equal(result[0].state,"apart");
+});
+test("healthy gaps, explicit smaller clearance and touch exemptions remain accepted", () => {
+  const tube=route(0,20,"pipe");
+  assert.equal(run([tube],[A.ball([32,0,100],1,{name:"solid"})]).length,0);
+  assert.equal(run([tube],[A.ball([29,0,100],1,{name:"solid"})],{ratio:.1}).length,0);
+  assert.equal(run([{...tube,touch:["solid"]}],[A.ball([29,0,100],1,{name:"solid"})]).length,0);
+  assert.equal(run([tube,route(51,20,"other")],[]).length,0);
+});
+test("existing small penetrating and separated pipes keep their results", () => {
+  assert.equal(run([route(0,1,"first"),route(1.5,1,"second")],[])[0]?.kind,"through");
+  assert.equal(run([route(0,1,"first"),route(4,1,"second")],[]).length,0);
+});

package/skills/axstack-anatomy/scripts/audit-empty-clipping.test.mjs

@@ -0,0 +1,38 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import test from "node:test";
+import * as A from "../kit/audit.mjs";
+import { turning } from "../kit/turn-build.mjs";
+const small='<rect x="2" y="2" width="2" height="2"/>';
+const fixtures=[
+  ["fully disjoint primitive",'<defs><clipPath id="cut"><rect width="10" height="10"/></clipPath></defs><rect x="20" y="20" width="10" height="10" clip-path="url(#cut)"/>'+small],
+  ["nested disjoint clips",'<defs><clipPath id="one"><rect width="10" height="10"/></clipPath><clipPath id="two"><rect x="20" y="20" width="10" height="10"/></clipPath></defs><g clip-path="url(#one)"><g clip-path="url(#two)"><rect width="64" height="64"/></g></g>'+small],
+  ["zero area clip",'<defs><clipPath id="cut"><rect width="0" height="10"/></clipPath></defs><rect width="64" height="64" clip-path="url(#cut)"/>'+small],
+  ["empty declared clip",'<defs><clipPath id="cut"/></defs><rect width="64" height="64" clip-path="url(#cut)"/>'+small],
+  ["ordinary intersecting clip",'<defs><clipPath id="cut"><rect x="2" y="2" width="4" height="4"/></clipPath></defs><rect width="64" height="64" clip-path="url(#cut)"/>'],
+  ["ordinary visible primitives",small+'<rect x="10" y="10" width="4" height="4"/>'],
+  ["fully invisible clipped drawing",'<defs><clipPath id="cut"><rect width="10" height="10"/></clipPath></defs><rect x="20" y="20" width="10" height="10" clip-path="url(#cut)"/>'],
+];
+let pixels;const directory=await mkdtemp(join(tmpdir(),"anatomy-empty-clipping-"));
+try{
+  const page=join(directory,"figure.html");await writeFile(page,'<!doctype html><div class="iso-plate"></div>');
+  const expression=`(async()=>{const fixtures=${JSON.stringify(fixtures.map(([,m])=>m))};const result=[];for(const m of fixtures){const svg='<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64">'+m+'</svg>';const image=new Image();await new Promise((resolve,reject)=>{image.onload=resolve;image.onerror=reject;image.src='data:image/svg+xml;charset=utf-8,'+encodeURIComponent(svg)});const c=document.createElement('canvas');c.width=c.height=64;const ctx=c.getContext('2d');ctx.drawImage(image,0,0);const data=ctx.getImageData(0,0,64,64).data;let box=null;for(let y=0;y<64;y++)for(let x=0;x<64;x++)if(data[(y*64+x)*4+3])box=box?[Math.min(box[0],x),Math.min(box[1],y),Math.max(box[2],x+1),Math.max(box[3],y+1)]:[x,y,x+1,y+1];result.push(box);}return result;})()`;
+  const result=await promisify(execFile)(process.execPath,["scripts/drive.mjs",page,JSON.stringify([["eval",expression]])],{timeout:30000});pixels=JSON.parse(result.stdout.match(/eval: (.*)/)[1]);assert.equal(pixels.length,fixtures.length);
+}finally{await rm(directory,{recursive:true,force:true});}
+const P={origin:[0,0],scale:1,azimuth:45,elevation:30};
+fixtures.forEach(([name,markup],i)=>test(`public clipped bounds match actual native SVG pixels for ${name}`,()=>{
+  assert.deepEqual(A.markupBox(markup),pixels[i]);
+  if(pixels[i]){const T=turning(P);T.layer("figure");const part=T.fixed({name:"fixed",svg:markup,anchor:[0,0,0],shapes:[A.ball([0,0,0],50)]});assert.deepEqual(part.spec.box,pixels[i].map((v,j)=>v+(j<2?-.5:.5)));}
+}));
+test("coverage accepts the true visible plane without an invisible clipped outlier",()=>{
+  const cam=A.cameraBasis(P),F={o:[0,0,0],a:cam.V,u:cam.R,v:cam.D};
+  const shape=A.prism(F,[[2,2],[4,2],[4,4],[2,4]].map(p=>p.map(v=>v/cam.k)),0,.01);
+  assert.deepEqual(A.coverage([{name:"plane",svg:fixtures[0][1],shapes:[shape]}],P),[]);
+});
+test("clipped visible line bounds preserve their degenerate axis",()=>{
+  assert.deepEqual(A.markupBox('<defs><clipPath id="cut"><rect width="10" height="10"/></clipPath></defs><line x1="4" y1="2" x2="4" y2="8" clip-path="url(#cut)"/>'),[4,2,4,8]);
+});

package/skills/axstack-anatomy/scripts/audit-order-convergence.test.mjs

@@ -0,0 +1,55 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import * as A from "../kit/audit.mjs";
+import * as G from "../kit/lathe.mjs";
+const P = { origin: [0, 0], scale: 1, azimuth: 0, elevation: 0 };
+const cam = A.cameraBasis(P);
+const at = (screen, depth) => G.add3(G.mul3(cam.R, screen), G.mul3(cam.V, depth));
+const inspect = (items) => A.overlapsOf(items, P, { step: 0.25, tolerance: 0.01, least: 0.01 });
+const chain = (count) => Array.from({ length: count }, (_, i) => ({ name: `ball${i}`, key: 0, shapes: [A.ball(at(i * 1.5, -i * 0.5), 1)] }));
+const assertRules = (overlaps, solved) => {
+  for (const pair of overlaps.pairs) {
+    const front = pair.front[0].area >= overlaps.least ? pair.a : pair.b;
+    const back = front === pair.a ? pair.b : pair.a;
+    assert.ok(solved.keys[front] - solved.keys[back] >= 0.02 - 1e-9);
+  }
+};
+test("a 410-part acyclic drawn overlap chain converges without losing constraints", () => {
+  const items = chain(410); const overlaps = inspect(items);
+  assert.equal(overlaps.pairs.length, 409);
+  assert.ok(overlaps.pairs.every((p) => p.front[0].area >= overlaps.least && p.front[1].area < overlaps.least));
+  const solved = A.orderKeys(items, overlaps);
+  assert.deepEqual(solved.dropped, []);
+  assert.deepEqual(solved.cycles, []);
+  assertRules(overlaps, solved);
+});
+test("an explicit final-round budget does not invent a victim once all rules are satisfied", () => {
+  const items = chain(10); const overlaps = inspect(items);
+  const solved = A.orderKeys(items, overlaps, { rounds: 9 });
+  assert.deepEqual(solved.dropped, []);
+  assertRules(overlaps, solved);
+});
+test("small acyclic figures preserve the existing zero-drop solution", () => {
+  const items = chain(10); const overlaps = inspect(items); const solved = A.orderKeys(items, overlaps);
+  assert.deepEqual(solved.dropped, []);
+  assertRules(overlaps, solved);
+  assert.ok(Math.abs(solved.keys[0] - 0.18) < 1e-12);
+});
+test("an actual three-item geometric cycle still drops its weakest conflicting rule", () => {
+  const items = [
+    { name: "a", key: 0, shapes: [A.ball(at(0, 3), 1), A.ball(at(20, 0), 1)] },
+    { name: "b", key: 0, shapes: [A.ball(at(0, 0), 1), A.ball(at(10, 3), 1)] },
+    { name: "c", key: 0, shapes: [A.ball(at(10, 0), 1), A.ball(at(20, 3), 1)] },
+  ];
+  const overlaps = inspect(items); assert.equal(overlaps.pairs.length, 3);
+  const solved = A.orderKeys(items, overlaps);
+  assert.equal(solved.rules, 3);
+  assert.equal(solved.dropped.length, 1);
+  assert.equal(solved.cycles.length, 0);
+  for (const pair of overlaps.pairs) {
+    const front = pair.front[0].area >= overlaps.least ? pair.a : pair.b;
+    const back = front === pair.a ? pair.b : pair.a;
+    if (solved.dropped.some((rule) => rule.front === front && rule.back === back)) continue;
+    assert.ok(solved.keys[front] - solved.keys[back] >= 0.02 - 1e-9);
+  }
+});

package/skills/axstack-anatomy/scripts/audit-path-origin.test.mjs

@@ -0,0 +1,26 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import test from "node:test";
+import { markupBox } from "../kit/audit.mjs";
+
+const execute = promisify(execFile);
+for (const [name, markup] of [
+  ["relative move after closing a subpath", '<path d="M10 10L20 10L20 20Z m5 0l2 0"/>'],
+  ["transformed relative move after closing a subpath", '<g transform="translate(5 3)"><path d="M10 10L20 10L20 20Z m5 0l2 0"/></g>'],
+  ["absolute move after closing a subpath", '<path d="M10 10L20 10L20 20Z M15 10L17 10"/>'],
+  ["open relative segments", '<path d="M10 10l10 0l0 10m5 0l2 0"/>'],
+]) test(`audit bounds match actual native SVG for ${name}`, async () => {
+  const directory = await mkdtemp(join(tmpdir(), "anatomy-audit-path-origin-"));
+  try {
+    const page = join(directory, "figure.html");
+    await writeFile(page, `<!doctype html><div class="iso-plate"><svg width="100" height="100" viewBox="0 0 100 100">${markup}</svg></div>`);
+    const actions = JSON.stringify([["eval", "(()=>{const b=document.querySelector('svg').getBBox();return [b.x,b.y,b.x+b.width,b.y+b.height]})()"]]);
+    const result = await execute(process.execPath, ["scripts/drive.mjs", page, actions], { timeout: 30000 });
+    const native = JSON.parse(result.stdout.match(/eval: (.*)/)[1]);
+    assert.deepEqual(markupBox(markup), native);
+  } finally { await rm(directory, { recursive: true, force: true }); }
+});

package/skills/axstack-anatomy/scripts/audit-profile.test.mjs

@@ -0,0 +1,41 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import * as A from "../kit/audit.mjs";
+import * as G from "../kit/lathe.mjs";
+const F = G.frameAlong([0, 0, 0], [0, 0, 1]);
+const radius = (s) => 2 + Math.sin(2 * Math.PI * s / 10);
+const slope = (s) => Math.cos(2 * Math.PI * s / 10) * 2 * Math.PI / 10;
+const profile = [[0, 2], [10, 2]];
+const radialAt = (points, s) => {
+  const index = points.findIndex((p) => p[0] >= s);
+  if (!index) return points[0][1];
+  const [a, ra] = points[index - 1]; const [b, rb] = points[index];
+  return ra + (rb - ra) * (s - a) / (b - a);
+};
+test("inflected analytic recording follows the actual band side geometry", () => {
+  const bands = G.bandsOf(profile, [], F, { origin: [0, 0], scale: 10 }, { radius, slope });
+  const recorded = A.traced(profile, { radius });
+  const actual = bands.sidesOf().points.flat();
+  const bulge = actual.filter((p) => Math.abs(p[2] - 2.5) < 1e-8);
+  assert.equal(bulge.length, 2);
+  for (const p of bulge) assert.ok(Math.abs(radialAt(recorded, p[2]) - Math.hypot(p[0], p[1])) <= 0.02);
+});
+test("analytic tracing keeps bulge points inside the recorded solid", () => {
+  assert.ok(A.sdf(A.solid(F, profile, { radius }), [0, 2.5, 2.5]) < 0);
+});
+test("analytic tracing keeps neck points outside the recorded solid", () => {
+  assert.ok(A.sdf(A.solid(F, profile, { radius }), [0, 1.5, 7.5]) > 0);
+});
+test("smooth Hermite inflection retains its quarter-span curvature", () => {
+  const knots = [[0, 2, 1], [1, 2, 1], [2, 3, 1], [3, 3, 1]];
+  const curve = G.profileCurve(knots);
+  assert.ok(Math.abs(radialAt(A.traced(knots), 1.25) - curve.radius(1.25)) <= 0.02);
+  assert.ok(Math.abs(radialAt(A.traced(knots), 1.75) - curve.radius(1.75)) <= 0.02);
+});
+test("constant and linear radius controls keep their exact two endpoints", () => {
+  assert.deepEqual(A.traced([[0, 2], [10, 2]], { radius: () => 2 }), [[0, 2], [10, 2]]);
+  assert.deepEqual(A.traced([[0, 1], [10, 3]], { radius: (s) => 1 + s / 5 }), [[0, 1], [10, 3]]);
+});
+test("explicit zero recursion depth retains the requested coarse profile", () => {
+  assert.deepEqual(A.traced(profile, { radius, depth: 0 }), profile);
+});

package/skills/axstack-anatomy/scripts/audit-projection.test.mjs

@@ -0,0 +1,36 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import * as A from "../kit/audit.mjs";
+const projection = (azimuth, elevation, scale = 1) => ({ origin: [0, 0], scale, azimuth, elevation });
+const options = { step: 0.5, tolerance: 0.1, least: 0.25 };
+const fixture = () => [{ name: "body", key: 0, shapes: [A.cylinder(0, 0, 2, 0, 10)] }, { name: "probe", key: 0, shapes: [A.ball([1.5, 0, 5], 1)] }];
+for (const [name, before, after] of [
+  ["azimuth reversal", projection(45, 30), projection(180, 30)],
+  ["elevation change", projection(45, 30), projection(45, 60)],
+  ["side view to oblique", projection(0, 0), projection(45, 30)],
+]) test(`reused body ray geometry matches a fresh build after ${name}`, () => {
+  const items = fixture();
+  A.overlapsOf(items, before, options);
+  const reused = A.overlapsOf(items, after, options);
+  const fresh = A.overlapsOf(fixture(), after, options);
+  assert.equal(fresh.pairs.length, 1);
+  assert.deepEqual(reused, fresh);
+});
+test("azimuth reversal retains the physically nearer body in the key solver", () => {
+  const items = fixture();
+  A.overlapsOf(items, projection(45, 30), options);
+  const solved = A.orderKeys(items, A.overlapsOf(items, projection(180, 30), options));
+  assert.equal(solved.cycles.length, 0);
+  assert.ok(solved.keys[0] > solved.keys[1]);
+});
+test("repeated identical projections keep identical depth results", () => {
+  const items = fixture(); const P = projection(45, 30);
+  const first = A.overlapsOf(items, P, options);
+  assert.equal(first.pairs.length, 1);
+  assert.deepEqual(A.overlapsOf(items, P, options), first);
+});
+test("scale and origin changes keep the unchanged camera direction valid", () => {
+  const items = fixture(); A.overlapsOf(items, projection(45, 30), options);
+  const P = { ...projection(45, 30, 2), origin: [20, 30] };
+  assert.deepEqual(A.overlapsOf(items, P, options), A.overlapsOf(fixture(), P, options));
+});

package/skills/axstack-anatomy/scripts/audit-slide-clearance.test.mjs

@@ -0,0 +1,58 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import * as A from "../kit/audit.mjs";
+import * as G from "../kit/lathe.mjs";
+const P = { origin: [0, 0], scale: 1, azimuth: 45, elevation: 30 };
+const F = G.frameAlong([0, 0, 0], [0, 0, 1]);
+function scene(axis = [0, 0, 1]) {
+  const frame = G.frameAlong([0, 0, 0], axis);
+  const move = G.mul3(axis, 8);
+  const rod = A.slide(frame, 0, 2, 1, { name: "piston", move, piece: "piston" });
+  const obstacle = A.disc(frame, 6, 8, 2, { name: "obstacle" });
+  const drawn = G.rodOut(frame, 0, 2, 1, P, { stroke: 8 });
+  assert.equal(drawn.reach, 10);
+  assert.ok(drawn.paths.fill.length > 0 && drawn.clip.length > 0);
+  return { rod, obstacle, frame };
+}
+for (const axis of [[0, 0, 1], [1, 0, 0]]) test(`native solid clearance checks an extending rod along ${axis}`, () => {
+  const { rod, obstacle, frame } = scene(axis);
+  const state = { label: "stroke", shares: { piston: 1 } };
+  const posed = A.moved(rod, A.offsetOf(rod, state));
+  const inside = G.add3(frame.o, G.mul3(frame.a, 7));
+  assert.equal(posed.slide.to, 10);
+  assert.ok(A.sdf(posed, inside) < -0.9 && A.sdf(obstacle, inside) < -0.9);
+  const result = A.solidClearances([rod, obstacle], { state, spacing: 0.2, sunk: 0.2 });
+  assert.equal(result.length, 1);
+  assert.equal(result[0].tube, "piston");
+  assert.equal(result[0].other, "obstacle");
+  assert.equal(result[0].state, "stroke");
+  assert.ok(result[0].clearance < -0.9);
+});
+test("native recorder audit reports an extending rod with a stationary obstacle in either input order", () => {
+  const { rod, obstacle } = scene();
+  for (const shapes of [[rod, obstacle], [obstacle, rod]]) {
+    const R = A.recorder(P, { order: ["piston"] });
+    for (const shape of shapes) R.solid(shape);
+    const result = A.audit(R, P, { frames: [], apart: true });
+    assert.equal(result.apart.length, 1);
+    assert.ok(result.apart[0].clearance <= -0.5);
+    assert.ok(A.failures(result) > 0);
+  }
+});
+test("native solid clearance preserves rest, intermediate and retracted rod controls", () => {
+  const { rod, obstacle } = scene();
+  for (const state of [0, 0.4, -0.1]) assert.deepEqual(A.solidClearances([rod, obstacle], { state, spacing: 0.2, sunk: 0.2 }), []);
+});
+test("native solid clearance preserves translated solid penetration detection", () => {
+  const { obstacle } = scene();
+  const moving = A.ball([0, 0, 1], 1, { name: "moving", move: [0, 0, 6] });
+  const result = A.solidClearances([moving, obstacle], { state: 1, spacing: 0.2, sunk: 0.2 });
+  assert.equal(result.length, 1);
+  assert.ok(result[0].clearance < -0.9);
+});
+test("native sliding clearance preserves a seated host exemption", () => {
+  const { rod, obstacle } = scene();
+  rod.seated = true;
+  rod.cut = obstacle;
+  assert.deepEqual(A.solidClearances([rod, obstacle], { state: 1, spacing: 0.2, sunk: 0.2 }), []);
+});

package/skills/axstack-anatomy/scripts/audit-svg-attributes.test.mjs

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import test from "node:test";
+import * as A from "../kit/audit.mjs";
+import { turning } from "../kit/turn-build.mjs";
+const P={origin:[0,0],scale:1,azimuth:45,elevation:30};
+const fixtures=[
+  ["single quoted rectangle", "<rect x='10' y='20' width='30' height='40'/>"],
+  ["spaces around attribute equals", '<rect x = "10" y = "20" width = "30" height = "40"/>'],
+  ["single quoted nested transform", "<g transform = 'translate(5 3)'><path d='M10 10L20 10L20 20Z'/></g>"],
+  ["numeric XML path references", '<path d="M&#49;0 &#x32;0L40 20L40 60Z"/>'],
+  ["numeric XML transform references", '<g transform="translate(&#49;0 5)"><circle cx="10" cy="10" r="5"/></g>'],
+  ["mixed attribute quotes and multiline path", "<path d='M10 20\nL40 20L40 60Z' transform=\"translate(2 3)\"/>"],
+  ["single quoted ellipse", "<ellipse cx='10' cy='20' rx='4' ry='2'/>"],
+  ["quoted attribute text is not geometry", `<rect data-label="x='99'" x='10' y='20' width='30' height='40'/>`],
+  ["quoted greater-than delimiter", `<rect data-label='a > b' x="10" y="20" width="30" height="40"/>`],
+  ["quoted less-than delimiter", `<rect data-label="a &lt; b" x='10' y='20' width='30' height='40'/>`],
+  ["ordinary double quoted rectangle", '<rect x="10" y="20" width="30" height="40"/>'],
+  ["ordinary transformed circle", '<g transform="translate(2 3)"><circle cx="10" cy="10" r="5"/></g>'],
+];
+let native;const directory=await mkdtemp(join(tmpdir(),"anatomy-svg-attributes-"));
+try{
+  const page=join(directory,"figure.html");await writeFile(page,`<!doctype html><div class="iso-plate"><svg width="100" height="100">${fixtures.map(([,m],i)=>`<g id="f${i}">${m}</g>`).join("")}</svg></div>`);
+  const expression=`Array.from({length:${fixtures.length}},(_,i)=>{const b=document.querySelector('#f'+i).getBBox();return[b.x,b.y,b.x+b.width,b.y+b.height]})`;
+  const result=await promisify(execFile)(process.execPath,["scripts/drive.mjs",page,JSON.stringify([["eval",expression]])],{timeout:30000});native=JSON.parse(result.stdout.match(/eval: (.*)/)[1]);
+}finally{await rm(directory,{recursive:true,force:true});}
+fixtures.forEach(([name,markup],i)=>test(`public SVG bounds and fixed parts decode ${name}`,()=>{
+  assert.deepEqual(A.markupBox(markup),native[i]);
+  const T=turning(P);T.layer("figure");const part=T.fixed({name:"fixed",svg:markup,anchor:[0,0,0],shapes:[A.ball([0,0,0],50)]});
+  assert.deepEqual(part.spec.box,native[i].map((v,j)=>v+(j<2?-.5:.5)));
+}));
+test("coverage rejects a stand-in for single quoted real geometry",()=>{
+  const item={name:"quoted",svg:fixtures[0][1],shapes:[A.ball([0,0,0],.1)]};assert.equal(A.coverage([item],P).length,1);
+  assert.equal(A.coverage([{...item,shapes:[A.ball([0,0,0],50)]}],P).length,0);
+});
+test("quoted and escaped clip identifiers retain authored clipping",()=>{
+  const markup="<defs><clipPath id = 'cut&amp;1'><rect x='2' y='3' width='4' height='5'/></clipPath></defs><rect width='100' height='100' clip-path = 'url(#cut&amp;1)'/>";
+  assert.deepEqual(A.markupBox(markup),[2,3,6,8]);
+});
+test("quoted halo class remains excluded from authored bounds",()=>{
+  assert.deepEqual(A.markupBox("<circle class = 'iso-halo' cx='50' cy='50' r='40'/><rect x='2' y='3' width='4' height='5'/>"),[2,3,6,8]);
+});

package/skills/axstack-anatomy/scripts/audit-taper.test.mjs

@@ -0,0 +1,29 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import * as A from "../kit/audit.mjs";
+
+const taper = () => A.tube([[0, 0, 0], [10, 0, 0]], t => 1 + 2 * t);
+const close = (actual, expected) => assert.ok(Math.abs(actual - expected) < 1e-12, `${actual} differs from ${expected}`);
+test("the narrow portion of a taper does not invent a collision", () => {
+  close(A.sdf(taper(), [1, 2, 0]), 0.8 / Math.sqrt(1.04));
+});
+test("the wide portion of a taper does not hide a collision", () => {
+  close(A.sdf(taper(), [9, 2.5, 0]), -0.3 / Math.sqrt(1.04));
+});
+test("the actual conical surface has zero signed distance", () => {
+  close(A.sdf(taper(), [1, 1.2, 0]), 0);
+});
+test("taper distance follows a rotated and translated tube frame", () => {
+  const shape = A.tube([[5, 3, 2], [5, 13, 2]], [1, 3]);
+  close(A.sdf(shape, [7, 4, 2]), 0.8 / Math.sqrt(1.04));
+});
+test("constant-radius cylinders retain their sides, caps and interior", () => {
+  const shape = A.tube([[0, 0, 0], [10, 0, 0]], 2);
+  close(A.sdf(shape, [5, 3, 0]), 1);
+  close(A.sdf(shape, [-1, 0, 0]), 1);
+  close(A.sdf(shape, [5, 0, 0]), -2);
+});
+test("taper end caps keep their true radii", () => {
+  close(A.sdf(taper(), [-1, 0, 0]), 1);
+  close(A.sdf(taper(), [11, 0, 0]), 1);
+});

package/skills/axstack-anatomy/scripts/capture-selector.test.mjs

@@ -0,0 +1,131 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { access, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import test from "node:test";
+
+const execute = promisify(execFile);
+
+async function capture(selector, svgOnly = false, keys = false) {
+  const directory = await mkdtemp(join(tmpdir(), "anatomy-capture-target-"));
+  try {
+    const page = join(directory, "figure.html");
+    const out = join(directory, "capture.png");
+    const content = svgOnly
+      ? '<svg width="80" height="40" xmlns="http://www.w3.org/2000/svg"><rect width="80" height="40" fill="green"/></svg>'
+      : `<div class="iso-plate" tabindex="0" id="first" style="width:100px;height:80px;background:blue"><span data-readout>first:0</span></div><div class="iso-plate" tabindex="0" id="second" style="width:60px;height:40px;background:red"><span data-readout>second:0</span></div><script>for(const plate of document.querySelectorAll('.iso-plate'))plate.addEventListener('keydown',e=>{if(e.key==='ArrowRight')plate.querySelector('[data-readout]').textContent=plate.id+':1'})</script>`;
+    await writeFile(page, '<!doctype html><style>body{margin:20px}</style>' + content);
+    const args = ["scripts/capture.mjs", page, "--out", out, "--wait", "0", "--scale", "1"];
+    if (selector !== undefined) args.push("--select", selector);
+    if (keys) args.push("--key", "ArrowRight");
+    let result;
+    try {
+      result = { code: 0, ...await execute(process.execPath, args, { timeout: 30000 }) };
+    } catch (error) {
+      result = { code: error.code, stdout: error.stdout, stderr: error.stderr };
+    }
+    let png;
+    try {
+      await access(out);
+      png = await readFile(out);
+    } catch {}
+    return { ...result, png };
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+}
+
+function dimensions(png) {
+  assert.ok(png);
+  assert.equal(png.subarray(1, 4).toString(), "PNG");
+  return [png.readUInt32BE(16), png.readUInt32BE(20)];
+}
+
+test("an absent explicit figure selector fails without an unrelated screenshot", async () => {
+  const result = await capture("#removed-figure");
+  assert.equal(result.code, 1);
+  assert.match(result.stderr, /Capture target not found: #removed-figure/);
+  assert.equal(result.png, undefined);
+  assert.doesNotMatch(result.stdout, /saved /);
+});
+
+test("a malformed explicit selector retains an actionable capture diagnostic", async () => {
+  const result = await capture("[invalid");
+  assert.equal(result.code, 1);
+  assert.match(result.stderr, /Capture target not found: \[invalid/);
+  assert.equal(result.png, undefined);
+});
+
+test("a matching selector captures the requested second figure", async () => {
+  const result = await capture("#second");
+  assert.equal(result.code, 0, result.stderr);
+  assert.deepEqual(dimensions(result.png), [72, 52]);
+  assert.match(result.stdout, /60x40/);
+});
+
+test("default selection retains the first plate", async () => {
+  const result = await capture(undefined);
+  assert.equal(result.code, 0, result.stderr);
+  assert.deepEqual(dimensions(result.png), [112, 92]);
+  assert.match(result.stdout, /100x80/);
+});
+
+test("default selection retains the standalone SVG fallback", async () => {
+  const result = await capture(undefined, true);
+  assert.equal(result.code, 0, result.stderr);
+  assert.deepEqual(dimensions(result.png), [92, 52]);
+  assert.match(result.stdout, /80x40/);
+});
+
+test("an explicit target reports that figure's readout", async () => {
+  const result = await capture("#second");
+  assert.equal(result.code, 0, result.stderr);
+  assert.match(result.stdout, /readout "second:0"/);
+});
+
+test("keyboard interaction reaches the explicitly selected figure", async () => {
+  const result = await capture("#second", false, true);
+  assert.equal(result.code, 0, result.stderr);
+  assert.match(result.stdout, /readout "second:1"/);
+  assert.deepEqual(dimensions(result.png), [72, 52]);
+});
+
+async function driveTarget(actions, standaloneLines = false) {
+  const directory=await mkdtemp(join(tmpdir(),"anatomy-drive-target-"));
+  try{
+    const page=join(directory,"figure.html"),out=join(directory,"selected.png"),file=join(directory,"actions.json");
+    const svg='<svg width="60" height="40" viewBox="0 0 60 40"><rect x="10" y="10" width="30" height="20" fill="none" stroke="black"/><path class="iso-line" d="M10 20L40 20" fill="none" stroke="black"/></svg>';
+    await writeFile(page,`<!doctype html><style>body{margin:20px}</style><div class="iso-plate" id="first" tabindex="0" style="width:100px;height:80px"><span data-readout>first:0</span>${svg}</div><div class="iso-plate" id="second" tabindex="0" style="width:60px;height:40px"><span data-readout>second:0</span>${svg}</div><script>for(const el of document.querySelectorAll('.iso-plate'))el.addEventListener('keydown',event=>{if(event.key==='ArrowRight')el.querySelector('[data-readout]').textContent=el.id+':1'})</script>`);
+    await writeFile(file,JSON.stringify(actions.map(action=>action.map(value=>value==='OUTPUT'?out:value))));
+    const args=standaloneLines?["scripts/lines.mjs",page,"--select","#missing","--wait","0"]:["scripts/drive.mjs",page,"--actions",file];
+    let result;try{result={code:0,...await execute(process.execPath,args,{timeout:30000})};}catch(error){result={code:error.code,stdout:error.stdout,stderr:error.stderr};}
+    let png;try{png=await readFile(out);}catch{}return{...result,png};
+  }finally{await rm(directory,{recursive:true,force:true});}
+}
+for(const [name,action] of [
+  ["shot",["shot","OUTPUT","#missing"]],
+  ["move",["move","#missing",.5,.5]],
+  ["click",["click","#missing"]],
+  ["drag",["drag","#missing",0,0,1,1]],
+  ["scroll",["scroll","#missing"]],
+  ["key",["key","ArrowRight","#missing"]],
+  ["lines",["lines",null,"#missing"]],
+])test(`drive ${name} rejects an absent explicit target instead of continuing`,async()=>{
+  const result=await driveTarget([action,["eval","'after missing target'"]]);assert.equal(result.code,1,result.stdout);assert.match(result.stderr,/(Drive|Line) target not found: #missing/);assert.doesNotMatch(result.stdout,/after missing target/);assert.equal(result.png,undefined);
+});
+test("standalone lines rejects an absent selected figure",async()=>{
+  const result=await driveTarget([],true);assert.equal(result.code,1,result.stdout);assert.match(result.stderr,/Line target not found: #missing/);
+});
+test("drive targets the requested figure for keyboard input screenshot and reported readout",async()=>{
+  const result=await driveTarget([["key","ArrowRight","#second"],["shot","OUTPUT","#second"],["eval","document.querySelector('#first [data-readout]').textContent"]]);
+  assert.equal(result.code,0,result.stderr);assert.match(result.stdout,/readout "second:1"/);assert.match(result.stdout,/eval: "first:0"/);assert.deepEqual(dimensions(result.png),[68,48]);
+});
+test("drive defaults preserve first-figure keyboard focus and reporting",async()=>{
+  const result=await driveTarget([["key","ArrowRight"],["shot","OUTPUT"],["eval","document.querySelector('#second [data-readout]').textContent"]]);
+  assert.equal(result.code,0,result.stderr);assert.match(result.stdout,/readout "first:1"/);assert.match(result.stdout,/eval: "second:0"/);assert.deepEqual(dimensions(result.png),[108,88]);
+});
+test("line selection preserves real rooted-line checks on the requested SVG",async()=>{
+  const result=await driveTarget([["lines",null,"#second svg"]]);assert.equal(result.code,0,result.stderr);assert.match(result.stdout,/line ends: 0 of [1-9]\d* ends on [1-9]\d* lines float/);
+});