/* © 2026 K2B NETWORK SOLUTIONS LLC. All rights reserved. */
/* eslint-disable */
// ImpScreens — RC25 (imp), the imports pack screens:
//   window.ImpWorkbook        detect(sheets) — is this the old system's multi-sheet workbook? + the per-sheet column rules
//   window.ImpWorkbookFlow    the whole workbook as ONE job: every sheet to its destination in the README's load order, one plan with
//                             counts per sheet, run in order with per-sheet results (opened from the import wizard's file step)
//   window.ImpReconcileWindow Accounting › Reconcile inventory to GL: per schedule (new / used / parts / body shop / WIP / service A/R)
//                             the GL balance as of a date next to the imported list, the difference, the items behind it, and the two
//                             postings — always both offered, with plain words on when each is right (the SERVER posts; this screen asks)
//   window.ImpRoHistory       Service › Old ROs: the repair-order history imported from the old system, looked up on the server
//   window.ImpTbSchedules     a panel under Classic Reports › Trial Balance: which inventory accounts tie to a schedule, last reconciled when
//   RC26 (inv): window.ImpVehicleHistory / ImpVinHistoryButton — every deal, trade and old + K2B repair order on a VIN with the owner at the time
//               (GET /api/import/vehicle-history; Sales sees no cost); window.ImpCustomerOldRos — the customer's old repair orders (linked by
//               phone / VIN, or waiting with the phone as customer #) and vehicles (GET /api/import/customer-history); the Old ROs tab shows
//               the links and the office's "Link old ROs to customers" button (POST /api/import/link-ros); Reconcile Inventory leaves off
//               non-inventory accounts (238 SAW MILL LOT: dealership property) and lets the office exclude others on the schedule map.
// Everything money is integer cents from the server; the rules are ImpCalc.jsx.txt (== the server's imp-calc.js).
(function () {
  const D = () => window.DMS;
  const C = () => window.ImpCalc;
  const money = (c) => (C() ? C().fmt(Math.round(+c || 0)) : String((+c || 0) / 100));
  const box = { background: "#FFF", border: "1px solid #C9D6E3", borderRadius: 4 };
  const cell = { padding: "4px 8px", borderTop: "1px solid #EEE", verticalAlign: "top", fontSize: 11.5 };
  const hcell = { padding: "5px 8px", textAlign: "left", background: "#F0F3F7", fontWeight: 700, borderBottom: "1px solid #D6DEE7", fontSize: 11.5, whiteSpace: "nowrap" };
  const num = { textAlign: "right", fontFamily: "'Courier Prime', monospace", whiteSpace: "nowrap" };
  const btn = (primary, extra) => ({ fontWeight: 700, padding: "5px 14px", background: primary ? "#FFE9B0" : undefined, ...(extra || {}) });
  const toast = (t, k, ms) => { try { window.k2bToast && window.k2bToast(t, k || "info", ms || 4200); } catch (e) {} };
  const todayIso = () => { const d = new Date(); return d.getFullYear() + "-" + String(d.getMonth() + 1).padStart(2, "0") + "-" + String(d.getDate()).padStart(2, "0"); };
  const errText = (e) => (e && e.body && e.body.error) || (e && e.message) || String(e || "unknown");
  const sidebar = (route) => { const el = document.querySelector('.jb-sidebar [data-route="' + route + '"]'); if (el) el.click(); };
  const goTo = (go, route) => { if (typeof go === "function") go(route); else sidebar(route); };

  /* ═══════════════════════════════ 1. the old system's workbook ═══════════════════════════════ */
  // sig: the columns that identify the sheet when it was renamed (RC25 fix round, attack W1: a sheet renamed "ROs 2026" is recognised by
  // its columns; a sheet recognised neither way is LISTED as not imported, never silently left out)
  const WB_SHEETS = [
    { name: "Chart_of_Accounts", dest: "glChart", why: "the chart first — every other list looks its accounts up here", sig: { all: ["account", "description"], none: ["balance", "asof", "rowtype", "mtdamount", "ytdamount"] } },
    { name: "GL_Opening_Balances", dest: "glTrial", why: "ONE balanced opening-balances entry dated the sheet's as-of date (accounts missing from the chart are added from the sheet's description)", sig: { all: ["asof", "account", "balance"] } },
    { name: "Customers", dest: "customers", why: "customers before the deals and repair orders that mention them (RC30 (cn): the customer # is the phone without the area code — a customer_number column is used as is, a row with a phone and no number is numbered from the phone, a row with neither gets a number K2B issues)", sig: { any: [["customerid", "name", "homephone"], ["customernumber", "name"], ["name", "homephone"]] } },   // RC30 merge: cn's two signatures + imp2's (name + home_phone)
    { name: "Vehicles", dest: "vehicleMaster", why: "every VIN the old system ever saw — a lookup list on the server for the repair-order history (NOT units in stock)", sig: { all: ["vin", "sources"] } },
    { name: "Inventory", dest: "inventory", why: "the units in stock, with the old ledger's GL Cost and GL Account per unit (nothing is posted — the approval screen ties them to the ledger)", sig: { all: ["stock", "glcost"] } },
    { name: "Sales_Deals", dest: "deals", why: "closed-deal history (records only; RC36: the x_* / unconfirmed_* columns are kept as “from the old system — unconfirmed” information)", sig: { all: ["dealnumber", "saleprice"] } },
    { name: "Repair_Orders", dest: "roHistory", why: "repair-order history in batches to the server; the RO_Lines sheet supplies the job lines (closed ROs = history, open ROs = on the board, no journal)", linesSheet: "RO_Lines", sig: { all: ["recordid", "paytypeflag", "rototal"] } },
    { name: "RO_Lines", partOf: "Repair_Orders", why: "the job lines of the repair orders (imported together with Repair_Orders)", sig: { all: ["recordid", "lineno", "text1"], none: ["rototal"] } },
    // RC33 (svi): the service side — names for the customer #s, the A/R aging, open warranty claims, body-shop jobs in progress (each sheet optional; the
    // service customer list is recognised by its NAME only — its columns would also match the Customers sheet)
    { name: "Service_Customers", dest: "svcCustomers", why: "the names (and addresses) of the service customers, by their 7-digit customer # — a customer is created at approval for a number not on file, a customer on file only gets its blank fields filled, another name is listed for the office" },
    { name: "AR_Aging", dest: "arAging", why: "the A/R aging by customer (current / 31-60 / 61-90 / 91-120 / over 120 / total) — the customers' A/R accounts, tied to 220 (and 220A) on the review", sig: { all: ["customernumber", "current", "total"] } },
    { name: "Warranty_Claims", dest: "warrantyClaims", why: "the open warranty claims (claim #, RO #, amount) — tied to 263 WARRANTY CLAIMS on the review", sig: { all: ["claimnumber", "ronumber", "amount"] } },
    { name: "Body_Shop_WIP", dest: "bodyWip", why: "the body-shop jobs still in progress (their cost) — tied to 245 BODY SHOP INVENTORY on the review", sig: { all: ["ronumber", "materialscost"] } },
    // RC36 (fpd36): the lender's floorplan statement (optional) — compared with the floored units, 310 / 314 on the review; kept on file at approval
    { name: "Floorplan_Statement", dest: "floorplanStmt", why: "the lender's floorplan statement (stock # / VIN, floor date, amount floored, curtailments, balance owed) — compared unit by unit with the floored units and 310 / 314 on the review; nothing is posted", sig: { any: [["stock", "balanceowed"], ["vin", "balanceowed"]] } },
    // RC30 (imp2): the owner's template adds the parts list and the Tie_Out sheet (which GL account each list must agree with)
    { name: "Parts", dest: "partsMaster", why: "the parts on hand (part #, bin, on hand, cost) — tied to the parts inventory account on approval", sig: { all: ["part", "onhand"] } },
    // RC36 (imp36): a template sheet for every import — vendors (old balances → A/P), the check register, journal entries, aged schedules
    { name: "Vendors", dest: "vendors", why: "the vendors (old balance owed for reference — tied to A/P 300 on the review)", sig: { all: ["vendorname", "terms"] } },
    { name: "Check_Register", dest: "checks", why: "the check register (register records only — tied to the bank account's credits on the review)", sig: { all: ["checknumber", "payee", "amount"] } },
    { name: "Journal_Entries", dest: "glJournal", why: "journal entries (posted at approval — compared with what the books already carry for the same days)", sig: { all: ["entryref", "glaccount", "debit", "credit"] } },
    { name: "Aged_Schedules", dest: "schedule", why: "aged schedules by GL account (control #, balance) — each account tied to its ledger balance on the review", sig: { all: ["control", "balance", "glaccount"] } },
    { name: "Summary_by_Year", reference: true, why: "the deal file's own totals by year — read back on the review of the deals (deals / new / used / total sales / financed)" },
    { name: "Tie_Out", tieOut: true, why: "which GL account each list must agree with (Inventory / Parts / Customer A/R / WIP labor / Sublet / Warranty / Body shop / Parts on open ROs / Information / Exclude) — read by the approval screen; the defaults are used when this sheet is missing", sig: { all: ["glaccount", "tiesto"] } },
    { name: "Trial_Balance_Report", reference: true, why: "kept for reference — compare it with Classic Reports › Trial Balance after the opening balances post", sig: { all: ["account", "rowtype"] } },
    { name: "PL_Report", reference: true, why: "kept for reference — compare it with Profit & Loss" },
    { name: "README", skip: true, why: "the old system's notes" },
    { name: "START_HERE", skip: true, why: "the template's instructions (not data)" },
    { name: "Column_Guide", skip: true, why: "the template's column guide (not data)" },
  ];
  const nkey = (s) => String(s || "").toLowerCase().replace(/[^a-z0-9]/g, "");
  const sigHit = (w, sh) => { if (!w.sig || !sh || !Array.isArray(sh.headers)) return false; const hs = new Set(sh.headers.map(nkey)); const alls = w.sig.any || [w.sig.all || []]; return alls.some((all) => all.every((h) => hs.has(h))) && !(w.sig.none || []).some((h) => hs.has(h)); };   // RC30 (cn): sig.any = several column signatures (the ACS export and the K2B template)
  function detect(sheets) {
    const found = {}, byColumns = {}, taken = new Set();
    (sheets || []).forEach((sh) => { const k = nkey(sh && sh.name); WB_SHEETS.forEach((w) => { if (!found[w.name] && nkey(w.name) === k) { found[w.name] = sh; taken.add(sh); } }); });
    (sheets || []).forEach((sh) => { if (taken.has(sh)) return; const w = WB_SHEETS.find((x) => !found[x.name] && sigHit(x, sh)); if (w) { found[w.name] = sh; byColumns[w.name] = sh.name; taken.add(sh); } });
    const importable = WB_SHEETS.filter((w) => w.dest && found[w.name]);
    const unknown = (sheets || []).filter((sh) => sh && !taken.has(sh)).map((sh) => ({ name: sh.name, rows: (sh.rows || []).length }));
    const missing = WB_SHEETS.filter((w) => (w.dest || w.partOf) && !found[w.name] && w.name !== "Parts").map((w) => w.name);   // RC30: the ACS export has no Parts sheet — not "missing"
    return { ok: importable.length >= 2, recognised: Object.keys(found).length, names: WB_SHEETS.filter((w) => found[w.name]).map((w) => w.name), found, importable: importable.map((w) => w.name), byColumns, unknown, missing, tieOut: found.Tie_Out || null };
  }
  const typeFromAcct = (a) => { const s = String(a || "").trim().toUpperCase(); if (/^0\d{3}/.test(s)) return "Expense"; const d = (s.match(/^\d+/) || [""])[0]; return ({ 1: "Asset", 2: "Asset", 3: "Liability", 4: "Sales", 5: "Sales", 6: "Cost", 7: "Expense", 8: "Income", 9: "Income" })[d[0]] || "Expense"; };
  const ymm = (y, mk, md) => [y, mk, md].map((x) => String(x == null ? "" : x).trim()).filter(Boolean).join(" ");
  const X_WHY = "not imported (meaning unconfirmed)", SSN_WHY = "never imported (sensitive)", NOFIELD = "no K2B field";
  const WB_COLS = {
    Chart_of_Accounts: { map: { Account: "acct", Description: "name", "Type (from the account number)": "type" }, virtual: (r) => ({ "Type (from the account number)": typeFromAcct(r.Account) }),
      note: "The old chart has no account type column: the type is taken from the account number (0xxx expense · 1xx / 2xx asset · 3xx liability and equity · 4xx / 5xx sales · 6xx cost · 7xx expense · 8xx / 9xx income)." },
    GL_Opening_Balances: { map: { Account: "acct", Description: "name", Balance: "ytd" }, skip: { "As Of": "used as the as-of date of the opening balances" },
      opts: (rows) => ({ asOf: rows[0] && rows[0]["As Of"] ? String(rows[0]["As Of"]).slice(0, 10) : "", periodMode: "asOf", addMissingAccounts: true }) },
    Customers: { map: { customer_number: "custNum", name: "fullName", address: "street", city: "city", state: "state", zip: "postal", home_phone: "phone", work_phone: "workPhone", email: "email", customer_id: "oldCustNo" },   // RC30 (cn): customer_number = THE customer # (7 digits), work_phone and email imported; RC26 (inv) fix round: customer_id kept as the old system's customer id — an old deal names its buyer by it
      skip: { employer: NOFIELD, county: NOFIELD, ssn_last4: SSN_WHY, last_deal_date: NOFIELD } },
    Vehicles: { map: { vin: "vin", year: "year", make: "make", model: "model", color: "color", sources: "sources" }, skip: { customer_number: "the vehicle's last owner — linked through the repair orders and deals, not stored on the VIN list" } },
    Inventory: { guess: "inventory", skip: { "Mileage Code": NOFIELD } },
    Parts: { map: { "Part #": "part", Description: "desc", Bin: "bin", "On hand": "onHand", Cost: "cost", List: "list", Trade: "trade", Source: "source", "Core charge": "core", "GL Account": "glAcct" } },
    Sales_Deals: {
      // RC36 (imp36): the deal history complete — year / make / model, the trade, finance terms, the second salesperson, the GL accounts, county, employer, the
      // stock-in date, purchased from, the open items; the x_* / unconfirmed_* columns are kept as "from the old system — unconfirmed" information
      map: { year: "vehYear", make: "vehMake", model: "vehModel", body: "vehBody", color: "vehColor", sale_gl_account: "saleAcct", inventory_gl_account: "invAcct", salesperson2_code: "salesperson2", stock_in_date: "stockInDate", purchased_from: "purchasedFrom",
        buyer_county: "county", buyer_employer: "employer", buyer_work_phone: "workPhone", cobuyer_relation: "cobuyerRelation", sales_tax: "salesTax", net_trade: "netTrade", total_down: "totalDown", total_of_payments: "totalOfPayments", total_sale_price: "totalSalePrice", first_payment_date: "firstPayDate",
        trade1_year: "tradeYear", trade1_make: "tradeMake", trade1_model: "tradeModel", trade1_body: "tradeBody", trade1_color: "tradeColor", funded: "funded", payoff_paid: "payoffPaid", tax_remitted: "taxRemitted", contract_remitted: "contractRemitted",
        x_doc_fee_or_pack: "ucDocFee", x_total_cost: "ucTotalCost", x_trade_acv: "ucTradeAcv", x_front_gross: "ucFrontGross", x_back_gross: "ucBackGross", x_created_date: "ucCreated", x_modified_date: "ucModified",
        unconfirmed_doc_fee_or_pack: "ucDocFee", unconfirmed_total_cost: "ucTotalCost", unconfirmed_trade_acv: "ucTradeAcv", unconfirmed_front_gross: "ucFrontGross", unconfirmed_back_gross: "ucBackGross", unconfirmed_created_date: "ucCreated", unconfirmed_modified_date: "ucModified",
        deal_number: "dealNo", deal_date: "date", lender_code: "lender", salesperson_code: "salesperson", stock_number: "stock", vin: "vin", "Vehicle (year make model)": "vehicle", odometer: "miles", new_used: "type",
        buyer_name: "buyer", buyer_address: "street", buyer_city: "city", buyer_state: "state", buyer_zip: "postal", buyer_home_phone: "phone", customer_number: "custNum", customer_id: "oldCustNo", cobuyer_name: "cobuyer", vehicle_cost: "invoicePrice",   // RC30 (cn): customer_number = the buyer's customer #
        trade1_stock_number: "tradeStock", "Trade (year make model)": "tradeDesc", trade1_vin: "tradeVin", trade1_odometer: "tradeMiles", trade1_lienholder: "payoffLender", trade_payoff: "payoff1",
        sale_price: "salePrice", cash_down: "cashReceived", trade_allowance: "tradeAllow", service_contract: "vscSale", apr: "contractRate", term_months: "term", payment_amount: "payment", amount_financed: "amtFinanced", finance_charge: "financeCharge" },
      virtual: (r) => ({ "Vehicle (year make model)": ymm(r.year, r.make, r.model), "Trade (year make model)": ymm(r.trade1_year, r.trade1_make, r.trade1_model) }),
      historyOnly: Object.fromEntries(["x_doc_fee_or_pack", "x_total_cost", "x_trade_acv", "x_front_gross", "x_back_gross", "x_created_date", "x_modified_date", "unconfirmed_doc_fee_or_pack", "unconfirmed_total_cost", "unconfirmed_trade_acv", "unconfirmed_front_gross", "unconfirmed_back_gross", "unconfirmed_created_date", "unconfirmed_modified_date"].map((c) => [c, "kept on the deal as “from the old system — unconfirmed” (information only, decides nothing)"])),   // RC36 (imp36): listed on the plan as unconfirmed information
      skip: { buyer_ssn: SSN_WHY, cobuyer_ssn: SSN_WHY },
      note: "RC36: every column is read. The x_* / unconfirmed_* columns are kept on the deal as “from the old system — unconfirmed” (information only — the old export says their meaning is unconfirmed; they decide nothing in K2B). The SSN columns are never imported. The review ties the deals to the general ledger (open items vs 205 / 303 / 324A / 302, sales and cost of sales year to date)." },
    Vendors: { guess: "vendors" }, Check_Register: { guess: "checks" }, Journal_Entries: { guess: "glJournal" }, Aged_Schedules: { guess: "schedule" },   // RC36 (imp36): the template's column names are the fields' own synonyms
    Repair_Orders: {
      map: { record_id: "roNo", customer_account: "customerAccount", customer_number: "customerAccount", ro_date: "date", pay_type_flag: "flag", vin: "vin", stock_number: "stock", year: "year", make: "make", model: "model", color: "color", odometer: "odometer", technician_code: "tech", advisor_code: "advisor",   // RC30 (imp2): template customer_number
        customer_name: "customerName", customer_last_name: "custLast", customer_first_name: "custFirst", address: "custStreet", city: "custCity", state: "custState", zip: "custPostal", phone: "custPhone", email: "custEmail", status: "status",   // RC33 (svi): the template v3's customer columns (the ACS export has none)
        parts_sale: "partsSale", parts_cost: "partsCost", labor_sale: "laborSale", labor_cost: "laborCost", sublet_sale: "subletSale", sublet_cost: "subletCost", shop_supplies: "supplies", tax_rate_pct: "taxRatePct", sales_tax: "salesTax", ro_total: "total", x_customer_pay_total: "customerPay", x_warranty_or_internal_total: "otherPay" },
      historyOnly: { x_customer_pay_total: "kept on the RO history exactly as printed — meaning unconfirmed, decides nothing", x_warranty_or_internal_total: "kept on the RO history exactly as printed — meaning unconfirmed, decides nothing" },
      note: "The two x_ columns add up to ro_total on every row, but the old export says their meaning is unconfirmed (on an open RO the customer pay is 0 until it is invoiced): they are kept on the repair-order HISTORY as printed and decide nothing in K2B — an open RO goes on the board as Customer pay, and they never count as A/R. pay_type_flag: I = invoiced (closed), O = open, H = held, W = warranty (closed); a VOID customer account = a voided RO. RC33: a customer_name column (template v3) makes the customer of a 7-digit customer # at approval (or fills the blank fields of the one on file; another name on file is listed for the office)." },
    // RC33 (svi): the service lists of the template v3
    Service_Customers: { map: { customer_number: "custNum", name: "customerName", last_name: "custLast", first_name: "custFirst", address: "custStreet", city: "custCity", state: "custState", zip: "custPostal", phone: "custPhone", work_phone: "custWorkPhone", email: "custEmail" } },
    AR_Aging: { map: { customer_number: "control", name: "name", current: "current", days_31_60: "d31_60", days_61_90: "d61_90", days_91_120: "d91_120", over_120: "over120", total: "total", gl_account: "gl", as_of: "asOf" },
      opts: (rows) => ({ asOf: rows[0] && rows[0].as_of ? String(rows[0].as_of).slice(0, 10) : "" }) },
    // RC36 (fpd36): the K2B template's floorplan statement columns (any other header is guessed from the destination's names)
    Floorplan_Statement: { guess: "floorplanStmt", map: { stock_number: "stock", vin: "vin", description: "desc", lender: "lender", floor_date: "floorDate", amount_floored: "advance", curtailments_paid: "curtail", balance_owed: "balance", statement_date: "stmtDate" } },
    Warranty_Claims: { map: { claim_number: "claim", ro_number: "ro", claim_date: "date", amount: "amount", amount_paid: "paid", status: "status" } },
    Body_Shop_WIP: { map: { ro_number: "roNo", date: "date", customer_number: "custNum", labor_cost: "laborCost", parts_cost: "partsCost", materials_cost: "materialsCost", sublet_cost: "subletCost", status: "status" } },
  };
  function buildJob(w, sh, fileName, allSheets) {
    const spec = WB_COLS[w.name] || {}; const Dm = D(); const SKIP = Dm.IMPORT_SKIP || "__skip";
    const rows = spec.virtual ? sh.rows.map((r) => Object.assign({}, r, spec.virtual(r))) : sh.rows;
    const headers = spec.virtual ? sh.headers.concat(Object.keys(spec.virtual(sh.rows[0] || {})).filter((h) => !sh.headers.includes(h))) : sh.headers.slice();
    let mapping = {};
    if (spec.guess) { const g = Dm.importGuessMapping(spec.guess, headers, rows); mapping = Object.assign({}, g.mapping); }
    const notImported = [];
    headers.forEach((h) => {
      if (spec.map && spec.map[h]) { mapping[h] = spec.map[h]; return; }
      if (spec.skip && spec.skip[h]) { mapping[h] = SKIP; notImported.push({ col: h, why: spec.skip[h] }); return; }
      if (!mapping[h]) { mapping[h] = SKIP; notImported.push({ col: h, why: /^x_/i.test(h) ? X_WHY : /ssn/i.test(h) ? SSN_WHY : NOFIELD }); }
    });
    const used = {};
    headers.forEach((h) => { const f = mapping[h]; if (f && f !== SKIP) { if (used[f]) { mapping[h] = SKIP; notImported.push({ col: h, why: "“" + used[f] + "” already fills that field" }); } else used[f] = h; } });
    const opts = Object.assign({ headers, fileName, sheetName: sh.name, allSheets }, spec.opts ? spec.opts(rows) : {});
    const historyOnly = Object.keys(spec.historyOnly || {}).filter((h) => headers.includes(h) && mapping[h] && mapping[h] !== SKIP).map((h) => ({ col: h, why: spec.historyOnly[h] }));
    return { w, sh, rows, headers, mapping, notImported, historyOnly, opts, dest: w.dest, def: Dm.importDest(w.dest), note: spec.note || "" };
  }
  const planJob = (job) => { try { return D().importPlan(job.dest, job.rows, job.mapping, job.opts); } catch (e) { return { error: "Preview failed: " + ((e && e.message) || e) }; } };
  const countsText = (c) => c ? `${c.added} added · ${c.updated} updated · ${c.skipped} skipped · ${c.rejected} rejected` : "";
  window.ImpWorkbook = { SHEETS: WB_SHEETS, COLS: WB_COLS, detect, buildJob, planJob, typeFromAcct };

  const ImpWorkbookFlow = ({ file, go, onBack, onClose }) => {
    const Dm = D();
    const det = React.useMemo(() => detect(file.sheets), [file]);
    const jobs = React.useMemo(() => WB_SHEETS.filter((w) => w.dest && det.found[w.name]).map((w) => buildJob(w, det.found[w.name], file.name, file.sheets)), [file, det]);
    const extras = WB_SHEETS.filter((w) => !w.dest && det.found[w.name]);
    const sheetName = (w) => det.byColumns[w.name] ? <>{w.name}<div data-testid="wb-bycolumns" style={{ fontWeight: 400, color: "#555" }}>sheet “{det.byColumns[w.name]}”, recognised by its columns</div></> : w.name;
    const noOpening = !det.found.GL_Opening_Balances;
    const [plans, setPlans] = React.useState({});
    const [results, setResults] = React.useState({});
    const [running, setRunning] = React.useState(false);
    const [cur, setCur] = React.useState("");
    const [progress, setProgress] = React.useState(null);
    const [stopped, setStopped] = React.useState("");
    const [staged, setStaged] = React.useState(null);   // RC30 (imp2): the ONE run every sheet went into, once it waits for approval
    const [, tick] = React.useReducer((n) => n + 1, 0);
    const doneAll = !running && jobs.length > 0 && jobs.every((j) => results[j.w.name]);
    const asOf = (jobs.find((j) => j.w.name === "GL_Opening_Balances") || { opts: {} }).opts.asOf || "";
    React.useEffect(() => { const p = {}; jobs.forEach((j) => { p[j.w.name] = planJob(j); }); setPlans(p); }, [jobs]);
    const allowed = (j) => !j.def || !Dm.can || !j.def.perm || Dm.can(j.def.perm);
    const openReview = (runId) => { try { if (runId) localStorage.setItem("k2b-imp-review-run", runId); } catch (e) {} goTo(go, "importreview"); };
    // RC30 (imp2): the whole workbook is ONE staged run, one part per sheet — nothing is written or posted here; the Tie_Out sheet travels
    // with the run (the approval screen's tie-out); a blocked sheet (e.g. opening balances that do not net to zero) is staged as a problem
    // part so the owner sees why, instead of stopping the whole workbook.
    const runAll = async () => {
      if (running) return;
      if (!Dm.importStage || !Dm.importStageStart) { toast("This DMS page is older than the server — reload it (Ctrl+F5).", "warn", 6000); return; }
      setRunning(true); setStopped(""); setResults({}); setStaged(null);
      const tieRows = det.tieOut ? det.tieOut.rows.map((r) => ({ glAccount: r["GL Account"], tiesTo: r["Ties to"], note: r.Note })) : undefined;
      let runId = "";
      try {
        const st = await Dm.importStageStart({ fileName: file.name, source: "Old system workbook", parts: jobs.map((j) => ({ part: C().partName(j.w.name), dest: j.dest, sheet: j.sh.name })), asOf, tieOut: tieRows, totalRows: jobs.reduce((s, j) => s + j.rows.length, 0) });
        runId = st.runId;
      } catch (e) { setStopped("start"); setResults({ start: { status: "failed", msg: errText(e) } }); setRunning(false); toast(errText(e), "warn", 7000); return; }
      let failedAt = "";
      for (const j of jobs) {
        setCur(j.w.name); setProgress(null);
        if (!allowed(j)) { setResults((r) => ({ ...r, [j.w.name]: { status: "failed", msg: `Your role can't import into ${j.def ? j.def.short : j.dest}.` } })); failedAt = j.w.name; break; }
        const plan = planJob(j);
        setPlans((p) => ({ ...p, [j.w.name]: plan }));
        if (plan.error) { setResults((r) => ({ ...r, [j.w.name]: { status: "failed", msg: plan.error } })); failedAt = j.w.name; break; }
        const meta = { file: file.name, sheet: j.sh.name, source: "Old system workbook" };
        let res;
        try { res = await Dm.importStage(j.dest, plan, meta, (p) => setProgress(p), { runId, part: C().partName(j.w.name), noFinish: true, allowBlocked: true }); }
        catch (e) { res = { ok: false, msg: errText(e) }; }
        setProgress(null);
        if (!res || !res.ok) { setResults((r) => ({ ...r, [j.w.name]: { status: "failed", msg: (res && res.msg) || "failed", plan } })); failedAt = j.w.name; break; }
        setResults((r) => ({ ...r, [j.w.name]: { status: "done", msg: res.msg, counts: res.counts, histId: res.id, server: res.server, plan, blocked: plan.blocked ? plan.blockers[0].title : "" } }));
        tick();
      }
      let fin = null;
      try { fin = await Dm.importStageFinish(runId, {}); } catch (e) { toast(errText(e), "warn", 7000); }
      setStaged({ runId, run: fin && fin.run ? fin.run : null, review: fin && fin.review ? fin.review : null });
      if (failedAt) setStopped(failedAt);
      setCur(""); setRunning(false);
    };
    const skipAndContinue = () => { setStopped(""); };
    return (
      <div data-testid="imp-workbook" style={{ flex: 1, minHeight: 0, display: "flex", flexDirection: "column", background: "#FFF", fontFamily: "var(--font-ui)", fontSize: 12, color: "#000" }}>
        <div style={{ flex: "0 0 auto", padding: "8px 14px", borderBottom: "1px solid #E4E4E4", display: "flex", gap: 10, alignItems: "center", flexWrap: "wrap" }}>
          <div style={{ fontWeight: 700, fontSize: 15, color: "var(--k2b-navy)" }}>📚 The whole old-system workbook — {file.name}</div>
          <span style={{ color: "#555" }}>{jobs.length} sheets to import in the README's load order{extras.length ? ` · ${extras.length} kept for reference` : ""}{det.unknown.length ? ` · ${det.unknown.length} not recognised` : ""}{det.missing.length ? ` · ${det.missing.length} missing` : ""}{asOf ? ` · opening balances as of ${asOf}` : ""}</span>
          <span style={{ flex: 1 }} />
          <button className="k2b-button small" data-testid="wb-back" disabled={running} onClick={onBack} style={btn(false)}>‹ One sheet at a time instead</button>
        </div>
        <div style={{ flex: "1 1 auto", minHeight: 0, overflow: "auto", padding: "10px 14px", display: "flex", flexDirection: "column", gap: 10 }}>
          <div style={{ ...box, padding: "9px 12px", fontSize: 12, lineHeight: 1.5 }}>
            <b>How this works.</b> Each sheet is planned exactly as if you had imported it alone (the same column rules, the same preview rules) and every sheet goes into ONE import run on the server, in the order below. <b>Nothing is saved and nothing is posted to the General Ledger</b> — not even the opening-balances entry — until the owner approves the run on <b>Accounting › Import review &amp; approval</b>, where every problem row is explained and the lists are tied to the ledger (the Tie_Out sheet, or the defaults). A sheet with a problem (opening balances that do not net to zero, say) does not stop the others: it is shown as a problem on the review screen.
          </div>
          <div style={{ ...box, overflow: "auto" }}>
            <table data-testid="wb-plan" style={{ width: "100%", borderCollapse: "collapse" }}>
              <thead><tr><th style={hcell}>#</th><th style={hcell}>Sheet</th><th style={hcell}>Rows</th><th style={hcell}>Goes to</th><th style={hcell}>Columns</th><th style={hcell}>Plan (before anything runs)</th><th style={hcell}>Result</th></tr></thead>
              <tbody>
                {jobs.map((j, i) => {
                  const p = plans[j.w.name], r = results[j.w.name];
                  const mapped = j.headers.filter((h) => j.mapping[h] && j.mapping[h] !== (Dm.IMPORT_SKIP || "__skip")).length;
                  return (
                    <tr key={j.w.name} data-testid={"wb-sheet-" + j.w.name} data-status={r ? r.status : cur === j.w.name ? "running" : "waiting"} style={{ background: cur === j.w.name ? "#FFF8E6" : r && r.status === "failed" ? "#FDECEA" : r ? "#F3FBF4" : undefined }}>
                      <td style={cell}>{i + 1}</td>
                      <td style={{ ...cell, fontWeight: 700, whiteSpace: "nowrap" }}>{sheetName(j.w)}{j.w.linesSheet && det.found[j.w.linesSheet] ? <div style={{ fontWeight: 400, color: "#555" }}>+ {j.w.linesSheet} ({det.found[j.w.linesSheet].rows.length} lines)</div> : null}</td>
                      <td style={{ ...cell, ...num }}>{j.rows.length.toLocaleString("en-US")}</td>
                      <td style={cell}><b>{j.def ? j.def.label : j.dest}</b><div style={{ color: "#555" }}>{j.w.why}</div>{!allowed(j) && <div style={{ color: "#A02234" }}>Your role can't import here.</div>}</td>
                      <td style={cell}><div>{mapped} imported{j.notImported.length ? `, ${j.notImported.length} not` : ""}</div>{j.notImported.length > 0 && <details><summary style={{ cursor: "pointer", color: "#555" }}>not imported</summary><ul style={{ margin: "3px 0 0 14px", padding: 0 }}>{j.notImported.map((x) => <li key={x.col} data-testid="wb-notimported" data-col={x.col}><span style={{ fontFamily: "'Courier Prime', monospace" }}>{x.col}</span> — {x.why}</li>)}</ul></details>}{j.historyOnly && j.historyOnly.length > 0 && <div style={{ color: "#8A4B00" }}>{j.historyOnly.length} kept as history only (meaning unconfirmed): {j.historyOnly.map((x) => <span key={x.col} data-testid="wb-historyonly" data-col={x.col} style={{ fontFamily: "'Courier Prime', monospace", marginRight: 6 }}>{x.col}</span>)}</div>}{j.note && <div style={{ color: "#555", marginTop: 3 }}>{j.note}</div>}</td>
                      <td style={cell} data-testid={"wb-counts-" + j.w.name}>{!p ? "…" : p.error ? <span style={{ color: "#A02234" }}>{p.error}</span> : <><div>{countsText(p.counts)}</div>{p.blocked && <div style={{ color: "#8A4B00" }}>⚠ {p.blockers[0].title}{j.w.name !== "Chart_of_Accounts" && /account/i.test(p.blockers[0].title) ? " — checked again after the chart is imported" : ""}</div>}{p.summary && p.summary.kind === "trialBalance" && p.summary.entry && <div style={{ color: "#555" }}>one entry {p.summary.entry.ref} · {p.summary.entry.lines} lines · {money(Math.round(p.summary.entry.debits * 100))}</div>}{p.summary && p.summary.kind === "roHistory" && <div style={{ color: "#555" }}>closed {p.summary.byStatus.closed} · open {p.summary.byStatus.open} · held {p.summary.byStatus.held} · void {p.summary.byStatus.void} · {p.summary.lines} job lines · {p.summary.batches} batches</div>}{p.counts && p.counts.rejected > 0 && j.dest === "customers" && <div style={{ color: "#8A4B00" }}>rejected rows: a customer # that does not match the phone, a code word in the number column, or the same 7 digits on another area code (the office adds those in the CRM)</div>}</>}</td>
                      <td style={cell} data-testid={"wb-result-" + j.w.name}>{cur === j.w.name ? <span style={{ color: "var(--k2b-navy)", fontWeight: 700 }}>⏳ sending…{progress && progress.total ? ` batch ${progress.done} of ${progress.total}` : ""}</span> : r ? (r.status === "done" ? <span style={{ color: r.blocked ? "#8A4B00" : "#176A38" }}>{r.blocked ? "⚠ staged with a problem: " + r.blocked : "✓ staged"}{r.counts ? ` — ${r.counts.staged || 0} ready · ${r.counts.rejected || 0} problems · ${r.counts.skipped || 0} skipped` : ""}</span> : <span style={{ color: "#A02234" }}>✕ {r.msg}</span>) : <span style={{ color: "#999" }}>waiting</span>}</td>
                    </tr>
                  );
                })}
                {extras.map((w) => { const orphan = w.partOf && !det.found[w.partOf]; return <tr key={w.name} data-testid={"wb-sheet-" + w.name} data-status={orphan ? "not-imported" : "reference"} style={{ background: orphan ? "#FDECEA" : undefined }}><td style={cell}></td><td style={{ ...cell, fontWeight: 700 }}>{sheetName(w)}</td><td style={{ ...cell, ...num }}>{det.found[w.name].rows.length.toLocaleString("en-US")}</td><td style={cell} colSpan={4}><span style={{ color: orphan ? "#A02234" : "#555" }}>{orphan ? `NOT imported: its ${w.partOf} sheet is not in this file (or was not recognised) — job lines need their repair orders. Import the repair orders with them, or import this sheet later into Service — repair orders once the repair orders are on the server.` : <>{w.partOf ? "imported together with " + w.partOf : w.skip ? "not imported" : "kept for reference — not imported"}: {w.why}</>}</span></td></tr>; })}
                {det.unknown.map((u) => <tr key={"u-" + u.name} data-testid="wb-sheet-unknown" data-sheet={u.name} data-status="unrecognised" style={{ background: "#FDECEA" }}><td style={cell}></td><td style={{ ...cell, fontWeight: 700 }}>{u.name}</td><td style={{ ...cell, ...num }}>{u.rows.toLocaleString("en-US")}</td><td style={cell} colSpan={4}><span style={{ color: "#A02234" }}>Not recognised — NOT imported. Its name and columns match none of the old export's sheets ({WB_SHEETS.filter((w) => !w.skip).map((w) => w.name).join(", ")}). Rename it to the sheet it is, or import it on its own with the wizard (choose its destination first).</span></td></tr>)}
                {det.missing.map((n) => <tr key={"m-" + n} data-testid="wb-sheet-missing" data-sheet={n} data-status="missing" style={{ background: n === "GL_Opening_Balances" ? "#FFF3D6" : "#F7F7F7" }}><td style={cell}></td><td style={{ ...cell, fontWeight: 700, color: "#777" }}>{n}</td><td style={cell}></td><td style={cell} colSpan={4}><span style={{ color: n === "GL_Opening_Balances" ? "#8A4B00" : "#777" }}>{n === "GL_Opening_Balances" ? "Not in this file: NO opening balances are posted. The inventory accounts will carry no balance, so on Reconcile inventory to GL the right posting is (b) “Post the inventory to the books at cost” — unless the opening balances reach the ledger another way first (then (a))." : "Not in this file — nothing is imported for it."}</span></td></tr>)}
              </tbody>
            </table>
          </div>
          {progress && progress.total > 0 && <div data-testid="wb-progress" style={{ ...box, padding: "8px 12px" }}><div style={{ fontWeight: 700 }}>{cur}: batch {progress.done} of {progress.total} — {(progress.rows || 0).toLocaleString("en-US")} of {(progress.rowsTotal || 0).toLocaleString("en-US")} rows</div><div style={{ height: 14, background: "#E4E4E4", border: "1px solid #808080", marginTop: 4 }}><div style={{ width: Math.round(progress.done / progress.total * 100) + "%", height: "100%", background: "var(--k2b-green, #176A38)" }} /></div></div>}
          {stopped && <div data-testid="wb-stopped" style={{ padding: "8px 12px", background: "#FDECEA", border: "1px solid #F3B8B0", fontSize: 12 }}>The run stopped at <b>{stopped}</b>: {results[stopped] && results[stopped].msg} — the sheets before it are on the server waiting for approval. Fix the file (or the books) and run again (a new run).</div>}
          {staged && !running && (
            <div data-testid="wb-done" data-run={staged.runId} style={{ padding: "9px 12px", background: "#FFF8E6", border: "1px solid #E7D49A", borderRadius: 4, fontSize: 12, lineHeight: 1.5, display: "flex", gap: 10, alignItems: "center", flexWrap: "wrap" }}>
              <div style={{ flex: "1 1 360px" }}><b>Every sheet is on the server — import run <span data-testid="wb-run-id" style={{ fontFamily: "'Courier Prime', monospace" }}>{staged.runId}</span> is <span data-testid="wb-run-status">{staged.run ? staged.run.statusWord : "waiting for approval"}</span>.</b> Nothing is saved or posted yet. {staged.run ? `${staged.run.totals.ready} rows ready · ${staged.run.totals.problems} with problems · ${staged.run.totals.skipped} skipped.` : ""} The owner reviews it on Import review &amp; approval: every problem row with what it most likely means, the lists tied to the ledger as of {asOf || "the as-of date"}{noOpening ? " (this file had NO opening balances — the accounts carry no balance yet)" : ""}, and the reconciling entries to tick.{det.unknown.length ? ` ${det.unknown.length} sheet${det.unknown.length === 1 ? " was" : "s were"} not recognised and not imported.` : ""}</div>
              <button className="k2b-button small" data-testid="wb-open-review" onClick={() => openReview(staged.runId)} style={btn(true, { background: "#FFD08A" })}>Review &amp; approve ▸</button>
            </div>
          )}
        </div>
        <div style={{ flex: "0 0 auto", display: "flex", gap: 8, alignItems: "center", padding: "8px 14px", borderTop: "1px solid #D6DEE7", background: "#F7F9FB" }}>
          <button className="k2b-button small" onClick={onClose} style={btn(false)}>Close</button>
          <span style={{ flex: 1 }} />
          {!staged && <button className="k2b-button" data-testid="wb-run" disabled={running || !jobs.length} onClick={runAll} style={btn(true, { padding: "6px 18px" })}>{running ? "Sending…" : stopped ? "Send again (a new run)" : `Send all ${jobs.length} sheets for approval`}</button>}
        </div>
      </div>
    );
  };

  /* ═══════════════════════════════ 2. Reconcile inventory to GL ═══════════════════════════════ */
  // RC25 fix round: the account that takes an adjusting entry is never guessed into a GM-program account, and when the imported units
  // carry no account (the old Inventory sheet has none) the office picks it — the default is the only account, else the account the
  // assigned items sit on with the largest difference (never a PROGRAM one), else nothing.
  const isProgram = (a) => /PROGRAM/i.test(String((a && a.name) || ""));
  const defaultPick = (s) => {
    if (!s.accounts.length) return "";
    if (s.accounts.length === 1) return s.accounts[0].acct;
    const withItems = s.accounts.filter((a) => a.items > 0 && !isProgram(a)).sort((a, b) => Math.abs(b.diffCents) - Math.abs(a.diffCents));
    return s.unassignedItems === 0 && withItems.length ? withItems[0].acct : "";
  };
  const ScheduleCard = ({ s, data, conv, may, onPost, busy, acctSel, setAcctSel, complete, setComplete, perAcct, setPerAcct }) => {
    const [open, setOpen] = React.useState(false);
    const diffColor = s.diffCents === 0 ? "#176A38" : "#A02234";
    const pick = acctSel[s.key] !== undefined ? acctSel[s.key] : defaultPick(s);
    const unit = s.unit;
    const confirmed = !s.partial || !!complete[s.key];
    const blockedWhy = !may ? "The office posts this (Admin / F&I, Office Manager, Accounting)." : !conv ? "Pick the conversion / clearing account first." : s.laterEntry && s.laterEntry.future ? "An entry on these accounts is dated in the future — correct its date in Accounting first." : s.laterEntry ? "An entry on these accounts is dated after this day — pick a later as-of date." : !confirmed ? "Tick “the list is complete” first (only when the accountant confirms it)." : "";
    const ready = may && conv && !busy && confirmed;
    return (
      <div data-testid={"rc-schedule-" + s.key} data-diff={s.diffCents} data-gl={s.glCents} data-sub={s.subledgerCents} data-partial={s.partial ? "1" : "0"} style={{ ...box, padding: "10px 12px", display: "flex", flexDirection: "column", gap: 8 }}>
        <div style={{ display: "flex", gap: 10, alignItems: "baseline", flexWrap: "wrap" }}>
          <div style={{ fontWeight: 700, fontSize: 14, color: "var(--k2b-navy)" }}>{s.label}</div>
          <div style={{ color: "#555", fontSize: 11.5 }}>{s.detail}</div>
          {s.partial && <span data-testid="rc-info-only" style={{ fontSize: 11, fontWeight: 700, color: "#8A4B00", background: "#FFF3D6", border: "1px solid #E7D49A", borderRadius: 3, padding: "1px 6px" }}>information</span>}
          <span style={{ flex: 1 }} />
          <div data-testid="rc-state" style={{ fontWeight: 700, color: s.hasDetail ? diffColor : "#8A4B00" }}>{s.hasDetail ? (s.diffCents === 0 ? "✓ agrees to the cent" : (s.diffCents > 0 ? "list higher by " : "ledger higher by ") + money(Math.abs(s.diffCents))) : "no imported list yet"}</div>
        </div>
        <table style={{ width: "100%", borderCollapse: "collapse" }}>
          <thead><tr><th style={hcell}>GL account</th><th style={hcell}>Name</th><th style={{ ...hcell, ...num }}>Ledger balance</th><th style={{ ...hcell, ...num }}>On the list</th><th style={{ ...hcell, ...num }}>Difference</th><th style={{ ...hcell, ...num }}>{unit}s</th></tr></thead>
          <tbody>
            {s.accounts.map((a) => <tr key={a.acct} data-testid="rc-acct" data-acct={a.acct} data-gl={a.glCents} data-sub={a.subCents} data-items={a.items}><td style={{ ...cell, fontFamily: "'Courier Prime', monospace", fontWeight: 700 }}>{a.acct}</td><td style={cell}>{a.name}</td><td style={{ ...cell, ...num }}>{money(a.glCents)}</td><td style={{ ...cell, ...num }}>{a.items ? money(a.subCents) : <span style={{ color: "#999" }}>—</span>}</td><td style={{ ...cell, ...num, color: a.items && a.diffCents ? "#A02234" : undefined }}>{a.items ? money(a.diffCents) : ""}</td><td style={{ ...cell, ...num }}>{a.items || ""}</td></tr>)}
            {!s.accounts.length && <tr><td style={cell} colSpan={6}><span style={{ color: "#A02234" }}>No general-ledger account is mapped to this schedule — open “Schedule map” and pick the account(s).</span></td></tr>}
            {s.unassignedItems > 0 && <tr data-testid="rc-unassigned"><td style={cell} colSpan={2}><i>{s.unassignedItems} {unit}{s.unassignedItems === 1 ? "" : "s"} without a GL account on the record{s.accounts.length > 1 ? " — the schedule total is what ties; the list cannot be split by account" : ""}</i></td><td style={cell}></td><td style={{ ...cell, ...num }}>{money(s.unassignedCents)}</td><td style={cell}></td><td style={{ ...cell, ...num }}>{s.unassignedItems}</td></tr>}
            <tr style={{ fontWeight: 700, background: "#F7F9FB" }}><td style={cell} colSpan={2}>Total</td><td data-testid="rc-gl" style={{ ...cell, ...num }}>{money(s.glCents)}</td><td data-testid="rc-sub" style={{ ...cell, ...num }}>{s.hasDetail ? money(s.subledgerCents) : "—"}</td><td data-testid="rc-diff" style={{ ...cell, ...num, color: diffColor }}>{s.hasDetail ? money(s.diffCents) : ""}</td><td style={{ ...cell, ...num }}>{s.itemCount || ""}</td></tr>
          </tbody>
        </table>
        <div style={{ fontSize: 11.5, lineHeight: 1.5 }}>{s.words.state}</div>
        {s.importRef && <div data-testid="rc-import-ref" style={{ fontSize: 11, color: "#555" }}>The list comes from {s.importRef.kind}{s.importRef.file ? " “" + s.importRef.file + "”" : ""}{s.importRef.at ? ", " + String(s.importRef.at).slice(0, 10) : ""} — a posting is linked to it ({s.importRef.id}).</div>}
        {s.problemItems > 0 && <div data-testid="rc-problems" style={{ fontSize: 11.5, color: "#8A4B00" }}>⚠ {s.problemItems} {unit}{s.problemItems === 1 ? " has a cost" : "s have a cost"} that was rounded to the cent or could not be read — see “Show the {unit}s” (the note on each); fix the record before posting.</div>}
        {/* RC28 (fx, the reviewer's finding 1): a cost / quantity that can't be read blocks every posting of the schedule (never counted as $0.00) */}
        {s.unreadableItems > 0 && <div data-testid="rc-unreadable" style={{ padding: "6px 10px", background: "#FDECEA", border: "1px solid #F3B8B0", fontSize: 11.5, lineHeight: 1.45 }}>⛔ {s.words.unreadable} {(s.unreadable || []).slice(0, 8).map((u) => (u.missing ? `${u.id} (no cost entered)` : `${u.id} (${u.field === "onHand" ? "on hand" : u.field === "costBooked" ? "GL cost" : u.field} "${u.value}")`)).join(", ")}{s.unreadableItems > 8 ? " …" : ""}</div>}
        {s.laterEntry && <div data-testid="rc-later" style={{ padding: "6px 10px", background: "#FDECEA", border: "1px solid #F3B8B0", fontSize: 11.5, lineHeight: 1.45 }}>⚠ {s.words.later}</div>}
        {s.partial && (
          <div data-testid="rc-partial" style={{ padding: "6px 10px", background: "#FFF8E6", border: "1px solid #E7D49A", fontSize: 11.5, lineHeight: 1.45 }}>
            {s.words.partial}
            {s.hasDetail && s.diffCents !== 0 && may && <label style={{ display: "flex", gap: 6, alignItems: "center", marginTop: 4, fontWeight: 700 }}><input type="checkbox" data-testid="rc-complete" checked={!!complete[s.key]} onChange={(e) => setComplete({ ...complete, [s.key]: e.target.checked })} /> The list above is complete — the accountant confirmed it is the whole balance of {s.accounts.map((a) => a.acct).join(" / ") || "the account"}</label>}
          </div>
        )}
        {s.hasDetail && s.itemCount > 0 && <div><button className="k2b-button small" data-testid="rc-items-toggle" onClick={() => setOpen(!open)} style={btn(false)}>{open ? "Hide" : "Show"} the {s.itemCount} {unit}{s.itemCount === 1 ? "" : "s"} behind the total</button></div>}
        {open && (
          <div style={{ ...box, maxHeight: 320, overflow: "auto" }}>
            <table data-testid="rc-items" style={{ width: "100%", borderCollapse: "collapse" }}>
              <thead><tr>{(s.key === "parts" ? ["Part #", "Description", "Bin", "On hand", "Cost", "Value", "Account", "Note"] : s.key === "wip" ? ["RO #", "Date", "Customer", "Vehicle", "Labor cost", "On the board"] : s.key === "ar" ? ["Who", "A/R control #", "GL account", "Amount"] : SVC_KEYS[s.key] ? ["What", "RO / claim / core", "Date", "Customer", "Amount", "Note"] : ["Stock #", "VIN", "Vehicle", "N/U", "Account", "GL cost", "Note"]).map((h) => <th key={h} style={hcell}>{h}</th>)}</tr></thead>
              <tbody>{(s.items || []).map((it, i) => (
                s.key === "parts" ? <tr key={i} data-testid="rc-item"><td style={{ ...cell, fontFamily: "'Courier Prime', monospace" }}>{it.part}</td><td style={cell}>{it.desc}</td><td style={cell}>{it.bin}</td><td style={{ ...cell, ...num }}>{it.onHand}</td><td style={{ ...cell, ...num }}>{money(it.costCents)}</td><td style={{ ...cell, ...num }}>{money(it.cents)}</td><td style={cell}>{it.acct || ""}</td><td style={{ ...cell, color: "#8A4B00" }}>{it.note || ""}</td></tr>
                : s.key === "wip" ? <tr key={i} data-testid="rc-item"><td style={{ ...cell, fontFamily: "'Courier Prime', monospace" }}>{it.roNo || it.part}</td><td style={cell}>{it.date || (it.kind === "tank" ? "bulk oil" : it.status === "held" ? "held" : "open")}</td><td style={cell}>{it.customer || it.desc || ""}</td><td style={cell}>{it.vehicle || ""}</td><td style={{ ...cell, ...num }}>{it.costHidden ? "—" : money(it.cents)}</td><td style={cell}>{it.k2bRoId || "—"}</td></tr>
                : SVC_KEYS[s.key] ? <tr key={i} data-testid="rc-item" data-kind={it.kind}><td style={cell}>{SVC_ITEM_WORD[it.kind] || it.kind}</td><td style={{ ...cell, fontFamily: "'Courier Prime', monospace" }}>{it.claim || it.roNo || it.part || ""}</td><td style={cell}>{it.date || ""}</td><td style={cell}>{it.customer || it.desc || ""}</td><td style={{ ...cell, ...num }}>{it.costHidden ? "—" : money(it.cents)}</td><td style={{ ...cell, color: "#8A4B00" }}>{it.note || (it.imported ? "imported" : "")}</td></tr>
                : s.key === "ar" ? <tr key={i} data-testid="rc-item"><td style={cell}>{it.customer}</td><td style={{ ...cell, fontFamily: "'Courier Prime', monospace" }}>{it.control}</td><td style={cell}>{it.acct || ""}</td><td style={{ ...cell, ...num }}>{money(it.cents)}</td></tr>
                : <tr key={i} data-testid="rc-item" data-stock={it.stock}><td style={{ ...cell, fontFamily: "'Courier Prime', monospace" }}>{it.stock}</td><td style={{ ...cell, fontFamily: "'Courier Prime', monospace" }}>{it.vin}</td><td style={cell}>{it.desc}</td><td style={cell}>{it.type}</td><td style={cell}>{it.acct || <span style={{ color: "#999" }}>none{it.guessedAcct ? ` (the import guessed ${it.guessedAcct} from the model — not used)` : ""}</span>}</td><td style={{ ...cell, ...num }}>{money(it.cents)}</td><td style={{ ...cell, color: "#8A4B00" }}>{it.note || ""}</td></tr>
              ))}{s.itemsHidden > 0 && <tr><td style={cell} colSpan={8}>… and {s.itemsHidden} more (all are counted).</td></tr>}</tbody>
            </table>
          </div>
        )}
        {s.posts && s.posts.length > 0 && <div data-testid="rc-posts" style={{ fontSize: 11.5, color: "#555" }}>Earlier: {s.posts.slice(0, 3).map((p) => `${p.kind === "checked" ? "marked reconciled" : p.kind === "adjust" ? "adjusting entry " + p.journalId + " " + money(p.diffCents) : "posted at cost " + p.journalId + " " + money(p.diffCents)} as of ${p.asOf} (${p.by || ""}${p.runId ? ", import " + p.runId : ""})`).join(" · ")}</div>}
        {/* the two actions — ALWAYS both offered, with the words that say when each is the right one */}
        <div style={{ display: "grid", gridTemplateColumns: "repeat(auto-fit, minmax(300px, 1fr))", gap: 8 }}>
          <div data-testid="rc-action-adjust" style={{ padding: "8px 10px", background: s.canAdjust && confirmed ? "#FFF8E6" : "#F7F7F7", border: "1px solid #E7D49A", borderRadius: 4, display: "flex", flexDirection: "column", gap: 6 }}>
            <div style={{ fontWeight: 700 }}>(a) Post one adjusting entry for the difference</div>
            <div style={{ fontSize: 11.5, lineHeight: 1.45 }}>{s.words.adjust}</div>
            {s.accounts.length > 1 && <label style={{ fontSize: 11.5 }}>Account that takes the entry: <select data-testid="rc-adjust-acct" value={pick} onChange={(e) => setAcctSel({ ...acctSel, [s.key]: e.target.value })} style={{ font: "inherit" }}><option value="">— pick the account (ask the accountant) —</option>{s.accounts.map((a) => <option key={a.acct} value={a.acct}>{a.acct} {a.name}</option>)}</select></label>}
            {s.accounts.length > 1 && s.unassignedItems === 0 && <label style={{ fontSize: 11.5, display: "flex", gap: 6, alignItems: "center" }}><input type="checkbox" data-testid="rc-per-account" checked={perAcct[s.key] !== undefined ? !!perAcct[s.key] : !!s.needsPerAccount} onChange={(e) => setPerAcct({ ...perAcct, [s.key]: e.target.checked })} /> Only this account, to its own list (one entry per account — every {unit} carries its account){s.needsPerAccount ? <b data-testid="rc-needs-per-account"> — {(s.accountsOff || []).join(" and ")} are both off: post one entry for each</b> : null}</label>}
            <div><button className="k2b-button small" data-testid="rc-adjust" disabled={!ready || !s.canAdjust || !pick} title={blockedWhy || (!pick ? "Pick the account that takes the entry." : "")} onClick={() => onPost("adjust", s, pick)} style={btn(s.canAdjust && confirmed, { background: s.canAdjust && confirmed ? "#FFD08A" : undefined })}>{busy === s.key + "adjust" ? "Posting…" : s.hasDetail && s.diffCents !== 0 ? `Post ${money(Math.abs(s.diffCents))} ${s.diffCents > 0 ? "debit" : "credit"} to ${pick || "…"}` : "Nothing to post (difference is zero)"}</button></div>
          </div>
          <div data-testid="rc-action-atcost" style={{ padding: "8px 10px", background: s.canAtCost && confirmed ? "#EAF7EE" : "#F7F7F7", border: "1px solid #9ED9B1", borderRadius: 4, display: "flex", flexDirection: "column", gap: 6 }}>
            <div style={{ fontWeight: 700 }}>(b) Post the inventory to the books at cost</div>
            <div style={{ fontSize: 11.5, lineHeight: 1.45 }}>{s.words.atCost}</div>
            {s.accounts.length > 1 && s.unassignedItems > 0 && <label style={{ fontSize: 11.5 }}>Account for the {unit}s without one: <select data-testid="rc-atcost-acct" value={pick} onChange={(e) => setAcctSel({ ...acctSel, [s.key]: e.target.value })} style={{ font: "inherit" }}><option value="">— pick the account —</option>{s.accounts.map((a) => <option key={a.acct} value={a.acct}>{a.acct} {a.name}</option>)}</select></label>}
            <div><button className="k2b-button small" data-testid="rc-atcost" disabled={!ready || !s.canAtCost || (s.accounts.length > 1 && s.unassignedItems > 0 && !pick)} title={blockedWhy || (!s.allAccountsEmpty ? "An account of this schedule already carries a balance (even if they add up to zero) — use (a), one entry per account." : "")} onClick={() => onPost("at-cost", s, pick)} style={btn(s.canAtCost && confirmed, { background: s.canAtCost && confirmed ? "#BDE5C8" : undefined })}>{busy === s.key + "at-cost" ? "Posting…" : s.hasDetail ? `Post ${money(s.subledgerCents)} at cost` : "Nothing to post"}</button></div>
          </div>
        </div>
        {s.canMark && may && <div><button className="k2b-button small" data-testid="rc-mark" disabled={!!busy} onClick={() => onPost("mark", s, pick)} style={btn(false)}>✓ Mark “{s.label}” reconciled as of this date (nothing is posted)</button></div>}
      </div>
    );
  };

  // RC33 (svi): the service lists' items on Reconcile Inventory
  const SVC_KEYS = { sublet: 1, warranty: 1, body: 1 };
  const SVC_ITEM_WORD = { ro: "old RO", k2bro: "K2B RO (sublet)", core: "core on the shelf", claim: "warranty claim", chargeback: "chargeback of a paid claim (GM takes it next)", job: "body-shop job", tank: "bulk oil" };   // chargeback: RC33 merge (rc33m)
  const ImpReconcileWindow = ({ onClose, go, embedded, asOf: asOf0 }) => {
    const Dm = D();
    const [asOf, setAsOf] = React.useState(asOf0 || todayIso());
    const [data, setData] = React.useState(null);
    const [settings, setSettings] = React.useState(null);
    const [err, setErr] = React.useState("");
    const [loading, setLoading] = React.useState(false);
    const [conv, setConv] = React.useState("");
    const [acctSel, setAcctSel] = React.useState({});
    const [perAcct, setPerAcct] = React.useState({});   // RC28 (fx, finding 4): one adjusting entry per account
    const [complete, setComplete] = React.useState({});   // RC25 fix round: "the list is complete" per partial schedule (WIP / A/R)
    const [busy, setBusy] = React.useState("");
    const [msg, setMsg] = React.useState(null);
    const [confirm, setConfirm] = React.useState(null);
    const [mapOpen, setMapOpen] = React.useState(false);
    const [mapDraft, setMapDraft] = React.useState({});
    const [exDraft, setExDraft] = React.useState([]);   // RC26 (inv): the office's extra non-inventory accounts
    const may = !!(data && data.may && data.may.post);
    const load = React.useCallback(async (date) => {
      if (!Dm || typeof Dm._apiGet !== "function") { setErr("This DMS page is older than the server — reload it (Ctrl+F5)."); return; }
      setLoading(true); setErr("");
      try {
        const d = await Dm._apiGet("/import/reconcile?asOf=" + encodeURIComponent(date || asOf));
        setData(d);
        setConv((c) => (c && (d.conversion.choices || []).some((a) => a.acct === c)) ? c : (d.conversion.acct || ""));
        if (!settings) { try { setSettings(await Dm._apiGet("/import/reconcile/settings")); } catch (e) {} }
      } catch (e) { setErr(errText(e)); }
      setLoading(false);
    }, [asOf, settings]);
    React.useEffect(() => { load(asOf); }, []);   // eslint-disable-line
    const onPost = (kind, s, pick) => {
      if (kind === "mark") return doPost(kind, s, pick);
      const Cc = C();
      let lines = [];
      // RC28 (fx, finding 4): "only this account, to its own list" — the account's own difference (one entry per account)
      const one = kind === "adjust" && (perAcct[s.key] !== undefined ? perAcct[s.key] : s.needsPerAccount) ? (s.accounts.find((a) => a.acct === pick) || null) : null;   // RC28 fix round (audit FU2)
      if (kind === "adjust") lines = Cc ? Cc.adjustLines(pick, conv, one ? one.diffCents : s.diffCents) : [];
      else { const by = {}; s.accounts.forEach((a) => { if (a.subCents) by[a.acct] = (by[a.acct] || 0) + a.subCents; }); if (s.unassignedCents) by[pick || (s.accounts[0] || {}).acct] = (by[pick || (s.accounts[0] || {}).acct] || 0) + s.unassignedCents; lines = Cc ? Cc.atCostLines(by, conv) : []; }
      setConfirm({ kind, s, pick, lines });
    };
    const doPost = async (kind, s, pick) => {
      setConfirm(null); setMsg(null);
      const key = Dm._newIdemKey(kind === "adjust" ? "ia" : kind === "at-cost" ? "ic" : "im");
      // RC25 fix round: the posting names the import it reconciles (runId) and, for a partial list, the office's "the list is complete"
      const extra = Object.assign({}, s.importRef && s.importRef.id ? { runId: s.importRef.id } : {}, s.partial && complete[s.key] ? { listComplete: true } : {});
      const one = kind === "adjust" && (perAcct[s.key] !== undefined ? perAcct[s.key] : s.needsPerAccount) ? (s.accounts.find((a) => a.acct === pick) || null) : null;   // RC28 fix round (audit FU2)
      const body = kind === "adjust" ? Object.assign({ schedule: s.key, account: pick, asOf, conversionAcct: conv, expectedDiffCents: one ? undefined : s.diffCents }, one ? { perAccount: true } : {}, extra)
        : kind === "at-cost" ? Object.assign({ schedule: s.key, asOf, conversionAcct: conv, expectedCents: s.subledgerCents }, pick ? { account: pick } : {}, extra)
        : { schedule: s.key, asOf };
      setBusy(s.key + kind);
      const r = await Dm._command("/import/reconcile/" + kind, body, key, "/import/reconcile/op/");
      setBusy("");
      if (!r.ok) {
        const b = (r.err && r.err.body) || {};
        const text = r.unknown ? `The server did not answer. Look at the ledger before trying again (the office can look up ${key}).` : b.error || (r.err && r.err.message) || "The server refused this posting.";
        setMsg({ level: "error", text, code: b.code, journalId: b.journalId });
        toast(text, "warn", 7000);
        return;
      }
      const res = r.res || {};
      setMsg({ level: "ok", text: res.message || "Posted.", journalId: res.journalId, replayed: !!res.replayed });
      toast(res.message || "Posted.", "ok", 6000);
      if (res.conversionAcct) setConv(res.conversionAcct);
      load(asOf);
    };
    const saveConv = async () => { try { await Dm._apiPost("/import/reconcile/settings", { conversionAcct: conv }); toast("Saved as the default conversion / clearing account.", "ok"); } catch (e) { toast(errText(e), "warn", 6000); } };
    const openMap = () => { const d = {}; (data ? data.schedules : []).forEach((s) => { d[s.key] = s.accounts.map((a) => a.acct); }); setMapDraft(d); setExDraft(((data && data.excluded) || []).filter((x) => !x.fixed).map((x) => x.acct)); setMapOpen(true); };
    const saveMap = async () => { try { const m = {}; Object.keys(mapDraft).forEach((k) => { m[k] = (mapDraft[k] || []).filter((a) => !(exDraft || []).includes(a)); }); await Dm._apiPost("/import/reconcile/settings", { map: m, exclude: exDraft || [] }); setMapOpen(false); setSettings(null); toast("Schedule map saved — it is now the default for everyone.", "ok"); load(asOf); } catch (e) { toast(errText(e), "warn", 6000); } };
    const chart = (settings && settings.chart) || [];
    const invRange = chart.filter((a) => /^(22|23|24)\d/.test(a.acct));
    const suggested = data ? data.conversion.suggested : [];
    // RC25 fix round (audit H3): only balance-sheet accounts outside the inventories / receivables can be the other side; shown with their type
    const choices = (data && data.conversion.choices) || [];
    const sugSet = new Set(suggested.map((a) => a.acct));
    const groups = [["Suggested (the name says conversion / clearing / suspense / opening balance)", choices.filter((a) => sugSet.has(a.acct))], ["Equity and liabilities (3xx)", choices.filter((a) => !sugSet.has(a.acct) && /^3/.test(a.acct))], ["Other balance-sheet accounts", choices.filter((a) => !sugSet.has(a.acct) && !/^3/.test(a.acct))]].filter((g) => g[1].length);
    const convRow = choices.find((a) => a.acct === conv);
    const body = (
      <div data-testid="rc-screen" style={{ flex: 1, minHeight: 0, display: "flex", flexDirection: "column", background: "#FFF", fontFamily: "var(--font-ui)", fontSize: 12, color: "#000" }}>
        <div style={{ flex: "0 0 auto", padding: "8px 14px", borderBottom: "1px solid #E4E4E4", display: "flex", gap: 10, alignItems: "center", flexWrap: "wrap" }}>
          <div><div style={{ fontWeight: 700, fontSize: 15, color: "var(--k2b-navy)" }}>⚖ Reconcile inventory to the General Ledger</div><div style={{ color: "#555", fontSize: 11.5 }}>what the imported lists say is on the lot / shelf / in the shop, next to what the ledger carries, per inventory account</div></div>
          <span style={{ flex: 1 }} />
          <label style={{ fontSize: 12 }}>As of <input type="date" data-testid="rc-asof" value={asOf} onChange={(e) => setAsOf(e.target.value)} style={{ font: "inherit", padding: "3px 6px" }} /></label>
          <button className="k2b-button small" data-testid="rc-refresh" disabled={loading} onClick={() => load(asOf)} style={btn(true)}>{loading ? "Loading…" : "Show"}</button>
          <button className="k2b-button small" data-testid="rc-map-open" disabled={!data} onClick={openMap} style={btn(false)}>Schedule map…</button>
        </div>
        <div style={{ flex: "1 1 auto", minHeight: 0, overflow: "auto", padding: "10px 14px", display: "flex", flexDirection: "column", gap: 10 }}>
          {err && <div data-testid="rc-error" style={{ padding: "8px 12px", background: "#FDECEA", border: "1px solid #F3B8B0" }}>⚠ {err}</div>}
          {msg && <div data-testid="rc-msg" data-level={msg.level} data-code={msg.code || ""} style={{ padding: "8px 12px", background: msg.level === "ok" ? "#EAF7EE" : "#FDECEA", border: "1px solid " + (msg.level === "ok" ? "#9ED9B1" : "#F3B8B0"), fontSize: 12.5, lineHeight: 1.5 }}>{msg.level === "ok" ? "✓ " : "✕ "}{msg.text}{msg.journalId && msg.level === "ok" ? <> — entry <b data-testid="rc-msg-je">{msg.journalId}</b></> : null}</div>}
          {data && (
            <div data-testid="rc-conv" style={{ ...box, padding: "9px 12px", display: "flex", gap: 10, alignItems: "center", flexWrap: "wrap", background: "#F4F8FC" }}>
              <div style={{ flex: "1 1 360px", fontSize: 12, lineHeight: 1.45 }}><b>Conversion / clearing account</b> — the other side of every posting from this screen. It must be a <b>balance-sheet</b> account (asset, liability or equity) that is on no schedule: a sales / cost account would put the difference into this month's earnings. {suggested.length ? <>Suggested from the chart (its name says conversion / clearing / suspense / opening balance): <b>{suggested.map((a) => a.acct + " " + a.name).join(", ")}</b>.</> : <span data-testid="rc-conv-none" style={{ color: "#8A4B00" }}>No balance-sheet account in the chart is named conversion / clearing / suspense / opening balance — the office must pick one (ask the accountant which equity or clearing account the conversion goes to; it is remembered as the default once used).</span>}{data.conversion.savedRefused ? <span style={{ color: "#A02234" }}> The saved default {data.conversion.savedRefused} is not allowed any more (not a balance-sheet account outside the inventories) — pick another.</span> : null}</div>
              <select data-testid="rc-conv-select" value={conv} onChange={(e) => setConv(e.target.value)} style={{ font: "inherit", padding: "3px 6px", maxWidth: 380 }}>
                <option value="">— pick an account —</option>
                {groups.map(([label, list]) => <optgroup key={label} label={label}>{list.map((a) => <option key={a.acct} value={a.acct}>{a.acct} {a.name} · {a.type}</option>)}</optgroup>)}
              </select>
              {convRow && <span data-testid="rc-conv-type" style={{ fontSize: 11, color: "#555" }}>{convRow.type} · balance sheet</span>}
              <button className="k2b-button small" data-testid="rc-conv-save" disabled={!conv || !may} onClick={saveConv} style={btn(false)}>Remember as default</button>
              <span style={{ fontSize: 11, color: "#555" }}>as of {data.asOf} · {data.counts.entries} ledger entries · {data.counts.unitsOnLot} units on the lot · {data.counts.partsOnHand} parts with stock · {data.counts.openRos} open / {data.counts.heldRos} held imported ROs{data.openMonth && data.openMonth.open ? ` · open month ${data.openMonth.open}` : ""}{!may ? " · view only (the office posts)" : ""}</span>
            </div>
          )}
          {data && data.schedules.map((s) => <ScheduleCard key={s.key} s={s} data={data} conv={conv} may={may} onPost={onPost} busy={busy} acctSel={acctSel} setAcctSel={setAcctSel} complete={complete} setComplete={setComplete} perAcct={perAcct} setPerAcct={setPerAcct} />)}
          {data && (data.excluded || []).length > 0 && (
            <div data-testid="rc-excluded" style={{ ...box, padding: "9px 12px", background: "#FAFAFA" }}>
              <div style={{ fontWeight: 700, color: "#555" }}>Not inventory — left off this screen</div>
              <table style={{ borderCollapse: "collapse", marginTop: 4 }}><tbody>{data.excluded.map((a) => <tr key={a.acct} data-testid="rc-excluded-acct" data-acct={a.acct}><td style={{ ...cell, fontFamily: "'Courier Prime', monospace", fontWeight: 700 }}>{a.acct}</td><td style={cell}>{a.name}</td><td style={{ ...cell, color: "#555" }}>{a.note}</td></tr>)}</tbody></table>
            </div>
          )}
          {data && window.ImpGlLive ? <window.ImpGlLive asOf={data.asOf} /> : null}{/* RC36 (imp36): every import's tie-out, read from the live books the same way the review reads it */}
          {data && data.other.length > 0 && (
            <div data-testid="rc-other" style={{ ...box, padding: "9px 12px" }}>
              <div style={{ fontWeight: 700, color: "var(--k2b-navy)" }}>Other inventory-type accounts (no imported list to compare with)</div>
              <table style={{ borderCollapse: "collapse", marginTop: 4 }}><tbody>{data.other.map((a) => <tr key={a.acct}><td style={{ ...cell, fontFamily: "'Courier Prime', monospace", fontWeight: 700 }}>{a.acct}</td><td style={cell}>{a.name}</td><td style={{ ...cell, ...num }}>{money(a.glCents)}</td></tr>)}</tbody></table>
              <div style={{ fontSize: 11.5, color: "#555", marginTop: 4 }}>Tires, body-shop materials, sublets, cores and the lots have no list in the old export; they stay as the opening balances say. Add one to a schedule with “Schedule map” if a list for it is imported later.</div>
            </div>
          )}
        </div>
        {confirm && (
          <K2BModal title={confirm.kind === "adjust" ? "Post one adjusting entry?" : "Post the inventory at cost?"} width={620} onClose={() => setConfirm(null)}
            buttons={<><K2BButton small onClick={() => setConfirm(null)}>Cancel</K2BButton><button className="k2b-button small" data-testid="rc-confirm" onClick={() => doPost(confirm.kind, confirm.s, confirm.pick)} style={btn(true, { background: "#FFD08A" })}>Post it</button></>}>
            <div style={{ fontSize: 12.5, lineHeight: 1.55 }}>
              <div><b>{confirm.s.label}</b> as of <b>{asOf}</b>: {confirm.kind === "adjust" ? `the ledger carries ${money(confirm.s.glCents)}, the list says ${money(confirm.s.subledgerCents)} — the entry moves the ledger by ${money(Math.abs(confirm.s.diffCents))}.` : `the list says ${money(confirm.s.subledgerCents)} and the accounts are empty — the entry books every ${confirm.s.unit} at cost.`}</div>
              <table data-testid="rc-confirm-lines" style={{ borderCollapse: "collapse", margin: "8px 0", fontSize: 12 }}><tbody>{confirm.lines.map((l, i) => <tr key={i}><td style={{ ...cell, fontFamily: "'Courier Prime', monospace", fontWeight: 700 }}>{l.acct}</td><td style={{ ...cell, ...num }}>{l.dr ? "DR " + money(Math.round(l.dr * 100)) : ""}</td><td style={{ ...cell, ...num }}>{l.cr ? "CR " + money(Math.round(l.cr * 100)) : ""}</td></tr>)}</tbody></table>
              <div style={{ marginBottom: 6 }}>The other side: <b>{conv}</b> {convRow ? convRow.name + " (" + convRow.type + ", balance sheet)" : ""}.{confirm.s.partial ? " You confirmed the list is complete." : ""}{confirm.s.importRef ? ` Linked to the import ${confirm.s.importRef.id}.` : ""}</div>
              <div style={{ color: "#555" }}>Dated {asOf}, source Import, written by the server once (a second click says it is already posted). It goes through the ledger's rules — balanced, chart accounts, open month (a closed month needs the owner's override). It can only be corrected by a reversing entry in Accounting.</div>
            </div>
          </K2BModal>
        )}
        {mapOpen && (
          <K2BModal title="Which general-ledger accounts belong to which schedule?" width={720} onClose={() => setMapOpen(false)}
            buttons={<><K2BButton small onClick={() => setMapOpen(false)}>Cancel</K2BButton><button className="k2b-button small" data-testid="rc-map-save" disabled={!may} onClick={saveMap} style={btn(true)}>Save for everyone</button></>}>
            <div style={{ fontSize: 12, lineHeight: 1.5, display: "flex", flexDirection: "column", gap: 8, maxHeight: 420, overflow: "auto" }}>
              <div style={{ color: "#555" }}>The map was taken from the account NAMES in the chart (inventory-range accounts 220 / 230–249). Tick the accounts each list should be compared with; an account can be on one schedule only.</div>
              <div data-testid="rc-map-exclude" style={{ ...box, padding: "6px 10px", background: "#FAFAFA" }}>
                <div style={{ fontWeight: 700 }}>Not inventory — leave off this screen</div>
                <div style={{ color: "#555", fontSize: 11 }}>A lot, a building or other property the dealership owns is not inventory. 238 SAW MILL LOT is always left off (dealership property).</div>
                <div style={{ display: "flex", flexWrap: "wrap", gap: "4px 14px", marginTop: 4 }}>
                  {invRange.map((a) => { const fixed = (data.excluded || []).some((x) => x.acct === a.acct && x.fixed); const on = fixed || (exDraft || []).includes(a.acct); return (
                    <label key={a.acct} style={{ fontSize: 11.5, opacity: fixed ? 0.6 : 1 }}><input type="checkbox" data-testid={"rc-ex-" + a.acct} checked={on} disabled={fixed} onChange={(e) => setExDraft(e.target.checked ? (exDraft || []).concat([a.acct]) : (exDraft || []).filter((x) => x !== a.acct))} /> {a.acct} {a.name}</label>); })}
                </div>
              </div>
              {(data ? data.schedules : []).map((s) => (
                <div key={s.key} data-testid={"rc-map-" + s.key} style={{ ...box, padding: "6px 10px" }}>
                  <div style={{ fontWeight: 700 }}>{s.label}</div>
                  <div style={{ display: "flex", flexWrap: "wrap", gap: "4px 14px", marginTop: 4 }}>
                    {invRange.map((a) => { const on = (mapDraft[s.key] || []).includes(a.acct); const elsewhere = !on && Object.keys(mapDraft).some((k) => k !== s.key && (mapDraft[k] || []).includes(a.acct)); return (
                      <label key={a.acct} style={{ fontSize: 11.5, opacity: elsewhere ? 0.45 : 1 }}><input type="checkbox" checked={on} disabled={elsewhere} onChange={(e) => setMapDraft({ ...mapDraft, [s.key]: e.target.checked ? (mapDraft[s.key] || []).concat([a.acct]) : (mapDraft[s.key] || []).filter((x) => x !== a.acct) })} /> {a.acct} {a.name}</label>); })}
                  </div>
                </div>
              ))}
            </div>
          </K2BModal>
        )}
      </div>
    );
    if (embedded) return body;
    return (
      <div className="k2b-window" style={{ width: "100%", maxWidth: 1400, height: "calc(100vh - 110px)", minHeight: 420, margin: "0 auto", display: "flex", flexDirection: "column" }}>
        <K2BTitlebar title={"Reconcile inventory to GL — " + ((window.K2BStore && window.K2BStore.pageId()) || "") + "-" + (window.K2BStore ? window.K2BStore.branding().printName : "")} onClose={onClose} onMin={() => {}} onMax={() => {}} />
        {body}
      </div>
    );
  };

  /* ═══════════════════════════════ 3. Old ROs (the imported repair-order history) ═══════════════════════════════ */
  const ImpRoHistory = ({ embedded, go }) => {
    const Dm = D();
    const [q, setQ] = React.useState({ ro: "", vin: "", customer: "", stock: "", q: "" });
    const [rows, setRows] = React.useState(null);
    const [status, setStatus] = React.useState(null);
    const [sel, setSel] = React.useState(null);
    const [err, setErr] = React.useState("");
    const [loading, setLoading] = React.useState(false);
    const [links, setLinks] = React.useState(null);   // RC26 (inv): the links to K2B customers
    const [linkBusy, setLinkBusy] = React.useState(false);
    const [linkMsg, setLinkMsg] = React.useState(null);
    const [vinOpen, setVinOpen] = React.useState("");
    const loadLinks = async () => { try { setLinks(await Dm._apiGet("/import/link-status")); } catch (e) { setLinks(null); } };
    React.useEffect(() => { (async () => { try { setStatus(await Dm._apiGet("/import/status")); } catch (e) { setErr(errText(e)); } })(); loadLinks(); }, []);   // eslint-disable-line
    const linkAll = async () => {
      setLinkBusy(true); setLinkMsg(null);
      const r = await Dm._command("/import/link-ros", {}, Dm._newIdemKey("lnk"), "/ops/op/");
      setLinkBusy(false);
      const m = r.ok ? { ok: true, text: r.res.message } : { ok: false, text: (r.err && r.err.body && r.err.body.error) || (r.unknown ? "The server did not answer — look at the counts before pressing again." : "The server refused.") };
      setLinkMsg(m); toast(m.text, m.ok ? "ok" : "warn", 8000); loadLinks();
    };
    const custWord = (r) => r.linkHow === "phone" || r.linkHow === "vin" ? `${r.customerNum} (by ${r.linkHow === "phone" ? "customer #" : "VIN"})` : r.linkHow === "waiting" ? `${r.customerNum} — waiting for a customer with this number` : r.linkHow === "ambiguous" ? `${r.possible.length} possible matches` : "";   // RC30 (cn): the account IS the customer #, no area code
    const search = async () => {
      setLoading(true); setErr(""); setSel(null);
      try {
        const ps = Object.keys(q).filter((k) => q[k].trim()).map((k) => k + "=" + encodeURIComponent(q[k].trim()));
        const r = await Dm._apiGet("/import/ro-history?" + ps.concat(["limit=200"]).join("&"));
        setRows(r.rows);
      } catch (e) { setErr(errText(e)); }
      setLoading(false);
    };
    const openOne = async (roNo) => { try { const r = await Dm._apiGet("/import/ro-history/" + encodeURIComponent(roNo)); setSel(r.ro); } catch (e) { setErr(errText(e)); } };
    const by = (status && status.ros && status.ros.byStatus) || {};
    const body = (
      <div data-testid="rh-screen" style={{ display: "flex", flexDirection: "column", gap: 8, padding: embedded ? "8px 0" : "10px 14px", fontSize: 12 }}>
        <div style={{ ...box, padding: "8px 12px", display: "flex", gap: 10, alignItems: "center", flexWrap: "wrap" }}>
          <div style={{ fontWeight: 700, color: "var(--k2b-navy)" }}>Repair orders imported from the old system</div>
          {links && links.counts && <span data-testid="rh-link-counts" style={{ color: "#0E5A2A" }}>Linked to customers: by phone <b data-testid="rh-link-phone">{links.counts.phone}</b> · by VIN <b data-testid="rh-link-vin">{links.counts.vin}</b> · waiting for a customer <b data-testid="rh-link-waiting">{links.counts.waiting}</b> · several possible <b data-testid="rh-link-ambiguous">{links.counts.ambiguous}</b> · no number / owner {links.counts.none}{links.counts.notLinked ? " · not linked yet " + links.counts.notLinked : ""}</span>}
          {links && links.may && links.may.run && <button className="k2b-button small" data-testid="rh-link-run" disabled={linkBusy} onClick={linkAll} style={btn(true)}>{linkBusy ? "Linking…" : "Link old ROs to customers"}</button>}
          {linkMsg && <span data-testid="rh-link-msg" data-ok={linkMsg.ok ? "1" : "0"} style={{ color: linkMsg.ok ? "#0E7A37" : "#A02234" }}>{linkMsg.text}</span>}
          <span data-testid="rh-counts" style={{ color: "#555" }}>{status ? `${(status.ros.count || 0).toLocaleString("en-US")} on the server — closed ${(by.closed || {}).count || 0} · open ${(by.open || {}).count || 0} · held ${(by.held || {}).count || 0} · void ${(by.void || {}).count || 0} · ${(status.vehicles || 0).toLocaleString("en-US")} VINs in the lookup list` : "…"}</span>
        </div>
        <div style={{ ...box, padding: "8px 12px", display: "flex", gap: 8, alignItems: "center", flexWrap: "wrap" }}>
          {[["ro", "RO #"], ["vin", "VIN"], ["customer", "Customer account"], ["stock", "Stock #"], ["q", "Anything"]].map(([k, l]) => <label key={k} style={{ fontSize: 11.5 }}>{l} <input data-testid={"rh-" + k} value={q[k]} onChange={(e) => setQ({ ...q, [k]: e.target.value })} onKeyDown={(e) => { if (e.key === "Enter") search(); }} style={{ font: "inherit", padding: "3px 6px", width: k === "q" ? 160 : 120 }} /></label>)}
          <button className="k2b-button small" data-testid="rh-search" disabled={loading} onClick={search} style={btn(true)}>Find</button>
        </div>
        {err && <div style={{ color: "#A02234" }}>⚠ {err}</div>}
        {rows && (
          <div style={{ ...box, overflow: "auto", maxHeight: 360 }}>
            <table data-testid="rh-rows" style={{ width: "100%", borderCollapse: "collapse" }}>
              <thead><tr>{["RO #", "Date", "Status", "Account", "Customer #", "Vehicle", "VIN", "Payer", "Total"].map((h) => <th key={h} style={hcell}>{h}</th>)}</tr></thead>
              <tbody>{rows.map((r) => <tr key={r.roNo} data-testid="rh-row" data-ro={r.roNo} data-status={r.status} data-link={r.linkHow || ""} onClick={() => openOne(r.roNo)} style={{ cursor: "pointer" }}><td style={{ ...cell, fontFamily: "'Courier Prime', monospace", fontWeight: 700 }}>{r.roNo}</td><td style={cell}>{r.date || (r.status === "open" ? "open" : "")}</td><td style={cell}>{r.void ? "VOID" : r.status}{r.k2bRoId ? " · " + r.k2bRoId : ""}</td><td style={cell}>{r.customerAccount}</td><td data-testid="rh-cust" style={{ ...cell, color: r.linkHow === "waiting" || r.linkHow === "ambiguous" ? "#8A4B00" : "#0E5A2A" }}>{custWord(r)}</td><td style={cell}>{[r.year, r.make, r.model].filter(Boolean).join(" ")}</td><td style={{ ...cell, fontFamily: "'Courier Prime', monospace" }}>{r.vin}</td><td style={cell}>{r.payerWord}</td><td style={{ ...cell, ...num }}>{money(r.cents.total)}</td></tr>)}{!rows.length && <tr><td style={cell} colSpan={9}>Nothing found.</td></tr>}</tbody>
            </table>
          </div>
        )}
        {sel && (
          <div data-testid="rh-detail" style={{ ...box, padding: "9px 12px", display: "flex", flexDirection: "column", gap: 6 }}>
            <div style={{ fontWeight: 700, fontSize: 13, color: "var(--k2b-navy)" }}>RO {sel.roNo} — {sel.void ? "VOID" : sel.flagWord} {sel.date ? "· " + sel.date : ""} {sel.k2bRoId ? <button className="k2b-button small" onClick={() => goTo(go, "service")} style={btn(false, { marginLeft: 8 })}>Open {sel.k2bRoId} on the board ▸</button> : null}</div>
            <div data-testid="rh-link" data-link={sel.linkHow || ""}>K2B customer: <b>{sel.linkHow === "phone" || sel.linkHow === "vin" || sel.linkHow === "waiting" ? sel.customerNum : "—"}</b> {sel.linkNote ? <span style={{ color: "#555" }}>— {sel.linkNote}</span> : null}{sel.possible && sel.possible.length ? <span data-testid="rh-possible"> · possible matches: {sel.possible.map((p) => p.custNum + (p.name ? " " + p.name : "")).join("; ")}</span> : null}{sel.vin ? <button className="k2b-button small" data-testid="rh-vin-history" onClick={() => setVinOpen(sel.vin)} style={btn(false, { marginLeft: 8 })}>History by VIN ▸</button> : null}</div>
            <div>Old account <b>{sel.customerAccount || "—"}</b> · Vehicle <b>{[sel.year, sel.make, sel.model, sel.color].filter(Boolean).join(" ")}</b> · VIN <span style={{ fontFamily: "'Courier Prime', monospace" }}>{sel.vin || "—"}</span>{sel.stock ? ` · stock ${sel.stock}` : ""} · {sel.odometer != null ? sel.odometer.toLocaleString("en-US") + " mi" : ""} · tech {sel.tech || "—"} · advisor {sel.advisor || "—"}</div>
            <table style={{ borderCollapse: "collapse" }}><tbody>
              <tr>{["Parts", "Labor", "Sublet", "Supplies", "Tax", "Total", "Customer pay *", "Warranty / internal *"].map((h) => <th key={h} style={{ ...hcell, ...num }}>{h}</th>)}</tr>
              <tr>{["partsSale", "laborSale", "subletSale", "supplies", "salesTax", "total", "customerPay", "otherPay"].map((k) => <td key={k} data-testid={"rh-" + k} style={{ ...cell, ...num }}>{money(sel.cents[k])}</td>)}</tr>
              <tr>{sel.costHidden ? <td data-testid="rh-cost-hidden" style={{ ...cell, color: "#777" }} colSpan={3}>cost: not shown to your role</td> : ["partsCost", "laborCost", "subletCost"].map((k) => <td key={k} data-testid={"rh-" + k} style={{ ...cell, ...num, color: "#555" }}>cost {money(sel.cents[k])}</td>)}<td style={cell} colSpan={5}><span style={{ color: "#555" }}>payer: {sel.payerWord}{sel.taxRatePct != null ? ` · tax rate ${sel.taxRatePct}%` : ""}</span></td></tr>
            </tbody></table>
            {sel.lines && sel.lines.length > 0 && <div data-testid="rh-lines"><b>Job lines</b><ol style={{ margin: "2px 0 0 18px" }}>{sel.lines.map((l, i) => <li key={i}>{l.text}{l.op ? <span style={{ color: "#555" }}> ({l.op})</span> : null}</li>)}</ol></div>}
            {sel.note && <div style={{ color: "#8A4B00" }}>{sel.note}</div>}
            <div style={{ color: "#777", fontSize: 11 }}>History from the old system (import run {sel.runId}). No journal entry was posted for it in K2B. * the old export's x_customer_pay_total / x_warranty_or_internal_total, shown as printed: their meaning is not confirmed, so they decide nothing in K2B. The old account is the old service system's number — the customer's phone without the area code, which IS the K2B Customer # (RC30); the link above is by that number first, then by the VIN's owner at the RO date.</div>
          </div>
        )}
      </div>
    );
    const withVin = <>{body}{vinOpen && <ImpVehicleHistory vin={vinOpen} onClose={() => setVinOpen("")} />}</>;
    if (embedded) return withVin;
    return <div className="k2b-window" style={{ width: "100%", maxWidth: 1240, margin: "0 auto" }}><K2BTitlebar title="Old repair orders (imported)" onClose={() => {}} />{withVin}</div>;
  };

  /* ═══════════════════════════════ RC26 (inv): the history of a vehicle by VIN, the customer's old ROs ═══════════════════════════════ */
  const KIND_WORD = { deal: "Sold", trade: "Traded in", "ro-old": "Old RO", ro: "K2B RO", body: "Body shop" };
  const ImpVehicleHistory = ({ vin, onClose }) => {
    const Dm = D();
    const [d, setD] = React.useState(null);
    const [err, setErr] = React.useState("");
    React.useEffect(() => { (async () => { try { setD(await Dm._apiGet("/import/vehicle-history?vin=" + encodeURIComponent(vin))); } catch (e) { setErr(errText(e)); } })(); }, [vin]);   // eslint-disable-line
    return (
      <K2BModal title={"Vehicle history — " + vin} width={880} onClose={onClose} buttons={<K2BButton small onClick={onClose}>Close</K2BButton>}>
        <div data-testid="vh-screen" data-vin={vin} style={{ fontSize: 12, display: "flex", flexDirection: "column", gap: 6, maxHeight: 520, overflow: "auto" }}>
          {err && <div style={{ color: "#A02234" }}>⚠ {err}</div>}
          {!d && !err && <div>Loading…</div>}
          {d && <div><b>{d.vehicle || "Vehicle"}</b> · VIN <span style={{ fontFamily: "'Courier Prime', monospace" }}>{d.vin}</span>{d.inStock ? ` · in inventory as ${d.inStock.stock} (${d.inStock.status || "—"})` : ""} · {d.counts.deals} sale{d.counts.deals === 1 ? "" : "s"}, {d.counts.trades} trade{d.counts.trades === 1 ? "" : "s"}, {d.counts.oldRos} old RO{d.counts.oldRos === 1 ? "" : "s"}, {d.counts.k2bRos} K2B RO{d.counts.k2bRos === 1 ? "" : "s"}</div>}
          {d && (
            <table data-testid="vh-events" style={{ width: "100%", borderCollapse: "collapse" }}>
              <thead><tr>{["Date", "What", "Number", "Owner at the time", "Odometer", "Total"].concat(d.costShown ? ["Cost"] : []).map((h) => <th key={h} style={hcell}>{h}</th>)}</tr></thead>
              <tbody>{d.events.map((e, i) => (
                <tr key={i} data-testid="vh-event" data-kind={e.kind} data-ref={e.roNo || e.roId || e.dealId || ""}>
                  <td style={cell}>{e.date || "—"}</td>
                  <td style={cell}>{KIND_WORD[e.kind] || e.kind}{e.status && e.kind !== "deal" && e.kind !== "trade" ? " · " + e.status : ""}</td>
                  <td style={{ ...cell, fontFamily: "'Courier Prime', monospace", fontWeight: 700 }}>{e.roNo || e.roId || e.dealId || ""}</td>
                  <td data-testid="vh-owner" style={cell}>{e.owner ? (e.owner.name || "—") + (e.owner.custNum ? " · " + e.owner.custNum : "") + (e.kind === "ro-old" && e.linkHow === "waiting" ? " (waiting for a customer)" : "") : (e.kind === "ro-old" && e.possible && e.possible.length ? e.possible.length + " possible customers" : "—")}</td>
                  <td style={{ ...cell, ...num }}>{e.odometer != null && e.odometer !== "" ? Number(e.odometer).toLocaleString("en-US") : ""}</td>
                  <td style={{ ...cell, ...num }}>{e.totalCents != null ? money(e.totalCents) : ""}</td>
                  {d.costShown && <td data-testid="vh-cost" style={{ ...cell, ...num, color: "#555" }}>{e.costCents != null ? money(e.costCents) : ""}</td>}
                </tr>))}
                {!d.events.length && <tr><td style={cell} colSpan={7}>Nothing on file for this VIN.</td></tr>}
              </tbody>
            </table>
          )}
          <div style={{ color: "#777", fontSize: 11 }}>The owner of an old RO is its linked K2B customer, else the vehicle's owner at that date from the deals (the latest sale before it, or the customer who traded it in later).</div>
        </div>
      </K2BModal>
    );
  };
  const ImpVinHistoryButton = ({ vin, label, small }) => {
    const [open, setOpen] = React.useState(false);
    const v = String(vin || "").trim();
    if (v.length < 11) return null;
    return <><button type="button" className="k2b-button small" data-testid="vin-history-btn" data-vin={v} onClick={(e) => { e.stopPropagation(); setOpen(true); }} style={btn(false, small ? { padding: "2px 8px" } : {})}>{label || "History by VIN"}</button>{open && <ImpVehicleHistory vin={v} onClose={() => setOpen(false)} />}</>;
  };
  const ImpCustomerOldRos = ({ custNum }) => {
    const Dm = D();
    const [d, setD] = React.useState(null);
    React.useEffect(() => { let live = true; (async () => { try { const r = await Dm._apiGet("/import/customer-history?custNum=" + encodeURIComponent(custNum)); if (live) setD(r); } catch (e) { if (live) setD({ ok: false }); } })(); return () => { live = false; }; }, [custNum]);   // eslint-disable-line
    if (!d || d.ok === false || (!d.ros.length && !d.vehicles.length)) return null;
    return (
      <div data-testid="cust-old-ros" data-count={d.ros.length} style={{ marginTop: 14 }}>
        <div style={{ fontSize: 11, textTransform: "uppercase", letterSpacing: "0.06em", color: "var(--jb-text-dim)", fontWeight: 700, marginBottom: 6 }}>Old repair orders — the old system ({d.ros.length}){d.counts.waiting ? ` · ${d.counts.waiting} matched by this Customer #` : ""}</div>
        <div style={{ display: "flex", flexDirection: "column", gap: 3, maxHeight: 260, overflow: "auto" }}>
          {d.ros.slice(0, 200).map((r) => (
            <div key={r.roNo} data-testid="cust-old-ro" data-ro={r.roNo} data-link={r.linkHow} style={{ display: "flex", gap: "4px 10px", flexWrap: "wrap", padding: "4px 10px", background: "var(--jb-surface-2)", borderRadius: 4, fontSize: 12 }}>
              <b>{r.roNo}</b><span>{r.date}</span><span style={{ color: "var(--jb-text-dim)" }}>{r.vehicle}</span><span style={{ flex: 1 }} /><span>{money(r.totalCents)}</span><span style={{ fontSize: 10, color: "var(--jb-text-dim)" }}>{r.linkHow === "phone" ? "by phone" : r.linkHow === "vin" ? "by VIN" : r.linkHow === "waiting" ? "by customer #" : r.linkHow}</span>
            </div>))}
        </div>
        {d.vehicles.length > 0 && <div data-testid="cust-old-vehicles" style={{ marginTop: 6, display: "flex", flexDirection: "column", gap: 3 }}>{d.vehicles.map((v) => <div key={v.vin} style={{ display: "flex", gap: 8, alignItems: "center", fontSize: 12 }}><span>{v.vehicle || "Vehicle"}</span><span style={{ fontFamily: "var(--jb-mono)", fontSize: 10.5, color: "var(--jb-text-dim)" }}>{v.vin}</span><span style={{ fontSize: 10.5, color: "#555" }}>{v.oldRos} old RO{v.oldRos === 1 ? "" : "s"}{v.deals ? " · bought" : ""}{v.trades ? " · traded in" : ""}</span><ImpVinHistoryButton vin={v.vin} small /></div>)}</div>}
      </div>
    );
  };

  /* ═══════════════════════════════ 4. the panel under the Trial Balance ═══════════════════════════════ */
  const ImpTbSchedules = () => {
    const Dm = D();
    const [sum, setSum] = React.useState(null);
    React.useEffect(() => { (async () => { try { setSum(await Dm._apiGet("/import/reconcile/summary")); } catch (e) { setSum({ error: errText(e) }); } })(); }, []);   // eslint-disable-line
    if (!sum || sum.error || !sum.accounts || !sum.accounts.length) return null;
    const fmtAt = (iso) => { const d = new Date(iso); return isNaN(d) ? "" : d.toLocaleDateString("en-US"); };
    return (
      <div data-testid="tb-schedules" style={{ marginTop: 6, padding: "6px 10px", background: "#F4F8FC", border: "1px solid #C9D6E3", borderRadius: 4, fontSize: 11.5 }}>
        <div style={{ display: "flex", gap: 8, alignItems: "center", flexWrap: "wrap" }}><b>Inventory accounts tied to a schedule</b><span style={{ color: "#555" }}>(the imported lists on Reconcile inventory to GL)</span><span style={{ flex: 1 }} /><button className="k2b-button small" data-testid="tb-open-reconcile" onClick={() => sidebar("reconcile")} style={btn(false)}>Reconcile inventory to GL ▸</button></div>
        <table style={{ borderCollapse: "collapse", marginTop: 3 }}><tbody>{sum.accounts.map((a) => <tr key={a.acct} data-testid="tb-sched" data-acct={a.acct}><td style={{ ...cell, fontFamily: "'Courier Prime', monospace", fontWeight: 700, padding: "2px 8px" }}>{a.acct}</td><td style={{ ...cell, padding: "2px 8px" }}>{a.name}</td><td style={{ ...cell, padding: "2px 8px" }}>{a.scheduleLabel}</td><td style={{ ...cell, padding: "2px 8px", color: a.lastReconciled ? "#176A38" : "#8A4B00" }}>{a.lastReconciled ? `last reconciled as of ${a.lastReconciled.asOf} (${a.lastReconciled.kind === "checked" ? "at zero" : a.lastReconciled.kind === "adjust" ? "adjusting entry " + a.lastReconciled.journalId : "posted at cost " + a.lastReconciled.journalId}, ${fmtAt(a.lastReconciled.at)})` : "not reconciled yet"}</td></tr>)}</tbody></table>
      </div>
    );
  };

  /* ═══════════════════════════════ 5. RC30 (imp2): Import review & approval ═══════════════════════════════
     Every import waits here. Per run: the parts (sheets) with rows ready / with problems / skipped; every problem row with "what this most
     likely means" and the fix (the server's rule table — ImpCalc.RULES, the same words on every station); the GL tie-out as if approved
     (list total vs the ledger balance on the as-of date per account, the difference, the ranked likely causes); the reconciling entries to
     tick; the conversion clearing account; the typed confirmation. The SERVER approves (one command, one transaction), rejects or undoes. */
  const LEVEL_WORD = { reject: "not imported", warn: "imported, with a note", ready: "ready", skip: "skipped" };
  // RC33 (svi): the review's words for the lists an account ties to
  const TIE_WORD = { inventory: "Inventory", parts: "Parts", ar: "Customer A/R", wip: "WIP labor (open ROs)", sublet: "Sublet (open ROs)", warranty: "Warranty claims", body: "Body shop jobs", info: "Information", roparts: "Parts on open ROs" };
  const TIE_UNIT = { wip: " items", sublet: " items", warranty: " claims", body: " jobs", info: "", roparts: "" };
  const ImpReviewWindow = ({ onClose, go, embedded }) => {
    const Dm = D();
    const [runs, setRuns] = React.useState(null);
    const [may, setMay] = React.useState({ approve: false });
    const [sel, setSel] = React.useState(() => { try { return localStorage.getItem("k2b-imp-review-run") || ""; } catch (e) { return ""; } });
    const [rv, setRv] = React.useState(null);
    const [err, setErr] = React.useState("");
    const [loading, setLoading] = React.useState(false);
    const [asOf, setAsOf] = React.useState("");
    const [ticks, setTicks] = React.useState({});
    const [complete, setComplete] = React.useState({});   // RC33 (svi): "the list is complete" per account (a partial list posts only with it)
    const [glPost, setGlPost] = React.useState([]);        // RC36 (imp36): the ticked entries of the tie-out by import (ImpGl.jsx.txt)
    const rvNarrow = typeof window !== "undefined" && window.innerWidth < 760;   // RC36 (imp36): phones
    const [conv, setConv] = React.useState("");
    const [confirm, setConfirm] = React.useState("");
    const [reason, setReason] = React.useState("");
    const [busy, setBusy] = React.useState("");
    const [msg, setMsg] = React.useState(null);
    const [openPart, setOpenPart] = React.useState({});
    const [filter, setFilter] = React.useState("all");
    const loadRuns = React.useCallback(async () => {
      if (!Dm || typeof Dm._apiGet !== "function") { setErr("This DMS page is older than the server — reload it (Ctrl+F5)."); return; }
      try { const r = await Dm._apiGet("/import/stage/runs?limit=100"); setRuns(r.runs || []); setMay(r.may || {}); if (!sel) { const w = (r.runs || []).find((x) => x.status === "waiting") || (r.runs || [])[0]; if (w) setSel(w.runId); } }
      catch (e) { setErr(errText(e)); }
    }, [sel]);
    const load = React.useCallback(async (runId, date, keepMsg) => {
      if (!runId) { setRv(null); return; }
      setLoading(true); setErr(""); if (!keepMsg) setMsg(null);
      try {
        const d = await Dm._apiGet("/import/stage/runs/" + encodeURIComponent(runId) + "/review" + (date ? "?asOf=" + encodeURIComponent(date) : ""));
        setRv(d); setAsOf(d.tieOut ? d.tieOut.asOf : (d.run.asOf || ""));
        setConv((c) => (d.tieOut && d.tieOut.conversion ? (c && (d.tieOut.conversion.choices || []).some((a) => a.acct === c) ? c : d.tieOut.conversion.acct || "") : ""));
        setTicks({}); setComplete({}); setConfirm("");
      } catch (e) { setErr(errText(e)); setRv(null); }
      setLoading(false);
    }, []);
    React.useEffect(() => { loadRuns(); }, []);   // eslint-disable-line
    React.useEffect(() => { load(sel, ""); try { if (sel) localStorage.setItem("k2b-imp-review-run", sel); } catch (e) {} }, [sel]);   // eslint-disable-line
    const run = rv && rv.run;
    const tie = rv && rv.tieOut;
    const postings = tie ? tie.accounts.filter((a) => a.posting && ticks[a.acct] && (!a.posting.needsConfirm || complete[a.acct])) : [];
    const act = async (kind) => {
      if (!run) return;
      setMsg(null); setBusy(kind);
      const key = Dm._newIdemKey(kind === "approve" ? "iap" : kind === "reject" ? "irj" : "iun");
      const body = kind === "approve" ? { confirm, postings: postings.map((a) => Object.assign({ kind: "adjust", schedule: a.schedule, account: a.acct, perAccount: true, expectedDiffCents: a.diffCents }, a.posting.needsConfirm ? { listComplete: true } : {})).concat(glPost.map((g) => ({ kind: "gl-tie", dest: g.dest, account: g.account, expectedDiffCents: g.expectedDiffCents, listComplete: g.listComplete }))), asOf, conversionAcct: conv || undefined }
        : kind === "reject" ? { reason } : { confirm };
      const r = await Dm._command("/import/stage/runs/" + encodeURIComponent(run.runId) + "/" + kind, body, key, "/import/stage/op/");
      setBusy("");
      let m;
      if (!r.ok) {
        const b = (r.err && r.err.body) || {};
        const text = r.unknown ? `The server did not answer. Look at the run's status before trying again (the office can look up ${key}).` : b.error || (r.err && r.err.message) || "The server refused.";
        m = { level: "error", text, code: b.code, used: b.used }; toast(text, "warn", 8000);
      } else {
        const res = r.res || {};
        m = { level: "ok", text: res.message || "Done.", code: kind, journals: res.journals, replayed: !!res.replayed }; toast(res.message || "Done.", "ok", 7000);
        setConfirm(""); setReason("");
      }
      await loadRuns(); await load(run.runId, asOf, true);   // the refreshed run keeps the command's answer on the screen
      setMsg(m);
    };
    const partRows = (p) => (p.problems || []).filter((x) => filter === "all" || x.level === filter);
    const body = (
      <div data-testid="rv-screen" style={{ flex: 1, minHeight: 0, display: "flex", flexDirection: "column", background: "#FFF", fontFamily: "var(--font-ui)", fontSize: 12, color: "#000" }}>
        <div style={{ flex: "0 0 auto", padding: "8px 14px", borderBottom: "1px solid #E4E4E4", display: "flex", gap: 10, alignItems: "center", flexWrap: "wrap" }}>
          <div><div style={{ fontWeight: 700, fontSize: 15, color: "var(--k2b-navy)" }}>✔ Import review &amp; approval</div><div style={{ color: "#555", fontSize: 11.5 }}>every import waits here — nothing is saved or posted until the owner approves it</div></div>
          <span style={{ flex: 1 }} />
          <span data-testid="rv-may" data-approve={may.approve ? "1" : "0"} style={{ fontSize: 11.5, color: may.approve ? "#176A38" : "#8A4B00", fontWeight: 700 }}>{may.approve ? "You may approve" : "View only — the owner (or a login the owner granted) approves"}</span>
          <button className="k2b-button small" data-testid="rv-refresh" disabled={loading} onClick={() => { loadRuns(); load(sel, asOf); }} style={btn(false)}>{loading ? "Loading…" : "Refresh"}</button>
        </div>
        <div style={{ flex: "1 1 auto", minHeight: 0, display: "flex", gap: 0, flexDirection: rvNarrow ? "column" : "row", overflow: rvNarrow ? "auto" : undefined }}>{/* RC36 (imp36): a phone stacks the run list above the review */}
          <div data-testid="rv-runs" style={{ flex: rvNarrow ? "0 0 auto" : "0 0 300px", maxHeight: rvNarrow ? 200 : undefined, borderRight: rvNarrow ? undefined : "1px solid #E4E4E4", borderBottom: rvNarrow ? "1px solid #E4E4E4" : undefined, overflow: "auto", padding: 8, display: "flex", flexDirection: "column", gap: 4 }}>
            {!runs && <div style={{ color: "#777" }}>Loading…</div>}
            {runs && !runs.length && <div data-testid="rv-no-runs" style={{ color: "#777", padding: 6 }}>No import runs yet. Import a file (Data &amp; Admin › Import / Export) — it shows up here, waiting for approval.</div>}
            {(runs || []).map((r) => (
              <div key={r.runId} data-testid="rv-run" data-run={r.runId} data-status={r.status} onClick={() => setSel(r.runId)} style={{ ...box, padding: "6px 9px", cursor: "pointer", borderColor: sel === r.runId ? "#1B66A8" : "#C9D6E3", background: sel === r.runId ? "#EEF5FC" : r.status === "waiting" ? "#FFF8E6" : "#FFF" }}>
                <div style={{ display: "flex", gap: 6, alignItems: "baseline" }}><b style={{ fontFamily: "'Courier Prime', monospace", fontSize: 11 }}>{r.runId}</b><span style={{ flex: 1 }} /><span style={{ fontSize: 10.5, fontWeight: 700, color: r.status === "waiting" ? "#8A4B00" : r.status === "approved" ? "#176A38" : "#777" }}>{r.statusWord}</span></div>
                <div style={{ fontSize: 11, color: "#555" }}>{r.fileName || r.kind}{r.source ? " · " + r.source : ""}</div>
                <div style={{ fontSize: 11, color: "#555" }}>{r.totals.ready} ready · {r.totals.problems} problems · {r.totals.skipped} skipped · {(r.parts || []).length} part{(r.parts || []).length === 1 ? "" : "s"}{r.asOf ? " · as of " + r.asOf : ""}</div>
              </div>
            ))}
          </div>
          <div style={{ flex: "1 1 auto", minHeight: 0, overflow: "auto", padding: "10px 14px", display: "flex", flexDirection: "column", gap: 10 }}>
            {err && <div data-testid="rv-error" style={{ padding: "8px 12px", background: "#FDECEA", border: "1px solid #F3B8B0" }}>⚠ {err}</div>}
            {msg && <div data-testid="rv-msg" data-level={msg.level} data-code={msg.code || ""} style={{ padding: "8px 12px", background: msg.level === "ok" ? "#EAF7EE" : "#FDECEA", border: "1px solid " + (msg.level === "ok" ? "#9ED9B1" : "#F3B8B0"), fontSize: 12.5, lineHeight: 1.5 }}>{msg.level === "ok" ? "✓ " : "✕ "}{msg.text}{msg.journals && msg.journals.length ? <div data-testid="rv-msg-journals" style={{ fontSize: 11.5, marginTop: 3 }}>Posted: {msg.journals.map((j) => j.id).join(", ")}</div> : null}{msg.used && msg.used.length ? <ul data-testid="rv-msg-used" style={{ margin: "4px 0 0 16px" }}>{msg.used.slice(0, 20).map((u, i) => <li key={i}>{u.collection} {u.id} — {u.why}</li>)}</ul> : null}</div>}
            {!run && !err && <div style={{ color: "#777" }}>Pick an import run on the left.</div>}
            {run && (
              <>
                <div data-testid="rv-run-head" data-run={run.runId} data-status={run.status} style={{ ...box, padding: "9px 12px", display: "flex", gap: 14, alignItems: "baseline", flexWrap: "wrap" }}>
                  <div><b style={{ fontFamily: "'Courier Prime', monospace" }}>{run.runId}</b> — <b data-testid="rv-status" style={{ color: run.status === "waiting" ? "#8A4B00" : run.status === "approved" ? "#176A38" : "#777" }}>{run.statusWord}</b></div>
                  <span>{run.fileName || run.kind}{run.source ? " · " + run.source : ""}</span>
                  <span>sent by {run.createdByName || run.createdBy} {run.finishedAt ? "on " + new Date(run.finishedAt).toLocaleString("en-US") : ""}</span>
                  {run.approvedAt && <span style={{ color: "#176A38" }}>approved by {run.approvedByName || run.approvedBy} on {new Date(run.approvedAt).toLocaleString("en-US")}{run.journals && run.journals.length ? " · posted " + run.journals.map((j) => j.id).join(", ") : " · nothing posted"}</span>}
                  {run.rejectedAt && <span style={{ color: "#A02234" }}>rejected: {run.rejectReason}</span>}
                  {run.undoneAt && <span style={{ color: "#8A6400" }}>undone on {new Date(run.undoneAt).toLocaleString("en-US")}</span>}
                  <span style={{ flex: 1 }} />
                  <span data-testid="rv-totals" data-ready={run.totals.ready} data-problems={run.totals.problems} data-skipped={run.totals.skipped}><b>{run.totals.ready}</b> rows ready · <b style={{ color: run.totals.problems ? "#A02234" : undefined }}>{run.totals.problems}</b> with problems · <b>{run.totals.skipped}</b> skipped{run.totals.warnings ? ` · ${run.totals.warnings} with a note` : ""}</span>
                </div>
                {(rv.checks || []).map((c, i) => (
                  <div key={i} data-testid="rv-check" data-rule={c.rule} data-part={c.part} style={{ padding: "8px 12px", background: "#FDECEA", border: "1px solid #F3B8B0", fontSize: 12, lineHeight: 1.5 }}>
                    <b>{c.part}: {c.label}.</b> {c.text}
                    <div style={{ marginTop: 3 }}><b>What this most likely means:</b><ol style={{ margin: "2px 0 0 18px" }}>{(c.means || []).map((m, k) => <li key={k}>{m}</li>)}</ol><b>The fix:</b> {c.fix}</div>
                  </div>
                ))}
                <div style={{ ...box, overflow: "auto" }}>
                  <table data-testid="rv-parts" style={{ width: "100%", borderCollapse: "collapse" }}>
                    <thead><tr><th style={hcell}>Sheet / part</th><th style={hcell}>Goes to</th><th style={{ ...hcell, ...num }}>Rows</th><th style={{ ...hcell, ...num }}>Ready</th><th style={{ ...hcell, ...num }}>With problems</th><th style={{ ...hcell, ...num }}>Skipped</th><th style={hcell}>Read from</th><th style={hcell}>Notes</th></tr></thead>
                    <tbody>{(rv.parts || []).map((p) => (
                      <tr key={p.part} data-testid={"rv-part-" + p.part} data-dest={p.dest} data-ready={p.counts.ready} data-problems={p.counts.problems} data-skipped={p.counts.skipped} data-blocked={p.blocked || ""} style={{ background: p.blocked ? "#FDECEA" : undefined }}>
                        <td style={{ ...cell, fontWeight: 700 }}>{p.part}</td><td style={cell}>{p.label}</td><td style={{ ...cell, ...num }}>{p.counts.rows}</td><td style={{ ...cell, ...num, color: "#176A38" }}>{p.counts.ready}</td><td style={{ ...cell, ...num, color: p.counts.problems ? "#A02234" : undefined }}>{p.counts.problems}</td><td style={{ ...cell, ...num }}>{p.counts.skipped}</td>
                        <td style={cell}>{Object.keys(p.origins || {}).map((o) => <span key={o} data-testid={"rv-origin-" + o} style={{ display: "inline-block", marginRight: 6, padding: "0 6px", borderRadius: 9, fontSize: 10.5, fontWeight: 700, background: o === "text" ? "#ECECEC" : "#FFF0CC", color: o === "text" ? "#555" : "#8A6400" }}>{o === "text" ? "file" : o === "pdf-text" ? "read from PDF — check" : "scanned page (AI) — check"} {p.origins[o]}</span>)}</td>
                        <td style={cell}>{p.blocked ? <span style={{ color: "#A02234" }}>⚠ not written: {(p.blockers || []).map((b) => b.title).join("; ")}</span> : null}{p.entry ? <span> opening balances {p.entry.ref || p.entry.id} · {p.entry.lines} lines · dated {p.entry.date}</span> : null}{p.alreadyPosted ? <span style={{ color: "#8A4B00" }}> already posted as {p.alreadyPosted.id} — not posted again</span> : null}{(p.metaWarnings || []).map((w, i) => <div key={i} style={{ color: "#8A4B00" }}>{w.title}{w.detail ? ": " + w.detail : ""}</div>)}</td>
                      </tr>))}</tbody>
                  </table>
                </div>
                {/* RC33 (svi): what the names on the service lists do at approval */}
                {(() => { const nm = rv.names || ((rv.parts || []).find((p) => p.names) || {}).names; if (!nm) return null; return (
                  <div data-testid="rv-names" data-create={nm.create} data-fill={nm.fill} data-differs={nm.differs} data-two={nm.two} data-mismatch={nm.mismatch} data-others={nm.others || 0} style={{ ...box, padding: "8px 12px", fontSize: 12, lineHeight: 1.5, background: "#F4F8FC" }}>
                    <b>Customers from the service lists</b> ({nm.numbers} customer #{nm.numbers === 1 ? "" : "s"} with a name{nm.sources ? ` — repair orders ${nm.sources.roHistory || 0}, service list ${nm.sources.svcCustomers || 0}, A/R aging ${nm.sources.arAging || 0} rows` : ""}): <b>{nm.create}</b> created at approval · <b>{nm.fill}</b> on file, blank fields filled (nothing the office typed is overwritten) · <b>{nm.same || 0}</b> already complete · <b style={{ color: nm.differs ? "#8A4B00" : undefined }}>{nm.differs}</b> another name on file — listed for the office, nothing changed · <b style={{ color: nm.two || nm.mismatch || nm.used ? "#A02234" : undefined }}>{(nm.two || 0) + (nm.mismatch || 0) + (nm.used || 0)}</b> not created (two names / a phone of another number / a retired number){nm.others ? ` · ${nm.others} other name${nm.others === 1 ? "" : "s"} on older rows of ${nm.othersNums || nm.others} customer #${(nm.othersNums || nm.others) === 1 ? "" : "s"} — listed for the office (same household / a typo / a different person), nothing written for ${nm.others === 1 ? "it" : "them"}` : ""}{nm.noNumber ? ` · ${nm.noNumber} row${nm.noNumber === 1 ? "" : "s"} with a name on an account that is no customer # (no customer made)` : ""}.
                  </div>); })()}
                {(rv.parts || []).filter((p) => (p.problems || []).length).map((p) => (
                  <div key={"pr-" + p.part} data-testid={"rv-problems-" + p.part} style={{ ...box, padding: "8px 12px" }}>
                    <div style={{ display: "flex", gap: 10, alignItems: "center", flexWrap: "wrap" }}><b>{p.part} — {p.problems.length} row{p.problems.length === 1 ? "" : "s"} to look at</b><span style={{ color: "#555", fontSize: 11.5 }}>(rows "not imported" are left out when the run is approved; rows "with a note" are imported)</span><span style={{ flex: 1 }} />
                      <select data-testid="rv-filter" value={filter} onChange={(e) => setFilter(e.target.value)} style={{ font: "inherit" }}><option value="all">all</option><option value="reject">not imported</option><option value="warn">with a note</option></select>
                      <button className="k2b-button small" data-testid={"rv-toggle-" + p.part} onClick={() => setOpenPart({ ...openPart, [p.part]: !openPart[p.part] })} style={btn(false)}>{openPart[p.part] === false ? "Show" : "Hide"}</button></div>
                    {openPart[p.part] !== false && (
                      <table style={{ width: "100%", borderCollapse: "collapse", marginTop: 6 }}>
                        <thead><tr><th style={hcell}>Row</th><th style={hcell}>Record</th><th style={hcell}>Result</th><th style={hcell}>What is wrong</th><th style={hcell}>What this most likely means · the fix</th></tr></thead>
                        <tbody>{partRows(p).map((x) => (
                          <tr key={x.rowNo} data-testid="rv-problem" data-level={x.level} data-rule={(x.rules[0] || {}).rule || ""} data-key={x.key || ""} data-origin={x.origin}>
                            <td style={{ ...cell, ...num }}>{(x.srcRows || []).join(" ") || x.rowNo}</td>
                            <td style={cell}><span style={{ fontFamily: "'Courier Prime', monospace", fontWeight: 700 }}>{x.key}</span>{x.label ? <div style={{ color: "#555" }}>{x.label}</div> : null}{x.originWord ? <div data-testid="rv-origin-word" style={{ color: "#8A6400", fontSize: 10.5 }}>{x.originWord}{x.pageRef ? " · " + x.pageRef : ""}</div> : null}</td>
                            <td style={cell}><span style={{ fontSize: 10.5, fontWeight: 700, padding: "1px 7px", borderRadius: 9, background: x.level === "reject" ? "#F3D9D9" : "#FFF0CC", color: x.level === "reject" ? "#9A2A2A" : "#8A6400" }}>{LEVEL_WORD[x.level] || x.level}</span></td>
                            <td style={cell}>{(x.reasons || []).map((r, i) => <div key={"r" + i}>{r.field ? <b>{r.field}: </b> : null}{r.reason}</div>)}{(x.warnings || []).map((r, i) => <div key={"w" + i} style={{ color: "#8A4B00" }}>{r.field ? <b>{r.field}: </b> : null}{r.reason}</div>)}{(x.rules || []).filter((r) => r.text && !(x.reasons || []).some((q) => q.reason === r.text)).map((r, i) => <div key={"t" + i} style={{ color: "#8A4B00" }}>{r.text}</div>)}</td>
                            <td style={cell}>{Array.from(new Map((x.rules || []).map((r) => [r.rule, r])).values()).map((r) => <div key={r.rule} data-testid="rv-explain" data-rule={r.rule} style={{ marginBottom: 4 }}><b>{r.label}</b>{r.means && r.means.length ? <ol style={{ margin: "2px 0 2px 18px" }}>{r.means.map((m, k) => <li key={k}>{m}</li>)}</ol> : null}{r.fix ? <div style={{ color: "#176A38" }}>Fix: {r.fix}</div> : null}</div>)}</td>
                          </tr>))}</tbody>
                      </table>
                    )}
                    {p.problems.length >= 300 && <div style={{ color: "#555", fontSize: 11 }}>The first 300 rows are shown; every row is counted.</div>}
                  </div>
                ))}
                {/* RC36 (fpd36): the floorplan tie-out of an Inventory / Floorplan statement part (Floorplan.jsx.txt; the server answers run.floorplan) */}
                {run.floorplan && window.FpReviewTie ? <window.FpReviewTie fp={run.floorplan} go={go} /> : null}
                {tie && (
                  <div data-testid="rv-tieout" style={{ ...box, padding: "9px 12px", display: "flex", flexDirection: "column", gap: 8 }}>
                    <div style={{ display: "flex", gap: 10, alignItems: "center", flexWrap: "wrap" }}>
                      <div><b>GL tie-out as if approved</b> — the list total next to the ledger balance per account, as of <input type="date" data-testid="rv-asof" value={asOf} onChange={(e) => setAsOf(e.target.value)} style={{ font: "inherit", padding: "2px 5px" }} /> <button className="k2b-button small" data-testid="rv-asof-go" onClick={() => load(run.runId, asOf)} style={btn(false)}>Show</button></div>
                      <span style={{ color: "#555", fontSize: 11.5 }}>accounts from {tie.source}{tie.obEntry ? ` · the staged opening-balances entry ${tie.obEntry.ref || tie.obEntry.id} (${tie.obEntry.lines} lines) counts on the ledger side` : ""} · {tie.counts.unitsOnLot} units on the lot after approval</span>
                    </div>
                    {/* RC31 (fx31, RC30 acceptance F5 — owner decision): a file dated BEFORE entries already on the books is said FIRST; no entry is offered for those accounts */}
                    {tie.dated && <div data-testid="rv-dated" data-accounts={(tie.dated.accounts || []).join(",")} style={{ padding: "7px 10px", background: "#FDECEA", border: "1px solid #F3B8B0", fontSize: 12, lineHeight: 1.45 }}>⚠ <b>{(tie.dated.words || "").split(" — ")[0]}</b>{(tie.dated.words || "").indexOf(" — ") !== -1 ? " — " + (tie.dated.words || "").split(" — ").slice(1).join(" — ") : ""}</div>}
                    {/* RC31 fix round (fx31 checkers): a file dated after today, and items with no GL account of their own (an entry per account would write them off) — said FIRST */}
                    {tie.future && <div data-testid="rv-future" style={{ padding: "7px 10px", background: "#FDECEA", border: "1px solid #F3B8B0", fontSize: 12, lineHeight: 1.45 }}>⚠ <b>{tie.future.words}</b></div>}
                    {tie.noAccount && <div data-testid="rv-noacct" data-accounts={(tie.noAccount.accounts || []).join(",")} style={{ padding: "7px 10px", background: "#FDECEA", border: "1px solid #F3B8B0", fontSize: 12, lineHeight: 1.45 }}>⚠ <b>{tie.noAccount.words}</b></div>}
                    {tie.badTieRows && tie.badTieRows.length > 0 && <div style={{ color: "#A02234", fontSize: 11.5 }}>Tie_Out rows not understood: {tie.badTieRows.map((b) => `row ${b.row}${b.acct ? " (" + b.acct + ")" : ""}: ${b.why}`).join("; ")}</div>}
                    <table style={{ width: "100%", borderCollapse: "collapse" }}>
                      <thead><tr><th style={hcell}>GL account</th><th style={hcell}>Ties to</th><th style={{ ...hcell, ...num }}>List total</th><th style={{ ...hcell, ...num }}>Ledger {asOf}</th><th style={{ ...hcell, ...num }}>Difference</th><th style={hcell}>What this most likely means (most likely first)</th><th style={hcell}>Post on approval</th></tr></thead>
                      <tbody>{tie.accounts.map((a) => (
                        <tr key={a.acct} data-testid={"rv-tie-" + a.acct} data-list={a.listCents} data-gl={a.glCents} data-diff={a.diffCents} data-items={a.items} style={{ background: a.diffCents ? "#FFF8E6" : undefined }}>
                          <td style={{ ...cell, fontFamily: "'Courier Prime', monospace", fontWeight: 700 }}>{a.acct}<div style={{ fontFamily: "var(--font-ui)", fontWeight: 400, color: "#555" }}>{a.name}</div></td>
                          <td style={cell}>{TIE_WORD[a.tiesTo] || a.tiesTo}{a.note ? <div style={{ color: "#555", fontSize: 11 }}>{a.note}</div> : null}{a.source === "default" ? <div style={{ color: "#999", fontSize: 10.5 }}>default</div> : null}</td>
                          <td style={{ ...cell, ...num }}>{a.items ? money(a.listCents) : <span style={{ color: "#999" }}>—</span>}<div style={{ color: "#777", fontSize: 10.5 }}>{a.items ? a.items + (a.tiesTo === "ar" ? " list" : a.tiesTo === "parts" ? " parts" : TIE_UNIT[a.tiesTo] || " units") : ""}</div></td>
                          <td style={{ ...cell, ...num }}>{money(a.glCents)}{a.obCents ? <div style={{ color: "#777", fontSize: 10.5 }}>incl. staged OB {money(a.obCents)}</div> : null}</td>
                          <td data-testid="rv-tie-diff" data-nolist={a.noList ? "1" : "0"} style={{ ...cell, ...num, color: a.diffCents ? "#A02234" : a.noList ? "#777" : "#176A38", fontWeight: 700 }}>{a.noList ? "—" : a.items || a.glCents ? money(a.diffCents) : ""}<div style={{ fontWeight: 400, fontSize: 10.5 }}>{a.state}</div></td>
                          <td style={cell}>{(a.causes || []).map((c, i) => <div key={i} data-testid="rv-cause" data-rule={c.rule}><b>{c.label}</b><ol style={{ margin: "2px 0 2px 18px" }}>{c.means.map((m, k) => <li key={k} data-testid="rv-cause-item">{m}</li>)}</ol><div style={{ color: "#176A38", fontSize: 11 }}>Fix: {c.fix}</div></div>)}</td>
                          <td style={cell}>{a.info ? <span data-testid={"rv-info-" + a.acct} style={{ color: "#555", fontSize: 11 }}>information — never posted from the import</span> : a.posting ? <div style={{ display: "flex", flexDirection: "column", gap: 4 }}><label style={{ display: "flex", gap: 6, alignItems: "flex-start" }}><input type="checkbox" data-testid={"rv-tick-" + a.acct} disabled={run.status !== "waiting" || !may.approve || (a.posting.needsConfirm && !complete[a.acct])} checked={!!ticks[a.acct] && (!a.posting.needsConfirm || !!complete[a.acct])} onChange={(e) => setTicks({ ...ticks, [a.acct]: e.target.checked })} /><span>adjusting entry: {a.posting.words}</span></label>{a.posting.needsConfirm ? <label data-testid={"rv-complete-wrap-" + a.acct} style={{ display: "flex", gap: 6, alignItems: "flex-start", color: "#8A4B00", fontSize: 11 }}><input type="checkbox" data-testid={"rv-complete-" + a.acct} disabled={run.status !== "waiting" || !may.approve} checked={!!complete[a.acct]} onChange={(e) => { setComplete({ ...complete, [a.acct]: e.target.checked }); if (!e.target.checked) setTicks({ ...ticks, [a.acct]: false }); }} /><span>the list is complete — {a.posting.confirmWords}</span></label> : null}{a.posting.holdWords ? <div data-testid={"rv-hold-" + a.acct} style={{ color: "#555", fontSize: 10.5, lineHeight: 1.4 }}>{a.posting.holdWords}</div> : null}</div> : a.noList ? <span data-testid={"rv-nolist-" + a.acct} style={{ color: "#777", fontSize: 11 }}>no list imported for this account yet — nothing to compare, nothing to post (the balance stays as the sheet says)</span> : (a.causes || [])[0] && (a.causes[0].rule === "as_of_future" || a.causes[0].rule === "entry_dated_future") ? <span data-testid={"rv-later-" + a.acct} data-rule={a.causes[0].rule} style={{ color: "#A02234", fontSize: 11 }}>nothing offered — {a.causes[0].rule === "as_of_future" ? "the file is dated after today (set the as-of date)" : (a.laterEntry ? a.laterEntry.id : "an entry") + " is dated in the future (correct its date in Accounting)"}</span> : a.laterEntry ? <span data-testid={"rv-later-" + a.acct} style={{ color: "#A02234", fontSize: 11 }}>nothing offered — the books already have {a.laterEntry.id} dated after this file (re-export today's list or set the as-of date)</span> : (a.causes || [])[0] && ["tie_row_mismatch", "tie_not_on_schedule", "items_without_account", "unreadable_money"].indexOf(a.causes[0].rule) !== -1 ? <span data-testid={"rv-noentry-" + a.acct} data-rule={a.causes[0].rule} style={{ color: "#A02234", fontSize: 11 }}>nothing offered — {a.causes[0].rule === "tie_row_mismatch" ? "the Tie_Out sheet and the books tie this account to different lists" : a.causes[0].rule === "tie_not_on_schedule" ? "the account is on no schedule of the books" : a.causes[0].rule === "items_without_account" ? "items on this list carry no GL account of their own" : "a cost or quantity on this list cannot be read"} (see the reason)</span> : a.diffCents ? <span style={{ color: "#777", fontSize: 11 }}>{a.tiesTo === "ar" ? "A/R: correct with a journal entry after approval" : "no schedule for this account — post it on Reconcile Inventory after approval"}</span> : <span style={{ color: "#176A38" }}>nothing to post</span>}</td>
                        </tr>))}</tbody>
                    </table>
                    {tie.unassigned && tie.unassigned.units > 0 && <div data-testid="rv-unassigned" style={{ color: "#8A4B00", fontSize: 11.5 }}>{tie.unassigned.note}</div>}
                    {tie.unassigned && tie.unassigned.partsNote && <div data-testid="rv-unassigned-parts" style={{ color: "#8A4B00", fontSize: 11.5 }}>{tie.unassigned.partsNote}</div>}
                    {tie.excluded && tie.excluded.length > 0 && <div data-testid="rv-excluded" style={{ color: "#555", fontSize: 11.5 }}>Left off as property, not inventory: {tie.excluded.map((e) => `${e.acct} ${e.name} (${money(e.glCents)})`).join(" · ")}</div>}
                    <div data-testid="rv-conv" data-problem={tie.conversion.problem ? "1" : "0"} style={{ padding: "7px 10px", background: tie.conversion.problem ? "#FDECEA" : "#F4F8FC", border: "1px solid " + (tie.conversion.problem ? "#F3B8B0" : "#C9D6E3"), fontSize: 12, display: "flex", gap: 10, alignItems: "center", flexWrap: "wrap" }}>
                      <div style={{ flex: "1 1 360px" }}><b>Conversion clearing account</b> — the other side of every reconciling entry (the owner's choice: 390 CONVERSION CLEARING). It must be a balance-sheet account on no schedule; a profit &amp; loss account is refused.{tie.conversion.problem ? <div data-testid="rv-conv-problem" style={{ color: "#A02234", marginTop: 3 }}>{tie.conversion.problem}</div> : <div style={{ color: "#176A38", marginTop: 3 }}>Set: {tie.conversion.acct} {tie.conversion.name}</div>}</div>
                      <select data-testid="rv-conv-select" value={conv} onChange={(e) => setConv(e.target.value)} style={{ font: "inherit", padding: "3px 6px", maxWidth: 360 }}><option value="">— use the saved default —</option>{(tie.conversion.choices || []).map((a) => <option key={a.acct} value={a.acct}>{a.acct} {a.name} · {a.type}</option>)}</select>
                    </div>
                  </div>
                )}
                {rv.glTie && window.ImpGlTie ? <window.ImpGlTie glTie={rv.glTie} run={run} may={may} onPostings={setGlPost} /> : null}{/* RC36 (imp36): every import ties to the GL */}
                {run.status === "waiting" && (
                  <div data-testid="rv-actions" style={{ ...box, padding: "10px 12px", background: "#FFF8E6", display: "flex", flexDirection: "column", gap: 8 }}>
                    <div style={{ fontSize: 12.5, lineHeight: 1.5 }}><b>Approve</b> writes the {run.totals.ready} ready row{run.totals.ready === 1 ? "" : "s"} to the records{tie && tie.obEntry ? `, posts the opening-balances entry ${tie.obEntry.ref || tie.obEntry.id}` : ""}{postings.length ? `, and posts ${postings.length} adjusting entr${postings.length === 1 ? "y" : "ies"} (${postings.map((a) => a.acct + " " + money(Math.abs(a.diffCents))).join(", ")}) against the conversion clearing account` : ""}{glPost.length ? `, and posts ${glPost.length} tie-out entr${glPost.length === 1 ? "y" : "ies"} by import (${glPost.map((g) => g.words).join(", ")}) against the conversion clearing account` : ""} — in ONE step, audited. Rows with problems are left out. It can be undone while nothing has used the data.</div>
                    <div style={{ display: "flex", gap: 8, alignItems: "center", flexWrap: "wrap" }}>
                      <label style={{ fontSize: 12 }}>Type <b>APPROVE</b> to confirm: <input data-testid="rv-confirm" value={confirm} onChange={(e) => setConfirm(e.target.value)} disabled={!may.approve} placeholder="APPROVE" style={{ font: "inherit", padding: "3px 6px", width: 120 }} /></label>
                      <button className="k2b-button" data-testid="rv-approve" disabled={!may.approve || !!busy || confirm.trim().toUpperCase() !== "APPROVE"} onClick={() => act("approve")} style={btn(true, { background: "#FFD08A", padding: "6px 18px" })}>{busy === "approve" ? "Approving…" : "Approve this import"}</button>
                      <span style={{ flex: 1 }} />
                      <input data-testid="rv-reason" value={reason} onChange={(e) => setReason(e.target.value)} placeholder="why it is rejected" style={{ font: "inherit", padding: "3px 6px", width: 220 }} />
                      <button className="k2b-button small" data-testid="rv-reject" disabled={!!busy || reason.trim().length < 3} onClick={() => act("reject")} style={btn(false, { color: "#A02234" })}>{busy === "reject" ? "Rejecting…" : "Reject (discard the staged rows)"}</button>
                    </div>
                    {!may.approve && <div data-testid="rv-view-only" style={{ color: "#8A4B00", fontSize: 11.5 }}>Only the dealership owner (or a login the owner gave "approve imports" in the Owner panel) can approve. You can look and reject.</div>}
                  </div>
                )}
                {run.status === "approved" && (
                  <div data-testid="rv-undo-box" style={{ ...box, padding: "10px 12px", display: "flex", gap: 8, alignItems: "center", flexWrap: "wrap" }}>
                    <div style={{ flex: "1 1 360px", fontSize: 12 }}><b>Undo</b> reverses the entries this run posted (RV- entries, never deleted) and removes the records it wrote — refused with the list when anything has used or changed them since.</div>
                    <label style={{ fontSize: 12 }}>Type <b>UNDO</b>: <input data-testid="rv-undo-confirm" value={confirm} onChange={(e) => setConfirm(e.target.value)} disabled={!may.approve} placeholder="UNDO" style={{ font: "inherit", padding: "3px 6px", width: 100 }} /></label>
                    <button className="k2b-button small" data-testid="rv-undo" disabled={!may.approve || !!busy || confirm.trim().toUpperCase() !== "UNDO"} onClick={() => act("undo")} style={btn(false, { color: "#A02234" })}>{busy === "undo" ? "Undoing…" : "Undo this import"}</button>
                  </div>
                )}
                <div style={{ fontSize: 11, color: "#777" }}>The explanations come from a fixed rule table (ImpCalc RULES — the same words on every station). If a rule is wrong, send us the rule code shown with the row (for example cust_not_7), the row or account it fired on, and what the right answer was.</div>
              </>
            )}
          </div>
        </div>
      </div>
    );
    if (embedded) return body;
    return (
      <div className="k2b-window" style={{ width: "100%", maxWidth: 1500, height: "calc(100vh - 110px)", minHeight: 420, margin: "0 auto", display: "flex", flexDirection: "column" }}>
        <K2BTitlebar title={"Import review & approval — " + ((window.K2BStore && window.K2BStore.pageId()) || "") + "-" + (window.K2BStore ? window.K2BStore.branding().printName : "")} onClose={onClose} onMin={() => {}} onMax={() => {}} />
        {body}
      </div>
    );
  };

  Object.assign(window, { ImpWorkbookFlow, ImpReconcileWindow, ImpRoHistory, ImpTbSchedules, ImpVehicleHistory, ImpVinHistoryButton, ImpCustomerOldRos, ImpReviewWindow });
})();