{{/* /fleet/economics (Task 13): the operator unit-economics dashboard.
     Everything on this page renders server-side from EconomicsView, which
     is already priced under the active scenario (economicsview.go) — the
     ONE inline <script> at the foot only RE-computes in place when an
     operator tweaks a knob, transliterating
     internal/economics/compute.go's AllocateBox/PriceAccount/Project
     function-for-function (same names, JS-cased) so drift between the two
     is reviewable at a glance. With JS off, every number above stays
     exactly what the server rendered, and the knob drawer's only working
     control is the save-scenario form at its foot: it round-trips the
     CURRENTLY active scenario's JSON unchanged (Task 12's
     /fleet/economics/scenarios door), just under a new name and/or
     activated — the knobs above it don't feed the save without JS,
     because there is no field-by-field parsing on the server side for
     them, only whole-JSON parsing (server.go's handleEconomicsScenarioSave
     comment).

     The knob drawer markup (define "econ_knob_drawer") and the pure
     calculation functions the inline script needs (define "econ_maths_js")
     both live at the bottom of this file and are INCLUDED here rather than
     only defined here — Task 14's /fleet/economics/accounts page templates
     the same two blocks (economics_accounts.html) so its own knob drawer
     and its own recompute() share one source for both the editable knobs
     and the maths, instead of a second ~300-line copy. See
     economics_accounts.html's header comment for that page's (smaller)
     recompute().

     DataJSON payload keys (economicsPayload, economicsview.go) this page's
     JS reads — every key here must match that struct's json tag exactly,
     the same rule the struct's own doc comment states from the Go side:
     scenario, meters, boxLoads, boxSpecs, bills, coveredDays, periodDays,
     daysInMonth, tiers, poolTopupUnitAccrual (Task 6 — the dimensionless
     Σ 1/daysInMonth(d) over the period; econ_maths_js's poolLedger scales
     it by the live pool.topup_usd knob rather than re-deriving the per-day
     sum client-side — see that field's own doc comment for why). */}}
{{define "economics"}}{{template "top" .}}
<h1>Fleet economics</h1>
{{if .Flash}}<p class="banner">{{.Flash}}</p>{{end}}
{{if .FlashErr}}<p class="banner error">{{.FlashErr}}</p>{{end}}
{{if .Economics.Warning}}<p class="banner error">{{icon "triangle-alert"}} {{.Economics.Warning}}</p>{{end}}
{{if .Economics.ScenarioWarning}}<p class="banner error">{{icon "triangle-alert"}} {{.Economics.ScenarioWarning}}</p>{{end}}

<p class="small">Generated {{fmtTime .Economics.GeneratedAt}} &middot; scenario <strong>{{.Economics.Scenario.Name}}</strong> ({{.Economics.Scenario.Mode}}) &middot; {{.Economics.CoveredDays}}/{{.Economics.PeriodDays}} days metered</p>

<nav class="small" aria-label="Period">
  Period:
  <a href="?period=mtd"{{if eq .Economics.Period "mtd"}} aria-current="page"{{end}}>Month to date</a> &middot;
  <a href="?period=last"{{if eq .Economics.Period "last"}} aria-current="page"{{end}}>Last month</a> &middot;
  <a href="?period=7d"{{if eq .Economics.Period "7d"}} aria-current="page"{{end}}>Last 7 days</a>
</nav>
<p class="small"><a href="/fleet/economics/accounts">Every account, searchable →</a></p>

{{/* Headline tiles: EconomicsView.Accounts (allocated+metered cost and
     revenue per tenant) plus every box's unallocated idle headroom plus
     fixed overheads (brief: "period totals from EconomicsView.Accounts +
     idle + overheads") — see sumAcctCost/sumBoxIdle/overheadUSD (server.go)
     for the exact formula, mirrored by the inline script's recompute(). */}}
{{$revenue := sumAcctRevenue .Economics.Accounts}}
{{$cost := add (sumAcctCost .Economics.Accounts) (sumBoxIdle .Economics.Boxes) (overheadUSD .Economics.Scenario .Economics.PeriodDays)}}
{{$profit := sub $revenue $cost}}
{{$margin := marginOf $revenue $cost}}
{{/* $showProjection: the spec's "month-to-date with projection" promise —
     only meaningful on "mtd" (the other periods are already whole,
     closed ranges with nothing left to project), and only once at least
     one day of this month has actually been swept (economics.Project
     itself returns 0 for CoveredDays<=0, which would render a false,
     confident-looking "$0.00 for the month" rather than simply omitting
     the line). The margin tile has no projected line — a ratio doesn't
     project the way a dollar total does. */}}
{{$showProjection := and (eq .Economics.Period "mtd") (gt .Economics.CoveredDays 0)}}
<section class="tiles" aria-label="Headline economics">
  <div class="tile">
    <h2>Would-be revenue</h2>
    <p class="tile-value" id="tile-revenue">{{usd $revenue}}</p>
    <p class="tile-detail">{{.Economics.CoveredDays}}/{{.Economics.PeriodDays}} days metered</p>
    {{if $showProjection}}<p class="tile-detail" id="tile-revenue-projected">projected {{usd (project $revenue .Economics.CoveredDays .Economics.DaysInMonth)}} for the month</p>{{end}}
  </div>
  <div class="tile">
    <h2>Cost</h2>
    <p class="tile-value" id="tile-cost">{{usd $cost}}</p>
    <p class="tile-detail">{{.Economics.CoveredDays}}/{{.Economics.PeriodDays}} days metered</p>
    {{if $showProjection}}<p class="tile-detail" id="tile-cost-projected">projected {{usd (project $cost .Economics.CoveredDays .Economics.DaysInMonth)}} for the month</p>{{end}}
  </div>
  <div class="tile">
    <h2>Profit</h2>
    <p class="tile-value" id="tile-profit">{{usd $profit}}</p>
    <p class="tile-detail">{{.Economics.CoveredDays}}/{{.Economics.PeriodDays}} days metered</p>
    {{if $showProjection}}<p class="tile-detail" id="tile-profit-projected">projected {{usd (project $profit .Economics.CoveredDays .Economics.DaysInMonth)}} for the month</p>{{end}}
  </div>
  <div class="tile">
    <h2>Achieved margin</h2>
    <p class="tile-value" id="tile-margin">{{pctf $margin}}</p>
    <p class="tile-detail">{{.Economics.CoveredDays}}/{{.Economics.PeriodDays}} days metered</p>
  </div>
  {{/* Fleet pool tile (Task 6): PoolLedger's own doc comment (economicsview.go)
       for the exact formula — a share of paying revenue plus a day-accrued
       monthly top-up, against the pool-tier accounts' own real spend. Headroom
       MAY be negative (the pool is overdrawn this period) and renders honestly,
       never clamped — the negative case carries the page's existing warning
       styling (.error, same class every other on-page warning uses) on the
       headroom figure alone, not the whole tile. */}}
  <div class="tile" id="tile-pool">
    <h2>Fleet pool</h2>
    <p class="tile-value">POOL <span id="tile-pool-usd">{{usd .Economics.Pool.PoolUSD}}</span> &middot; draw <span id="tile-pool-draw">{{usd .Economics.Pool.DrawUSD}}</span> &middot; headroom <span id="tile-pool-headroom"{{if lt .Economics.Pool.HeadroomUSD 0.0}} class="error"{{end}}>{{usd .Economics.Pool.HeadroomUSD}}</span></p>
    <p class="tile-detail">{{.Economics.CoveredDays}}/{{.Economics.PeriodDays}} days metered</p>
  </div>
