axstack 0.36.1 → 0.38.0

package/skills/axstack-anatomy/scripts/turn-fidelity.mjs

@@ -0,0 +1,413 @@
+import * as k from "../kit/iso-kit.mjs";
+import * as G from "../kit/lathe.mjs";
+import { tubePieces } from "../kit/tube.mjs";
+import { TURN } from "../kit/turn.mjs";
+
+const rootOf = (group) => {
+  let root = group;
+  while (root && root.parent) root = root.parent;
+  return root && root.kind === "turn" ? root : null;
+};
+const restValues = (T, theta) => Object.fromEntries(T.groups.map((g) => [g.name, g.kind === "turn" && !g.parent ? theta : g.kind === "free" ? null : 0]));
+
+export function identity(T, P, angles, { plant = null } = {}) {
+  const scene = TURN.prepare(T.data, { unit: 1 });
+const subpaths = (d) => {
+    const out = [];
+    for (const [, body] of (d ?? "").matchAll(/M([^M]*)/g)) {
+      const nums = (body.match(/-?\d+(?:\.\d+)?(?:e-?\d+)?/g) ?? []).map(Number);
+      const pts = [];
+      for (let i = 0; i + 1 < nums.length; i += 2) pts.push([nums[i], nums[i + 1]]);
+      out.push({ pts, closed: /Z\s*$/.test(body) });
+    }
+    return out;
+  };
+  const segDist = (p, a, b) => {
+    const dx = b[0] - a[0];
+    const dy = b[1] - a[1];
+    const l = dx * dx + dy * dy;
+    const t = l ? Math.max(0, Math.min(1, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / l)) : 0;
+    return Math.hypot(p[0] - a[0] - dx * t, p[1] - a[1] - dy * t);
+  };
+  const toPoly = (pts, closed) => (pts, closed);
+  void toPoly;
+  const distToPoly = (p, poly, closed = true) => {
+    let best = Infinity;
+    const n = poly.length;
+    for (let i = 0; i < (closed ? n : n - 1); i++) best = Math.min(best, segDist(p, poly[i], poly[(i + 1) % n]));
+    if (n === 1) best = Math.hypot(p[0] - poly[0][0], p[1] - poly[0][1]);
+    return best;
+  };
+  const oneWay = (A, B) => {
+    let worst = 0;
+    for (const p of A) {
+      let near = null;
+      let gap = Infinity;
+      for (const q of B) {
+        const g = Math.hypot(p[0] - q[0], p[1] - q[1]);
+        if (g < gap) {
+          gap = g;
+          near = q;
+        }
+      }
+      worst = Math.max(worst, gap < 0.15 ? Math.max(Math.abs(p[0] - near[0]), Math.abs(p[1] - near[1])) : distToPoly(p, B));
+    }
+    return worst;
+  };
+  const hausdorff = (A, B) => Math.max(oneWay(A, B), oneWay(B, A));
+  const applyMatrix = (pts, t) => {
+    const v = (t.match(/-?\d+(?:\.\d+)?(?:e-?\d+)?/g) ?? []).map(Number);
+    return pts.map(([x, y]) => [v[0] * x + v[2] * y + v[4], v[1] * x + v[3] * y + v[5]]);
+  };
+  const levelOf = (score, bands) => {
+    let u = 0;
+    for (const t of bands) {
+      const x = Math.min(1, Math.max(0, (score - (t - 0.035)) / 0.07));
+      u += x * x * (3 - 2 * x);
+    }
+    return u;
+  };
+  
+  
+const results = { outline: 0, top: 0, faces: 0, compared: 0, skipped: 0, missing: 0, crease: 0 };
+const worstAt = {};
+for (const theta of angles) {
+  const cams = TURN.cams(scene, restValues(T, theta));
+  const Pp = { ...P, azimuth: P.azimuth - theta };
+  for (const part of T.parts) {
+    if (part.kind !== "prism" || !rootOf(part.group) || part.group.kind === "free") continue;
+    const planted = plant && part.name === plant;
+    const run = scene.runs[part.id];
+    const cam = part.group ? cams[part.group.index] : cams.world;
+    const f = TURN.emit(run, cam, TURN.frame(run));
+    let root = part.group;
+    while (root && root.parent) root = root.parent;
+    const pivot = root ? [root.origin[0], root.origin[1], 0] : [0, 0, 0];
+    const a = k.iso(pivot, P);
+    const b = k.iso(pivot, Pp);
+    const shift = [a[0] - b[0], a[1] - b[1]];
+    const sh = (pts) => pts.map(([x, y]) => [x + shift[0], y + shift[1]]);
+    const { F, ring, s0, s1 } = part.world;
+    const up = run.up;
+    const Pk = planted ? { ...Pp, azimuth: Pp.azimuth - 2 } : Pp;
+    const kit = up ? k.extrude(ring, s0, s1 - s0, Pk) : G.prismOf(F, ring, s0, s1, Pk);
+    const cut = Boolean(part.spec.cuts?.length);
+    const mine = subpaths(f.d[run.role[cut ? "fill" : "edge"]])[0].pts;
+    const theirs = sh(subpaths(kit.fill)[0].pts);
+    const visible = cut ? oneWay(subpaths(f.d[run.role.edge]).flatMap((path) => path.pts), theirs) : 0;
+    const ho = Math.max(hausdorff(mine, theirs), visible);
+    results.outline = Math.max(results.outline, ho);
+    if (ho > (worstAt[part.name]?.outline ?? -1)) worstAt[part.name] = { ...(worstAt[part.name] ?? {}), outline: ho, at: theta };
+    if (up) {
+      const topMine = applyMatrix(subpaths(part.planPath)[0].pts, f.t[run.role.top]);
+      const topKit = sh(subpaths(kit.top)[0].pts);
+      results.top = Math.max(results.top, hausdorff(topMine, topKit));
+    }
+    const kitFaces = kit.shades.map((d) => subpaths(d)).concat(up ? [] : [subpaths(kit.top)]);
+    const faceCount = up ? run.n : run.n + 2;
+    for (let i = 0; i < faceCount; i++) {
+      const role = run.role[`f${i}`];
+      const d = f.d[role];
+      if (!d) continue;
+      const q = f.q[role];
+      if (q % TURN.q !== 0) {
+        results.skipped++;
+        continue;
+      }
+      const tone = q / TURN.q;
+      const pts = subpaths(d)[0].pts;
+      let best = Infinity;
+      for (const sp of kitFaces[tone] ?? []) best = Math.min(best, hausdorff(pts, sh(sp.pts)));
+      if (!Number.isFinite(best)) {
+        results.missing++;
+        continue;
+      }
+      results.compared++;
+      results.faces = Math.max(results.faces, best);
+    }
+  }
+}
+
+  const limit = 0.06;
+  const pass = results.outline <= limit && results.top <= limit && results.faces <= limit && results.missing === 0;
+  const worst = Object.entries(worstAt).filter(([, w]) => w.outline > limit).map(([name, w]) => `${name} outline ${w.outline.toFixed(3)} at ${w.at}°`);
+  return { pass, text: `prisms at ${angles.length} angles: outline ${results.outline.toFixed(4)} px · top ${results.top.toFixed(4)} px · faces ${results.faces.toFixed(4)} px over ${results.compared} faces (${results.skipped} in crossfade windows, ${results.missing} with no kit face of that tone)`, worst };
+}
+
+export function rounds(T, P, angles, { only = null } = {}) {
+  const scene = TURN.prepare(T.data, { unit: 1 });
+  const CELL = 0.1;
+const subpaths = (d) => {
+    const out = [];
+    for (const [, body] of (d ?? "").matchAll(/M([^M]*)/g)) {
+      const nums = (body.match(/-?\d+(?:\.\d+)?(?:e-?\d+)?/g) ?? []).map(Number);
+      const pts = [];
+      for (let i = 0; i + 1 < nums.length; i += 2) pts.push([nums[i], nums[i + 1]]);
+      out.push(pts);
+    }
+    return out;
+  };
+  const segDist = (p, a, b) => {
+    const dx = b[0] - a[0];
+    const dy = b[1] - a[1];
+    const l = dx * dx + dy * dy;
+    const t = l ? Math.max(0, Math.min(1, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / l)) : 0;
+    return Math.hypot(p[0] - a[0] - dx * t, p[1] - a[1] - dy * t);
+  };
+  const distToPoly = (p, poly) => {
+    let best = Infinity;
+    for (let i = 0; i < poly.length; i++) best = Math.min(best, segDist(p, poly[i], poly[(i + 1) % poly.length]));
+    return best;
+  };
+  const hausdorff = (A, B) => {
+    let worst = 0;
+    for (const p of A) worst = Math.max(worst, distToPoly(p, B));
+    for (const p of B) worst = Math.max(worst, distToPoly(p, A));
+    return worst;
+  };
+  function raster(layers, box, grow = 0) {
+    const [x0, y0, x1, y1] = box;
+    const w = Math.ceil((x1 - x0) / CELL) + 1;
+    const h = Math.ceil((y1 - y0) / CELL) + 1;
+    const out = new Int8Array(w * h).fill(-1);
+    for (const { tone, d } of layers) {
+      if (!d) continue;
+      const mask = new Uint8Array(w * h);
+      const polys = subpaths(d);
+      for (let row = 0; row < h; row++) {
+        const y = y0 + row * CELL + CELL / 2;
+        const hits = [];
+        for (const poly of polys)
+          for (let i = 0; i < poly.length; i++) {
+            const a = poly[i];
+            const b = poly[(i + 1) % poly.length];
+            if ((a[1] <= y && b[1] > y) || (b[1] <= y && a[1] > y)) {
+              const x = a[0] + ((y - a[1]) / (b[1] - a[1])) * (b[0] - a[0]);
+              hits.push([x, b[1] > a[1] ? 1 : -1]);
+            }
+          }
+        hits.sort((p, q) => p[0] - q[0]);
+        let wind = 0;
+        for (let i = 0; i < hits.length - 1; i++) {
+          wind += hits[i][1];
+          if (!wind) continue;
+          const from = Math.max(0, Math.ceil((hits[i][0] - x0 - CELL / 2) / CELL));
+          const to = Math.min(w - 1, Math.floor((hits[i + 1][0] - x0 - CELL / 2) / CELL));
+          for (let c = from; c <= to; c++) mask[row * w + c] = 1;
+        }
+      }
+      const reach = Math.round(grow / CELL);
+      for (let row = 0; row < h; row++)
+        for (let c = 0; c < w; c++) {
+          let on = mask[row * w + c];
+          for (let dy = -reach; dy <= reach && !on; dy++)
+            for (let dx = -reach; dx <= reach && !on; dx++) {
+              if (dx * dx + dy * dy > reach * reach) continue;
+              const rr = row + dy;
+              const cc = c + dx;
+              if (rr >= 0 && cc >= 0 && rr < h && cc < w && mask[rr * w + cc]) on = 1;
+            }
+          if (on) out[row * w + c] = tone;
+        }
+    }
+    return { out, w, h };
+  }
+  
+const stats = { outline: 0, outlineFine: 0, bands: 0, cells: 0, mismatched: 0, parts: 0 };
+const worst = [];
+for (const theta of angles) {
+  const cams = TURN.cams(scene, restValues(T, theta));
+  const Pp = { ...P, azimuth: P.azimuth - theta };
+  const Pf = { ...Pp, origin: [Pp.origin[0] * 10, Pp.origin[1] * 10], scale: Pp.scale * 10 };
+  for (const part of T.parts) {
+    if ((part.kind !== "round" && part.kind !== "lathe") || (only && !only.test(part.name)) || !rootOf(part.group) || part.group.kind === "free") continue;
+    const run = scene.runs[part.id];
+    const cam = part.group ? cams[part.group.index] : cams.world;
+    const f = TURN.emit(run, cam, TURN.frame(run));
+    let root = part.group;
+    while (root && root.parent) root = root.parent;
+    const pivot = root ? [root.origin[0], root.origin[1], 0] : [0, 0, 0];
+    const a = k.iso(pivot, P);
+    const b = k.iso(pivot, Pp);
+    const shift = [a[0] - b[0], a[1] - b[1]];
+    let F, s0, s1, r0, r1, ends, profile;
+    if (part.kind === "lathe") {
+      const { curve, knots } = part.world;
+      F = part.world.F;
+      s0 = curve.s0;
+      s1 = curve.s1;
+      r0 = curve.radius(s0);
+      r1 = curve.radius(s1);
+      ends = ["flat", "flat"];
+      profile = [[s0, r0], ...knots.slice(1, -1).map((sv) => [sv, curve.radius(sv), 1]), [s1, r1]];
+    } else ({ F, s0, s1, r0, r1, ends, profile } = part.world);
+    const meridian = [...(ends[0] === "open" ? [] : [[profile[0][0], 0]]), ...profile.filter((p) => p[1] > 1e-9), ...(ends[1] === "open" ? [] : [[profile[profile.length - 1][0], 0]])];
+    const domed = ends.includes("dome");
+    const radius = (s) => {
+      if (ends[0] === "dome" && s < s0) return Math.sqrt(Math.max(0, r0 * r0 - (s - s0) ** 2));
+      if (ends[1] === "dome" && s > s1) return Math.sqrt(Math.max(0, r1 * r1 - (s - s1) ** 2));
+      return r0 + ((r1 - r0) * (Math.max(s0, Math.min(s1, s)) - s0)) / (s1 - s0);
+    };
+    const slope = (s) => {
+      if (ends[0] === "dome" && s < s0) return -(s - s0) / Math.max(1e-4, radius(s));
+      if (ends[1] === "dome" && s > s1) return -(s - s1) / Math.max(1e-4, radius(s));
+      return (r1 - r0) / (s1 - s0);
+    };
+    const lo = ends[0] === "dome" ? s0 - r0 : s0;
+    const hi = ends[1] === "dome" ? s1 + r1 : s1;
+    const knots = [];
+    for (let i = 0; i <= 64; i++) knots.push(lo + ((hi - lo) * i) / 64);
+    const analytic = [[lo, 0], ...knots.slice(1, -1).map((sv) => [sv, radius(sv), 1]), [hi, 0]];
+    if (ends[0] !== "dome") analytic.splice(1, 0, [lo, r0]);
+    if (ends[1] !== "dome") analytic.splice(analytic.length - 1, 0, [hi, r1]);
+    const lathed = part.kind === "lathe" ? { slope: part.world.curve.slope, radius: part.world.curve.radius } : null;
+    const kit = lathed ? G.lathe(meridian, F, Pp, { smooth: lathed }) : domed ? G.lathe(analytic, F, Pp, { smooth: { slope, radius } }) : G.lathe(meridian, F, Pp, { smooth: true });
+    const kitFine = lathed ? G.lathe(meridian, F, Pf, { smooth: lathed }) : domed ? G.lathe(analytic, F, Pf, { smooth: { slope, radius } }) : G.lathe(meridian, F, Pf, { smooth: true });
+    const sh = (pts) => pts.map(([x, y]) => [x + shift[0], y + shift[1]]);
+    const cut = Boolean(part.spec.cuts?.length);
+    const mine = subpaths(f.d[run.role[cut ? "fill" : "edge"]])[0];
+    const theirs = sh(subpaths(kit.fill)[0]);
+    const fineRef = subpaths(kitFine.fill)[0].map(([x, y]) => [x / 10 + shift[0], y / 10 + shift[1]]);
+    const ho = hausdorff(mine, theirs);
+    const visible = cut ? subpaths(f.d[run.role.edge]).flat().reduce((worst, point) => Math.max(worst, distToPoly(point, fineRef)), 0) : 0;
+    const hf = Math.max(hausdorff(mine, fineRef), visible);
+    stats.outline = Math.max(stats.outline, ho);
+    stats.outlineFine = Math.max(stats.outlineFine, hf);
+    stats.parts++;
+    const ours = [0, 1, 2, 3, 4].map((t) => ({ tone: t, d: f.d[run.role[`s${t}`]] }));
+    for (const end of [0, 1]) {
+      const role = run.role[`k${end}`];
+      if (role === undefined || !f.d[role]) continue;
+      const q = f.q[role];
+      ours.push({ tone: q % TURN.q === 0 ? q / TURN.q : 9, d: f.d[role] });
+    }
+    const theirsLayers = [...kitFine.shades.map((d, t) => ({ tone: t, d })), { tone: 4, d: kitFine.top }].map(({ tone, d }) => ({ tone, d: subpaths(d).map((poly) => "M" + poly.map(([x, y]) => `${x / 10 + shift[0]} ${y / 10 + shift[1]}`).join("L") + "Z").join("") }));
+    let x0 = Infinity;
+    let y0 = Infinity;
+    let x1 = -Infinity;
+    let y1 = -Infinity;
+    for (const [x, y] of mine) {
+      x0 = Math.min(x0, x);
+      y0 = Math.min(y0, y);
+      x1 = Math.max(x1, x);
+      y1 = Math.max(y1, y);
+    }
+    const box = [x0 - 1, y0 - 1, x1 + 1, y1 + 1];
+    const A = raster(ours, box, 0.2);
+    const B = raster(theirsLayers, box, 0.2);
+    const inside = raster([{ tone: 1, d: f.d[run.role.edge] }], box).out;
+    const capCells = raster([0, 1].map((end) => ({ tone: 1, d: run.role[`k${end}`] !== undefined ? f.d[run.role[`k${end}`]] : "" })), box, 0.6).out;
+    const capExempt = part.kind === "lathe";
+    const insideKit = raster([{ tone: 1, d: "M" + fineRef.map(([x, y]) => `${x} ${y}`).join("L") + "Z" }], box).out;
+    let worstGap = 0;
+    const reach = Math.ceil(0.5 / CELL) + 2;
+    for (let row = 0; row < A.h; row++)
+      for (let c = 0; c < A.w; c++) {
+        const i = row * A.w + c;
+        if (inside[i] < 0 || insideKit[i] < 0) continue;
+        const ta = A.out[i];
+        const tb = B.out[i];
+        if (ta === 9 || ta < 0 || tb < 0) continue;
+        if (capExempt && capCells[i] >= 0) continue;
+        stats.cells++;
+        if (ta === tb) continue;
+        let edge = false;
+        for (let dy = -3; dy <= 3 && !edge; dy++) for (let dx = -3; dx <= 3; dx++) if (inside[(row + dy) * A.w + c + dx] < 0) edge = true;
+        if (edge) continue;
+        stats.mismatched++;
+        let near = Infinity;
+        for (let dy = -reach; dy <= reach; dy++)
+          for (let dx = -reach; dx <= reach; dx++) {
+            const rr = row + dy;
+            const cc = c + dx;
+            if (rr < 0 || cc < 0 || rr >= A.h || cc >= A.w) continue;
+            if (B.out[rr * A.w + cc] === ta) near = Math.min(near, Math.hypot(dx, dy) * CELL);
+          }
+        worstGap = Math.max(worstGap, near);
+      }
+    stats.bands = Math.max(stats.bands, worstGap);
+    if (worstGap > 0.5 || hf > 0.05) worst.push({ part: part.name, theta, band: worstGap, outline: hf });
+  }
+}
+
+  return { pass: stats.outlineFine <= 0.05 && stats.bands <= 0.5, text: `rounds: ${stats.parts} frames at ${angles.length} angles: outline vs kit ${stats.outline.toFixed(4)} px (kit rounds to 0.1), vs kit at 10x ${stats.outlineFine.toFixed(4)} px · band boundaries ≤ ${stats.bands.toFixed(2)} px apart (${stats.mismatched} of ${stats.cells} interior cells differ)`, worst: worst.sort((a, b) => b.band - a.band || b.outline - a.outline).slice(0, 12).map((w) => `${w.part} at ${w.theta}°: outline ${w.outline.toFixed(3)} px, band ${w.band.toFixed(2)} px`) };
+}
+
+export function tubes(T, P, angles) {
+  const scene = TURN.prepare(T.data, { unit: 1 });
+const subpaths = (d) => [...(d ?? "").matchAll(/M([^M]*)/g)].map(([, body]) => {
+    const nums = (body.match(/-?\d+(?:\.\d+)?(?:e-?\d+)?/g) ?? []).map(Number);
+    const pts = [];
+    for (let i = 0; i + 1 < nums.length; i += 2) pts.push([nums[i], nums[i + 1]]);
+    return pts;
+  });
+  const segDist = (p, a, b) => {
+    const dx = b[0] - a[0], dy = b[1] - a[1], l = dx * dx + dy * dy;
+    const t = l ? Math.max(0, Math.min(1, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / l)) : 0;
+    return Math.hypot(p[0] - a[0] - dx * t, p[1] - a[1] - dy * t);
+  };
+  const compare = (mine, theirs) => {
+    const A = subpaths(mine);
+    const B = subpaths(theirs);
+    if (A.length !== B.length) return { error: Infinity, why: `subpaths ${A.length} vs ${B.length}` };
+    let worst = 0;
+    for (let i = 0; i < A.length; i++) {
+      if (A[i].length === B[i].length) for (let j = 0; j < A[i].length; j++) worst = Math.max(worst, Math.abs(A[i][j][0] - B[i][j][0]), Math.abs(A[i][j][1] - B[i][j][1]));
+      else {
+        for (const [from, to] of [[A[i], B[i]], [B[i], A[i]]]) for (const p of from) worst = Math.max(worst, Math.min(...to.slice(1).map((q, j) => segDist(p, to[j], q))));
+      }
+    }
+    return { error: worst };
+  };
+  
+const stats = { body: 0, shine: 0, shade: 0, edges: 0, rings: 0, chunks: 0 };
+const bad = [];
+for (const theta of angles) {
+  const cams = TURN.cams(scene, restValues(T, theta));
+  const Pp = { ...P, azimuth: P.azimuth - theta };
+  const Pf = { ...Pp, origin: [Pp.origin[0] * 10, Pp.origin[1] * 10], scale: Pp.scale * 10 };
+  for (const route of T.routes) {
+    if (route.group && (!rootOf(route.group) || route.group.kind === "free")) continue;
+    const root = rootOf(route.group);
+    const pivot = root ? [root.origin[0], root.origin[1], 0] : [0, 0, 0];
+    const a = k.iso(pivot, P);
+    const b = k.iso(pivot, Pp);
+    const shift = [a[0] - b[0], a[1] - b[1]];
+    const kit = tubePieces(route.world, route.r, Pf, { maxLength: route.chunk, spacing: route.spacing, gaps: route.gaps, breaks: route.breaks, caps: route.caps, stripes: route.wide, rings: route.rings });
+    const scaled = (d) => subpaths(d).map((pts) => "M" + pts.map(([x, y]) => `${x / 10 + shift[0]} ${y / 10 + shift[1]}`).join("L")).join("");
+    const chunks = T.parts.filter((part) => part.route === route.name);
+    if (kit.length !== chunks.length) {
+      bad.push(`${route.name}: ${chunks.length} chunks vs kit ${kit.length}`);
+      continue;
+    }
+    chunks.forEach((part, index) => {
+      const run = scene.runs[part.id];
+      const f = TURN.emit(run, route.group ? cams[route.group.index] : cams.world, TURN.frame(run));
+      const piece = kit[index];
+      stats.chunks++;
+      for (const key of ["body", "shine", "shade", "edges"]) {
+        if (run.role[key] === undefined) continue;
+        const { error, why } = compare(f.d[run.role[key]], scaled(piece[key]));
+        stats[key] = Math.max(stats[key], error);
+        if (error > 0.05) bad.push(`${part.name} ${key} at ${theta}°: ${why ?? error.toFixed(3)}`);
+      }
+      if (route.rings) {
+        const mine = run.roles.filter((role) => role.name.startsWith("r")).map((role) => f.d[run.role[role.name]]).join("");
+        const theirs = scaled(piece.rings.filter((ring) => ring.alpha * 32 >= 0.5).map((ring) => ring.d).join(""));
+        const A = subpaths(mine);
+        const B = subpaths(theirs);
+        let worst = A.length === B.length ? 0 : Infinity;
+        for (const seg of A) {
+          let best = Infinity;
+          for (const other of B) best = Math.min(best, Math.max(...seg.map((p, j) => Math.hypot(p[0] - other[j][0], p[1] - other[j][1]))));
+          worst = Math.max(worst, best);
+        }
+        stats.rings = Math.max(stats.rings, worst);
+        if (worst > 0.05) bad.push(`${part.name} rings at ${theta}°: ${A.length} vs ${B.length} segments, worst ${worst.toFixed(3)}`);
+      }
+    });
+  }
+}
+
+  return { pass: !bad.length, text: `tubes: ${stats.chunks} chunk frames at ${angles.length} angles against tubePieces at 10x: body ${stats.body.toFixed(4)} · shine ${stats.shine.toFixed(4)} · shade ${stats.shade.toFixed(4)} · edges ${stats.edges.toFixed(4)} · rings ${stats.rings.toFixed(4)} px`, worst: bad.slice(0, 20) };
+}

