feat(web): return a mixed pile without a face — default "Mixed" denom on redeposits

A coin-roll return is a lump of face going back to the bank; the reconciliation
math nets returns globally and never reads their denomination (only buys use
denom, for box throughput). The engine's own invariant tests already feed it
denomless returns — but the Return-to-bank workflow was forcing a single denom,
over-constraining the UI relative to the domain model. So a mixed pile (dollars +
halves + dimes + quarters) had no faithful entry, which is exactly what you can't
always keep track of.

- Return-to-bank defaults denom to "" ("Mixed / whole deposit"); the specific
  denoms stay selectable for when you do know.
- The Edit grid's denom column gains a first-class "Mixed" option so a denomless
  return round-trips cleanly instead of binding to an out-of-range blank select.
- Add a store+calc round-trip test proving a denomless return persists as "" and
  nets against the float (to_redeposit).
- e2e: assert the return is denomless and that its grid select renders "Mixed".

No schema, API, or calc change — all three already treat a return as denomless.

Author: tompscanlan

internal/store/data_test.go

@@ -1,8 +1,10 @@
 package store_test
 
 import (
+	"math"
 	"testing"
 
+	"github.com/tompscanlan/coinrollhunter/internal/calc"
 	"github.com/tompscanlan/coinrollhunter/internal/model"
 	"github.com/tompscanlan/coinrollhunter/internal/store"
 )
@@ -79,3 +81,63 @@ func TestResolveDatasetReadPathColumnAlignment(t *testing.T) {
 		t.Errorf("Metal = %q, want gold", lot.Metal)
 	}
 }
+
+// TestDenomlessReturnRoundTrips pins the "return a sum without a face" path — a
+// mixed-pile redeposit. A 'return' roll-txn may carry an empty denom: it persists
+// and reads back as "", and the float reconciliation nets it globally, so
+// to_redeposit drops by the full face regardless of denom. This is the single-pool
+// model (ADR-001/005): a return is cash going back to the bank; denomination is a
+// buy-only attribute (box throughput). Guards the mixed-return feature end to end
+// through the store + calc, not just the UI.
+func TestDenomlessReturnRoundTrips(t *testing.T) {
+	s, err := store.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { s.Close() })
+
+	if _, err := s.InsertRollTxn(model.RollTxn{
+		Date: "2026-02-01", Bank: "Stock Yards", Action: "buy",
+		Denom: "halves", Unit: "box", Amount: 1, FaceUSD: 500,
+	}); err != nil {
+		t.Fatal(err)
+	}
+	// The mixed redeposit: a lump sum back to the bank, no denom tracked (Denom "").
+	if _, err := s.InsertRollTxn(model.RollTxn{
+		Date: "2026-02-03", Bank: "Stock Yards", Action: "return",
+		Unit: "face", Amount: 480, FaceUSD: 480,
+	}); err != nil {
+		t.Fatal(err)
+	}
+
+	d, err := s.ResolveDataset()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var ret *model.RollTxn
+	for i := range d.RollTxns {
+		if d.RollTxns[i].Action == "return" {
+			ret = &d.RollTxns[i]
+		}
+	}
+	if ret == nil {
+		t.Fatal("return roll-txn was not read back from the store")
+	}
+	if ret.Denom != "" {
+		t.Errorf("return denom = %q, want \"\" (a denomless mixed return must persist blank)", ret.Denom)
+	}
+	if ret.FaceUSD != 480 {
+		t.Errorf("return face = %v, want 480", ret.FaceUSD)
+	}
+
+	// Single-pool reconciliation: bought 500, returned 480, nothing kept ⇒ $20 float.
+	// The denomless return must net against the float exactly like a denom'd one.
+	r := calc.Compute(d)
+	if got := r.ToRedeposit; math.Abs(got-20) > 1e-9 {
+		t.Errorf("to_redeposit = %v, want 20 (denomless return must net against the float)", got)
+	}
+	if math.Abs(r.Returns-480) > 1e-9 {
+		t.Errorf("returns = %v, want 480", r.Returns)
+	}
+}

qa/do-tab.e2e.mjs

