viewof K      = Inputs.range([40, 200],   {value: 160, step: 10,   label: katexLabel("K", " (Home capital)")})
viewof L      = Inputs.range([40, 200],   {value: 80,  step: 10,   label: katexLabel("L", " (Home labor)")})
viewof Kf     = Inputs.range([40, 200],   {value: 80,  step: 10,   label: katexLabel("K^{*}", " (Foreign capital)")})
viewof Lf     = Inputs.range([40, 200],   {value: 160, step: 10,   label: katexLabel("L^{*}", " (Foreign labor)")})
viewof alphaC = Inputs.range([0.1, 0.5],  {value: 0.20, step: 0.05, label: katexLabel("\\alpha_{C}", " (cloth K share)")})
viewof alphaW = Inputs.range([0.5, 0.9],  {value: 0.70, step: 0.05, label: katexLabel("\\alpha_{W}", " (wine K share)")})
viewof pCW    = Inputs.range([0.5, 2.0],  {value: 1.0, step: 0.1,  label: katexLabel("p_{C} / p_{W}", "")})
viewof loc    = Inputs.range([0.05, 0.95],{value: 0.5, step: 0.05, label: katexLabel("L_{C} / L", "")})
viewof beta   = Inputs.range([0.1, 0.9],  {value: 0.5, step: 0.05, label: katexLabel("\\beta", " (cloth expenditure share)")})
viewof stage  = Inputs.range([1, 3],      {value: 3, step: 1,    label: "reveal stage"})
viewof cobwebRound = Inputs.range([0, 8], {value: 0, step: 1,    label: "cobweb round"})

katexReady = {
  if (window.katex && typeof window.katex.renderToString === "function") {
    return window.katex;
  }
  // Fall back to loading dynamically if header inject didn't land yet.
  return new Promise((resolve, reject) => {
    const check = () => {
      if (window.katex && typeof window.katex.renderToString === "function") {
        resolve(window.katex);
      } else {
        setTimeout(check, 30);
      }
    };
    check();
    setTimeout(() => reject(new Error("katex failed to load")), 8000);
  });
}

// Build a slider/HTML label: KaTeX-rendered math followed by plain trailing text.
// Wrapping in a cell ensures the `katexReady` dependency is resolved before
// the returned function is available to consumers (Quarto OJS does not scan
// function bodies for reactive deps).
katexLabel = {
  const ready = katexReady;
  return function (mathStr, trailing = "") {
    const span = document.createElement("span");
    const mathSpan = document.createElement("span");
    mathSpan.innerHTML = ready.renderToString(mathStr, { throwOnError: false });
    span.appendChild(mathSpan);
    if (trailing) span.appendChild(document.createTextNode(trailing));
    return span;
  };
}

// Render a point label using pure SVG <text> with <tspan>s.
// Accepts plain text with `_X` / `_{XX}` for subscripts and
// `^X` / `^{XX}` for superscripts. Wrap math in `$...$` to render
// in italic (serif-italic mimics TeX math). No foreignObject / KaTeX,
// so it renders reliably in Safari as well as Chromium.
function texLabel(parent, px, py, str, {
  color = "#000", fontSize = 12, anchor = "middle", bold = false, rotated = false, math = false
} = {}) {
  const textEl = parent.append("text")
    .attr("fill", color)
    .attr("font-size", fontSize)
    .attr("font-family", "serif")
    .attr("font-weight", bold ? "bold" : "normal")
    .attr("text-anchor",
      anchor === "start" ? "start" :
      anchor === "end" ? "end" : "middle")
    .attr("dominant-baseline", "middle")
    .attr("transform",
      rotated
        ? `translate(${px},${py}) rotate(-90)`
        : `translate(${px},${py})`);

  let i = 0;
  let inMath = math;
  while (i < str.length) {
    const c = str[i];
    if (c === "$") {
      inMath = !inMath;
      i++;
      continue;
    }
    if (c === "_" || c === "^") {
      i++;
      let content = "";
      if (str[i] === "{") {
        i++;
        while (i < str.length && str[i] !== "}") content += str[i++];
        i++;
      } else {
        content = str[i++] || "";
      }
      const tspan = textEl.append("tspan")
        .attr("baseline-shift", c === "_" ? "sub" : "super")
        .attr("font-size", `${fontSize * 0.72}px`)
        .text(content);
      if (inMath) tspan.attr("font-style", "italic");
    } else {
      let run = "";
      while (i < str.length && str[i] !== "_" && str[i] !== "^" && str[i] !== "$") {
        run += str[i++];
      }
      if (run) {
        const tspan = textEl.append("tspan").text(run);
        if (inMath) tspan.attr("font-style", "italic");
      }
    }
  }
  return textEl;
}

