axstack 0.36.1 → 0.38.0

package/skills/axstack-anatomy/scripts/line-ends.mjs

@@ -0,0 +1,306 @@
+function lineEnds({ select = null, tolerance = 1, root: rootSlack = 2, mark = 7, least = 0.3, cover = 0.5, show = false } = {}) {
+  const plate = select == null ? document.querySelector(".iso-plate") || document.body : document.querySelector(select);
+  if (!plate) throw new Error(`Line target not found: ${select}`);
+  const box = plate.getBoundingClientRect();
+  const style = document.createElement("style");
+  style.textContent = `${select || ".iso-plate"} *{pointer-events:none!important}${select || ".iso-plate"} svg,${select || ".iso-plate"} svg *{pointer-events:visiblePainted!important}`;
+  document.head.append(style);
+  const skipClass = ["iso-edge", "iso-bevel", "iso-crease", "tb-edge"];
+  const svgs = [...(plate.matches("svg") ? [plate] : []), ...plate.querySelectorAll("svg")];
+  const shapes = svgs.flatMap((svg) => [...svg.querySelectorAll("path, line, polyline, polygon, circle, ellipse, rect")]).filter((el) => !el.closest("defs, clipPath, mask, pattern, marker, symbol"));
+  const opacityOf = (el) => {
+    let alpha = 1;
+    for (let node = el; node && node.nodeType === 1; node = node.parentElement) {
+      const cs = getComputedStyle(node);
+      if (cs.display === "none") return 0;
+      alpha *= Number(cs.opacity);
+      if (node === plate) break;
+    }
+    return getComputedStyle(el).visibility === "hidden" ? 0 : alpha;
+  };
+  const numbers = (text) => (text.match(/-?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?/gi) || []).map(Number);
+  const subpathsOf = (d) => {
+    const out = [];
+    let current = null;
+    let x = 0;
+    let y = 0;
+    let sx = 0;
+    let sy = 0;
+    let control = null;
+    const push = (px, py) => {
+      current.points.push([px, py]);
+      x = px;
+      y = py;
+    };
+    const start = (px, py) => {
+      current = { points: [[px, py]], closed: false };
+      out.push(current);
+      x = sx = px;
+      y = sy = py;
+    };
+    const cubic = (x1, y1, x2, y2, px, py) => {
+      const x0 = x;
+      const y0 = y;
+      for (let i = 1; i <= 8; i++) {
+        const t = i / 8;
+        const u = 1 - t;
+        push(u * u * u * x0 + 3 * u * u * t * x1 + 3 * u * t * t * x2 + t * t * t * px, u * u * u * y0 + 3 * u * u * t * y1 + 3 * u * t * t * y2 + t * t * t * py);
+      }
+      control = { kind: "cubic", point: [x2, y2] };
+    };
+    const quad = (x1, y1, px, py) => {
+      const x0 = x;
+      const y0 = y;
+      for (let i = 1; i <= 6; i++) {
+        const t = i / 6;
+        const u = 1 - t;
+        push(u * u * x0 + 2 * u * t * x1 + t * t * px, u * u * y0 + 2 * u * t * y1 + t * t * py);
+      }
+      control = { kind: "quadratic", point: [x1, y1] };
+    };
+    for (const [, command, args] of d.matchAll(/([MmLlHhVvCcSsQqTtAaZz])([^MmLlHhVvCcSsQqTtAaZz]*)/g)) {
+      const v = numbers(args);
+      const rel = command === command.toLowerCase();
+      const C = command.toUpperCase();
+      const ox = () => (rel ? x : 0);
+      const oy = () => (rel ? y : 0);
+      if (C === "Z") {
+        if (current) {
+          current.closed = true;
+          push(sx, sy);
+        }
+        current = null;
+        continue;
+      }
+      if (C === "M") {
+        for (let i = 0; i + 1 < v.length; i += 2) {
+          if (i === 0) start(v[0] + ox(), v[1] + oy());
+          else push(v[i] + ox(), v[i + 1] + oy());
+        }
+        control = null;
+        continue;
+      }
+      if (!current) start(x, y);
+      if (C === "L") for (let i = 0; i + 1 < v.length; i += 2) push(v[i] + ox(), v[i + 1] + oy());
+      else if (C === "H") for (const value of v) push(value + ox(), y);
+      else if (C === "V") for (const value of v) push(x, value + oy());
+      else if (C === "C") for (let i = 0; i + 5 < v.length; i += 6) cubic(v[i] + ox(), v[i + 1] + oy(), v[i + 2] + ox(), v[i + 3] + oy(), v[i + 4] + ox(), v[i + 5] + oy());
+      else if (C === "S")
+        for (let i = 0; i + 3 < v.length; i += 4) {
+          const reflected = control?.kind === "cubic" ? [2 * x - control.point[0], 2 * y - control.point[1]] : [x, y];
+          cubic(reflected[0], reflected[1], v[i] + ox(), v[i + 1] + oy(), v[i + 2] + ox(), v[i + 3] + oy());
+        }
+      else if (C === "Q") for (let i = 0; i + 3 < v.length; i += 4) quad(v[i] + ox(), v[i + 1] + oy(), v[i + 2] + ox(), v[i + 3] + oy());
+      else if (C === "T")
+        for (let i = 0; i + 1 < v.length; i += 2) {
+          const reflected = control?.kind === "quadratic" ? [2 * x - control.point[0], 2 * y - control.point[1]] : [x, y];
+          quad(reflected[0], reflected[1], v[i] + ox(), v[i + 1] + oy());
+        }
+      else if (C === "A") {
+        const arc = document.createElementNS("http://www.w3.org/2000/svg", "path");
+        arc.setAttribute("d", `M${x} ${y}${command}${args}`);
+        const length = arc.getTotalLength();
+        const count = Math.max(8, Math.ceil(length / 2));
+        for (let index = 1; index <= count; index++) {
+          const point = arc.getPointAtLength(length * index / count);
+          push(point.x, point.y);
+        }
+      }
+      if (C !== "C" && C !== "S" && C !== "Q" && C !== "T") control = null;
+    }
+    return out;
+  };
+  const geometryOf = (el) => {
+    const tag = el.tagName.toLowerCase();
+    const num = (name) => Number(el.getAttribute(name) || 0);
+    if (tag === "path") return subpathsOf(el.getAttribute("d") || "");
+    if (tag === "line") return [{ points: [[num("x1"), num("y1")], [num("x2"), num("y2")]], closed: false }];
+    if (tag === "polyline" || tag === "polygon") {
+      const v = numbers(el.getAttribute("points") || "");
+      const points = [];
+      for (let i = 0; i + 1 < v.length; i += 2) points.push([v[i], v[i + 1]]);
+      if (tag === "polygon" && points.length) points.push(points[0]);
+      return [{ points, closed: tag === "polygon" }];
+    }
+    if (tag === "rect") {
+      const [x, y, w, h] = [num("x"), num("y"), num("width"), num("height")];
+      const rx = Math.min(w / 2, Math.max(0, el.hasAttribute("rx") ? num("rx") : num("ry")));
+      const ry = Math.min(h / 2, Math.max(0, el.hasAttribute("ry") ? num("ry") : num("rx")));
+      if (!rx || !ry) return [{ points: [[x, y], [x + w, y], [x + w, y + h], [x, y + h], [x, y]], closed: true }];
+      const points = [];
+      for (const [cx, cy, start] of [[x + w - rx, y + ry, -Math.PI / 2], [x + w - rx, y + h - ry, 0], [x + rx, y + h - ry, Math.PI / 2], [x + rx, y + ry, Math.PI]]) {
+        for (let index = 0; index <= 32; index++) {
+          const angle = start + index * Math.PI / 64;
+          points.push([cx + rx * Math.cos(angle), cy + ry * Math.sin(angle)]);
+        }
+      }
+      points.push(points[0]);
+      return [{ points, closed: true }];
+    }
+    return [];
+  };
+  const cell = 6;
+  const grid = new Map();
+  const add = (gx, gy, entry) => {
+    const id = `${gx},${gy}`;
+    if (!grid.has(id)) grid.set(id, []);
+    grid.get(id).push(entry);
+  };
+  const lines = [];
+  let scale = 1;
+  for (const el of shapes) {
+    const cs = getComputedStyle(el);
+    const alpha = opacityOf(el);
+    if (alpha < 0.1) continue;
+    const ctm = el.getScreenCTM();
+    if (!ctm) continue;
+    const map = ([px, py]) => [ctm.a * px + ctm.c * py + ctm.e, ctm.b * px + ctm.d * py + ctm.f];
+    const tag = el.tagName.toLowerCase();
+    const stroked = cs.stroke !== "none" && parseFloat(cs.strokeWidth) > 0 && Number(cs.strokeOpacity) > 0.05;
+    const filled = cs.fill !== "none" && Number(cs.fillOpacity) > 0.05;
+    if (tag === "circle" || tag === "ellipse") {
+      if (!stroked && !filled) continue;
+      const cx = Number(el.getAttribute("cx") || 0);
+      const cy = Number(el.getAttribute("cy") || 0);
+      const rx = Number(el.getAttribute(tag === "circle" ? "r" : "rx") || 0);
+      const ry = Number(el.getAttribute(tag === "circle" ? "r" : "ry") || 0);
+      if (rx <= 0 || ry <= 0) continue;
+      const points = Array.from({ length: 128 }, (_, index) => {
+        const angle = index * Math.PI * 2 / 128;
+        return map([cx + rx * Math.cos(angle), cy + ry * Math.sin(angle)]);
+      });
+      const entry = { el, kind: "round", points, cx, cy, rx, ry, filled };
+      const xs = points.map(([x]) => x);
+      const ys = points.map(([, y]) => y);
+      for (let gx = Math.floor(Math.min(...xs) / cell); gx <= Math.floor(Math.max(...xs) / cell); gx++) for (let gy = Math.floor(Math.min(...ys) / cell); gy <= Math.floor(Math.max(...ys) / cell); gy++) add(gx, gy, entry);
+      continue;
+    }
+    if (!stroked) continue;
+    const owner = el.closest("svg");
+    const viewCtm = owner && owner.getScreenCTM();
+    if (viewCtm) scale = Math.hypot(viewCtm.a, viewCtm.b) || scale;
+    const subpaths = geometryOf(el).map((sub, index) => ({ ...sub, index, flat: sub.points.map(map) }));
+    subpaths.forEach((sub) => {
+      for (let i = 0; i < sub.flat.length - 1; i++) {
+        const a = sub.flat[i];
+        const b = sub.flat[i + 1];
+        const entry = { el, kind: "segment", a, b, sub: sub.index, i };
+        for (let gx = Math.floor(Math.min(a[0], b[0]) / cell); gx <= Math.floor(Math.max(a[0], b[0]) / cell); gx++) for (let gy = Math.floor(Math.min(a[1], b[1]) / cell); gy <= Math.floor(Math.max(a[1], b[1]) / cell); gy++) add(gx, gy, entry);
+      }
+    });
+    const checked = el.classList.contains("iso-line") && !skipClass.some((name) => el.classList.contains(name)) && alpha >= least;
+    if (checked) lines.push({ el, subpaths, alpha, free: el.getAttribute("data-free") });
+  }
+  const near = (p, reach) => {
+    const out = new Set();
+    for (let gx = Math.floor((p[0] - reach) / cell); gx <= Math.floor((p[0] + reach) / cell); gx++) for (let gy = Math.floor((p[1] - reach) / cell); gy <= Math.floor((p[1] + reach) / cell); gy++) for (const entry of grid.get(`${gx},${gy}`) || []) out.add(entry);
+    return out;
+  };
+  const segmentDistance = (p, a, b) => {
+    const dx = b[0] - a[0];
+    const dy = b[1] - a[1];
+    const span = dx * dx + dy * dy;
+    const t = span > 0 ? Math.max(0, Math.min(1, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / span)) : 0;
+    return Math.hypot(p[0] - a[0] - dx * t, p[1] - a[1] - dy * t);
+  };
+  const lengthOf = (flat) => flat.reduce((sum, p, i) => (i ? sum + Math.hypot(p[0] - flat[i - 1][0], p[1] - flat[i - 1][1]) : 0), 0);
+  const hidden = (el, p) => {
+    const stack = document.elementsFromPoint(p[0], p[1]);
+    const at = stack.indexOf(el);
+    const above = at < 0 ? stack : stack.slice(0, at);
+    return above.some((node) => {
+      if (!(node instanceof SVGGeometryElement) || node.contains(el)) return false;
+      const cs = getComputedStyle(node);
+      return cs.fill !== "none" && Number(cs.fillOpacity) * opacityOf(node) >= cover && node.isPointInFill(new DOMPoint(...inverse(node, p)));
+    });
+  };
+  const inverse = (node, p) => {
+    const m = node.getScreenCTM().inverse();
+    return [m.a * p[0] + m.c * p[1] + m.e, m.b * p[0] + m.d * p[1] + m.f];
+  };
+  const clearance = (line, sub, end, p, reach) => {
+    let best = Infinity;
+    const own = sub.flat;
+    const skipNear = 2 * reach;
+    const along = [0];
+    for (let i = 1; i < own.length; i++) along.push(along[i - 1] + Math.hypot(own[i][0] - own[i - 1][0], own[i][1] - own[i - 1][1]));
+    const total = along[along.length - 1];
+    for (const entry of near(p, reach * 4)) {
+      if (entry.kind === "round") {
+        const local = inverse(entry.el, p);
+        const inside = ((local[0] - entry.cx) / entry.rx) ** 2 + ((local[1] - entry.cy) / entry.ry) ** 2 <= 1;
+        if (entry.filled && inside) best = 0;
+        else for (let index = 0; index < entry.points.length; index++) best = Math.min(best, segmentDistance(p, entry.points[index], entry.points[(index + 1) % entry.points.length]));
+        continue;
+      }
+      if (entry.el === line.el && entry.sub === sub.index) {
+        const from = along[entry.i];
+        const to = along[entry.i + 1];
+        const gapFrom = end === "start" ? from : total - to;
+        if (gapFrom < skipNear) continue;
+      }
+      best = Math.min(best, segmentDistance(p, entry.a, entry.b));
+    }
+    return best;
+  };
+  const describe = (el) => {
+    const item = el.closest("[data-part], [data-name], [data-item], .it");
+    const tag = item && item !== el ? (item.getAttribute("data-part") || item.getAttribute("data-name") || item.getAttribute("data-item") || `it k ${item.getAttribute("data-k") || ""}`) : "";
+    return `${el.getAttribute("class")}${el.getAttribute("data-tone") ? ` ${el.getAttribute("data-tone")}` : ""}${tag ? ` in ${tag}` : ""}`;
+  };
+  const problems = [];
+  let ends = 0;
+  const slack = tolerance * scale;
+  const rooted = rootSlack * scale;
+  for (const line of lines) {
+    for (const sub of line.subpaths) {
+      if (sub.closed || sub.flat.length < 2) continue;
+      const first = sub.flat[0];
+      const last = sub.flat[sub.flat.length - 1];
+      if (Math.hypot(first[0] - last[0], first[1] - last[1]) < 0.05 * scale) continue;
+      const length = lengthOf(sub.flat);
+      if (length < 0.2 * scale) continue;
+      const result = {};
+      for (const [end, p] of [["start", first], ["end", last]]) {
+        if (line.free === "" || line.free === "both" || line.free === end) {
+          result[end] = 0;
+          continue;
+        }
+        ends++;
+        result[end] = hidden(line.el, p) ? 0 : clearance(line, sub, end, p, Math.max(slack, rooted));
+      }
+      const straight = sub.flat.length === 2 || sub.flat.every((q) => segmentDistance(q, first, last) < 0.15 * scale);
+      const isMark = straight && length <= mark * scale;
+      const fail = (end) => result[end] !== undefined && result[end] > slack;
+      let bad = [];
+      if (isMark) {
+        const best = Math.min(result.start ?? Infinity, result.end ?? Infinity);
+        if (!(best <= rooted)) bad = ["start", "end"].filter((end) => result[end] !== undefined && result[end] > 0);
+      } else bad = ["start", "end"].filter(fail);
+      for (const end of bad) {
+        const p = end === "start" ? first : last;
+        problems.push({ what: describe(line.el), d: (line.el.getAttribute("d") || "").slice(0, 36), end, mark: isMark, gap: result[end] / scale, at: [Math.round((p[0] - box.left) * 10) / 10, Math.round((p[1] - box.top) * 10) / 10], client: p, opacity: Math.round(line.alpha * 100) / 100, length: Math.round((length / scale) * 10) / 10 });
+      }
+    }
+  }
+  style.remove();
+  problems.sort((a, b) => b.gap - a.gap);
+  if (show) {
+    const ns = "http://www.w3.org/2000/svg";
+    const overlay = document.createElementNS(ns, "svg");
+    overlay.setAttribute("data-line-ends", "");
+    overlay.setAttribute("style", `position:fixed;left:0;top:0;width:${innerWidth}px;height:${innerHeight}px;pointer-events:none;z-index:2147483647;overflow:visible`);
+    for (const problem of problems) {
+      const ring = document.createElementNS(ns, "circle");
+      ring.setAttribute("cx", problem.client[0]);
+      ring.setAttribute("cy", problem.client[1]);
+      ring.setAttribute("r", 5);
+      ring.setAttribute("style", "fill:none;stroke:#ff0050;stroke-width:1.5");
+      overlay.append(ring);
+    }
+    document.body.append(overlay);
+  }
+  return { ends, lines: lines.length, problems: problems.map(({ client, ...rest }) => rest) };
+}
+
+export const LINE_ENDS = lineEnds.toString();

