Wire harness and control cabinet layout

function matrix(e, blk) {
  const base = blk?.base || { x: 0, y: 0 };
  const sx = e.sx ?? 1, sy = e.sy ?? 1, r = e.rot || 0, co = Math.cos(r), si = Math.sin(r);
  const a = co * sx, b = si * sx, c = -si * sy, d = co * sy;
  return [a, b, c, d, e.x - (a * base.x + c * base.y), e.y - (b * base.x + d * base.y)];
}

function onSeg(p, a, b) {
  const dx = b.x - a.x, dy = b.y - a.y, l2 = dx * dx + dy * dy;
  const u = l2 ? Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / l2)) : 0;
  return d2(p, { x: a.x + u * dx, y: a.y + u * dy });
}

const tol2 = tol * tol;
for (const [, s] of bySpace) {
  const ends = new Cells(Math.max(tol * 20, 1)), pins = new Cells(Math.max(tol * 20, 1)), segs = new Cells(5);
  for (const w of s.wires) {
    dsu.find('w:' + w.uid);
    for (const [i, p] of [[0, w.pts[0]], [1, w.pts[w.pts.length - 1]]]) ends.add(p.x, p.y, p.x, p.y, { w, i, p });
    for (let k = 0; k + 1 < w.pts.length; k++) { const a = w.pts[k], b = w.pts[k + 1]; segs.add(Math.min(a.x, b.x) - tol, Math.min(a.y, b.y) - tol, Math.max(a.x, b.x) + tol, Math.max(a.y, b.y) + tol, { w, k, a, b, last: w.pts.length - 2 }); }
  }
  for (const d of s.devices) for (const p of d.pins) pins.add(p.x, p.y, p.x, p.y, { d, p });
  for (const w of s.wires) {
    for (const [i, p] of [[0, w.pts[0]], [1, w.pts[w.pts.length - 1]]]) {
      for (const o of ends.at(p, tol)) if ((o.w !== w || o.i !== i) && d2(p, o.p) <= tol2) dsu.union('w:' + w.uid, 'w:' + o.w.uid);
      for (const { d, p: pin } of pins.at(p, tol)) if (d2(p, pin) <= tol2) dsu.union('w:' + w.uid, pk(d, pin));
      for (const o of segs.at(p)) {
        if (onSeg(p, o.a, o.b) > tol2) continue;
        if ((o.k === 0 && d2(p, o.a) <= tol2) || (o.k === o.last && d2(p, o.b) <= tol2)) continue;   // that is an end, handled above
        if (o.w === w && ((i === 0 && o.k === 0) || (i === 1 && o.k === o.last))) continue;
        dsu.union('w:' + w.uid, 'w:' + o.w.uid);
      }
    }
  }
  for (const d of s.devices) for (const pin of d.pins) for (const o of segs.at(pin)) {   // a wire passing through a pin
    if (onSeg(pin, o.a, o.b) <= tol2) dsu.union('w:' + o.w.uid, pk(d, pin));
  }
}

export function toRail(r, p) {
  const c = Math.cos(r.rot), s = Math.sin(r.rot), dx = p.x - r.x, dy = p.y - r.y;
  return { s: (dx * c + dy * s) / r.k, off: (-dx * s + dy * c) / r.k };
}

export function fromRail(r, s, off = 0) {
  const c = Math.cos(r.rot), si = Math.sin(r.rot);
  return { x: r.x + (s * c - off * si) * r.k, y: r.y + (s * si + off * c) * r.k };
}

/** mods = [{ id, e, d (clean module) }] → those on the rail (centre within the rail's width + tol), with s0 / s1 in mm along it, in order. */
export function onRail(r, mods, tol = 5) {
  const out = [];
  for (const m of mods) {
    const p = toRail(r, { x: m.e.x, y: m.e.y });
    if (Math.abs(p.off) <= r.w / 2 + tol && p.s > -tol && p.s < r.len + tol) out.push({ ...m, s: p.s, s0: p.s - m.d.w / 2, s1: p.s + m.d.w / 2 });
  }
  return out.sort((a, b) => a.s - b.s);
}

export function railChecks(r, mods) {
  const out = [];
  for (let i = 0; i < mods.length; i++) {
    const m = mods[i];
    if (m.s0 < -0.01 || m.s1 > r.len + 0.01) out.push({ code: 'past', ids: [m.id], vars: { tag: m.d.tag, len: r.len } });
    for (let j = i + 1; j < mods.length && mods[j].s0 < m.s1 - 0.01; j++) out.push({ code: 'overlap', ids: [m.id, mods[j].id], vars: { a: m.d.tag, b: mods[j].d.tag } });
  }
  return out;
}