// Plain-SVG axis label (reliable rotation/positioning in all browsers)
function svgAxisLabel(parent, px, py, text, {rotated = false, fontSize = 12} = {}) {
  return parent.append("text")
    .attr("text-anchor", "middle")
    .attr("dominant-baseline", "middle")
    .attr("font-size", fontSize)
    .attr("font-family", "serif")
    .attr("fill", "#000")
    .attr("transform",
      rotated
        ? `translate(${px},${py}) rotate(-90)`
        : `translate(${px},${py})`)
    .text(text);
}

// ── Shared label placement helpers (collision-avoiding) ──
// Each panel instantiates one placer bound to its own {g, x, y, iw, ih}.
// Curves passed in `avoid` (and the labeled curve itself, for labelOnCurve)
// must be arrays of [xData, yData] pairs in data coordinates.
//
// Usage:
//   const L = makeLabelPlacer({g, x, y, iw, ih});
//   L.labelOnCurve("PPF", ppfPoints, -1, [icPts], "#800000", true, {tex: "PPF"});
//   L.placeLabel("autarky", candidates, [curves...], "#800000", true, "autarky");
function makeLabelPlacer({g, x, y, iw, ih}) {
  const placedBBs = [];

  // Width/height estimate for a label's footprint in pixels. Sub/superscripts
  // extend the vertical footprint — underestimating the height lets the
  // collision checker miss curves that clip the subscript.
  function approxBB(str, px, py, anchor, fs = 11) {
    const hasSub = /_/.test(str);
    const w = str.length * (fs * 0.62);
    const h = hasSub ? fs * 2.3 : fs * 1.5;
    let x0 = px;
    if (anchor === "middle") x0 = px - w / 2;
    else if (anchor === "end") x0 = px - w;
    // texLabel uses dominant-baseline: middle, so py is the vertical centre.
    return {x0, y0: py - h / 2, x1: x0 + w, y1: py + h / 2};
  }

  function segHitsBB(ax, ay, bx, by, bb) {
    // Trivial reject: segment entirely on one side of a bb edge.
    if ((ax < bb.x0 && bx < bb.x0) || (ax > bb.x1 && bx > bb.x1) ||
        (ay < bb.y0 && by < bb.y0) || (ay > bb.y1 && by > bb.y1)) return false;
    // Endpoint inside.
    if (ax >= bb.x0 && ax <= bb.x1 && ay >= bb.y0 && ay <= bb.y1) return true;
    if (bx >= bb.x0 && bx <= bb.x1 && by >= bb.y0 && by <= bb.y1) return true;
    // Segment-vs-edge intersection (parametric).
    function si(p0x, p0y, p1x, p1y, p2x, p2y, p3x, p3y) {
      const s1x = p1x - p0x, s1y = p1y - p0y;
      const s2x = p3x - p2x, s2y = p3y - p2y;
      const denom = -s2x * s1y + s1x * s2y;
      if (denom === 0) return false;
      const s = (-s1y * (p0x - p2x) + s1x * (p0y - p2y)) / denom;
      const t = ( s2x * (p0y - p2y) - s2y * (p0x - p2x)) / denom;
      return s >= 0 && s <= 1 && t >= 0 && t <= 1;
    }
    return si(ax, ay, bx, by, bb.x0, bb.y0, bb.x1, bb.y0) ||
           si(ax, ay, bx, by, bb.x1, bb.y0, bb.x1, bb.y1) ||
           si(ax, ay, bx, by, bb.x1, bb.y1, bb.x0, bb.y1) ||
           si(ax, ay, bx, by, bb.x0, bb.y1, bb.x0, bb.y0);
  }

  function bbHitsCurve(bb, pts) {
    for (let k = 0; k < pts.length - 1; k++) {
      const [cx1, cy1] = pts[k];
      const [cx2, cy2] = pts[k + 1];
      if (segHitsBB(x(cx1), y(cy1), x(cx2), y(cy2), bb)) return true;
    }
    return false;
  }

  function bbHitsBB(a, b) {
    return !(a.x1 < b.x0 || a.x0 > b.x1 || a.y1 < b.y0 || a.y0 > b.y1);
  }

  function inPlot(bb) {
    return bb.x0 >= 2 && bb.y0 >= 2 && bb.x1 <= iw - 2 && bb.y1 <= ih - 2;
  }

  // Place a point-style label: try each candidate {x, y, anchor?} in order,
  // accept the first that clears every `avoid` curve and every already-placed
  // label. If none clears, fall back to the first candidate unchecked.
  function placeLabel(str, candidates, avoid, color, bold, texStr) {
    const labelTeX = texStr || str;
    const pad = 3;
    for (const c of candidates) {
      const px = x(c.x), py = y(c.y);
      const raw = approxBB(str, px, py, c.anchor || "start");
      const bb = {x0: raw.x0 - pad, y0: raw.y0 - pad, x1: raw.x1 + pad, y1: raw.y1 + pad};
      if (!inPlot(bb)) continue;
      let hit = false;
      for (const curve of avoid) if (bbHitsCurve(bb, curve)) { hit = true; break; }
      if (hit) continue;
      for (const o of placedBBs) if (bbHitsBB(bb, o)) { hit = true; break; }
      if (hit) continue;
      placedBBs.push(bb);
      return texLabel(g, px, py, labelTeX, {color, fontSize: 11, anchor: c.anchor || "start", bold, math: true});
    }
    const c = candidates[0];
    return texLabel(g, x(c.x), y(c.y), labelTeX, {color, fontSize: 11, anchor: c.anchor || "start", bold, math: true});
  }

  // Place a label next to a curve by offsetting perpendicular to the local
  // tangent.
  //
  // Search order (outermost → innermost):
  //   1. fontSizes large → small — keep labels readable; shrink only when no
  //      position at the current size clears (a)(b). Requirement (d)'s "a
  //      little offset" is the minimum, not a hard maximum — at fs=11 we may
  //      still drift to the 2nd–3rd offset band to find a clear spot.
  //   2. offsets   near → far   — (d) "as close as possible, with a little offset"
  //   3. fracs     end-biased   — (c) "at one of the ends of the labeled curve"
  //   4. sides     +1 / −1      — (a) flip to the other side of the curve
  // First non-colliding position wins.
  //
  // `side`: −1 toward origin, +1 outside, 0 either.
  function labelOnCurve(str, curve, side, avoid, color, bold, opts = {}) {
    // End-biased fracs: strongly prefer the curve endpoints, cap at ≤0.25/≥0.75
    // so we never drift to the middle under the default.
    const fracs     = opts.fracs     || [0.04, 0.96, 0.08, 0.92, 0.12, 0.88, 0.16, 0.84, 0.20, 0.80, 0.25, 0.75];
    const offsets   = opts.offsets   || [3, 5, 7, 10, 14, 19];
    const fontSizes = opts.fontSizes || [11, 10, 9, 8, 7];
    const anc       = opts.anchor    || "middle";
    const labelTeX  = opts.tex       || str;
    const originPx = x(0), originPy = y(0);
    for (const fs of fontSizes) {
      for (const off of offsets) {
        for (const f of fracs) {
          const i = Math.max(1, Math.min(curve.length - 2, Math.floor((curve.length - 1) * f)));
          if (!curve[i]) continue;
          const [cx, cy] = curve[i];
          const i0 = Math.max(0, i - 3), i1 = Math.min(curve.length - 1, i + 3);
          const tx = x(curve[i1][0]) - x(curve[i0][0]);
          const ty = y(curve[i1][1]) - y(curve[i0][1]);
          const tlen = Math.hypot(tx, ty) || 1;
          const baseNx = -ty / tlen, baseNy = tx / tlen;
          const cPx = x(cx), cPy = y(cy);
          const sides = side === 0 ? [+1, -1] : [side];
          for (const s of sides) {
            const dot = baseNx * (originPx - cPx) + baseNy * (originPy - cPy);
            let nnx = baseNx, nny = baseNy;
            if ((s === -1 && dot < 0) || (s === +1 && dot > 0)) { nnx = -baseNx; nny = -baseNy; }
            const lpx = cPx + nnx * off;
            const lpy = cPy + nny * off;
            const raw = approxBB(str, lpx, lpy, anc, fs);
            const pad = 2;
            const bb = {x0: raw.x0 - pad, y0: raw.y0 - pad, x1: raw.x1 + pad, y1: raw.y1 + pad};
            if (!inPlot(bb)) continue;
            if (bbHitsCurve(bb, curve)) continue;
            let hit = false;
            for (const c of avoid) if (bbHitsCurve(bb, c)) { hit = true; break; }
            if (hit) continue;
            for (const o of placedBBs) if (bbHitsBB(bb, o)) { hit = true; break; }
            if (hit) continue;
            placedBBs.push(bb);
            return texLabel(g, lpx, lpy, labelTeX, {color, fontSize: fs, anchor: anc, bold, math: true});
          }
        }
      }
    }
    // Last resort: smallest font, near first fraction, offset upward.
    const fs = fontSizes[fontSizes.length - 1];
    const fi = Math.max(1, Math.min(curve.length - 2, Math.floor((curve.length - 1) * fracs[0])));
    const [cx, cy] = curve[fi];
    return texLabel(g, x(cx) + 6, y(cy) - 20, labelTeX, {color, fontSize: fs, anchor: anc, bold, math: true});
  }

  return {placedBBs, approxBB, segHitsBB, bbHitsCurve, bbHitsBB, inPlot, placeLabel, labelOnCurve};
}