package/skills/axstack-anatomy/scripts/lines-arcs.test.mjs

@@ -0,0 +1,50 @@
+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 { fileURLToPath } from "node:url";
+import test from "node:test";
+
+const execute = promisify(execFile);
+const lines = fileURLToPath(new URL("lines.mjs", import.meta.url));
+
+async function check(arc, line) {
+  const directory = await mkdtemp(join(tmpdir(), "anatomy-lines-arcs-"));
+  try {
+    const page = join(directory, "figure.html");
+    await writeFile(page, `<!doctype html><div class="iso-plate"><svg width="200" height="100" viewBox="0 0 200 100"><path fill="none" stroke="black" d="${arc}"/><path class="iso-line" fill="none" stroke="black" d="${line}"/></svg></div>`);
+    try {
+      return { code: 0, ...await execute(process.execPath, [lines, page, "--wait", "0"], { timeout: 30000 }) };
+    } catch (error) {
+      return { code: error.code, stdout: error.stdout, stderr: error.stderr };
+    }
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+}
+
+test("the empty chord of an arc does not root a line", async () => {
+  const result = await check("M20 50A30 30 0 0 1 80 50", "M50 50L50 70");
+  assert.equal(result.code, 1);
+  assert.match(result.stdout, /line ends: 2 of 2/);
+});
+
+test("the actual middle of an arc roots a line", async () => {
+  const result = await check("M20 50A30 30 0 0 1 80 50", "M50 20L50 0");
+  assert.equal(result.code, 1);
+  assert.match(result.stdout, /line ends: 1 of 2/);
+});
+
+test("relative arcs retain their endpoint and curvature", async () => {
+  const result = await check("M20 50a30 30 0 0 1 60 0", "M50 20L50 0");
+  assert.equal(result.code, 1);
+  assert.match(result.stdout, /line ends: 1 of 2/);
+});
+
+test("arc endpoints preserve fully rooted lines", async () => {
+  const result = await check("M20 50A30 30 0 0 1 80 50", "M20 50L80 50");
+  assert.equal(result.code, 0);
+  assert.match(result.stdout, /line ends: 0/);
+});

package/skills/axstack-anatomy/scripts/lines-bezier.test.mjs

@@ -0,0 +1,28 @@
+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";
+
+const execute = promisify(execFile);
+for (const [name, path, x, y] of [
+  ["quadratic then smooth cubic", "M20 60 Q40 20 60 60 S80 100 100 60", 72.5, 75],
+  ["cubic then smooth quadratic", "M20 60 C30 20 50 20 60 60 T100 60", 80, 60],
+  ["matching cubic continuation", "M20 60 C30 20 50 20 60 60 S80 100 100 60", 76.25, 90],
+  ["matching quadratic continuation", "M20 60 Q40 20 60 60 T100 60", 80, 80],
+]) test(`native SVG ${name} roots a line on the actual curve`, async () => {
+  const directory = await mkdtemp(join(tmpdir(), "anatomy-bezier-control-"));
+  try {
+    const file = join(directory, "figure.html");
+    await writeFile(file, `<!doctype html><div class="iso-plate"><svg width="140" height="120" viewBox="0 0 140 120"><path id="curve" fill="none" stroke="black" d="${path}"/><path class="iso-line" data-free="start" fill="none" stroke="black" d="M${x} 10L${x} ${y}"/></svg></div>`);
+    const actions = JSON.stringify([["eval", `document.querySelector('#curve').isPointInStroke(new DOMPoint(${x},${y}))`], ["lines"]]);
+    let result;
+    try { result = { code: 0, ...await execute(process.execPath, ["scripts/drive.mjs", file, actions], { timeout: 30000 }) }; }
+    catch (error) { result = { code: error.code, stdout: error.stdout, stderr: error.stderr }; }
+    assert.match(result.stdout, /eval: true/);
+    assert.equal(result.code, 0);
+    assert.match(result.stdout, /line ends: 0 of 1/);
+  } finally { await rm(directory, { recursive: true, force: true }); }
+});

package/skills/axstack-anatomy/scripts/lines-round.test.mjs

@@ -0,0 +1,56 @@
+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 { fileURLToPath } from "node:url";
+import test from "node:test";
+
+const execute = promisify(execFile);
+const lines = fileURLToPath(new URL("lines.mjs", import.meta.url));
+
+async function check(shape, path) {
+  const directory = await mkdtemp(join(tmpdir(), "anatomy-lines-round-"));
+  try {
+    const page = join(directory, "figure.html");
+    await writeFile(page, `<!doctype html><div class="iso-plate"><svg width="200" height="100" viewBox="0 0 200 100">${shape}<path class="iso-line" fill="none" stroke="black" d="${path}"/></svg></div>`);
+    try {
+      return { code: 0, ...await execute(process.execPath, [lines, page, "--wait", "0"], { timeout: 30000 }) };
+    } catch (error) {
+      return { code: error.code, stdout: error.stdout, stderr: error.stderr };
+    }
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+}
+
+test("line ends above a flat ellipse are floating", async () => {
+  const result = await check('<ellipse cx="50" cy="50" rx="40" ry="5" fill="black"/>', "M30 30L50 30");
+  assert.equal(result.code, 1);
+  assert.match(result.stdout, /line ends: 2 of 2/);
+});
+
+test("line ends inside an unfilled circle are floating", async () => {
+  const result = await check('<circle cx="50" cy="50" r="40" fill="none" stroke="black"/>', "M30 50L50 50");
+  assert.equal(result.code, 1);
+  assert.match(result.stdout, /line ends: 2 of 2/);
+});
+
+test("line ends on ellipse rims remain rooted", async () => {
+  const result = await check('<ellipse cx="50" cy="50" rx="40" ry="5" fill="none" stroke="black"/>', "M10 50L90 50");
+  assert.equal(result.code, 0);
+  assert.match(result.stdout, /line ends: 0/);
+});
+
+test("a nonuniformly scaled circle does not root nearby floating ends", async () => {
+  const result = await check('<circle cx="25" cy="25" r="20" transform="scale(2,.25)" fill="black"/>', "M30 20L50 20");
+  assert.equal(result.code, 1);
+  assert.match(result.stdout, /line ends: 2 of 2/);
+});
+
+test("line ends inside a filled ellipse remain rooted", async () => {
+  const result = await check('<ellipse cx="50" cy="50" rx="40" ry="5" fill="black"/>', "M30 50L50 50");
+  assert.equal(result.code, 0);
+  assert.match(result.stdout, /line ends: 0/);
+});

package/skills/axstack-anatomy/scripts/lines-rounded-rect.test.mjs

@@ -0,0 +1,32 @@
+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";
+
+const execute = promisify(execFile);
+for (const [name, attributes, x, y, rooted, transform = ""] of [
+  ["rounded cutaway rejects square-corner attachment", 'width="100" height="80" rx="30"', 0, 0, false],
+  ["rounded curve accepts its native attachment", 'width="100" height="80" rx="30"', 8.78679656440357, 8.786796564403573, true],
+  ["elliptical corner accepts its native attachment", 'width="100" height="80" rx="30" ry="10"', 4.019237886466836, 5, true],
+  ["missing horizontal radius follows vertical radius", 'width="100" height="80" ry="20"', 5.857864376269049, 5.857864376269051, true],
+  ["oversized radii clamp independently", 'width="100" height="80" rx="200" ry="200"', 14.644660940672622, 11.715728752538102, true],
+  ["affine corner preserves transformed attachment", 'width="100" height="80" rx="30"', 8.78679656440357, 8.786796564403573, true, "matrix(2 .2 .4 1 50 50)"],
+  ["ordinary square retains its original attachment", 'width="100" height="80"', 0, 0, true],
+  ["explicit zero radius remains square", 'width="100" height="80" rx="0" ry="30"', 0, 0, true],
+]) test(name, async () => {
+  const directory = await mkdtemp(join(tmpdir(), "anatomy-rounded-rect-lines-"));
+  try {
+    const file = join(directory, "figure.html");
+    await writeFile(file, `<!doctype html><div class="iso-plate"><svg width="360" height="300" viewBox="0 0 360 300"><g transform="${transform}"><rect id="outline" x="0" y="0" ${attributes} fill="none" stroke="black"/><path class="iso-line" data-free="start" fill="none" stroke="black" d="M${x} -20 L${x} ${y}"/></g></svg></div>`);
+    const actions = JSON.stringify([["eval", `document.querySelector('#outline').isPointInStroke(new DOMPoint(${x},${y}))`], ["lines"]]);
+    let result;
+    try { result = { code: 0, ...await execute(process.execPath, ["scripts/drive.mjs", file, actions], { timeout: 30000 }) }; }
+    catch (error) { result = { code: error.code, stdout: error.stdout, stderr: error.stderr }; }
+    assert.match(result.stdout, new RegExp(`eval: ${rooted}`));
+    assert.equal(result.code, rooted ? 0 : 1, result.stderr);
+    assert.match(result.stdout, new RegExp(`line ends: ${rooted ? 0 : 1} of 1`));
+  } finally { await rm(directory, { recursive: true, force: true }); }
+});

package/skills/axstack-anatomy/scripts/lines.mjs

@@ -0,0 +1,31 @@
+import { spawn } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const argv = process.argv.slice(2);
+if (!argv.length || argv.includes("--help") || argv.includes("-h")) {
+  console.log(`Check that every texture line in a figure ends on something.
+
+  node lines.mjs <file.html | url> [--out marks.png] [--tolerance 1] [--select css] [--wait 1500] [drive.mjs flags]
+
+Every open subpath of every .iso-line (seams, grooves, ribs, rule lines, ticks, needles) must end on another stroke,
+a dot or an outline within the tolerance (viewBox px), or under a fill painted after it. A short straight mark (a tick)
+needs one rooted end. Outlines, creases, bevels and tube edges are the kit's own and are not checked. Lines drawn with
+fadeLineSvg ramp out and pass; lineSvg(d, { free: true | "start" | "end" }) marks an end that is meant to stop (a needle
+tip, rule lines standing for printed text). Exits 1 if any end floats; --out writes the card with each one ringed.`);
+  process.exit(argv.length ? 0 : 1);
+}
+const take = (flag, fallback) => {
+  const at = argv.indexOf(flag);
+  if (at < 0) return fallback;
+  const value = argv[at + 1];
+  argv.splice(at, 2);
+  return value;
+};
+const out = take("--out", null);
+const tolerance = Number(take("--tolerance", 1));
+const select = take("--select", null);
+const wait = Number(take("--wait", 1500));
+const actions = JSON.stringify([["wait", wait], ["lines", out, select, { tolerance }]]);
+const child = spawn(process.execPath, [join(dirname(fileURLToPath(import.meta.url)), "drive.mjs"), argv[0], actions, ...argv.slice(1)], { stdio: "inherit" });
+child.on("exit", (code) => process.exit(code ?? 1));

package/skills/axstack-anatomy/scripts/lines.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 { fileURLToPath } from "node:url";
+import test from "node:test";
+
+const execute = promisify(execFile);
+const lines = fileURLToPath(new URL("lines.mjs", import.meta.url));
+
+async function check(path) {
+  const directory = await mkdtemp(join(tmpdir(), "anatomy-lines-"));
+  try {
+    const page = join(directory, "figure.html");
+    await writeFile(page, `<!doctype html><svg id="figure" width="200" height="100" viewBox="0 0 200 100"><path class="iso-line" fill="none" stroke="black" d="${path}"/></svg>`);
+    try {
+      return { code: 0, ...await execute(process.execPath, [lines, page, "--select", "#figure", "--wait", "0"], { timeout: 30000 }) };
+    } catch (error) {
+      return { code: error.code, stdout: error.stdout, stderr: error.stderr };
+    }
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+}
+
+test("a selected SVG checks its own floating lines", async () => {
+  const result = await check("M20 20L180 20");
+  assert.equal(result.code, 1);
+  assert.match(result.stdout, /line ends: 2 of 2 ends on 1 lines float/);
+});
+
+test("a selected SVG preserves closed-path exemption", async () => {
+  const result = await check("M20 20L180 20L180 80L20 80Z");
+  assert.equal(result.code, 0);
+  assert.match(result.stdout, /line ends: 0/);
+});

package/skills/axstack-anatomy/scripts/navigation.test.mjs

@@ -0,0 +1,55 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { createServer } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+
+const execute = promisify(execFile);
+
+async function run(name, kind) {
+  const directory = await mkdtemp(join(tmpdir(), "anatomy-navigation-"));
+  try {
+    let target = join(directory, "figure.html");
+    if (kind === "valid") await writeFile(target, '<!doctype html><div class="iso-plate" style="width:100px;height:100px">Figure</div>');
+    if (kind === "refused") {
+      const server = createServer();
+      await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+      target = `http://127.0.0.1:${server.address().port}/`;
+      await new Promise((resolve) => server.close(resolve));
+    }
+    const args = [fileURLToPath(new URL(`${name}.mjs`, import.meta.url)), target, ...(name === "capture" ? ["--out", join(directory, "shot.png"), "--wait", "0"] : ["[]"])];
+    try {
+      return { code: 0, ...await execute(process.execPath, args, { timeout: 30000 }) };
+    } catch (error) {
+      return { code: error.code, stdout: error.stdout, stderr: error.stderr };
+    }
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+}
+
+for (const name of ["capture", "drive"]) {
+  test(`${name} fails a missing local page`, async () => {
+    const result = await run(name, "missing");
+    assert.equal(result.code, 1);
+    assert.match(result.stderr, /Navigation failed.*ERR_FILE_NOT_FOUND/);
+    assert.doesNotMatch(result.stdout, /console: clean/);
+  });
+
+  test(`${name} fails refused HTTP navigation`, async () => {
+    const result = await run(name, "refused");
+    assert.equal(result.code, 1);
+    assert.match(result.stderr, /Navigation failed.*ERR_CONNECTION_REFUSED/);
+    assert.doesNotMatch(result.stdout, /console: clean/);
+  });
+
+  test(`${name} preserves successful local navigation`, async () => {
+    const result = await run(name, "valid");
+    assert.equal(result.code, 0);
+    assert.match(result.stdout, /console: clean/);
+  });
+}

package/skills/axstack-anatomy/scripts/orbit-sampling.test.mjs

@@ -0,0 +1,50 @@
+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";
+
+const execute = promisify(execFile);
+const page = "examples/turning-dial/turning-dial-verify-light.html";
+async function run(args) {
+  try { return { code: 0, ...await execute(process.execPath, ["scripts/turn-check.mjs", page, ...args], { timeout: 60000 }) }; }
+  catch (error) { return { code: error.code, stdout: error.stdout, stderr: error.stderr }; }
+}
+for (const step of ["NaN", "Infinity", "-1", "721"])
+  test(`rejects orbit step ${step} instead of passing an empty sweep`, async () => {
+    const result = await run(["--order", "--step", step]);
+    assert.equal(result.code, 1);
+    assert.match(result.stderr, /--step must be a finite number/);
+    assert.doesNotMatch(result.stdout, /turn check passed/);
+  });
+test("rejects an empty explicit pose list instead of auditing zero states", async () => {
+  const directory = await mkdtemp(join(tmpdir(), "anatomy-orbit-states-"));
+  try {
+    const file = join(directory, "states.json"); await writeFile(file, "[]");
+    const result = await run(["--order", "--states", file]);
+    assert.equal(result.code, 1); assert.match(result.stderr, /nonempty JSON list/);
+    assert.doesNotMatch(result.stdout, /turn check passed/);
+  } finally { await rm(directory, { recursive: true, force: true }); }
+});
+test("rejects a nonfinite fine step instead of silently skipping the second difference", async () => {
+  const result = await run(["--pops", "--step", "360", "--fine", "NaN"]);
+  assert.equal(result.code, 1); assert.match(result.stderr, /--fine must be a finite number/);
+  assert.doesNotMatch(result.stdout, /turn check passed/);
+});
+test("preserves a valid native orbit sweep and its planted control", async () => {
+  const result = await run(["--order", "--step", "360"]);
+  assert.equal(result.code, 0); assert.match(result.stdout, /order: 1 states/);
+  assert.match(result.stdout, /order control.*fails as it should/); assert.match(result.stdout, /turn check passed/);
+});
+
+test("preserves a nonempty explicit pose list and its planted control", async () => {
+  const directory = await mkdtemp(join(tmpdir(), "anatomy-orbit-states-"));
+  try {
+    const file = join(directory, "states.json"); await writeFile(file, "[0,90]");
+    const result = await run(["--order", "--states", file]);
+    assert.equal(result.code, 0); assert.match(result.stdout, /order: 2 states/);
+    assert.match(result.stdout, /order control.*fails as it should/); assert.match(result.stdout, /turn check passed/);
+  } finally { await rm(directory, { recursive: true, force: true }); }
+});