/* eslint-disable */
/* © 2026 K2B NETWORK SOLUTIONS LLC. All rights reserved.
   Proprietary and confidential. Unauthorized copying, distribution, or use of
   this file, via any medium, is strictly prohibited. Original work product. */
// RC36 (lane fpd36) — FLOORPLAN RECONCILIATION. The owner (10/29): "the floorplan needs to reconcile with the inventory floored".
//   window.FloorplanRecon  Accounting › Floorplan: the floored units in stock (amount, lender, floor date, curtailments) + the sold units
//                          whose payoff is owed, per floorplan account next to the books (310 / 314 …) with the difference and what it most
//                          likely means; the lender's statement compared unit by unit (missing from the statement, not in stock / sold
//                          — payoff owed: Pay Off ▸ (the RC33 payoff command), amount differences); the units in stock NOT floored (cash in
//                          inventory) — "Take the floored amounts from the statement" (a server command, no entry) for the ones the lender lists.
//   window.FpReviewTie     the same tie-out on an import's review (Inventory / Floorplan statement parts — the server answers run.floorplan).
// Reads GET /api/floorplan/reconcile (the ACTIVE store only). Every amount is integer cents from the server; nothing is added up in dollars here.
(function () {
  const D = () => window.DMS;
  const m$ = (c) => { const n = Math.round(+c || 0); const neg = n < 0; const a = Math.abs(n); return (neg ? "-$" : "$") + Math.floor(a / 100).toLocaleString("en-US") + "." + String(a % 100).padStart(2, "0"); };
  const errText = (e) => (e && e.body && e.body.error) || (e && e.message) || "The server did not answer.";
  const useNarrow = () => { const [n, setN] = React.useState(typeof window !== "undefined" && window.innerWidth < 720); React.useEffect(() => { const f = () => setN(window.innerWidth < 720); window.addEventListener("resize", f); return () => window.removeEventListener("resize", f); }, []); return n; };
  const box = { background: "#FFF", border: "1px solid var(--jb-border, #D5DCE3)", borderRadius: 8 };
  const cell = { padding: "5px 8px", borderTop: "1px solid #EEF1F4", fontSize: 12, verticalAlign: "top" };
  const hcell = { padding: "5px 8px", fontSize: 11, textAlign: "left", color: "#555", fontWeight: 700, background: "#F4F6F8", whiteSpace: "nowrap" };
  const num = { textAlign: "right", fontFamily: "var(--jb-mono, monospace)", whiteSpace: "nowrap" };

  /** a list as a table on a laptop, as stacked cards on a phone (no sideways scrolling) */
  function FpList({ rows, cols, narrow, testid, empty, rowKey, extra }) {
    if (!rows || !rows.length) return <div style={{ color: "#777", fontSize: 12, padding: "4px 2px" }}>{empty || "None."}</div>;
    if (narrow) return (
      <div data-testid={testid} style={{ display: "flex", flexDirection: "column", gap: 6 }}>
        {rows.map((r, i) => (
          <div key={rowKey ? rowKey(r, i) : i} data-testid={testid + "-row"} data-stock={r.stock || ""} style={{ ...box, padding: "7px 9px", fontSize: 12 }}>
            {cols.map((c) => { const v = c.render ? c.render(r) : r[c.key]; if (v === undefined || v === null || v === "") return null; return (
              <div key={c.label} style={{ display: "flex", justifyContent: "space-between", gap: 10 }}><span style={{ color: "#666" }}>{c.label}</span><span style={Object.assign({ textAlign: "right", minWidth: 0, overflowWrap: "anywhere" }, c.num ? { fontFamily: "var(--jb-mono, monospace)" } : {})}>{v}</span></div>); })}
            {extra ? extra(r) : null}
          </div>))}
      </div>);
    return (
      <div style={{ overflowX: "auto" }}>
        <table data-testid={testid} style={{ width: "100%", borderCollapse: "collapse" }}>
          <thead><tr>{cols.map((c) => <th key={c.label} style={Object.assign({}, hcell, c.num ? { textAlign: "right" } : {})}>{c.label}</th>)}{extra ? <th style={hcell}></th> : null}</tr></thead>
          <tbody>{rows.map((r, i) => (
            <tr key={rowKey ? rowKey(r, i) : i} data-testid={testid + "-row"} data-stock={r.stock || ""}>
              {cols.map((c) => <td key={c.label} style={Object.assign({}, cell, c.num ? num : {})}>{c.render ? c.render(r) : r[c.key]}</td>)}
              {extra ? <td style={cell}>{extra(r)}</td> : null}
            </tr>))}</tbody>
        </table>
      </div>);
  }

  /** the tie per floorplan account (the screen and the import review share it) */
  function FpAccounts({ accounts, narrow, asOf }) {
    const cols = [
      { label: "Account", render: (a) => <span><b style={{ fontFamily: "var(--jb-mono, monospace)" }}>{a.acct}</b> <span style={{ color: "#555" }}>{a.name}</span></span> },
      { label: "Floored in stock", num: true, render: (a) => m$(a.flooredCents) + (a.units ? ` (${a.units})` : "") },
      { label: "Sold, payoff owed", num: true, render: (a) => m$(a.soldOwedCents) + (a.sold ? ` (${a.sold})` : "") },
      { label: "K2B list", num: true, render: (a) => m$(a.listCents) },
      { label: "Books " + (asOf || ""), num: true, render: (a) => m$(a.glCents) },
      { label: "Difference", num: true, render: (a) => <b data-testid="fp-acct-diff" style={{ color: a.diffCents ? "#A02234" : "#176A38" }}>{m$(a.diffCents)}</b> },
      { label: "What it most likely means", render: (a) => <div style={{ maxWidth: narrow ? "none" : 460, textAlign: "left" }}>{(a.causes || []).map((c, i) => <div key={i} data-testid="fp-cause" style={{ marginBottom: 2 }}>{c}</div>)}</div> },
    ];
    return <FpList rows={accounts} cols={cols} narrow={narrow} testid="fp-accounts" rowKey={(a) => a.acct} empty="No floorplan account in the chart." />;
  }

  /** the lender statement compared (counts + lists); act = { take(stocks), payoff(stock) } on the screen, none on the review */
  function FpCompare({ cmp, narrow, act, may, limit }) {
    const [pick, setPick] = React.useState({});
    if (!cmp) return null;
    const lim = (a) => (limit ? (a || []).slice(0, limit) : (a || []));
    const st = cmp.statement;
    const can = (cmp.flooredFromStatement || []).filter((x) => x.canTake);
    const picked = can.filter((x) => pick[x.stock]).map((x) => x.stock);
    const sec = (key, title, rows, cols, tone, extra, foot) => (
      <div data-testid={"fp-cmp-" + key} data-count={(cmp.counts || {})[key] || 0} style={{ marginTop: 8 }}>
        <div style={{ fontWeight: 700, fontSize: 12.5, color: tone || "#1F2D3D", marginBottom: 3 }}>{title} — {(cmp.counts || {})[key] || 0}</div>
        <FpList rows={lim(rows)} cols={cols} narrow={narrow} testid={"fp-cmp-" + key + "-list"} rowKey={(r, i) => (r.stock || r.vin || "") + i} empty="None." extra={extra} />
        {foot || null}
      </div>);
    const veh = { label: "Vehicle", key: "desc" };
    const stk = { label: "Stock #", render: (r) => <b style={{ fontFamily: "var(--jb-mono, monospace)" }}>{r.stock || "—"}</b> };
    const why = { label: "What it most likely means", render: (r) => <span style={{ color: "#444" }}>{r.cause}</span> };
    return (
      <div data-testid="fp-compare" data-statement={st.id} style={{ ...box, padding: "9px 12px" }}>
        <div style={{ fontSize: 12.5 }}><b>Lender statement</b> {st.lender ? "· " + st.lender : ""} · dated {st.date} · {st.units} unit{st.units === 1 ? "" : "s"} · <b data-testid="fp-stmt-total" data-cents={st.totalCents}>{m$(st.totalCents)}</b>
          {st.fileName ? <span style={{ color: "#777" }}> · {st.fileName}</span> : null}</div>
        <div data-testid="fp-cmp-totals" style={{ fontSize: 11.5, color: "#555", marginTop: 2 }}>Matched {(cmp.counts || {}).matched || 0} unit{(cmp.counts || {}).matched === 1 ? "" : "s"}: K2B {m$(cmp.totals.matchedOursCents)} vs the lender {m$(cmp.totals.matchedStatementCents)}.</div>
        {sec("flooredFromStatement", "On the statement, NOT floored in K2B (cash in inventory the lender floors)", cmp.flooredFromStatement,
          [stk, veh, { label: "Lender says owed", num: true, render: (r) => m$(r.statementCents) }, { label: "Cost", num: true, render: (r) => m$(r.costCents) }, why], "#8A4B00",
          act && may && may.fromStatement ? (r) => r.canTake ? <label style={{ fontSize: 11.5, whiteSpace: "nowrap" }}><input type="checkbox" data-testid="fp-take-pick" data-stock={r.stock} checked={!!pick[r.stock]} onChange={(e) => setPick(Object.assign({}, pick, { [r.stock]: e.target.checked }))} /> take</label> : null : null,
          act && may && may.fromStatement && can.length ? (
            <div style={{ display: "flex", gap: 8, alignItems: "center", flexWrap: "wrap", marginTop: 5 }}>
              <button className="k2b-button small" data-testid="fp-take-all" onClick={() => { const o = {}; can.forEach((x) => { o[x.stock] = true; }); setPick(o); }}>Pick all {can.length}</button>
              <button className="k2b-button small" data-testid="fp-take" disabled={!picked.length} onClick={() => act.take(st.id, picked)}>Take the floored amounts from the statement ({picked.length})</button>
              <span style={{ fontSize: 11, color: "#555" }}>No entry is posted — the books already carry the floorplan balance; the server refuses it if the list would be more than the books.</span>
            </div>) : null)}
        {sec("missingFromStatement", "Floored in K2B, NOT on the statement", cmp.missingFromStatement, [stk, veh, { label: "K2B owes", num: true, render: (r) => m$(r.owedCents) }, { label: "Lender", key: "lender" }, why], "#A02234")}
        {sec("soldPayoffOwed", "Sold — the lender still carries it (payoff owed)", cmp.soldPayoffOwed, [stk, veh, { label: "Lender says owed", num: true, render: (r) => m$(r.statementCents) }, { label: "Sold", key: "soldDate" }, why], "#A02234",
          act && may && may.payoff ? (r) => r.payoffCents ? <button className="k2b-button small" data-testid="fp-payoff" data-stock={r.stock} onClick={() => act.payoff(r.stock)}>Pay Off ▸</button> : null : null)}
        {sec("soldPaid", "Sold and paid off in K2B — the lender still lists it", cmp.soldPaid, [stk, veh, { label: "Lender says owed", num: true, render: (r) => m$(r.statementCents) }, { label: "Paid", key: "paidDate" }, why])}
        {sec("notInStock", "On the statement, not in K2B inventory", cmp.notInStock, [stk, { label: "VIN", key: "vin" }, veh, { label: "Lender says owed", num: true, render: (r) => m$(r.statementCents) }, why], "#A02234")}
        {sec("amountDiff", "Amount differences", cmp.amountDiff, [stk, veh, { label: "K2B", num: true, render: (r) => m$(r.oursCents) }, { label: "Lender", num: true, render: (r) => m$(r.statementCents) }, { label: "Difference", num: true, render: (r) => <b style={{ color: "#A02234" }}>{m$(r.diffCents)}</b> }, why], "#A02234")}
        {(cmp.counts || {}).otherLender ? sec("otherLender", "Floored with another lender (not on this statement)", cmp.otherLender, [stk, veh, { label: "Lender", key: "lender" }, { label: "K2B owes", num: true, render: (r) => m$(r.owedCents) }]) : null}
      </div>);
  }

  /* ═══════════════ the import review's floorplan section (rv.run.floorplan) ═══════════════ */
  function FpReviewTie({ fp, go }) {
    const narrow = useNarrow();
    if (!fp) return null;
    if (fp.error) return <div data-testid="rv-floorplan" style={{ ...box, padding: "8px 12px", color: "#A02234", fontSize: 12 }}>{fp.error}</div>;
    const t = fp.totals || {};
    return (
      <div data-testid="rv-floorplan" data-list={t.listCents} data-gl={t.glCents} data-diff={t.diffCents} data-notfloored={t.notFlooredUnits} style={{ ...box, padding: "9px 12px", display: "flex", flexDirection: "column", gap: 8 }}>
        <div><b>Floorplan tie-out as if approved</b> — the floored units (and the sold units awaiting payoff) next to the books' floorplan accounts, as of {fp.asOf}</div>
        {(fp.words || []).map((w, i) => <div key={i} data-testid="rv-fp-word" style={{ fontSize: 12, lineHeight: 1.45, color: "#333" }}>{w}</div>)}
        <FpAccounts accounts={fp.accounts || []} narrow={narrow} asOf={fp.asOf} />
        <div data-testid="rv-fp-notfloored" style={{ fontSize: 12, color: "#8A4B00" }}>In stock, not floored (cash in inventory): {t.notFlooredUnits || 0} unit{t.notFlooredUnits === 1 ? "" : "s"} · {m$(t.notFlooredCostCents)} at cost.</div>
        {fp.compare ? <FpCompare cmp={fp.compare} narrow={narrow} limit={10} /> : null}
        {go ? <div><button className="k2b-button small" onClick={() => go("floorplan")}>Open Accounting › Floorplan ▸</button></div> : null}
      </div>);
  }

  /* ═══════════════ Accounting › Floorplan ═══════════════ */
  function FloorplanRecon({ onClose, go }) {
    const Dm = D();
    const narrow = useNarrow();
    const [asOf, setAsOf] = React.useState("");
    const [stmt, setStmt] = React.useState("latest");
    const [stmts, setStmts] = React.useState([]);
    const [data, setData] = React.useState(null);
    const [err, setErr] = React.useState("");
    const [msg, setMsg] = React.useState(null);
    const [busy, setBusy] = React.useState(false);
    const [pay, setPay] = React.useState(null);   // { stock, method, ref }
    const load = React.useCallback(async (a, s) => {
      if (!Dm || typeof Dm._apiGet !== "function") { setErr("This DMS page is older than the server — reload it (Ctrl+F5)."); return; }
      setErr("");
      try {
        const q = [];
        if (a) q.push("asOf=" + encodeURIComponent(a));
        if (s) q.push("statement=" + encodeURIComponent(s));
        const d = await Dm._apiGet("/floorplan/reconcile" + (q.length ? "?" + q.join("&") : ""));
        setData(d); if (!a) setAsOf(d.asOf);
        const l = await Dm._apiGet("/floorplan/statements"); setStmts(l.statements || []);
      } catch (e) { setErr(errText(e)); }
    }, []);
    React.useEffect(() => { load("", "latest"); }, []);   // eslint-disable-line
    React.useEffect(() => (Dm && Dm.subscribe) ? Dm.subscribe(() => {}) : undefined, []);
    const act = {
      take: async (statementId, stocks) => {
        setBusy(true); setMsg(null);
        const key = Dm._newIdemKey("fps");
        const r = await Dm._command("/floorplan/from-statement", { statementId, stocks }, key, "/money/op/");
        setBusy(false);
        if (r.ok) { try { Dm._applyServerRecords(r.res.records || []); } catch (e) {} setMsg({ ok: true, text: r.res.message }); load(asOf, stmt); }
        else setMsg({ ok: false, text: (r.err && r.err.body && r.err.body.error) || (r.unknown ? `The server did not answer — look again before trying (the office can look up ${key}).` : "Refused — nothing was changed.") });
      },
      payoff: (stock) => setPay({ stock, method: "ach", ref: "" }),
    };
    const doPay = async () => {
      if (!pay) return;
      setBusy(true); setMsg(null);
      const r = await Dm.payoffFloorplan(pay.stock, pay.method === "check" ? { method: "check" } : { method: pay.method, ref: pay.ref.trim() });
      setBusy(false);
      setMsg({ ok: !!(r && r.ok), text: (r && r.msg) || "Done." });
      if (r && r.ok) { setPay(null); load(asOf, stmt); }
    };
    const t = (data && data.totals) || {};
    const tile = (label, cents, sub, tone, testid) => (
      <div data-testid={testid} data-cents={cents} style={{ ...box, boxSizing: "border-box", padding: "8px 10px", flex: narrow ? "1 1 40%" : "1 1 150px", minWidth: 0 }}>
        <div style={{ fontSize: 10.5, color: "#666", textTransform: "uppercase", letterSpacing: 0.5 }}>{label}</div>
        <div style={{ fontFamily: "var(--jb-mono, monospace)", fontWeight: 800, fontSize: narrow ? 15 : 18, color: tone || "#1F2D3D" }}>{m$(cents)}</div>
        {sub ? <div style={{ fontSize: 11, color: "#666" }}>{sub}</div> : null}
      </div>);
    const stk = { label: "Stock #", render: (r) => <b style={{ fontFamily: "var(--jb-mono, monospace)" }}>{r.stock}</b> };
    return (
      <div className="k2b-window" data-testid="fp-window" style={{ width: "100%", maxWidth: 1280, height: "calc(100vh - 110px)", margin: "0 auto", display: "flex", flexDirection: "column", background: "var(--jb-surface, #F4F4F4)", fontFamily: "var(--jb-font)" }}>
        <K2BTitlebar title="Floorplan Reconciliation" icon="store" onClose={onClose} />
        <div style={{ display: "flex", gap: 10, alignItems: "center", flexWrap: "wrap", padding: narrow ? "8px 10px" : "8px 16px", background: "#FFF", borderBottom: "1px solid var(--jb-border)", fontSize: 12.5 }}>
          <label>As of <input type="date" data-testid="fp-asof" value={asOf} onChange={(e) => { setAsOf(e.target.value); load(e.target.value, stmt); }} style={{ font: "inherit" }} /></label>
          <label>Lender statement <select data-testid="fp-stmt" value={stmt} onChange={(e) => { setStmt(e.target.value); load(asOf, e.target.value); }} style={{ font: "inherit", maxWidth: narrow ? 200 : 360 }}>
            <option value="latest">the latest on file</option>
            <option value="none">none (books vs K2B only)</option>
            {stmts.map((s) => <option key={s.id} value={s.id}>{s.date} · {s.lender || "lender"} · {s.units} units · {m$(s.totalCents)}</option>)}
          </select></label>
          <button className="k2b-button small" onClick={() => load(asOf, stmt)}>Refresh</button>
          <button className="k2b-button small" onClick={() => go && go("uploadtool")}>Bring in a statement ▸</button>
        </div>
        <div style={{ flex: 1, overflow: "auto", padding: narrow ? 10 : 16, display: "flex", flexDirection: "column", gap: 10 }}>
          {err ? <div data-testid="fp-error" style={{ ...box, padding: 10, color: "#A02234" }}>{err}</div> : null}
          {msg ? <div data-testid="fp-msg" data-ok={msg.ok ? "1" : "0"} style={{ ...box, padding: "8px 10px", background: msg.ok ? "#EAF6EE" : "#FDECEA", fontSize: 12.5 }}>{msg.text}</div> : null}
          {!data && !err ? <div style={{ color: "#777" }}>Loading…</div> : null}
          {data ? <>
            <div style={{ display: "flex", gap: 8, flexWrap: "wrap" }}>
              {tile("Floored in stock", t.flooredCents, `${t.flooredUnits || 0} unit${t.flooredUnits === 1 ? "" : "s"}${t.curtailCents ? " · curtailments " + m$(t.curtailCents) : ""}`, null, "fp-t-floored")}
              {tile("Sold — payoff owed", t.soldOwedCents, `${t.soldOwedUnits || 0} unit${t.soldOwedUnits === 1 ? "" : "s"}`, t.soldOwedUnits ? "#A02234" : null, "fp-t-sold")}
              {tile("K2B floored list", t.listCents, "what K2B says is owed", null, "fp-t-list")}
              {tile("Books (floorplan accounts)", t.glCents, "as of " + data.asOf, null, "fp-t-gl")}
              {tile("Difference", t.diffCents, t.diffCents ? "books minus K2B's list" : "ties to the books", t.diffCents ? "#A02234" : "#176A38", "fp-t-diff")}
              {tile("Not floored (cash)", t.notFlooredCostCents, `${t.notFlooredUnits || 0} unit${t.notFlooredUnits === 1 ? "" : "s"} at cost`, "#8A4B00", "fp-t-nf")}
            </div>
            <div style={{ ...box, padding: "9px 12px" }}>
              <div style={{ fontWeight: 700, marginBottom: 5 }}>The books vs K2B's floored list, by account</div>
              <FpAccounts accounts={data.accounts} narrow={narrow} asOf={data.asOf} />
              {(data.unreadable || []).length ? <div data-testid="fp-unreadable" style={{ color: "#A02234", fontSize: 12, marginTop: 6 }}>Not readable (left out of the totals — correct them): {data.unreadable.map((u) => `${u.stock} ${u.what} "${u.value}"`).join("; ")}</div> : null}
            </div>
            {pay ? (
              <div data-testid="fp-pay" style={{ ...box, padding: "9px 12px", background: "#FFF8E6", display: "flex", gap: 8, alignItems: "center", flexWrap: "wrap", fontSize: 12.5 }}>
                <b>Pay off {pay.stock}</b>
                <select data-testid="fp-pay-method" value={pay.method} onChange={(e) => setPay(Object.assign({}, pay, { method: e.target.value }))} style={{ font: "inherit" }}><option value="ach">ACH</option><option value="wire">Wire</option><option value="check">Check (printed in Check Writing)</option></select>
                {pay.method !== "check" ? <input data-testid="fp-pay-ref" placeholder="confirmation #" autoComplete="off" value={pay.ref} onChange={(e) => setPay(Object.assign({}, pay, { ref: e.target.value }))} style={{ font: "inherit", width: 150 }} /> : null}
                <button className="k2b-button small" data-testid="fp-pay-go" disabled={busy || (pay.method !== "check" && !pay.ref.trim())} onClick={doPay}>Pay the floored amount</button>
                <button className="k2b-button small" onClick={() => setPay(null)}>Cancel</button>
              </div>) : null}
            {data.compare ? <FpCompare cmp={data.compare} narrow={narrow} act={busy ? null : act} may={data.may} /> : (
              <div data-testid="fp-nostmt" style={{ ...box, padding: "9px 12px", fontSize: 12.5, color: "#555" }}>No lender statement {stmt === "none" ? "chosen" : "on file"}. Bring the lender's floorplan statement in with the Upload tool (destination "Floorplan statement" — the template is <a href="templates/csv/Floorplan_Statement.csv" download>Floorplan_Statement.csv</a>); after the owner approves it, this screen compares it unit by unit.</div>)}
            <div style={{ ...box, padding: "9px 12px" }}>
              <div style={{ fontWeight: 700, marginBottom: 5 }}>Sold — payoff owed ({(data.soldOwed || []).length})</div>
              <FpList rows={data.soldOwed} narrow={narrow} testid="fp-sold" rowKey={(r) => r.stock} empty="No payoff owed."
                cols={[stk, { label: "Vehicle", key: "desc" }, { label: "Lender", key: "lender" }, { label: "Sold", key: "soldDate" }, { label: "Deal", key: "deal" }, { label: "Owed", num: true, render: (r) => m$(r.owedCents) }, { label: "Account", key: "acct" }]}
                extra={data.may && data.may.payoff ? (r) => <button className="k2b-button small" data-testid="fp-payoff" data-stock={r.stock} disabled={busy} onClick={() => act.payoff(r.stock)}>Pay Off ▸</button> : null} />
            </div>
            <div style={{ ...box, padding: "9px 12px" }}>
              <div style={{ fontWeight: 700, marginBottom: 5 }}>Floored units in stock ({t.flooredUnits || 0})</div>
              <FpList rows={data.floored} narrow={narrow} testid="fp-floored" rowKey={(r) => r.stock} empty="No floored unit in stock."
                cols={[stk, { label: "Vehicle", key: "desc" }, { label: "Lender", key: "lender" }, { label: "Floor date", key: "floorDate" }, { label: "Age", num: true, render: (r) => r.ageDays + "d" }, { label: "Floored", num: true, render: (r) => m$(r.advanceCents) },
                  { label: "Curtailments", num: true, render: (r) => r.curtailCents ? m$(r.curtailCents) : "—" }, { label: "Owed", num: true, render: (r) => m$(r.owedCents) }, { label: "Account", key: "acct" }]} />
            </div>
            <div style={{ ...box, padding: "9px 12px" }}>
              <div style={{ fontWeight: 700, marginBottom: 5 }}>In stock, NOT floored — cash in inventory ({t.notFlooredUnits || 0} · {m$(t.notFlooredCostCents)} at cost)</div>
              <FpList rows={data.notFloored} narrow={narrow} testid="fp-notfloored" rowKey={(r) => r.stock} empty="Every unit in stock is floored."
                cols={[stk, { label: "Vehicle", key: "desc" }, { label: "Type", key: "type" }, { label: "Age", num: true, render: (r) => r.ageDays + "d" }, { label: "Cost", num: true, render: (r) => m$(r.costCents) },
                  { label: "Floor it", render: (r) => <span style={{ color: "#8A4B00", fontSize: 11.5 }}>{data.compare && (data.compare.flooredFromStatement || []).some((x) => x.stock === r.stock) ? "the lender's statement lists it — take the amount above" : "ask your floorplan lender to advance on it"}</span> }]} />
              {data.truncated ? <div style={{ color: "#777", fontSize: 11 }}>The longest lists show the first 400 units; every unit is in the totals.</div> : null}
            </div>
          </> : null}
        </div>
        <div style={{ borderTop: "1px solid var(--jb-border)", padding: "8px 16px", display: "flex", gap: 6, flexWrap: "wrap" }}>
          <K2BButton small onClick={onClose}>ESC-Close</K2BButton>
          <K2BButton small onClick={() => go && go("deadmoney")}>Dead Money</K2BButton>
          <K2BButton small onClick={() => go && go("reconcile")}>Reconcile Inventory</K2BButton>
        </div>
      </div>);
  }

  Object.assign(window, { FloorplanRecon, FpReviewTie, FpAccounts, FpCompare });
})();