Takeoff quantities from marks

const segs = segmentLengths(m.pts).map((d) => d * ftPerUnit);
const kinds = segs.map((_, i) => segSlope(m, it, i));
const sloped = segs.map((d, i) => d * (kinds[i].k === 'rake' ? slopeFactor(kinds[i].p) : kinds[i].k === 'hip' ? hipFactor(kinds[i].p) : 1));
const ded = new Set(m.deducts || []);
let len = 0, cut = 0, plan = 0;
sloped.forEach((d, i) => { if (ded.has(i)) cut += d; else { len += d; plan += segs[i]; } });
return { lengthFt: len, grossFt: len + cut, deductFt: cut, planFt: plan, segmentsFt: segs, slopedFt: sloped, slopes: kinds, deducts: [...ded] };

const a = areaWithHoles(m.pts, m.holes);
const k2 = ftPerUnit * ftPerUnit, f = slopeFactor(pitch);
return { areaSqft: a.net * k2 * f, planSqft: a.net * k2, factor: f, pitch, grossSqft: a.gross * k2 * f, cutSqft: a.cut * k2 * f, perimeterFt: a.perimeter * ftPerUnit, outerPerimeterFt: a.outerPerimeter * ftPerUnit };

/**
 * Totals per item (feet / square feet) and per sheet. Marks on sheets with no scale are
 * counted in `unscaled` and left out of the totals — never measured as zero silently.
 */
export function quantities(state, { area, exclude } = {}) {
  const out = new Map();
  for (const it of state.items) {
    const q = { item: it, lengthFt: 0, areaSqft: 0, perimeterFt: 0, count: 0, marks: 0, unscaled: 0, backoutSqft: 0, bySheet: new Map() };
    if (it.type === 'fixed') {                             // a typed quantity (TK.5+): in its bid area like a mark would be
      const a = it.area || null;
      q.fixed = (area !== undefined && a !== area) || (exclude && a && exclude.has(a)) ? 0 : it.qty || 0;
    }
    out.set(it.id, q);
  }
  const bo = backouts(state);
  const rep = new Map((state.groups || []).map((g) => [g.id, g.repeat]));
  for (const m of state.marks) {
    if (area !== undefined && (m.area || null) !== area) continue;      // one bid area (null: the marks in none)
    if (exclude && m.area && exclude.has(m.area)) continue;              // add alternates, out of the base bid (T17)
    const q = out.get(m.item);
    if (!q) continue;
    q.marks++;
    const sc = state.sheets[m.sheet]?.scale;
    const r = measureMark(m, sc?.ftPerUnit, q.item);
    if (!r) { q.unscaled++; continue; }
    let s = q.bySheet.get(m.sheet);
    if (!s) q.bySheet.set(m.sheet, (s = { lengthFt: 0, areaSqft: 0, perimeterFt: 0, count: 0, marks: 0 }));
    s.marks++;
    const k = rep.get(m.group) || 1;                       // a typical group's mark (T16) counts `repeat` times
    if (m.kind !== q.item.type) {                          // a second condition (T8): its own totals, measured plainly
      const zero = () => ({ lengthFt: 0, areaSqft: 0, perimeterFt: 0, count: 0, marks: 0 });
      const qc = ((q.conds ??= {})[m.kind] ??= zero()), sc2 = ((s.conds ??= {})[m.kind] ??= zero());
      for (const o of [qc, sc2]) { o.marks++; o.count += k; o.lengthFt += (r.lengthFt || 0) * k; o.areaSqft += (r.areaSqft || 0) * k; o.perimeterFt += (r.perimeterFt || 0) * k; }
      continue;
    }
    if (m.kind === 'count') { q.count += k; s.count += k; }
    else if (m.kind === 'linear') { q.lengthFt += r.lengthFt * k; s.lengthFt += r.lengthFt * k; q.count += k; s.count += k; }
    else {
      const cut = bo.cut(m, sc.ftPerUnit) * r.factor;     // back-outs (T14) that cover part of it, on the slope (T15)
      const a = Math.max(0, r.areaSqft - cut);
      q.areaSqft += a * k; s.areaSqft += a * k; q.backoutSqft += (r.areaSqft - a) * k; q.perimeterFt += r.perimeterFt * k; s.perimeterFt += r.perimeterFt * k; q.count += k; s.count += k;
    }
  }
  return out;
}

cut(m, ftPerUnit) {
  const list = bySheet.get(m.sheet);
  if (!list || m.kind !== 'area' || !(ftPerUnit > 0)) return 0;
  const ob = bounds(m.pts);
  let a = 0;
  for (const b of list) {
    if (!b.of.has(m.item) || b.m.id === m.id) continue;
    if (b.box.minX >= ob.maxX || b.box.maxX <= ob.minX || b.box.minY >= ob.maxY || b.box.maxY <= ob.minY) continue;
    a += overlapArea(m.pts, m.holes || [], b.m.pts);
  }
  return a * ftPerUnit * ftPerUnit;
},

/** Formula variables for an item's totals (or one sheet's), in the item's own units. */
export function itemVars(it, t) {
  const lu = lengthUnitOf(it.unit);
  if (it.type === 'linear') {
    return { L: ftTo(t.lengthFt, lu), H: ftTo(it.heightFt, lu), A: sqftTo(t.lengthFt * it.heightFt, areaUnitOf(it.unit)), N: t.count };
  }
  if (it.type === 'area') return { A: sqftTo(t.areaSqft, it.unit), P: ftTo(t.perimeterFt, lu), H: ftTo(it.heightFt, lu), N: t.count };
  if (it.type === 'fixed') return { Q: t.fixed ?? it.qty ?? 0 };
  return { N: t.count };
}

/** A second condition's quantity (T8) in its unit, from its totals ({ lengthFt, areaSqft, count } or none). */
export function condQty(c, t) {
  if (!t) return 0;
  return c.kind === 'linear' ? ftTo(t.lengthFt, lengthUnitOf(c.unit)) : c.kind === 'area' ? sqftTo(t.areaSqft, c.unit) : t.count;
}