calc-concrete.js

// Group E (cont.): ACI 318-19 reinforced-concrete member bench.
// spec-v257..v259 establish this new lazy-loaded renderer module -- the
// reinforced-concrete member companion to the steel-member bench
// (calc-steel.js, spec-v254..v256) one material over. The catalog already
// placed and cured the concrete (concrete, concrete-mix-design,
// concrete-evaporation-rate, concrete-strength-gain) and counted the rebar
// (rebar, rebar-schedule, rebar-lap-splice), but nothing checked the
// reinforced-concrete member itself: does the beam carry the moment, does it
// carry the shear, and does the bar develop its force. Every tile keeps
// group: "E" (a tile's group letter is independent of the module that holds
// it -- the spec-v70..v98 split precedent). Tiles:
//   v257 rc-beam-flexure        (ACI 318-19 §22.2, singly-reinforced, tension-controlled)
//   v258 rc-beam-shear          (ACI 318-19 §22.5, Vc + Vs and stirrup spacing)
//   v259 rc-development-length  (ACI 318-19 §25.4.2, straight-bar tension ld)
// All GOVERNANCE.general design aids; the psi factors and material strengths
// are user-supplied from the drawings and ACI 318-19 tables. See
// spec-v257.md..v259.md.

import {
  DEBOUNCE_MS, debounce, makeNumber, makeSelect,
  makeOutputLine, attachExampleButton, fmt,
  makeStepsPanel,
} from "./ui-fields.js";

// v18 §7 contract guard: reject a non-finite numeric input (copied verbatim
// from the sibling calc-* modules; non-exported, so it adds no corpus row).
const _finiteGuard = (o) => {
  if (o && typeof o === "object" && !Array.isArray(o)) {
    for (const v of Object.values(o)) {
      if (typeof v === "number" && !Number.isFinite(v)) {
        return { error: "All numeric inputs must be finite numbers." };
      }
    }
  }
  return null;
};

// Compact renderer factory (same shape as the calc-steel / calc-firesprinkler
// _simpleRenderer factories) supporting number and select inputs.
function _simpleRenderer(spec) {
  const _rlRender = function (inputRegion, outputRegion, citationEl) {
    citationEl.textContent = spec.citation;
    attachExampleButton(inputRegion, () => fillExample(spec.example));
    const fields = {};
    for (const f of spec.fields) {
      let field;
      if (f.kind === "select") field = makeSelect(f.label, f.id || f.key, f.options);
      else field = makeNumber(f.label, f.id || f.key, f.attrs || { step: "any", min: "0" });
      fields[f.key] = field;
      if (f.default !== undefined) {
        if (f.kind === "select") field.select.value = f.default;
        else field.input.value = String(f.default);
      }
      inputRegion.appendChild(field.wrap);
    }
    const outs = {};
    for (const o of spec.outputs) outs[o.key] = makeOutputLine(outputRegion, o.label, o.id);
    const _steps = makeStepsPanel(outputRegion);
    function fillExample(v) {
      for (const f of spec.fields) {
        if (v[f.key] === undefined) continue;
        if (f.kind === "select") fields[f.key].select.value = v[f.key];
        else fields[f.key].input.value = v[f.key];
      }
      update();
    }
    const update = debounce(() => {
      const params = {};
      for (const f of spec.fields) {
        if (f.kind === "select") params[f.key] = fields[f.key].select.value;
        // A field marked `required` passes null when blank, so the compute can
        // ask for it. Blank must not become 0 where 0 is a real value (0 F).
        else params[f.key] = f.required && fields[f.key].input.value === "" ? null : Number(fields[f.key].input.value) || 0;
      }
      const r = spec.compute(params); _steps.update(spec.fields, params, r);
      if (r.error) { for (const k of Object.keys(outs)) outs[k].textContent = "-"; outs[spec.outputs[0].key].textContent = r.error; return; }
      for (const o of spec.outputs) outs[o.key].textContent = o.value(r);
    }, DEBOUNCE_MS);
    for (const f of spec.fields) {
      const el = f.kind === "select" ? fields[f.key].select : fields[f.key].input;
      el.addEventListener(f.kind === "select" ? "change" : "input", update);
    }
  };

  _rlRender.schema = {
    inputs: (spec.fields || []).map((f) => ({ key: f.key, label: f.label, kind: f.kind ?? "number", options: f.options ?? null, default: f.default ?? null, attrs: f.attrs ?? (f.kind && f.kind !== "number" ? null : { step: "any", min: "0" }) })),
    outputs: (spec.outputs || []).map((o) => ({ key: o.key, label: o.label, unit: o.unit ?? null, format: o.value })),
    citation: spec.citation ?? null,
    scope: spec.scope ?? null,
  };
  return _rlRender;
}

export const CONCRETE_RENDERERS = {};

// ===================== spec-v257: reinforced concrete beam flexural capacity =====================

