Regulation limits read from the pack's tables

/** The table's width × thickness (mm) for this footing, or null. */
export function footingFromTable(profile, { stories = 1, foundation = 'slab-on-grade', heavy = false, snowPsf = null, soilPsf = 1500 } = {}) {
  const tables = Object.values(profile?.tables || {}).filter((t) => t.kind === 'footing');
  const t = tables.find((x) => (heavy ? /concrete|masonry/i : /light frame$/i).test(String(x.data?.construction || ''))) || tables[0];
  if (!t || !Array.isArray(t.data?.rows)) return null;
  const loads = [...new Set(t.data.rows.map((r) => Number(r.load)))].sort((a, b) => a - b);
  // the "20" row is 20 psf roof live or 25 psf ground snow; a larger snow load takes the next row up
  const want = snowPsf === null ? loads[0] : (loads.find((l) => (l === 20 ? 25 : l) >= snowPsf) ?? null);
  if (want === null) return null;
  const n = Math.max(1, Math.min(3, Math.round(stories)));
  const row = t.data.rows.find((r) => Number(r.load) === want && Number(r.stories) === n && r.foundation === foundation);
  const col = (t.data.columns_psf || []).findIndex((c) => Number(c) >= soilPsf);
  const cell = row && col >= 0 ? String(row.cells[col] || '') : '';
  const m = /^(\d+(?:\.\d+)?)\s*x\s*(\d+(?:\.\d+)?)$/.exec(cell);
  if (!m || +m[2] > 24) return null;   // a printed typo (e.g. "20x60") is not used
  return { width: +m[1] * IN_MM, thick: +m[2] * IN_MM, table: t, load: want };
}

const need = Math.max(rd.value, frost || 0);
out.push(row('foundation', where, synth('found.footing.depth.min', need, frost && frost > rd.value ? rd.clause + ' / frost depth' : rd.clause, rd.label, rd.note), Math.max(0, below - 6 * IN_MM), ref));

const ftIn = (s) => { const m = /^(\d+)-(\d+)/.exec(String(s || '')); return m ? (+m[1] * 12 + +m[2]) * IN_MM : null; };

export function headerSpanFromTable(profile, { size, floorsAbove = 0, snowPsf = null, widthMm }) {
  const t = Object.values(profile?.tables || {}).find((x) => x.kind === 'header' && /R602\.7\(1\)|exterior/i.test(x.id + ' ' + (x.label || '')))
    || Object.values(profile?.tables || {}).find((x) => x.kind === 'header');
  if (!t || !Array.isArray(t.data?.rows)) return null;
  const supporting = floorsAbove <= 0 ? /^roof and ceiling$/i : floorsAbove === 1 ? /one center-bearing floor/i : /two center-bearing floors/i;
  const r = t.data.rows.find((x) => supporting.test(String(x.supporting || '')) && String(x.size) === size);
  if (!r) return null;
  const cols = Object.keys(r.cells || {}).map((k) => [parseFloat(k), k]).sort((a, b) => a[0] - b[0]);
  const s = snowPsf === null ? cols[0] : cols.find(([v]) => v >= Math.max(30, snowPsf));
  if (!s) return null;
  const byW = r.cells[s[1]], ws = Object.keys(byW).map(Number).sort((a, b) => a - b);
  const wFt = widthMm / FT_MM;
  if (wFt > ws[ws.length - 1] + 1e-6) return { beyond: true, table: t };
  const lo = [...ws].reverse().find((x) => x <= wFt) ?? ws[0], hi = ws.find((x) => x >= wFt) ?? ws[ws.length - 1];
  const a = ftIn(byW[String(lo)]), b = ftIn(byW[String(hi)]);
  if (a === null || b === null) return null;
  const span = hi === lo ? a : a + (b - a) * (wFt - lo) / (hi - lo);
  return { span, table: t, snowCol: s[0] };
}

const span = Math.max(0, (p.length || 0) - 3 * IN_MM);