package/skills/axstack-anatomy/scripts/turn-group-reference.test.mjs

@@ -0,0 +1,40 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { turning } from "../kit/turn-build.mjs";
+import { identity } from "./turn-fidelity.mjs";
+const P = { origin: [0, 0], scale: 1, azimuth: 45, elevation: 30 };
+const fixture = () => { const T = turning(P); T.layer("parts"); return T; };
+const prism = (T, group) => T.prism({ name: "pointer", group, plan: { x: 0, y: 0, w: 4, d: 2, r: 0 }, z: 0, h: 1 });
+test("missing named part groups cannot silently pass as static geometry", () => {
+  const T = fixture(); T.group("dial", { turn: {} });
+  assert.throws(() => { prism(T, "dail"); T.build(); identity(T, P, [0, 90]); }, /turning: unknown group dail/);
+  assert.equal(T.parts.length, 0);
+});
+test("missing named parent groups cannot silently root nested motion", () => {
+  const T = fixture(); T.group("dial", { turn: {} });
+  assert.throws(() => T.group("slide", { parent: "dail", slide: { direction: [1, 0, 0], travel: 5 } }), /turning: unknown group dail/);
+  assert.equal(T.groups.length, 1);
+});
+test("duplicate group names cannot alias incompatible motion values", () => {
+  const T = fixture(); T.group("dial", { turn: {} });
+  assert.throws(() => T.group("dial", { slide: { direction: [1, 0, 0], travel: 5 } }), /turning: duplicate group dial/);
+  assert.equal(T.groups.length, 1);
+});
+test("existing named and object group references retain native fidelity", () => {
+  for (const named of [false, true]) {
+    const T = fixture(); const group = T.group("dial", { turn: {} });
+    const part = prism(T, named ? "dial" : group);
+    const child = T.group("slide", { parent: named ? "dial" : group, slide: { direction: [1, 0, 0], travel: 5 } });
+    assert.equal(part.group, group); assert.equal(child.parent, group);
+    T.build(); const result = identity(T, P, [0, 90]);
+    assert.equal(result.pass, true);
+    assert.match(result.text, /over [1-9]\d* faces/);
+  }
+});
+test("omitted and explicit null groups keep supported static geometry", () => {
+  for (const group of [undefined, null]) {
+    const T = fixture(); const part = prism(T, group);
+    assert.equal(part.group, null);
+    T.build(); assert.equal(T.parts.length, 1);
+  }
+});