// ── Helper: synced slider panel (subset selectable per slide) ──
function sliderPanel(keys = ["K", "L", "alphaC", "alphaW", "loc"], opts = {}) {
  const all = {
    K:      Inputs.bind(Inputs.range([40, 200],   {value: 160, step: 10,   label: katexLabel("K", " (Home capital)")}), viewof K),
    L:      Inputs.bind(Inputs.range([40, 200],   {value: 80,  step: 10,   label: katexLabel("L", " (Home labor)")}), viewof L),
    Kf:     Inputs.bind(Inputs.range([40, 200],   {value: 80,  step: 10,   label: katexLabel("K^{*}", " (Foreign capital)")}), viewof Kf),
    Lf:     Inputs.bind(Inputs.range([40, 200],   {value: 160, step: 10,   label: katexLabel("L^{*}", " (Foreign labor)")}), viewof Lf),
    alphaC: Inputs.bind(Inputs.range([0.1, 0.5],  {value: 0.20, step: 0.05, label: katexLabel("\\alpha_{C}", " (cloth K share)")}), viewof alphaC),
    alphaW: Inputs.bind(Inputs.range([0.5, 0.9],  {value: 0.70, step: 0.05, label: katexLabel("\\alpha_{W}", " (wine K share)")}), viewof alphaW),
    pCW:    Inputs.bind(Inputs.range([0.5, 2.0],  {value: 1.0, step: 0.1,  label: katexLabel("p_{C} / p_{W}", "")}), viewof pCW),
    loc:    Inputs.bind(Inputs.range([0.05, 0.95],{value: 0.5, step: 0.05, label: katexLabel("L_{C} / L", "")}), viewof loc),
    beta:   Inputs.bind(Inputs.range([0.1, 0.9],  {value: 0.5, step: 0.05, label: katexLabel("\\beta", " (cloth expenditure share)")}), viewof beta),
    stage:  Inputs.bind(Inputs.range([1, 3],      {value: 3, step: 1,    label: "reveal stage"}), viewof stage),
    cobwebRound: Inputs.bind(Inputs.range([0, 8], {value: 0, step: 1,    label: "cobweb round"}), viewof cobwebRound)
  };
  const div = document.createElement("div");
  div.style.fontSize = "13px";
  if (opts.columns && opts.columns > 1) {
    div.style.display = "grid";
    div.style.gridTemplateColumns = `repeat(${opts.columns}, 1fr)`;
    div.style.columnGap = "16px";
    div.style.rowGap = "2px";
  }
  for (const k of keys) all[k].style.maxWidth = "100%";
  for (const k of keys) div.appendChild(all[k]);
  return div;
}