</section>

<h2>Accounts</h2>
{{if .Economics.Accounts}}
<div class="tablewrap">
<table>
  <tr><th>Account</th><th>Cost</th><th>Revenue</th><th title="Pooled rows (free-tier position &quot;pooled&quot;) show an em-dash: their revenue is shared through the fleet pool, not individually priced, so a margin fraction has nothing to divide. Fleet-tier rows can legitimately show 100%: fleet boxes are customer-owned hardware, zero cost to the platform, by design.">Margin</th><th>Free tier</th></tr>
  {{range .Economics.Accounts}}
  {{$name := index $.Economics.Names .Account}}
  <tr data-account="{{.Account}}">
    {{/* Account-names batch: same treatment as economics_accounts.html's
         row (see that template's comment on this exact markup) — this page
         has no econAccountRow, so the name is looked up straight from
         EconomicsView.Names by sqid rather than carried on the row. */}}
    <td>{{if $name}}{{$name}} <span class="small">{{.Account}}</span>{{else}}{{.Account}}{{end}}</td>
    <td class="js-acct-cost">{{usd .CostUSD}}</td>
    <td class="js-acct-revenue">{{usd .RevenueUSD}}</td>
    <td class="js-acct-margin">{{marginCell .MarginFrac .FreeTierPos}}</td>
    <td class="js-acct-freetier">{{.FreeTierPos}}</td>
  </tr>
  {{end}}
</table>
</div>
{{/* MINOR 3 (fix round, Task 6 review): the Margin column's title=
     tooltip is invisible on touch/keyboard — this legend carries the
     same two notes visibly, for everyone. */}}
<p class="small">Margin: pooled rows show an em-dash — their revenue is shared through the fleet pool, not individually priced. Fleet-tier rows can legitimately show 100% margin — fleet boxes are customer-owned hardware, zero cost to the platform, by design.</p>
{{else}}<p class="small">No accounts to price this period.</p>{{end}}
<p class="small"><a href="/fleet/economics/accounts">Every account, searchable →</a></p>

<h2>Boxes</h2>
{{if .Economics.Boxes}}
<div class="tablewrap">
<table>
  <tr><th>Box</th><th>Hours</th><th>Cost</th><th>Idle</th><th>Utilization</th><th>Egress</th><th>Revenue</th><th>Profit</th></tr>
  {{range .Economics.Boxes}}
  <tr data-box="{{.Box}}">
    <td>{{.Box}}</td>
    <td class="js-hours">{{printf "%.2f" .Hours}}</td>
    <td class="js-cost">{{usd .CostUSD}}</td>
    <td class="js-idle">{{usd .IdleUSD}}</td>
    <td>
      <span class="bar"><span class="bar-fill" style="width:{{printf "%.0f" (mul .Utilization 100.0)}}%"></span></span>
      <span class="js-util-pct">{{pctf .Utilization}}</span>
    </td>
    <td>{{if .EgressMetered}}<span class="js-egress">metered</span>{{else}}<span class="js-egress chip chip-stale">unmetered</span>{{end}}</td>
    <td class="js-revenue">{{usd .RevenueUSD}}</td>
    <td class="js-profit">{{usd (sub .RevenueUSD .CostUSD)}}</td>
  </tr>
  {{end}}
</table>
</div>
{{else}}<p class="small">No box has published metrics this period.</p>{{end}}

<div id="econ-live">
{{$ec2 := sumBoxesEC2 .Economics.Boxes .Economics.Scenario.RateCard}}
{{$ebs := sumBoxesEBS .Economics.Boxes .Economics.Scenario.RateCard}}
{{$s3storage := mul (sumMeter .Economics.Meters "storage_gb_month") .Economics.Scenario.RateCard.StorageGBMonthUSD}}
{{$s3requests := mul (sumMeter .Economics.Meters "requests_1k") .Economics.Scenario.RateCard.RequestsPer1kUSD}}
{{$egress := mul (sumMeter .Economics.Meters "egress_gb") .Economics.Scenario.RateCard.EgressGBUSD}}
{{$backhaulGB := sumMeter .Economics.Meters "backhaul_gb"}}
{{$backhaul := mul $backhaulGB .Economics.Scenario.RateCard.InterRegionGBUSD}}
{{$overheads := overheadUSD .Economics.Scenario .Economics.PeriodDays}}
{{$modelTotal := add $ec2 $ebs $s3storage $s3requests $egress $backhaul $overheads}}
<h2>Model vs. bill</h2>
<div class="tablewrap">
<table>
  <tr><th>Model component</th><th>USD</th></tr>
  <tr><td>EC2 (box hours)</td><td id="model-ec2">{{usd $ec2}}</td></tr>
  <tr><td>EBS</td><td id="model-ebs">{{usd $ebs}}</td></tr>
  <tr><td>S3 storage</td><td id="model-s3-storage">{{usd $s3storage}}</td></tr>
  <tr><td>S3 requests</td><td id="model-s3-requests">{{usd $s3requests}}</td></tr>
  <tr><td>Egress</td><td id="model-egress">{{usd $egress}}</td></tr>
  <tr><td>Backhaul (inter-region leg) <span class="small">{{printf "%.2f" $backhaulGB}} GB{{with sumMeter .Economics.Meters "egress_gb"}}{{if gt . 0.0}} · {{printf "%.1f" (mul (div $backhaulGB .) 100.0)}}% of egress{{end}}{{end}} · absorbed, in no account's bill{{if and (gt $backhaulGB 0.0) (eq .Economics.Scenario.RateCard.InterRegionGBUSD 0.0)}} · <strong>rate unset</strong> — set "Inter-region $/GB" in the knobs{{end}}</span></td><td id="model-backhaul">{{usd $backhaul}}</td></tr>
  <tr><td>Overheads</td><td id="model-overheads">{{usd $overheads}}</td></tr>
  <tr><th>Model total</th><th id="model-total">{{usd $modelTotal}}</th></tr>
</table>
</div>