package/skills/axstack-anatomy/scripts/turn-split-owner.test.mjs

@@ -0,0 +1,62 @@
+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";
+import { turning } from "../kit/turn-build.mjs";
+import { TURN } from "../kit/turn.mjs";
+import { posed } from "../kit/turn-audit.mjs";
+function fixture(kind, owner = "pipe") {
+  const T = turning({ origin: [0, 0], scale: 1, azimuth: 45, elevation: 30 }); T.layer("all");
+  const group = T.group("assembly", { turn: { pivot: [5, 2] } });
+  const F = G.frameAlong([0, 0, 0], [0, 0, 1]);
+  const base = { name: "ferrule", owner, group, F, s0: 0, s1: 10 };
+  const part = kind === "prism" ? T.prism({ ...base, polygon: [[-2, -2], [2, -2], [2, 2], [-2, 2]] }) : T.round({ ...base, r: 2, ...(kind === "default round" ? {} : { fixed: false }) });
+  const tube = A.tube([[0, 0, -2], [0, 0, 12]], 0.5, { name: "pipe", owner: "pipe" });
+  return { T, part, tube };
+}
+for (const kind of ["prism", "round", "default round"]) test(`split ${kind} preserves explicit ownership and its pipe clearance`, () => {
+  const { T, part, tube } = fixture(kind);
+  assert.deepEqual(A.clearances([tube], part.shapes), []);
+  const halves = T.split(part, { n: [0, 0, 1], d: 5 });
+  assert.equal(halves.length, 2);
+  assert.ok(halves.every((half) => half.owner === "pipe" && half.shapes.every((shape) => shape.owner === "pipe")));
+  assert.deepEqual(A.clearances([tube], halves.flatMap((half) => half.shapes)), []);
+  T.build();
+  const scene = TURN.prepare(T.data, { unit: 1 });
+  for (const angle of [0, 45, 90, 180]) {
+    const cams = TURN.cams(scene, { assembly: angle });
+    const group = T.groups[0];
+    const pose = { R: cams[group.index].R, t: cams[group.index].t, origin: group.origin };
+    const shapes = halves.flatMap((half) => half.shapes.map((shape) => posed(shape, pose)));
+    const original = posed(part.shapes[0], pose);
+    assert.deepEqual(A.clearances([posed(tube, pose)], shapes), []);
+    for (const z of [2.5, 7.5]) {
+      const a = angle * Math.PI / 180;
+      const point = [5 - 4 * Math.cos(a) + 2 * Math.sin(a), 2 - 4 * Math.sin(a) - 2 * Math.cos(a), z];
+      const distance = Math.min(...shapes.map((shape) => A.sdf(shape, point)));
+      assert.ok(distance < 0);
+      assert.ok(Math.abs(distance - A.sdf(original, point)) < 1e-8);
+    }
+    for (const run of scene.runs) {
+      const frame = TURN.emit(run, cams[run.group], TURN.frame(run));
+      assert.ok(frame.d.some((path) => typeof path === "string" && path.length));
+    }
+  }
+});
+test("an unrelated pipe still reports real penetration of split fittings", () => {
+  for (const kind of ["prism", "round", "default round"]) {
+    const { T, part, tube } = fixture(kind, "other");
+    const halves = T.split(part, { n: [0, 0, 1], d: 5 });
+    const failures = A.clearances([tube], halves.flatMap((half) => half.shapes));
+    assert.equal(failures.length, 2);
+    assert.ok(failures.every((failure) => failure.kind === "through" && failure.clearance < 0));
+  }
+});
+test("unowned split parts retain normal collision checking", () => {
+  for (const kind of ["prism", "round", "default round"]) {
+    const { T, part, tube } = fixture(kind, null);
+    const halves = T.split(part, { n: [0, 0, 1], d: 5 });
+    assert.ok(halves.every((half) => !half.owner && half.shapes.every((shape) => !shape.owner)));
+    assert.equal(A.clearances([tube], halves.flatMap((half) => half.shapes)).length, 2);
+  }
+});