ratio = ((1 - alphaC) / alphaC) * (alphaW / (1 - alphaW))

contractCurve = {
  const pts = [];
  const N = 200;
  for (let i = 0; i <= N; i++) {
    const lc = (i / N) * L;
    const kc = K * lc / (lc * (1 - ratio) + ratio * L);
    pts.push([lc, kc]);
  }
  return pts;
}

lcStar = loc * L
kcStar = K * lcStar / (lcStar * (1 - ratio) + ratio * L)
lwStar = L - lcStar
kwStar = K - kcStar

qcStar = Math.pow(kcStar, alphaC) * Math.pow(lcStar, 1 - alphaC)
qwStar = Math.pow(kwStar, alphaW) * Math.pow(lwStar, 1 - alphaW)

kLratioC = kcStar / lcStar
kLratioW = kwStar / lwStar

// ── Slide 2: PPF derived from the contract curve ──
ppfPoints = {
  const pts = [];
  const N = 200;
  for (let i = 0; i <= N; i++) {
    const lc = (i / N) * L;
    const kc = K * lc / (lc * (1 - ratio) + ratio * L);
    const lw = L - lc;
    const kw = K - kc;
    const qc = Math.pow(kc, alphaC) * Math.pow(lc, 1 - alphaC);
    const qw = Math.pow(kw, alphaW) * Math.pow(lw, 1 - alphaW);
    pts.push([qc, qw]);
  }
  return pts;
}