{{$curBill := billForMonth .Economics.Bills (periodMonth .Economics.Period)}}
{{if $curBill}}
{{/* "Counts as CARLOS" checkbox default (Paul's rule, brief step 3): a
     scenario with an EMPTY bill_services counts EVERY line on the bill —
     an old scenario, or one nobody has touched, must not silently zero the
     reconciliation. Once anything is unchecked, bill_services carries
     exactly the checked set. billServiceChecked (server.go) and the inline
     script's JS twin of the same name are the ONE place this rule is
     encoded — nowhere else re-derives it.

     Two corollaries the inline script's readScenarioFromDOM enforces
     (controller ruling, fix round 1):
       - Empty-means-all is only a READING of an empty list, never a
         WRITING instruction: when this period's page shows no checkboxes
         at all (no bill on screen), the save field must pass the base
         scenario's bill_services through untouched, not overwrite it to
         [] — the manual bill-entry form shares #econ-live's delegated
         listener, so a keystroke there must not clobber a reconciliation
         selection made on a DIFFERENT period's checkboxes.
       - "Count zero services" is not a meaningful reconciliation state
         (there is no tri-state to invent between "all" and "some"): when
         every checkbox is unchecked, the hidden save field keeps the last
         selection that had at least one box checked, and the drawer shows
         a note that the all-unchecked view is live-only, not saveable. */}}
{{$billChecked := sumBillServicesChecked $curBill.Services .Economics.Scenario.BillServices}}
{{$delta := sub $billChecked $modelTotal}}
<div class="tablewrap">
<table>
  <tr><th>Bill service ({{$curBill.Month}}, {{$curBill.Source}})</th><th>USD</th><th>Counts as CARLOS</th></tr>
  {{range $svc, $amt := $curBill.Services}}
  <tr>
    <td>{{$svc}}</td>
    <td>{{usd $amt}}</td>
    <td><input type="checkbox" class="bill-service-checkbox" data-service="{{$svc}}" data-amount="{{$amt}}"{{if billServiceChecked $.Economics.Scenario.BillServices $svc}} checked{{end}}></td>
  </tr>
  {{end}}
  <tr><th>Bill total (counted)</th><th id="bill-total-checked">{{usd $billChecked}}</th><th></th></tr>
</table>
</div>
<p>Delta, bill minus model: <strong id="breakdown-delta">{{usd $delta}}</strong></p>
{{else}}
<p class="small">No bill on file for {{periodMonth .Economics.Period}} — enter one manually.</p>
<form method="post" action="/fleet/economics/bill">
  <input type="hidden" name="csrf" value="{{.CSRF}}">
  <div class="knob-row">
    <label for="bill-month">Month</label>
    <input type="text" id="bill-month" name="month" pattern="\d{4}-\d{2}" value="{{periodMonth .Economics.Period}}" required>
  </div>
  <div class="knob-row">
    <label for="bill-total">Total USD</label>
    <input type="number" step="0.01" min="0" id="bill-total" name="total" required>
  </div>
  <div class="knob-row">
    <label for="bill-lines">Services, one "Service=USD" per line</label>
  </div>
  <p><textarea id="bill-lines" name="lines" rows="6" cols="48" placeholder="EC2=120.50&#10;S3=42.10"></textarea></p>
  <button type="submit">Save bill</button>
</form>
{{end}}

{{template "econ_knob_drawer" .}}
</div>