@@ -110,6 +110,9 @@ try {
   await page.getByText('Recorded', { exact: false }).first().waitFor({ timeout: 5000 })
   const returns4 = (await api('/roll-txns')).filter((r) => r.action === 'return')
   ok('return recorded', returns4.length === 1 && returns4[0].face_usd === 400, `@ ${returns4[0]?.face_usd}`)
+  // A redeposit is a lump of face going back — the denom defaults to "Mixed" ("") so
+  // a mixed pile records as one sum (single-pool float; the math never reads it).
+  ok('return is denomless (mixed pile — single-pool float)', returns4[0]?.denom === '', `denom ${JSON.stringify(returns4[0]?.denom)}`)
   await page.getByRole('button', { name: 'Done' }).click()
 
   // === 5. Reconcile / close out ===  (record a forgotten keeper, then book the rest)
@@ -236,6 +239,21 @@ try {
   ok('source-type inert on return rows (om-kn0f)',
     returnSourceCells.length >= 1 && returnSourceCells.every((t) => t === '—'),
     JSON.stringify(returnSourceCells))
+
+  // A denomless (mixed) return must bind to the "Mixed" option (value '') and
+  // render it — not an out-of-range blank select. denom is the 2nd select in a
+  // row (action, denom, unit); source(5) is an inert span on return rows.
+  const returnDenomSelects = await page.$$eval('section table tbody tr', (rows) =>
+    rows
+      .filter((r) => r.querySelector('select')?.value === 'return')
+      .map((r) => {
+        const sel = r.querySelectorAll('select')[1]
+        return { value: sel?.value, label: sel?.selectedOptions[0]?.textContent?.trim() }
+      }),
+  )
+  ok('mixed return denom binds to "Mixed" (value "") in Edit grid',
+    returnDenomSelects.length >= 1 && returnDenomSelects.every((c) => c.value === '' && c.label === 'Mixed'),
+    JSON.stringify(returnDenomSelects))
 } catch (e) {
   ok('UNCAUGHT', false, e.message)
   await page.screenshot({ path: `${SHOT}/do-error.png`, fullPage: true }).catch(() => {})

web/app/src/lib/components/workflows/ReturnToBank.svelte

@@ -26,7 +26,11 @@
   // form state
   let bank = $state('')
   let date = $state(today())
-  let denom = $state<string>('halves')
+  // A redeposit is a lump of face going back; the denom is optional. Default to
+  // "" ("Mixed") so a mixed pile (dollars + halves + dimes + quarters) records as
+  // one sum — the reconciliation math nets returns globally and never reads their
+  // denom (ADR-001/005 single-pool float). Pick a specific denom only if you know it.
+  let denom = $state<string>('')
   let amount = $state(0)
   let notes = $state('')
   let banks = $state<string[]>([])
@@ -193,11 +197,12 @@
         </label>
 
         <label class="flex flex-col gap-1 text-xs text-muted-foreground">
-          Denomination
+          Denomination (optional)
           <select
             bind:value={denom}
             class="rounded-md border border-input bg-card px-2 py-1.5 text-sm text-foreground focus:border-ring focus:outline-none"
           >
+            <option value="">Mixed / whole deposit</option>
             {#each DENOMS as d (d)}<option value={d}>{d}</option>{/each}
           </select>
         </label>

web/app/src/lib/grids.ts

@@ -300,7 +300,11 @@ export const rollTxnsGrid: GridConfig<RollTxn> = {
     { accessorKey: 'date', header: 'Date', meta: { editor: 'date', width: '150px' } },
     { accessorKey: 'bank', header: 'Bank', meta: { editor: 'autocomplete', placeholder: 'Stock Yards', suggestions: () => banks } },
     { accessorKey: 'action', header: 'Action', meta: { editor: 'select', options: ['buy', 'return'], width: '100px' } },
-    { accessorKey: 'denom', header: 'Denom', meta: { editor: 'select', options: DENOMS, width: '110px' } },
+    // A 'return' is a lump of face going back to the bank; its denom is optional
+    // (a mixed deposit — the float nets returns globally, never per-denom). '' binds
+    // to the "Mixed" option and renders it, so a mixed return round-trips cleanly
+    // instead of showing an out-of-range blank select.
+    { accessorKey: 'denom', header: 'Denom', meta: { editor: 'select', optionsFn: () => [{ value: '', label: 'Mixed' }, ...DENOMS], width: '110px' } },
     { accessorKey: 'unit', header: 'Unit', meta: { editor: 'select', options: ROLL_UNITS, width: '90px' } },
     // Buy-only attribute: a 'return' is just face going back to the bank, so the
     // cell renders inert ("—") on return rows (om-kn0f).