qcMax = Math.pow(K, alphaC) * Math.pow(L, 1 - alphaC)
qwMax = Math.pow(K, alphaW) * Math.pow(L, 1 - alphaW)

// Autarky allocation (closed form from C-D utility × C-D production)
etaAut = (beta / (1 - beta)) * ((1 - alphaC) / (1 - alphaW))
lcAut = (etaAut * L) / (1 + etaAut)
kcAut = K * lcAut / (lcAut * (1 - ratio) + ratio * L)
qcAut = Math.pow(kcAut, alphaC) * Math.pow(lcAut, 1 - alphaC)
qwAut = Math.pow(K - kcAut, alphaW) * Math.pow(L - lcAut, 1 - alphaW)
uAut = Math.pow(qcAut, beta) * Math.pow(qwAut, 1 - beta)
priceAut = (beta * qwAut) / ((1 - beta) * qcAut)

ppfPointsF = {
  const pts = [];
  const N = 200;
  for (let i = 0; i <= N; i++) {
    const lc = (i / N) * Lf;
    const kc = Kf * lc / (lc * (1 - ratio) + ratio * Lf);
    const lw = Lf - lc;
    const kw = Kf - kc;
    const qc = Math.pow(kc, alphaC) * Math.pow(lc, 1 - alphaC);
    const qw = Math.pow(kw, alphaW) * Math.pow(lw, 1 - alphaW);
    pts.push([qc, qw]);
  }
  return pts;
}

qcMaxF = Math.pow(Kf, alphaC) * Math.pow(Lf, 1 - alphaC)
qwMaxF = Math.pow(Kf, alphaW) * Math.pow(Lf, 1 - alphaW)

// Foreign autarky (closed form: C-D utility × C-D production, identical to Home)
etaAutF   = (beta / (1 - beta)) * ((1 - alphaC) / (1 - alphaW))
lcAutF    = (etaAutF * Lf) / (1 + etaAutF)
kcAutF    = Kf * lcAutF / (lcAutF * (1 - ratio) + ratio * Lf)
qcAutF    = Math.pow(kcAutF, alphaC) * Math.pow(lcAutF, 1 - alphaC)
qwAutF    = Math.pow(Kf - kcAutF, alphaW) * Math.pow(Lf - lcAutF, 1 - alphaW)
uAutF     = Math.pow(qcAutF, beta) * Math.pow(qwAutF, 1 - beta)
priceAutF = (beta * qwAutF) / ((1 - beta) * qcAutF)

function produce(p, Kend, Lend) {
  const logBC = -alphaC * Math.log(alphaC) - (1 - alphaC) * Math.log(1 - alphaC);
  const logBW = -alphaW * Math.log(alphaW) - (1 - alphaW) * Math.log(1 - alphaW);
  const det   = alphaW - alphaC;
  const rhsC  = Math.log(p) - logBC;
  const rhsW  = -logBW;
  const w = Math.exp((rhsC * alphaW - rhsW * alphaC) / det);
  const r = Math.exp(((1 - alphaC) * rhsW - (1 - alphaW) * rhsC) / det);

  const klC = (alphaC / (1 - alphaC)) * (w / r);
  const klW = (alphaW / (1 - alphaW)) * (w / r);

  // Full-employment cloth labor: K_C + K_W = K with K_i = klI · L_i.
  const lc = (Kend - klW * Lend) / (klC - klW);

  // Outside the cone → full specialization.
  if (lc < 0) {
    const qw = Math.pow(Kend, alphaW) * Math.pow(Lend, 1 - alphaW);
    return {qc: 0, qw, lc: 0, kc: 0, lw: Lend, kw: Kend, w, r,
            specialized: "wine"};
  }
  if (lc > Lend) {
    const qc = Math.pow(Kend, alphaC) * Math.pow(Lend, 1 - alphaC);
    return {qc, qw: 0, lc: Lend, kc: Kend, lw: 0, kw: 0, w, r,
            specialized: "cloth"};
  }

  const kc = klC * lc;
  const lw = Lend - lc;
  const kw = Kend - kc;
  const qc = Math.pow(kc, alphaC) * Math.pow(lc, 1 - alphaC);
  const qw = Math.pow(kw, alphaW) * Math.pow(lw, 1 - alphaW);
  return {qc, qw, lc, kc, lw, kw, w, r, specialized: null};
}