<script type="application/json" id="econ-data">{{.Economics.DataJSON}}</script>
<script>
(function () {
  "use strict";
  // The JSON payload script tag is written just above, IN SOURCE ORDER,
  // deliberately before this script: a browser parses and inserts each
  // <script> as it's encountered, so by the time this one executes,
  // #econ-data is already in the DOM for getElementById to find.
  var dataEl = document.getElementById("econ-data");
  if (!dataEl) { return; }
  var payload;
  try { payload = JSON.parse(dataEl.textContent); } catch (e) { return; }

  {{template "econ_maths_js" .}}

  function recompute() {
    var sc = readScenarioFromDOM(payload.scenario);
    setText("margin-multiple", marginMultiple(sc.margin));

    var boxResults = {};
    var totalAllocated = {};
    Object.keys(payload.boxLoads).forEach(function (box) {
      var alloc = allocateBox(sc.rate_card, sc.allocation, payload.boxLoads[box]);
      boxResults[box] = alloc;
      Object.keys(alloc.perAccount).forEach(function (acct) {
        totalAllocated[acct] = (totalAllocated[acct] || 0) + alloc.perAccount[acct];
      });
    });

    var acctSet = {};
    Object.keys(payload.meters).forEach(function (a) { acctSet[a] = true; });
    Object.keys(totalAllocated).forEach(function (a) { acctSet[a] = true; });
    var tiers = payload.tiers || {};
    var accounts = {};
    Object.keys(acctSet).forEach(function (acct) {
      var a = priceAccount(sc, acct, payload.meters[acct] || {}, totalAllocated[acct] || 0);
      // Tier-aware view-layer override (economics-v2 Task 5/Task 6),
      // applied AFTER priceAccount exactly like buildEconomicsView applies
      // it after PriceAccount: a pool/try/""-tier account's revenue is
      // pooled, not individually priced, so a knob tweak must never flip a
      // pooled row back to priced by recomputing it "inside" the free tier.
      if (isPoolTier(tierOf(tiers, acct))) {
        a.revenueUSD = 0;
        a.marginFrac = 0;
        a.freeTierPos = "pooled";
      }
      accounts[acct] = a;
    });

    var revenueTotal = 0, acctCostTotal = 0, idleTotal = 0;
    Object.keys(accounts).forEach(function (a) {
      revenueTotal += accounts[a].revenueUSD;
      acctCostTotal += accounts[a].costUSD;
    });
    Object.keys(boxResults).forEach(function (b) { idleTotal += boxResults[b].idleUSD; });
    var overheadTotal = overheadUSD(sc, payload.periodDays);
    var costTotal = acctCostTotal + idleTotal + overheadTotal;
    var profitTotal = revenueTotal - costTotal;
    var marginTotal = revenueTotal > 0 ? profitTotal / revenueTotal : 0;

    setText("tile-revenue", usd(revenueTotal));
    setText("tile-cost", usd(costTotal));
    setText("tile-profit", usd(profitTotal));
    setText("tile-margin", pctf(marginTotal));

    {{/* The three lines below are wrapped in a Go template (not just
         JS) "mtd" check, deliberately: setText's own `if (el)` guard would
         already no-op on a period that never rendered the element, but
         leaving the literal word live in every period's JS source would
         defeat the honesty rule (a non-mtd page must not carry the word
         at all, not merely fail to display it) — see
         TestEconomicsPageMTDShowsProjection. */}}
    {{if eq .Economics.Period "mtd"}}
    setText("tile-revenue-projected", "projected " + usd(project(revenueTotal, payload.coveredDays, payload.daysInMonth)) + " for the month");
    setText("tile-cost-projected", "projected " + usd(project(costTotal, payload.coveredDays, payload.daysInMonth)) + " for the month");
    setText("tile-profit-projected", "projected " + usd(project(profitTotal, payload.coveredDays, payload.daysInMonth)) + " for the month");
    {{end}}

    document.querySelectorAll("[data-account]").forEach(function (row) {
      var a = accounts[row.getAttribute("data-account")];
      if (!a) { return; }
      setCellText(row, ".js-acct-cost", usd(a.costUSD));
      setCellText(row, ".js-acct-revenue", usd(a.revenueUSD));
      setCellText(row, ".js-acct-margin", marginCell(a.marginFrac, a.freeTierPos));
      setCellText(row, ".js-acct-freetier", a.freeTierPos);
    });

    // Fleet pool tile (Task 6): recomputed from the SAME accounts map the
    // account rows above just used, so a knob tweak (revenue_frac,
    // topup_usd, or anything upstream of an account's own revenue/cost)
    // keeps the tile in lockstep with the account table on screen.
    var pool = poolLedger(sc, tiers, accounts);
    setText("tile-pool-usd", usd(pool.poolUSD));
    setText("tile-pool-draw", usd(pool.drawUSD));
    var poolHeadroomEl = document.getElementById("tile-pool-headroom");
    if (poolHeadroomEl) {
      poolHeadroomEl.textContent = usd(pool.headroomUSD);
      poolHeadroomEl.classList.toggle("error", pool.headroomUSD < 0);
    }

    document.querySelectorAll("[data-box]").forEach(function (row) {
      var box = row.getAttribute("data-box");
      var load = payload.boxLoads[box];
      var alloc = boxResults[box];
      if (!load || !alloc) { return; }
      var revenue = 0;
      Object.keys(alloc.perAccount).forEach(function (acct) {
        var total = totalAllocated[acct];
        if (!total) { return; }
        var share = alloc.perAccount[acct] / total;
        revenue += (accounts[acct] ? accounts[acct].revenueUSD : 0) * share;
      });
      var util = alloc.totalUSD > 0 ? 1 - alloc.idleUSD / alloc.totalUSD : 0;
      setCellText(row, ".js-hours", load.hours.toFixed(2));
      setCellText(row, ".js-cost", usd(alloc.totalUSD));
      setCellText(row, ".js-idle", usd(alloc.idleUSD));
      setCellText(row, ".js-util-pct", pctf(util));
      var fill = row.querySelector(".bar-fill");
      if (fill) { fill.style.width = Math.round(util * 100) + "%"; }
      setCellText(row, ".js-revenue", usd(revenue));
      setCellText(row, ".js-profit", usd(revenue - alloc.totalUSD));
    });

    var ec2 = 0, ebs = 0;
    Object.keys(payload.boxLoads).forEach(function (box) {
      var load = payload.boxLoads[box];
      var spec = getBoxSpec(sc.rate_card, box);
      ec2 += spec.hour_usd * load.hours;
      ebs += spec.ebs_gb * sc.rate_card.ebs_gb_month_usd * (load.hours / HOURS_PER_MONTH);
    });
    var s3storage = sumMeter(payload.meters, "storage_gb_month") * sc.rate_card.storage_gb_month_usd;
    var s3requests = sumMeter(payload.meters, "requests_1k") * sc.rate_card.requests_per_1k_usd;
    var egress = sumMeter(payload.meters, "egress_gb") * sc.rate_card.egress_gb_usd;
    var backhaul = sumMeter(payload.meters, "backhaul_gb") * (sc.rate_card.inter_region_gb_usd || 0);
    var modelTotal = ec2 + ebs + s3storage + s3requests + egress + backhaul + overheadTotal;
    setText("model-ec2", usd(ec2));
    setText("model-ebs", usd(ebs));
    setText("model-s3-storage", usd(s3storage));
    setText("model-s3-requests", usd(s3requests));
    setText("model-egress", usd(egress));
    setText("model-backhaul", usd(backhaul));
    setText("model-overheads", usd(overheadTotal));
    setText("model-total", usd(modelTotal));

    var billTotalEl = document.getElementById("bill-total-checked");
    if (billTotalEl) {
      var billTotal = 0;
      document.querySelectorAll(".bill-service-checkbox").forEach(function (el) {
        if (el.checked) { billTotal += parseFloat(el.getAttribute("data-amount")) || 0; }
      });
      billTotalEl.textContent = usd(billTotal);
      setText("breakdown-delta", usd(billTotal - modelTotal));
    }

    var field = document.getElementById("scenario-json-field");
    if (field) { field.value = JSON.stringify(sc); }
  }

  var live = document.getElementById("econ-live");
  if (live) {
    live.addEventListener("input", recompute);
    live.addEventListener("change", recompute);
  }
})();
</script>
{{template "bottom" .}}{{end}}

{{/* econ_knob_drawer: the "Pricing knobs" <details> — every rate-card,
     allocation, mode/margin, rate-sheet and free-tier input, plus the
     save-as-scenario form. Shared verbatim between /fleet/economics (Task
     13) and /fleet/economics/accounts (Task 14): both pages price the
     SAME EconomicsView.Scenario, so one set of knob markup and one
     save-scenario door (POST /fleet/economics/scenarios, which always
     redirects to /fleet/economics regardless of which page submitted it —
     see handleEconomicsScenarioSave) serves both. Takes the whole page `.`
     — reads .Economics.Scenario and .CSRF, exactly as when this was inline
     in "economics". */}}
{{define "econ_knob_drawer"}}
<details class="reveal" id="knob-drawer">
<summary>Pricing knobs</summary>

<h3>Rate card &mdash; boxes</h3>
<div class="tablewrap">
<table>
  <tr><th>Box</th><th>$/hour</th><th>Cores</th><th>Mem GB</th><th>EBS GB</th></tr>
  {{range $boxKey, $spec := .Economics.Scenario.RateCard.Boxes}}
  <tr>
    <td>{{if eq $boxKey ""}}default{{else}}{{$boxKey}}{{end}}</td>
    <td><input type="number" step="0.0001" min="0" data-box-key="{{$boxKey}}" data-field="hour_usd" value="{{$spec.HourUSD}}"></td>
    <td><input type="number" step="0.1" min="0" data-box-key="{{$boxKey}}" data-field="cores" value="{{$spec.Cores}}"></td>
    <td><input type="number" step="0.1" min="0" data-box-key="{{$boxKey}}" data-field="mem_gb" value="{{$spec.MemGB}}"></td>
    <td><input type="number" step="1" min="0" data-box-key="{{$boxKey}}" data-field="ebs_gb" value="{{$spec.EBSGB}}"></td>
  </tr>
  {{end}}
</table>
</div>

