Wall joins and plan outlines

/** Where p1 + s·d1 meets p2 + t·d2, or null when they are parallel. */
function meet(p1, d1, p2, d2) {
  const c = cross(d1, d2);
  if (Math.abs(c) < 1e-9) return null;
  const s = cross(sub(p2, p1), d2) / c;
  return add(p1, mul(d1, s));
}

/** The nodes where walls meet: { p, ends: [{ w, end }], tees: [{ w, s }] } (w = index into the prepared list). */
export function wallNodes(W, tol = 1) {
  const nodes = [];
  for (let i = 0; i < W.length; i++) for (const end of ['a', 'b']) {
    const p = W[i][end];
    let n = nodes.find((x) => dist(x.p, p) <= tol);
    if (!n) { n = { p, ends: [], tees: [] }; nodes.push(n); }
    n.ends.push({ w: i, end });
  }
  for (const n of nodes) {
    const here = new Set(n.ends.map((e) => e.w));
    for (let j = 0; j < W.length; j++) {
      if (here.has(j)) continue;
      const w = W[j], q = w.g.param(n.p), s = q.s, off = Math.abs(q.off);
      if (s > tol && s < w.L - tol && off <= w.h + tol) n.tees.push({ w: j, s });
    }
  }
  return nodes;
}

  rays.sort((x, y) => x.ang - y.ang);
  for (let i = 0; i < rays.length; i++) {
    const A = rays[i], B = rays[(i + 1) % rays.length];
    if (!A.real && !B.real) continue;   // the two halves of a T's through wall
    // the space between A (its left face) and B, the next one anticlockwise (its right face)
    const c = W[A.w].arc || W[B.w].arc ? meetFaces(A.fl, B.fr, p) : meet(add(A.o, mul(left(A.d), A.h)), A.d, add(B.o, mul(left(B.d), -B.h)), B.d);
    const turn = cross(A.d, B.d), ahead = dot(A.d, B.d);
    if (!c || (turn <= 1e-9 && ahead > 1e-9)) continue;   // parallel or overlapping: square ends (1e-9: a curved wall's tangent is not exact)
    if (dist(c, p) > 4 * Math.max(A.h, B.h) + tol) continue;   // too sharp a mitre: square
    A.left = c; B.right = c;
  }
}

/** Where two faces meet nearest `near`: lines { p, d } and circles { c, r } (a curved wall's faces); null when they don't. */
function meetFaces(F, G, near) {
  if (F.d && G.d) return meet(F.p, F.d, G.p, G.d);
  const pick = (list) => list.filter(Boolean).sort((x, y) => dist(x, near) - dist(y, near))[0] || null;
  if (F.d || G.d) {
    const L = F.d ? F : G, K = F.d ? G : F, m = sub(L.p, K.c), bq = dot(L.d, m), cq = dot(m, m) - K.r * K.r, disc = bq * bq - cq;
    if (disc < 0) return null;
    const sq = Math.sqrt(disc);
    return pick([add(L.p, mul(L.d, -bq - sq)), add(L.p, mul(L.d, -bq + sq))]);
  }
  const dd = dist(F.c, G.c);
  if (dd < 1e-6 || dd > F.r + G.r || dd < Math.abs(F.r - G.r)) return null;   // one circle (a curve going on), or apart
  const x = (dd * dd + F.r * F.r - G.r * G.r) / (2 * dd), y = Math.sqrt(Math.max(0, F.r * F.r - x * x));
  const u = mul(sub(G.c, F.c), 1 / dd), m = add(F.c, mul(u, x));
  return pick([add(m, mul(left(u), y)), add(m, mul(left(u), -y))]);
}

/**
 * A curved wall's outline: its corners from the joins (A at its start, B at its end, as for a straight wall), the right face
 * from A to B and the left face back as arcs — the outline returned is in chords (rooms, the plan), its `bulged` copy keeps
 * each arc edge as a bulge on the point it starts from ([x, y, bulge], for the IFC profile).
 */
function arcOutline(w, A, B) {
  const k = w.arc, ang = (q) => Math.atan2(q[1] - k.C[1], q[0] - k.C[0]);
  const wrap = (x) => { let y = (x + Math.PI) % (2 * Math.PI); if (y <= 0) y += 2 * Math.PI; return y - Math.PI; };
  const bulge = (P, Q, want) => Math.tan((wrap(ang(Q) - ang(P) - want) + want) / 4);
  let poly = [[...A.right, bulge(A.right, B.left, k.theta)], B.left, B.centre, [...B.right, bulge(B.right, A.left, -k.theta)], A.left, A.centre].filter(Boolean);
  // repeated points: the later one keeps its bulge (the edge to it is nothing)
  poly = poly.filter((q, i) => dist(q, poly[(i + 1) % poly.length]) > 1e-6 || poly.length < 4);
  let flat = flatPoly(poly);
  if (poly.length < 4 || !simpleCCW(flat)) {
    poly = [[...w.g.at(0, -w.h), Math.tan(k.theta / 4)], w.g.at(w.L, -w.h), [...w.g.at(w.L, w.h), Math.tan(-k.theta / 4)], w.g.at(0, w.h)];
    flat = flatPoly(poly);
  }
  flat.bulged = poly;
  return flat;
}

/** Drop repeated and collinear points. */
function clean(poly) {
  let p = poly.filter((q, i) => i === 0 || dist(q, poly[i - 1]) > 1e-6);
  if (p.length > 1 && dist(p[0], p[p.length - 1]) <= 1e-6) p.pop();
  let changed = true;
  while (changed && p.length > 3) {
    changed = false;
    for (let i = 0; i < p.length; i++) {
      const a = p[(i + p.length - 1) % p.length], b = p[i], c = p[(i + 1) % p.length];
      const ab = sub(b, a), bc = sub(c, b);
      if (Math.abs(cross(ab, bc)) <= 1e-6 * (Math.hypot(...ab) * Math.hypot(...bc) + 1e-12) && dot(ab, bc) >= 0) { p.splice(i, 1); changed = true; break; }
    }
  }
  return p;
}

export function polyArea(p) { let s = 0; for (let i = 0; i < p.length; i++) s += cross(p[i], p[(i + 1) % p.length]); return s / 2; }

function simpleCCW(p) {
  if (p.length < 3 || polyArea(p) <= 1e-6) return false;
  const n = p.length;
  for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) {
    if (j === i + 1 || (i === 0 && j === n - 1)) continue;
    if (segCross(p[i], p[(i + 1) % n], p[j], p[(j + 1) % n])) return false;
  }
  return true;
}

/** How far the location line is from the centre line, to the wall's left (mm). */
export function locationOffset(just, t, extSide, assembly = null) {
  if (String(just).startsWith('core')) {
    const layers = assembly?.layers || [], first = layers.findIndex(l => l.core), last = layers.findLastIndex(l => l.core);
    if (first < 0) return null;
    const outer = layers.slice(0, first).reduce((s,l) => s+l.t, 0), inner = layers.slice(0, last+1).reduce((s,l) => s+l.t, 0);
    const sign = extSide === 'right' ? -1 : 1;
    return sign * (t/2 - (just === 'coreExterior' ? outer : just === 'coreInterior' ? inner : (outer+inner)/2));
  }
  const ext = extSide === 'right' ? -t / 2 : t / 2;
  return just === 'left' ? t / 2 : just === 'right' ? -t / 2 : just === 'exterior' ? ext : just === 'interior' ? -ext : 0;
}