// dims: in { fc: M L^-1 T^-2, fy: M L^-1 T^-2, as_in2: L^2, b: L, d: L, mu: M L^2 T^-2 } out: { a_in: L, mn_kipft: M L^2 T^-2, phi_mn: M L^2 T^-2, util: dimensionless, eps_t: dimensionless, tc_limit: dimensionless, tension_controlled: dimensionless }
export function computeRcBeamFlexure({ fc = 4000, fy = 60000, as_in2 = 0, b = 0, d = 0, mu = 0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  if (!(fc > 0)) return { error: "Concrete strength f'c must be positive (psi)." };
  if (!(fy > 0)) return { error: "Steel yield fy must be positive (psi)." };
  if (!(as_in2 > 0)) return { error: "Tension steel area As must be positive (in^2)." };
  if (!(b > 0)) return { error: "Beam width b must be positive (in)." };
  if (!(d > 0)) return { error: "Effective depth d must be positive (in)." };
  const a_in = (as_in2 * fy) / (0.85 * fc * b);
  const mn_kipin = as_in2 * fy * (d - a_in / 2) / 1000;
  const mn_kipft = mn_kipin / 12;
  // phi = 0.90 holds only for a tension-controlled section, and ACI 318-19 9.3.3.1 requires a
  // nonprestressed beam to be one (eps_t >= eps_ty + 0.003). Until 2026-10-03 this was never
  // checked, so an over-reinforced beam read "OK" at phi 0.90; until 2026-10-10 the check only
  // changed a label and phi Mn was still 0.90 Mn (21% high on a section the T-beam tile rates at
  // phi 0.745). phi now follows Table 21.2.2, as the T-beam and doubly reinforced tiles do.
  const c_in = a_in / _RC_BETA1(fc);
  if (c_in >= d) return { error: "The neutral axis falls at or below the tension steel - this section is grossly over-reinforced and cannot be designed as a beam. Reduce As or enlarge the section." };
  const eps_t = 0.003 * (d - c_in) / c_in;
  const eps_ty = fy / 29e6;
  const tc_limit = eps_ty + 0.003;
  const tension_controlled = eps_t >= tc_limit - 1e-9 * tc_limit;
  const phi = tension_controlled ? 0.90 : eps_t <= eps_ty ? 0.65 : 0.65 + 0.25 * (eps_t - eps_ty) / 0.003;
  const phi_mn = phi * mn_kipft;
  const util = mu > 0 ? mu / phi_mn : null;
  return { a_in, mn_kipft, phi_mn, util, eps_t, tc_limit, tension_controlled, phi };
}

export const rcBeamFlexureExample = { inputs: { fc: 4000, fy: 60000, as_in2: 3.00, b: 12, d: 21.5, mu: 200 } };

CONCRETE_RENDERERS["rc-beam-flexure"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 §22.2.2.4.1 (equivalent rectangular stress block, a = As x fy / (0.85 x f'c x b)), §22.2 (Mn = As x fy x (d - a/2)), and §21.2.2 (phi = 0.90 for a tension-controlled section, net tensile strain at least fy/Es + 0.003, falling linearly to 0.65 at fy/Es). Covers only a singly-reinforced rectangular section; a beam that is not tension-controlled fails §9.3.3.1 and is reported at its reduced phi; compression reinforcement, T-beam flange action, minimum steel (§9.6.1.2), and shear are not checked here (see the RC beam shear tile). Take As and d from the reinforcement schedule for the actual section. A design aid, not a substitute for a licensed engineer's design -- the engineer of record's stamped design governs.",
  example: rcBeamFlexureExample.inputs,
  fields: [
    { key: "fc", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "fy", label: "Steel yield fy (psi)", kind: "number" },
    { key: "as_in2", label: "Tension steel area As (in²)", kind: "number" },
    { key: "b", label: "Beam width b (in)", kind: "number" },
    { key: "d", label: "Effective depth d (in)", kind: "number" },
    { key: "mu", label: "Required moment Mu (kip-ft, 0 = capacity only)", kind: "number", default: 0, attrs: { step: "any" } },
  ],
  outputs: [
    { key: "a", id: "rbf-out-a", label: "Stress-block depth a", value: (r) => fmt(r.a_in, 2) + " in" },
    { key: "mn", id: "rbf-out-mn", label: "Nominal moment Mn", value: (r) => fmt(r.mn_kipft, 1) + " kip-ft" },
    { key: "pm", id: "rbf-out-pm", label: "Design moment phi Mn", value: (r) => fmt(r.phi_mn, 1) + " kip-ft (phi = " + fmt(r.phi, 2) + (r.tension_controlled ? ")" : "; NOT tension-controlled, eps_t " + fmt(r.eps_t, 4) + " under " + fmt(r.tc_limit, 4) + " -- fails ACI 318-19 9.3.3.1)") },
    { key: "ut", id: "rbf-out-ut", label: "Demand / capacity", value: (r) => r.util === null ? "- (no Mu entered)" : fmt(r.util, Math.abs(r.util - 1) < 0.005 && r.util !== 1 ? 4 : 2) + (r.util <= 1 + 1e-9 ? (r.tension_controlled ? " (OK)" : " (NOT tension-controlled - fails ACI 318-19 9.3.3.1)") : " (OVER)") },
  ],
  compute: computeRcBeamFlexure,
});

// ===================== spec-v258: reinforced concrete beam shear and stirrup spacing =====================

// The simplified Vc (Table 22.5.5.1(a)) holds only with Av >= Av,min, and
// 9.6.3.1 requires Av,min wherever Vu > phi lambda sqrt(f'c) bw d (half of
// phi Vc here). s_max_in is the governing maximum spacing: 9.7.6.2.2's d/2 <=
// 24 in (d/4 <= 12 in when Vs > 4 sqrt(f'c) bw d) and the spacing at which Av
// still meets 9.6.3.4's Av,min = max(0.75 sqrt(f'c), 50) bw s / fyt. Until
// 2026-09-25 these were listed as separate checks and s_max was a bare d/2.
// dims: in { fc: M L^-1 T^-2, fyt: M L^-1 T^-2, bw: L, d: L, av_in2: L^2, vu: M L T^-2, lambda: dimensionless, stirrup_type: dimensionless } out: { vc_kip: M L T^-2, phi_vc: M L T^-2, vs_req_kip: M L T^-2, s_req_in: L, s_max_in: L, s_avmin_in: L }
export function computeRcBeamShear({ fc = 4000, fyt = 60000, bw = 0, d = 0, av_in2 = 0, vu = 0, lambda = 1.0, stirrup_type = "bar" } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  if (!(fc > 0)) return { error: "Concrete strength f'c must be positive (psi)." };
  if (!(fyt > 0)) return { error: "Stirrup yield fyt must be positive (psi)." };
  if (!(bw > 0)) return { error: "Web width bw must be positive (in)." };
  if (!(d > 0)) return { error: "Effective depth d must be positive (in)." };
  if (!(av_in2 > 0)) return { error: "Stirrup area Av must be positive (in^2)." };
  if (!(lambda > 0)) return { error: "Lightweight factor lambda must be positive." };
  if (lambda > 1) return { error: "Lightweight factor lambda cannot exceed 1.0 (ACI 318-19 19.2.4)." };
  // ACI 318-19 Table 20.2.2.4(a) caps fyt for shear at 60,000 psi for deformed bars and 80,000 psi
  // for welded deformed wire; the shear-friction and corbel tiles already apply the same table.
  // Until 2026-10-07 a Grade 80 or 100 stirrup spread its spacing in proportion to the grade.
  if (stirrup_type !== "bar" && stirrup_type !== "wwr") return { error: "Stirrup type must be bar (deformed bar) or wwr (welded deformed wire)." };
  const fyt_used_psi = Math.min(fyt, stirrup_type === "wwr" ? 80000 : 60000);
  const vc_kip = 2 * lambda * Math.sqrt(fc) * bw * d / 1000;
  const phi_vc = 0.75 * vc_kip;
  const vs_req_kip = vu > 0 ? Math.max(0, vu / 0.75 - vc_kip) : 0;
  const s_req_in = vs_req_kip > 0 ? av_in2 * fyt_used_psi * d / (vs_req_kip * 1000) : null;
  const sqfc_bwd_kip = Math.sqrt(fc) * bw * d / 1000;
  // 22.5.3.1 caps sqrt(f'c) at 100 psi unless Av,min is provided (22.5.3.2), so the test for
  // "no stirrups at all" uses the capped value. Until 2026-10-10 a 16,000 psi beam was told it
  // needed none at a shear the capped expression does not allow.
  const min_required = vu > 0.75 * lambda * Math.min(Math.sqrt(fc), 100) * bw * d / 1000;
  const s_avmin_in = av_in2 * fyt_used_psi / (Math.max(0.75 * Math.sqrt(fc), 50) * bw);
  const tight = vs_req_kip > 4 * sqfc_bwd_kip;
  const s_geom_in = tight ? Math.min(d / 4, 12) : Math.min(d / 2, 24);
  const s_max_in = Math.min(s_geom_in, s_avmin_in);
  const section_ok = vs_req_kip <= (8 * sqfc_bwd_kip) + 1e-9 * Math.abs(8 * sqfc_bwd_kip);
  const stirrups = vu > phi_vc;
  return { vc_kip, phi_vc, vs_req_kip, s_req_in, s_max_in, s_avmin_in, fyt_used_psi, s_max_rule: s_avmin_in < s_geom_in ? "Av,min" : tight ? "d/4" : "d/2", min_required, section_ok, stirrups };
}

export const rcBeamShearExample = { inputs: { fc: 4000, fyt: 60000, bw: 12, d: 21.5, av_in2: 0.22, vu: 40, lambda: 1.0 } };

CONCRETE_RENDERERS["rc-beam-shear"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 §22.5.5.1 (Vc = 2 x lambda x sqrt(f'c) x bw x d, the simplified concrete shear for a non-prestressed member without axial load, psi units), §22.5.10.5.3 (Vs = Av x fyt x d / s for vertical stirrups), §21.2.1 (phi = 0.75 for shear), and §9.7.6.2.2 (the d/2 <= 24 in maximum stirrup spacing, halved to d/4 <= 12 in when Vs exceeds 4 x sqrt(f'c) x bw x d), §9.6.3.1 and §9.6.3.4 (Av,min = max(0.75 sqrt(f'c), 50) bw s / fyt wherever Vu > phi lambda sqrt(f'c) bw d, the condition for the simplified Vc), and §22.5.1.2 (Vs <= 8 sqrt(f'c) bw d). Uses the simplified Vc, not the detailed §22.5.5.1 expression with the reinforcement-ratio and size-effect terms; covers vertical stirrups on a member without significant axial load; does not check deep-beam action. Lambda is 1.0 normalweight, 0.75 lightweight (§19.2.4). A design aid, not a substitute for a licensed engineer's design -- the engineer of record's stamped design governs.",
  example: rcBeamShearExample.inputs,
  fields: [
    { key: "fc", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "fyt", label: "Stirrup yield fyt (psi)", kind: "number" },
    { key: "stirrup_type", label: "Stirrup type (sets the 20.2.2.4(a) fyt cap)", kind: "select", options: [{ value: "bar", label: "Deformed bar (fyt up to 60,000 psi)", selected: true }, { value: "wwr", label: "Welded deformed wire (up to 80,000 psi)" }] },
    { key: "bw", label: "Web width bw (in)", kind: "number" },
    { key: "d", label: "Effective depth d (in)", kind: "number" },
    { key: "av_in2", label: "Stirrup area Av, both legs (in²)", kind: "number" },
    { key: "vu", label: "Factored shear Vu (kip, 0 = capacity only)", kind: "number", default: 0, attrs: { step: "any" } },
    { key: "lambda", label: "Lightweight factor lambda (1.0 normalweight)", kind: "number" },
  ],
  outputs: [
    { key: "vc", id: "rbs-out-vc", label: "Concrete shear Vc", value: (r) => fmt(r.vc_kip, 1) + " kip" },
    { key: "pv", id: "rbs-out-pv", label: "Design concrete shear phi Vc (phi = 0.75)", value: (r) => fmt(r.phi_vc, 1) + " kip" },
    { key: "st", id: "rbs-out-st", label: "Stirrups required", value: (r) => !r.section_ok ? "SECTION TOO SMALL (Vs > 8 sqrt(f'c) bw d; enlarge the beam)" : r.stirrups ? "YES by strength (Vu > phi Vc)" : r.min_required ? "YES, the Av,min minimum (Vu > phi lambda sqrt(f'c) bw d)" : "no (Vu <= phi lambda sqrt(f'c) bw d)" },
    { key: "vs", id: "rbs-out-vs", label: "Stirrup shear demand Vs,req", value: (r) => fmt(r.vs_req_kip, 1) + " kip" },
    { key: "sr", id: "rbs-out-sr", label: "Required stirrup spacing", value: (r) => r.s_req_in === null ? "- (none required by strength)" : fmt(r.s_req_in, 1) + " in" },
    { key: "sm", id: "rbs-out-sm", label: "Code max spacing", value: (r) => fmt(r.s_max_in, 2) + " in (" + r.s_max_rule + " governs; Av,min allows " + fmt(r.s_avmin_in, 1) + " in)" },
  ],
  compute: computeRcBeamShear,
});

// ===================== spec-v259: rebar tension development length =====================

// dims: in { fc: M L^-1 T^-2, fy: M L^-1 T^-2, db: L, psi_t: dimensionless, psi_e: dimensionless, psi_s: dimensionless, psi_g: dimensionless, lambda: dimensionless, conf: dimensionless } out: { te: dimensionless, conf_eff: dimensionless, ld_in: L, ld_db: dimensionless }
export function computeRcDevelopmentLength({ fc = 4000, fy = 60000, db = 0, psi_t = 1.0, psi_e = 1.0, psi_s = 1.0, psi_g = 1.0, lambda = 1.0, conf = 2.5 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  if (!(fc > 0)) return { error: "Concrete strength f'c must be positive (psi)." };
  if (!(fy > 0)) return { error: "Bar yield fy must be positive (psi)." };
  if (!(db > 0)) return { error: "Bar diameter db must be positive (in)." };
  if (!(conf > 0)) return { error: "Confinement term (cb + Ktr)/db must be positive." };
  if (!(psi_t > 0) || !(psi_e > 0) || !(psi_s > 0) || !(psi_g > 0)) return { error: "The psi factors must be positive." };
  // Table 25.4.2.5 has no value under 1.0 for casting position, coating or grade, and none under
  // 0.8 for bar size. A smaller entry shortened ld in proportion with nothing said.
  if (psi_t < 1 || psi_e < 1 || psi_g < 1) return { error: "psi_t, psi_e and psi_g are 1.0 or more in ACI 318-19 Table 25.4.2.5." };
  if (psi_s < 0.8) return { error: "The bar-size factor psi_s is 0.8 (No. 6 and smaller) or 1.0 in ACI 318-19 Table 25.4.2.5." };
  if (!(lambda > 0)) return { error: "Lightweight factor lambda must be positive." };
  if (lambda > 1) return { error: "Lightweight factor lambda cannot exceed 1.0 (ACI 318-19 19.2.4)." };
  const te = Math.min(psi_t * psi_e, 1.7);
  const conf_eff = Math.min(conf, 2.5);
  // 25.4.1.4 caps sqrt(f'c) at 100 psi in development-length calculations
  // (no exception, unlike shear's 22.5.3.2). sqrt(f'c) is in the denominator,
  // so the cap lengthens ld above f'c = 10,000 psi - the conservative direction.
  const sqrt_fc = Math.min(Math.sqrt(fc), 100);
  // Table 25.4.2.5 fixes psi_g by bar grade: 1.0 for Grade 40/60, 1.15 for
  // Grade 80, 1.3 for Grade 100. An entered psi_g below the grade's value is
  // raised to it; until 2026-09-25 a Grade 80 bar left at 1.0 read 13% short.
  const psi_g_grade = fy <= 60000 ? 1.0 : fy <= 80000 ? 1.15 : 1.3;
  const psi_g_used = Math.max(psi_g, psi_g_grade);
  const ld_calc = (3 / 40) * fy * te * psi_s * psi_g_used / (lambda * sqrt_fc * conf_eff) * db;
  const ld_in = Math.max(ld_calc, 12);
  const ld_db = ld_in / db;
  return { te, conf_eff, ld_in, ld_db, psi_g_used };
}

export const rcDevelopmentLengthExample = { inputs: { fc: 4000, fy: 60000, db: 1.00, psi_t: 1.0, psi_e: 1.0, psi_s: 1.0, psi_g: 1.0, lambda: 1.0, conf: 2.5 } };

CONCRETE_RENDERERS["rc-development-length"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 §25.4.2.3 (the general tension development-length equation ld = (3/40) x (fy x psi_t x psi_e x psi_s x psi_g) / (lambda x sqrt(f'c) x ((cb + Ktr)/db)) x db), §25.4.2.4 (the (cb + Ktr)/db confinement term, capped at 2.5), §25.4.2.5 / Table 25.4.2.5 (psi_t casting position 1.3 top bar / 1.0 other, psi_e coating 1.5 or 1.2 epoxy / 1.0 uncoated, psi_s size 0.8 for #6 and smaller / 1.0 for #7 and larger, psi_g grade 1.0 Gr 60 / 1.15 Gr 80 / 1.3 Gr 100, with psi_t x psi_e capped at 1.7), §25.4.2.1 (the 12 in minimum), and §25.4.1.4 (the value of sqrt(f'c) shall not exceed 100 psi, so f'c above 10,000 psi does not further shorten ld). The psi factors are user-selected inputs, not derived here -- the tool does not read cover, spacing, or transverse reinforcement to compute cb or Ktr. Straight-bar tension development only: not a standard hook (§25.4.3), a compression bar (§25.4.9), or a lap splice (§25.5, see the rebar lap splice tile). Lambda is 1.0 normalweight, 0.75 lightweight. A design aid, not a substitute for a licensed engineer's design -- the engineer of record's detailing governs.",
  example: rcDevelopmentLengthExample.inputs,
  fields: [
    { key: "fc", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "fy", label: "Bar yield fy (psi)", kind: "number" },
    { key: "db", label: "Bar diameter db (in, #8 = 1.00)", kind: "number" },
    { key: "psi_t", label: "Casting position psi_t (1.3 top bar, 1.0 other)", kind: "number" },
    { key: "psi_e", label: "Coating psi_e (1.5 / 1.2 epoxy, 1.0 uncoated)", kind: "number" },
    { key: "psi_s", label: "Bar size psi_s (0.8 for #6 and smaller, else 1.0)", kind: "number" },
    { key: "psi_g", label: "Grade psi_g (raised to 1.15 Gr 80 / 1.3 Gr 100 from fy)", kind: "number" },
    { key: "lambda", label: "Lightweight factor lambda (1.0 normalweight)", kind: "number" },
    { key: "conf", label: "Confinement (cb + Ktr)/db (max 2.5)", kind: "number" },
  ],
  outputs: [
    { key: "te", id: "rdl-out-te", label: "psi_t x psi_e (capped 1.7)", value: (r) => fmt(r.te, 2) },
    { key: "ce", id: "rdl-out-ce", label: "Confinement term used (capped 2.5)", value: (r) => fmt(r.conf_eff, 2) },
    { key: "ld", id: "rdl-out-ld", label: "Development length ld (12 in floor)", value: (r) => fmt(r.ld_in, 1) + " in" },
    { key: "db", id: "rdl-out-db", label: "In bar diameters", value: (r) => fmt(r.ld_db, 1) + " db" },
  ],
  compute: computeRcDevelopmentLength,
});

// ===================== spec-v284..v286: reinforced-concrete member depth batch =====================
// The ACI checks the beam flexure/shear/development bench left open: the tied
// column's concentric axial capacity (22.4), two-way punching shear at a
// column (22.6), and the standard-hook development length (25.4.3).

// dims: in { b_in: L, h_in: L, fc_psi: M L^-1 T^-2, fy_psi: M L^-1 T^-2, ast_in2: L^2 } out: { ag_in2: L^2, rho_g: dimensionless, po_kip: M L T^-2, phi_pn_kip: M L T^-2 }
export function computeRcColumnAxial({ b_in = 0, h_in = 0, fc_psi = 4000, fy_psi = 60000, ast_in2 = 0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  if (!(b_in > 0) || !(h_in > 0)) return { error: "Column dimensions must be positive (in)." };
  if (!(fc_psi > 0) || !(fy_psi > 0)) return { error: "Concrete and steel strengths must be positive (psi)." };
  if (!(ast_in2 > 0)) return { error: "Longitudinal steel area must be positive (in^2)." };
  const ag_in2 = b_in * h_in;
  if (!(ast_in2 < ag_in2)) return { error: "The steel area must be less than the gross section." };
  const rho_g = ast_in2 / ag_in2;
  const rho_flag = rho_g < 0.01 ? "below the ACI 10.6.1 1% minimum" : (rho_g > 0.08 ? "above the ACI 10.6.1 8% maximum" : "within the ACI 10.6.1 1-8% range");
  // ACI 318-19 22.4.2.1 limits fy to 80,000 psi in Po: high-strength bar cannot be credited past
  // the strain concrete reaches in pure compression. Until 2026-09-25 a Grade 100 bar was taken
  // at 100 ksi (StructurePoint's 18x18, 4 in^2 Grade 100 column: 1,488 kip here vs 1,408).
  const fy_used = Math.min(fy_psi, 80000);
  const po_lb = 0.85 * fc_psi * (ag_in2 - ast_in2) + fy_used * ast_in2;
  const phi_pn_lb = 0.80 * 0.65 * po_lb;
  const po_kip = po_lb / 1000;
  const phi_pn_kip = phi_pn_lb / 1000;
  return {
    ag_in2, rho_g, rho_flag, po_kip, phi_pn_kip,
    note: "ACI 318-19 22.4.2: nominal axial strength Po = 0.85 f'c (Ag - Ast) + fy Ast, with fy not more than 80,000 psi (22.4.2.1), with the 22.4.2.1 tied-column design cap phi Pn,max = 0.80 phi Po (phi = 0.65, compression-controlled tied) covering the accidental eccentricity a concentric load never truly avoids. Longitudinal steel belongs in the 10.6.1 1-8% ratio band. Concentric short tied column only - no P-M interaction diagram, no slenderness or second-order effects, and the spiral (0.85 / phi = 0.75) variant and tie detailing are separate. A design aid, not a substitute for the structural engineer of record's stamped design.",
  };
}
export const rcColumnAxialExample = { inputs: { b_in: 16, h_in: 16, fc_psi: 4000, fy_psi: 60000, ast_in2: 6.32 } };

// rc-column-steel-for-load: inverse of rc-column-axial. The forward tile gives the design axial strength from the steel
// area; the inverse recovers the longitudinal steel a target factored axial load needs for a given column size. From
// phi Pn = 0.80 x 0.65 x [0.85 f'c (Ag - Ast) + fy Ast] = 0.52 x Po,
// Ast = (phi Pn / 0.52 - 0.85 f'c Ag) / (fy - 0.85 f'c). The 1% minimum governs the minimum and 8% the maximum (ACI 10.6.1).
// dims: in { target_load_kip: M L T^-2, b_in: L, h_in: L, fc_psi: M L^-1 T^-2, fy_psi: M L^-1 T^-2 } out: { ast_required_in2: L^2, ag_in2: L^2, rho_g: dimensionless }
export function computeRcColumnSteelForLoad({ target_load_kip = 0, b_in = 0, h_in = 0, fc_psi = 4000, fy_psi = 60000 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const target = Number(target_load_kip) || 0;
  const b = Number(b_in) || 0;
  const h = Number(h_in) || 0;
  const fc = Number(fc_psi) || 0;
  const fy = Number(fy_psi) || 0;
  if (!(target > 0)) return { error: "Target factored axial load must be positive (kip)." };
  if (!(b > 0) || !(h > 0)) return { error: "Column dimensions must be positive (in)." };
  if (!(fc > 0) || !(fy > 0)) return { error: "Concrete and steel strengths must be positive (psi)." };
  if (!(Math.min(fy, 80000) > 0.85 * fc)) return { error: "Steel yield (capped at 80,000 psi in Po) must exceed 0.85 f'c." };
  const ag_in2 = b * h;
  const fyc = Math.min(fy, 80000); // ACI 318-19 22.4.2.1 caps fy at 80 ksi in Po, as the forward tile does
  const ast_strength = (target * 1000 / 0.52 - 0.85 * fc * ag_in2) / (fyc - 0.85 * fc);
  const ast_min = 0.01 * ag_in2;
  const ast_max = 0.08 * ag_in2;
  const ast_required_in2 = Math.max(ast_strength, ast_min);
  const rho_g = ast_required_in2 / ag_in2;
  const governs = ast_strength <= ast_min ? "the ACI 10.6.1 1% minimum" : "strength";
  const over_max = ast_required_in2 > ast_max + 1e-9 * Math.abs(ast_max);
  if (![ast_required_in2, ag_in2, rho_g].every(Number.isFinite)) return { error: "Column-steel math is not a finite value." };
  return {
    ast_required_in2, ag_in2, rho_g, ast_min_in2: ast_min, ast_max_in2: ast_max, governs, over_max,
    note: "ACI 318-19 22.4.2 concentric tied column solved for the steel: Ast = (phi Pn / 0.52 - 0.85 f'c Ag) / (fy - 0.85 f'c), with phi Pn = 0.80 x 0.65 x Po the tied-column design cap. The reported Ast is the LARGER of the strength requirement and the ACI 10.6.1 1% minimum (Ast_min = 0.01 Ag); if the strength requirement exceeds the 8% maximum (0.08 Ag), the section is too small for the load - enlarge the column or raise f'c. Round UP to a whole-bar layout that also satisfies the tie and clear-cover detailing. Concentric short tied column only - no P-M interaction, slenderness, or second-order effects, and a spiral column uses different phi factors. A design aid, not a substitute for the structural engineer of record's stamped design.",
  };
}
export const rcColumnSteelForLoadExample = { inputs: { target_load_kip: 639, b_in: 16, h_in: 16, fc_psi: 4000, fy_psi: 60000 } };
CONCRETE_RENDERERS["rc-column-steel-for-load"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 22.4.2 concentric tied column phi Pn = 0.80 x 0.65 x [0.85 f'c (Ag - Ast) + fy Ast] solved for the steel: Ast = (phi Pn / 0.52 - 0.85 f'c Ag) / (fy - 0.85 f'c), with the 10.6.1 1-8% band. Concentric short tied column; no P-M interaction or slenderness. A design aid, not a substitute for the engineer of record.",
  example: rcColumnSteelForLoadExample.inputs,
  fields: [
    { key: "target_load_kip", label: "Target factored axial load phi Pn (kip)", kind: "number" },
    { key: "b_in", label: "Column width b (in)", kind: "number" },
    { key: "h_in", label: "Column depth h (in)", kind: "number" },
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "fy_psi", label: "Steel yield fy (psi)", kind: "number" },
  ],
  outputs: [
    { key: "ast", id: "rcs-out-ast", label: "Required longitudinal steel Ast", value: (r) => fmt(r.ast_required_in2, 2) + " in^2 (" + fmt(r.rho_g * 100, 2) + "%, governed by " + r.governs + ")" + (r.over_max ? " -- OVER 8%, section too small" : "") },
    { key: "band", id: "rcs-out-band", label: "ACI 1-8% band", value: (r) => fmt(r.ast_min_in2, 2) + " to " + fmt(r.ast_max_in2, 2) + " in^2 (Ag " + fmt(r.ag_in2, 0) + " in^2)" },
    { key: "n", id: "rcs-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeRcColumnSteelForLoad,
});

CONCRETE_RENDERERS["rc-column-axial"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 22.4.2 nominal axial strength Po = 0.85 f'c (Ag - Ast) + fy Ast with the 22.4.2.1 tied-column cap phi Pn,max = 0.80 phi Po (phi = 0.65) and the 10.6.1 1-8% longitudinal ratio, by name. Concentric short tied column; no P-M interaction or slenderness. A design aid, not a substitute for the engineer of record.",
  example: rcColumnAxialExample.inputs,
  fields: [
    { key: "b_in", label: "Column width b (in)", kind: "number" },
    { key: "h_in", label: "Column depth h (in)", kind: "number" },
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "fy_psi", label: "Steel yield fy (psi)", kind: "number" },
    { key: "ast_in2", label: "Total longitudinal steel Ast (in²)", kind: "number" },
  ],
  outputs: [
    { key: "ag", id: "rca-out-ag", label: "Gross area Ag", value: (r) => fmt(r.ag_in2, 0) + " in^2" },
    { key: "rho", id: "rca-out-rho", label: "Steel ratio rho_g", value: (r) => fmt(r.rho_g * 100, 2) + "% (" + r.rho_flag + ")" },
    { key: "po", id: "rca-out-po", label: "Nominal Po", value: (r) => fmt(r.po_kip, 0) + " kip" },
    { key: "pn", id: "rca-out-pn", label: "Design phi Pn,max (0.80 x 0.65 x Po)", value: (r) => fmt(r.phi_pn_kip, 0) + " kip" },
    { key: "n", id: "rca-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeRcColumnAxial,
});

// dims: in { c1_in: L, c2_in: L, d_in: L, fc_psi: M L^-1 T^-2, position: dimensionless, lambda: dimensionless } out: { bo_in: L, beta: dimensionless, lambda_s: dimensionless, vc_psi: M L^-1 T^-2, phi_vc_kip: M L T^-2 }
export function computeRcPunchingShear({ c1_in = 0, c2_in = 0, d_in = 0, fc_psi = 4000, position = "interior", lambda = 1.0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  if (!(c1_in > 0) || !(c2_in > 0)) return { error: "Column plan dimensions must be positive (in)." };
  if (!(d_in > 0)) return { error: "Effective slab depth must be positive (in)." };
  if (!(fc_psi > 0)) return { error: "Concrete strength must be positive (psi)." };
  if (!(lambda > 0 && lambda <= 1)) return { error: "The lightweight factor lambda is over 0 and up to 1.0." };
  if (position !== "interior" && position !== "edge" && position !== "corner") return { error: "Column position must be interior, edge, or corner." };
  const alpha_s = position === "edge" ? 30 : (position === "corner" ? 20 : 40);
  // The critical section sits d/2 from the column faces, and a slab edge cuts
  // it off (ACI 318-19 22.6.4): interior four sides, edge three sides (c1
  // perpendicular to the edge, slab flush with the column's outer face),
  // corner two sides. Until 2026-09-18 every position took the four-sided
  // perimeter, 35% (edge) to 78% (corner) unconservative.
  const bo_in = position === "edge" ? 2 * (c1_in + d_in / 2) + (c2_in + d_in)
    : position === "corner" ? (c1_in + d_in / 2) + (c2_in + d_in / 2)
      : 2 * (c1_in + d_in) + 2 * (c2_in + d_in);
  const beta = Math.max(c1_in, c2_in) / Math.min(c1_in, c2_in);
  const t1 = 4;
  const t2 = 2 + 4 / beta;
  const t3 = 2 + (alpha_s * d_in) / bo_in;
  const least = Math.min(t1, t2, t3);
  const governs = least === t1 ? "the 4 sqrt(f'c) base term" : (least === t2 ? "the aspect-ratio (2 + 4/beta) term" : "the (2 + alpha_s d/bo) large-column term");
  const lambda_s = Math.min(Math.sqrt(2 / (1 + d_in / 10)), 1.0);
  // 22.5.3.1 caps sqrt(f'c) at 100 psi for two-way shear Vc; the 22.5.3.2
  // exception that lifts the cap requires minimum shear reinforcement, which
  // this no-shear-reinforcement punching case does not have. So the cap holds,
  // and it only bites above f'c = 10,000 psi.
  const sqrt_fc = Math.min(Math.sqrt(fc_psi), 100);
  const vc_psi = least * lambda_s * lambda * sqrt_fc;
  const phi_vc_kip = (0.75 * vc_psi * bo_in * d_in) / 1000;
  return {
    bo_in, beta, alpha_s, t2, t3, least, governs, lambda_s, vc_psi, phi_vc_kip,
    note: "ACI 318-19 Table 22.6.5.2 two-way (punching) shear on the d/2 critical perimeter: vc is the least of 4 lambda sqrt(f'c), (2 + 4/beta) lambda sqrt(f'c), and (2 + alpha_s d/bo) lambda sqrt(f'c), with alpha_s = 40/30/20 for an interior/edge/corner column and phi = 0.75; phi Vc = phi vc bo d. All three terms also carry the 22.5.5.1.3 size-effect factor lambda_s = sqrt(2 / (1 + d/10)) capped at 1.0 (new in the 2019 edition), so lambda_s is 1.0 up to d = 10 in and drops below it for deeper slabs and footings, cutting the punching capacity of thick members. sqrt(f'c) is capped at 100 psi per 22.5.3.1 (the 22.5.3.2 exception needs minimum shear reinforcement, which this case lacks), so it only affects f'c above 10,000 psi. Shear without unbalanced-moment transfer (no gamma_v amplification), no shear reinforcement or drop panel, rectangular column; the edge (three-sided) and corner (two-sided) perimeters assume the slab edge flush with the column face, c1 measured perpendicular to the edge. A design aid, not a substitute for the structural engineer of record's stamped design.",
  };
}
export const rcPunchingShearExample = { inputs: { c1_in: 20, c2_in: 20, d_in: 6, fc_psi: 4000, position: "interior", lambda: 1.0 } };

CONCRETE_RENDERERS["rc-punching-shear"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 Table 22.6.5.2 two-way shear (least of 4, 2 + 4/beta, 2 + alpha_s d/bo, each x the 22.5.5.1.3 size-effect factor lambda_s and lambda sqrt(f'c)) on the 22.6.4.1 d/2 critical perimeter, alpha_s = 40/30/20 interior/edge/corner, the 22.5.3.1 sqrt(f'c) <= 100 psi cap, and phi = 0.75, by name. No unbalanced-moment transfer or shear reinforcement. A design aid, not a substitute for the engineer of record.",
  example: rcPunchingShearExample.inputs,
  fields: [
    { key: "c1_in", label: "Column dimension c1 (in)", kind: "number" },
    { key: "c2_in", label: "Column dimension c2 (in)", kind: "number" },
    { key: "d_in", label: "Effective slab depth d (in)", kind: "number" },
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "position", label: "Column position (alpha_s)", kind: "select", options: [
      { value: "interior", label: "Interior (alpha_s = 40)" },
      { value: "edge", label: "Edge (alpha_s = 30)" },
      { value: "corner", label: "Corner (alpha_s = 20)" },
    ], default: "interior" },
    { key: "lambda", label: "Lightweight factor lambda", kind: "number" },
  ],
  outputs: [
    { key: "bo", id: "rps-out-bo", label: "Critical perimeter bo (at d/2)", value: (r) => fmt(r.bo_in, 0) + " in" },
    { key: "gov", id: "rps-out-gov", label: "Governing term", value: (r) => r.governs },
    { key: "ls", id: "rps-out-ls", label: "Size-effect factor lambda_s", value: (r) => fmt(r.lambda_s, 3) },
    { key: "vc", id: "rps-out-vc", label: "Concrete shear stress vc", value: (r) => fmt(r.vc_psi, 0) + " psi" },
    { key: "pvc", id: "rps-out-pvc", label: "Design capacity phi Vc", value: (r) => fmt(r.phi_vc_kip, 1) + " kip" },
    { key: "n", id: "rps-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeRcPunchingShear,
});

// Axial load added 2026-10-09: Table 22.5.5.1(c) carries + Nu/(6 Ag), Nu positive in compression, with
// Nu/(6 Ag) <= 0.05 f'c (22.5.5.1.2), Vc >= 0 and Vc <= 5 lambda sqrt(f'c) bw d (22.5.5.1.1).
// dims: in { fc_psi: M L^-1 T^-2, bw_in: L, d_in: L, as_in2: L^2, vu_kip: M L T^-2, lambda: dimensionless, nu_kip: M L T^-2, ag_in2: L^2 } out: { rho_w: dimensionless, lambda_s: dimensionless, vc_psi: M L^-1 T^-2, vc_kip: M L T^-2, phi_vc_kip: M L T^-2, vc_simplified_kip: M L T^-2, axial_term_psi: M L^-1 T^-2 }
export function computeRcOneWayShear({ fc_psi = 4000, bw_in = 0, d_in = 0, as_in2 = 0, vu_kip = 0, lambda = 1.0, nu_kip = 0, ag_in2 = 0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  if (!(fc_psi > 0)) return { error: "Concrete strength f'c must be positive (psi)." };
  if (!(bw_in > 0)) return { error: "Section width bw must be positive (in)." };
  if (!(d_in > 0)) return { error: "Effective depth d must be positive (in)." };
  if (!(as_in2 > 0)) return { error: "Tension reinforcement As must be positive (in^2)." };
  if (!(lambda > 0 && lambda <= 1)) return { error: "The lightweight factor lambda is over 0 and up to 1.0." };
  if (nu_kip !== 0 && !(ag_in2 > 0)) return { error: "With an axial load, enter the gross section area Ag (in^2)." };
  if (ag_in2 < 0) return { error: "Gross area Ag cannot be negative (in^2)." };
  const sqrt_fc = Math.min(Math.sqrt(fc_psi), 100); // 22.5.3.1 caps sqrt(f'c) at 100 psi
  const rho_w = as_in2 / (bw_in * d_in);
  const lambda_s = Math.min(Math.sqrt(2 / (1 + d_in / 10)), 1.0);
  const axial_term_psi = nu_kip !== 0 ? Math.min((nu_kip * 1000) / (6 * ag_in2), 0.05 * fc_psi) : 0;
  const vc_cap_psi = 5 * lambda * sqrt_fc;
  const vc_raw_psi = 8 * lambda_s * lambda * Math.cbrt(rho_w) * sqrt_fc + axial_term_psi;
  const vc_psi = Math.min(Math.max(vc_raw_psi, 0), vc_cap_psi);
  const vc_kip = (vc_psi * bw_in * d_in) / 1000;
  const phi_vc_kip = 0.75 * vc_kip;
  const vc_simplified_kip = (2 * lambda * sqrt_fc * bw_in * d_in) / 1000;
  const adequate = vu_kip > 0 ? vu_kip <= phi_vc_kip + 1e-9 * Math.abs(phi_vc_kip) : null;
  return {
    rho_w, lambda_s, vc_psi, vc_kip, phi_vc_kip, vc_simplified_kip, adequate, axial_term_psi, vc_capped: vc_raw_psi > vc_cap_psi, vc_floored: vc_raw_psi < 0,
    note: "ACI 318-19 Table 22.5.5.1(c) one-way (beam-action) shear for a member WITHOUT at least minimum shear reinforcement: Vc = [8 lambda_s lambda (rho_w)^(1/3) sqrt(f'c) + Nu/(6 Ag)] bw d, with Nu positive in compression and Nu/(6 Ag) no more than 0.05 f'c; Vc is not less than zero (axial tension can erase it) or more than 5 lambda sqrt(f'c) bw d; where rho_w = As/(bw d) is the longitudinal tension-steel ratio and lambda_s = sqrt(2 / (1 + d/10)) capped at 1.0 is the 22.5.5.1.3 size-effect factor (new in the 2019 edition), phi = 0.75. This is the check that governs footings, one-way slabs, and shallow beams with no stirrups; the size-effect penalty and the (rho_w)^(1/3) term make a deep, lightly reinforced section carry noticeably less than the old 2 sqrt(f'c) rule of thumb (shown for comparison). sqrt(f'c) is capped at 100 psi per 22.5.3.1. If the member has at least Av,min stirrups, lambda_s = 1.0 and the simplified 2 lambda sqrt(f'c) (or the (a) expressions) applies instead - see rc-beam-shear. Normalweight unless lambda is set. A design aid, not a substitute for the structural engineer of record's stamped design.",
  };
}
export const rcOneWayShearExample = { inputs: { fc_psi: 4000, bw_in: 12, d_in: 16, as_in2: 1.0, vu_kip: 0, lambda: 1.0 } };

CONCRETE_RENDERERS["rc-one-way-shear"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 Table 22.5.5.1(c) one-way shear Vc = 8 lambda_s lambda (rho_w)^(1/3) sqrt(f'c) bw d for a member without at least minimum shear reinforcement, the 22.5.5.1.3 size-effect factor lambda_s = sqrt(2/(1 + d/10)) <= 1.0, the 22.5.3.1 sqrt(f'c) <= 100 psi cap, and phi = 0.75, by name. Axial load enters as Nu/(6 Ag) when entered; the stirrup-reinforced case is rc-beam-shear. A design aid, not a substitute for the engineer of record.",
  example: rcOneWayShearExample.inputs,
  fields: [
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "bw_in", label: "Section width bw (in)", kind: "number" },
    { key: "d_in", label: "Effective depth d (in)", kind: "number" },
    { key: "as_in2", label: "Tension steel As (in²)", kind: "number" },
    { key: "vu_kip", label: "Factored shear Vu (kip, 0 = capacity only)", kind: "number" },
    { key: "lambda", label: "Lightweight factor lambda (1.0 normalweight)", kind: "number" },
    { key: "nu_kip", label: "Factored axial load Nu (kip, + compression, - tension; 0 if none)", kind: "number", attrs: { step: "any" } },
    { key: "ag_in2", label: "Gross section area Ag (in², needed with Nu)", kind: "number" },
  ],
  outputs: [
    { key: "rw", id: "rows-out-rw", label: "Reinforcement ratio rho_w = As/(bw d)", value: (r) => fmt(r.rho_w, 4) },
    { key: "ls", id: "rows-out-ls", label: "Size-effect factor lambda_s", value: (r) => fmt(r.lambda_s, 3) },
    { key: "vc", id: "rows-out-vc", label: "Concrete shear stress vc", value: (r) => fmt(r.vc_psi, 0) + " psi" + (r.axial_term_psi !== 0 ? " (axial term " + (r.axial_term_psi > 0 ? "+" : "") + fmt(r.axial_term_psi, 0) + " psi)" : "") + (r.vc_capped ? ", capped at 5 lambda sqrt(f'c)" : "") + (r.vc_floored ? ", floored at zero by the tension" : "") },
    { key: "pvc", id: "rows-out-pvc", label: "Design capacity phi Vc (phi = 0.75)", value: (r) => fmt(r.phi_vc_kip, 1) + " kip" },
    { key: "cmp", id: "rows-out-cmp", label: "vs. simplified 2 sqrt(f'c) bw d", value: (r) => fmt(r.vc_simplified_kip, 1) + " kip (before phi)" },
    { key: "ok", id: "rows-out-ok", label: "Adequate for Vu", value: (r) => r.adequate === null ? "- (enter Vu to check)" : (r.adequate ? "YES (Vu <= phi Vc)" : "NO (Vu > phi Vc; needs stirrups or a deeper section)") },
    { key: "n", id: "rows-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeRcOneWayShear,
});

// dims: in { fc_psi: M L^-1 T^-2, fyt_psi: M L^-1 T^-2, bw_in: L, d_in: L, av_in2: L^2, vu_kip: M L T^-2, lambda: dimensionless, stirrup_type: dimensionless } out: { av_min_per_s: L, s_max_av_min_in: L, trigger_kip: M L T^-2, vc_kip: M L T^-2, vs_req_kip: M L T^-2, vs_max_kip: M L T^-2, phi_vn_max_kip: M L T^-2, s_max_code_in: L, s_max_in: L }
export function computeRcMinShearReinforcement({ fc_psi = 4000, fyt_psi = 60000, bw_in = 0, d_in = 0, av_in2 = 0, vu_kip = 0, lambda = 1.0, stirrup_type = "bar" } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  if (!(fc_psi > 0)) return { error: "Concrete strength f'c must be positive (psi)." };
  if (!(fyt_psi > 0)) return { error: "Stirrup yield fyt must be positive (psi)." };
  if (!(bw_in > 0)) return { error: "Web width bw must be positive (in)." };
  if (!(d_in > 0)) return { error: "Effective depth d must be positive (in)." };
  if (!(av_in2 > 0)) return { error: "Stirrup area Av must be positive (in^2)." };
  if (!(lambda > 0 && lambda <= 1)) return { error: "The lightweight factor lambda is over 0 and up to 1.0." };
  // ACI 318-19 Table 20.2.2.4(a) caps fyt for shear at 60,000 psi for deformed bars and 80,000 psi
  // for welded deformed wire; the shear-friction and corbel tiles already apply the same table.
  // Until 2026-10-07 a Grade 80 or 100 stirrup spread its spacing in proportion to the grade.
  if (stirrup_type !== "bar" && stirrup_type !== "wwr") return { error: "Stirrup type must be bar (deformed bar) or wwr (welded deformed wire)." };
  const fyt_used_psi = Math.min(fyt_psi, stirrup_type === "wwr" ? 80000 : 60000);
  const PHI = 0.75;
  // 22.5.3.1 caps sqrt(f'c) at 100 psi for the shear-STRENGTH terms (Vc, the
  // 9.6.3.1 trigger, and the Vs limits). The 9.6.3.4 Av,min detailing minimum
  // sits in Chapter 9 and carries no such cap, so it uses the true sqrt(f'c).
  // The two differ only above f'c = 10,000 psi.
  const sqrt_fc_raw = Math.sqrt(fc_psi);
  const sqrt_fc = Math.min(sqrt_fc_raw, 100);
  // 9.6.3.4: Av,min/s = greater of 0.75 sqrt(f'c) bw/fyt and 50 bw/fyt.
  const av_min_a = 0.75 * sqrt_fc_raw * bw_in / fyt_used_psi;
  const av_min_b = 50 * bw_in / fyt_used_psi;
  const av_min_per_s = Math.max(av_min_a, av_min_b);
  const av_min_governs = av_min_a >= av_min_b ? "the 0.75 sqrt(f'c) bw/fyt term (f'c above ~4,444 psi)" : "the 50 bw/fyt floor (f'c below ~4,444 psi)";
  const s_max_av_min_in = av_in2 / av_min_per_s;
  // 9.6.3.1: Av,min is required where Vu > phi lambda sqrt(f'c) bw d (ACI
  // 318-19 replaced the 318-14 "Vu > 0.5 phi Vc" trigger with this one).
  const trigger_kip = PHI * lambda * sqrt_fc * bw_in * d_in / 1000;
  const av_min_required = vu_kip > 0 ? vu_kip > trigger_kip : null;
  // Simplified Vc for a member with at least Av,min (Table 22.5.5.1(a)).
  const vc_kip = 2 * lambda * sqrt_fc * bw_in * d_in / 1000;
  const vs_req_kip = vu_kip > 0 ? Math.max(0, vu_kip / PHI - vc_kip) : 0;
  // 22.5.1.2 section-size ceiling and the 9.7.6.2.2 spacing tightening.
  const vs_max_kip = 8 * sqrt_fc * bw_in * d_in / 1000;
  const vs_half_kip = 4 * sqrt_fc * bw_in * d_in / 1000;
  const phi_vn_max_kip = PHI * (vc_kip + vs_max_kip);
  const tightened = vs_req_kip > vs_half_kip;
  const s_max_code_in = tightened ? Math.min(d_in / 4, 12) : Math.min(d_in / 2, 24);
  const s_max_in = Math.min(s_max_code_in, s_max_av_min_in);
  const section_adequate = vu_kip > 0 ? vu_kip <= phi_vn_max_kip + 1e-9 * Math.abs(phi_vn_max_kip) : null;
  return {
    av_min_per_s, av_min_governs, s_max_av_min_in, trigger_kip, av_min_required, fyt_used_psi,
    vc_kip, vs_req_kip, vs_max_kip, phi_vn_max_kip, tightened, s_max_code_in, s_max_in, section_adequate,
    note: "The detailing and section-size checks that sit BESIDE the rc-beam-shear strength calculation, all ACI 318-19. (1) 9.6.3.4 minimum shear reinforcement Av,min/s = greater of 0.75 sqrt(f'c) bw/fyt and 50 bw/fyt; the 50 bw/fyt floor governs below about 4,444 psi and the sqrt(f'c) term above it. Dividing the stirrup area by Av,min/s gives the widest spacing that still satisfies the minimum. (2) 9.6.3.1 requires Av,min wherever Vu exceeds phi lambda sqrt(f'c) bw d -- the 2019 edition REPLACED the old 318-14 'Vu > 0.5 phi Vc' trigger with this one, and Table 9.6.3.1 exempts shallow beams (h <= 10 in), joists, and certain slab-integral members, which are not modeled here. (3) 22.5.1.2 caps the stirrup contribution at Vs <= 8 sqrt(f'c) bw d, so the section itself can never carry more than phi (Vc + 8 sqrt(f'c) bw d) no matter how much steel is added -- past that the beam must get deeper or wider. (4) 9.7.6.2.2 caps stirrup spacing at the lesser of d/2 and 24 in, halved to d/4 and 12 in once Vs exceeds 4 sqrt(f'c) bw d. Vc uses the simplified Table 22.5.5.1(a) expression appropriate to a member with at least Av,min. A design aid, not a substitute for the structural engineer of record's stamped design.",
  };
}
export const rcMinShearReinforcementExample = { inputs: { fc_psi: 4000, fyt_psi: 60000, bw_in: 12, d_in: 21.5, av_in2: 0.22, vu_kip: 40, lambda: 1.0 } };

CONCRETE_RENDERERS["rc-min-shear-reinforcement"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 9.6.3.4 (Av,min/s = greater of 0.75 sqrt(f'c) bw/fyt and 50 bw/fyt), 9.6.3.1 (Av,min required where Vu > phi lambda sqrt(f'c) bw d, the 2019 replacement for the 318-14 0.5 phi Vc trigger), 22.5.1.2 (Vs <= 8 sqrt(f'c) bw d section-size ceiling), and 9.7.6.2.2 (spacing at the lesser of d/2 and 24 in, halved past Vs = 4 sqrt(f'c) bw d), with phi = 0.75, by name. The Table 9.6.3.1 exemptions are not modeled. A design aid, not a substitute for the engineer of record.",
  example: rcMinShearReinforcementExample.inputs,
  fields: [
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "fyt_psi", label: "Stirrup yield fyt (psi)", kind: "number" },
    { key: "stirrup_type", label: "Stirrup type (sets the 20.2.2.4(a) fyt cap)", kind: "select", options: [{ value: "bar", label: "Deformed bar (fyt up to 60,000 psi)", selected: true }, { value: "wwr", label: "Welded deformed wire (up to 80,000 psi)" }] },
    { key: "bw_in", label: "Web width bw (in)", kind: "number" },
    { key: "d_in", label: "Effective depth d (in)", kind: "number" },
    { key: "av_in2", label: "Stirrup area Av, both legs (in²)", kind: "number" },
    { key: "vu_kip", label: "Factored shear Vu (kip, 0 = detailing only)", kind: "number", default: 0, attrs: { step: "any" } },
    { key: "lambda", label: "Lightweight factor lambda (1.0 normalweight)", kind: "number" },
  ],
  outputs: [
    { key: "am", id: "rmsr-out-am", label: "Minimum Av/s required", value: (r) => fmt(r.av_min_per_s, 4) + " in^2/in" },
    { key: "ag", id: "rmsr-out-ag", label: "Which minimum governs", value: (r) => r.av_min_governs },
    { key: "sa", id: "rmsr-out-sa", label: "Widest spacing meeting Av,min", value: (r) => fmt(r.s_max_av_min_in, 1) + " in" },
    { key: "tr", id: "rmsr-out-tr", label: "Av,min triggered above Vu of", value: (r) => fmt(r.trigger_kip, 1) + " kip" },
    { key: "rq", id: "rmsr-out-rq", label: "Av,min required here", value: (r) => r.av_min_required === null ? "- (enter Vu to check)" : (r.av_min_required ? "YES (Vu > phi lambda sqrt(f'c) bw d)" : "no (below the trigger)") },
    { key: "sc", id: "rmsr-out-sc", label: "Code max spacing", value: (r) => fmt(r.s_max_code_in, 2) + " in" + (r.tightened ? " (halved: Vs > 4 sqrt(f'c) bw d)" : "") },
    { key: "sg", id: "rmsr-out-sg", label: "Governing max spacing", value: (r) => fmt(r.s_max_in, 2) + " in" },
    { key: "vm", id: "rmsr-out-vm", label: "Section ceiling phi (Vc + Vs,max)", value: (r) => fmt(r.phi_vn_max_kip, 1) + " kip" },
    { key: "ok", id: "rmsr-out-ok", label: "Section big enough for Vu", value: (r) => r.section_adequate === null ? "- (enter Vu to check)" : (r.section_adequate ? "YES" : "NO (deepen or widen; more stirrups cannot help)") },
    { key: "n", id: "rmsr-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeRcMinShearReinforcement,
});

// dims: in { db_in: L, fy_psi: M L^-1 T^-2, fc_psi: M L^-1 T^-2, psi_e: dimensionless, psi_r: dimensionless, psi_o: dimensionless, lambda: dimensionless, joint: dimensionless } out: { psi_c: dimensionless, ldh_eq_in: L, ldh_in: L, ld_straight_bottom_in: L, ld_straight_top_in: L }
export function computeRcHookDevelopment({ db_in = 0, fy_psi = 60000, fc_psi = 4000, psi_e = 1.0, psi_r = 1.0, psi_o = 1.0, lambda = 1.0, joint = "general" } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  if (!(db_in > 0)) return { error: "Bar diameter must be positive (in)." };
  if (!(fy_psi > 0) || !(fc_psi > 0)) return { error: "Steel and concrete strengths must be positive (psi)." };
  if (!(psi_e > 0) || !(psi_r > 0) || !(psi_o > 0)) return { error: "Modification factors must be positive (1.0 is the base)." };
  if (!(lambda > 0 && lambda <= 1)) return { error: "The lightweight factor lambda is over 0 and up to 1.0." };
  if (joint !== "general" && joint !== "smf") return { error: "Joint must be general (25.4.3) or a special moment frame joint (18.8.5)." };
  // For hooked bars lambda is 0.75 for ANY lightweight concrete (Table 25.4.3.2 and
  // 18.8.5.1), not the 19.2.4 value: a sand-lightweight 0.85 entered here used to
  // pass through and gave a hook 12% short.
  if (lambda < 1) lambda = 0.75;
  // 25.4.1.4 caps sqrt(f'c) at 100 psi in development-length calculations; in
  // the denominator, the cap lengthens ldh above f'c = 10,000 psi (conservative).
  const sqrt_fc = Math.min(Math.sqrt(fc_psi), 100);
  if (joint === "smf") {
    // ACI 318-19 18.8.5.1: a No. 3-11 hooked bar in a special moment frame beam-column
    // joint takes ldh = fy db / (65 lambda sqrt(f'c)), at least 8 db and 6 in (10 db and
    // 7.5 in in lightweight concrete); the 25.4.3 psi factors do not apply, the hook sits
    // in the confined core. 18.8.5.3: a straight bar needs 2.5 ldh, or 3.25 ldh with
    // more than 12 in of fresh concrete cast below it. Added 2026-10-08.
    if (db_in > 1.41 + 1e-9) return { error: "ACI 18.8.5.1 covers No. 3 to No. 11 bars (db up to 1.41 in)." };
    const ldh_eq_in = fy_psi * db_in / (65 * lambda * sqrt_fc);
    const floor_in = lambda < 1 ? Math.max(10 * db_in, 7.5) : Math.max(8 * db_in, 6);
    const ldh_in = Math.max(ldh_eq_in, floor_in);
    return {
      psi_c: null, ldh_eq_in, floor_in, floor_governs: floor_in >= ldh_eq_in, ldh_in, joint,
      ld_straight_bottom_in: 2.5 * ldh_in, ld_straight_top_in: 3.25 * ldh_in,
      note: "ACI 318-19 18.8.5.1 hooked-bar development in a special moment frame beam-column joint: ldh = fy db / (65 lambda sqrt(f'c)), at least 8 db and 6 in (10 db and 7.5 in for lightweight concrete), with the hook inside the confined core of the column or boundary element and bent into the joint. The constant already folds in the cover and tie confinement the joint provides, so the 25.4.3 psi factors are not applied. 18.8.5.3: a straight bar through the joint needs 2.5 ldh, or 3.25 ldh when more than 12 in of fresh concrete is cast below it. Headed bars are the rc-headed-bar-development tile. A design aid, not a substitute for the structural engineer of record's stamped detailing.",
    };
  }
  const psi_c = fc_psi < 6000 ? fc_psi / 15000 + 0.6 : 1.0;
  const ldh_eq_in = (fy_psi * psi_e * psi_r * psi_o * psi_c / (55 * lambda * sqrt_fc)) * Math.pow(db_in, 1.5);
  const floor_in = Math.max(8 * db_in, 6);
  const ldh_in = Math.max(ldh_eq_in, floor_in);
  const floor_governs = floor_in >= ldh_eq_in;
  return {
    psi_c, ldh_eq_in, floor_in, floor_governs, ldh_in, joint, ld_straight_bottom_in: null, ld_straight_top_in: null,
    note: "ACI 318-19 Eq. 25.4.3.1a standard-hook tension development: ldh = (fy psi_e psi_r psi_o psi_c / (55 lambda sqrt(f'c))) db^1.5, not less than max(8 db, 6 in), with the 25.4.3.2 factors (psi_e 1.0 uncoated / 1.2-1.3 coated; psi_r confinement; psi_o location/cover; psi_c = f'c/15,000 + 0.6 below 6,000 psi, 1.0 at or above). The db^1.5 scaling is why a hook multiple-of-db rule of thumb misleads. Standard 90/180 degree hooks on deformed bars only - headed bars (25.4.4) are rc-headed-bar-development, compression development is rc-compression-dev-length, and the bend-diameter/geometry detailing is separate. A design aid, not a substitute for the structural engineer of record's stamped detailing.",
  };
}
export const rcHookDevelopmentExample = { inputs: { db_in: 1.0, fy_psi: 60000, fc_psi: 4000, psi_e: 1.0, psi_r: 1.0, psi_o: 1.0, lambda: 1.0 } };

CONCRETE_RENDERERS["rc-hook-development"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 Eq. 25.4.3.1a hooked-bar development ldh = (fy psi_e psi_r psi_o psi_c / (55 lambda sqrt(f'c))) db^1.5 with the 25.4.3.2 modification factors (psi_c = f'c/15,000 + 0.6 under 6,000 psi), the 25.4.1.4 sqrt(f'c) <= 100 psi cap (f'c above 10,000 psi does not further shorten ldh), and the max(8 db, 6 in) floor, by name. Standard 90/180 hooks; headed bars are the rc-headed-bar-development tile. A design aid, not a substitute for the engineer of record.",
  example: rcHookDevelopmentExample.inputs,
  fields: [
    { key: "db_in", label: "Bar diameter db (in; #8 = 1.0)", kind: "number" },
    { key: "fy_psi", label: "Steel yield fy (psi)", kind: "number" },
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "psi_e", label: "Epoxy factor psi_e", kind: "number" },
    { key: "psi_r", label: "Confinement factor psi_r", kind: "number" },
    { key: "psi_o", label: "Location/cover factor psi_o", kind: "number" },
    { key: "lambda", label: "Lightweight factor lambda", kind: "number" },
    { key: "joint", label: "Where the hook is", kind: "select", options: [{ value: "general", label: "General (ACI 25.4.3)", selected: true }, { value: "smf", label: "Special moment frame joint (ACI 18.8.5)" }] },
  ],
  outputs: [
    { key: "pc", id: "rhd-out-pc", label: "Strength factor psi_c", value: (r) => r.psi_c === null ? "not used in a special moment frame joint (18.8.5.1)" : fmt(r.psi_c, 3) },
    { key: "eq", id: "rhd-out-eq", label: "Equation ldh (before floor)", value: (r) => fmt(r.ldh_eq_in, 1) + " in" },
    { key: "ldh", id: "rhd-out-ldh", label: "Hook development ldh", value: (r) => fmt(r.ldh_in, 1) + " in" + (r.floor_governs ? (r.joint === "smf" ? " (the 18.8.5.1 minimum governs)" : " (the max(8db, 6 in) floor governs)") : "") },
    { key: "st", id: "rhd-out-st", label: "Straight bar through the joint instead", value: (r) => r.ld_straight_bottom_in === null ? "(special moment frame joints only)" : fmt(r.ld_straight_bottom_in, 1) + " in, or " + fmt(r.ld_straight_top_in, 1) + " in with more than 12 in of concrete cast below (18.8.5.3)" },
    { key: "n", id: "rhd-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeRcHookDevelopment,
});

// ===================== spec-v1930: headed deformed bar development in tension (ACI 318-19 25.4.4) =====================
// The hook tile says "headed bars (25.4.4) ... are separate". ACI 318-19 Eq. 25.4.4.2(a):
// ldt = (fy psi_e psi_p psi_o psi_c / (75 sqrt(f'c))) db^1.5, not less than 8 db or 6 in, with
// psi_p 1.0 (Att >= 0.3 Ahs or s >= 6 db) / 1.6, psi_o 1.0 (inside a column core with 2.5 in side cover,
// or side cover >= 6 db) / 1.25, psi_e 1.0 / 1.2 epoxy, psi_c = f'c/15,000 + 0.6 below 6,000 psi.
// ACI 318-25 prints 90 in place of 75 (Dextra's 318-25 calculation: #8, fy 70,000, f'c 5,800, epoxy -> 12.09 in).
// dims: in { db_in: L, fy_psi: M L^-1 T^-2, fc_psi: M L^-1 T^-2, psi_e: dimensionless, psi_p: dimensionless, psi_o: dimensionless, edition: dimensionless } out: { psi_c: dimensionless, ldt_eq_in: L, floor_in: L, ldt_in: L, min_clear_cover_in: L, min_spacing_in: L }
export function computeRcHeadedBarDevelopment({ db_in = 0, fy_psi = 60000, fc_psi = 4000, psi_e = 1.0, psi_p = 1.0, psi_o = 1.0, edition = "318-19" } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  if (!(db_in > 0)) return { error: "Bar diameter must be positive (in)." };
  if (db_in > 1.41 + 1e-9) return { error: "ACI 25.4.4.1(b) permits a head on No. 11 bars and smaller (db up to 1.41 in); use a hook or the anchor provisions." };
  if (!(fy_psi > 0) || !(fc_psi > 0)) return { error: "Steel and concrete strengths must be positive (psi)." };
  const pe = Number(psi_e), pp = Number(psi_p), po = Number(psi_o);
  if (![1.0, 1.2].includes(pe)) return { error: "psi_e is 1.0 (uncoated or galvanized) or 1.2 (epoxy coated)." };
  if (![1.0, 1.6].includes(pp)) return { error: "psi_p is 1.0 or 1.6." };
  if (![1.0, 1.25].includes(po)) return { error: "psi_o is 1.0 or 1.25." };
  if (edition !== "318-19" && edition !== "318-25") return { error: "Edition must be ACI 318-19 or 318-25." };
  const psi_c = fc_psi < 6000 ? fc_psi / 15000 + 0.6 : 1.0;
  const sqrt_fc = Math.min(Math.sqrt(fc_psi), 100);
  const coef = edition === "318-25" ? 90 : 75;
  const ldt_eq_in = (fy_psi * pe * pp * po * psi_c / (coef * sqrt_fc)) * Math.pow(db_in, 1.5);
  const floor_in = Math.max(8 * db_in, 6);
  const ldt_in = Math.max(ldt_eq_in, floor_in);
  return {
    psi_c, coef, ldt_eq_in, floor_in, floor_governs: floor_in >= ldt_eq_in, ldt_in,
    min_clear_cover_in: 2 * db_in, min_spacing_in: 3 * db_in, min_bearing_area_ratio: edition === "318-25" && fy_psi > 60000 ? 6 : 4,
    note: "A head lets a bar develop in a fraction of a straight bar's length and with less congestion than a hook: the head bears on the concrete, and the bond along ldt does the rest. ldt runs from the critical section to the bearing face of the head and grows with db^1.5, so a No. 11 needs about twice the length of a No. 7 at the same stress. psi_p rewards ties parallel to the bar (Att at least 0.3 Ahs) or wide bar spacing; psi_o rewards a head inside a column core or with generous side cover. A head is permitted only on No. 11 and smaller bars in normalweight concrete, with the bearing area, cover, and spacing shown; a bar into a beam-column joint should still run to the far face of the confined core. Special moment frame joints (18.8.5) and compression development are separate. A design aid; the engineer of record governs.",
  };
}
export const rcHeadedBarDevelopmentExample = { inputs: { db_in: 1.0, fy_psi: 70000, fc_psi: 5800, psi_e: 1.2, psi_p: 1.0, psi_o: 1.0, edition: "318-25" } };

CONCRETE_RENDERERS["rc-headed-bar-development"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 Eq. 25.4.4.2(a) headed deformed bar development in tension ldt = (fy psi_e psi_p psi_o psi_c / (75 sqrt(f'c))) db^1.5, not less than 8 db or 6 in, with the Table 25.4.4.3 factors and the 25.4.1.4 sqrt(f'c) <= 100 psi cap, by name; 25.4.4.1 limits heads to No. 11 bars and smaller in normalweight concrete with Abrg >= 4 Ab, clear cover >= 2 db, and spacing >= 3 db. ACI 318-25 prints 90 in place of 75, as worked in Dextra's ACI 318-25 headed bar calculation. The engineer of record governs.",
  example: rcHeadedBarDevelopmentExample.inputs,
  fields: [
    { key: "db_in", label: "Bar diameter db (in; #8 = 1.0, No. 11 maximum)", kind: "number" },
    { key: "fy_psi", label: "Steel yield fy (psi)", kind: "number" },
    { key: "fc_psi", label: "Concrete strength f'c (psi, normalweight)", kind: "number" },
    { key: "psi_e", label: "Coating psi_e", kind: "select", options: [{ value: "1", label: "1.0 uncoated or galvanized", selected: true }, { value: "1.2", label: "1.2 epoxy or dual coated" }] },
    { key: "psi_p", label: "Parallel ties psi_p", kind: "select", options: [{ value: "1", label: "1.0 Att >= 0.3 Ahs, or wide bar spacing (6 db in 318-19)", selected: true }, { value: "1.6", label: "1.6 other" }] },
    { key: "psi_o", label: "Location psi_o", kind: "select", options: [{ value: "1", label: "1.0 inside a column core with 2.5 in side cover, or side cover >= 6 db", selected: true }, { value: "1.25", label: "1.25 other" }] },
    { key: "edition", label: "Code edition", kind: "select", options: [{ value: "318-19", label: "ACI 318-19 (75 sqrt(f'c))", selected: true }, { value: "318-25", label: "ACI 318-25 (90 sqrt(f'c))" }] },
  ],
  outputs: [
    { key: "pc", id: "rhb-out-pc", label: "Strength factor psi_c", value: (r) => fmt(r.psi_c, 3) },
    { key: "eq", id: "rhb-out-eq", label: "Equation ldt (before floor)", value: (r) => fmt(r.ldt_eq_in, 1) + " in" },
    { key: "ldt", id: "rhb-out-ldt", label: "Headed bar development ldt", value: (r) => fmt(r.ldt_in, 1) + " in" + (r.floor_governs ? " (the max(8 db, 6 in) floor governs)" : "") },
    { key: "lim", id: "rhb-out-lim", label: "Head use requires", value: (r) => "clear cover >= " + fmt(r.min_clear_cover_in, 2) + " in, spacing >= " + fmt(r.min_spacing_in, 2) + " in, head bearing area >= " + r.min_bearing_area_ratio + " Ab" },
    { key: "n", id: "rhb-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeRcHeadedBarDevelopment,
});

// ===================== spec-v299..v301: reinforced-concrete depth-2 batch =====================
// The ACI checks the strength tiles never make: the deflection-control minimum
// thickness (Table 7.3.1.1 / 9.3.1.1), the doubly-reinforced beam with
// compression steel, and shear friction across an interface (22.9).
const _RC_HMIN_DENOMS = {
  slab: { simply: 20, "one-end": 24, "both-ends": 28, cantilever: 10 },
  beam: { simply: 16, "one-end": 18.5, "both-ends": 21, cantilever: 8 },
};
const _RC_BETA1 = (fc_psi) => fc_psi <= 4000 ? 0.85 : Math.max(0.85 - 0.05 * (fc_psi - 4000) / 1000, 0.65);

// dims: in { l_ft: L, support: dimensionless, member: dimensionless, fy_psi: M L^-1 T^-2, wc_pcf: M L^-2 T^-2 } out: { base_in: L, kfy: dimensionless, klw: dimensionless, hmin_in: L, denom: dimensionless }
export function computeRcSlabMinThickness({ l_ft = 0, support = "simply", member = "slab", fy_psi = 60000, wc_pcf = 145 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  if (!(l_ft > 0)) return { error: "Span must be positive (ft)." };
  if (!(fy_psi > 0)) return { error: "Steel yield fy must be positive (psi)." };
  if (!(wc_pcf >= 90)) return { error: "Concrete unit weight must be at least 90 pcf, the lightest concrete the table's lightweight factor covers." };
  // Table 7.3.1.1 (one-way slabs) and Table 9.3.1.1 (beams) are different rows.
  const denoms = _RC_HMIN_DENOMS[member];
  if (!denoms) return { error: "Member must be slab or beam." };
  const denom = denoms[support];
  if (!denom) return { error: "Support condition must be simply, one-end, both-ends, or cantilever." };
  const base_in = (l_ft * 12) / denom;
  const kfy = fy_psi === 60000 ? 1.0 : 0.4 + fy_psi / 100000;
  const klw = wc_pcf >= 145 ? 1.0 : Math.max(1.65 - 0.005 * wc_pcf, 1.09);
  const hmin_in = base_in * kfy * klw;
  return {
    base_in, kfy, klw, hmin_in, denom,
    note: "ACI 318-19 Table 7.3.1.1 (one-way slabs) / 9.3.1.1 (beams) deflection-control minimum thickness: for a one-way slab l/20 simply supported, l/24 one end continuous, l/28 both ends continuous, l/10 cantilever; for a beam l/16, l/18.5, l/21 and l/8; times (0.4 + fy/100,000) for fy other than 60,000 psi and the 1.65 - 0.005 wc lightweight factor (>= 1.09). This is the depth that WAIVES an explicit deflection calculation - it applies to normalweight (unless wc is set) members not supporting or attached to partitions or construction likely to be damaged by large deflections, uses the clear span, and is not the strength (flexure/shear) design or the actual deflection of a thinner member. A design aid, not a substitute for the structural engineer of record's stamped design.",
  };
}
export const rcSlabMinThicknessExample = { inputs: { l_ft: 12, support: "simply", fy_psi: 60000, wc_pcf: 145 } };

CONCRETE_RENDERERS["rc-slab-min-thickness"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 Table 7.3.1.1 (one-way slabs) / 9.3.1.1 (beams) deflection-control minimum thickness (slab l/20, l/24, l/28, l/10; beam l/16, l/18.5, l/21, l/8), the (0.4 + fy/100,000) grade modifier, and the lightweight factor, by name. The depth that waives a deflection check, not a strength design. A design aid, not a substitute for the engineer of record.",
  example: rcSlabMinThicknessExample.inputs,
  fields: [
    { key: "l_ft", label: "Span l (ft, clear span)", kind: "number" },
    { key: "support", label: "Support condition", kind: "select", options: [
      { value: "simply", label: "Simply supported (slab l/20, beam l/16)" },
      { value: "one-end", label: "One end continuous (slab l/24, beam l/18.5)" },
      { value: "both-ends", label: "Both ends continuous (slab l/28, beam l/21)" },
      { value: "cantilever", label: "Cantilever (slab l/10, beam l/8)" },
    ], default: "simply" },
    { key: "member", label: "Member", kind: "select", options: [
      { value: "slab", label: "One-way slab (Table 7.3.1.1)" },
      { value: "beam", label: "Beam (Table 9.3.1.1)" },
    ], default: "slab" },
    { key: "fy_psi", label: "Steel yield fy (psi)", kind: "number" },
    { key: "wc_pcf", label: "Concrete unit weight (pcf)", kind: "number" },
  ],
  outputs: [
    { key: "base", id: "rsmt-out-base", label: "Base thickness (l / denominator)", value: (r) => fmt(r.base_in, 2) + " in" },
    { key: "mods", id: "rsmt-out-mods", label: "Grade / lightweight modifiers", value: (r) => fmt(r.kfy, 3) + " / " + fmt(r.klw, 3) },
    { key: "hmin", id: "rsmt-out-hmin", label: "Minimum thickness hmin", value: (r) => fmt(r.hmin_in, 2) + " in" },
    { key: "n", id: "rsmt-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeRcSlabMinThickness,
});

// rc-slab-max-span-for-thickness: inverse of rc-slab-min-thickness. The forward
// tile gives hmin from a span; with the depth fixed, the max span that still
// waives a deflection check is the inverse: hmin = l x (12/denom) x kfy x klw is
// linear in l, so max_span = available_thickness / hmin(at l = 1 ft). Reuses the
// forward at l = 1 ft to carry the denom / kfy / klw geometry in one place.
// dims: in { available_thickness_in: L, support: dimensionless, member: dimensionless, fy_psi: M L^-1 T^-2, wc_pcf: M L^-2 T^-2 } out: { max_span_ft: L, kfy: dimensionless, klw: dimensionless, denom: dimensionless }
export function computeRcSlabMaxSpanForThickness({ available_thickness_in = 0, support = "simply", member = "slab", fy_psi = 60000, wc_pcf = 145 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const h = Number(available_thickness_in) || 0;
  if (!(h > 0)) return { error: "Available thickness must be positive (in)." };
  const base = computeRcSlabMinThickness({ l_ft: 1, support, member, fy_psi, wc_pcf });
  if (base.error) return { error: base.error };
  const hmin_per_ft = base.hmin_in;
  const max_span_ft = h / hmin_per_ft;
  return {
    max_span_ft, kfy: base.kfy, klw: base.klw, denom: base.denom,
    note: "ACI 318-19 Table 7.3.1.1 / 9.3.1.1 deflection-control minimum thickness solved for the span: with the depth fixed, this is the longest span that still WAIVES an explicit deflection calculation (max_span = h x denom / (12 kfy klw), denom 20 / 24 / 28 / 10 for a slab and 16 / 18.5 / 21 / 8 for a beam). A longer span needs either a deflection calculation or a deeper member. It applies to normalweight (unless wc is set) members not supporting or attached to partitions or construction likely to be damaged by large deflections, uses the clear span, and is not the strength (flexure/shear) design. A design aid, not a substitute for the structural engineer of record's stamped design.",
  };
}
export const rcSlabMaxSpanForThicknessExample = { inputs: { available_thickness_in: 10, support: "both-ends", fy_psi: 60000, wc_pcf: 145 } };
CONCRETE_RENDERERS["rc-slab-max-span-for-thickness"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 Table 7.3.1.1 (one-way slabs) / 9.3.1.1 (beams) deflection-control minimum thickness solved for the span, max_span = h x denom / (12 kfy klw), by name. The longest span the depth covers without a deflection check, not a strength design. A design aid, not a substitute for the engineer of record.",
  example: rcSlabMaxSpanForThicknessExample.inputs,
  fields: [
    { key: "available_thickness_in", label: "Available thickness h (in)", kind: "number" },
    { key: "support", label: "Support condition", kind: "select", options: [
      { value: "simply", label: "Simply supported (slab l/20, beam l/16)" },
      { value: "one-end", label: "One end continuous (slab l/24, beam l/18.5)" },
      { value: "both-ends", label: "Both ends continuous (slab l/28, beam l/21)" },
      { value: "cantilever", label: "Cantilever (slab l/10, beam l/8)" },
    ], default: "simply" },
    { key: "member", label: "Member", kind: "select", options: [
      { value: "slab", label: "One-way slab (Table 7.3.1.1)" },
      { value: "beam", label: "Beam (Table 9.3.1.1)" },
    ], default: "slab" },
    { key: "fy_psi", label: "Steel yield fy (psi)", kind: "number" },
    { key: "wc_pcf", label: "Concrete unit weight (pcf)", kind: "number" },
  ],
  outputs: [
    { key: "span", id: "rms-out-span", label: "Max span (no deflection check)", value: (r) => fmt(r.max_span_ft, 2) + " ft" },
    { key: "mods", id: "rms-out-mods", label: "Grade / lightweight modifiers", value: (r) => fmt(r.kfy, 3) + " / " + fmt(r.klw, 3) },
    { key: "n", id: "rms-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeRcSlabMaxSpanForThickness,
});

// dims: in { b_in: L, d_in: L, dp_in: L, as_in2: L^2, asp_in2: L^2, fc_psi: M L^-1 T^-2, fy_psi: M L^-1 T^-2 } out: { a_in: L, c_in: L, eps_sp: dimensionless, eps_t: dimensionless, mn_kipft: M L^2 T^-2, phi_mn_kipft: M L^2 T^-2 }
export function computeRcDoublyReinforced({ b_in = 0, d_in = 0, dp_in = 0, as_in2 = 0, asp_in2 = 0, fc_psi = 4000, fy_psi = 60000 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  if (!(b_in > 0) || !(d_in > 0)) return { error: "Beam width and effective depth must be positive (in)." };
  if (!(dp_in > 0)) return { error: "Compression-steel depth d' must be positive (in)." };
  if (!(dp_in < d_in)) return { error: "The compression-steel depth d' must be less than the effective depth d." };
  if (!(as_in2 > 0)) return { error: "Tension steel As must be positive (in^2)." };
  if (asp_in2 < 0) return { error: "Compression steel A's cannot be negative (in^2)." };
  if (!(as_in2 > asp_in2)) return { error: "The tension steel must exceed the compression steel (As > A's) for a net tension couple." };
  if (!(fc_psi > 0) || !(fy_psi > 0)) return { error: "Concrete and steel strengths must be positive (psi)." };
  const beta1 = _RC_BETA1(fc_psi);
  const Es = 29e6;
  const eps_y = fy_psi / Es; // eps_ty = fy/Es, the yield (compression-controlled) strain
  // Strain compatibility, both steels at their own stress. The closed form
  // a = (As - A's) fy / (0.85 f'c b) assumes BOTH yield, and until 2026-10-10 it was
  // used whatever the strains said: a heavily reinforced section whose tension
  // steel had not yielded still got fy (9% high at As 12, A's 1 on a 14 x 22 beam),
  // and a neutral axis below the tension steel still returned a capacity. The
  // force balance 0.85 f'c b beta1 c + A's fs' = As fs is solved for c by
  // bisection; where both steels yield it returns the closed form exactly.
  const fsAt = (c) => Math.min(fy_psi, Es * 0.003 * (d_in - c) / c);
  const fspAt = (c) => Math.max(-fy_psi, Math.min(fy_psi, Es * 0.003 * (c - dp_in) / c));
  const unbalanced = (c) => 0.85 * fc_psi * b_in * beta1 * c + asp_in2 * fspAt(c) - as_in2 * fsAt(c);
  let lo = 1e-6, hi = d_in;
  for (let i = 0; i < 200; i++) { const mid = (lo + hi) / 2; if (unbalanced(mid) > 0) hi = mid; else lo = mid; }
  const c_in = (lo + hi) / 2;
  const a_in = beta1 * c_in;
  const fs_psi = fsAt(c_in), fsp_psi = fspAt(c_in);
  const eps_sp = 0.003 * (c_in - dp_in) / c_in;
  const eps_t = 0.003 * (d_in - c_in) / c_in;
  const tension_yields = eps_t >= eps_y * (1 - 1e-9);
  // With no compression steel there is nothing to yield; the check does not apply.
  const comp_yields = asp_in2 > 0 ? eps_sp >= eps_y * (1 - 1e-9) : true;
  // ACI 318-19 21.2.2 / Table 21.2.2: the tension-controlled limit is eps_ty +
  // 0.003 and the transition denominator is 0.003 - NOT the fixed 0.005 of
  // 318-14. They coincide only near Grade 60 (eps_ty ~ 0.00207); for Grade 80
  // and 100 the old 0.005 wrongly classifies transition sections as
  // tension-controlled and overstates phi.
  const tc_limit = eps_y + 0.003;
  const tension_controlled = eps_t >= tc_limit;
  const phi = tension_controlled ? 0.90 : (eps_t <= eps_y ? 0.65 : 0.65 + 0.25 * (eps_t - eps_y) / 0.003);
  // Moments of the concrete block and the compression steel about the tension steel.
  const mn_lbin = 0.85 * fc_psi * b_in * a_in * (d_in - a_in / 2) + asp_in2 * fsp_psi * (d_in - dp_in);
  const mn_kipft = mn_lbin / 12000;
  const phi_mn_kipft = phi * mn_kipft;
  return {
    a_in, c_in, beta1, eps_sp, eps_t, eps_y, tc_limit, comp_yields, tension_yields, fs_psi, fsp_psi, tension_controlled, phi, mn_kipft, phi_mn_kipft,
    note: "ACI 318-19 doubly-reinforced rectangular-beam flexure: a = (As - A's) fy / (0.85 f'c b), c = a/beta1, and Mn = (As - A's) fy (d - a/2) + A's fy (d - d') - the singly-reinforced couple plus the steel-to-steel couple. This ASSUMES both steel layers yield (the compression-steel yield check epsilon's = 0.003 (c - d')/c >= fy/Es is flagged when it fails, where a rigorous solution would iterate with f's = Es epsilon's <= fy). The strength-reduction factor phi follows ACI 318-19 21.2.2: tension-controlled (phi = 0.90) at epsilon_t >= epsilon_ty + 0.003, compression-controlled (phi = 0.65) at epsilon_t <= epsilon_ty = fy/Es, and phi = 0.65 + 0.25 (epsilon_t - epsilon_ty)/0.003 between - the 2019 edition replaced the fixed 0.005 tension-controlled limit with epsilon_ty + 0.003, which matters for Grade 80 and 100 steel. Rectangular section (no T-beam flange); minimum steel, bar spacing, and development are not checked. A design aid, not a substitute for the structural engineer of record's stamped design.",
  };
}
export const rcDoublyReinforcedExample = { inputs: { b_in: 14, d_in: 22, dp_in: 2.0, as_in2: 8.0, asp_in2: 3.0, fc_psi: 4000, fy_psi: 60000 } };

CONCRETE_RENDERERS["rc-doubly-reinforced"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 doubly-reinforced flexure a = (As - A's) fy / (0.85 f'c b), Mn = (As - A's) fy (d - a/2) + A's fy (d - d'), the compression-steel yield check epsilon's >= fy/Es, and the 21.2.2 strength-reduction factor (tension-controlled phi = 0.90 at epsilon_t >= epsilon_ty + 0.003, the 2019 replacement for the fixed 0.005 limit), by name. Both layers assumed to yield; rectangular section. A design aid, not a substitute for the engineer of record.",
  example: rcDoublyReinforcedExample.inputs,
  fields: [
    { key: "b_in", label: "Beam width b (in)", kind: "number" },
    { key: "d_in", label: "Effective depth d (in)", kind: "number" },
    { key: "dp_in", label: "Compression-steel depth d' (in)", kind: "number" },
    { key: "as_in2", label: "Tension steel As (in²)", kind: "number" },
    { key: "asp_in2", label: "Compression steel A's (in²)", kind: "number" },
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "fy_psi", label: "Steel yield fy (psi)", kind: "number" },
  ],
  outputs: [
    { key: "ac", id: "rdr-out-ac", label: "Stress block a / neutral axis c", value: (r) => fmt(r.a_in, 2) + " / " + fmt(r.c_in, 2) + " in" },
    { key: "yld", id: "rdr-out-yld", label: "Compression steel yields?", value: (r) => (r.comp_yields ? "yes (epsilon's " + fmt(r.eps_sp, 5) + " >= " + fmt(r.eps_y, 5) + ")" : "no - it is at " + fmt(r.fsp_psi / 1000, 1) + " ksi, and the capacity is computed at that stress") + (r.tension_yields ? "" : "; THE TENSION STEEL HAS NOT YIELDED (" + fmt(r.fs_psi / 1000, 1) + " ksi): the section is compression-controlled and over-reinforced") },
    { key: "tc", id: "rdr-out-tc", label: "Section (phi)", value: (r) => (r.tension_controlled ? "tension-controlled (phi 0.90)" : "transition (phi " + fmt(r.phi, 3) + ")") + ", epsilon_t " + fmt(r.eps_t, 4) },
    { key: "mn", id: "rdr-out-mn", label: "Nominal Mn", value: (r) => fmt(r.mn_kipft, 1) + " kip-ft" },
    { key: "pm", id: "rdr-out-pm", label: "Design phi Mn", value: (r) => fmt(r.phi_mn_kipft, 1) + " kip-ft" },
    { key: "n", id: "rdr-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeRcDoublyReinforced,
});

// dims: in { avf_in2: L^2, fy_psi: M L^-1 T^-2, ac_in2: L^2, fc_psi: M L^-1 T^-2, iface: dimensionless, lambda: dimensionless } out: { mu_f: dimensionless, vn0_kip: M L T^-2, cap_kip: M L T^-2, vn_kip: M L T^-2, phi_vn_kip: M L T^-2 }
export function computeRcShearFriction({ avf_in2 = 0, fy_psi = 60000, ac_in2 = 0, fc_psi = 4000, iface = "roughened", lambda = 1.0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  if (!(avf_in2 > 0)) return { error: "The friction reinforcement area Avf must be positive (in^2)." };
  if (!(fy_psi > 0)) return { error: "Steel yield fy must be positive (psi)." };
  if (!(ac_in2 > 0)) return { error: "The interface area Ac must be positive (in^2)." };
  if (!(fc_psi > 0)) return { error: "Concrete strength f'c must be positive (psi)." };
  if (!(lambda > 0 && lambda <= 1)) return { error: "The lightweight factor lambda is over 0 and up to 1.0." };
  const mus = { monolithic: 1.4, roughened: 1.0, unroughened: 0.6, steel: 0.7 };
  const base_mu = mus[iface];
  if (!base_mu) return { error: "The interface must be monolithic, roughened, unroughened, or steel." };
  const mu_f = base_mu * lambda;
  // Table 20.2.2.4(a) caps fy at 60,000 psi for shear friction, as the corbel tile has since
  // 2026-10-03. Until 2026-10-07 this tile let Grade 80 and 100 bars raise Vn in proportion.
  const vn0_kip = (mu_f * avf_in2 * Math.min(fy_psi, 60000)) / 1000;
  // ACI 318-19 Table 22.9.4.4 caps Vn for EVERY interface, not just the
  // monolithic/roughened case: (a) monolithic or roughened to 1/4 in is the
  // least of 0.2 f'c, 480 + 0.08 f'c, and 1600 (x Ac); (b) all other cases
  // (unroughened concrete, or against as-rolled steel) is the least of 0.2 f'c
  // and 800 (x Ac). Omitting the (b) cap overstates Vn for those interfaces.
  const case_a = iface === "monolithic" || iface === "roughened";
  const cap_kip = case_a
    ? (Math.min(0.2 * fc_psi, 480 + 0.08 * fc_psi, 1600) * ac_in2) / 1000
    : (Math.min(0.2 * fc_psi, 800) * ac_in2) / 1000;
  const vn_kip = Math.min(vn0_kip, cap_kip);
  const capped = cap_kip < vn0_kip;
  const phi_vn_kip = 0.75 * vn_kip;
  return {
    mu_f, vn0_kip, cap_kip, vn_kip, capped, phi_vn_kip,
    note: "ACI 318-19 22.9 shear-friction strength Vn = mu Avf fy, with mu = 1.4 lambda (monolithic), 1.0 lambda (against roughened hardened concrete), 0.6 lambda (unroughened), 0.7 lambda (against as-rolled steel), and phi = 0.75. Table 22.9.4.4 caps Vn: a monolithic or 1/4-in-roughened interface (case a) by the least of 0.2 f'c, 480 + 0.08 f'c, and 1600 (x Ac); every OTHER interface - unroughened concrete or as-rolled steel (case b) - by the least of 0.2 f'c and 800 (x Ac), which is the lower ceiling and governs sooner. This returns the shear transferred across a single well-defined plane by friction in the perpendicular (no permanent net tension) case; a net tension across the plane needs added reinforcement Avf = Vu/(phi fy mu) + An. The reduced caps for lightweight concrete, the anchorage/development of the crossing bars, and the concrete bracket/corbel bearing are separate. A design aid, not a substitute for the structural engineer of record's stamped design.",
  };
}
export const rcShearFrictionExample = { inputs: { avf_in2: 2.0, fy_psi: 60000, ac_in2: 192, fc_psi: 4000, iface: "roughened", lambda: 1.0 } };

CONCRETE_RENDERERS["rc-shear-friction"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 22.9 shear friction Vn = mu Avf fy (mu 1.4/1.0/0.6/0.7 x lambda by interface), with the Table 22.9.4.4 cap - min(0.2 f'c, 480 + 0.08 f'c, 1600) Ac for a monolithic/roughened interface (case a) and min(0.2 f'c, 800) Ac for every other interface (case b) - and phi = 0.75, by name. Perpendicular (no net tension) case, single plane. A design aid, not a substitute for the engineer of record.",
  example: rcShearFrictionExample.inputs,
  fields: [
    { key: "avf_in2", label: "Reinforcement crossing the plane Avf (in²)", kind: "number" },
    { key: "fy_psi", label: "Steel yield fy (psi)", kind: "number" },
    { key: "ac_in2", label: "Interface area Ac (in²)", kind: "number" },
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "iface", label: "Interface condition (mu)", kind: "select", options: [
      { value: "monolithic", label: "Monolithic (1.4)" },
      { value: "roughened", label: "Against roughened concrete (1.0)" },
      { value: "unroughened", label: "Against unroughened concrete (0.6)" },
      { value: "steel", label: "Against as-rolled steel (0.7)" },
    ], default: "roughened" },
    { key: "lambda", label: "Lightweight factor lambda", kind: "number" },
  ],
  outputs: [
    { key: "mu", id: "rsf-out-mu", label: "Friction coefficient mu", value: (r) => fmt(r.mu_f, 2) },
    { key: "vn0", id: "rsf-out-vn0", label: "Friction strength mu Avf fy", value: (r) => fmt(r.vn0_kip, 1) + " kip" },
    { key: "cap", id: "rsf-out-cap", label: "Interface cap", value: (r) => fmt(r.cap_kip, 1) + " kip" + (r.capped ? " (governs)" : "") },
    { key: "vn", id: "rsf-out-vn", label: "Nominal Vn", value: (r) => fmt(r.vn_kip, 1) + " kip" },
    { key: "pv", id: "rsf-out-pv", label: "Design phi Vn", value: (r) => fmt(r.phi_vn_kip, 1) + " kip" },
    { key: "n", id: "rsf-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeRcShearFriction,
});

// ===================== spec-v378..v380: concrete material-properties trio =====================

// dims: in { fc_psi: M L^-1 T^-2, wc_pcf: M L^-3 } out: { ec_psi: M L^-1 T^-2, ec_ksi: M L^-1 T^-2, ec_normal_psi: M L^-1 T^-2 }
export function computeConcreteElasticModulus({ fc_psi = 4000, wc_pcf = 145 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  if (!(fc_psi > 0)) return { error: "Concrete strength f'c must be positive (psi)." };
  if (!(wc_pcf > 0)) return { error: "Unit weight wc must be positive (pcf)." };
  const ec_psi = Math.pow(wc_pcf, 1.5) * 33 * Math.sqrt(fc_psi);
  const ec_normal_psi = 57000 * Math.sqrt(fc_psi);
  const out_of_band = wc_pcf < 90 || wc_pcf > 160;
  return {
    ec_psi, ec_ksi: ec_psi / 1000, ec_normal_psi, ec_normal_ksi: ec_normal_psi / 1000, out_of_band,
    note: "ACI 318-19 §19.2.2.1(a): Ec = wc^1.5 x 33 x sqrt(f'c) psi, valid for 90 <= wc <= 160 pcf; the §19.2.2.1(b) normalweight shortcut is 57000 x sqrt(f'c). Ec sets the stiffness behind every deflection, drift, and short-column calculation. A lightweight deck (lower wc) is markedly less stiff at the same strength. A design aid; the engineer of record's stamped design governs.",
  };
}
export const concreteElasticModulusExample = { inputs: { fc_psi: 4000, wc_pcf: 145 } };
CONCRETE_RENDERERS["concrete-elastic-modulus"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 §19.2.2.1(a): Ec = wc^1.5 x 33 x sqrt(f'c) (psi), applicable for wc between 90 and 160 pcf; §19.2.2.1(b) gives the normalweight shortcut Ec = 57000 x sqrt(f'c). Returns the secant modulus used for deflection, drift, and stiffness; it is not the dynamic or tangent modulus, and the actual in-place modulus varies with aggregate and mix. A design aid, not a substitute for a licensed engineer's design -- the engineer of record's stamped design governs.",
  example: concreteElasticModulusExample.inputs,
  fields: [
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "wc_pcf", label: "Unit weight wc (pcf, 145 normalweight)", kind: "number" },
  ],
  outputs: [
    { key: "ec", id: "cem-out-ec", label: "Modulus Ec = wc^1.5 x 33 x sqrt(f'c)", value: (r) => fmt(r.ec_psi, 0) + " psi (" + fmt(r.ec_ksi, 0) + " ksi)" },
    { key: "en", id: "cem-out-en", label: "Normalweight shortcut 57000 x sqrt(f'c)", value: (r) => fmt(r.ec_normal_psi, 0) + " psi (" + fmt(r.ec_normal_ksi, 0) + " ksi)" },
    { key: "ob", id: "cem-out-ob", label: "Unit-weight range", value: (r) => r.out_of_band ? "OUT OF BAND (wc outside 90-160 pcf; ACI eq. not applicable)" : "within ACI 90-160 pcf" },
    { key: "n", id: "cem-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteElasticModulus,
});

// concrete-strength-from-modulus: inverse of concrete-elastic-modulus. The forward
// tile gives Ec from f'c; backing out the in-place strength from a measured (or
// specified) stiffness is the inverse: Ec = wc^1.5 x 33 x sqrt(f'c), so
// f'c = (Ec / (wc^1.5 x 33))^2.
// dims: in { ec_psi: M L^-1 T^-2, wc_pcf: M L^-3 } out: { fc_psi: M L^-1 T^-2, fc_ksi: M L^-1 T^-2 }
export function computeConcreteStrengthFromModulus({ ec_psi = 0, wc_pcf = 145 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const ec = Number(ec_psi) || 0;
  const wc = Number(wc_pcf) || 0;
  if (!(ec > 0)) return { error: "Elastic modulus Ec must be positive (psi)." };
  if (!(wc > 0)) return { error: "Unit weight wc must be positive (pcf)." };
  const root = ec / (Math.pow(wc, 1.5) * 33);
  const fc_psi = root * root;
  const out_of_band = wc < 90 || wc > 160;
  return {
    fc_psi, fc_ksi: fc_psi / 1000, out_of_band,
    note: "ACI 318-19 §19.2.2.1(a) Ec = wc^1.5 x 33 x sqrt(f'c) solved for the strength: f'c = (Ec / (wc^1.5 x 33))^2. Useful for backing out the equivalent in-place f'c from a resonance / sonic modulus test or a specified stiffness. The relation is valid for 90 <= wc <= 160 pcf; the in-place modulus scatters with aggregate and mix, so this is an equivalent strength, not a cylinder-break value. A design aid; the engineer of record's stamped design governs.",
  };
}
export const concreteStrengthFromModulusExample = { inputs: { ec_psi: 3644147, wc_pcf: 145 } };
CONCRETE_RENDERERS["concrete-strength-from-modulus"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 §19.2.2.1(a) Ec = wc^1.5 x 33 x sqrt(f'c) solved for f'c = (Ec / (wc^1.5 x 33))^2, by name. Backs out an equivalent in-place strength from a measured or specified modulus; the in-place modulus scatters with aggregate and mix, so this is not a cylinder-break value. A design aid, not a substitute for the engineer of record.",
  example: concreteStrengthFromModulusExample.inputs,
  fields: [
    { key: "ec_psi", label: "Elastic modulus Ec (psi)", kind: "number" },
    { key: "wc_pcf", label: "Unit weight wc (pcf, 145 normalweight)", kind: "number" },
  ],
  outputs: [
    { key: "fc", id: "csm-out-fc", label: "Equivalent strength f'c", value: (r) => fmt(r.fc_psi, 0) + " psi (" + fmt(r.fc_ksi, 2) + " ksi)" },
    { key: "ob", id: "csm-out-ob", label: "Unit-weight range", value: (r) => r.out_of_band ? "OUT OF BAND (wc outside 90-160 pcf; ACI eq. not applicable)" : "within ACI 90-160 pcf" },
    { key: "n", id: "csm-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteStrengthFromModulus,
});

// dims: in { fc_psi: M L^-1 T^-2, lambda: dimensionless } out: { fr_psi: M L^-1 T^-2, fr_fraction: dimensionless }
export function computeConcreteModulusOfRupture({ fc_psi = 4000, lambda = 1.0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  if (!(fc_psi > 0)) return { error: "Concrete strength f'c must be positive (psi)." };
  if (!(lambda > 0)) return { error: "Lightweight factor lambda must be positive." };
  if (lambda > 1) return { error: "Lightweight factor lambda cannot exceed 1.0 (ACI 318-19 19.2.4)." };
  const fr_psi = 7.5 * lambda * Math.sqrt(fc_psi);
  const fr_fraction = fr_psi / fc_psi;
  const out_of_band = lambda < 0.75 || lambda > 1.0;
  return {
    fr_psi, fr_fraction, out_of_band,
    note: "ACI 318-19 §19.2.3.1: fr = 7.5 x lambda x sqrt(f'c) psi, the flexural tensile stress at which plain concrete first cracks. lambda is 1.0 normalweight, 0.75 all-lightweight (§19.2.4). fr sets the cracking moment Mcr behind deflection (Ie) and minimum-reinforcement checks. It is a lower-bound design value, well below the actual scatter of a beam test. A design aid; the engineer of record's stamped design governs.",
  };
}
export const concreteModulusOfRuptureExample = { inputs: { fc_psi: 4000, lambda: 1.0 } };
CONCRETE_RENDERERS["concrete-modulus-of-rupture"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 §19.2.3.1: fr = 7.5 x lambda x sqrt(f'c) (psi), the modulus of rupture, with lambda = 1.0 normalweight and 0.75 all-lightweight (§19.2.4). This is the code cracking stress used for the cracking moment Mcr and minimum flexural reinforcement; the true rupture strength of a given mix scatters above this conservative design value. A design aid, not a substitute for a licensed engineer's design -- the engineer of record's stamped design governs.",
  example: concreteModulusOfRuptureExample.inputs,
  fields: [
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "lambda", label: "Lightweight factor lambda (1.0 NW, 0.75 LW)", kind: "number" },
  ],
  outputs: [
    { key: "fr", id: "cmr-out-fr", label: "Modulus of rupture fr = 7.5 lambda sqrt(f'c)", value: (r) => fmt(r.fr_psi, 0) + " psi" },
    { key: "ff", id: "cmr-out-ff", label: "As a fraction of f'c", value: (r) => fmt(r.fr_fraction, 4) + " x f'c" },
    { key: "ob", id: "cmr-out-ob", label: "Lambda range", value: (r) => r.out_of_band ? "OUT OF BAND (lambda outside 0.75-1.0)" : "within 0.75-1.0" },
    { key: "n", id: "cmr-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteModulusOfRupture,
});

// concrete-strength-from-rupture: inverse of concrete-modulus-of-rupture. The
// forward tile gives fr from f'c; backing out the strength from a flexural-beam
// (modulus-of-rupture) test is the inverse: fr = 7.5 x lambda x sqrt(f'c), so
// f'c = (fr / (7.5 x lambda))^2.
// dims: in { fr_psi: M L^-1 T^-2, lambda: dimensionless } out: { fc_psi: M L^-1 T^-2, fc_ksi: M L^-1 T^-2 }
export function computeConcreteStrengthFromRupture({ fr_psi = 0, lambda = 1.0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const fr = Number(fr_psi) || 0;
  // A blank or zero lambda is an error, as in the forward tile; it used to become 1.0.
  const lam = Number(lambda);
  if (!(fr > 0)) return { error: "Modulus of rupture fr must be positive (psi)." };
  if (!(lam > 0)) return { error: "Lightweight factor lambda must be positive." };
  if (lam > 1) return { error: "Lightweight factor lambda cannot exceed 1.0 (ACI 318-19 19.2.4)." };
  const root = fr / (7.5 * lam);
  const fc_psi = root * root;
  const out_of_band = lam < 0.75 || lam > 1.0;
  return {
    fc_psi, fc_ksi: fc_psi / 1000, out_of_band,
    note: "ACI 318-19 §19.2.3.1 fr = 7.5 x lambda x sqrt(f'c) solved for the strength: f'c = (fr / (7.5 x lambda))^2. Backs out the equivalent f'c implied by a flexural-beam (modulus-of-rupture) test, with lambda 1.0 normalweight and 0.75 all-lightweight. The code fr is a conservative lower bound and a real beam test scatters above it, so the implied f'c is a lower-bound equivalent, not a cylinder-break value. A design aid; the engineer of record's stamped design governs.",
  };
}
export const concreteStrengthFromRuptureExample = { inputs: { fr_psi: 474.342, lambda: 1.0 } };
CONCRETE_RENDERERS["concrete-strength-from-rupture"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 §19.2.3.1 fr = 7.5 x lambda x sqrt(f'c) solved for f'c = (fr / (7.5 x lambda))^2, by name, with lambda = 1.0 normalweight and 0.75 all-lightweight. The equivalent f'c from a flexural-beam test; the code fr is a conservative lower bound the true rupture strength scatters above. A design aid, not a substitute for the engineer of record.",
  example: concreteStrengthFromRuptureExample.inputs,
  fields: [
    { key: "fr_psi", label: "Modulus of rupture fr (psi)", kind: "number" },
    { key: "lambda", label: "Lightweight factor lambda (1.0 NW, 0.75 LW)", kind: "number" },
  ],
  outputs: [
    { key: "fc", id: "csr-out-fc", label: "Equivalent strength f'c", value: (r) => fmt(r.fc_psi, 0) + " psi (" + fmt(r.fc_ksi, 2) + " ksi)" },
    { key: "ob", id: "csr-out-ob", label: "Lambda range", value: (r) => r.out_of_band ? "OUT OF BAND (lambda outside 0.75-1.0)" : "within 0.75-1.0" },
    { key: "n", id: "csr-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteStrengthFromRupture,
});

// dims: in { b_in: L, h_in: L, fc_psi: M L^-1 T^-2, lambda: dimensionless } out: { fr_psi: M L^-1 T^-2, sm_in3: L^3, mcr_lbin: M L^2 T^-2, mcr_kipft: M L^2 T^-2 }
export function computeConcreteCrackingMoment({ b_in = 0, h_in = 0, fc_psi = 4000, lambda = 1.0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  if (!(b_in > 0)) return { error: "Section width b must be positive (in)." };
  if (!(h_in > 0)) return { error: "Section depth h must be positive (in)." };
  if (!(fc_psi > 0)) return { error: "Concrete strength f'c must be positive (psi)." };
  if (!(lambda > 0)) return { error: "Lightweight factor lambda must be positive." };
  if (lambda > 1) return { error: "Lightweight factor lambda cannot exceed 1.0 (ACI 318-19 19.2.4)." };
  const fr_psi = 7.5 * lambda * Math.sqrt(fc_psi);
  const sm_in3 = b_in * h_in * h_in / 6;
  const mcr_lbin = fr_psi * sm_in3;
  const mcr_kipft = mcr_lbin / 12000;
  const out_of_band = lambda < 0.75 || lambda > 1.0;
  return {
    fr_psi, sm_in3, mcr_lbin, mcr_kipft, out_of_band,
    note: "ACI 318-19 cracking moment Mcr = fr Ig / yt, the bending moment at which a plain (uncracked) section first cracks in flexure. With the modulus of rupture fr = 7.5 lambda sqrt(f'c) (§19.2.3.1; lambda 1.0 normalweight, 0.75 all-lightweight) and the gross rectangular section modulus S = Ig/yt = b h^2/6, Mcr = fr b h^2/6. This is the value behind the effective-moment-of-inertia (Ie) deflection analysis and the prestressed-member minimum-reinforcement check (§9.6.2.1: design strength at least 1.2 Mcr; a nonprestressed beam uses the As,min of §9.6.1.2 instead). Gross rectangular section with the reinforcement transform neglected (the standard approximation); a T-beam or a heavily reinforced section uses the transformed Ig. A design aid; the engineer of record's stamped design governs.",
  };
}
export const concreteCrackingMomentExample = { inputs: { b_in: 12, h_in: 20, fc_psi: 4000, lambda: 1.0 } };
CONCRETE_RENDERERS["concrete-cracking-moment"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 cracking moment Mcr = fr Ig/yt = fr b h^2/6 for a gross rectangular section, with the modulus of rupture fr = 7.5 lambda sqrt(f'c) (§19.2.3.1). The value behind the Ie deflection analysis and the prestressed-member minimum-reinforcement check (design strength >= 1.2 Mcr, §9.6.2.1; a nonprestressed beam uses the As,min of §9.6.1.2 instead). A design aid, not a substitute for a licensed engineer's design -- the engineer of record's stamped design governs.",
  example: concreteCrackingMomentExample.inputs,
  fields: [
    { key: "b_in", label: "Section width b (in)", kind: "number" },
    { key: "h_in", label: "Section total depth h (in)", kind: "number" },
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "lambda", label: "Lightweight factor lambda (1.0 NW, 0.75 LW)", kind: "number" },
  ],
  outputs: [
    { key: "mcr", id: "ccm-out-mcr", label: "Cracking moment Mcr", value: (r) => fmt(r.mcr_kipft, 2) + " kip-ft (" + fmt(r.mcr_lbin, 0) + " lb-in)" },
    { key: "fr", id: "ccm-out-fr", label: "Modulus of rupture fr", value: (r) => fmt(r.fr_psi, 0) + " psi" + (r.out_of_band ? " (lambda out of 0.75-1.0)" : "") },
    { key: "sm", id: "ccm-out-sm", label: "Gross section modulus S = b h²/6", value: (r) => fmt(r.sm_in3, 0) + " in^3" },
    { key: "n", id: "ccm-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteCrackingMoment,
});

// concrete-depth-for-cracking-moment: inverse of concrete-cracking-moment. The forward tile gives the cracking moment
// from the section depth; the inverse recovers the section depth that reaches a target cracking moment for a given width,
// so a designer sizes the section to a target Mcr (e.g. 1.2 Mcr for a prestressed member's minimum reinforcement). From
// Mcr = fr b h^2 / 6 with fr = 7.5 lambda sqrt(f'c), h = sqrt( 6 Mcr / (fr b) ).
// dims: in { target_mcr_kipft: M L^2 T^-2, b_in: L, fc_psi: M L^-1 T^-2, lambda: dimensionless } out: { h_in: L, fr_psi: M L^-1 T^-2, sm_in3: L^3 }
export function computeConcreteDepthForCrackingMoment({ target_mcr_kipft = 0, b_in = 0, fc_psi = 4000, lambda = 1.0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const mcr = Number(target_mcr_kipft) || 0;
  const b = Number(b_in) || 0;
  const fc = Number(fc_psi) || 0;
  const lam = Number(lambda) || 0;
  if (!(mcr > 0)) return { error: "Target cracking moment must be positive (kip-ft)." };
  if (!(b > 0)) return { error: "Section width b must be positive (in)." };
  if (!(fc > 0)) return { error: "Concrete strength f'c must be positive (psi)." };
  if (!(lam > 0)) return { error: "Lightweight factor lambda must be positive." };
  if (lam > 1) return { error: "Lightweight factor lambda cannot exceed 1.0 (ACI 318-19 19.2.4)." };
  const fr_psi = 7.5 * lam * Math.sqrt(fc);
  const mcr_lbin = mcr * 12000;
  const h_in = Math.sqrt(6 * mcr_lbin / (fr_psi * b));
  const sm_in3 = b * h_in * h_in / 6;
  const out_of_band = lam < 0.75 || lam > 1.0;
  if (![fr_psi, h_in, sm_in3].every(Number.isFinite)) return { error: "Section-depth math is not a finite value." };
  return {
    h_in, fr_psi, sm_in3, out_of_band,
    note: "ACI 318-19 cracking moment Mcr = fr b h^2/6 solved for the total depth: h = sqrt( 6 Mcr / (fr b) ), with the modulus of rupture fr = 7.5 lambda sqrt(f'c) (§19.2.3.1). Size to the target Mcr you need - for a prestressed member's minimum-reinforcement check (§9.6.2.1) the design strength must reach at least 1.2 Mcr, so a common use is to enter 1.2 Mcr and check the section against it. This is a gross rectangular section with the reinforcement transform neglected (the standard approximation); a T-beam or heavily reinforced section uses the transformed Ig, and the flexural, shear, and deflection design still govern the final depth. A design aid; the engineer of record's stamped design governs.",
  };
}
export const concreteDepthForCrackingMomentExample = { inputs: { target_mcr_kipft: 31.6, b_in: 12, fc_psi: 4000, lambda: 1.0 } };
CONCRETE_RENDERERS["concrete-depth-for-cracking-moment"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 cracking moment Mcr = fr b h^2/6 (fr = 7.5 lambda sqrt(f'c), §19.2.3.1) solved for the depth: h = sqrt( 6 Mcr / (fr b) ). The value behind the prestressed-member minimum-reinforcement check (design strength >= 1.2 Mcr, §9.6.2.1; a nonprestressed beam uses the As,min of §9.6.1.2 instead). A design aid, not a substitute for a licensed engineer's design -- the engineer of record's stamped design governs.",
  example: concreteDepthForCrackingMomentExample.inputs,
  fields: [
    { key: "target_mcr_kipft", label: "Target cracking moment Mcr (kip-ft)", kind: "number" },
    { key: "b_in", label: "Section width b (in)", kind: "number" },
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "lambda", label: "Lightweight factor lambda (1.0 NW, 0.75 LW)", kind: "number" },
  ],
  outputs: [
    { key: "h", id: "cdcm-out-h", label: "Required total depth h", value: (r) => fmt(r.h_in, 2) + " in" },
    { key: "fr", id: "cdcm-out-fr", label: "Modulus of rupture fr", value: (r) => fmt(r.fr_psi, 0) + " psi" + (r.out_of_band ? " (lambda out of 0.75-1.0)" : "") },
    { key: "sm", id: "cdcm-out-sm", label: "Gross section modulus S = b h²/6", value: (r) => fmt(r.sm_in3, 0) + " in^3" },
    { key: "n", id: "cdcm-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteDepthForCrackingMoment,
});

// dims: in { h_in: L, b_in: L, grade_ksi: M L^-1 T^-2 } out: { ratio: dimensionless, as_min_in2: L^2, s_max_in: L, grade_ksi: M L^-1 T^-2 }
export function computeConcreteShrinkageTemperatureSteel({ h_in = 0, b_in = 12, grade_ksi = 60 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  if (!(h_in > 0)) return { error: "Slab thickness h must be positive (in)." };
  if (!(b_in > 0)) return { error: "Design strip width b must be positive (in)." };
  if (!(grade_ksi > 0)) return { error: "Reinforcement grade must be positive (ksi)." };
  // ACI 318-19 Table 24.4.3.2: 0.0018 for deformed bars and welded wire of any
  // grade. Until 2026-09-24 this carried ACI 318-14's split (0.0020 below Grade
  // 60, 60/fy scaling above) under a 318-19 citation.
  const ratio = 0.0018;
  const ag_in2 = b_in * h_in;
  const as_min_in2 = ratio * ag_in2;
  const s_max_in = Math.min(5 * h_in, 18);
  const spacing_governor = 5 * h_in < 18 ? "5h" : "18 in cap";
  return {
    ratio, ag_in2, as_min_in2, s_max_in, spacing_governor,
    // Echoed: under ACI 318-19 the grade no longer changes the ratio.
    grade_ksi: Number(grade_ksi),
    note: "ACI 318-19 §24.4.3.2: minimum shrinkage-and-temperature reinforcement ratio is 0.0018 for deformed bars and welded wire of every grade (ACI 318-14 used 0.0020 below Grade 60 and scaled higher grades by 60/fy; the 2019 edition dropped both); As,min = ratio x b x h per strip. §24.4.3.3 caps the spacing at the smaller of 5h and 18 in. This is the steel perpendicular to the main bars in a one-way slab, not the flexural steel. A design aid; the engineer of record's stamped design governs.",
  };
}
export const concreteShrinkageTemperatureSteelExample = { inputs: { h_in: 6, b_in: 12, grade_ksi: 60 } };
CONCRETE_RENDERERS["concrete-shrinkage-temperature-steel"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 §24.4.3.2 (minimum shrinkage and temperature reinforcement ratio: 0.0018 for deformed bars and welded wire of any grade; the 0.0020 for Grade 40/50 was ACI 318-14) and §24.4.3.3 (spacing not to exceed the smaller of 5h and 18 in). As,min = ratio x b x h is the reinforcement perpendicular to the main bars in a one-way slab. Does not size the flexural (main) steel or check crack width for exposure. A design aid, not a substitute for a licensed engineer's design -- the engineer of record's stamped design governs.",
  example: concreteShrinkageTemperatureSteelExample.inputs,
  fields: [
    { key: "h_in", label: "Slab thickness h (in)", kind: "number" },
    { key: "b_in", label: "Design strip width b (in, default 12)", kind: "number", default: 12 },
    { key: "grade_ksi", label: "Reinforcement grade (ksi)", kind: "select", options: [
      { value: "60", label: "Grade 60 (ratio 0.0018)" },
      { value: "40", label: "Grade 40 (ratio 0.0018)" },
      { value: "50", label: "Grade 50 (ratio 0.0018)" },
    ], default: "60" },
  ],
  outputs: [
    { key: "rt", id: "csts-out-rt", label: "Reinforcement ratio", value: (r) => fmt(r.ratio, 4) },
    { key: "as", id: "csts-out-as", label: "Minimum area As,min = ratio x b x h", value: (r) => fmt(r.as_min_in2, 3) + " in^2 per strip" },
    { key: "sm", id: "csts-out-sm", label: "Max spacing min(5h, 18 in)", value: (r) => fmt(r.s_max_in, 1) + " in (" + r.spacing_governor + " governs)" },
    { key: "n", id: "csts-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteShrinkageTemperatureSteel,
});

// ===================== spec-v393..v395: concrete design-details trio =====================

// dims: in { bw_in: L, hf_in: L, ln_in: L, sw_in: L, beam_type: dimensionless } out: { overhang_in: L, be_in: L }
export function computeTBeamEffectiveFlangeWidth({ bw_in = 0, hf_in = 0, ln_in = 0, sw_in = 0, beam_type = "interior" } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const bw = Number(bw_in) || 0;
  const hf = Number(hf_in) || 0;
  const ln = Number(ln_in) || 0;
  const sw = Number(sw_in) || 0;
  if (!(bw > 0)) return { error: "Web width bw must be positive (in)." };
  if (!(hf > 0)) return { error: "Flange (slab) thickness hf must be positive (in)." };
  if (!(ln > 0)) return { error: "Clear span ln must be positive (in)." };
  if (!(sw > 0)) return { error: "Clear distance to the adjacent web sw must be positive (in)." };
  // An unrecognized type used to be an interior beam, which counts the flange on both sides.
  if (beam_type !== "edge" && beam_type !== "interior") return { error: "Beam type must be interior (flange both sides) or edge (flange one side)." };
  const edge = beam_type === "edge";
  const overhang = edge
    ? Math.min(6 * hf, sw / 2, ln / 12)
    : Math.min(8 * hf, sw / 2, ln / 8);
  const be_in = edge ? bw + overhang : bw + 2 * overhang;
  const governs = edge
    ? (overhang === 6 * hf ? "6 hf" : overhang === sw / 2 ? "sw/2" : "ln/12")
    : (overhang === 8 * hf ? "8 hf" : overhang === sw / 2 ? "sw/2" : "ln/8");
  return {
    overhang_in: overhang, be_in, governs,
    note: "ACI 318-19 §6.3.2 effective flange width of a T-beam: the slab that acts with the web is limited to the smallest of a multiple of the flange thickness, half the clear distance to the next web, and a fraction of the clear span - taken on both sides for an interior beam (be = bw + 2 x overhang) and one side for an edge/spandrel beam (be = bw + overhang). Only this width is counted as the compression flange in the flexural design. A design aid; the engineer of record's stamped design governs.",
  };
}
export const tBeamEffectiveFlangeWidthExample = { inputs: { bw_in: 12, hf_in: 4, ln_in: 240, sw_in: 48, beam_type: "interior" } };
CONCRETE_RENDERERS["t-beam-effective-flange-width"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 §6.3.2.1 (interior T-beam effective flange overhang = smallest of 8 hf, half the clear distance to the next web, and ln/8; be = bw + 2 x overhang) and §6.3.2.1 for an edge beam (6 hf, half the clear distance, ln/12; be = bw + overhang). Only the effective flange acts as the compression flange in flexure. A design aid, not a substitute for a licensed engineer's design -- the engineer of record's stamped design governs.",
  example: tBeamEffectiveFlangeWidthExample.inputs,
  fields: [
    { key: "bw_in", label: "Web width bw (in)", kind: "number" },
    { key: "hf_in", label: "Flange (slab) thickness hf (in)", kind: "number" },
    { key: "ln_in", label: "Clear span ln (in)", kind: "number" },
    { key: "sw_in", label: "Clear distance to adjacent web sw (in)", kind: "number" },
    { key: "beam_type", label: "Beam type", kind: "select", options: [
      { value: "interior", label: "Interior (flange both sides)" },
      { value: "edge", label: "Edge / spandrel (flange one side)" },
    ], default: "interior" },
  ],
  outputs: [
    { key: "oh", id: "tbf-out-oh", label: "Per-side flange overhang", value: (r) => fmt(r.overhang_in, 1) + " in (" + r.governs + " governs)" },
    { key: "be", id: "tbf-out-be", label: "Effective flange width be", value: (r) => fmt(r.be_in, 1) + " in" },
    { key: "n", id: "tbf-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeTBeamEffectiveFlangeWidth,
});

// dims: in { fc_psi: M L^-1 T^-2, fy_psi: M L^-1 T^-2, bw_in: L, d_in: L } out: { ratio: dimensionless, as_min_in2: L^2 }
export function computeConcreteBeamMinFlexuralSteel({ fc_psi = 4000, fy_psi = 60000, bw_in = 0, d_in = 0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const fc = Number(fc_psi) || 0;
  const fy = Number(fy_psi) || 0;
  const bw = Number(bw_in) || 0;
  const d = Number(d_in) || 0;
  if (!(fc > 0)) return { error: "Concrete strength f'c must be positive (psi)." };
  if (!(fy > 0)) return { error: "Steel yield fy must be positive (psi)." };
  if (!(bw > 0)) return { error: "Web width bw must be positive (in)." };
  if (!(d > 0)) return { error: "Effective depth d must be positive (in)." };
  // 9.6.1.2: fy in this expression is limited to 80,000 psi, so Grade 100 steel gets no further
  // reduction in As,min. Until 2026-10-10 it did (0.48 in^2 where 0.60 is required).
  const fy_used_psi = Math.min(fy, 80000);
  const term_sqrt = 3 * Math.sqrt(fc) / fy_used_psi;
  const term_flat = 200 / fy_used_psi;
  const ratio = Math.max(term_sqrt, term_flat);
  const as_min_in2 = ratio * bw * d;
  const governs = term_sqrt >= term_flat ? "3 sqrt(f'c)/fy" : "200/fy";
  return {
    ratio, as_min_in2, governs, fy_used_psi,
    note: "ACI 318-19 §9.6.1.2 minimum flexural reinforcement: As,min = max(3 sqrt(f'c)/fy, 200/fy) x bw x d, with fy taken as no more than 80,000 psi, so the beam has more capacity cracked than uncracked and does not fail suddenly at first cracking. The 200/fy floor governs up to about f'c = 4444 psi; above that the 3 sqrt(f'c)/fy term controls. For a statically determinate T-beam with the flange in tension, bw is replaced by the smaller of 2 bw and the flange width (not applied here). A design aid; the engineer of record's stamped design governs.",
  };
}
export const concreteBeamMinFlexuralSteelExample = { inputs: { fc_psi: 4000, fy_psi: 60000, bw_in: 12, d_in: 20 } };
CONCRETE_RENDERERS["concrete-beam-min-flexural-steel"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 §9.6.1.2: minimum flexural reinforcement As,min = max(3 sqrt(f'c)/fy, 200/fy) x bw x d with fy limited to 80,000 psi, ensuring the cracking moment does not exceed the flexural capacity (no sudden failure at first crack). The 200/fy floor governs to about f'c = 4444 psi; the sqrt term controls above. A design aid, not a substitute for a licensed engineer's design -- the engineer of record's stamped design governs.",
  example: concreteBeamMinFlexuralSteelExample.inputs,
  fields: [
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "fy_psi", label: "Steel yield fy (psi)", kind: "number" },
    { key: "bw_in", label: "Web width bw (in)", kind: "number" },
    { key: "d_in", label: "Effective depth d (in)", kind: "number" },
  ],
  outputs: [
    { key: "rt", id: "cmf-out-rt", label: "Minimum steel ratio", value: (r) => fmt(r.ratio, 5) + " (" + r.governs + " governs)" },
    { key: "as", id: "cmf-out-as", label: "Minimum area As,min", value: (r) => fmt(r.as_min_in2, 2) + " in^2" },
    { key: "n", id: "cmf-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteBeamMinFlexuralSteel,
});

// dims: in { fs_psi: M L^-1 T^-2, cc_in: L } out: { s1_in: L, s2_in: L, s_max_in: L }
export function computeConcreteCrackControlSpacing({ fs_psi = 40000, cc_in = null } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const fs = Number(fs_psi) || 0;
  // A blank cover used to compute as 0 in, which gives the widest spacing the rule allows.
  if (cc_in === null || cc_in === "") return { error: "Enter the clear cover cc (in); the spacing limit tightens as cover grows." };
  const cc = Number(cc_in) || 0;
  if (!(fs > 0)) return { error: "Service-load steel stress fs must be positive (psi)." };
  if (!(cc >= 0)) return { error: "Clear cover must be non-negative (in)." };
  const s1 = 15 * (40000 / fs) - 2.5 * cc;
  const s2 = 12 * (40000 / fs);
  const s_max = Math.min(s1, s2);
  if (!(s_max > 0)) return { error: "Required spacing is not positive -- reduce cover or steel stress (the section needs redesign)." };
  return {
    s1_in: s1, s2_in: s2, s_max_in: s_max,
    governs: s1 <= s2 ? "s1 (cover term)" : "s2 (12 x 40000/fs cap)",
    note: "ACI 318-19 §24.3.2 maximum spacing of tension reinforcement for flexural crack control: s = 15(40000/fs) - 2.5 cc, but not more than 12(40000/fs), where fs is the service-load stress (permitted as 2/3 fy) and cc is the clear cover to the nearest bar surface. Wider spacing or higher stress opens wider cracks; more cover requires tighter spacing. This is a serviceability (crack-width) limit, not a strength check. A design aid; the engineer of record's stamped design governs.",
  };
}
export const concreteCrackControlSpacingExample = { inputs: { fs_psi: 40000, cc_in: 2 } };
CONCRETE_RENDERERS["concrete-crack-control-spacing"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 §24.3.2: maximum tension-bar spacing for flexural crack control s = 15(40000/fs) - 2.5 cc, not more than 12(40000/fs), with fs the service-load steel stress (may be taken as 2/3 fy) and cc the clear cover. A serviceability crack-control limit, not a strength check. A design aid, not a substitute for a licensed engineer's design -- the engineer of record's stamped design governs.",
  example: concreteCrackControlSpacingExample.inputs,
  fields: [
    { key: "fs_psi", label: "Service steel stress fs (psi; 2/3 fy is permitted, 40,000 for Grade 60)", kind: "number", default: 40000 },
    { key: "cc_in", label: "Clear cover cc (in)", kind: "number", required: true },
  ],
  outputs: [
    { key: "s1", id: "ccs-out-s1", label: "s1 = 15(40000/fs) - 2.5 cc", value: (r) => fmt(r.s1_in, 1) + " in" },
    { key: "s2", id: "ccs-out-s2", label: "s2 = 12(40000/fs) cap", value: (r) => fmt(r.s2_in, 1) + " in" },
    { key: "sm", id: "ccs-out-sm", label: "Max bar spacing", value: (r) => fmt(r.s_max_in, 1) + " in (" + r.governs + ")" },
    { key: "n", id: "ccs-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteCrackControlSpacing,
});

// ===================== spec-v447: concrete threshold and cracking torsion (ACI 318-19 22.7) =====================
// dims: in { fc_psi: M L^-1 T^-2, b_in: L, h_in: L, lambda: dimensionless } out: { acp_in2: L^2, pcp_in: L, tth_inlb: M L^2 T^-2, neglect_inlb: M L^2 T^-2, tcr_inlb: M L^2 T^-2 }
export function computeConcreteTorsionThreshold({ fc_psi = 4000, b_in = 0, h_in = 0, lambda = 1.0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const fc = Number(fc_psi) || 0;
  const b = Number(b_in) || 0;
  const h = Number(h_in) || 0;
  const lam = Number(lambda) || 0;
  if (!(fc > 0)) return { error: "Specified strength f'c must be positive (psi)." };
  if (!(b > 0)) return { error: "Section width must be positive (in)." };
  if (!(h > 0)) return { error: "Section height must be positive (in)." };
  if (!(lam > 0)) return { error: "Lightweight factor lambda must be positive." };
  if (lam > 1) return { error: "Lightweight factor lambda cannot exceed 1.0 (ACI 318-19 19.2.4)." };
  const acp_in2 = b * h;
  const pcp_in = 2 * (b + h);
  // 22.7 caps sqrt(f'c) at 100 psi for Tth and Tcr; uncapped, a higher
  // threshold would let torsion be neglected when it should not be (the
  // non-conservative direction). Only bites above f'c = 10,000 psi.
  const sqrt_fc = Math.min(Math.sqrt(fc), 100);
  const tth_inlb = lam * sqrt_fc * (acp_in2 * acp_in2 / pcp_in);
  const neglect_inlb = 0.75 * tth_inlb;
  const tcr_inlb = 4 * tth_inlb;
  return {
    acp_in2, pcp_in, tth_inlb, neglect_inlb, tcr_inlb,
    note: "ACI 318-19 §22.7 torsion thresholds for a solid non-prestressed section: the threshold torsion Tth = lambda x sqrt(f'c) x (Acp^2 / pcp), where Acp = b x h is the area enclosed by the outside perimeter and pcp = 2(b + h) is that perimeter. Torsion may be neglected when the factored torque Tu is below phi x Tth (phi = 0.75); the section cracks in torsion at Tcr = 4 x Tth. sqrt(f'c) is capped at 100 psi per §22.7 (so f'c above 10,000 psi does not raise the threshold further). Above phi x Tth the beam must be designed for torsion with closed stirrups (At/s) and longitudinal steel (Al) per §9.5.4. A design aid, not a substitute for a licensed engineer's design -- the engineer of record's stamped design governs.",
  };
}
export const concreteTorsionThresholdExample = { inputs: { fc_psi: 4000, b_in: 12, h_in: 20, lambda: 1.0 } };
CONCRETE_RENDERERS["concrete-torsion-threshold"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 §22.7.4.1: threshold torsion Tth = lambda x sqrt(f'c) x (Acp^2/pcp), neglect torsion when Tu < phi x Tth (phi = 0.75), cracking torsion Tcr = 4 x Tth, with Acp and pcp the area and perimeter of the outside section, and the §22.7 sqrt(f'c) <= 100 psi cap. A design aid, not a substitute for a licensed engineer's design -- the engineer of record's stamped design governs.",
  example: concreteTorsionThresholdExample.inputs,
  fields: [
    { key: "fc_psi", label: "Specified strength f'c (psi)", kind: "number" },
    { key: "b_in", label: "Section width b (in)", kind: "number" },
    { key: "h_in", label: "Section height h (in)", kind: "number" },
    { key: "lambda", label: "Lightweight factor lambda (1.0 normal)", kind: "number" },
  ],
  outputs: [
    { key: "tth", id: "ctt-out-tth", label: "Threshold torsion Tth", value: (r) => fmt(r.tth_inlb, 0) + " in-lb (" + fmt(r.tth_inlb / 12000, 2) + " ft-kip)" },
    { key: "ne", id: "ctt-out-ne", label: "Neglect if Tu below phi x Tth", value: (r) => fmt(r.neglect_inlb / 12000, 2) + " ft-kip" },
    { key: "tcr", id: "ctt-out-tcr", label: "Cracking torsion Tcr = 4 Tth", value: (r) => fmt(r.tcr_inlb / 12000, 2) + " ft-kip" },
    { key: "ap", id: "ctt-out-ap", label: "Acp / pcp", value: (r) => fmt(r.acp_in2, 0) + " in^2 / " + fmt(r.pcp_in, 0) + " in" },
    { key: "n", id: "ctt-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteTorsionThreshold,
});

// ===================== spec-v490: concrete bearing strength (ACI 318-19 §22.8) =====================

// dims: in { loaded_area_in2: L^2, support_area_in2: L^2, fc_psi: M L^-1 T^-2, factored_load_kip: M L T^-2 } out: { sqrt_ratio: dimensionless, bn_lb: M L T^-2, phibn_kip: M L T^-2, dcr: dimensionless }
export function computeConcreteBearingStrength({ loaded_area_in2 = 0, support_area_in2 = 0, fc_psi = 4000, factored_load_kip = 0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const a1 = Number(loaded_area_in2) || 0;
  const a2 = Number(support_area_in2) || 0;
  const fc = Number(fc_psi) || 0;
  const pu = Number(factored_load_kip) || 0;
  if (!(a1 > 0)) return { error: "Loaded area A1 must be positive (in^2)." };
  if (!(a2 >= a1)) return { error: "Supporting area A2 must be at least the loaded area A1 (A2 < A1 is geometrically impossible)." };
  if (!(fc > 0)) return { error: "Concrete strength f'c must be positive (psi)." };
  if (pu < 0) return { error: "Factored load must be non-negative (kip; 0 = capacity only)." };
  const sqrt_ratio = Math.min(Math.sqrt(a2 / a1), 2.0);
  const bn_lb = 0.85 * fc * a1 * sqrt_ratio;
  const phibn_kip = 0.65 * bn_lb / 1000;
  const dcr = pu > 0 ? pu / phibn_kip : null;
  if (![sqrt_ratio, bn_lb, phibn_kip].every(Number.isFinite)) return { error: "Bearing-strength math is not a finite value." };
  return { sqrt_ratio, bn_lb, phibn_kip, dcr };
}

export const concreteBearingStrengthExample = { inputs: { loaded_area_in2: 144, support_area_in2: 1296, fc_psi: 4000, factored_load_kip: 500 } };

CONCRETE_RENDERERS["concrete-bearing-strength"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 §22.8.3 bearing strength: sqrt_ratio = min(sqrt(A2 / A1), 2.0), Bn = 0.85 x f'c x A1 x sqrt_ratio, phiBn = 0.65 x Bn (phi = 0.65 for bearing, §21.2). The sqrt(A2/A1) confinement bonus applies only when the supporting surface is wider than the loaded area on all sides and the slopes/steps meet §22.8.3.2, and it is capped at 2.0. A required bearing area exceeding the member may need a bearing plate or confinement reinforcement. A design aid, not a substitute for the structural engineer of record's stamped design.",
  example: concreteBearingStrengthExample.inputs,
  fields: [
    { key: "loaded_area_in2", label: "Loaded area A1 (in²)", kind: "number" },
    { key: "support_area_in2", label: "Supporting area A2 (in², >= A1)", kind: "number" },
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "factored_load_kip", label: "Factored load Pu (kip, 0 = capacity only)", kind: "number", default: 0 },
  ],
  outputs: [
    { key: "sr", id: "cbs-out-sr", label: "Confinement factor sqrt(A2/A1), capped at 2.0", value: (r) => fmt(r.sqrt_ratio, Math.abs(r.sqrt_ratio - 2) < 0.0005 && r.sqrt_ratio !== 2 ? 5 : 3) + (r.sqrt_ratio >= 2 ? " (at the 2.0 cap)" : "") },
    { key: "bn", id: "cbs-out-bn", label: "Nominal bearing strength Bn", value: (r) => fmt(r.bn_lb, 0) + " lb (" + fmt(r.bn_lb / 1000, 1) + " kip)" },
    { key: "pb", id: "cbs-out-pb", label: "Design bearing strength phiBn (phi = 0.65)", value: (r) => fmt(r.phibn_kip, 1) + " kip" },
    { key: "dcr", id: "cbs-out-dcr", label: "Demand / capacity", value: (r) => r.dcr === null ? "- (no Pu entered)" : fmt(r.dcr, Math.abs(r.dcr - 1) < 0.005 && r.dcr !== 1 ? 4 : 2) + (r.dcr <= 1 + 1e-9 ? " (OK)" : " (OVER)") },
  ],
  compute: computeConcreteBearingStrength,
});

// ===================== spec-v491: rebar compression development length (ACI 318-19 §25.4.9) =====================

// dims: in { bar_diameter_in: L, fy_psi: M L^-1 T^-2, fc_psi: M L^-1 T^-2, lambda: dimensionless, psi_r: dimensionless } out: { term1_in: L, term2_in: L, ldc_in: L, governing: dimensionless }
export function computeRcCompressionDevLength({ bar_diameter_in = 0, fy_psi = 60000, fc_psi = 4000, lambda = 1.0, psi_r = 1.0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const db = Number(bar_diameter_in) || 0;
  const fy = Number(fy_psi) || 0;
  const fc = Number(fc_psi) || 0;
  const lam = Number(lambda) || 0;
  const pr = Number(psi_r) || 0;
  if (!(db > 0)) return { error: "Bar diameter db must be positive (in)." };
  if (!(fy > 0)) return { error: "Bar yield fy must be positive (psi)." };
  if (!(fc > 0)) return { error: "Concrete strength f'c must be positive (psi)." };
  if (!(lam > 0 && lam <= 1)) return { error: "Lightweight factor lambda must be in (0, 1] (1.0 normalweight, 0.75 lightweight)." };
  if (!(pr >= 0.75 && pr <= 1.0)) return { error: "Confinement factor psi_r must be 0.75 to 1.0 (0.75 with ties/spiral per 25.4.9.3, else 1.0)." };
  // 25.4.1.4 caps sqrt(f'c) at 100 psi in development-length calculations; in
  // the denominator, the cap lengthens term1 above f'c = 10,000 psi (conservative).
  const sqrt_fc = Math.min(Math.sqrt(fc), 100);
  const term1_in = (fy * pr) / (50 * lam * sqrt_fc) * db;
  const term2_in = 0.0003 * fy * pr * db;
  const ldc_in = Math.max(term1_in, term2_in, 8.0);
  const governing = ldc_in <= 8.0 ? "8 in minimum" : (term1_in >= term2_in ? "term1: fy / (50 lambda sqrt(f'c))" : "term2: 0.0003 fy floor");
  if (![term1_in, term2_in, ldc_in].every(Number.isFinite)) return { error: "Compression-development math is not a finite value." };
  return { term1_in, term2_in, ldc_in, governing };
}

export const rcCompressionDevLengthExample = { inputs: { bar_diameter_in: 1.0, fy_psi: 60000, fc_psi: 4000, lambda: 1.0, psi_r: 1.0 } };

CONCRETE_RENDERERS["rc-compression-dev-length"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 §25.4.9.2 compression development length ldc = max((fy x psi_r) / (50 x lambda x sqrt(f'c)) x db, 0.0003 x fy x psi_r x db, 8 in). Compression development is shorter than tension because the bar end bears on the concrete (no flexural-cracking penalty). The 0.0003 fy db term governs at high f'c, where the sqrt(f'c) term keeps shrinking, and the 25.4.1.4 cap (sqrt(f'c) <= 100 psi) freezes the sqrt(f'c) term at f'c = 10,000 psi so it cannot shrink further. psi_r = 0.75 applies only where §25.4.9.3 confining reinforcement (ties or a spiral of the stated size and spacing) wraps the developed bar; lambda = 0.75 for lightweight concrete. Lap-splice (§25.5) and minimum-length provisions still apply. A design aid, not a substitute for the engineer of record's detailing.",
  example: rcCompressionDevLengthExample.inputs,
  fields: [
    { key: "bar_diameter_in", label: "Bar diameter db (in, #8 = 1.00)", kind: "number" },
    { key: "fy_psi", label: "Bar yield fy (psi)", kind: "number" },
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "lambda", label: "Lightweight factor lambda (1.0 normalweight, 0.75 lightweight)", kind: "number" },
    { key: "psi_r", label: "Confinement factor psi_r (0.75 with ties/spiral, else 1.0)", kind: "number" },
  ],
  outputs: [
    { key: "t1", id: "rcd-out-t1", label: "Term 1: fy / (50 lambda sqrt(f'c)) x db", value: (r) => fmt(r.term1_in, 2) + " in" },
    { key: "t2", id: "rcd-out-t2", label: "Term 2: 0.0003 fy db (floor)", value: (r) => fmt(r.term2_in, 2) + " in" },
    { key: "ld", id: "rcd-out-ld", label: "Compression development length ldc (8 in min)", value: (r) => fmt(r.ldc_in, 1) + " in" },
    { key: "gv", id: "rcd-out-gv", label: "Governing term", value: (r) => r.governing },
  ],
  compute: computeRcCompressionDevLength,
});

// ===================== spec-v1237: effective moment of inertia Ie (ACI 318-19 §24.2.3.5, Bischoff) =====================
// The Ie the cracking-moment tile names ("the value behind the Ie deflection analysis") and the value the
// long-term-deflection tile takes as a hand-entered input but nobody derives. ACI 318-19 replaced Branson's cubic
// with Bischoff's form: Ie = Ig when Ma <= (2/3)Mcr (Eq 24.2.3.5b), else Ie = Icr/[1 - ((2/3)Mcr/Ma)^2 (1 - Icr/Ig)]
// (Eq 24.2.3.5a). Mcr = fr Ig/yt, fr = 7.5 lambda sqrt(f'c). Icr is the cracked transformed section (singly
// reinforced rectangular): n = Es/Ec, kd = d(sqrt((rho n)^2 + 2 rho n) - rho n), Icr = b kd^3/3 + n As (d-kd)^2.
// dims: in { b_in: L, h_in: L, d_in: L, as_in2: L^2, fc_psi: M L^-1 T^-2, ma_kipft: M L^2 T^-2, lambda: dimensionless } out: { ig_in4: L^4, icr_in4: L^4, ie_in4: L^4, mcr_kipft: M L^2 T^-2 }
export function computeConcreteEffectiveInertia({ b_in = 0, h_in = 0, d_in = 0, as_in2 = 0, fc_psi = 4000, ma_kipft = 0, lambda = 1.0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const b = Number(b_in), h = Number(h_in), d = Number(d_in), As = Number(as_in2);
  const fc = Number(fc_psi), Ma_kipft = Number(ma_kipft), lam = Number(lambda);
  if (!(b > 0)) return { error: "Section width b must be positive (in)." };
  if (!(h > 0)) return { error: "Section total depth h must be positive (in)." };
  if (!(d > 0)) return { error: "Effective depth d must be positive (in)." };
  if (!(d < h)) return { error: "Effective depth d must be less than the total depth h." };
  if (!(As > 0)) return { error: "Tension steel area As must be positive (in^2)." };
  if (!(fc > 0)) return { error: "Concrete strength f'c must be positive (psi)." };
  if (!(Ma_kipft > 0)) return { error: "Service moment Ma must be positive (kip-ft)." };
  if (!(lam > 0)) return { error: "Lightweight factor lambda must be positive." };
  if (lam > 1) return { error: "Lightweight factor lambda cannot exceed 1.0 (ACI 318-19 19.2.4)." };
  const Es = 29000000; // psi
  const Ec = 57000 * Math.sqrt(fc); // ACI 19.2.2.1(b) normalweight
  const n = Es / Ec;
  const ig_in4 = b * h * h * h / 12;
  const yt = h / 2;
  const fr = 7.5 * lam * Math.sqrt(fc);
  const mcr_lbin = fr * ig_in4 / yt;
  const mcr_kipft = mcr_lbin / 12000;
  const ma_lbin = Ma_kipft * 12000;
  const rho = As / (b * d);
  const rn = rho * n;
  const kd = d * (Math.sqrt(rn * rn + 2 * rn) - rn);
  const icr_in4 = b * kd * kd * kd / 3 + n * As * (d - kd) * (d - kd);
  const cracked = ma_lbin > (2 / 3) * mcr_lbin;
  let ie_in4;
  if (!cracked) {
    ie_in4 = ig_in4; // Eq 24.2.3.5b
  } else {
    // Eq 24.2.3.5a carries the 2/3 INSIDE: Ie = Icr / [1 - ((2/3)Mcr/Ma)^2 (1 - Icr/Ig)],
    // which meets Ig exactly at Ma = (2/3)Mcr where 24.2.3.5b hands over. Until
    // 2026-09-18 the 2/3 was only in the switch, so Ie jumped there and went
    // NEGATIVE just above it (the Ie > Ig clamp hid part of that band).
    ie_in4 = icr_in4 / (1 - Math.pow((2 / 3) * mcr_lbin / ma_lbin, 2) * (1 - icr_in4 / ig_in4)); // Eq 24.2.3.5a
    if (ie_in4 > ig_in4) ie_in4 = ig_in4; // Ie can never exceed Ig
  }
  if (![ig_in4, icr_in4, ie_in4, mcr_kipft, kd].every(Number.isFinite)) return { error: "Effective-inertia math is not a finite value." };
  return {
    ig_in4, icr_in4, ie_in4, mcr_kipft, kd_in: kd, ec_psi: Ec, n, ie_ratio: ie_in4 / ig_in4, cracked,
    note: "ACI 318-19 §24.2.3.5 effective moment of inertia for deflection, the value the cracking-moment tile points to and the immediate deflection the long-term-deflection tile needs. The 2019 code replaced Branson's cubic with Bischoff's form: if the service moment Ma <= (2/3) Mcr the section is essentially uncracked and Ie = Ig; once Ma exceeds (2/3) Mcr, Ie = Icr / [1 - ((2/3)Mcr/Ma)^2 (1 - Icr/Ig)], which drops rapidly toward the cracked value Icr as the load grows. Mcr = fr Ig/yt with fr = 7.5 lambda sqrt(f'c); Icr is the cracked transformed section n = Es/Ec, kd = d(sqrt((rho n)^2 + 2 rho n) - rho n), Icr = b kd^3/3 + n As (d-kd)^2 for a singly-reinforced rectangular beam (Es = 29,000,000 psi, Ec = 57000 sqrt(f'c) normalweight). The immediate deflection is then (a load-case coefficient) w L^4 / (Ec Ie); feed that into concrete-longterm-defl for creep and shrinkage. Bischoff's form predicts larger deflections than the old Branson equation, especially for lightly reinforced slabs. Singly-reinforced rectangular section; a T-beam or doubly-reinforced section uses the appropriate transformed Icr. A design aid; the engineer of record's stamped design governs.",
  };
}
export const concreteEffectiveInertiaExample = { inputs: { b_in: 12, h_in: 20, d_in: 17.5, as_in2: 3.0, fc_psi: 4000, ma_kipft: 60, lambda: 1.0 } };
CONCRETE_RENDERERS["concrete-effective-inertia"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 §24.2.3.5 effective moment of inertia (Bischoff): Ie = Ig for Ma <= (2/3)Mcr (Eq 24.2.3.5b), else Ie = Icr/[1 - ((2/3)Mcr/Ma)^2 (1 - Icr/Ig)] (Eq 24.2.3.5a). Mcr = fr Ig/yt, fr = 7.5 lambda sqrt(f'c) (§19.2.3.1); Icr is the cracked transformed section (singly-reinforced rectangular) with n = Es/Ec and Ec = 57000 sqrt(f'c) (§19.2.2.1). The 2019 code removed Branson's cubic. Confirmed against the ACI 318-19 code change (StructurePoint / PCA). A design aid, not a substitute for a licensed engineer's design -- the engineer of record's stamped design governs.",
  example: concreteEffectiveInertiaExample.inputs,
  fields: [
    { key: "b_in", label: "Section width b (in)", kind: "number" },
    { key: "h_in", label: "Total depth h (in)", kind: "number" },
    { key: "d_in", label: "Effective depth d to tension steel (in)", kind: "number" },
    { key: "as_in2", label: "Tension steel area As (in²)", kind: "number" },
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "ma_kipft", label: "Service moment Ma (kip-ft)", kind: "number" },
    { key: "lambda", label: "Lightweight factor lambda (1.0 NW, 0.75 LW)", kind: "number" },
  ],
  outputs: [
    { key: "ie", id: "cei-out-ie", label: "Effective inertia Ie", value: (r) => fmt(r.ie_in4, 0) + " in^4 (" + fmt(r.ie_ratio * 100, 0) + "% of Ig" + (r.cracked ? ", cracked" : ", uncracked -> Ig") + ")" },
    { key: "icr", id: "cei-out-icr", label: "Cracked inertia Icr", value: (r) => fmt(r.icr_in4, 0) + " in^4 (kd = " + fmt(r.kd_in, 2) + " in)" },
    { key: "ig", id: "cei-out-ig", label: "Gross inertia Ig", value: (r) => fmt(r.ig_in4, 0) + " in^4" },
    { key: "mcr", id: "cei-out-mcr", label: "Cracking moment Mcr", value: (r) => fmt(r.mcr_kipft, 2) + " kip-ft" },
    { key: "n", id: "cei-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteEffectiveInertia,
});

// ===================== spec-v497: long-term deflection multiplier (ACI 318-19 §24.2.4.1) =====================

// dims: in { immediate_defl_in: L, duration_months: T, comp_steel_ratio: dimensionless } out: { xi: dimensionless, lambda: dimensionless, additional_defl_in: L, total_defl_in: L }
export function computeConcreteLongtermDefl({ immediate_defl_in = 0, duration_months = 60, comp_steel_ratio = 0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const di = Number(immediate_defl_in) || 0;
  const mo = Number(duration_months) || 0;
  const rho = Number(comp_steel_ratio) || 0;
  if (di < 0) return { error: "Immediate deflection cannot be negative (in)." };
  if (!(mo > 0)) return { error: "Sustained-load duration must be positive (months)." };
  if (rho < 0) return { error: "Compression-steel ratio cannot be negative." };
  if (rho > 0.08) return { error: "The compression-steel ratio is a fraction (0.01 for 1%), and no more than 0.08." };
  // Table 24.2.4.1.3 gives xi at 3, 6, 12 and 60 months or more: 1.0, 1.2, 1.4,
  // 2.0. Between those points it rises (Fig. R24.2.4.1), so stepping down to the
  // last table point understated a 3 to 5 year deflection by up to 30% (1.4 at
  // 59 months, 2.0 at 60). Interpolated here on the logarithm of time, which
  // tracks the figure; under 3 months the 3-month value is kept, which is high.
  const XI = [[3, 1.0], [6, 1.2], [12, 1.4], [60, 2.0]];
  let xi = mo >= 60 ? 2.0 : 1.0;
  for (let i = 0; i < XI.length - 1; i++) {
    const [m0, x0] = XI[i], [m1, x1] = XI[i + 1];
    if (mo >= m0 && mo < m1) xi = x0 + (x1 - x0) * Math.log(mo / m0) / Math.log(m1 / m0);
  }
  const lambda = xi / (1 + 50 * rho);
  const additional_defl_in = lambda * di;
  const total_defl_in = di + additional_defl_in;
  if (![xi, lambda, additional_defl_in, total_defl_in].every(Number.isFinite)) return { error: "Long-term-deflection math is not a finite value." };
  return { xi, lambda, additional_defl_in, total_defl_in };
}

export const concreteLongtermDeflExample = { inputs: { immediate_defl_in: 0.4, duration_months: 60, comp_steel_ratio: 0 } };

CONCRETE_RENDERERS["concrete-longterm-defl"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 §24.2.4.1.1 additional time-dependent (creep and shrinkage) deflection: lambda = xi / (1 + 50 rho'), additional = lambda x immediate, total = immediate + additional. The time factor xi is 2.0 at 5 years or more, 1.4 at 12 months, 1.2 at 6 months, 1.0 at 3 months. The multiplier applies to the immediate deflection from the SUSTAINED portion of the load (dead plus the sustained fraction of live). Compression reinforcement rho' = As'/(b d) reduces creep, so a doubly-reinforced beam deflects far less over time. The total long-term deflection is what the L/240 and L/480 serviceability limits are checked against; the immediate deflection itself comes from an effective-moment-of-inertia (Ie) analysis. A design aid, not a substitute for the engineer of record's design.",
  example: concreteLongtermDeflExample.inputs,
  fields: [
    { key: "immediate_defl_in", label: "Immediate deflection from sustained load (in)", kind: "number" },
    { key: "duration_months", label: "Sustained-load duration (months, >=60 = 5 yr)", kind: "number" },
    { key: "comp_steel_ratio", label: "Compression-steel ratio rho' = As'/(b d) (0 if none)", kind: "number" },
  ],
  outputs: [
    { key: "xi", id: "cld-out-xi", label: "Time factor xi", value: (r) => fmt(r.xi, 2) },
    { key: "lm", id: "cld-out-lm", label: "Creep multiplier lambda", value: (r) => fmt(r.lambda, 3) },
    { key: "ad", id: "cld-out-ad", label: "Additional long-term deflection", value: (r) => fmt(r.additional_defl_in, 3) + " in" },
    { key: "tot", id: "cld-out-tot", label: "Total deflection (immediate + long-term)", value: (r) => fmt(r.total_defl_in, 3) + " in" },
  ],
  compute: computeConcreteLongtermDefl,
});

// ===================== spec-v1279: immediate elastic deflection from Ie (ACI 318-19 §24.2.3) =====================
// The effective-inertia (Ie) tile stops at Ie and its note says "the immediate
// deflection is then (a load-case coefficient) w L^4 / (Ec Ie)"; the long-term
// tile then TAKES that immediate deflection as a hand-entered input. Nothing
// computed the deflection itself. This fills the middle of the chain
// (cracking-moment -> effective-inertia -> immediate-deflection -> longterm-defl):
// the standard elastic beam deflection delta = K w L^4 / (Ec Ie), with K the
// support/loading coefficient and Ec = 57000 sqrt(f'c). Ie comes from the Ie tile.
const _DEFL_COEFF = {
  // kp, added 2026-10-09: the concentrated-load coefficient, delta = kp P L^3/(E I), midspan load (tip load for
  // the cantilever). Simple, fixed and cantilever maxima coincide with the uniform-load maximum; the propped
  // case adds the two maxima (0.4215 L and 0.447 L), slightly conservative.
  simple_udl:     { k: 5 / 384, kp: 1 / 48,  label: "Simply supported (5/384 uniform, 1/48 midspan point)" },
  fixed_udl:      { k: 1 / 384, kp: 1 / 192, label: "Fixed both ends (1/384 uniform, 1/192 midspan point)" },
  propped_udl:    { k: 1 / 185, kp: 1 / (48 * Math.sqrt(5)), label: "Propped cantilever (~1/185 uniform, 1/107 midspan point)" },
  cantilever_udl: { k: 1 / 8,   kp: 1 / 3,   label: "Cantilever (1/8 uniform, 1/3 tip point)" },
};
// dims: in { ie_in4: L^4, fc_psi: M L^-1 T^-2, w_klf: M T^-2, span_ft: L, support: dimensionless, point_load_kip: M L T^-2 } out: { ec_ksi: M L^-1 T^-2, immediate_defl_in: L, span_over_defl: dimensionless, coefficient: dimensionless, point_defl_in: L }
export function computeConcreteImmediateDeflection({ ie_in4 = 0, fc_psi = 4000, w_klf = 0, span_ft = 0, support = "simple_udl", point_load_kip = 0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const C = _DEFL_COEFF[support];
  if (!C) return { error: "Unknown support / loading case." };
  if (!(ie_in4 > 0)) return { error: "Effective inertia Ie must be positive (in^4)." };
  if (!(fc_psi > 0)) return { error: "Concrete strength f'c must be positive (psi)." };
  if (w_klf < 0 || point_load_kip < 0) return { error: "Service loads cannot be negative (kip/ft, kip)." };
  if (!(w_klf > 0) && !(point_load_kip > 0)) return { error: "Enter a service load: uniform w (kip/ft), a concentrated load P (kip), or both." };
  if (!(span_ft > 0)) return { error: "Span must be positive (ft)." };
  const ec_ksi = 57000 * Math.sqrt(fc_psi) / 1000;   // ACI 318-19 Eq 19.2.2.1.a, normalweight
  const w_kin = w_klf / 12;                            // kip/in
  const L_in = span_ft * 12;
  const point_defl_in = C.kp * point_load_kip * Math.pow(L_in, 3) / (ec_ksi * ie_in4);
  const immediate_defl_in = C.k * w_kin * Math.pow(L_in, 4) / (ec_ksi * ie_in4) + point_defl_in;
  const span_over_defl = L_in / immediate_defl_in;
  if (![ec_ksi, immediate_defl_in, span_over_defl].every(Number.isFinite)) return { error: "Immediate-deflection math is not a finite value." };
  return {
    ec_ksi, coefficient: C.k, immediate_defl_in, span_over_defl, point_defl_in,
    note: "ACI 318-19 §24.2.3 immediate (short-term) elastic deflection of a reinforced-concrete beam: delta = K w L^4 / (Ec Ie), the value the effective-inertia tile points to and the long-term tile takes as its input. K is the support/loading coefficient (5/384 simply supported under uniform load, 1/384 fixed both ends, 1/8 cantilever, ~1/185 propped cantilever), Ec = 57000 sqrt(f'c) is the normalweight modulus (§19.2.2.1), and Ie is the effective (Bischoff) moment of inertia from concrete-effective-inertia. Enter w as the service load per foot (kip/ft) for the load case whose deflection you want (dead alone, or dead plus the sustained fraction of live for the creep input). The span/deflection ratio L/delta is what the ACI Table 24.2.2 serviceability limits (L/180, L/240, L/360, L/480) are checked against. Feed this immediate deflection into concrete-longterm-defl for creep and shrinkage. A concentrated load P adds K_p P L^3/(Ec Ie) by superposition (1/48 simple midspan, 1/192 fixed, 1/(48 sqrt 5) propped, 1/3 cantilever tip); compute Ie at the moment from both loads. Uses the effective inertia at the section of maximum moment; a prismatic member is assumed. A design aid; the engineer of record's stamped design governs.",
  };
}
export const concreteImmediateDeflectionExample = { inputs: { ie_in4: 4662, fc_psi: 4000, w_klf: 0.8, span_ft: 24, support: "simple_udl" } };

CONCRETE_RENDERERS["concrete-immediate-deflection"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 §24.2.3 immediate deflection delta = K w L^4 / (Ec Ie), with Ec = 57000 sqrt(f'c) (§19.2.2.1) and Ie the effective (Bischoff) moment of inertia (§24.2.3.5). K is the elastic beam coefficient for the support/loading (5/384 simply supported UDL, 1/384 fixed-fixed UDL, 1/8 cantilever UDL, ~1/185 propped cantilever UDL). The span/deflection ratio is checked against the ACI Table 24.2.2 limits (L/180, L/240, L/360, L/480). Standard elastic beam theory with the ACI effective inertia. A design aid, not a substitute for a licensed engineer's design -- the engineer of record's stamped design governs.",
  example: concreteImmediateDeflectionExample.inputs,
  fields: [
    { key: "ie_in4", label: "Effective inertia Ie (in⁴, from the Ie tile)", kind: "number" },
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "w_klf", label: "Service load w (kip/ft)", kind: "number" },
    { key: "span_ft", label: "Span L (ft)", kind: "number" },
    { key: "point_load_kip", label: "Concentrated service load P (kip, midspan or cantilever tip; 0 if none)", kind: "number" },
    { key: "support", label: "Support and loading", kind: "select", options: Object.keys(_DEFL_COEFF).map((k) => ({ value: k, label: _DEFL_COEFF[k].label })), default: "simple_udl" },
  ],
  outputs: [
    { key: "d", id: "cid-out-d", label: "Immediate deflection", value: (r) => fmt(r.immediate_defl_in, 3) + " in" + (r.point_defl_in > 0 ? " (" + fmt(r.point_defl_in, 3) + " in of it from the concentrated load)" : "") },
    { key: "ratio", id: "cid-out-ratio", label: "Span / deflection", value: (r) => "L/" + fmt(r.span_over_defl, 0) },
    { key: "ec", id: "cid-out-ec", label: "Modulus Ec", value: (r) => fmt(r.ec_ksi, 0) + " ksi" },
    { key: "n", id: "cid-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteImmediateDeflection,
});

// ===================== spec-v1281: doubly-reinforced cracked moment of inertia Icr (ACI 318-19) =====================
// concrete-effective-inertia computes the cracked inertia Icr for a SINGLY-reinforced section and its own note
// says "a T-beam or doubly-reinforced section uses the appropriate transformed Icr." This adds the doubly-
// reinforced rectangular case: compression steel As' at depth d' raises the cracked neutral axis and stiffens
// the section. Cracked transformed section (concrete in compression only, tension concrete ignored):
//   locate the neutral axis c from  b c^2/2 + (n-1) As' (c - d') = n As (d - c)
//   Icr = b c^3/3 + (n-1) As' (c - d')^2 + n As (d - c)^2,  n = Es/Ec, Ec = 57000 sqrt(f'c).
// With As' = 0 it reduces EXACTLY to the singly-reinforced Icr the effective-inertia tile returns.
// dims: in { b_in: L, d_in: L, as_in2: L^2, fc_psi: M L^-1 T^-2, asp_in2: L^2, dp_in: L } out: { n: dimensionless, ec_psi: M L^-1 T^-2, kd_in: L, icr_in4: L^4 }
export function computeConcreteCrackedInertiaDoubly({ b_in = 0, d_in = 0, as_in2 = 0, fc_psi = 4000, asp_in2 = 0, dp_in = 2.5 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const b = Number(b_in), d = Number(d_in), As = Number(as_in2), fc = Number(fc_psi), Asp = Number(asp_in2), dp = Number(dp_in);
  if (!(b > 0)) return { error: "Section width b must be positive (in)." };
  if (!(d > 0)) return { error: "Effective depth d must be positive (in)." };
  if (!(As > 0)) return { error: "Tension steel area As must be positive (in^2)." };
  if (!(fc > 0)) return { error: "Concrete strength f'c must be positive (psi)." };
  if (Asp < 0) return { error: "Compression steel area As' cannot be negative (in^2)." };
  if (Asp > 0 && !(dp > 0)) return { error: "Compression steel depth d' must be positive when As' > 0 (in)." };
  if (Asp > 0 && !(dp < d)) return { error: "Compression steel depth d' must be less than the effective depth d (in)." };
  const Es = 29000000;
  const Ec = 57000 * Math.sqrt(fc);          // ACI 318-19 Eq 19.2.2.1.a, normalweight
  const n = Es / Ec;
  // b c^2/2 + (n-1) As' (c - d') - n As (d - c) = 0  ->  (b/2) c^2 + B c - C = 0
  const B = (n - 1) * Asp + n * As;
  const C = (n - 1) * Asp * dp + n * As * d;
  const kd = (-B + Math.sqrt(B * B + 2 * b * C)) / b;
  const icr = b * Math.pow(kd, 3) / 3 + (n - 1) * Asp * Math.pow(kd - dp, 2) + n * As * Math.pow(d - kd, 2);
  if (![n, Ec, kd, icr].every(Number.isFinite) || !(kd > 0) || !(kd < d)) return { error: "Cracked-section math is not a finite value; check the inputs." };
  return {
    n, ec_psi: Ec, kd_in: kd, icr_in4: icr, rho: As / (b * d), rho_prime: Asp / (b * d),
    note: "The cracked transformed moment of inertia Icr and neutral-axis depth kd for a DOUBLY-reinforced rectangular concrete section - the case the effective-inertia tile (singly-reinforced) names as separate. Below the cracking moment the section is uncracked; once it cracks the tension concrete is ignored and the section is a transformed area of the compression concrete (b above the neutral axis), the tension steel (n As at d), and the compression steel ((n-1) As' at d', the n-1 crediting the concrete it displaces). The neutral axis c solves b c^2/2 + (n-1) As' (c - d') = n As (d - c), and Icr = b c^3/3 + (n-1) As' (c - d')^2 + n As (d - c)^2, with n = Es/Ec and Ec = 57000 sqrt(f'c). Adding compression steel raises the neutral axis and stiffens the cracked section, so Icr grows and long-term deflection drops. With As' = 0 this returns exactly the singly-reinforced Icr the concrete-effective-inertia tile uses; feed this Icr into that tile (or a deflection check) for a doubly-reinforced beam. Rectangular section, elastic cracked analysis (no creep in Icr itself). A design aid; the engineer of record's stamped design governs.",
  };
}
export const concreteCrackedInertiaDoublyExample = { inputs: { b_in: 12, d_in: 17.5, as_in2: 3.0, fc_psi: 4000, asp_in2: 1.0, dp_in: 2.5 } };

CONCRETE_RENDERERS["concrete-cracked-inertia-doubly"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 cracked transformed section for a doubly-reinforced rectangular beam: neutral axis from b c^2/2 + (n-1) As'(c - d') = n As(d - c), Icr = b c^3/3 + (n-1) As'(c - d')^2 + n As(d - c)^2, with n = Es/Ec and Ec = 57000 sqrt(f'c) (§19.2.2.1). Standard elastic cracked-section mechanics (Wight & MacGregor; PCA Notes on ACI 318); As' = 0 reduces to the singly-reinforced Icr. A design aid, not a substitute for a licensed engineer's design -- the engineer of record's stamped design governs.",
  example: concreteCrackedInertiaDoublyExample.inputs,
  fields: [
    { key: "b_in", label: "Section width b (in)", kind: "number" },
    { key: "d_in", label: "Effective depth d to tension steel (in)", kind: "number" },
    { key: "as_in2", label: "Tension steel area As (in²)", kind: "number" },
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "asp_in2", label: "Compression steel area As' (in², 0 if none)", kind: "number" },
    { key: "dp_in", label: "Compression steel depth d' (in)", kind: "number" },
  ],
  outputs: [
    { key: "icr", id: "cid2-out-icr", label: "Cracked inertia Icr", value: (r) => fmt(r.icr_in4, 0) + " in^4" },
    { key: "kd", id: "cid2-out-kd", label: "Neutral-axis depth kd", value: (r) => fmt(r.kd_in, 2) + " in" },
    { key: "n", id: "cid2-out-n", label: "Modular ratio n", value: (r) => fmt(r.n, 2) + " (Ec " + fmt(r.ec_psi / 1000, 0) + " ksi)" },
    { key: "note", id: "cid2-out-note", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteCrackedInertiaDoubly,
});

// ===================== spec-v1283: flanged (T-beam) cracked moment of inertia Icr (ACI 318-19) =====================
// concrete-effective-inertia (singly rectangular) names "a T-beam ... uses the appropriate transformed Icr" and
// concrete-cracked-inertia-doubly names "a T-beam uses the flanged transformed section." This is that flanged case,
// completing the singly / doubly / flanged trio. The compression zone is the full flange width b down to hf, then
// only the web width bw below; tension steel is transformed with n As. The neutral axis lands in the flange or the
// web, decided automatically. With bw = b (or the neutral axis inside the flange) it reduces EXACTLY to the
// singly-reinforced rectangular Icr the effective-inertia tile returns. Pairs with t-beam-effective-flange-width,
// which supplies the effective flange width b.
// dims: in { b_in: L, hf_in: L, bw_in: L, d_in: L, as_in2: L^2, fc_psi: M L^-1 T^-2 } out: { n: dimensionless, ec_psi: M L^-1 T^-2, kd_in: L, icr_in4: L^4 }
export function computeConcreteCrackedInertiaTee({ b_in = 0, hf_in = 0, bw_in = 0, d_in = 0, as_in2 = 0, fc_psi = 4000 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const b = Number(b_in), hf = Number(hf_in), bw = Number(bw_in), d = Number(d_in), As = Number(as_in2), fc = Number(fc_psi);
  if (!(b > 0)) return { error: "Effective flange width b must be positive (in)." };
  if (!(hf > 0)) return { error: "Flange thickness hf must be positive (in)." };
  if (!(bw > 0)) return { error: "Web width bw must be positive (in)." };
  if (!(bw <= b)) return { error: "Web width bw cannot exceed the flange width b (in)." };
  if (!(d > hf)) return { error: "Effective depth d must be greater than the flange thickness hf (in)." };
  if (!(As > 0)) return { error: "Tension steel area As must be positive (in^2)." };
  if (!(fc > 0)) return { error: "Concrete strength f'c must be positive (psi)." };
  const Es = 29000000;
  const Ec = 57000 * Math.sqrt(fc);          // ACI 318-19 Eq 19.2.2.1.a, normalweight
  const n = Es / Ec;
  // Trial 1: neutral axis inside the flange, rectangle of width b: b c^2/2 + n As c - n As d = 0.
  let kd = (-(n * As) + Math.sqrt(n * As * (n * As) + 2 * b * n * As * d)) / b;
  let neutral_axis_in = "flange";
  let icr;
  if (kd <= hf) {
    icr = b * Math.pow(kd, 3) / 3 + n * As * Math.pow(d - kd, 2);
  } else {
    // Neutral axis in the web: bw c^2/2 + (b - bw) hf (c - hf/2) = n As (d - c).
    // (bw/2) c^2 + [(b-bw) hf + n As] c - [(b-bw) hf^2/2 + n As d] = 0
    const A = bw / 2;
    const B = (b - bw) * hf + n * As;
    const C = (b - bw) * hf * hf / 2 + n * As * d;
    kd = (-B + Math.sqrt(B * B + 4 * A * C)) / (2 * A);
    neutral_axis_in = "web";
    icr = bw * Math.pow(kd, 3) / 3 + (b - bw) * (Math.pow(hf, 3) / 12 + hf * Math.pow(kd - hf / 2, 2)) + n * As * Math.pow(d - kd, 2);
  }
  if (![n, Ec, kd, icr].every(Number.isFinite) || !(kd > 0) || !(kd < d)) return { error: "Cracked-section math is not a finite value; check the inputs." };
  return {
    n, ec_psi: Ec, kd_in: kd, icr_in4: icr, neutral_axis_in, rho_w: As / (bw * d),
    note: "The cracked transformed moment of inertia Icr and neutral-axis depth kd for a FLANGED (T-beam) concrete section with tension steel only - the case both concrete-effective-inertia (singly rectangular) and concrete-cracked-inertia-doubly name as separate. Once the section cracks the tension concrete is ignored: the compression zone is the full flange width b down to the flange thickness hf, then only the web width bw below, and the tension steel is transformed with n As at depth d. If the neutral axis lands within the flange (c <= hf) the section behaves as a rectangle of width b, b c^2/2 = n As(d - c) and Icr = b c^3/3 + n As(d - c)^2; if it falls in the web, bw c^2/2 + (b - bw) hf (c - hf/2) = n As(d - c) and Icr = bw c^3/3 + (b - bw)[hf^3/12 + hf(c - hf/2)^2] + n As(d - c)^2, with n = Es/Ec and Ec = 57000 sqrt(f'c). The wide compression flange raises the neutral axis and stiffens the cracked section, so a slab acting with the beam sharply cuts deflection. With bw = b (or the neutral axis inside the flange) it returns exactly the singly-reinforced rectangular Icr the concrete-effective-inertia tile uses; take the effective flange width b from t-beam-effective-flange-width, and feed this Icr into a deflection check. A design aid; the engineer of record's stamped design governs.",
  };
}
export const concreteCrackedInertiaTeeExample = { inputs: { b_in: 48, hf_in: 4, bw_in: 12, d_in: 17.5, as_in2: 6.0, fc_psi: 4000 } };

CONCRETE_RENDERERS["concrete-cracked-inertia-tee"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 cracked transformed section for a flanged (T-beam) beam with tension steel: neutral axis in the flange (b c^2/2 = n As(d - c), Icr = b c^3/3 + n As(d - c)^2) or in the web (bw c^2/2 + (b - bw) hf(c - hf/2) = n As(d - c), Icr = bw c^3/3 + (b - bw)[hf^3/12 + hf(c - hf/2)^2] + n As(d - c)^2), with n = Es/Ec and Ec = 57000 sqrt(f'c) (§19.2.2.1). Standard elastic cracked flanged-section mechanics (Wight & MacGregor; PCA Notes on ACI 318); bw = b reduces to the singly-reinforced rectangular Icr. A design aid, not a substitute for a licensed engineer's design -- the engineer of record's stamped design governs.",
  example: concreteCrackedInertiaTeeExample.inputs,
  fields: [
    { key: "b_in", label: "Effective flange width b (in)", kind: "number" },
    { key: "hf_in", label: "Flange thickness hf (in)", kind: "number" },
    { key: "bw_in", label: "Web width bw (in)", kind: "number" },
    { key: "d_in", label: "Effective depth d to tension steel (in)", kind: "number" },
    { key: "as_in2", label: "Tension steel area As (in²)", kind: "number" },
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
  ],
  outputs: [
    { key: "icr", id: "cit-out-icr", label: "Cracked inertia Icr", value: (r) => fmt(r.icr_in4, 0) + " in^4" },
    { key: "kd", id: "cit-out-kd", label: "Neutral-axis depth kd", value: (r) => fmt(r.kd_in, 2) + " in (neutral axis in the " + r.neutral_axis_in + ")" },
    { key: "n", id: "cit-out-n", label: "Modular ratio n", value: (r) => fmt(r.n, 2) + " (Ec " + fmt(r.ec_psi / 1000, 0) + " ksi)" },
    { key: "note", id: "cit-out-note", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteCrackedInertiaTee,
});

// ===================== spec-v548: cast-in anchor tension concrete breakout (ACI 318-19 Ch. 17) =====================

// Anchor groups added 2026-10-09 (the pryout note said the group form was not modeled): ACI 318-19 17.6.2.1, a
// concentrically loaded rectangular group of n1 rows (spacing s1, toward the edge) by n2 anchors (spacing s2, along
// it), ANc = [min(ca1, 1.5 hef) + (n1 - 1) min(s1, 3 hef) + 1.5 hef] x [3 hef + (n2 - 1) min(s2, 3 hef)] <= n ANco.
// dims: in { embedment_in: L, fc_psi: M L^-1 T^-2, edge_distance_in: L, anchor_type: dimensionless, lambda: dimensionless, cracking: dimensionless, rows_toward_edge: dimensionless, spacing_toward_edge_in: L, anchors_along_edge: dimensionless, spacing_along_edge_in: L } out: { nb_lb: M L T^-2, ncb_lb: M L T^-2, phi_ncb_lb: M L T^-2, phi_tension: dimensionless }
export function computeConcreteAnchorBreakout({ embedment_in = 0, fc_psi = 0, edge_distance_in = 0, anchor_type = "cast-in", lambda = 1.0, cracking = "cracked", rows_toward_edge = 1, spacing_toward_edge_in = 0, anchors_along_edge = 1, spacing_along_edge_in = 0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const hef = Number(embedment_in) || 0;
  const fc = Number(fc_psi) || 0;
  const ca1 = Number(edge_distance_in) || 0;
  const lam = Number(lambda) || 0;
  if (!(hef > 0)) return { error: "Effective embedment must be positive (in)." };
  if (!(fc > 0)) return { error: "Concrete strength f'c must be positive (psi)." };
  if (ca1 < 0) return { error: "Edge distance cannot be negative (in)." };
  if (!(lam > 0)) return { error: "Lightweight factor lambda must be positive (1.0 normalweight)." };
  if (lam > 1) return { error: "Lightweight factor lambda cannot exceed 1.0 (ACI 318-19 19.2.4)." };
  // ACI 318-19 Table 17.5.3, tension concrete breakout, Condition B: phi 0.70 cast-in; post-installed
  // by its ACI 355.2 / 355.4 category, 0.65 / 0.55 / 0.45 for Category 1 / 2 / 3.
  const _anchor = { "cast-in": [24, 0.70], "post-installed": [17, 0.65], "post-installed-cat2": [17, 0.55], "post-installed-cat3": [17, 0.45] }[anchor_type];
  if (!_anchor) return { error: "Anchor type must be cast-in or post-installed (Category 1, 2 or 3)." };
  if (cracking !== "cracked" && cracking !== "uncracked") return { error: "Cracking must be cracked or uncracked." };
  const n1 = Number(rows_toward_edge) || 1, n2 = Number(anchors_along_edge) || 1;
  const s1 = Number(spacing_toward_edge_in) || 0, s2 = Number(spacing_along_edge_in) || 0;
  if (!(Number.isInteger(n1) && n1 >= 1 && Number.isInteger(n2) && n2 >= 1)) return { error: "Anchor counts must be whole numbers of 1 or more." };
  if ((n1 > 1 && !(s1 > 0)) || (n2 > 1 && !(s2 > 0))) return { error: "Enter the spacing (in) for each direction that has more than one anchor." };
  const [kc, phi_tension] = _anchor;
  // ACI 318-19 17.3.1 caps f'c in the anchor equations at 10,000 psi cast-in and 8,000 psi
  // post-installed. Added 2026-10-07, after the shear-breakout and blowout tiles (2026-10-03):
  // until then a 12,000 psi mix read 9.5% stronger here, and pryout inherits this Nb.
  const nb_lb = kc * lam * Math.sqrt(Math.min(fc, anchor_type === "cast-in" ? 10000 : 8000)) * Math.pow(hef, 1.5);
  const ANco = 9 * hef * hef;
  const psi_ed = ca1 < 1.5 * hef ? 0.7 + 0.3 * ca1 / (1.5 * hef) : 1.0;
  const n_anchors = n1 * n2;
  const len1 = Math.min(ca1, 1.5 * hef) + (n1 - 1) * Math.min(s1, 3 * hef) + 1.5 * hef;
  const len2 = 3 * hef + (n2 - 1) * Math.min(s2, 3 * hef);
  const ANc = len1 * len2;
  const area_ratio = Math.min(ANc / ANco, n_anchors);
  // ACI 318-19 17.6.2.5.1, added 2026-10-09: psi_c,N = 1.25 cast-in and 1.4 post-installed (kc = 17)
  // where analysis shows no cracking at service loads, 1.0 cracked. An uncracked post-installed anchor
  // without splitting reinforcement also takes psi_cp,N (17.6.2.6.1) with the 17.9.5 default critical
  // edge distance cac = 4 hef (torque- or displacement-controlled expansion; undercut is 2.5 hef).
  const uncracked = cracking === "uncracked";
  const psi_c = uncracked ? (anchor_type === "cast-in" ? 1.25 : 1.4) : 1.0;
  const cac = 4 * hef;
  const psi_cp = uncracked && anchor_type !== "cast-in" && ca1 < cac ? Math.max(ca1 / cac, 1.5 * hef / cac) : 1.0;
  const ncb_lb = area_ratio * psi_ed * psi_c * psi_cp * nb_lb;
  const phi_ncb_lb = phi_tension * ncb_lb;
  return {
    nb_lb, ANco, psi_ed, ANc, area_ratio, psi_c, psi_cp, ncb_lb, phi_ncb_lb, kc, phi_tension,
    n_anchors,
    note: "The basic strength scales with the embedment to the 1.5 power (a deeper anchor gains fast); a near-edge anchor loses capacity to the edge factor psi_ed and a truncated projected area (a full cone needs 1.5 hef of edge on all sides). A group of anchors closer than 3 hef shares one breakout cone: enter the rows toward the edge and the anchors per row with their spacings, and the projected area becomes ANc = [min(ca1, 1.5 hef) + (n1 - 1) min(s1, 3 hef) + 1.5 hef] x [3 hef + (n2 - 1) min(s2, 3 hef)] for the whole group (17.6.2.1, concentric load, psi_ec = 1), so four anchors at 6 in on a 6 in embedment carry 1.78 single-anchor breakouts, not 4. Cast-in (kc = 24) and post-installed (kc = 17) anchors differ. Concrete shown by analysis to stay uncracked at service loads takes psi_c,N = 1.25 cast-in or 1.4 post-installed (17.6.2.5.1); an uncracked post-installed anchor without splitting reinforcement closer to an edge than cac also takes psi_cp,N = max(ca,min, 1.5 hef)/cac (17.6.2.6.1), with the 17.9.5 default cac = 4 hef for expansion anchors (an undercut anchor's 2.5 hef or the product report's value would be less conservative). phi is Condition B (no supplementary reinforcement): 0.70 cast-in, and 0.65 / 0.55 / 0.45 for a post-installed anchor qualified in Category 1 / 2 / 3. ACI 318-19 Chapter 17 and the engineer of record govern.",
  };
}

export const concreteAnchorBreakoutExample = { inputs: { embedment_in: 6, fc_psi: 4000, edge_distance_in: 100, anchor_type: "cast-in", lambda: 1.0 } };

// ===================== spec-v552: slender column moment magnification, nonsway (ACI 318-19 6.6.4.5) =====================

// dims: in { factored_axial_kip: M L T^-2, end_moment_m2_kft: M L^2 T^-2, end_moment_m1_kft: M L^2 T^-2, unbraced_len_ft: L, eff_length_k: dimensionless, eff_stiffness_ei: M L^3 T^-2, column_dim_h_in: L } out: { cm: dimensionless, pc_kip: M L T^-2, delta_ns: dimensionless, mc_kft: M L^2 T^-2 }
export function computeRcSlenderColumnMagnify({ factored_axial_kip = 0, end_moment_m2_kft = 0, end_moment_m1_kft = 0, unbraced_len_ft = 0, eff_length_k = 1.0, eff_stiffness_ei = 0, column_dim_h_in = 0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const Pu = Number(factored_axial_kip) || 0;
  const M2 = Number(end_moment_m2_kft) || 0;
  const M1 = Number(end_moment_m1_kft) || 0;
  const lu = Number(unbraced_len_ft) || 0;
  const k = Number(eff_length_k) || 0;
  const EI = Number(eff_stiffness_ei) || 0;
  const h = Number(column_dim_h_in) || 0;
  if (!(Pu > 0)) return { error: "Factored axial load must be positive (kip)." };
  if (!(M2 > 0)) return { error: "Larger end moment M2 must be positive (kip-ft)." };
  if (!(lu > 0)) return { error: "Unbraced length must be positive (ft)." };
  if (!(k > 0)) return { error: "Effective-length factor k must be positive." };
  if (!(EI > 0)) return { error: "Effective stiffness EI must be positive (kip-in^2)." };
  if (!(h > 0)) return { error: "Enter the column dimension h in the direction of bending (in); the minimum moment M2,min = Pu (0.6 + 0.03 h) needs it." };
  if (Math.abs(M1) > M2 * (1 + 1e-9)) return { error: "M1 is the SMALLER end moment in magnitude; it cannot exceed M2. Swap them." };
  // ACI 318-19 Eq. 6.6.4.5.3a: Cm = 0.6 - 0.4 M1/M2, with M1/M2 NEGATIVE for single curvature and no
  // lower bound. Until 2026-09-25 this was the ACI 318-05 form (0.6 + 0.4 M1/M2 >= 0.4, positive for single
  // curvature) under a 318-19 citation, so a single-curvature M1 entered the 318-19 way halved Cm.
  const cm = 0.6 - 0.4 * (M1 / M2);
  const lu_in = lu * 12;
  const pc_kip = Math.PI * Math.PI * EI / Math.pow(k * lu_in, 2);
  if (Pu >= 0.75 * pc_kip) return { error: "Axial load is at or above 0.75 x Pc - the column has buckled; increase the section or reduce the length." };
  const delta_ns = Math.max(cm / (1 - Pu / (0.75 * pc_kip)), 1.0);
  const m2_min_kft = Pu * (0.6 + 0.03 * h) / 12;
  // 6.6.4.5.4: M2 in Mc = delta M2 shall be at least M2,min -- the floor goes on
  // M2 BEFORE it is magnified. Until 2026-10-10 this was max(delta M2, M2,min),
  // which leaves a small end moment under a large magnifier unamplified (44% low
  // at Pu 200, M2 10, delta 2.03).
  const m2_used_kft = Math.max(M2, m2_min_kft);
  const mc_kft = delta_ns * m2_used_kft;
  return {
    cm, pc_kip, delta_ns, m2_min_kft, m2_used_kft, mc_kft,
    note: "The critical buckling load Pc carries a 0.75 stiffness reduction in the denominator; the design moment is floored at M2,min = Pu(0.6 + 0.03h). A column just over the slenderness limit k lu/r <= 34 + 12(M1/M2) (ACI 318-19 Eq. 6.2.5.1b) picks up a magnifier the flexure check never applies. In ACI 318-19, M1/M2 is NEGATIVE for single curvature (Cm up to 1.0) and positive for double curvature (which lowers Cm, to 0.2 at M1 = M2) -- the reverse of the pre-2014 sign convention. ACI 318 and the engineer of record govern.",
  };
}

export const rcSlenderColumnMagnifyExample = { inputs: { factored_axial_kip: 200, end_moment_m2_kft: 80, end_moment_m1_kft: -50, unbraced_len_ft: 14, eff_length_k: 1.0, eff_stiffness_ei: 1500000, column_dim_h_in: 16 } };

CONCRETE_RENDERERS["rc-slender-column-magnify"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 Section 6.6.4.5 nonsway (braced) moment magnifier: Cm = 0.6 - 0.4 M1/M2 (M1/M2 negative for single curvature, per 318-19); Pc = pi^2 EI / (k lu)^2; delta_ns = max(Cm / (1 - Pu/(0.75 Pc)), 1.0); Mc = delta_ns x max(M2, M2,min) (6.6.4.5.4: the floor applies to M2 before it is magnified), M2,min = Pu(0.6 + 0.03h). The 0.75 stiffness reduction sits in the denominator; the moment is floored at M2,min. A column just over the slenderness limit picks up an amplifier the flexure check never applies. ACI 318 and the engineer of record govern.",
  example: rcSlenderColumnMagnifyExample.inputs,
  fields: [
    { key: "factored_axial_kip", label: "Factored axial load Pu (kip)", kind: "number" },
    { key: "end_moment_m2_kft", label: "Larger end moment M2 (kip-ft)", kind: "number" },
    { key: "end_moment_m1_kft", label: "Smaller end moment M1 (kip-ft; negative for single curvature, ACI 318-19)", kind: "number", attrs: { step: "any" } },
    { key: "unbraced_len_ft", label: "Unbraced length lu (ft)", kind: "number" },
    { key: "eff_length_k", label: "Effective-length factor k", kind: "number" },
    { key: "eff_stiffness_ei", label: "Effective stiffness EI (kip-in²)", kind: "number" },
    { key: "column_dim_h_in", label: "Column dimension h (in)", kind: "number" },
  ],
  outputs: [
    { key: "cm", id: "scm-out-cm", label: "Cm", value: (r) => fmt(r.cm, 3) },
    { key: "pc", id: "scm-out-pc", label: "Critical buckling load Pc", value: (r) => fmt(r.pc_kip, 1) + " kip" },
    { key: "dns", id: "scm-out-dns", label: "Moment magnifier delta_ns", value: (r) => fmt(r.delta_ns, 2) },
    { key: "mc", id: "scm-out-mc", label: "Magnified design moment Mc", value: (r) => fmt(r.mc_kft, 1) + " kip-ft (M2,min " + fmt(r.m2_min_kft, 1) + ")" },
  ],
  compute: computeRcSlenderColumnMagnify,
});

// ===================== spec-v556: concrete corbel / bracket design (ACI 318-19 16.5) =====================

// dims: in { factored_shear_lb: M L T^-2, horiz_tension_lb: M L T^-2, shear_span_av_in: L, eff_depth_d_in: L, height_h_in: L, width_b_in: L, fc_psi: M L^-1 T^-2, fy_psi: M L^-1 T^-2, friction_mu: dimensionless } out: { nuc_lb: M L T^-2, asc_in2: L^2, phi_vn_lb: M L T^-2 }
export function computeConcreteCorbelBracket({ factored_shear_lb = 0, horiz_tension_lb = 0, shear_span_av_in = 0, eff_depth_d_in = 0, height_h_in = 0, width_b_in = 0, fc_psi = 4000, fy_psi = 60000, friction_mu = 1.4 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const Vu = Number(factored_shear_lb) || 0;
  const Nuc_in = Number(horiz_tension_lb) || 0;
  const av = Number(shear_span_av_in) || 0;
  const d = Number(eff_depth_d_in) || 0;
  const h = Number(height_h_in) || 0;
  const b = Number(width_b_in) || 0;
  const fc = Number(fc_psi) || 0;
  const fy = Number(fy_psi) || 0;
  const mu = Number(friction_mu) || 0;
  if (!(Vu > 0)) return { error: "Factored shear Vu must be positive (lb)." };
  if (!(d > 0)) return { error: "Effective depth d must be positive (in)." };
  if (!(b > 0)) return { error: "Width b must be positive (in)." };
  if (!(h > 0)) return { error: "Height h must be positive (in)." };
  if (h < d) return { error: "The overall height h at the support face cannot be less than the effective depth d." };
  if (!(fc > 0)) return { error: "Concrete strength f'c must be positive (psi)." };
  if (!(fy > 0)) return { error: "Yield strength fy must be positive (psi)." };
  if (!(mu > 0)) return { error: "Shear-friction coefficient must be positive." };
  if (av < 0) return { error: "Shear span cannot be negative (in)." };
  if (av > d) return { error: "Shear span av exceeds d (av/d > 1) - outside the ACI 16.5 corbel range; design as a cantilever beam." };
  // ACI 318-19 16.5.1.1(b): the corbel provisions apply only where Nuc <= Vu.
  if (Nuc_in > Vu + 1e-9 * Vu) return { error: "Horizontal tension Nuc exceeds Vu - outside the ACI 16.5.1.1 corbel range." };
  const nuc_lb = Math.max(Nuc_in, 0.2 * Vu);
  // Table 20.2.2.4(a) caps fy at 60,000 psi for shear friction. Until 2026-10-03 a higher
  // grade cut Avf in proportion (fy 100,000 took 40% off the governing steel).
  const avf_in2 = Vu / (0.75 * mu * Math.min(fy, 60000));
  const mu_lbin = Vu * av + nuc_lb * (h - d);
  const af_in2 = mu_lbin / (0.75 * fy * 0.85 * d);
  const an_in2 = nuc_lb / (0.75 * fy);
  const flex_path = af_in2 + an_in2;
  const sf_path = (2 / 3) * avf_in2 + an_in2;
  // ACI 318-19 16.5.5.1 also imposes a FLOOR on the primary steel:
  // Asc,min = 0.04 (f'c/fy) b d. Without it a lightly loaded corbel reports
  // less steel than the code permits.
  const asc_min_in2 = 0.04 * (fc / fy) * b * d;
  const asc_in2 = Math.max(flex_path, sf_path, asc_min_in2);
  const governing_path = asc_min_in2 >= Math.max(flex_path, sf_path)
    ? "the 0.04 (f'c/fy) b d minimum"
    : (flex_path >= sf_path ? "flexure + tension" : "shear-friction + tension");
  // ACI 318-19 16.5.5.2 closed-stirrup (horizontal) reinforcement, distributed
  // within 2d/3 adjacent to Asc. A corbel is not detailed without it.
  const ah_in2 = 0.5 * (asc_in2 - an_in2);
  const ah_zone_in = (2 / 3) * d;
  const phi_vn_lb = 0.75 * Math.min(0.2 * fc, 480 + 0.08 * fc, 1600) * b * d;
  return {
    nuc_lb, avf_in2, af_in2, an_in2, flex_path, sf_path, asc_min_in2, asc_in2, governing_path,
    ah_in2, ah_zone_in, phi_vn_lb, shear_ok: Vu <= phi_vn_lb,
    note: "The horizontal tension Nuc of at least 0.2 Vu is mandatory (restrained shrinkage and creep drag on the bearing) and drives the top steel. The primary steel is the greatest of the flexure-plus-tension path, the shear-friction-plus-tension path (which governs flips with the shear span), and the 16.5.5.1 floor Asc,min = 0.04 (f'c/fy) b d. Closed stirrups Ah = 0.5 (Asc - An) per 16.5.5.2 must be distributed within 2d/3 below the primary steel - a corbel is not detailed without them. The shear is capped by the min-of-three limit, not the sqrt(f'c) shear, so a deep short corbel is cap-governed. ACI 318 and the engineer of record govern.",
  };
}

export const concreteCorbelBracketExample = { inputs: { factored_shear_lb: 40000, horiz_tension_lb: 0, shear_span_av_in: 4, eff_depth_d_in: 12, height_h_in: 14, width_b_in: 14, fc_psi: 4000, fy_psi: 60000, friction_mu: 1.4 } };

CONCRETE_RENDERERS["concrete-corbel-bracket"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 Section 16.5 brackets and corbels: Nuc = max(input, 0.2 Vu); Avf = Vu/(phi mu fy); Mu = Vu av + Nuc(h - d); Af = Mu/(phi fy 0.85 d); An = Nuc/(phi fy); Asc = max(Af + An, (2/3)Avf + An, 0.04 (f'c/fy) b d per 16.5.5.1); Ah = 0.5 (Asc - An) closed stirrups within 2d/3 per 16.5.5.2; phiVn = phi min(0.2 f'c, 480 + 0.08 f'c, 1600) b d (phi = 0.75). The 0.2 Vu horizontal tension is mandatory and drives the top steel; the primary steel is the greatest of the two paths and the 0.04 (f'c/fy) b d minimum; the closed stirrups Ah are required within 2d/3; the shear is capped by the min-of-three limit. ACI 318 and the engineer of record govern.",
  example: concreteCorbelBracketExample.inputs,
  fields: [
    { key: "factored_shear_lb", label: "Factored shear Vu (lb)", kind: "number" },
    { key: "horiz_tension_lb", label: "Horizontal tension Nuc (lb, clamped to 0.2 Vu)", kind: "number" },
    { key: "shear_span_av_in", label: "Shear span av (in, av/d <= 1)", kind: "number" },
    { key: "eff_depth_d_in", label: "Effective depth d (in)", kind: "number" },
    { key: "height_h_in", label: "Total height h (in)", kind: "number" },
    { key: "width_b_in", label: "Width b (in)", kind: "number" },
    { key: "fc_psi", label: "Concrete f'c (psi)", kind: "number" },
    { key: "fy_psi", label: "Steel fy (psi)", kind: "number" },
    { key: "friction_mu", label: "Shear-friction mu", kind: "number" },
  ],
  outputs: [
    { key: "n", id: "ccb-out-n", label: "Mandatory tension Nuc", value: (r) => fmt(r.nuc_lb, 0) + " lb" },
    { key: "asc", id: "ccb-out-asc", label: "Primary steel Asc (governing)", value: (r) => fmt(r.asc_in2, 3) + " in^2 (" + r.governing_path + ")" },
    { key: "paths", id: "ccb-out-paths", label: "Flexure vs shear-friction path", value: (r) => fmt(r.flex_path, 3) + " / " + fmt(r.sf_path, 3) + " in^2" },
    { key: "ascmin", id: "ccb-out-ascmin", label: "Code minimum 0.04 (f'c/fy) b d", value: (r) => fmt(r.asc_min_in2, 3) + " in^2" },
    { key: "ah", id: "ccb-out-ah", label: "Closed stirrups Ah (within 2d/3)", value: (r) => fmt(r.ah_in2, 3) + " in^2 spread over the top " + fmt(r.ah_zone_in, 1) + " in" },
    { key: "v", id: "ccb-out-v", label: "Shear cap phiVn", value: (r) => fmt(r.phi_vn_lb / 1000, 1) + " kip - " + (r.shear_ok ? "OK" : "OVER, deepen the corbel") },
  ],
  compute: computeConcreteCorbelBracket,
});

CONCRETE_RENDERERS["concrete-anchor-breakout"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 Section 17.6.2 concrete breakout in tension (CCD method): Nb = kc lambda sqrt(f'c) hef^1.5 (kc = 24 cast-in, 17 post-installed), ANco = 9 hef^2, edge factor psi_ed = 0.7 + 0.3 ca1/(1.5 hef) when ca1 < 1.5 hef, Ncb = (ANc/ANco) psi_ed Nb, phiNcb = phi Ncb, phi 0.70 cast-in and 0.65 / 0.55 / 0.45 post-installed Category 1 / 2 / 3 (Condition B, no supplementary reinforcement). The basic strength scales with embedment^1.5; a near-edge anchor loses capacity to the edge factor and a truncated projected area. Cracking factor psi_c,N = 1.0 cracked, 1.25 cast-in / 1.4 post-installed uncracked (17.6.2.5.1); uncracked post-installed splitting factor psi_cp,N = max(ca,min, 1.5 hef)/cac with cac = 4 hef (17.6.2.6.1, 17.9.5). ACI 318 Chapter 17 and the engineer of record govern.",
  example: concreteAnchorBreakoutExample.inputs,
  fields: [
    { key: "embedment_in", label: "Effective embedment hef (in)", kind: "number" },
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "edge_distance_in", label: "Nearest edge distance ca1 (in, large = away)", kind: "number" },
    { key: "anchor_type", label: "Anchor type", kind: "select", options: [{ value: "cast-in", label: "Cast-in (kc = 24)" }, { value: "post-installed", label: "Post-installed, Category 1 (kc = 17)" }, { value: "post-installed-cat2", label: "Post-installed, Category 2 (kc = 17)" }, { value: "post-installed-cat3", label: "Post-installed, Category 3 (kc = 17)" }] },
    { key: "lambda", label: "Lightweight factor lambda", kind: "number" },
    { key: "cracking", label: "Concrete at service loads", kind: "select", options: [{ value: "cracked", label: "Cracked (psi_c,N 1.0)" }, { value: "uncracked", label: "Uncracked by analysis (psi_c,N 1.25 cast-in, 1.4 post-installed)" }] },
    { key: "rows_toward_edge", label: "Group: anchor rows toward the edge (1 for a single anchor)", kind: "number", default: 1, attrs: { step: "1", min: "1", value: "1" } },
    { key: "spacing_toward_edge_in", label: "Group: spacing between those rows (in)", kind: "number" },
    { key: "anchors_along_edge", label: "Group: anchors per row, along the edge", kind: "number", default: 1, attrs: { step: "1", min: "1", value: "1" } },
    { key: "spacing_along_edge_in", label: "Group: spacing along the edge (in)", kind: "number" },
  ],
  outputs: [
    { key: "nb", id: "cab-out-nb", label: "Basic breakout Nb", value: (r) => fmt(r.nb_lb, 0) + " lb" },
    { key: "ncb", id: "cab-out-ncb", label: "Nominal breakout Ncb (edge-modified)", value: (r) => fmt(r.ncb_lb, 0) + " lb (psi_ed " + fmt(r.psi_ed, 2) + ", area " + fmt(r.area_ratio, 3) + (r.psi_c !== 1 ? ", psi_c,N " + fmt(r.psi_c, 2) : "") + (r.psi_cp !== 1 ? ", psi_cp,N " + fmt(r.psi_cp, 3) : "") + ")" },
    { key: "phi", id: "cab-out-phi", label: "Design capacity phiNcb", value: (r) => fmt(r.phi_ncb_lb, 0) + " lb" + (r.n_anchors > 1 ? " for the group of " + r.n_anchors + " (ANc/ANco " + fmt(r.area_ratio, 2) + ", not " + r.n_anchors + ")" : "") },
    { key: "n", id: "cab-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteAnchorBreakout,
});

// --- spec-v612 E: Concrete headed-anchor pullout (ACI 318-19 17.6.3) ---
// Np = 8 * Abrg * fc. Npn = psi_cP * Np (1.4 uncracked, 1.0 cracked). phiNpn = 0.70 * Npn.
// dims: in { head_bearing_area_in2: L^2, fc_psi: M L^-1 T^-2, cracking: dimensionless } out: { np_lb: M L T^-2, npn_lb: M L T^-2, phi_npn_lb: M L T^-2 }
export function computeConcreteAnchorPullout({ head_bearing_area_in2 = 0, fc_psi = 0, cracking = "cracked" } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const abrg = Number(head_bearing_area_in2) || 0;
  const fc = Number(fc_psi) || 0;
  if (!(abrg > 0)) return { error: "Head bearing area must be positive (in^2)." };
  if (!(fc > 0)) return { error: "Concrete strength must be positive (psi)." };
  const uncracked = cracking === "uncracked";
  if (cracking !== "cracked" && cracking !== "uncracked") return { error: "Cracking must be cracked or uncracked." };
  const psi_cP = uncracked ? 1.4 : 1.0;
  // ACI 318-19 17.3.1 caps f'c at 10,000 psi for a cast-in (headed) anchor. Until 2026-10-07 a
  // 12,000 psi mix read 20% more pullout.
  const np_lb = 8 * abrg * Math.min(fc, 10000);
  const npn_lb = psi_cP * np_lb;
  const phi_npn_lb = 0.70 * npn_lb;
  return {
    np_lb, npn_lb, phi_npn_lb, psi_cP,
    note: "Pullout does not depend on embedment - deepening the anchor does not raise it (that is the breakout mode). It applies to headed anchors where the head bears on the concrete, not to adhesive or expansion anchors (which use a tested bond or slip value). Abrg is the net bearing area of the head or nut. The 1.4 uncracked factor applies only when analysis shows the concrete stays uncracked at service load; use 1.0 otherwise. phi = 0.70 is Condition B (no supplementary reinforcement). ACI 318 Chapter 17 and the engineer of record govern - a design check, not a stamped anchor design.",
  };
}
export const concreteAnchorPulloutExample = { inputs: { head_bearing_area_in2: 0.654, fc_psi: 4000, cracking: "cracked" } };
CONCRETE_RENDERERS["concrete-anchor-pullout"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 Section 17.6.3 headed-anchor pullout: Np = 8 x Abrg x f'c; Npn = psi_cP x Np (psi_cP = 1.4 uncracked at service, 1.0 cracked); phiNpn = 0.70 x Npn (Condition B, no supplementary reinforcement). Pullout does not depend on embedment (that is the breakout mode); it applies to headed anchors where the head bears on the concrete, not adhesive or expansion anchors. Abrg is the net bearing area of the head or nut. ACI 318 Chapter 17 and the engineer of record govern.",
  example: concreteAnchorPulloutExample.inputs,
  fields: [
    { key: "head_bearing_area_in2", label: "Head/nut net bearing area Abrg (in²)", kind: "number" },
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "cracking", label: "Concrete condition at service", kind: "select", options: [{ value: "cracked", label: "Cracked (psi_cP = 1.0)", selected: true }, { value: "uncracked", label: "Uncracked (psi_cP = 1.4)" }] },
  ],
  outputs: [
    { key: "np", id: "cap-out-np", label: "Basic pullout Np", value: (r) => fmt(r.np_lb, 0) + " lb (" + fmt(r.np_lb / 1000, 1) + " kip)" },
    { key: "npn", id: "cap-out-npn", label: "Nominal pullout Npn", value: (r) => fmt(r.npn_lb, 0) + " lb (psi_cP " + fmt(r.psi_cP, 1) + ")" },
    { key: "phi", id: "cap-out-phi", label: "Design pullout phiNpn", value: (r) => fmt(r.phi_npn_lb, 0) + " lb (" + fmt(r.phi_npn_lb / 1000, 1) + " kip)" },
    { key: "n", id: "cap-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteAnchorPullout,
});

// --- spec-v617 E: Concrete anchor side-face blowout (ACI 318-19 17.6.4) ---
// Nsb = 160 * ca1 * sqrt(Abrg) * lambda * sqrt(f'c); corner (1 + ca2/ca1)/4 when ca2 < 3 ca1; phi = 0.70. Governs when hef > 2.5 ca1.
// dims: in { edge_distance_in: L, head_bearing_area_in2: L^2, fc_psi: M L^-1 T^-2, embedment_in: L, perp_edge_in: L, lambda: dimensionless } out: { nsb_lb: M L T^-2, corner_factor: dimensionless, nsbn_lb: M L T^-2, phi_nsb_lb: M L T^-2 }
export function computeConcreteAnchorBlowout({ edge_distance_in = 0, head_bearing_area_in2 = 0, fc_psi = 0, embedment_in = 0, perp_edge_in = 0, lambda = 1.0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const ca1 = Number(edge_distance_in) || 0;
  const abrg = Number(head_bearing_area_in2) || 0;
  const fc = Number(fc_psi) || 0;
  const hef = Number(embedment_in) || 0;
  const ca2 = Number(perp_edge_in) || 0;
  const lam = Number(lambda) || 0;
  if (!(ca1 > 0)) return { error: "Edge distance c_a1 must be positive (in)." };
  if (!(abrg > 0)) return { error: "Head bearing area must be positive (in^2)." };
  if (!(fc > 0)) return { error: "Concrete strength must be positive (psi)." };
  if (!(hef > 0)) return { error: "Embedment must be positive (in)." };
  if (!(lam > 0 && lam <= 1)) return { error: "Lambda must be in (0, 1] (1.0 normal weight)." };
  if (ca2 < 0) return { error: "Perpendicular edge distance must be zero (none) or positive (in)." };
  if (ca2 > 0 && ca2 < ca1) return { error: "c_a1 must be the minimum edge distance - swap the edges so c_a1 <= c_a2." };
  // 17.3.1 caps f'c at 10,000 psi for a cast-in anchor (added 2026-10-03).
  const nsb_lb = 160 * ca1 * Math.sqrt(abrg) * lam * Math.sqrt(Math.min(fc, 10000));
  const corner_factor = ca2 > 0 && ca2 < 3 * ca1 ? (1 + ca2 / ca1) / 4 : 1.0;
  const nsbn_lb = nsb_lb * corner_factor;
  const phi_nsb_lb = 0.70 * nsbn_lb;
  const applicable = hef > 2.5 * ca1;
  return {
    nsb_lb, corner_factor, nsbn_lb, phi_nsb_lb, applicable,
    note: (applicable
      ? "Blowout governs at this embedment (hef > 2.5 c_a1) - the strength does not depend on embedment; the edge distance is the knob."
      : "NOT the governing mode here: hef <= 2.5 c_a1, so concrete breakout (concrete-anchor-breakout) governs; the blowout numbers are shown for reference.")
      + " Applies to headed cast-in anchors where the head bears on the concrete. Closely spaced anchors along the edge interact per ACI 318-19 17.6.4.2 (not included). phi = 0.70 is Condition B (no supplementary reinforcement). ACI 318 Chapter 17 and the engineer of record govern - a design check, not a stamped anchor design.",
  };
}
export const concreteAnchorBlowoutExample = { inputs: { edge_distance_in: 3, head_bearing_area_in2: 0.654, fc_psi: 4000, embedment_in: 10, perp_edge_in: 0, lambda: 1.0 } };
CONCRETE_RENDERERS["concrete-anchor-blowout"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 Section 17.6.4 side-face blowout: Nsb = 160 x c_a1 x sqrt(Abrg) x lambda_a x sqrt(f'c); corner modification (1 + c_a2/c_a1)/4 where c_a2 < 3 c_a1; phiNsb = 0.70 x Nsb (Condition B). Governs for headed cast-in anchors with deep embedment near an edge (hef > 2.5 c_a1; shallower anchors are governed by breakout) and does not depend on embedment. Closely spaced anchors along the edge interact per 17.6.4.2. ACI 318 Chapter 17 and the engineer of record govern.",
  example: concreteAnchorBlowoutExample.inputs,
  fields: [
    { key: "edge_distance_in", label: "Nearest edge distance c_a1 (in)", kind: "number" },
    { key: "head_bearing_area_in2", label: "Head/nut net bearing area Abrg (in²)", kind: "number" },
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "embedment_in", label: "Embedment hef (in)", kind: "number" },
    { key: "perp_edge_in", label: "Perpendicular edge c_a2 (in, 0 = none)", kind: "number" },
    { key: "lambda", label: "Lightweight factor lambda_a (1.0 normal weight)", kind: "number" },
  ],
  outputs: [
    { key: "nsb", id: "cab-out-nsb", label: "Basic blowout Nsb", value: (r) => fmt(r.nsb_lb, 0) + " lb (" + fmt(r.nsb_lb / 1000, 1) + " kip)" },
    { key: "nsbn", id: "cab-out-nsbn", label: "Nominal Nsbn (corner factor)", value: (r) => fmt(r.nsbn_lb, 0) + " lb (factor " + fmt(r.corner_factor, 3) + ")" },
    { key: "phi", id: "cab-out-phi", label: "Design phiNsb", value: (r) => fmt(r.phi_nsb_lb, 0) + " lb (" + fmt(r.phi_nsb_lb / 1000, 1) + " kip)" + (r.applicable ? "" : " - breakout governs (hef <= 2.5 c_a1)") },
    { key: "n", id: "cab-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteAnchorBlowout,
});

// --- spec-v1019 E: Cast-in anchor SHEAR concrete breakout (ACI 318-19 17.7.2) ---
// Vb = min(7 (le/da)^0.2 sqrt(da), 9) lambda_a sqrt(f'c) ca1^1.5 (17.7.2.2.1a/b, lesser governs;
// the 9-form carries NO sqrt(da)); le = min(hef, 8 da). AVco = 4.5 ca1^2; single anchor, one loaded
// edge: AVc = min(1.5 ca1, ha) x (1.5 ca1 + min(1.5 ca1, ca2)). psi_edV = 0.7 + 0.3 ca2/(1.5 ca1)
// when ca2 < 1.5 ca1; psi_cV 1.0 cracked / 1.4 uncracked; psi_hV = sqrt(1.5 ca1/ha) >= 1.0 when
// ha < 1.5 ca1. phi = 0.70 Condition B.
// dims: in { anchor_dia_in: L, embedment_in: L, fc_psi: M L^-1 T^-2, edge_distance_in: L, perp_edge_in: L, member_thickness_in: L, cracking: dimensionless, lambda: dimensionless, direction: dimensionless } out: { vb_lb: M L T^-2, vcb_lb: M L T^-2, phi_vcb_lb: M L T^-2 }
export function computeConcreteAnchorShearBreakout({ anchor_dia_in = 0, embedment_in = 0, fc_psi = 4000, edge_distance_in = 0, perp_edge_in = 0, member_thickness_in = 0, cracking = "cracked", lambda = 1.0, direction = "toward" } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const da = Number(anchor_dia_in) || 0;
  const hef = Number(embedment_in) || 0;
  const fc = Number(fc_psi) || 0;
  const ca1_entered = Number(edge_distance_in) || 0;
  const ca2 = Number(perp_edge_in) || 0;
  const ha = Number(member_thickness_in) || 0;
  const lam = Number(lambda) || 0;
  if (!(da > 0)) return { error: "Anchor diameter must be positive (in)." };
  if (!(hef > 0)) return { error: "Effective embedment must be positive (in)." };
  if (!(fc > 0)) return { error: "Concrete strength f'c must be positive (psi)." };
  if (!(ca1_entered > 0)) return { error: "Edge distance c_a1 (toward the shear) must be positive (in) - far from an edge, shear breakout does not apply; steel or pryout governs." };
  // ACI 318-19 17.7.2.1.2: in a narrow, thin member where BOTH ca2 and ha are
  // under 1.5 ca1, the ca1 used in every breakout equation may not exceed the
  // greater of ca2/1.5 and ha/1.5 (s/3 applies to groups). Until 2026-09-18
  // this was not applied, 20% unconservative on the worked corner case.
  const narrow = ca2 > 0 && ha > 0 && ca2 < 1.5 * ca1_entered && ha < 1.5 * ca1_entered;
  const ca1 = narrow ? Math.min(ca1_entered, Math.max(ca2 / 1.5, ha / 1.5)) : ca1_entered;
  if (ca2 < 0) return { error: "Perpendicular edge distance must be zero (none) or positive (in)." };
  if (ha < 0) return { error: "Member thickness must be zero (thick) or positive (in)." };
  if (!(lam > 0 && lam <= 1)) return { error: "Lambda must be in (0, 1] (1.0 normal weight)." };
  const uncracked = cracking === "uncracked";
  if (cracking !== "cracked" && cracking !== "uncracked") return { error: "Cracking must be cracked or uncracked." };
  if (direction !== "toward" && direction !== "parallel") return { error: "Shear direction must be toward the edge or parallel to it." };
  const parallel = direction === "parallel";
  const le_in = Math.min(hef, 8 * da);
  const coef7 = 7 * Math.pow(le_in / da, 0.2) * Math.sqrt(da);
  const governing_form = coef7 <= 9 ? "7-form (stiffness)" : "9-cap (stiff anchor)";
  // ACI 318-19 17.3.1: f'c used in the anchor equations is capped at 10,000 psi for a cast-in
  // anchor (this tile's case). Until 2026-10-03 a 12,000 psi mix read 9.5% stronger.
  const vb_lb = Math.min(coef7, 9) * lam * Math.sqrt(Math.min(fc, 10000)) * Math.pow(ca1, 1.5);
  const AVco = 4.5 * ca1 * ca1;
  const depth_in = ha > 0 ? Math.min(1.5 * ca1, ha) : 1.5 * ca1;
  const width_in = 1.5 * ca1 + (ca2 > 0 ? Math.min(1.5 * ca1, ca2) : 1.5 * ca1);
  const AVc = depth_in * width_in;
  const area_ratio = Math.min(AVc / AVco, 1.0);
  // ACI 318-19 17.7.2.1(c): shear parallel to an edge may take twice the breakout computed as if the
  // shear acted toward that edge, with psi_edV = 1.0. Until 2026-10-08 the note named this as not modeled.
  const psi_edV = !parallel && ca2 > 0 && ca2 < 1.5 * ca1 ? 0.7 + 0.3 * ca2 / (1.5 * ca1) : 1.0;
  const psi_cV = uncracked ? 1.4 : 1.0;
  const psi_hV = ha > 0 && ha < 1.5 * ca1 ? Math.sqrt(1.5 * ca1 / ha) : 1.0;
  const vcb_lb = (parallel ? 2 : 1) * area_ratio * psi_edV * psi_cV * psi_hV * vb_lb;
  const phi_vcb_lb = 0.70 * vcb_lb;
  if (![vb_lb, vcb_lb, phi_vcb_lb].every(Number.isFinite)) return { error: "Shear-breakout math did not produce a finite value." };
  return {
    vb_lb, governing_form, le_in, AVco, AVc, area_ratio, psi_edV, psi_cV, psi_hV, vcb_lb, phi_vcb_lb,
    ca1_used_in: ca1, narrow_member_limit: narrow, parallel_doubled: parallel,
    note: "The strength scales with the EDGE DISTANCE to the 1.5 power (not the embedment - that is the tension mode): moving the anchor away from the edge is the strongest knob. A second edge closer than 1.5 c_a1 (corner) and a member thinner than 1.5 c_a1 both truncate the breakout half-pyramid; psi_hV partially compensates for the thin-member area loss. Shear parallel to an edge (direction select) takes twice the strength computed as if the shear acted toward that edge, with psi_edV = 1.0 (17.7.2.1(c)); c_a1 is then the distance to that edge. Single anchor; groups, eccentricity, and the seismic 0.75 factor are separate. Steel shear and pryout are separate checks. phi = 0.70 is Condition B (no supplementary reinforcement). ACI 318 Chapter 17 and the engineer of record govern - a design check, not a stamped anchor design.",
  };
}
export const concreteAnchorShearBreakoutExample = { inputs: { anchor_dia_in: 0.75, embedment_in: 6, fc_psi: 4000, edge_distance_in: 6, perp_edge_in: 0, member_thickness_in: 0, cracking: "cracked", lambda: 1.0 } };
CONCRETE_RENDERERS["concrete-anchor-shear-breakout"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 Section 17.7.2 concrete breakout in shear: Vb = lesser of 7 (le/da)^0.2 sqrt(da) lambda_a sqrt(f'c) c_a1^1.5 and 9 lambda_a sqrt(f'c) c_a1^1.5 (17.7.2.2.1), le = min(hef, 8 da); AVco = 4.5 c_a1^2; Vcb = (AVc/AVco) psi_edV psi_cV psi_hV Vb with psi_edV = 0.7 + 0.3 c_a2/(1.5 c_a1) when c_a2 < 1.5 c_a1 (17.7.2.4.1), psi_cV = 1.0 cracked / 1.4 uncracked (17.7.2.5.1), psi_hV = sqrt(1.5 c_a1/ha) when ha < 1.5 c_a1 (17.7.2.6.1); phiVcb = 0.70 Vcb (Condition B, Table 17.5.3). The capacity scales with the edge distance to the 1.5 power, not the embedment. Shear toward the edge (or parallel to it, doubled with psi_edV = 1.0 per 17.7.2.1(c)), single cast-in anchor. ACI 318 Chapter 17 and the engineer of record govern.",
  example: concreteAnchorShearBreakoutExample.inputs,
  fields: [
    { key: "anchor_dia_in", label: "Anchor diameter da (in)", kind: "number" },
    { key: "embedment_in", label: "Effective embedment hef (in)", kind: "number" },
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "edge_distance_in", label: "Edge distance c_a1, toward the shear (in)", kind: "number" },
    { key: "perp_edge_in", label: "Perpendicular edge c_a2 (in, 0 = none)", kind: "number" },
    { key: "member_thickness_in", label: "Member thickness ha (in, 0 = thick)", kind: "number" },
    { key: "cracking", label: "Concrete condition at service", kind: "select", options: [{ value: "cracked", label: "Cracked (psi_cV = 1.0)", selected: true }, { value: "uncracked", label: "Uncracked (psi_cV = 1.4)" }] },
    { key: "lambda", label: "Lightweight factor lambda_a (1.0 normal weight)", kind: "number" },
    { key: "direction", label: "Shear direction", kind: "select", options: [{ value: "toward", label: "Toward the edge", selected: true }, { value: "parallel", label: "Parallel to the edge (x2, psi_edV = 1.0)" }] },
  ],
  outputs: [
    { key: "vb", id: "casb-out-vb", label: "Basic breakout Vb", value: (r) => fmt(r.vb_lb, 0) + " lb (" + r.governing_form + ", le " + fmt(r.le_in, 2) + " in)" },
    { key: "geom", id: "casb-out-geom", label: "Projected area AVc / AVco", value: (r) => fmt(r.AVc, 1) + " / " + fmt(r.AVco, 1) + " in^2 (ratio " + fmt(r.area_ratio, 3) + ")" },
    { key: "psi", id: "casb-out-psi", label: "Factors psi_edV / psi_cV / psi_hV", value: (r) => fmt(r.psi_edV, 3) + " / " + fmt(r.psi_cV, 1) + " / " + fmt(r.psi_hV, 3) },
    { key: "vcb", id: "casb-out-vcb", label: "Nominal breakout Vcb", value: (r) => fmt(r.vcb_lb, 0) + " lb (" + fmt(r.vcb_lb / 1000, 1) + " kip)" + (r.parallel_doubled ? ", doubled for shear parallel to the edge" : "") },
    { key: "phi", id: "casb-out-phi", label: "Design capacity phiVcb", value: (r) => fmt(r.phi_vcb_lb, 0) + " lb (" + fmt(r.phi_vcb_lb / 1000, 1) + " kip)" },
    { key: "n", id: "casb-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteAnchorShearBreakout,
});

// --- spec-v1020 E: Concrete anchor pryout in shear (ACI 318-19 17.7.3) ---
// Vcp = kcp x Ncp, Ncp = Ncb (the tension-breakout strength, computed by CALLING the landed
// computeConcreteAnchorBreakout so the two tiles can never drift); kcp = 1.0 for hef < 2.5 in,
// 2.0 for hef >= 2.5 in; phi = 0.70 Condition B. Governs short stiff anchors AWAY from an edge.
// dims: in { embedment_in: L, fc_psi: M L^-1 T^-2, edge_distance_in: L, anchor_type: dimensionless, lambda: dimensionless, cracking: dimensionless, rows_toward_edge: dimensionless, spacing_toward_edge_in: L, anchors_along_edge: dimensionless, spacing_along_edge_in: L } out: { ncb_lb: M L T^-2, vcp_lb: M L T^-2, phi_vcp_lb: M L T^-2 }
export function computeConcreteAnchorPryout({ embedment_in = 0, fc_psi = 4000, edge_distance_in = 0, anchor_type = "cast-in", lambda = 1.0, cracking = "cracked", rows_toward_edge = 1, spacing_toward_edge_in = 0, anchors_along_edge = 1, spacing_along_edge_in = 0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const base = computeConcreteAnchorBreakout({ embedment_in, fc_psi, edge_distance_in, anchor_type, lambda, cracking, rows_toward_edge, spacing_toward_edge_in, anchors_along_edge, spacing_along_edge_in });
  if (base.error) return { error: base.error };
  const hef = Number(embedment_in) || 0;
  const kcp = hef < 2.5 ? 1.0 : 2.0;
  const vcp_lb = kcp * base.ncb_lb;
  const phi_vcp_lb = 0.70 * vcp_lb;
  if (![vcp_lb, phi_vcp_lb].every(Number.isFinite)) return { error: "Pryout math did not produce a finite value." };
  return {
    ncb_lb: base.ncb_lb, psi_c: base.psi_c, psi_cp: base.psi_cp, kcp, vcp_lb, phi_vcp_lb,
    note: "Pryout is the shear mode that governs SHORT, STIFF anchors AWAY from an edge - the anchor rotates and pries a breakout body out of the surface BEHIND it, so the capacity is proportional to the tension-breakout strength (Vcp = kcp Ncb), not to any edge distance in the shear direction. Near an edge, concrete-anchor-shear-breakout applies instead, and a shear design takes the LEAST of steel, edge breakout, and pryout. kcp jumps from 1.0 to 2.0 at hef = 2.5 in. A group (rows and spacing) uses the group breakout Ncbg, so this is the group pryout Vcpg = kcp Ncbg (17.7.3.1b). Uncracked concrete raises Ncb, and so the pryout, by psi_c,N (17.6.2.5.1; the cracking select). phi = 0.70 is Condition B (no supplementary reinforcement). ACI 318 Chapter 17 and the engineer of record govern - a design check, not a stamped anchor design.",
  };
}
export const concreteAnchorPryoutExample = { inputs: { embedment_in: 6, fc_psi: 4000, edge_distance_in: 100, anchor_type: "cast-in", lambda: 1.0 } };
CONCRETE_RENDERERS["concrete-anchor-pryout"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 Section 17.7.3 concrete pryout: Vcp = kcp x Ncp with Ncp = Ncb, the Section 17.6.2 tension-breakout strength (17.7.3.1a); kcp = 1.0 for hef < 2.5 in and 2.0 for hef >= 2.5 in; phiVcp = 0.70 Vcp (Condition B, Table 17.5.3). Ncb carries the 17.6.2.5.1 cracking factor psi_c,N (1.25 cast-in, 1.4 post-installed, uncracked). Pryout governs short stiff anchors away from an edge loaded in shear - the anchor pries a breakout body out of the surface behind it, so the capacity tracks the tension breakout, not an edge distance. Near an edge the 17.7.2 shear breakout applies instead; a shear design takes the least of steel, edge breakout, and pryout. ACI 318 Chapter 17 and the engineer of record govern.",
  example: concreteAnchorPryoutExample.inputs,
  fields: [
    { key: "embedment_in", label: "Effective embedment hef (in)", kind: "number" },
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "edge_distance_in", label: "Nearest edge distance ca1 (in, large = away)", kind: "number" },
    { key: "anchor_type", label: "Anchor type", kind: "select", options: [{ value: "cast-in", label: "Cast-in (kc = 24)" }, { value: "post-installed", label: "Post-installed, Category 1 (kc = 17)" }, { value: "post-installed-cat2", label: "Post-installed, Category 2 (kc = 17)" }, { value: "post-installed-cat3", label: "Post-installed, Category 3 (kc = 17)" }] },
    { key: "lambda", label: "Lightweight factor lambda_a (1.0 normal weight)", kind: "number" },
    { key: "cracking", label: "Concrete at service loads", kind: "select", options: [{ value: "cracked", label: "Cracked (psi_c,N 1.0)" }, { value: "uncracked", label: "Uncracked by analysis (psi_c,N 1.25 cast-in, 1.4 post-installed)" }] },
    { key: "rows_toward_edge", label: "Group: anchor rows toward the edge (1 for a single anchor)", kind: "number", default: 1, attrs: { step: "1", min: "1", value: "1" } },
    { key: "spacing_toward_edge_in", label: "Group: spacing between those rows (in)", kind: "number" },
    { key: "anchors_along_edge", label: "Group: anchors per row, along the edge", kind: "number", default: 1, attrs: { step: "1", min: "1", value: "1" } },
    { key: "spacing_along_edge_in", label: "Group: spacing along the edge (in)", kind: "number" },
  ],
  outputs: [
    { key: "ncb", id: "capy-out-ncb", label: "Tension breakout Ncb (the base)", value: (r) => fmt(r.ncb_lb, 0) + " lb (" + fmt(r.ncb_lb / 1000, 1) + " kip)" },
    { key: "kcp", id: "capy-out-kcp", label: "Pryout coefficient kcp", value: (r) => fmt(r.kcp, 1) + (r.kcp === 1 ? " (hef < 2.5 in)" : " (hef >= 2.5 in)") },
    { key: "vcp", id: "capy-out-vcp", label: "Nominal pryout Vcp", value: (r) => fmt(r.vcp_lb, 0) + " lb (" + fmt(r.vcp_lb / 1000, 1) + " kip)" },
    { key: "phi", id: "capy-out-phi", label: "Design pryout phiVcp", value: (r) => fmt(r.phi_vcp_lb, 0) + " lb (" + fmt(r.phi_vcp_lb / 1000, 1) + " kip)" },
    { key: "n", id: "capy-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteAnchorPryout,
});

// --- spec-v1021 E: Concrete anchor steel strength (ACI 318-19 17.6.1 / 17.7.1) ---
// Ase = (pi/4)(da - 0.9743/n)^2 (R17.6.1.2 commentary formula); futa capped at min(1.9 fya, 125 ksi);
// Nsa = Ase futa (17.6.1.2), phi 0.75 ductile tension; Vsa = 0.6 Ase futa (17.7.1.2b, cast-in
// headed/hooked BOLT; a cast-in headed STUD takes Vsa = Ase futa on its unthreaded shank, 17.7.1.2a,
// added 2026-10-08), phi 0.65 ductile shear.
// dims: in { anchor_dia_in: L, threads_per_in: L^-1, fya_psi: M L^-1 T^-2, futa_psi: M L^-1 T^-2, anchor_type: dimensionless } out: { ase_in2: L^2, nsa_lb: M L T^-2, phi_nsa_lb: M L T^-2, vsa_lb: M L T^-2, phi_vsa_lb: M L T^-2 }
export function computeConcreteAnchorSteelStrength({ anchor_dia_in = 0, threads_per_in = 0, fya_psi = 36000, futa_psi = 58000, anchor_type = "bolt" } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const da = Number(anchor_dia_in) || 0;
  const n = Number(threads_per_in) || 0;
  const fya = Number(fya_psi) || 0;
  const futa = Number(futa_psi) || 0;
  if (anchor_type !== "bolt" && anchor_type !== "stud") return { error: "Anchor type must be a headed or hooked bolt, or a headed stud." };
  const stud = anchor_type === "stud";
  if (!(da > 0)) return { error: "Anchor diameter must be positive (in)." };
  if (!stud && !(n > 0)) return { error: "Threads per inch must be positive (from the bolt callout, e.g. 5/8-11 has 11)." };
  if (!(fya > 0)) return { error: "Yield strength fya must be positive (psi)." };
  if (!(futa > 0)) return { error: "Tensile strength futa must be positive (psi)." };
  // A headed stud has no threads: Ase is the shank area.
  const root = stud ? da : da - 0.9743 / n;
  if (!(root > 0)) return { error: "Thread pitch is larger than the diameter allows - check the threads-per-inch callout." };
  const ase_in2 = Math.PI / 4 * root * root;
  const futa_used_psi = Math.min(futa, 1.9 * fya, 125000);
  const capped = futa_used_psi < futa;
  const nsa_lb = ase_in2 * futa_used_psi;
  const phi_nsa_lb = 0.75 * nsa_lb;
  const vsa_lb = (stud ? 1.0 : 0.6) * ase_in2 * futa_used_psi;
  const phi_vsa_lb = 0.65 * vsa_lb;
  if (![ase_in2, nsa_lb, phi_nsa_lb, vsa_lb, phi_vsa_lb].every(Number.isFinite)) return { error: "Steel-strength math did not produce a finite value." };
  return {
    ase_in2, futa_used_psi, capped, nsa_lb, phi_nsa_lb, vsa_lb, phi_vsa_lb,
    note: "The steel number every anchor-family tile's 'takes the least of steel and ...' note refers to. Ase is the effective (threaded) area, smaller than the nominal shank; futa is capped at the lesser of 1.9 fya and 125,000 psi so a high-strength rod cannot claim more than the code allows. The 0.6 shear factor is for cast-in headed and hooked BOLTS; a headed stud welded to a plate (anchor type select) develops the full Ase futa on its unthreaded shank per 17.7.1.2(a), and threads per inch are then not used (AWS D1.1 Type B studs: fya 51,000, futa 65,000 psi); ductile steel phi (0.75 tension / 0.65 shear) is used, and a brittle element takes lower phi. The anchor design takes the LEAST of this and the concrete modes (breakout, pullout, blowout, shear breakout, pryout). ACI 318 Chapter 17 and the engineer of record govern - a design check, not a stamped anchor design.",
  };
}
export const concreteAnchorSteelStrengthExample = { inputs: { anchor_dia_in: 0.625, threads_per_in: 11, fya_psi: 36000, futa_psi: 58000 } };
CONCRETE_RENDERERS["concrete-anchor-steel-strength"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 Sections 17.6.1 and 17.7.1 anchor steel strength: Ase = (pi/4)(da - 0.9743/n)^2 (the R17.6.1.2 commentary formula, also AISC Manual Table 7-18); futa taken as no more than the lesser of 1.9 fya and 125,000 psi; Nsa = Ase futa (17.6.1.2) with phi = 0.75 (ductile steel, tension); Vsa = 0.6 Ase futa for cast-in headed and hooked bolts (17.7.1.2b) with phi = 0.65 (ductile steel, shear) per Table 17.5.3. A welded headed stud develops the full Ase futa (17.7.1.2a, not modeled). The anchor design takes the least of the steel and every concrete mode. ACI 318 Chapter 17 and the engineer of record govern.",
  example: concreteAnchorSteelStrengthExample.inputs,
  fields: [
    { key: "anchor_dia_in", label: "Anchor diameter da (in)", kind: "number" },
    { key: "threads_per_in", label: "Threads per inch n (5/8-11 -> 11)", kind: "number" },
    { key: "fya_psi", label: "Steel yield fya (psi)", kind: "number" },
    { key: "futa_psi", label: "Steel tensile futa (psi)", kind: "number" },
    { key: "anchor_type", label: "Anchor type", kind: "select", options: [{ value: "bolt", label: "Headed or hooked bolt (Vsa = 0.6 Ase futa)", selected: true }, { value: "stud", label: "Welded headed stud (Vsa = Ase futa, shank area)" }] },
  ],
  outputs: [
    { key: "ase", id: "cass-out-ase", label: "Effective thread area Ase", value: (r) => fmt(r.ase_in2, 4) + " in^2" },
    { key: "futa", id: "cass-out-futa", label: "futa used (after the 1.9 fya / 125 ksi cap)", value: (r) => fmt(r.futa_used_psi, 0) + " psi" + (r.capped ? " - CAPPED below the entered value" : "") },
    { key: "nsa", id: "cass-out-nsa", label: "Steel tension Nsa / phiNsa", value: (r) => fmt(r.nsa_lb, 0) + " / " + fmt(r.phi_nsa_lb, 0) + " lb (phi 0.75)" },
    { key: "vsa", id: "cass-out-vsa", label: "Steel shear Vsa / phiVsa", value: (r) => fmt(r.vsa_lb, 0) + " / " + fmt(r.phi_vsa_lb, 0) + " lb (phi 0.65)" },
    { key: "n", id: "cass-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteAnchorSteelStrength,
});

// --- spec-v1022 E: Concrete anchor tension-shear interaction (ACI 318-19 17.8) ---
// Trilinear rule: shear ratio <= 0.2 -> full tension permitted; tension ratio <= 0.2 -> full shear
// permitted; else Nua/phiNn + Vua/phiVn <= 1.2 (17.8.3). Each individual ratio must be <= 1.0 on its
// own (17.8.1/17.8.2) - the interaction never waives that. Continuous at the 0.2 corners.
// dims: in { nua_lb: M L T^-2, vua_lb: M L T^-2, phi_nn_lb: M L T^-2, phi_vn_lb: M L T^-2 } out: { tension_ratio: dimensionless, shear_ratio: dimensionless, sum_ratio: dimensionless }
export function computeConcreteAnchorInteraction({ nua_lb = 0, vua_lb = 0, phi_nn_lb = 0, phi_vn_lb = 0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const nua = Number(nua_lb) || 0;
  const vua = Number(vua_lb) || 0;
  const pn = Number(phi_nn_lb) || 0;
  const pv = Number(phi_vn_lb) || 0;
  if (nua < 0) return { error: "Tension demand cannot be negative (lb); enter 0 for shear-only." };
  if (vua < 0) return { error: "Shear demand cannot be negative (lb); enter 0 for tension-only." };
  if (!(pn > 0)) return { error: "Design tension capacity phiNn must be positive (lb) - the least of the tension-mode tiles." };
  if (!(pv > 0)) return { error: "Design shear capacity phiVn must be positive (lb) - the least of the shear-mode tiles." };
  const tension_ratio = nua / pn;
  const shear_ratio = vua / pv;
  const individual_ok = tension_ratio <= 1.0 + 1e-9 * Math.abs(1.0) && shear_ratio <= 1.0 + 1e-9 * Math.abs(1.0);
  let branch, sum_ratio, limit, governing_ratio;
  if (shear_ratio <= 0.2) {
    branch = "full tension permitted (shear under 20%)";
    sum_ratio = tension_ratio + shear_ratio;
    limit = 1.0;
    governing_ratio = tension_ratio;
  } else if (tension_ratio <= 0.2) {
    branch = "full shear permitted (tension under 20%)";
    sum_ratio = tension_ratio + shear_ratio;
    limit = 1.0;
    governing_ratio = shear_ratio;
  } else {
    branch = "interaction (both over 20%)";
    sum_ratio = tension_ratio + shear_ratio;
    limit = 1.2;
    governing_ratio = sum_ratio / 1.2;
  }
  const pass = individual_ok && governing_ratio <= 1.0 + 1e-12;
  const utilization_pct = Math.max(tension_ratio, shear_ratio, governing_ratio) * 100;
  if (![tension_ratio, shear_ratio, sum_ratio, utilization_pct].every(Number.isFinite)) return { error: "Interaction math did not produce a finite value." };
  return {
    tension_ratio, shear_ratio, branch, sum_ratio, limit, utilization_pct, pass,
    note: "Enter the GOVERNING design capacities: phiNn is the least of the tension modes (steel, breakout, pullout, blowout) and phiVn the least of the shear modes (steel, shear breakout, pryout), in the same phi basis. Each demand must clear its own capacity outright - the interaction never waives that - and when both demands exceed 20% of capacity the sum must stay under 1.2, so an anchor comfortable in tension and comfortable in shear can still fail combined. The rule is continuous at the 20% corners. Seismic modifications (17.10) act on the capacities upstream. ACI 318 Chapter 17 and the engineer of record govern - a design check, not a stamped anchor design.",
  };
}
export const concreteAnchorInteractionExample = { inputs: { nua_lb: 6000, vua_lb: 3000, phi_nn_lb: 9831, phi_vn_lb: 5112 } };
CONCRETE_RENDERERS["concrete-anchor-interaction"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 Section 17.8 interaction of tensile and shear forces: where Vua/phiVn <= 0.2 the full tension strength is permitted, where Nua/phiNn <= 0.2 the full shear strength is permitted, and otherwise Nua/phiNn + Vua/phiVn <= 1.2 (17.8.3) - with each demand also required to clear its own capacity (17.8.1, 17.8.2). The trilinear rule is continuous at the 20% corners. phiNn is the least of the tension modes (steel, breakout, pullout, blowout) and phiVn the least of the shear modes (steel, shear breakout, pryout). ACI 318 Chapter 17 and the engineer of record govern.",
  example: concreteAnchorInteractionExample.inputs,
  fields: [
    { key: "nua_lb", label: "Factored tension demand Nua (lb)", kind: "number" },
    { key: "vua_lb", label: "Factored shear demand Vua (lb)", kind: "number" },
    { key: "phi_nn_lb", label: "Governing design tension capacity phiNn (lb)", kind: "number" },
    { key: "phi_vn_lb", label: "Governing design shear capacity phiVn (lb)", kind: "number" },
  ],
  outputs: [
    { key: "tr", id: "cai-out-tr", label: "Tension ratio Nua/phiNn", value: (r) => fmt(r.tension_ratio, 3) },
    { key: "sr", id: "cai-out-sr", label: "Shear ratio Vua/phiVn", value: (r) => fmt(r.shear_ratio, 3) },
    { key: "br", id: "cai-out-br", label: "Branch", value: (r) => r.branch + " (limit " + fmt(r.limit, 1) + ")" },
    { key: "sum", id: "cai-out-sum", label: "Combined sum", value: (r) => fmt(r.sum_ratio, 3) + (r.limit === 1.2 ? " vs 1.2" : " (informational)") },
    { key: "res", id: "cai-out-res", label: "Result", value: (r) => (r.pass ? "PASSES" : "FAILS") + " at " + fmt(r.utilization_pct, 1) + "% utilization" },
    { key: "n", id: "cai-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteAnchorInteraction,
});

// ===================== spec-v793: fresh (batch) concrete temperature (ACI 305.1) =====================
// Mass-weighted thermal-energy balance: mixture T = sum(c_i m_i T_i) / sum(c_i m_i), with the specific
// heat of solids (cement + aggregate) ~0.22 Btu/lb-F and water = 1.0. Free surface moisture on the
// aggregate is water at the aggregate temperature.
// dims: in { agg_weight_lb: M, agg_temp_f: T, cement_weight_lb: M, cement_temp_f: T, water_weight_lb: M, water_temp_f: T, agg_moisture_weight_lb: M } out: { concrete_temp_f: T }
export function computeFreshConcreteTemp({ agg_weight_lb = 0, agg_temp_f = null, cement_weight_lb = 0, cement_temp_f = null, water_weight_lb = 0, water_temp_f = null, agg_moisture_weight_lb = 0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  // A missing temperature is not 0 F: three ingredients with the water left blank
  // read 69.7 F, a plausible, cooler-than-real answer on a hot-weather check.
  for (const [name, v] of [["aggregate", agg_temp_f], ["cement", cement_temp_f], ["mix water", water_temp_f]]) {
    if (v === null || v === undefined || v === "") return { error: "Enter the " + name + " temperature (F)." };
  }
  const Wa = Number(agg_weight_lb) || 0;
  const Ta = Number(agg_temp_f);
  const Wc = Number(cement_weight_lb) || 0;
  const Tc = Number(cement_temp_f);
  const Ww = Number(water_weight_lb) || 0;
  const Tw = Number(water_temp_f);
  const Wwa = Number(agg_moisture_weight_lb) || 0;
  if (!(Wa > 0)) return { error: "Aggregate weight must be positive (lb)." };
  if (!(Wc > 0)) return { error: "Cement weight must be positive (lb)." };
  if (!(Ww > 0)) return { error: "Added (mix) water weight must be positive (lb)." };
  if (Wwa < 0) return { error: "Aggregate free-moisture weight cannot be negative (lb)." };
  if (![Ta, Tc, Tw].every(Number.isFinite)) return { error: "Enter valid temperatures (F)." };
  const num = 0.22 * (Ta * Wa + Tc * Wc) + Tw * Ww + Ta * Wwa;
  const den = 0.22 * (Wa + Wc) + Ww + Wwa;
  if (!(den > 0)) return { error: "The total heat-capacity weight must be positive." };
  const concrete_temp_f = num / den;
  if (!Number.isFinite(concrete_temp_f)) return { error: "Fresh-concrete-temperature math is not a finite value." };
  const hot = concrete_temp_f > 90;
  return {
    concrete_temp_f, hot,
    note: "ACI 305.1 fresh-concrete temperature by heat balance: the mix temperature is the mass-weighted average of its ingredients, weighting the solids (cement and aggregate) by their specific heat ~0.22 Btu/lb-F and water by 1.0, so T = [0.22(Ta Wa + Tc Wc) + Tw Ww + Twa Wwa] / [0.22(Wa + Wc) + Ww + Wwa]. Because water's heat capacity is over four times the solids', the MIX WATER is the cheapest lever -- chilling it, or replacing part of it with ice (crediting the 144 Btu/lb heat of fusion), pulls the batch down the most per pound. The aggregate, being the largest mass, sets the baseline, and its free surface moisture rides at the aggregate temperature. Hot-weather concreting (ACI 305) commonly caps the placing temperature near 90 F; above it, set time shortens, slump loss and plastic-shrinkage cracking rise, and 28-day strength can drop. Cement heat of hydration and mixer friction add a few degrees this static balance omits. A batching aid; the mix design and the project specification govern.",
  };
}
export const freshConcreteTempExample = { inputs: { agg_weight_lb: 3000, agg_temp_f: 80, cement_weight_lb: 564, cement_temp_f: 150, water_weight_lb: 240, water_temp_f: 70, agg_moisture_weight_lb: 60 } };
CONCRETE_RENDERERS["fresh-concrete-temp"] = _simpleRenderer({
  citation: "Citation: ACI 305.1 hot-weather fresh-concrete temperature (heat balance): T = [0.22(Ta Wa + Tc Wc) + Tw Ww + Twa Wwa] / [0.22(Wa + Wc) + Ww + Wwa], solids specific heat ~0.22 Btu/lb-F, water 1.0, free aggregate moisture at the aggregate temperature. Water is the cheapest lever (chill it or add ice, 144 Btu/lb of fusion). ACI 305 commonly caps placing near 90 F. Omits hydration heat and mixer friction. A batching aid; the mix design and spec govern.",
  example: freshConcreteTempExample.inputs,
  fields: [
    { key: "agg_weight_lb", label: "Aggregate weight (lb)", kind: "number" },
    { key: "agg_temp_f", label: "Aggregate temperature (°F)", kind: "number", required: true, attrs: { step: "any" } },
    { key: "cement_weight_lb", label: "Cement weight (lb)", kind: "number" },
    { key: "cement_temp_f", label: "Cement temperature (°F)", kind: "number", required: true, attrs: { step: "any" } },
    { key: "water_weight_lb", label: "Added (mix) water weight (lb)", kind: "number" },
    { key: "water_temp_f", label: "Mix water temperature (°F)", kind: "number", required: true, attrs: { step: "any" } },
    { key: "agg_moisture_weight_lb", label: "Free moisture on aggregate (lb)", kind: "number" },
  ],
  outputs: [
    { key: "t", id: "fct-out-t", label: "Fresh concrete temperature", value: (r) => fmt(r.concrete_temp_f, 1) + " F" + (r.hot ? " -- above the ~90 F hot-weather ceiling" : "") },
    { key: "n", id: "fct-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeFreshConcreteTemp,
});

// ===================== spec-v918: curing compound coverage =====================
// dims: in { slab_area_sf: L^2, coats: dimensionless, coverage_sf_per_gal: L^-1, waste_pct: dimensionless } out: { gallons_needed: dimensionless, gallons_exact: dimensionless, pails_5gal: dimensionless }
export function computeCuringCompoundCoverage({ slab_area_sf = 2500, coats = 1, coverage_sf_per_gal = 200, waste_pct = 0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  if (!(slab_area_sf > 0)) return { error: "Slab area must be positive (sf)." };
  if (!(coats > 0)) return { error: "Coats must be positive." };
  if (!(coverage_sf_per_gal > 0)) return { error: "Coverage rate must be positive (sf/gal)." };
  if (waste_pct < 0) return { error: "Waste cannot be negative (percent)." };
  const gallons_exact = slab_area_sf * coats / coverage_sf_per_gal * (100 + waste_pct) / 100;
  const gallons_needed = Math.ceil(gallons_exact - 1e-9);
  const pails_5gal = Math.ceil(gallons_needed / 5 - 1e-9);
  if (![gallons_exact, gallons_needed, pails_5gal].every(Number.isFinite)) return { error: "Coverage math is not a finite value." };
  return {
    gallons_exact,
    gallons_needed,
    pails_5gal,
    note: "Liquid membrane-forming curing compound (ASTM C309): gallons = area x coats / coverage, rounded up. Coverage runs about 200 sf/gal but the product label governs -- a rougher broom or tined finish, a second coat, and vertical faces all cut it. Apply right after the surface sheen leaves so the membrane seals in the mix water; a dissipating-resin (Type 1-D) or a white-pigmented (Type 2, reflects heat) is chosen per the job. A material-ordering estimate; the product data sheet and the spec govern the rate and the type.",
  };
}
export const curingCompoundCoverageExample = { inputs: { slab_area_sf: 2500, coats: 1, coverage_sf_per_gal: 200, waste_pct: 0 } };

CONCRETE_RENDERERS["curing-compound-coverage"] = _simpleRenderer({
  citation: "Citation: liquid membrane cure coverage by name (ASTM C309). gallons = ceil(area x coats / coverage x (1 + waste)); coverage ~200 sf/gal but the product label governs. Apply after the surface sheen leaves. A material estimate; the product data sheet and the spec govern.",
  example: curingCompoundCoverageExample.inputs,
  fields: [
    { key: "slab_area_sf", label: "Slab area (sf)", kind: "number" },
    { key: "coats", label: "Coats", kind: "number" },
    { key: "coverage_sf_per_gal", label: "Coverage (sf/gal, label governs)", kind: "number" },
    { key: "waste_pct", label: "Waste / overspray (%)", kind: "number" },
  ],
  outputs: [
    { key: "g", id: "ccc-out-g", label: "Curing compound", value: (r) => fmt(r.gallons_needed, 0) + " gal (" + fmt(r.gallons_exact, 1) + " exact)" },
    { key: "p", id: "ccc-out-p", label: "5-gallon pails", value: (r) => fmt(r.pails_5gal, 0) + " pails" },
    { key: "n", id: "ccc-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeCuringCompoundCoverage,
});

// ===================== spec-v921: concrete isolation-joint filler takeoff =====================
// dims: in { slab_length_ft: L, slab_width_ft: L, num_columns: dimensionless, column_perimeter_ft: L, strip_length_ft: L } out: { slab_perimeter_ft: L, column_isolation_ft: L, filler_lf: L, strips: dimensionless }
export function computeConcreteIsolationJoint({ slab_length_ft = 40, slab_width_ft = 30, num_columns = 6, column_perimeter_ft = 4, strip_length_ft = 10 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  if (!(slab_length_ft > 0)) return { error: "Slab length must be positive (ft)." };
  if (!(slab_width_ft > 0)) return { error: "Slab width must be positive (ft)." };
  if (num_columns < 0) return { error: "Column count cannot be negative." };
  if (column_perimeter_ft < 0) return { error: "Column perimeter cannot be negative (ft)." };
  if (!(strip_length_ft > 0)) return { error: "Strip length must be positive (ft)." };
  const slab_perimeter_ft = 2 * (slab_length_ft + slab_width_ft);
  const column_isolation_ft = Math.round(num_columns) * column_perimeter_ft;
  const filler_lf = slab_perimeter_ft + column_isolation_ft;
  const strips = Math.ceil(filler_lf / strip_length_ft - 1e-9);
  if (![slab_perimeter_ft, column_isolation_ft, filler_lf, strips].every(Number.isFinite)) return { error: "Isolation-joint math is not a finite value." };
  return {
    slab_perimeter_ft,
    column_isolation_ft,
    filler_lf,
    strips,
    note: "Pre-molded isolation-joint filler (usually 1/2 in fiber or foam) wraps a slab-on-grade wherever it abuts a rigid element so the slab can move independently: the slab perimeter against walls and footings, plus the full perimeter of each column, pier, or equipment pad it surrounds. filler = 2 x (L + W) + columns x column-perimeter; strips = ceil(filler / strip length). A 40 x 30 ft slab around six 12 in columns is 164 LF, 17 ten-foot strips. This is distinct from the sawn CONTROL joints (concrete-sawcut-footage), which relieve shrinkage within the slab. The structural and slab-on-grade details (ACI 302 / ACI 360) govern the joint locations and the filler.",
  };
}
export const concreteIsolationJointExample = { inputs: { slab_length_ft: 40, slab_width_ft: 30, num_columns: 6, column_perimeter_ft: 4, strip_length_ft: 10 } };

CONCRETE_RENDERERS["concrete-isolation-joint"] = _simpleRenderer({
  citation: "Citation: isolation-joint filler takeoff by name. filler = 2 x (L + W) + columns x column-perimeter; strips = ceil(filler / strip length). Isolation joints let a slab move independently of rigid elements (walls, footings, columns); distinct from sawn control joints. ACI 302 / ACI 360 and the structural detail govern.",
  example: concreteIsolationJointExample.inputs,
  fields: [
    { key: "slab_length_ft", label: "Slab length (ft)", kind: "number" },
    { key: "slab_width_ft", label: "Slab width (ft)", kind: "number" },
    { key: "num_columns", label: "Columns / piers in the slab", kind: "number" },
    { key: "column_perimeter_ft", label: "Perimeter per column (ft, 12 in sq = 4)", kind: "number" },
    { key: "strip_length_ft", label: "Filler strip length (ft)", kind: "number" },
  ],
  outputs: [
    { key: "f", id: "cij-out-f", label: "Isolation-joint filler", value: (r) => fmt(r.filler_lf, 0) + " LF (" + fmt(r.slab_perimeter_ft, 0) + " perimeter + " + fmt(r.column_isolation_ft, 0) + " columns)" },
    { key: "s", id: "cij-out-s", label: "Filler strips", value: (r) => fmt(r.strips, 0) + " strips" },
    { key: "n", id: "cij-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteIsolationJoint,
});

// ===================== spec-v936: concrete stair / stoop volume takeoff =====================
// dims: in { num_risers: dimensionless, riser_in: L, tread_in: L, width_in: L, throat_in: L } out: { volume_in3: L^3, volume_ft3: L^3, volume_cy: L^3 }
export function computeConcreteStairVolume({ num_risers = 4, riser_in = 7, tread_in = 11, width_in = 48, throat_in = 4 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  if (!(num_risers >= 1)) return { error: "Number of risers must be at least 1." };
  if (!(riser_in > 0)) return { error: "Riser height must be positive (in)." };
  if (!(tread_in > 0)) return { error: "Tread depth must be positive (in)." };
  if (!(width_in > 0)) return { error: "Width must be positive (in)." };
  if (!(throat_in > 0)) return { error: "Throat (waist) thickness must be positive (in)." };
  const n = Math.round(num_risers);
  // Cross-section = the sawtooth steps (n triangles of 1/2 R T) plus the raking waist slab (throat x rake length).
  const steps_area = n * 0.5 * riser_in * tread_in;
  const rake_length = Math.sqrt((n * riser_in) ** 2 + (n * tread_in) ** 2);
  const slab_area = throat_in * rake_length;
  const volume_in3 = (steps_area + slab_area) * width_in;
  const volume_ft3 = volume_in3 / 1728;
  const volume_cy = volume_in3 / 46656;
  if (![volume_in3, volume_ft3, volume_cy].every(Number.isFinite)) return { error: "Stair-volume math is not a finite value." };
  return {
    volume_in3,
    volume_ft3,
    volume_cy,
    note: "Concrete volume of a poured stair or stoop = the stepped wedge plus the raking waist slab: cross-section = n triangular steps (each 1/2 x riser x tread) + the throat slab (throat thickness x the rake length sqrt((n x riser)^2 + (n x tread)^2)), times the width. A 4-riser stoop at 7 in rise, 11 in tread, 48 in wide on a 4 in throat is about 10.1 ft3 (0.37 cy). Order a bit over -- this is the neat geometry, and it ignores the nosing overhang, a top landing or bottom footing, the reinforcing displacement, and the fact that the run is taken as risers x tread. A ready-mix ordering estimate; the structural stair detail and the finisher's forms govern the actual pour." ,
  };
}

export const concreteStairVolumeExample = { inputs: { num_risers: 4, riser_in: 7, tread_in: 11, width_in: 48, throat_in: 4 } };

CONCRETE_RENDERERS["concrete-stair-volume"] = _simpleRenderer({
  citation: "Citation: concrete stair volume geometry by name. cross-section = n x (1/2 x riser x tread) steps + throat x rake-length slab; volume = cross-section x width; cy = in3 / 46656. A ready-mix estimate; the stair detail and forms govern.",
  example: concreteStairVolumeExample.inputs,
  fields: [
    { key: "num_risers", label: "Number of risers", kind: "number" },
    { key: "riser_in", label: "Riser height (in)", kind: "number" },
    { key: "tread_in", label: "Tread depth (in)", kind: "number" },
    { key: "width_in", label: "Stair width (in)", kind: "number" },
    { key: "throat_in", label: "Throat / waist thickness (in)", kind: "number" },
  ],
  outputs: [
    { key: "cy", id: "csv-out-cy", label: "Concrete volume", value: (r) => fmt(r.volume_cy, 2) + " cy (" + fmt(r.volume_ft3, 1) + " ft3)" },
    { key: "n", id: "csv-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcreteStairVolume,
});

// ===================== spec-v975: slab load-transfer dowel schedule (ACI 302) =====================
// dims: in { joint_length_ft: L, slab_thickness_in: L, dowel_spacing_in: L, edge_clearance_in: L, num_joints: dimensionless } out: { dowels_per_joint: dimensionless, total_dowels: dimensionless, dowel_diameter_in: L }
export function computeSlabDowelSchedule({ joint_length_ft = 40, slab_thickness_in = 6, dowel_spacing_in = 12, edge_clearance_in = 6, num_joints = 5 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  if (!(joint_length_ft > 0)) return { error: "Joint length must be positive (ft)." };
  if (!(slab_thickness_in > 0)) return { error: "Slab thickness must be positive (in)." };
  if (!(dowel_spacing_in > 0)) return { error: "Dowel spacing must be positive (in)." };
  if (!(edge_clearance_in >= 0)) return { error: "Edge clearance cannot be negative (in)." };
  if (!(num_joints >= 1)) return { error: "Number of joints must be at least 1." };
  // One dowel every spacing along the joint, inset from each edge, plus one to start.
  const usable_in = joint_length_ft * 12 - 2 * edge_clearance_in;
  if (!(usable_in > 0)) return { error: "The two edge clearances take up the whole joint; no dowel fits." };
  const dowels_per_joint = usable_in <= 1e-9 ? 1 : Math.floor(usable_in / dowel_spacing_in + 1e-9) + 1;
  const total_dowels = dowels_per_joint * Math.round(num_joints);
  const dowel_diameter_in = slab_thickness_in / 8;
  if (![dowels_per_joint, total_dowels, dowel_diameter_in].every(Number.isFinite)) return { error: "Dowel-schedule math is not a finite value." };
  return {
    dowels_per_joint,
    total_dowels,
    dowel_diameter_in,
    note: "The smooth load-transfer dowels for a jointed concrete slab-on-grade, per ACI 302 detailing practice. Round, GREASED (bond-broken) dowels bridge a construction or contraction joint so the two panels deflect together under wheel loads while still free to shrink and slide -- distinct from the deformed, bonded bars of a structural connection (rc-shear-friction). One dowel is placed every spacing (commonly 12 in on center) along the joint, held back from each slab edge, so dowels per joint = floor((joint length x 12 - 2 x edge clearance) / spacing) + 1: a 40 ft joint at 12 in on center with 6 in edge clearance takes 40 dowels, and five such joints need 200. The dowel diameter is roughly the slab thickness over 8 (about 3/4 in for a 6 in slab) at about 18 in long, ONE end greased or capped so the joint can open -- but ACI 302.1R gives the actual dowel size, length, and spacing by slab thickness in a table, which governs over the t/8 guideline here. The dowels must be aligned parallel to the slab and to each other (a dowel basket or careful placement); misaligned dowels lock the joint and crack the slab. A material-takeoff and detailing aid; the structural drawings, ACI 302 / ACI 360, and the engineer of record govern the size and schedule.",
  };
}

export const slabDowelScheduleExample = { inputs: { joint_length_ft: 40, slab_thickness_in: 6, dowel_spacing_in: 12, edge_clearance_in: 6, num_joints: 5 } };

CONCRETE_RENDERERS["slab-dowel-schedule"] = _simpleRenderer({
  citation: "Citation: slab load-transfer dowel schedule (ACI 302 detailing), by name. dowels per joint = floor((joint length x 12 - 2 x edge clearance) / spacing) + 1; total = per joint x joints; dowel diameter ~ slab thickness/8 (advisory), ~18 in long, one end greased. ACI 302.1R gives the dowel size/length/spacing table (governs); the structural drawings and engineer of record govern.",
  example: slabDowelScheduleExample.inputs,
  fields: [
    { key: "joint_length_ft", label: "Joint length (ft)", kind: "number" },
    { key: "slab_thickness_in", label: "Slab thickness (in)", kind: "number" },
    { key: "dowel_spacing_in", label: "Dowel spacing (in o.c.)", kind: "number" },
    { key: "edge_clearance_in", label: "Edge clearance (in)", kind: "number", default: 6 },
    { key: "num_joints", label: "Number of dowelled joints", kind: "number" },
  ],
  outputs: [
    { key: "d", id: "sds-out-d", label: "Dowels per joint", value: (r) => String(r.dowels_per_joint) + " (one per " + "spacing + 1)" },
    { key: "t", id: "sds-out-t", label: "Total dowels", value: (r) => String(r.total_dowels) },
    { key: "s", id: "sds-out-s", label: "Dowel diameter (advisory, ACI 302 table governs)", value: (r) => fmt(r.dowel_diameter_in, 3) + " in (~t/8)" },
    { key: "n", id: "sds-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeSlabDowelSchedule,
});

// ===================== spec-v999: bagged (premix) concrete count for a small pour =====================
// dims: in { length_ft: L, width_ft: L, thickness_in: L, bag_yield_ft3: L^3, waste_pct: dimensionless } out: { volume_ft3: L^3, bags: dimensionless }
export function computeConcretePremixBags({ length_ft = 4, width_ft = 4, thickness_in = 4, bag_yield_ft3 = 0.60, waste_pct = 10 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  if (!(length_ft > 0)) return { error: "Length must be positive (ft)." };
  if (!(width_ft > 0)) return { error: "Width must be positive (ft)." };
  if (!(thickness_in > 0)) return { error: "Thickness must be positive (in)." };
  if (!(bag_yield_ft3 > 0)) return { error: "Bag yield must be positive (ft^3 per bag)." };
  if (!(waste_pct >= 0)) return { error: "Waste percent cannot be negative." };
  // Slab/pad volume, then bags at the mix's per-bag yield with a waste allowance.
  const volume_ft3 = length_ft * width_ft * (thickness_in / 12);
  // - 1e-9: a 6 x 6 ft, 4 in pad at 10% waste is exactly 22 bags but computed
  // 22.000000000000004 and read 23 (fixed 2026-10-01).
  const bags = Math.ceil(volume_ft3 * (1 + waste_pct / 100) / bag_yield_ft3 - 1e-9);
  if (![volume_ft3, bags].every(Number.isFinite)) return { error: "Bag-count math is not a finite value." };
  return {
    volume_ft3,
    bags,
    note: "The number of bags of pre-mixed concrete for a small pour -- a pad, footing, curb, or equipment base -- where ordering ready-mix by the yard makes no sense. The volume is length x width x thickness (all in feet, so a thickness in inches is divided by 12), and the bag count is that volume, plus a waste allowance, divided by the mix's yield per bag. Bagged concrete yields a published volume per bag that scales with the dry weight at about 0.0075 cubic feet per pound: an 80 lb bag makes about 0.60 cubic feet, 60 lb about 0.45, 50 lb about 0.375, and 40 lb about 0.30. A 4 ft x 4 ft pad 4 in thick is 4 x 4 x (4/12) = 5.33 cubic feet, so with 10% waste it takes ceil(5.33 x 1.10 / 0.60) = 10 of the 80 lb bags, or 14 of the 60 lb bags. Round UP -- a partial bag still means opening a whole one -- and add extra for uneven subgrade, spillage, and over-excavation; past roughly 1 cubic yard (about 45 of the 80 lb bags) ready-mix is usually cheaper and faster. A material-ordering estimate; the exact bag yield printed on the product, the real formwork dimensions, and the mix design govern." ,
  };
}

export const concretePremixBagsExample = { inputs: { length_ft: 4, width_ft: 4, thickness_in: 4, bag_yield_ft3: 0.60, waste_pct: 10 } };

CONCRETE_RENDERERS["concrete-premix-bags"] = _simpleRenderer({
  citation: "Citation: bagged (premix) concrete count for a small pour, by name. volume = L x W x (thickness_in/12); bags = ceil(volume x (1 + waste) / bag yield). Bag yield ~0.0075 ft^3/lb: 80 lb ~0.60 ft^3, 60 lb ~0.45, 50 lb ~0.375, 40 lb ~0.30. Round up; past ~1 cu yd (~45 of the 80 lb bags) ready-mix is cheaper. The printed bag yield, the real formwork, and the mix design govern.",
  example: concretePremixBagsExample.inputs,
  fields: [
    { key: "length_ft", label: "Length (ft)", kind: "number" },
    { key: "width_ft", label: "Width (ft)", kind: "number" },
    { key: "thickness_in", label: "Thickness (in)", kind: "number" },
    { key: "bag_yield_ft3", label: "Bag yield (ft³): 80lb 0.60, 60lb 0.45, 50lb 0.375, 40lb 0.30", kind: "number" },
    { key: "waste_pct", label: "Waste (percent)", kind: "number", default: 10 },
  ],
  outputs: [
    { key: "v", id: "cpb-out-v", label: "Pour volume", value: (r) => fmt(r.volume_ft3, 2) + " ft^3" },
    { key: "b", id: "cpb-out-b", label: "Bags needed", value: (r) => String(r.bags) + " bags" },
    { key: "n", id: "cpb-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeConcretePremixBags,
});

// ===================== spec-v1123: T-beam flexural capacity (ACI 318-19) =====================

// The flange action rc-beam-flexure names as a separate check and t-beam-effective-flange-width
// stops one step short of. Two behaviors, and which one applies is the whole question:
// if the stress block stays inside the slab (a <= hf) the section is just a rectangle of
// width be and the answer must equal the rectangular tile exactly - the fuzzer pins that
// against computeRcBeamFlexure. Only when a would run past the flange does the section
// become a true T, and the capacity splits into a flange couple and a web couple.
// The effective width is DELEGATED to computeTBeamEffectiveFlangeWidth so the two tiles
// cannot disagree, with an override for a be taken from the engineer's drawings.
// dims: in { fc_psi: M L^-1 T^-2, fy_psi: M L^-1 T^-2, as_in2: L^2, bw_in: L, hf_in: L, d_in: L, ln_in: L, sw_in: L, beam_type: dimensionless, be_override_in: L, mu_kipft: M L^2 T^-2 } out: { be_in: L, a_in: L, c_in: L, mn_kipft: M L^2 T^-2, phi_mn_kipft: M L^2 T^-2, asf_in2: L^2, asw_in2: L^2, eps_t: dimensionless, phi: dimensionless }
export function computeRcTBeamFlexure({ fc_psi = 4000, fy_psi = 60000, as_in2 = 0, bw_in = 0, hf_in = 0, d_in = 0, ln_in = 0, sw_in = 0, beam_type = "interior", be_override_in = 0, mu_kipft = 0 } = {}) {
  const _g = _finiteGuard(arguments[0]); if (_g) return _g;
  const fc = Number(fc_psi) || 0, fy = Number(fy_psi) || 0, As = Number(as_in2) || 0;
  const bw = Number(bw_in) || 0, hf = Number(hf_in) || 0, d = Number(d_in) || 0;
  const beOver = Number(be_override_in) || 0, mu = Number(mu_kipft) || 0;
  if (!(fc > 0)) return { error: "Concrete strength f'c must be positive (psi)." };
  if (!(fy > 0)) return { error: "Steel yield fy must be positive (psi)." };
  if (!(As > 0)) return { error: "Tension steel area As must be positive (in^2)." };
  if (!(bw > 0)) return { error: "Web width bw must be positive (in)." };
  if (!(hf > 0)) return { error: "Flange thickness hf must be positive (in)." };
  if (!(d > hf)) return { error: "Effective depth d must exceed the flange thickness." };

  let be_in, be_source, be_governs = null;
  if (beOver > 0) {
    be_in = beOver; be_source = "override";
  } else {
    const fw = computeTBeamEffectiveFlangeWidth({ bw_in: bw, hf_in: hf, ln_in: Number(ln_in) || 0, sw_in: Number(sw_in) || 0, beam_type });
    if (fw.error) return { error: fw.error + " (or enter an effective flange width directly)" };
    be_in = fw.be_in; be_source = "6.3.2"; be_governs = fw.governs;
  }
  if (be_in < bw) return { error: "Effective flange width cannot be less than the web width." };

  const beta1 = _RC_BETA1(fc);
  // Trial: assume the compression block stays within the flange.
  const a_trial = (As * fy) / (0.85 * fc * be_in);
  const t_action = a_trial > hf;

  let a_in, c_in, mn_kipin, asf_in2 = 0, asw_in2 = As;
  if (!t_action) {
    // Rectangular behavior on width be - identical to the rectangular tile.
    a_in = a_trial;
    c_in = a_in / beta1;
    mn_kipin = As * fy * (d - a_in / 2) / 1000;
  } else {
    // True T action: the overhanging flange carries one couple, the web the rest.
    asf_in2 = 0.85 * fc * (be_in - bw) * hf / fy;
    // Asw is always positive here: reaching this branch requires As fy > 0.85 f'c be hf,
    // which already exceeds the 0.85 f'c (be - bw) hf that Asf represents. No guard needed.
    asw_in2 = As - asf_in2;
    a_in = (asw_in2 * fy) / (0.85 * fc * bw);
    c_in = a_in / beta1;
    mn_kipin = (asf_in2 * fy * (d - hf / 2) + asw_in2 * fy * (d - a_in / 2)) / 1000;
  }

  // ACI 318-19 21.2.2: the tension-controlled limit is eps_ty + 0.003, NOT the fixed 0.005
  // the 2014 edition used - they coincide only near Grade 60.
  // A neutral axis at or below the steel means the section is not a beam at any phi.
  if (c_in >= d) return { error: "The neutral axis falls at or below the tension steel - this section is grossly over-reinforced and cannot be designed as a beam. Reduce As, widen the flange, or deepen the section." };

  const eps_ty = fy / 29e6;
  const tc_limit = eps_ty + 0.003;
  const eps_t = 0.003 * (d - c_in) / c_in;
  const tension_controlled = eps_t >= tc_limit;
  const compression_controlled = eps_t <= eps_ty;
  const phi = tension_controlled ? 0.90 : compression_controlled ? 0.65 : 0.65 + 0.25 * (eps_t - eps_ty) / 0.003;

  const mn_kipft = mn_kipin / 12;
  const phi_mn_kipft = phi * mn_kipft;
  const util = mu > 0 ? mu / phi_mn_kipft : null;
  const flange_fraction = t_action ? asf_in2 / As : 0;

  const note = "Effective flange width " + be_in.toFixed(1) + " in"
    + (be_source === "override" ? " (entered directly)" : ", from ACI 318-19 6.3.2 with " + be_governs + " governing")
    + ". Trial stress-block depth on that width is " + a_trial.toFixed(2) + " in against a " + hf + " in flange, so "
    + (t_action
      ? "the block runs PAST the flange and the section acts as a true T. The overhanging flange develops " + asf_in2.toFixed(2) + " in^2 worth of compression (" + (flange_fraction * 100).toFixed(0) + "% of the steel) at a lever arm of d - hf/2, and the remaining " + asw_in2.toFixed(2) + " in^2 is balanced by the web with its own block " + a_in.toFixed(2) + " in deep. "
      : "the whole compression block stays INSIDE the slab - which is the usual case for a positive-moment T-beam - so the section is simply a rectangle " + be_in.toFixed(1) + " in wide, and this returns exactly what the rectangular tile would. The web width does not enter the flexural answer at all. ")
    + "Mn = " + mn_kipft.toFixed(1) + " kip-ft, phi Mn = " + phi_mn_kipft.toFixed(1) + " kip-ft at phi = " + phi.toFixed(3) + ". "
    + "Net tensile strain is " + eps_t.toFixed(5) + " against a tension-controlled limit of " + tc_limit.toFixed(5) + " (eps_ty + 0.003 per 21.2.2, the 2019 edition's replacement for the old fixed 0.005 - they differ once you leave Grade 60), so the section is "
    + (tension_controlled ? "tension-controlled and phi is the full 0.90. " : compression_controlled ? "COMPRESSION-CONTROLLED, phi drops to 0.65, and a beam should be redesigned rather than accepted here. " : "in the TRANSITION zone, so phi is interpolated and this section is more heavily reinforced than good practice for a beam. ")
    + (util !== null ? "Against the " + mu + " kip-ft demand the utilization is " + util.toFixed(2) + (util <= 1 + 1e-9 ? (tension_controlled ? " - OK. " : " - within capacity, but NOT ACCEPTABLE: ACI 318-19 9.3.3.1 requires a nonprestressed beam to be tension-controlled (eps_t >= " + tc_limit.toFixed(5) + "), and this one is not - reduce As or deepen the section. ") : " - OVER. ") : "")
    + "Positive moment only: at a support the slab is in TENSION, the flange does nothing, and the section reverts to a rectangle of the WEB width - do not use this for negative moment. Singly reinforced; compression steel is the doubly-reinforced tile. Minimum steel (9.6.1.2), shear, deflection, bar spacing, and development are separate checks with their own tiles. A design aid, not a substitute for a licensed engineer's design - the engineer of record's stamped design governs.";

  return { be_in, be_source, be_governs, a_trial_in: a_trial, t_action, a_in, c_in, beta1, asf_in2, asw_in2, flange_fraction, eps_ty, tc_limit, eps_t, tension_controlled, compression_controlled, phi, mn_kipft, phi_mn_kipft, util, note };
}

export const rcTBeamFlexureExample = { inputs: { fc_psi: 4000, fy_psi: 60000, as_in2: 8.0, bw_in: 12, hf_in: 3, d_in: 24, ln_in: 240, sw_in: 24, beam_type: "interior", be_override_in: 0, mu_kipft: 700 } };

CONCRETE_RENDERERS["rc-tbeam-flexure"] = _simpleRenderer({
  citation: "Citation: ACI 318-19 T-beam flexure - 22.2.2.4.1 equivalent rectangular stress block, 6.3.2 effective flange width (delegated to the landed t-beam-effective-flange-width tile so the two cannot disagree), and 21.2.2 for the strength-reduction factor. If the trial block a = As fy / (0.85 f'c be) stays within the flange the section is rectangular of width be and Mn = As fy (d - a/2), identical to the rectangular tile. If it runs past, the flange overhangs are resolved as Asf = 0.85 f'c (be - bw) hf / fy at a lever arm d - hf/2 and the remaining steel Asw = As - Asf is balanced by the web with a = Asw fy / (0.85 f'c bw). phi follows 21.2.2 - tension-controlled at eps_t >= eps_ty + 0.003, compression-controlled at eps_t <= eps_ty = fy/Es, interpolated between; the 2019 edition replaced the fixed 0.005 limit, which matters above Grade 60. POSITIVE MOMENT ONLY: over a support the slab is in tension and the section reverts to a rectangle of the web width. Singly reinforced; minimum steel, shear, deflection, spacing, and development are separate. A design aid, not a substitute for a licensed engineer's design.",
  example: rcTBeamFlexureExample.inputs,
  fields: [
    { key: "fc_psi", label: "Concrete strength f'c (psi)", kind: "number" },
    { key: "fy_psi", label: "Steel yield fy (psi)", kind: "number" },
    { key: "as_in2", label: "Tension steel area As (in²)", kind: "number" },
    { key: "bw_in", label: "Web width bw (in)", kind: "number" },
    { key: "hf_in", label: "Flange (slab) thickness hf (in)", kind: "number" },
    { key: "d_in", label: "Effective depth d (in)", kind: "number" },
    { key: "ln_in", label: "Clear span ln (in)", kind: "number" },
    { key: "sw_in", label: "Clear distance to the next web sw (in)", kind: "number" },
    { key: "beam_type", label: "Beam location", kind: "select", options: [{ value: "interior", label: "Interior (flange both sides)", selected: true }, { value: "edge", label: "Edge / spandrel (one side)" }] },
    { key: "be_override_in", label: "Effective width override (in; 0 = compute it)", kind: "number" },
    { key: "mu_kipft", label: "Required moment Mu (kip-ft; 0 = capacity only)", kind: "number", default: 0, attrs: { step: "any" } },
  ],
  outputs: [
    { key: "be", id: "rtb-out-be", label: "Effective flange width be", value: (r) => fmt(r.be_in, 1) + " in" + (r.be_source === "override" ? " (entered)" : " (" + r.be_governs + " governs)") },
    { key: "bh", id: "rtb-out-bh", label: "Behavior", value: (r) => r.t_action ? "TRUE T - block " + fmt(r.a_in, 2) + " in deep runs past the " + fmt(r.a_trial_in, 2) + " in trial into the web" : "RECTANGULAR - block " + fmt(r.a_in, 2) + " in stays inside the flange" },
    { key: "sp", id: "rtb-out-sp", label: "Steel split (flange / web)", value: (r) => r.t_action ? fmt(r.asf_in2, 2) + " / " + fmt(r.asw_in2, 2) + " in^2 (" + fmt(r.flange_fraction * 100, 0) + "% in the flange)" : "all in the flange couple - no web block" },
    { key: "mn", id: "rtb-out-mn", label: "Nominal moment Mn", value: (r) => fmt(r.mn_kipft, 1) + " kip-ft" },
    { key: "pm", id: "rtb-out-pm", label: "Design moment phi Mn", value: (r) => fmt(r.phi_mn_kipft, 1) + " kip-ft at phi = " + fmt(r.phi, 3) },
    { key: "et", id: "rtb-out-et", label: "Net tensile strain", value: (r) => fmt(r.eps_t, 5) + " vs a " + fmt(r.tc_limit, 5) + " tension-controlled limit - " + (r.tension_controlled ? "tension-controlled" : r.compression_controlled ? "COMPRESSION-CONTROLLED" : "transition zone") },
    { key: "ut", id: "rtb-out-ut", label: "Demand / capacity", value: (r) => r.util === null ? "- (no Mu entered)" : fmt(r.util, Math.abs(r.util - 1) < 0.005 && r.util !== 1 ? 4 : 2) + (r.util <= 1 + 1e-9 ? (r.tension_controlled ? " (OK)" : " (NOT tension-controlled - fails ACI 318-19 9.3.3.1)") : " (OVER)") },
    { key: "n", id: "rtb-out-n", label: "Note", value: (r) => r.note },
  ],
  compute: computeRcTBeamFlexure,
});

// spec-v1862: the concrete placement and tilt-up field-operations bench moved to calc-concreteplacement.js.