<h3>Rate card &mdash; storage &amp; transfer</h3>
<div class="knob-row"><label for="knob-ebs-gb-month-usd">EBS $/GB-month</label><input type="number" step="0.001" min="0" id="knob-ebs-gb-month-usd" value="{{.Economics.Scenario.RateCard.EBSGBMonthUSD}}"></div>
<div class="knob-row"><label for="knob-storage-gb-month-usd">S3 storage $/GB-month</label><input type="number" step="0.001" min="0" id="knob-storage-gb-month-usd" value="{{.Economics.Scenario.RateCard.StorageGBMonthUSD}}"></div>
<div class="knob-row"><label for="knob-requests-per-1k-usd">S3 requests $/1k</label><input type="number" step="0.001" min="0" id="knob-requests-per-1k-usd" value="{{.Economics.Scenario.RateCard.RequestsPer1kUSD}}"></div>
<div class="knob-row"><label for="knob-egress-gb-usd">Egress $/GB</label><input type="number" step="0.001" min="0" id="knob-egress-gb-usd" value="{{.Economics.Scenario.RateCard.EgressGBUSD}}"></div>
<div class="knob-row"><label for="knob-inter-region-gb-usd">Inter-region $/GB (backhaul leg)</label><input type="number" step="0.001" min="0" id="knob-inter-region-gb-usd" value="{{.Economics.Scenario.RateCard.InterRegionGBUSD}}"></div>

<h3>Overheads</h3>
<div class="tablewrap">
<table>
  <tr><th>Line item</th><th>$/month</th></tr>
  {{range $i, $li := .Economics.Scenario.RateCard.Overheads}}
  <tr><td>{{$li.Name}}</td><td><input type="number" step="0.01" min="0" class="knob-overhead" data-index="{{$i}}" value="{{$li.USDMonth}}"></td></tr>
  {{end}}
</table>
</div>

<h3>Allocation</h3>
<div class="knob-row">
  <label>Policy</label>
  <label><input type="radio" name="alloc-policy" value="cpu"{{if eq .Economics.Scenario.Allocation.Policy "cpu"}} checked{{end}}> CPU</label>
  <label><input type="radio" name="alloc-policy" value="mem"{{if eq .Economics.Scenario.Allocation.Policy "mem"}} checked{{end}}> Memory</label>
  <label><input type="radio" name="alloc-policy" value="blend"{{if eq .Economics.Scenario.Allocation.Policy "blend"}} checked{{end}}> Blend</label>
</div>
<div class="knob-row"><label for="knob-cpu-weight">Blend CPU weight</label><input type="number" step="0.05" min="0" max="1" id="knob-cpu-weight" value="{{.Economics.Scenario.Allocation.CPUWeight}}"></div>

<h3>Mode &amp; margin</h3>
<div class="knob-row">
  <label>Pricing mode</label>
  <label><input type="radio" name="mode" value="cost-plus"{{if eq .Economics.Scenario.Mode "cost-plus"}} checked{{end}}> Cost-plus</label>
  <label><input type="radio" name="mode" value="rate-sheet"{{if eq .Economics.Scenario.Mode "rate-sheet"}} checked{{end}}> Rate sheet</label>
</div>
<div class="knob-row">
  <label for="knob-margin">Margin (cost-plus)</label>
  <input type="range" id="knob-margin" min="0" max="0.95" step="0.01" value="{{.Economics.Scenario.Margin}}">
  <span id="margin-multiple">{{marginMultiple .Economics.Scenario.Margin}}</span>
</div>

<h3>Rate sheet</h3>
<div class="knob-row"><label for="knob-sheet-app-month-usd">$/app-month</label><input type="number" step="0.01" min="0" id="knob-sheet-app-month-usd" value="{{.Economics.Scenario.Sheet.AppMonthUSD}}"></div>
<div class="knob-row"><label for="knob-sheet-egress-gb-usd">$/GB egress</label><input type="number" step="0.01" min="0" id="knob-sheet-egress-gb-usd" value="{{.Economics.Scenario.Sheet.EgressGBUSD}}"></div>
<div class="knob-row"><label for="knob-sheet-storage-gb-month-usd">$/GB-month storage</label><input type="number" step="0.01" min="0" id="knob-sheet-storage-gb-month-usd" value="{{.Economics.Scenario.Sheet.StorageGBMonthUSD}}"></div>
<div class="knob-row"><label for="knob-sheet-instance-hour-usd">$/instance-hour</label><input type="number" step="0.001" min="0" id="knob-sheet-instance-hour-usd" value="{{.Economics.Scenario.Sheet.InstanceHourUSD}}"></div>
{{/* economics-v2 (Task 6): fleet box + mem-overage rate-sheet knobs — the
     same three RateSheet fields compute.go's PriceAccount reads under
     fleetRevenue and the rate-sheet mem-overage term, both modes. */}}
<div class="knob-row"><label for="knob-sheet-box-month-server-usd">$/box-month (server)</label><input type="number" step="0.01" min="0" id="knob-sheet-box-month-server-usd" value="{{.Economics.Scenario.Sheet.BoxMonthServerUSD}}"></div>
<div class="knob-row"><label for="knob-sheet-box-month-device-usd">$/box-month (device)</label><input type="number" step="0.01" min="0" id="knob-sheet-box-month-device-usd" value="{{.Economics.Scenario.Sheet.BoxMonthDeviceUSD}}"></div>
<div class="knob-row"><label for="knob-sheet-mem-gb-hour-usd">$/GB-hour mem overage (rate-sheet)</label><input type="number" step="0.001" min="0" id="knob-sheet-mem-gb-hour-usd" value="{{.Economics.Scenario.Sheet.MemGBHourUSD}}"></div>

<h3>Fleet volume break</h3>
<div class="knob-row"><label for="knob-fleet-break-min-boxes">Min avg boxes/month</label><input type="number" step="0.1" min="0" id="knob-fleet-break-min-boxes" value="{{.Economics.Scenario.FleetBreak.MinBoxes}}"></div>
<div class="knob-row"><label for="knob-fleet-break-discount">Discount at/above min</label><input type="number" step="0.01" min="0" max="0.99" id="knob-fleet-break-discount" value="{{.Economics.Scenario.FleetBreak.Discount}}"></div>

<h3>Fleet pool</h3>
<div class="knob-row"><label for="knob-pool-revenue-frac">Revenue share to pool</label><input type="number" step="0.01" min="0" max="1" id="knob-pool-revenue-frac" value="{{.Economics.Scenario.Pool.RevenueFrac}}"></div>
<div class="knob-row"><label for="knob-pool-topup-usd">Monthly top-up $</label><input type="number" step="0.01" min="0" id="knob-pool-topup-usd" value="{{.Economics.Scenario.Pool.TopupUSD}}"></div>