export const freeLength = (r, mods) => Math.max(0, r.len - mods.reduce((s, m) => s + m.d.w, 0));

/** Where a module of width w whose centre is wanted at s may sit: inside the rail, and flush to a neighbour's edge when within `snap` mm. */
export function snapOnRail(r, mods, w, s, snap = 3) {
  let c = Math.max(w / 2, Math.min(r.len - w / 2, s));
  for (const m of mods) {
    for (const edge of [m.s1 + w / 2, m.s0 - w / 2]) if (Math.abs(c - edge) <= snap) c = edge;
  }
  return Math.max(w / 2, Math.min(r.len - w / 2, c));
}

const unitsOf = (doc) => { const u = ruleUnitOf(doc), per = perUnit(doc, u); return { u, k: (1 / per) * (u === 'in' ? 1 / 25.4 : 1) }; };   // k = drawing units per millimetre

transform: (data, m) => { const d = cleanBundle(data); return d ? { ...d, k: d.k * Math.hypot(m[0], m[1]) || d.k, nodes: d.nodes.map((n) => ({ ...n, x: m[0] * n.x + m[2] * n.y + m[4], y: m[1] * n.x + m[3] * n.y + m[5] })) } : data; },

for (const m of mods(doc)) if (m.d.tag) modules.set(m.d.tag, { x: m.e.x / m.d.k, y: m.e.y / m.d.k });
return { hs, ends, modules };

const harn = [...A.G.hs].map((h) => ({ id: h.name, mm: [...h.graph.segs.values()].reduce((s, x) => s + x.len, 0) }));

for (const [key, g] of A.R.segments) if (g.harness === h.id) counts[g.seg] = { n: g.wires.length, od: g.ods.length ? Math.round(bundleDiameter(g.ods, settings.packing) * 10) / 10 : 0 };

const [p, q] = pts, len = Math.hypot(q.x - p.x, q.y - p.y) / k;
const data = cleanRail({ k, len, w: 35 });
if (!data) { c.print(t('err.size')); return; }
const e = addObject(c.doc, 'hrail', data, 'HN-RAIL', { x: p.x, y: p.y, rot: Math.atan2(q.y - p.y, q.x - p.x) });
api.select([e.id]);
c.print(t('done.rail', { len: Math.round(data.len) }));

let s = Math.max(0, rail.q.s, dir.length ? dir[dir.length - 1].s1 : 0), n = 0, left = 0;
for (const part of todo()) {
  const w = sizeFor(part.type).w;
  if (s + w > rail.pl.len + 1e-9) { left++; continue; }
  placeModule(doc, part, rail, s + w / 2, {}); have.add(part.id); s += w; n++;

export function bundleEnts(h) {
  const k = h.k || 1, th = 4 * k, out = [];
  const node = new Map(h.nodes.map((n) => [n.id, n]));
  for (const s of h.segs) {
    const a = node.get(s.a), b = node.get(s.b);
    if (!a || !b) continue;
    out.push(ln(a.x, a.y, b.x, b.y));
    const mm = Number.isFinite(s.len) && s.len > 0 ? s.len : Math.hypot(a.x - b.x, a.y - b.y) / k;
    const l = Math.hypot(b.x - a.x, b.y - a.y) || 1, nx = -(b.y - a.y) / l, ny = (b.x - a.x) / l;
    let ang = Math.atan2(b.y - a.y, b.x - a.x);
    if (Math.cos(ang) < -1e-9) ang += Math.PI;
    const c = h.counts?.[s.id];
    out.push(text((a.x + b.x) / 2 + nx * th * 1.1, (a.y + b.y) / 2 + ny * th * 1.1, th, Math.round(mm), 'center', 'middle', ang));
    if (c && c.n) out.push(text((a.x + b.x) / 2 - nx * th * 1.1, (a.y + b.y) / 2 - ny * th * 1.1, th * 0.8, c.n + ' × ' + (c.od ? 'Ø' + Math.round(c.od * 10) / 10 : ''), 'center', 'middle', ang));
  }
  for (const n of h.nodes) {
    out.push(circ(n.x, n.y, 2.2 * k));
    out.push(text(n.x + 3 * k, n.y + 3 * k, th, n.label || n.id, 'left', 'bottom'));
  }
  if (h.name && h.nodes.length) { const n = h.nodes[0]; out.push(text(n.x, n.y - 8 * k, th * 1.3, h.name, 'left', 'top')); }
  return out;
}