export function studFromTable(profile, { size, bearing, floorsAbove = 0 }) {
  const t = Object.values(profile?.tables || {}).find((x) => x.kind === 'stud');
  const r = t?.data?.rows?.find((x) => x[0] === size);
  if (!r) return null;
  if (!bearing) return { height: r[6] === null ? null : r[6] * FT_MM, spacing: r[7] === null ? null : r[7] * IN_MM, table: t };
  const sp = floorsAbove <= 0 ? r[2] : floorsAbove === 1 ? r[3] : r[4];
  return { height: r[1] === null ? null : r[1] * FT_MM, spacing: sp === null ? null : sp * IN_MM, table: t };
}

// Floor joists: the pack's joist table (kind 'joist', data.rows = [{ species, grade, size, spans: { '16': '15-7', … } }], the 40 psf
// living-area table, the stricter of the two). BimCraft does not record the species, so the span asked for is the LOWEST of the
// table's species for that size and spacing (between listed spacings the next wider one). Joists framed as TJI (engineered) are the
// maker's tables, not the code's, and are left out. A joist's span = its length (the framing tool runs joists wall to wall).
export function spanFromTable(profile, kind, { size, spacingMm }) {
  const t = Object.values(profile?.tables || {}).find((x) => x.kind === kind);
  const rows = (t?.data?.rows || []).filter((r) => r.size === size);
  if (!rows.length) return null;
  const sps = Object.keys(rows[0].spans || {}).map(Number).sort((a, b) => a - b);
  const sIn = spacingMm / IN_MM, col = sps.find((x) => x >= sIn - 0.05);
  if (col === undefined) return null;
  const spans = rows.map((r) => ftIn(r.spans[String(col)])).filter((v) => v !== null);
  return spans.length ? { span: Math.min(...spans), table: t, spacing: col } : null;
}

function roofSpanRows(framings, profile, { ruleId, kind, role, levelName, roomFor }) {
  const r = profile?.rule(ruleId);
  if (!r || !framings?.length) return [];
  const crit = profile.criteria || {};
  const snow = crit.ground_snow_load && crit.ground_snow_load.unit === 'psf' ? Number(crit.ground_snow_load.value) : null;
  const out = [];
  for (const f of framings) {
    const ps = f.pieces.filter((p) => p.role === role && /^\d+x\d+$/.test(p.size));
    if (!ps.length) continue;
    const longest = ps.reduce((a, b) => (b.length > a.length ? b : a));
    const horiz = role === 'rafter' ? longest.length * Math.cos((Number(f.pitch) || 0) * RAD) : longest.length;
    const where = (levelName(f.storey) || '') + ' roof ' + (role === 'rafter' ? 'rafters ' : 'ceiling joists ') + longest.size;
    const jt = spanFromTable(profile, kind, { size: longest.size, spacingMm: f.spacing });
    const rule = { ...r, value: jt ? jt.span : r.value, clause: jt ? jt.table.clause || jt.table.id : r.clause };
    const rw = row('roof', where + (jt ? ' at ' + jt.spacing + ' in' : ''), rule, horiz, longest.guid || f.guid);
    if (!jt || (role === 'rafter' && snow !== null && snow > 20)) { rw.ok = null; rw.found = null; }
    out.push(rw);
  }
  return out;
}

/** A wall type's insulation: { cavity, cont } in R-IP, or null when no layer is insulation (or has no known conductivity). */
export function insulationOf(type, lambdaOf) {
  if (!type?.layers) return null;
  let cavity = 0, cont = 0, any = false;
  for (const l of type.layers) {
    if (!(l.function === 'insulation' || IS_INS.test(String(l.mat || '')))) continue;
    const lam = lambdaOf(String(l.mat || ''));
    if (!(lam > 0) || !(l.t > 0)) continue;
    any = true;
    const r = l.t / 1000 / lam * SI_TO_IP_R;
    if (CONT_INS.test(String(l.mat || ''))) cont += r; else cavity += r;
  }
  return any ? { cavity, cont } : null;
}

const need = opts.length ? Math.min(...opts.map((o) => o.cavity + o.cont)) : 0;
const rule = { ...rw, value: need, clause };
if (!opts.length || !ins) { out.push(note(rule, where, a.ref)); continue; }
const met = opts.some((o) => ins.cavity + 0.05 >= o.cavity && ins.cont + 0.05 >= o.cont);
const rowx = row('wall', where, rule, ins.cavity + ins.cont, a.ref);
rowx.ok = met;   // the options are cavity AND continuous pairs: met by any one