package/skills/axstack-anatomy/theme.js

@@ -0,0 +1,56 @@
+// Inject these exact bytes after the anatomy build's inline kit script.
+function installAnatomyTheme({ doc = document, view = window, resolveColor } = {}) {
+  const body = doc.body;
+  const media = view.matchMedia('(prefers-color-scheme: dark)');
+  // Canvas delegates every supported CSS color syntax to the browser, in sRGB.
+  const color = resolveColor ?? ((value) => {
+    const canvas = doc.createElement('canvas');
+    canvas.width = canvas.height = 1;
+    const context = canvas.getContext('2d', { willReadFrequently: true });
+    context.fillStyle = value;
+    context.fillRect(0, 0, 1, 1);
+    return context.getImageData(0, 0, 1, 1).data;
+  });
+  if (!doc.getElementById('axstack-anatomy-theme')) {
+    const style = doc.createElement('style');
+    style.id = 'axstack-anatomy-theme';
+    style.textContent = `
+body.iso[data-axstack-t3] { margin:0; padding:0; background:transparent;
+  --anatomy-page:transparent; --anatomy-mono:var(--font-mono);
+  color:var(--foreground); font-family:var(--font-sans); }
+body.iso[data-axstack-t3] .iso-page { margin:0; padding:0; width:100%; max-width:none; min-height:0; background:none; }
+body.iso[data-axstack-t3] .iso-plate { padding:16px; border-radius:var(--radius); }
+`;
+    doc.head.appendChild(style);
+  }
+  const update = () => {
+    const background = view.getComputedStyle(doc.documentElement).getPropertyValue('--background').trim();
+    const marker = body.getAttribute('data-axstack-theme');
+    let dark = media.matches;
+    if (background) {
+      const rgba = color(background);
+      const alpha = rgba[3] / 255;
+      const channel = (index) => {
+        const value = (rgba[index] * alpha + 255 * (1 - alpha)) / 255;
+        return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+      };
+      dark = 0.2126 * channel(0) + 0.7152 * channel(1) + 0.0722 * channel(2) < 0.5;
+      if (body.getAttribute('data-axstack-t3') === null) body.setAttribute('data-axstack-t3', '');
+    } else body.removeAttribute('data-axstack-t3');
+    const theme = marker === 'dark' || marker === 'light' ? marker : dark ? 'dark' : 'light';
+    if (body.getAttribute('data-theme') !== theme) body.setAttribute('data-theme', theme);
+    // Override the kit's dark root scheme so transparent iframe pages follow the frame.
+    if (doc.documentElement.style.colorScheme !== theme) doc.documentElement.style.colorScheme = theme;
+  };
+  update();
+  media.addEventListener('change', update);
+  const observer = new view.MutationObserver(update);
+  observer.observe(doc.documentElement, {
+    attributes: true, attributeFilter: ['class', 'style', 'data-axstack-theme'] });
+  observer.observe(body, { attributes: true, attributeFilter: ['data-axstack-theme'] });
+  observer.observe(doc.head, { subtree: true, childList: true, characterData: true,
+    attributes: true, attributeFilter: ['media', 'disabled'] });
+  return () => { media.removeEventListener('change', update); observer.disconnect(); };
+}
+
+if (typeof document !== 'undefined') installAnatomyTheme();