// World relative supply: parametric sweep over p, log-spaced.
worldRSpoints = {
  const pts = [];
  const N = 160;
  const pMin = 0.15, pMax = 6.0;
  for (let i = 0; i <= N; i++) {
    const t = i / N;
    const p = Math.exp(Math.log(pMin) + t * (Math.log(pMax) - Math.log(pMin)));
    const h = produce(p, K, L);
    const f = produce(p, Kf, Lf);
    const qcW = h.qc + f.qc;
    const qwW = h.qw + f.qw;
    if (qwW > 1e-9) pts.push({rs: qcW / qwW, p});
  }
  return pts;
}

// Per-country relative supply (subdued layers in the world panel).
homeRSpoints = {
  const pts = [];
  const N = 160;
  const pMin = 0.15, pMax = 6.0;
  for (let i = 0; i <= N; i++) {
    const t = i / N;
    const p = Math.exp(Math.log(pMin) + t * (Math.log(pMax) - Math.log(pMin)));
    const h = produce(p, K, L);
    if (h.qw > 1e-9) pts.push({rs: h.qc / h.qw, p});
  }
  return pts;
}

foreignRSpoints = {
  const pts = [];
  const N = 160;
  const pMin = 0.15, pMax = 6.0;
  for (let i = 0; i <= N; i++) {
    const t = i / N;
    const p = Math.exp(Math.log(pMin) + t * (Math.log(pMax) - Math.log(pMin)));
    const f = produce(p, Kf, Lf);
    if (f.qw > 1e-9) pts.push({rs: f.qc / f.qw, p});
  }
  return pts;
}

// World relative demand from C-D utility (cloth share β):
// C_C/C_W = (β/(1−β)) · (1/p)  ⇒  rs = k/p with k = β/(1−β).
worldRDpoints = {
  const pts = [];
  const N = 240;
  const k = beta / (1 - beta);
  const pMin = 0.05, pMax = 6.0;
  for (let i = 1; i <= N; i++) {
    const t = i / N;
    const p = pMin + t * (pMax - pMin);
    pts.push({rs: k / p, p});
  }
  return pts;
}

// World equilibrium price via bisection on excess relative supply.
pStar = {
  const k = beta / (1 - beta);
  function excess(p) {
    const h = produce(p, K, L);
    const f = produce(p, Kf, Lf);
    const qwW = h.qw + f.qw;
    if (qwW <= 0) return Infinity;
    return (h.qc + f.qc) / qwW - k / p;
  }
  let lo = 0.05, hi = 10;
  let flo = excess(lo), fhi = excess(hi);
  for (let i = 0; i < 60 && flo * fhi > 0; i++) {
    hi *= 1.5;
    fhi = excess(hi);
  }
  for (let i = 0; i < 80; i++) {
    const mid = 0.5 * (lo + hi);
    const fm = excess(mid);
    if (fm === 0) return mid;
    if (flo * fm < 0) { hi = mid; fhi = fm; }
    else              { lo = mid; flo = fm; }
  }
  return 0.5 * (lo + hi);
}

// Trade production, income, consumption, welfare (per country).
prodH = produce(pStar, K, L)
prodF = produce(pStar, Kf, Lf)

incH = pStar * prodH.qc + prodH.qw
incF = pStar * prodF.qc + prodF.qw

consCH = beta * incH / pStar
consWH = (1 - beta) * incH
consCF = beta * incF / pStar
consWF = (1 - beta) * incF

uTradeH = Math.pow(consCH, beta) * Math.pow(consWH, 1 - beta)
uTradeF = Math.pow(consCF, beta) * Math.pow(consWF, 1 - beta)

rsStar = (prodH.qc + prodF.qc) / (prodH.qw + prodF.qw)

// Per-country autarky relative supply (for marker placement on world RS panel).
rsAutH = qcAut  / qwAut
rsAutF = qcAutF / qwAutF