<h3>Free tier</h3>
<div class="knob-row"><label for="knob-ft-apps">Apps</label><input type="number" step="1" min="0" id="knob-ft-apps" value="{{.Economics.Scenario.FreeTier.Apps}}"></div>
<div class="knob-row"><label for="knob-ft-egress-gb">Egress GB</label><input type="number" step="1" min="0" id="knob-ft-egress-gb" value="{{.Economics.Scenario.FreeTier.EgressGB}}"></div>
<div class="knob-row"><label for="knob-ft-mem-gb-hours">Mem GB-hours</label><input type="number" step="1" min="0" id="knob-ft-mem-gb-hours" value="{{.Economics.Scenario.FreeTier.MemGBHours}}"></div>
<div class="knob-row"><label for="knob-ft-storage-gb">Storage GB</label><input type="number" step="1" min="0" id="knob-ft-storage-gb" value="{{.Economics.Scenario.FreeTier.StorageGB}}"></div>

<h3>Save as scenario</h3>
<p class="small">With JavaScript on, this saves the knobs above exactly as tweaked. With it off, this round-trips the currently active scenario unchanged, under a new name and/or activated. Saving from either page lands back on the dashboard (/fleet/economics) — the one save door both pages share.</p>
<form method="post" action="/fleet/economics/scenarios">
  <input type="hidden" name="csrf" value="{{.CSRF}}">
  <input type="hidden" name="scenario" id="scenario-json-field" value="{{scenarioJSON .Economics.Scenario}}">
  <div class="knob-row">
    <label for="scenario-name">Name</label>
    <input type="text" id="scenario-name" name="name" pattern="[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?" required>
  </div>
  <label><input type="checkbox" name="activate" value="1"> Activate</label>
  <button type="submit">Save scenario</button>
  {{/* Hidden by default; the inline script shows it (display:"") exactly
       when every "counts as CARLOS" checkbox is unchecked — the state the
       save field refuses to persist (see the template comment by the bill
       table). Only /fleet/economics ever has bill checkboxes on screen, so
       this note only ever becomes visible there — but the element must
       exist on both pages: setBillServicesZeroNote (econ_maths_js) looks
       it up by id and simply no-ops via its `if (el)` guard when absent. */}}
  <p class="small error" id="bill-services-zero-note" style="display:none">At least one service must count — unchecking all shows a zero model line but is not saveable as a selection.</p>
</form>
</details>
{{end}}