package/skills/axstack-explain/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: axstack-explain
-description: When the user asks how, why, explain, or show, says they do not understand, a spec is being finalized, or you judge they need to understand something, use axstack-explain to show how it works and what exists, is missing, or remains unverified.
+description: When the user asks how, why, explain, or show, asks to diagram, visualize, draw or defend, requests a whiteboard defense, says they do not understand, a spec is being finalized, or you judge they need to understand something, use axstack-explain to show how it works and what exists, is missing, or remains unverified.
 ---
 
 # Explain
@@ -12,6 +12,7 @@ Explain a system, change, current behavior, intended behavior, or implementation
 gap from inspected evidence. This direct route needs no spec ceremony. Use
 project documentation as evidence where relevant. It supersedes `axstack-docs`; if a stale install
 exposes both skills, route the request here only.
+For a stale `axstack-diagram` install, route requests here only.
 
 Before acting, load [Standing contracts](../axstack/references/contracts.md),
 then follow its required lifecycle and audit pointers. Explanation work has no
@@ -51,9 +52,21 @@ immediately before an actual profile dispatch.
 
 ## 2. Choose proportional output
 
-Load [Diagram](../axstack-diagram/SKILL.md) for every diagram.
 Explain owns evidence gathering, claim labels, the 700-word cap, dispatch, and delivery.
