Joist depth from a span table the person loads

/** "15-6" = 15 ft 6 in; "15-6 1/2" too; a plain number is feet (imperial) or metres (metric). → mm, or NaN. */
function spanMm(v, metric) {
  if (metric) { const n = num(v); return n > 0 ? n * 1000 : NaN; }
  if (typeof v === 'number') return v > 0 ? v * FT : NaN;
  const s = String(v ?? '').trim();
  const m = /^(\d+)\s*-\s*(\d+(?:\.\d+)?)(?:\s+(\d+)\/(\d+))?$/.exec(s);
  if (m) return +m[1] * FT + (+m[2] + (m[3] ? +m[3] / +m[4] : 0)) * IN;
  const n = Number(s);
  return n > 0 ? n * FT : NaN;
}

const series = String(r?.series ?? '').trim(), depth = num(r?.depth) * u;
if (!series || !(depth > 0)) { errors.push(bad('tji.err.row', { series: series || '?' })); continue; }
const spans = new Map();
for (const [cid, bySp] of Object.entries(r.spans || {})) {
  if (!cases.some((c) => c.id === cid)) { errors.push(bad('tji.err.case', { id: cid })); continue; }
  const list = [];
  for (const [sp, v] of Object.entries(bySp || {})) {
    const spacing = num(sp) * u, max = spanMm(v, metric);
    if (!(spacing > 0) || !(max > 0)) { errors.push(bad('tji.err.span', { series, case: cid, spacing: sp })); continue; }
    list.push({ spacing, max });

/** A listed spacing column serves a requested spacing equal to it or up to 2% CLOSER (400 mm for 16 in, 600 mm for 24 in): never a wider one. */
const spacingFits = (listed, want) => want <= listed * 1.005 && want >= listed * 0.98;

/**
 * The smallest depth (then the shortest-reaching series at that depth) whose listed maximum clear span, for this case and this on-centre
 * spacing, reaches `span` (mm). Refuses, with a plain message, a case or spacing the table does not list and a span beyond every row.
 */
export function pickTji(table, { span, spacing, caseId } = {}) {
  if (!table) return bad('tji.err.none');
  const cs = table.cases.find((c) => c.id === caseId) || table.cases[0];
  const near = (a) => spacingFits(a, spacing);
  const listed = [...new Set(table.rows.flatMap((r) => (r.spans.get(cs.id) || []).map((x) => x.spacing)))].sort((a, b) => a - b);
  if (!listed.some(near)) return bad('tji.err.spacing', { spacing: depthWord(spacing, table.metric), list: listed.map((x) => depthWord(x, table.metric)).join(', '), table: table.id });
  const cands = [];
  for (const r of table.rows) { const hit = (r.spans.get(cs.id) || []).find((x) => near(x.spacing)); if (hit) cands.push({ r, max: hit.max }); }
  cands.sort((a, b) => a.r.depth - b.r.depth || a.max - b.max);
  const top = cands.reduce((m, c) => Math.max(m, c.max), 0);
  const pick = cands.find((c) => c.max + 1e-6 >= span);
  if (!pick) return bad('tji.err.beyond', { span: (span / FT).toFixed(1) + ' ft / ' + (span / 1000).toFixed(2) + ' m', max: (top / FT).toFixed(1) + ' ft / ' + (top / 1000).toFixed(2) + ' m', table: table.id });
  const label = pick.r.label || (pick.r.series + ' ' + depthWord(pick.r.depth, table.metric));
  return { ok: true, series: pick.r.series, depth: pick.r.depth, size: label, max: pick.max, spacing, caseId: cs.id };
}

/** The listed maximum clear span (mm) of the row a framing named by its size label, at this spacing and case: for the regs add-on's check. null = not in the table. */
export function tjiMaxSpan(table, size, spacing, caseId) {
  if (!table) return null;
  const cs = table.cases.find((c) => c.id === caseId) || table.cases[0];
  const r = table.rows.find((x) => (x.label || (x.series + ' ' + depthWord(x.depth, table.metric))) === size);
  const hit = r && (r.spans.get(cs.id) || []).find((x) => spacingFits(x.spacing, spacing));
  return hit ? { span: hit.max, case: cs } : null;
}

const depthWord = (mm, metric) => (metric ? Math.round(mm) + ' mm' : (Math.round(mm / IN * 1000) / 1000) + ' in');