{{/* econ_maths_js: every pure (no page-specific DOM target) function the
     knob-recompute scripts need — economics.AllocateBox/PriceAccount
     transliterated, plus the small DOM/formatting helpers and
     readScenarioFromDOM, which reads the econ_knob_drawer inputs back into
     a live-edited Scenario. Emits BARE JavaScript, no <script> tags and no
     wrapping IIFE of its own: each including page's own <script> already
     opens one (see "economics" above and economics_accounts.html), and a
     template action splices this in as plain text at that point — so every
     function/var here shares that ONE enclosing scope with the
     including page's own dataEl/payload preamble and its own recompute().
     Takes `.` for template-call symmetry with econ_knob_drawer; nothing
     inside reads it (this block is pure JS, no Go value substitution). */}}
{{define "econ_maths_js"}}
  // lastNonEmptyBillServices remembers the most recent "counts as CARLOS"
  // selection that had at least one box checked, seeded from the scenario
  // the page loaded with — readScenarioFromDOM's zero-checked branch reads
  // this instead of ever serializing an empty (== "count everything",
  // the opposite meaning) selection. null until either the loaded scenario
  // or this session has seen a non-empty selection. Only /fleet/economics
  // ever has bill checkboxes to derive this from; on a page with none, the
  // branch that would update it never runs, and this stays whatever the
  // loaded scenario seeded it to.
  var lastNonEmptyBillServices = (payload.scenario.bill_services && payload.scenario.bill_services.length > 0)
    ? payload.scenario.bill_services
    : null;
  function setBillServicesZeroNote(show) {
    var el = document.getElementById("bill-services-zero-note");
    if (el) { el.style.display = show ? "" : "none"; }
  }

  // HoursPerMonth mirrors internal/economics/compute.go's exported constant
  // of the same name — the proration every hour-denominated rate uses to
  // read against a GB-month figure.
  var HOURS_PER_MONTH = 730;

  function numVal(id) {
    var el = document.getElementById(id);
    if (!el) { return 0; }
    var v = parseFloat(el.value);
    return isNaN(v) ? 0 : v;
  }
  function radioVal(name) {
    var el = document.querySelector('input[name="' + name + '"]:checked');
    return el ? el.value : "";
  }
  function setText(id, text) {
    var el = document.getElementById(id);
    if (el) { el.textContent = text; }
  }
  function setCellText(row, sel, text) {
    var el = row.querySelector(sel);
    if (el) { el.textContent = text; }
  }

  // usd/pctf/marginMultiple are the JS twins of the same-named template
  // funcs (server.go) — same rounding, same sign handling, so a knob change
  // never disagrees with the page's own initial render in HOW a number is
  // shown, only in what the number IS.
  function usd(v) {
    if (isNaN(v) || !isFinite(v)) { return "—"; }
    var neg = v < 0;
    if (neg) { v = -v; }
    var s = "$" + v.toFixed(2);
    return neg ? "-" + s : s;
  }
  function pctf(v) { return Math.round(v * 100) + "%"; }
  // project is economics.Project (compute.go) transliterated: scale a
  // month-to-date figure to covered/period days, 0 when nothing has been
  // covered yet (never a divide-by-zero NaN). recompute() only calls this
  // on the one period whose tiles carry a second, scaled-up line at all —
  // see that call site's own template guard.
  function project(mtd, covered, days) {
    if (covered <= 0) { return 0; }
    return mtd * days / covered;
  }
  function marginMultiple(margin) {
    if (margin < 0 || margin >= 1) { return "—"; }
    return (1 / (1 - margin)).toFixed(1) + "×";
  }

  // getBoxSpec mirrors AllocateBox's own box-then-default lookup
  // (compute.go: rc.Boxes[b.Box], falling back to rc.Boxes[""]).
  function getBoxSpec(rateCard, box) {
    var boxes = rateCard.boxes || {};
    return boxes[box] || boxes[""] || {hour_usd: 0, cores: 0, mem_gb: 0, ebs_gb: 0};
  }

  // billable mirrors compute.go's billable: a meter reading minus its free-
  // tier allowance, floored at zero.
  function billable(meters, meter, allowance) {
    var v = (meters[meter] || 0) - allowance;
    return v < 0 ? 0 : v;
  }

  // allocateBox is economics.AllocateBox transliterated: same three
  // returns (perAccount, idleUSD, totalUSD), same policy switch, same
  // early return for a box with zero metered hours (100% idle, nothing to
  // allocate — AllocateBox's own comment on that branch applies here
  // unchanged).
  function allocateBox(rateCard, allocation, boxLoad) {
    var spec = getBoxSpec(rateCard, boxLoad.box);
    var totalUSD = spec.hour_usd * boxLoad.hours + spec.ebs_gb * rateCard.ebs_gb_month_usd * (boxLoad.hours / HOURS_PER_MONTH);
    var perAccount = {};
    if (boxLoad.hours <= 0) {
      return {perAccount: perAccount, idleUSD: totalUSD, totalUSD: totalUSD};
    }
    var allocated = 0;
    var byAccount = boxLoad.by_account || {};
    Object.keys(byAccount).forEach(function (acct) {
      var load = byAccount[acct];
      var cpuShare = 0, memShare = 0;
      if (spec.cores > 0) { cpuShare = load.cpu_core_hours / (spec.cores * boxLoad.hours); }
      if (spec.mem_gb > 0) { memShare = load.mem_gb_hours / (spec.mem_gb * boxLoad.hours); }
      var share;
      if (allocation.policy === "cpu") { share = cpuShare; }
      else if (allocation.policy === "mem") { share = memShare; }
      else { share = allocation.cpu_weight * cpuShare + (1 - allocation.cpu_weight) * memShare; }
      var usdShare = share * totalUSD;
      perAccount[acct] = usdShare;
      allocated += usdShare;
    });
    var idleUSD = totalUSD - allocated;
    if (idleUSD < 0) { idleUSD = 0; }
    return {perAccount: perAccount, idleUSD: idleUSD, totalUSD: totalUSD};
  }

  // priceAccount is economics.PriceAccount transliterated: same cost/
  // revenue/margin/freeTierPos formulas, same cost-plus vs rate-sheet
  // branch on sc.mode.
  function priceAccount(sc, account, meters, allocatedUSD) {
    var rc = sc.rate_card;
    var cost = allocatedUSD +
      (meters.egress_gb || 0) * rc.egress_gb_usd +
      (meters.requests_1k || 0) * rc.requests_per_1k_usd +
      (meters.storage_gb_month || 0) * rc.storage_gb_month_usd;

    var ft = sc.free_tier;
    var bEgress = billable(meters, "egress_gb", ft.egress_gb);
    var bStorage = billable(meters, "storage_gb_month", ft.storage_gb);
    var bApps = billable(meters, "app_months", ft.apps);
    var bMem = billable(meters, "mem_gb_hours", ft.mem_gb_hours);
    var computeFrac = 1.0;
    var m = meters.mem_gb_hours || 0;
    if (m > 0) { computeFrac = bMem / m; }

    var revenue;
    if (sc.mode === "rate-sheet") {
      revenue = bApps * sc.sheet.app_month_usd +
        bEgress * sc.sheet.egress_gb_usd +
        bStorage * sc.sheet.storage_gb_month_usd +
        (meters.instance_hours || 0) * sc.sheet.instance_hour_usd +
        // Mem overage, rate-sheet mode only — the SAME bMem binding used
        // above for computeFrac and the clipped check below, per
        // compute.go's PriceAccount (economics-v2 Task 2/Task 6).
        bMem * sc.sheet.mem_gb_hour_usd;
    } else { // cost-plus
      var billableCost = allocatedUSD * computeFrac +
        bEgress * rc.egress_gb_usd +
        (meters.requests_1k || 0) * rc.requests_per_1k_usd +
        bStorage * rc.storage_gb_month_usd;
      revenue = billableCost / (1 - sc.margin);
    }

    // Fleet box revenue (both modes) — economics-v2 (Task 2/Task 6),
    // compute.go's PriceAccount transliterated verbatim: the fleet term
    // sits OUTSIDE the cost-plus/rate-sheet branch above, meter reads
    // guarded against undefined (an account with no fleet usage never
    // wrote these keys), volume break applied only when a floor is set AND
    // cleared.
    var fleetRevenue = ((meters.fleet_box_hours_server || 0) / HOURS_PER_MONTH) * sc.sheet.box_month_server_usd +
      ((meters.fleet_box_hours_device || 0) / HOURS_PER_MONTH) * sc.sheet.box_month_device_usd;
    var avgBoxes = ((meters.fleet_box_hours_server || 0) + (meters.fleet_box_hours_device || 0)) / HOURS_PER_MONTH;
    if (sc.fleet_break.min_boxes > 0 && avgBoxes >= sc.fleet_break.min_boxes) {
      fleetRevenue *= (1 - sc.fleet_break.discount);
    }
    revenue += fleetRevenue;

    var margin = 0;
    if (revenue > 0) { margin = (revenue - cost) / revenue; }

    var anyUsage = false;
    Object.keys(meters).forEach(function (k) {
      if (k === "backhaul_gb" || k === "backhaul_requests_1k") { return; } // data, not usage (#288)
      if (meters[k] > 0) { anyUsage = true; }
    });
    var clipped = bEgress < (meters.egress_gb || 0) ||
      bStorage < (meters.storage_gb_month || 0) ||
      bApps < (meters.app_months || 0) ||
      bMem < (meters.mem_gb_hours || 0);
    var pos = "paying";
    if (revenue === 0 && anyUsage) { pos = "inside"; }
    else if (clipped) { pos = "partial"; }

    return {account: account, costUSD: cost, revenueUSD: revenue, marginFrac: margin, freeTierPos: pos};
  }

  // tierOf/isPoolTier mirror economicsview.go's same-named functions
  // (economics-v2 Task 5/Task 6): "" — whether from an explicit blank tier
  // or the account simply being absent from payload.tiers entirely (a
  // fleet-only account whose owner never signed up) — is pool semantics,
  // same as the explicit "try" and "pool" tiers.
  function tierOf(tiers, acct) {
    return tiers[acct] || "";
  }
  function isPoolTier(tier) {
    return tier === "" || tier === "try" || tier === "pool";
  }

  // marginCell is the JS twin of server.go's "marginCell" template func: an
  // em-dash for a pooled row, never "0%" — see that func's doc comment.
  function marginCell(frac, pos) {
    return pos === "pooled" ? "—" : pctf(frac);
  }

  // poolLedger mirrors buildEconomicsView's PoolLedger construction
  // (economicsview.go, economics-v2 Task 5/Task 6): paying revenue sums
  // every non-pool-tier row's revenue, draw sums every pool-tier row's
  // cost, and the topup term is payload.poolTopupUnitAccrual (the
  // dimensionless Σ 1/daysInMonth(d) the server accrued this period —
  // see economicsPayload's doc comment) times the CURRENT topup_usd knob,
  // reproducing poolTopupAccrual exactly under any knob value without
  // re-deriving the per-day sum client-side. `rows` is the accounts map
  // this page's recompute() already built (account -> priceAccount's
  // result, AFTER the tier override below has been applied) — its
  // revenueUSD is already 0 for a pool-tier row, but this still checks the
  // tier explicitly for draw/paying-revenue attribution, exactly like the
  // Go it mirrors, rather than relying on that zero.
  function poolLedger(sc, tiers, rows) {
    var payingRevenue = 0, poolDraw = 0;
    Object.keys(rows).forEach(function (acct) {
      var r = rows[acct];
      if (isPoolTier(tierOf(tiers, acct))) {
        poolDraw += r.costUSD;
      } else {
        payingRevenue += r.revenueUSD;
      }
    });
    var poolUSD = sc.pool.revenue_frac * payingRevenue + sc.pool.topup_usd * payload.poolTopupUnitAccrual;
    return {poolUSD: poolUSD, drawUSD: poolDraw, headroomUSD: poolUSD - poolDraw, payingRevenueUSD: payingRevenue};
  }

  // overheadUSD mirrors the server.go template func of the same name: the
  // rate card's fixed monthly line items, prorated over the period by
  // periodDays, not coveredDays (see that func's doc comment for why).
  function overheadUSD(sc, periodDays) {
    var monthly = 0;
    (sc.rate_card.overheads || []).forEach(function (li) { monthly += li.usd_month; });
    return monthly * periodDays * 24 / HOURS_PER_MONTH;
  }

  // sumMeter mirrors the server.go template func: one named meter, summed
  // across every account in the payload's "meters" map.
  function sumMeter(meters, meter) {
    var sum = 0;
    Object.keys(meters).forEach(function (a) { sum += (meters[a][meter] || 0); });
    return sum;
  }

  // billServiceChecked is the SAME "counts as CARLOS" default rule as the
  // server.go template func of the same name — see economics.html's
  // template comment by the bill table for the reasoning, one sentence of
  // which applies here unchanged: keep it in exactly one place per side
  // (Go, JS), never re-derive it.
  function billServiceChecked(billServices, service) {
    if (!billServices || billServices.length === 0) { return true; }
    return billServices.indexOf(service) !== -1;
  }

  // readScenarioFromDOM clones the payload's starting scenario (so any
  // field this page has no knob for — Schema, Name — survives untouched)
  // and overwrites every field the drawer DOES expose from its current
  // input values, plus bill_services from the checkbox row. Reading the
  // WHOLE scenario back out on every change, rather than patching one
  // field, keeps this the single place that must agree with every input's
  // id/data-* attribute — the same "one source of truth" reasoning as
  // billServiceChecked above.
  function readScenarioFromDOM(base) {
    var sc = JSON.parse(JSON.stringify(base));
    sc.rate_card.boxes = sc.rate_card.boxes || {};
    document.querySelectorAll("[data-box-key]").forEach(function (el) {
      var key = el.getAttribute("data-box-key");
      var field = el.getAttribute("data-field");
      if (!sc.rate_card.boxes[key]) { sc.rate_card.boxes[key] = {}; }
      sc.rate_card.boxes[key][field] = parseFloat(el.value) || 0;
    });
    sc.rate_card.ebs_gb_month_usd = numVal("knob-ebs-gb-month-usd");
    sc.rate_card.storage_gb_month_usd = numVal("knob-storage-gb-month-usd");
    sc.rate_card.requests_per_1k_usd = numVal("knob-requests-per-1k-usd");
    sc.rate_card.egress_gb_usd = numVal("knob-egress-gb-usd");
    sc.rate_card.inter_region_gb_usd = numVal("knob-inter-region-gb-usd");
    document.querySelectorAll(".knob-overhead").forEach(function (el) {
      var i = parseInt(el.getAttribute("data-index"), 10);
      if (sc.rate_card.overheads && sc.rate_card.overheads[i]) {
        sc.rate_card.overheads[i].usd_month = parseFloat(el.value) || 0;
      }
    });
    sc.allocation.policy = radioVal("alloc-policy") || sc.allocation.policy;
    sc.allocation.cpu_weight = numVal("knob-cpu-weight");
    sc.mode = radioVal("mode") || sc.mode;
    sc.margin = numVal("knob-margin");
    sc.sheet.app_month_usd = numVal("knob-sheet-app-month-usd");
    sc.sheet.egress_gb_usd = numVal("knob-sheet-egress-gb-usd");
    sc.sheet.storage_gb_month_usd = numVal("knob-sheet-storage-gb-month-usd");
    sc.sheet.instance_hour_usd = numVal("knob-sheet-instance-hour-usd");
    // economics-v2 (Task 6): the seven new knobs, read back exactly like
    // every knob above — one place, matching the drawer's ids one-to-one.
    sc.sheet.box_month_server_usd = numVal("knob-sheet-box-month-server-usd");
    sc.sheet.box_month_device_usd = numVal("knob-sheet-box-month-device-usd");
    sc.sheet.mem_gb_hour_usd = numVal("knob-sheet-mem-gb-hour-usd");
    sc.fleet_break.min_boxes = numVal("knob-fleet-break-min-boxes");
    sc.fleet_break.discount = numVal("knob-fleet-break-discount");
    sc.pool.revenue_frac = numVal("knob-pool-revenue-frac");
    sc.pool.topup_usd = numVal("knob-pool-topup-usd");
    sc.free_tier.apps = numVal("knob-ft-apps");
    sc.free_tier.egress_gb = numVal("knob-ft-egress-gb");
    sc.free_tier.mem_gb_hours = numVal("knob-ft-mem-gb-hours");
    sc.free_tier.storage_gb = numVal("knob-ft-storage-gb");

    // See the template comment by the bill table (the two corollaries
    // block) for both rules enforced below.
    var boxes = document.querySelectorAll(".bill-service-checkbox");
    if (boxes.length > 0) {
      var checked = [];
      boxes.forEach(function (el) { if (el.checked) { checked.push(el.getAttribute("data-service")); } });
      if (checked.length > 0) {
        // Empty means "every service counts" (billServiceChecked's
        // default) — so leaving every box checked writes [] back, not an
        // equivalent, brittle explicit list of every service name on the
        // bill.
        sc.bill_services = checked.length < boxes.length ? checked : [];
        lastNonEmptyBillServices = sc.bill_services;
        setBillServicesZeroNote(false);
      } else {
        // All unchecked: "count zero services" is not a representable
        // reconciliation state (empty already means "count everything",
        // the opposite meaning). Keep the save field at the last
        // selection that had at least one box checked this session, or —
        // if the operator hasn't touched a checkbox yet — the base
        // scenario's own saved list, either way never [].  The live
        // model/bill numbers on screen may still show the all-unchecked
        // $0 total; only the SAVED state declines to represent it, which
        // is why the note below exists.
        sc.bill_services = lastNonEmptyBillServices !== null ? lastNonEmptyBillServices : sc.bill_services;
        setBillServicesZeroNote(true);
      }
    }
    // boxes.length === 0: no bill is on screen for this period, so there
    // is nothing to derive a selection from — sc.bill_services stays
    // exactly what the clone of base already carries, untouched. Without
    // this early-out, a keystroke in the unrelated manual-bill-entry form
    // (inside the same #econ-live listener scope) would fire recompute()
    // and clobber a reconciliation selection made against a DIFFERENT
    // period's bill into [] — the fix-round finding this whole branch
    // exists for. On /fleet/economics/accounts, which has no bill-entry
    // form at all, boxes.length is always 0, so this branch never runs.
    return sc;
  }
{{end}}