-Diagram never calls explain.
+Choose the best visual for the concept: flowchart, sequence, state, architecture
+map, timeline, comparison or bespoke SVG are examples, not a taxonomy.
+Follow [Fidelity](references/fidelity.md) for every visual.
+For whole-work understanding or defense, follow [Whiteboard defense](references/whiteboard-defense.md).
+Dispatch every visual Explain delivers to `axstack-explainer` with a bounded
+evidence brief, including inline pages, chat Mermaid and anatomy figures.
+Plain-prose answers stay driver-written; other phases retain their own Mermaid
+owners, and README/docs diagram edits go through Implement under these rules.
+Use inline SVG or CSS inside inline pages. Never use Mermaid in inline pages.
+Use Mermaid for chat, GitHub, and docs.
+Include `accTitle` and `accDescr` in each Mermaid view.
+Never use theme init in Mermaid. Split large Mermaid diagrams into views.
+Use anatomy only on an explicit isometric, physical-object or anatomy request,
+through [Anatomy](../axstack-anatomy/SKILL.md).
 
 1. Keep the primary reader-facing explanation to a maximum of 700 words in
    chat, HTML, and every other requested format. Preserve in that primary view
@@ -67,18 +80,13 @@ Diagram never calls explain.
    maximum. If the draft is longer, compress repetition first and move only
    supporting detail to a separate linked ticket or appendix. Essential answers
    must not be hidden behind links, and evidence must not be silently discarded.
-   Only archify node detail cards are exempt from the 700-word cap.
-   Each card has at most 40 words and cites its source, as defined in
-   [Archify](../axstack-diagram/references/archify.md).
-   Count node labels, headings, captions, and all non-card text.
+   Count node labels, headings, captions, and all page text.
 2. Use chat only for an explicit chat request, an answer outside the description's conditions,
    or inline-page fallback.
    Use a compact diagram when useful.
-   For chat answers, never dispatch an agent when applying its Mermaid rules inline.
 3. For the conditions in the description, create an inline page by default.
    Honor an explicitly requested artifact format.
-   Use archify only on an explicit viewer request, through the configured
-   `axstack-explainer`. The reply adds only what the page omits.
+   The reply adds only what the page omits.
 4. Profile IDs are presets, not availability proof. Before dispatch, follow the
    launch sequence and preserve the configured model, mode, and effort. Report
    an unavailable route; never substitute a model.
@@ -86,16 +94,18 @@ Diagram never calls explain.
 ## 3. Verify and deliver
 
 1. For inline pages, follow [Inline pages](references/inline-pages.md).
-   For archify and every other explicitly requested HTML or visual artifact
+   For every explicitly requested HTML or visual artifact
    outside inline T3 pages, follow [Visual QA](references/visual-qa.md).
 2. Require independent `axstack-explainer-review` for consequential or complex
-   claims, archify output, or on request.
+   claims or on request.
+   The `axstack-explainer-review` always reviews every visual at its exact final
+   bytes before delivery.
    Consequential claims include gap or missing-claim reports, blast-radius
-   safety facts, and spec readbacks.
+   safety facts, spec readbacks, and every whiteboard-defense explanation in chat too.
    Bind it to the exact artifact identity.
    Any byte change invalidates
    that review and requires a fresh check. In `claude-only`, separate Sonnet
-   author high and reviewer high sessions are allowed for explanations as
+   author high and reviewer high sessions are allowed for explanations and every visual as
    session independence only. This exception never permits same-model code
    review or a cross-provider-independence claim.
 3. Report source, tests, rendered observations, independent review, and
@@ -103,6 +113,9 @@ Diagram never calls explain.
 4. For a public artifact, remove private paths, identifiers, prompts,
    credentials, messages, and internal records. Local creation does not grant
    authority to publish.
-5. Deliver the smallest useful explanation. Explanation causes no automatic
+5. Follow [Delivery](references/delivery.md) for fallback and repair holds.
+   Deliver the smallest useful explanation. Explanation causes no automatic
    design and no automatic implementation; route later change work separately
    only when the user requests it.
+
+Ideas: [archify](https://github.com/tt-a1i/archify), [diagram-design](https://github.com/cathrynlavery/diagram-design), [visual-explainer](https://github.com/nicobailon/visual-explainer), [Matt Pocock](https://github.com/mattpocock/skills), and [poteto](https://github.com/poteto/how); guidance uses Axstack's own words.