refactor(ssr): delete dead transaction-account-row-no-cursor* twin (heuristic 1)

transaction-account-row-no-cursor* and its only helper account-field-name were
unreferenced anywhere in src/ or test/ -- the *-no-cursor* duplicate the plan targets
for removal. The live row renderer is the top-rooted cursor form transaction-account-row*
(driven by fc/cursor-map from the accounts cursor). Deleting the twin: no-cursor twins
1 -> 0, ~53 LOC removed. Swap spec stays 6/6.

.claude/skills/ssr-form-migration/SKILL.md

@@ -0,0 +1,122 @@
+---
+name: ssr-form-migration
+description: Migrate an SSR form or wizard modal to the whole-form HTMX swap doctrine, top-rooted render functions, the data-driven session-backed wizard engine, and (where it helps) Selmer templates. Use when simplifying a server-rendered form/wizard modal in this codebase, removing EDN-snapshot round-trips, deleting *-no-cursor* duplicate render fns, collapsing per-interaction routes, or replacing the multi-step wizard protocol machinery.
+---
+
+# SSR Form & Wizard Migration
+
+A repeatable method for making a server-rendered form/wizard modal **simpler** without
+changing user-facing behavior. Distilled from the first proven migration — the
+`transaction/edit.clj` modal, which already runs on the whole-form `hx-select` swap
+approach with **zero out-of-band swaps**. Every migration *reads this skill first* and
+*extends it last* (the Growth contract below). If migration N+1 is not easier than N,
+the skill-update step was skipped — treat that as a bug.
+
+The four patterns every migration moves code toward live in `reference/`:
+
+- `reference/swap-doctrine.md` — the four-rule HTMX swap priority order + the focus
+  invariant + Alpine-survives-swap hardening + target-selector strategy.
+- `reference/render-functions.md` — one render fn per component, taking explicit data
+  **or a top-rooted cursor**; no faked cursor positions, no `*-no-cursor*` twins.
+- `reference/form-vs-wizard.md` — single-step → plain form; multi-step → data-driven
+  engine with **per-step state in the Ring session** (the Django `formtools` model).
+- `reference/selmer-conventions.md` — plain-HTML attributes via Selmer, the
+  Hiccup↔Selmer interop bridge, include/block patterns.
+
+Growing cookbooks (append every migration):
+`component-cookbook.md`, `gotchas.md`, `test-recipes.md`, `scorecard.md`.
+
+---
+
+## The per-migration playbook
+
+Run this loop for each modal. The phase notes in the migration plan list only what is
+*specific* to a modal; this loop is the constant.
+
+1. **Read the skill.** Skim `reference/` and note which `component-cookbook.md`
+   entries and `gotchas.md` you can reuse. Start from the cookbook, not a blank file.
+
+2. **Classify** (`reference/form-vs-wizard.md`).
+   - Single logical step (even with a `?mode=` toggle or add/remove rows) → **plain
+     form**: no server-side wizard state, no snapshot, no protocol.
+   - Genuinely multiple steps the user advances through → **wizard**: the data-driven
+     engine + per-step session storage.
+   - When in doubt, it's a form.
+
+3. **Baseline the scorecard** (`scorecard.md`, heuristics in §6 of the plan). Record
+   before-numbers with cheap tools:
+   ```bash
+   F=src/clj/auto_ap/ssr/<modal>.clj
+   wc -l $F                                   # LOC (heuristic 4)
+   grep -c 'defn.*-no-cursor' $F              # *-no-cursor* twins (heuristic 1)
+   grep -cE 'with-cursor|MapCursor\.' $F      # faked cursor re-roots (heuristic 1)
+   grep -c 'hx-swap-oob' $F                   # OOB swaps (heuristic 7)
+   grep -cE '"hx-[a-z]' $F                    # mixed string hx- attrs (heuristic 8)
+   # route count: count this modal's entries in src/cljc/auto_ap/routes/*.cljc
+   ```
+
+4. **Characterize behavior (test-first).** Write or confirm a Playwright spec that
+   captures *current* behavior before you touch anything — focus/caret survival across
+   swaps, each field round-trip, validation errors, and the real save. This spec is the
+   parity contract; it must stay green through every commit. See `test-recipes.md`.
+
+5. **Consolidate render functions** (`reference/render-functions.md`). Make each render
+   fn take explicit data or a **top-rooted cursor**. Delete `*-no-cursor*` duplicates
+   and any `with-cursor`/`MapCursor` rebind that fakes a deep starting position
+   (heuristics 1, 2). Using a cursor is fine; faking where it *starts* is not.
+
+6. **Templatize in Selmer** (`reference/selmer-conventions.md`) where the component is
+   interactive/attribute-heavy. Reuse cookbook bits; add new ones back (heuristics 5, 8).
+   Static markup may stay Hiccup — Selmer scope is hybrid (Open decision 2).
+
+7. **Wire HTMX per the swap doctrine** (`reference/swap-doctrine.md`). Keep the focus
+   invariant intact. No OOB except a genuinely disjoint region, documented (heuristic 7).
+
+8. **Collapse routes** to 2 (`GET` open, `POST` submit) — `+1` for an add-row endpoint,
+   `+1` for the single `*-form-changed` whole-form re-render endpoint (heuristic 6).
+
+9. **Verify.** Modal e2e green + full e2e suite at-or-above baseline; assert DB
+   mutations by querying Datomic, not markup; REPL-check the pure render/data fns.
+   Re-measure the scorecard — **no metric may regress for the touched modal** without a
+   written exception in `gotchas.md`.
+
+10. **Commit** one reversible feature commit. The message includes the scorecard delta
+    and the reused/new cookbook entries.
+
+11. **Feed the skill** (the Growth contract). *Not optional.*
+
+---
+
+## Growth contract — the last task of every migration
+
+- Converted a component? → add its before/after to `component-cookbook.md`.
+- Hit a surprise? → one entry in `gotchas.md`.
+- Found a test pattern? → `test-recipes.md`.
+- Playbook step missing or wrong? → fix this `SKILL.md`.
+- Measured the scorecard? → append the row to `scorecard.md`.
+
+**Success signal:** each migration reuses more cookbook entries and starts from a better
+scorecard baseline than the previous one.
+
+---
+
+## Non-negotiables
+
+- **Focus invariant:** the input the user is typing in is *never* inside the region its
+  own request swaps. Violating this drops the caret. (Proven by the
+  `transaction-edit-swap.spec.ts` caret tests.)
+- **No new OOB swaps.** If tempted to OOB something inside the same feature, restructure
+  the DOM so the dependent element shares an ancestor with the trigger and use an
+  ordinary swap (e.g. totals in a sibling `<tbody>`).
+- **Behavior parity is proven by tests, not by reading.** The full e2e suite stays green
+  after every migration.
+- **Don't game the heuristics.** They're directional evidence paired with the e2e parity
+  gate; review the trend, not single numbers.
+
+## Project conventions that bite (see `gotchas.md`)
+
+- Edit Clojure with the clojure-mcp tools (`clojure_edit`, `clojure_edit_replace_sexp`),
+  not the raw file editor. `clj-paren-repair` then `lein cljfmt fix` when a file won't
+  compile.
+- Run tests via the `clojure-eval` skill / `clj-nrepl-eval -p PORT`, not `lein test`.
+- Temp files go in `./tmp/`.

.claude/skills/ssr-form-migration/reference/component-cookbook.md

@@ -0,0 +1,103 @@
+# Component cookbook
+
+GROWS every migration. Each entry: what it is, the swap rule it uses, and the canonical
+snippet. Reuse these before writing anything new; the success signal is *more reuse each
+migration*.
+
+Seeded from `transaction/edit.clj` (Hiccup form — Selmer versions land in Phase 2).
+
+---
+
+## typeahead (account / vendor) — Alpine + tippy, survives swaps
+
+Used for account and vendor selection. Click-to-select (not a live text caret), so a
+whole-form swap on change is safe. Null-guard `tippy?`/`$refs.input?`.
+
+```clojure
+(defn account-typeahead* [{:keys [name value client-id x-model]}]
+  [:div.flex.flex-col
+   (com/typeahead {:name name
+                   :placeholder "Search..."
+                   :url (hu/url (bidi/path-for ssr-routes/only-routes :account-search)
+                                (cond-> {:purpose "transaction"} client-id (assoc :client-id client-id)))
+                   :id name
+                   :x-model x-model            ; binds selected value into the row's Alpine scope
+                   :value value
+                   :content-fn (fn [v] (:account/name (d-accounts/clientize ... v client-id)))})])
+```
+Reuse note: `:x-model` lets the *parent* row read the selected id (e.g. `accountId`) to
+gate a targeted location swap. See account-row.
+
+## account-row — cursor render fn + per-row targeted location swap + whole-form remove
+
+The canonical "row in a repeated grid" pattern. One render fn, top-rooted cursor.
+- account typeahead binds `accountId` into row Alpine scope;
+- **location cell** swaps *only itself* (`#account-location-<index>`) on `changed`
+  (swap-doctrine Rule 2);
+- **amount cell** swaps *only* `#account-totals` (Rule 4, sibling tbody);
+- **remove** swaps the whole form (Rule 3).
+
+```clojure
+(defn transaction-account-row* [{:keys [value client-id amount-mode index]}]
+  (com/data-grid-row
+   (-> {:class "account-row" :id (str "account-row-" index)
+        :x-data (hx/json {:show ... :accountId (fc/field-value (:transaction-account/account value))})
+        :data-key "show" :x-ref "p"}
+       hx/alpine-mount-then-appear)
+   (fc/with-field :db/id (com/hidden {:name (fc/field-name) :value (fc/field-value)}))
+   (fc/with-field :transaction-account/account
+     (com/data-grid-cell {} (com/validated-field {:errors (fc/field-errors)}
+       (account-typeahead* {:value (fc/field-value) :client-id client-id
+                            :name (fc/field-name) :x-model "accountId"}))))
+   (fc/with-field :transaction-account/location
+     (com/data-grid-cell {:id (str "account-location-" index)} ...Rule 2 targeted swap...))
+   (fc/with-field :transaction-account/amount
+     (com/data-grid-cell {} ...Rule 4 totals swap...))
+   (com/data-grid-cell {:class "align-top"} ...Rule 3 whole-form remove...)))
+```
+TODO Phase 2: drop the `transaction-account-row-no-cursor*` twin; this is the only kept form.
+
+## totals in a sibling `<tbody>` — Rule 4 instead of OOB
+
+Running totals live in their own `<tbody id="account-totals">`, a sibling of the
+input-bearing rows, so an amount edit refreshes them with a plain targeted swap and never
+replaces the amount input (caret survives).
+
+```clojure
+(com/data-grid
+ {:footer-tbody
+  [:tbody {:id "account-totals"}
+   (com/data-grid-row {:class "account-total-row"} ... (account-total* request) ...)
+   (com/data-grid-row {:class "account-balance-row"} ... (account-balance* request) ...)]}
+ ...input rows...)
+```
+
+## money-input / text-input amount field — Rule 4 targeted totals swap
+
+```clojure
+(com/money-input
+ {:name (fc/field-name) :id (str "account-amount-" index) :class "w-16 account-amount-field"
+  :hx-post (bidi/path-for ssr-routes/only-routes ::route/edit-form-changed)
+  :hx-target "#account-totals" :hx-select "#account-totals" :hx-swap "outerHTML"
+  :hx-trigger "keyup changed delay:300ms" :hx-include "closest form"})
+```
+`%` mode swaps to `com/text-input {:type "number" :step "0.01"}` with the same swap attrs.
+
+## memo field — Rule 1, no request
+
+```clojure
+(com/text-input {:value (fc/field-value) :name (fc/field-name) :id "edit-memo"
+                 :placeholder "Optional note"})   ; no hx-* — rides along to save
+```
+
+## mode toggle ($/% radio, simple/advanced link) — Rule 3, whole-form swap
+
+```clojure
+(com/radio-card {:options [{:value "$" :content "$"} {:value "%" :content "%"}]
+                 :value amount-mode :name "step-params[amount-mode]"
+                 :hx-post (bidi/path-for ssr-routes/only-routes ::route/toggle-amount-mode)
+                 :hx-target "#wizard-form" :hx-select "#wizard-form" :hx-swap "outerHTML"
+                 :hx-include "closest form"})
+```
+TODO Phase 2: the simple/advanced toggle becomes a `?mode=` re-render (plain form), not a
+dedicated route.

.claude/skills/ssr-form-migration/reference/form-vs-wizard.md

@@ -0,0 +1,115 @@
+# Forms vs. wizards (and the data-driven wizard engine)
+
+## Classify first
+
+| Signal | Classification |
+|--------|----------------|
+| One logical step — even with a `?mode=` toggle, $/% radio, or add/remove rows | **plain form** |
+| The user genuinely advances through ordered steps, each validated before the next | **wizard** |
+| In doubt | **form** |
+
+Most "wizards" in this codebase are single-step forms wearing wizard costumes: they
+implement the multi-step protocol (`mm/ModalWizardStep` + friends), serialize an EDN
+snapshot into hidden fields, and register 10–20 stacked-middleware routes — all for one
+step. That is pure overhead to delete.
+
+## The machinery being replaced
+
+`transaction/edit.clj` today still carries the old shape, useful as the "before":
+
+```clojure
+(defrecord LinksStep [linear-wizard]
+  mm/ModalWizardStep
+  (step-name   [_] "Transaction Actions")
+  (step-key    [_] :links)
+  (edit-path   [_ _] [])
+  (step-schema [_] (mm/form-schema linear-wizard))
+  (render-step [this {{:keys [snapshot step-params]} :multi-form-state :as request}] ...))
+```
+
+…plus the snapshot round-trip: the whole accumulating form state is serialized to hidden
+fields (custom EDN readers), then rebuilt every request by merging the posted pieces back
+into the snapshot (`:multi-form-state :snapshot` is read ~75× in `edit.clj`). The
+serialization needs custom readers, the merge is error-prone, and the payload grows each
+step.
+
+---
+
+## Single-step → plain form
+
+Two routes: `GET` (render) and `POST` (validate + save). State is plain form fields + an
+entity id. No snapshot, no server state, no protocol.
+
+```clojure
+{::route/edit        (fn [req] (html-response (render-edit-form {:entity (get-entity req)})))
+ ::route/edit-submit (fn [req] (validate-and-save req))}
+```
+
+A `?mode=` toggle is just the `GET` re-rendering with a different query param — still a
+plain form. An add-row interaction is one extra `POST` that appends a fresh row and
+re-renders (the `+1` route).
+
+---
+
+## Genuinely multi-step → data-driven engine with session-stored step state
+
+> **Inspiration — Django `formtools` `WizardView`.** Django's wizard does *not* round-trip
+> a serialized blob of the whole form through the page. Each step's validated data is
+> written to a **storage backend (the user session by default)** under that step's key,
+> and the steps are combined only at the very end via `get_all_cleaned_data()`. We adopt
+> the same model: **replace the EDN snapshot + piecewise merging with per-step form state
+> stored in the Ring session.** A step writes its own data under its own key; nothing is
+> merged into a snapshot and nothing about other steps rides through the form.
+> Refs: `formtools.wizard.views.WizardView`, `SessionStorage`, `get_all_cleaned_data()`
+> (https://django-formtools.readthedocs.io/en/latest/wizard.html).
+
+A wizard is **data**:
+
+```clojure
+(def vendor-wizard-config
+  {:steps [{:key :info  :schema info-schema  :fields [...] :render render-info-step
+            :next (fn [data] :terms)}
+           {:key :terms :schema terms-schema :fields [...] :render render-terms-step
+            :next (fn [data] :done)}]
+   :init-fn (fn [req] {...})
+   :submit-route "/admin/vendor/wizard/submit"
+   :done-fn (fn [all-data req] (save! all-data) (html-response "Saved"))})
+```
+
+with a tiny engine (no protocols) whose state lives **in the session**, keyed by a wizard
+instance id, each step's data under its own step key — the formtools `SessionStorage`
+model. No snapshot, no custom EDN readers, no merge-into-snapshot:
+
+```clojure
+;; Storage backed by the Ring session. Path: [:wizards <wizard-id> :step-data <step-key>]
+(defn create-wizard! [session config]
+  (let [id (str (java.util.UUID/randomUUID))]
+    [id (assoc-in session [:wizards id]
+                  {:current-step (-> config :steps first :key) :step-data {}})]))
+
+(defn put-step [session id k data] (assoc-in session [:wizards id :step-data k] data)) ; replace, not merge
+(defn set-step [session id k]      (assoc-in session [:wizards id :current-step] k))
+(defn get-all  [session id]        (->> (get-in session [:wizards id :step-data]) vals (apply merge)))
+(defn forget   [session id]        (update session :wizards dissoc id))
+```
+
+The render emits only a **reference token** (`wizard-id`, `current-step`) in the form —
+never the form's state. The submit handler validates the posted step, `put-step`s it,
+computes `:next`, and either advances (`set-step`) or finishes (`get-all` + `:done-fn` +
+`forget`). Every fn returns the updated session for the handler to thread into the Ring
+response (`(assoc resp :session session')`).
+
+**Two routes per wizard:** open (`partial open-wizard config`) and submit
+(`partial handle-step-submit config`). State is namespaced by `wizard-id` inside the
+session, so multiple in-flight wizards (and browser tabs) don't collide, and it is
+discarded on completion (`forget`).
+
+### Storage lifetime (Open decision 1)
+
+State lives in the Ring session, scoped to true multi-step wizards (plain forms hold
+none). Lifetime follows the session; `forget` on completion prevents session bloat. For
+long-lived wizards, confirm the session backend (in-memory vs. durable) is acceptable or
+pick a durable store. **This engine is built in Phase 6** (Transaction Rule) — until then
+this file describes the target; validate `components/wizard_state.clj` +
+`components/wizard2.clj` against it when they land, and update this doc from the real
+implementation.

.claude/skills/ssr-form-migration/reference/gotchas.md

@@ -0,0 +1,88 @@
+# Gotchas
+
+GROWS every migration. One entry per surprise. Also the home for any **written exception**
+to the scorecard ratchet (a metric that regressed for a documented reason).
+
+---
+
+## Stale `$refs` / `tippy` after a swap
+
+A whole-form swap can run an Alpine event handler *before* the component re-initialises,
+so a handler that dereferences `$refs.input.__x_tippy` or calls `tippy.show()` throws.
+**Always null-guard:** `$refs.input?.__x_tippy?.hide()`, `tippy?.show()`. The
+`transaction-edit-swap.spec.ts` `trackErrors()` helper fails the test on any `pageerror`
+or `console.error`, which is exactly how a stale-ref throw surfaces.
+
+## Let the server value win — don't preserve Alpine state across a server-driven change
+
+When a server change should update a component (e.g. choosing a vendor sets its default
+account), rebuild that section fresh on the swap so the server-provided value lands
+without keying tricks. The bug this prevents: "changing the vendor a *second* time doesn't
+update the account" because preserved Alpine state shadowed the new server value. If you
+*must* preserve a component, key it by value so a change forces re-init:
+`(assoc attrs :key (str id "--" current-value))`.
+
+## Focus dies if the typed input is inside its own swapped region
+
+The single most important invariant. Amount field → swap a sibling tbody, not the row.
+Memo → swap nothing. If a caret test (`sameNode`) fails, the input is in its own swap
+region — re-target to a sibling/ancestor that excludes it.
+
+## Faked cursors breed duplicate render fns
+
+A `with-cursor`/`MapCursor` re-root to fake a deep start forces a `*-no-cursor*` twin.
+Removing the fake lets you delete the twin. Don't "fix" a faked cursor in place — top-root
+it and collapse to one render fn. (See `render-functions.md`.)
+
+## Edit Clojure with clojure-mcp tools, not the file editor
+
+`clojure_edit` / `clojure_edit_replace_sexp`. If a file won't compile: `clj-paren-repair`
+the file, then retry; if still broken, `lein cljfmt check`. Run tests via `clojure-eval` /
+`clj-nrepl-eval -p PORT`, never `lein test` (slow, last resort).
+
+## Solr/typeahead in tests
+
+Account/vendor search is backed by Solr, unavailable in tests. To drive a typeahead in
+e2e: type under the 3-char threshold, then inject a result into Alpine state
+(`Alpine.$data(el).elements = [{value, label}]`) and click it — the real click handler,
+`tippy.hide()`, Alpine reactivity, and the HTMX swap all run as in production. Entity ids
+come from `GET /test-info`.
+
+---
+
+## UI-only control fields must be stripped before a Datomic upsert
+
+The wizard snapshot/step-params carry UI control fields that are **not** schema
+attributes — `:action`, `:amount-mode`, and (added by the simple/advanced work) `:mode`.
+The `:manual` save handler stripped `:action`/`:amount-mode` but not `:mode`, so every
+*advanced* manual save passed `:mode "advanced"` into `:upsert-transaction` and 500'd with
+`:db.error/not-an-entity :mode`. Lesson: when a save derives its tx-data from the form
+snapshot, **strip every non-schema control key** before transacting. The session-backed
+wizard engine (Phase 6) avoids this class of bug by storing per-step *validated* data
+only — UI control fields never enter the combined data. This was a real production bug
+surfaced by the e2e gate, not a test artifact.
+
+## E2E helpers must use the Alpine **v3** API, not the v2 `__x` internal
+
+The app loads Alpine v3 (`cdn.jsdelivr.net/npm/alpinejs@3.x.x`). The v2 internal
+`el.__x.$data` is **gone** — `el.__x` is `undefined`, so any helper that pokes it silently
+no-ops. A stale `selectAccountFromTypeahead` did this and left the posted account empty
+(account-controlled by `x-model`, so the raw DOM `.value` you set is overwritten from
+Alpine's empty state). Drive components the real way instead: `window.Alpine.$data(el)`,
+open the tippy dropdown, inject `elements`, click the result — exactly as
+`transaction-edit-swap.spec.ts` does. Probe with
+`{ hasLegacy__x: !!el.__x, hasAlpineData: !!window.Alpine.$data(el) }`.
+
+## Diagnosing a "modal won't close after save"
+
+The edit modal closes on an `hx-trigger: modalclose` from a *successful* save; a
+validation failure re-renders the `#wizard-form` (200), and a server exception returns 500
+(caught by `wrap-error`). To find which: capture POST responses in Playwright
+(`page.on('response', …)`), read the `edit-submit` body — a `<form id="wizard-form">` means
+validation re-render; a `#error {…}` stack means a 500. Then serialize the form right
+before save (`new FormData(document.querySelector('#wizard-form'))`) to see exactly what
+posts. This is how the `:mode` 500 and the empty-account bugs above were isolated.
+
+## Scorecard exceptions (ratchet violations with a reason)
+
+_None yet._ Append here if a migration must let a metric regress for a documented reason.

.claude/skills/ssr-form-migration/reference/render-functions.md

@@ -0,0 +1,85 @@
+# Render functions: explicit data, or a top-rooted cursor
+
+**One function, data in, markup out.** The data can arrive as a plain map *or* via a
+cursor — as long as the cursor was rooted at the top of the form and walked down to here,
+never faked to start at this depth. The rule is about *where the cursor starts*, not
+whether you use one.
+
+## GOOD — explicit data, pure, testable without setup
+
+```clojure
+(defn account-row [{:keys [account index client-id amount-mode]}]
+  (com/data-grid-row
+    (com/hidden {:name (str "accounts[" index "][db/id]")
+                 :value (or (:db/id account) "")})
+    (com/data-grid-cell
+      (account-typeahead* {:value (:transaction-account/account account)
+                           :name  (str "accounts[" index "][account]")
+                           :client-id client-id}))
+    ...))
+```
+
+## ALSO FINE — a cursor that started at the form root and was advanced naturally
+
+```clojure
+;; The top-level render walks the cursor; the row fn receives the dereferenced row
+;; (or the advanced cursor). No rebinding of *current*/*prefix* to fake depth.
+(defn account-rows [accounts-cursor]
+  (for [row-cursor (fc/each accounts-cursor)]   ; advanced from the root, not faked
+    (account-row {:account @row-cursor :index (fc/index row-cursor) ...})))
+```
+
+`transaction/edit.clj`'s `transaction-account-row*` is the cursor form done right: the
+caller (`account-grid-body*`) holds a top-rooted cursor via `fc/cursor-map` and hands each
+row cursor to one render fn.
+
+---
+
+## The SMELL this migration removes
+
+### 1. Faking the cursor's starting position
+
+A "form cursor" is fine. The pain is **rebinding the dynamic root deeper in the tree** so
+a deeply nested render fn can run against a fragment. Real example from
+`transaction/edit.clj`'s `simple-mode-fields*` (the thing to delete):
+
+```clojure
+;; SMELL: re-roots the cursor to a synthetic MapCursor pointed at accounts[0] so a
+;; fragment can render "deep". Fragile, and the source of the *-no-cursor* twin below.
+(fc/with-field :transaction/accounts
+  (fc/with-cursor (let [cur fc/*current*]
+                    (if (sequential? @cur)
+                      (nth cur 0 nil)
+                      (auto_ap.cursor.MapCursor. {} (cursor/state cur)
+                                                 (conj (cursor/path cur) 0))))
+    ...))
+```
+
+Target: the cursor begins at the top level of what the form consumes and walks down
+naturally. Because the **whole form is re-rendered each time** (swap doctrine), there is
+no longer any reason to fake a deep starting position.
+
+### 2. The `*-no-cursor*` twin
+
+Faking the deep cursor forces a *second copy of the same markup* — one that reads the
+faked cursor and one that takes plain params for the cases where the fake can't be set up.
+`transaction/edit.clj` has exactly this pair:
+
+```clojure
+(defn transaction-account-row*           [{:keys [value index client-id ...]}] ...) ; cursor form
+(defn transaction-account-row-no-cursor* [{:keys [account index client-id ...]}] ...) ; duplicate markup
+```
+
+**Fix:** keep one render fn. If a caller already holds a top-rooted cursor, advance it and
+hand the row data (or the advanced cursor) to that one fn. Delete the `*-no-cursor*` copy.
+Heuristic 1 targets `grep -c 'defn.*-no-cursor'` → 0 and faked-cursor re-roots → 0.
+
+## Scorecard hooks (heuristics 1, 2)
+
+```bash
+grep -c 'defn.*-no-cursor' $F           # → 0
+grep -cE 'with-cursor|MapCursor\.' $F   # faked re-roots → 0 (top-rooted cursors are fine)
+```
+
+Top-rooted cursors do **not** count against heuristic 1 — only *re-roots that fake depth*
+and the `*-no-cursor*` twins do.

.claude/skills/ssr-form-migration/reference/scorecard.md

@@ -0,0 +1,46 @@
+# Quality scorecard (the ratchet)
+
+Cheap to measure (`grep -c`, `wc -l`, `clj-kondo`), recorded **before/after each
+migration** in the commit message and in the results table below. **No metric may regress
+for the touched modal** without a written exception in `gotchas.md`. These are directional
+evidence, not targets to game — always paired with the e2e parity gate.
+
+## Heuristics
+
+| # | Heuristic | Measure | Target |
+|---|-----------|---------|--------|
+| 1 | Faked cursor positions (not cursors themselves) | `grep -cE 'with-cursor\|MapCursor\.'` re-roots + `grep -c 'defn.*-no-cursor'` | → 0 (top-rooted cursors are fine) |
+| 2 | Implicit state merges (snapshot/cursor) | count merge sites | → 0 (forms); explicit `put-step` only (wizards) |
+| 3 | Branching complexity | `clj-kondo`, or count `cond`/`condp`/`case`/nested `if` + max depth | net ↓ |
+| 4 | Lines of code | `wc -l` on the modal's file(s) | net ↓ |
+| 5 | Reuse / cross-form similarity | cookbook components reused; duplicated-block count | reuse ↑, dup ↓ |
+| 6 | Route count | count routes for the modal | → 2 (+1 for add-row) |
+| 7 | OOB swaps | `grep -c hx-swap-oob` | → 0 unless a justified disjoint-region case is documented |
+| 8 | Attribute consistency | mixed `:x-`/`"x-"` encodings in migrated template | → 0 |
+
+## How to measure (copy/paste)
+
+```bash
+F=src/clj/auto_ap/ssr/<modal>.clj
+echo "LOC                $(wc -l < $F)"
+echo "no-cursor twins    $(grep -c 'defn.*-no-cursor' $F)"
+echo "faked-cursor roots $(grep -cE 'with-cursor|MapCursor\.' $F)"
+echo "snapshot merges    $(grep -c ':multi-form-state :snapshot' $F)"
+echo "branch forms       $(grep -cE '\(cond |\(condp |\(case |\(when-not ' $F)"
+echo "hx-swap-oob        $(grep -c 'hx-swap-oob' $F)"
+echo "mixed string hx-   $(grep -cE '\"hx-[a-z]' $F)"
+# route count: count this modal's entries in src/cljc/auto_ap/routes/*.cljc
+```
+
+## Results
+
+Each migration appends one row (after-numbers), referencing the before in the diff.
+
+| Phase | Modal | LOC | Routes | no-cursor twins | faked roots | snapshot merges | OOB | mixed hx- | cookbook reused / added |
+|-------|-------|-----|--------|-----------------|-------------|-----------------|-----|-----------|-------------------------|
+| 1 (baseline) | Transaction Edit `transaction/edit.clj` | 1608 | ~12 | 1 | 2 | ~75 | 0 | 8 | — / seeded 7 entries |
+
+> Phase 1 is distillation only — no app code changed. The Transaction Edit row is the
+> **before** baseline that Phase 2 must beat (target: routes → ~3, no-cursor → 0, faked
+> roots → 0, snapshot merges → 0, LOC ↓, mixed hx- → 0). The `0` OOB is already achieved
+> by the merged reference and must not regress.

.claude/skills/ssr-form-migration/reference/selmer-conventions.md

@@ -0,0 +1,68 @@
+# Selmer template conventions
+
+> **Status: STUB — validated in Phase 2.** This file describes the target. The Selmer
+> dependency, render helper, and interop bridge are added in Phase 2 (Transaction Edit);
+> rewrite this file from the *real, verified* example once that lands, and record each
+> converted component in `component-cookbook.md`.
+
+## Why Selmer for interactive components
+
+In Hiccup the same Alpine/HTMX attribute is sometimes a keyword and sometimes a string in
+the same file — there's no rule a reader (or an LLM) can rely on:
+
+```clojure
+;; All of these appear in one component today:
+:x-ref  "input"      "x-ref" "hidden"
+:x-model "value.value"   "x-model" "search"
+"@keydown.down.prevent.stop" "tippy.show();"   ; handlers MUST be strings
+:x-init "..."                                  ; structural attrs are keywords
+```
+
+In a Selmer template the same markup is unambiguous plain HTML:
+
+```html
+{# templates/components/typeahead.html #}
+<div class="relative" x-data="{{ x_data|safe }}" x-model="{{ x_model }}">
+  <a class="{{ classes }}" x-ref="input" tabindex="0"
+     @keydown.down.prevent.stop="tippy?.show()"
+     @keydown.backspace="tippy?.hide(); value = {value:'', label:''}">
+    <span x-text="value.label"></span>
+  </a>
+  ...
+</div>
+```
+
+Note the `tippy?.` null-guard carried over from the swap doctrine — Selmer doesn't change
+the Alpine-survives-swap requirement.
+
+## Render helper + interop bridge (the Phase 2 foundation)
+
+```clojure
+(defn render [tpl ctx] (selmer/render-file tpl ctx))
+(defn hiccup->html [h] (hiccup/html h))    ; embed hiccup inside selmer via {{ frag|safe }}
+;; selmer fragment inside hiccup: [:div (hiccup/raw (render "..." ctx))]
+```
+
+The bridge must work **both ways** during the strangler transition: a Hiccup component
+renders inside a Selmer template (pass `(hiccup->html h)` into the context, render with
+`|safe`), and a Selmer fragment renders inside a Hiccup tree (`(hiccup/raw (render ...))`).
+Prove both in Phase 2 before broad use.
+
+## Composition
+
+Selmer composes via `{% include %}` and `{% block %}`. Prefer small per-component
+templates that the cookbook references by path. Keep `|safe` to values the server fully
+controls (rendered Hiccup, JSON for `x-data`), never raw user input.
+
+## Scope (Open decision 2)
+
+Hybrid: convert interactive/attribute-heavy components first; static markup may stay
+Hiccup. Revisit a fuller sweep in Phase 11.
+
+## Attribute-consistency scorecard (heuristic 8)
+
+```bash
+grep -cE '"x-[a-z]|"hx-[a-z]|"@' <migrated-template>   # → 0 mixed encodings in Selmer
+```
+A migrated Selmer template has no mixed `:x-`/`"x-"` encodings because everything is plain
+HTML.

.claude/skills/ssr-form-migration/reference/swap-doctrine.md

@@ -0,0 +1,149 @@
+# Whole-form HTMX swap doctrine
+
+Every interactive control picks a swap strategy in this **priority order** (prefer the
+earliest rule that works). Worked examples are the real `transaction/edit.clj` swaps.
+
+## Rule 1 — No request when the field affects nothing else
+
+Its value rides along in the form and is read on submit. No `hx-*` at all.
+
+```clojure
+;; transaction/edit.clj — the memo field. Editing it issues NO request; the value
+;; just rides along until save. The e2e proves zero POSTs fire while typing.
+(com/text-input {:value (fc/field-value)
+                 :name  (fc/field-name)
+                 :id    "edit-memo"
+                 :placeholder "Optional note"})
+```
+
+## Rule 2 — Targeted swap of a single isolated cell when the effect is purely local
+
+Give the cell a stable id, keep it **out of the typed input's subtree**, and post the
+whole form but `hx-select` back only that cell.
+
+```clojure
+;; transaction/edit.clj — selecting an account only changes that row's valid Location
+;; options, so the change swaps just this cell. Nothing else re-renders.
+[:div {:id (str "account-location-" index)}        ; stable, per-row id
+ (com/validated-field
+  {:x-hx-val:account-id "accountId"
+   :x-dispatch:changed   "accountId"               ; Alpine fires `changed` when account changes
+   :hx-trigger "changed"
+   :hx-post    (bidi/path-for ssr-routes/only-routes ::route/edit-form-changed)
+   :hx-target  (str "#account-location-" index)
+   :hx-select  (str "#account-location-" index)
+   :hx-swap    "outerHTML"
+   :hx-include "closest form"}                      ; whole form posts; only this cell swaps back
+  (location-select* {...}))]
+```
+
+## Rule 3 — Whole-form swap when the change touches interdependent state
+
+Vendor change, add/remove row, mode toggle, $/% radio. The form's hidden state rides
+along, so one swap keeps everything consistent — **no out-of-band swaps**.
+
+```clojure
+;; transaction/edit.clj — vendor change rebuilds the whole manual-coding section
+;; (vendor default account, terms, etc. are interdependent).
+[:div {:hx-trigger "change"
+       :hx-post    (bidi/path-for ssr-routes/only-routes ::route/edit-vendor-changed)
+       :hx-target  "#wizard-form"
+       :hx-select  "#wizard-form"
+       :hx-swap    "outerHTML"
+       :hx-sync    "this:replace"
+       :hx-include "closest form"}
+ ...]
+```
+
+The active tab/action round-trips through the form (it's a hidden field bound to Alpine
+`activeForm`), so it **survives** the whole-form swap — that's why a whole-form swap is
+safe here even though the user is "on" a tab.
+
+## Rule 4 — OOB only for genuinely disjoint DOM regions
+
+A global flash/toast, a nav badge, a modal at the document root. **If tempted to OOB
+something inside the same feature, restructure instead**: give the dependent element a
+common ancestor with the trigger and use an ordinary swap.
+
+Worked example — running **totals live in their own sibling `<tbody>`** so an amount edit
+swaps the totals without ever replacing the amount input:
+
+```clojure
+;; The totals tbody is a sibling of the input-bearing rows.
+(com/data-grid
+ {:footer-tbody [:tbody {:id "account-totals"} ...totals rows...]}
+ ...account rows with inputs...)
+
+;; The amount input posts the whole form but hx-selects ONLY #account-totals.
+(com/money-input
+ {:name (fc/field-name)
+  :id   (str "account-amount-" index)
+  :class "w-16 account-amount-field"
+  :hx-post   (bidi/path-for ssr-routes/only-routes ::route/edit-form-changed)
+  :hx-target "#account-totals"      ; a SIBLING of this input's row...
+  :hx-select "#account-totals"      ; ...so the input is never in the swapped region
+  :hx-swap   "outerHTML"
+  :hx-trigger "keyup changed delay:300ms"
+  :hx-include "closest form"})
+```
+
+`grep -c hx-swap-oob` on a migrated modal must be `0` unless a justified disjoint-region
+case is documented here and in `gotchas.md`.
+
+---
+
+## The focus invariant (must always hold)
+
+> The input the user is typing in is never inside the region its own request swaps.
+
+This is *the* reason the doctrine works. The amount field swaps a sibling tbody; the memo
+field swaps nothing; the account typeahead's change swaps the whole form but the typeahead
+isn't an active text caret at that moment (it's a click-to-select). The
+`transaction-edit-swap.spec.ts` `sameNode` assertions exist to catch any violation.
+
+## Alpine components must survive swaps
+
+When a whole-form swap replaces a region containing Alpine/tippy components, they get
+re-initialised from the server-provided values. Two hardening moves:
+
+1. **Null-guard every reference** that depends on Alpine/tippy being initialised:
+   ```clojure
+   "@keydown.down.prevent.stop" "tippy?.show()"
+   "@keydown.enter.prevent.stop" "$refs.input?.__x_tippy?.hide(); ..."
+   ```
+   (`$refs.input?` / `tippy?` — the `?` matters; a swap can run a handler before re-init.)
+
+2. **Let the server value win.** Because the section is rebuilt fresh on each swap, the
+   server-driven value (e.g. a vendor's default account) lands without keying tricks —
+   no preserved stale Alpine state to fight. The "changing the vendor a *second* time
+   still updates it" e2e is the regression guard for this.
+
+   If you *do* preserve a component across a morph/replace, key it by its server value so
+   a server-driven change forces re-init: `(assoc attrs :key (str id "--" current-value))`.
+
+Use `hx/alpine-mount-then-appear` for rows that should mount-then-transition-in (it sets
+`x-data {data-key false}`, `x-init $nextTick(() => key=true)`, `x-show key`).
+
+---
+
+## Selector strategy for targeted swaps (a consideration, not a mandate)
+
+Rules 2 and 4 need a stable `hx-target`/`hx-select`. Per-element unique ids
+(`#account-location-0`) work and are what transaction-edit uses today. They get noisy in
+deeply repeated/nested structures. When you hit that (Phase 5 / the wizards), consider:
+
+- **Semantic markup + data-attributes** — mark rows/cells with their identity and target
+  by attribute, no per-element ids:
+  ```html
+  <tr data-row="account" data-index="0">
+    <td data-cell="location"> … </td>
+  </tr>
+  <!-- hx-target="[data-row='account'][data-index='0'] [data-cell='location']" -->
+  ```
+- **A `form-path -> selector` function**, derived the same way a cursor path is, so the
+  server and the markup agree on the target by construction. A render fn at form-path
+  `[:accounts 0 :location]` computes its own stable selector from that path.
+
+**Decision status:** still per-element ids. The first modal to hit nested repeated swaps
+(Invoice Bulk Edit, Phase 5) settles the convention and records it here + in
+`component-cookbook.md` for the wizards to reuse.

.claude/skills/ssr-form-migration/reference/test-recipes.md

@@ -0,0 +1,127 @@
+# Test recipes
+
+GROWS every migration. How to characterize and verify a modal. Consistent with the
+project `testing-conventions` skill: test user-observable behavior, assert DB state
+directly, don't test the means.
+
+## The three test layers
+
+1. **Characterization e2e first (Playwright).** Before changing a modal, write/confirm a
+   spec capturing *current* behavior — focus/caret survival across swaps, each field
+   round-trip, validation errors, the real save. This is the parity contract; keep it
+   green through every commit.
+2. **Pure-function checks via REPL.** Once render/data-prep fns are pure, exercise them
+   with `clojure-eval` / `clj-nrepl-eval -p <port>`. Assert on returned data; for markup
+   use string matches (`(re-find #"accounts\[0\]\[account\]" (str html))`) — this style
+   survives the Selmer switch. Avoid brittle structural assertions.
+3. **DB-state assertions for mutations.** If a submit writes Datomic, verify by querying
+   the DB, not by asserting on markup.
+
+## Running e2e
+
+```bash
+npx playwright test                              # full suite
+npx playwright test e2e/transaction-edit-swap.spec.ts   # one spec
+```
+- Config: `playwright.config.ts`, `baseURL http://localhost:3333`, `webServer:
+  lein run -m auto-ap.test-server`, `reuseExistingServer: !CI`.
+- **The server must be from the worktree you're testing.** `reuseExistingServer` will
+  silently reuse *any* server on `:3333` — including another worktree's. Confirm with
+  `ls -la /proc/$(lsof -ti :3333)/cwd` (or restart on a clean port) before trusting a run.
+- The test-server port is hardcoded (`test_server.clj` `run-jetty {:port 3333}`); to run a
+  second server from another worktree, change that or parameterise it.
+
+## Driving a typeahead in e2e (Solr unavailable in tests)
+
+```js
+await typeahead.locator('a[x-ref="input"]').click();      // open tippy dropdown
+const search = page.locator('[data-tippy-root] input[x-model="search"]').first();
+await search.fill('te');                                  // under 3-char Solr threshold
+await typeahead.evaluate((el, id) => {                     // inject a clickable result
+  window.Alpine.$data(el).elements = [{ value: id, label: 'Test Account' }];
+}, accountId);
+await page.locator('[data-tippy-root] a', { hasText: 'Test Account' }).first().click();
+```
+Entity ids come from `GET /test-info` (`{accounts:{test-account, vendor, vendor2, ...}}`).
+
+## Proving the focus invariant (caret survival) — the key swap test
+
+```js
+// before the debounced swap lands, capture the live focused node...
+await page.evaluate(() => { window.__focused = document.activeElement; });
+await swap;                                       // waitForResponse on the *-form-changed POST
+const ok = await page.evaluate(() => {
+  const a = document.activeElement;
+  return { sameNode: a === window.__focused, value: a?.value, caret: a?.selectionStart };
+});
+// ...assert the SAME node survived with value + caret intact.
+```
+`trackErrors(page)` (collect `pageerror` + `console.error`, assert `[]`) catches a swap
+that throws on a stale `$refs`/`tippy` — pair it with every swap test.
+
+## Asserting "no request" (Rule 1 fields)
+
+```js
+let posts = 0;
+page.on('request', r => { if (r.url().includes('edit-form-changed') && r.method()==='POST') posts++; });
+// ...type in the memo...
+expect(posts).toBe(0);   // memo affects nothing → issues no request
+```
+
+---
+
+## E2E baseline (the regression gate — never drop below this)
+
+The full suite must stay green after every migration. Specs touching the migrated modals:
+
+| Spec | Tests | Role |
+|------|-------|------|
+| `e2e/transaction-edit-swap.spec.ts` | 8 | **Phase 2 parity contract** — whole-form `hx-select` swaps, caret survival, no-request memo, vendor re-select |
+| `e2e/transaction-edit.spec.ts` | 15 | transaction edit behavior |
+| `e2e/bulk-code-transactions.spec.ts` | 18 | Phase 3 (bulk code) |
+| `e2e/transaction-import.spec.ts` | 4 | import |
+| `e2e/transaction-navigation.spec.ts` | 13 | navigation |
+
+### Running e2e from a non-default worktree (recipe)
+
+`:3333` is often taken by another worktree's server. To run this worktree's code:
+
+1. Boot the test server in-process on this worktree's REPL at an alternate port — no
+   second JVM, and it live-reloads as you edit:
+   ```clojure
+   (require '[auto-ap.test-server :as ts] '[ring.adapter.jetty :refer [run-jetty]]
+            '[datomic.api :as dc])
+   ;; reseed helper — call before each full run so state doesn't leak between runs
+   (defn reseed! []
+     (try (.stop (:server test-srv)) (catch Throwable _))
+     (try (dc/delete-database "datomic:mem://playwright-test") (catch Throwable _))
+     (def test-srv (let [c (ts/create-test-db) id (ts/seed-test-data c)]
+                     (reset! ts/test-transaction-id id)
+                     {:server (run-jetty (ts/test-app) {:port 3334 :join? false}) :tx-id id})))
+   (reseed!)
+   ```
+2. `playwright.config.ts` honors `BASE_URL`; setting it also disables the auto-started
+   webServer (so worktrees don't fight over :3333):
+   ```bash
+   BASE_URL=http://localhost:3334 npx playwright test --workers=1 --reporter=line
+   ```
+3. **Reseed (`reseed!`) before each full run.** One long-lived in-process server persists
+   its in-mem DB across separate `npx playwright` invocations; the swap spec's
+   `clearAccounts`/save mutate the shared transaction and leak into later specs. The
+   normal harness avoids this by booting a fresh server per `npx playwright test`.
+
+### Pass/fail baseline — measured on the merged hx-select reference (Phase 2 start)
+
+Server: in-process from `integreat-execute-refactor` on `:3334`, `--workers=1`, fresh seed.
+
+| Spec | Result |
+|------|--------|
+| `transaction-edit-swap.spec.ts` | **6 / 6 pass** — the whole-form swap parity contract |
+| `transaction-edit.spec.ts` | **1 fail (masks 7 via `mode: 'serial'`)** — `Shared Location … spread on save and reopen` fails: the save POST returns a validation error (amount/balance test-data assumption: "$200 = full amount of the 2nd transaction" doesn't hold), so the modal stays open. **Pre-existing on the merged reference, not introduced by this work.** |
+| Full suite (39) | **30 pass / 2 fail / 7 skipped.** 2nd failure: `transaction-navigation.spec.ts` date-range persistence (`date-range=all` expected, got `month`) — drift from the base branch's "require Apply for date-range filters" change, unrelated to forms. |
+
+**Gate for the Transaction Edit refactor:** the 6/6 swap-doctrine spec + REPL pure-fn
+checks. The `transaction-edit.spec.ts` `Shared Location` failure must be understood/fixed
+to unmask the other 7 before that file can serve as a full parity gate — it is **not**
+a regression to introduce, but it does cap the available characterization coverage today.
+Never drop below 30 passing on the full suite.

.gitignore

@@ -51,3 +51,6 @@ sysco-poller/**/*.csv
 .tmp/**
 playwright-report/**
 test-results/**
+# Scratch dir for temp files (screenshots, logs, etc.); keep the dir, ignore contents
+/tmp/*
+!/tmp/.gitkeep

AGENTS.md

@@ -1,5 +1,9 @@
 # Integreat Development Guide
 
+## Temporary Files
+
+Write any temporary files (screenshots, scratch logs, generated artifacts, etc.) to the `./tmp/` directory at the repo root. Its contents are gitignored (only `.gitkeep` is tracked), so nothing there will be accidentally committed. Do not scatter temp files elsewhere in the repo or in the system `/tmp`.
+
 ## Build & Run Commands
 
 ### Build

docs/ideation/2026-06-01-manual-transaction-import-ssr-ideation.md

@@ -0,0 +1,176 @@
+---
+date: 2026-06-01
+topic: manual-transaction-import-ssr
+focus: Port the master-branch "manual import transactions" feature to the SSR/alpine/htmx stack, modeled on the SSR ledger import, preserving all validations, starting from a failing e2e test, with minimal core-component change.
+mode: repo-grounded
+---
+
+# Ideation: Porting Manual Bank-Transaction Import to SSR
+
+## Grounding Context (Codebase)
+
+Three reference points were read in full:
+
+**1. The master feature (what we must reproduce).**
+- UI: `src/cljs/auto_ap/views/pages/transactions/manual.cljs` — a re-frame modal titled "Import Transactions" with a single `<textarea>` ("Yodlee manual import table"). User pastes tab-separated Yodlee data, clicks "Import". POSTs `(:data)` as EDN to `/api/transactions/batch-upload`.
+- Route/handler: `src/clj/auto_ap/routes/invoices.clj:241` `batch-upload-transactions` → `assert-admin`, then `manual/import-batch (manual/tabulate-data data)`.
+- Parsing: `src/clj/auto_ap/import/manual.clj` — `tabulate-data` reads CSV with `\tab` separator, drops the header row, and maps **fixed positional columns**: `[:status :raw-date :description-original :high-level-category nil nil :amount nil nil nil nil nil :bank-account-code :client-code]`.
+- Per-row mapping/validation: `manual->transaction` uses `import.manual.common/assoc-or-error` to accumulate errors for: **client lookup** (by bank-account-code → client), **bank-account lookup** (by code), **date parse** (`parse-date`, requires `MM/dd/yyyy`), **amount parse** (`parse-amount`).
+- Engine: `import.manual/import-batch` builds lookups, calls `t/start-import-batch :import-source/manual`, applies `t/apply-synthetic-ids` (dedupe key), imports only rows with no `:errors`, returns stats `{:import-batch/imported ... :failed-validation N :sample-error "..."}`.
+- Deeper validations live in `src/clj/auto_ap/import/transactions.clj` `categorize-transaction`: status must be `"POSTED"`, transaction date must be after `bank-account/start-date` and after `client/locked-until`, duplicate detection via `:transaction/id` (extant cache), missing client/bank-account/id → `:error`, plus suppression. Synthetic-id (`apply-synthetic-ids`/`synthetic-key`) gives idempotent re-import.
+
+**2. The SSR ledger import (the pattern to emulate).**
+- `src/clj/auto_ap/ssr/ledger.clj` implements a **dedicated two-stage page**, not a modal:
+  - `external-import-text-form*` (~L246): alpine `x-data {clipboard}`, a hidden `text-area` bound `x-model`, an `hx-post` to `::route/external-import-parse` triggered on a `"pasted"` event; a "Load from clipboard" button reads `navigator.clipboard`.
+  - `external-import-parse` (~L373): re-renders `external-import-form*` with `:just-parsed? true`.
+  - `external-import-table-form*` (~L117): renders parsed rows into an **editable** `com/data-grid-card` — each cell is a `fc/with-field` text/money input (form-cursor round-trips values + errors); per-row error/warning badge with tooltip; "Import" `hx-post`s to `::route/external-import-import`.
+  - Validation: malli `parse-form-schema` (~L341) with `:decode/string tsv->import-data` + `:decode/arbitrary` (vector→map) enforces shape (min-length, `clj-date-schema`, `money`, location max 2). Business validation in `add-errors`/`table->entries` (~L380–504) accumulates `[message status]` pairs (`:error`/`:warn`) at entry and line-item level; `flatten-errors` maps them to form-cursor field paths `[[:table idx] message status]`.
+  - `import-ledger` (~L554): splits good/ignored(warn-only)/bad entries; `throw+` `:field-validation` with `:form-errors` if any bad; upserts hidden vendors; retracts+re-inserts good entries (idempotent via `:journal-entry/external-id`); touches solr; returns `{:successful :ignored :form-errors}`. `external-import-import` wraps it in an `html-response` with an `hx-trigger` notification.
+
+**3. THE KEY DISCOVERY — scaffolding already exists, handlers do not.**
+- `src/cljc/auto_ap/routes/transactions.cljc` **already declares** the route names, mirroring ledger exactly:
+  ```
+  "/external-new" ::external-page
+  "/external-import-new" {"" ::external-import-page
+                          "/parse"  ::external-import-parse
+                          "/import" ::external-import-import}
+  ```
+- But `src/clj/auto_ap/ssr/transaction.clj` `key->handler` (L101) wires **only** `page/table/csv/bank-account-filter/bulk-delete` (+ `edit/` + `bulk-code/`). **No handler exists for any `external-import-*` route.** The aside nav (`ssr/components/aside.clj`) wires the *ledger* import nav (`::ledger-routes/external-import-page`) but there is no transaction-import nav entry. So the routes are declared dead ends; the gap is handlers + UI + validation + nav + tests.
+
+**Test conventions.** `test/clj/auto_ap/ssr/ledger_test.clj` is the template: pure-fn tests (`tsv->import-data`, `trim-header`, `line->id`, `flatten-errors`), validation tests (`add-errors` per error type), tx-building tests (`entry->tx`), and end-to-end import tests (`import-ledger` against Datomic via `wrap-setup` + `setup-test-data` + `admin-token`). `test/clj/auto_ap/test-server.clj` is a Playwright/browser e2e harness with `wrap-test-auth` and seeded `setup-test-data`. Existing engine unit tests: `test/clj/auto_ap/import/transactions_test.clj` already covers `categorize-transaction`.
+
+## Topic Axes
+
+- **Input/paste fidelity** — keeping the exact Yodlee positional-column paste payload (req #1)
+- **UI flow & surface** — modal vs. dedicated two-stage paste→review→import page (req #2)
+- **Validation architecture** — where shape vs. business rules live, and how errors surface (req #3)
+- **Core/backend reuse** — how much of `import.transactions` / `import.manual` is reused vs. reimplemented (req #5)
+- **Test strategy** — failing-first e2e, then unit coverage (req #4)
+
+## The Central Design Fork
+
+Requirements #1 ("paste the exact same content") and #2 ("follow ledger patterns") pull in slightly different directions, but resolve cleanly:
+
+- **Input format stays identical** — the user still copies the same Yodlee table and pastes the same tab-separated positional columns. We reuse `manual/columns` + `manual/tabulate-data` for the *paste shape*; we do **not** switch to ledger's named-header columns.
+- **Everything downstream follows ledger** — dedicated page, clipboard paste, editable review grid, per-row error/warning badges, re-validate loop, notification on import.
+
+The one decision genuinely worth the user's input is **how much of the ledger UX to adopt**: the full editable review grid (idea #5, higher value, more work) vs. a lighter paste→validate→summary page closer to master (still SSR, less scope). Both are presented below as ranked survivors; this is the seed question for brainstorming.
+
+## Ranked Ideas
+
+### 1. Wire the pre-scaffolded routes into a dedicated two-stage SSR import page
+**Description:** Implement `external-import-page` / `external-import-parse` / `external-import-import` handlers in a new `src/clj/auto_ap/ssr/transaction/import.clj`, add them to `ssr/transaction.clj` `key->handler` (with the same middleware stack: `wrap-must {:activity :view :subject :transaction}`, `wrap-client-redirect-unauthenticated`, etc.), and add a transaction "Import" nav entry in `aside.clj` parallel to the ledger one. The page structure mirrors `ledger/external-import-page`: breadcrumb → clipboard script → paste form → review table.
+**Axis:** UI flow & surface
+**Basis:** `direct:` `routes/transactions.cljc` already declares `::external-import-page/parse/import` but `ssr/transaction.clj:101 key->handler` wires none of them; `ssr/ledger.clj:686 key->handler` shows the exact wiring shape to copy.
+**Rationale:** The routing contract already exists and is unused — the cheapest, lowest-risk foundation, and it's what makes req #2 ("like the ledger import") literally true at the routing/page level.
+**Downsides:** Adds a new namespace; needs a nav entry and middleware parity to avoid auth gaps.
+**Confidence:** 95%
+**Complexity:** Low
+**Status:** Unexplored
+
+### 2. Preserve the exact Yodlee positional paste format (req #1)
+**Description:** Reuse `import.manual/columns` + `tabulate-data` (or a malli `:decode/string` wrapper around them) for parsing the pasted TSV, instead of ledger's named-header `tsv->import-data`. Keep the same column positions (`:status :raw-date :description-original ... :amount ... :bank-account-code :client-code`) so users paste identical content.
+**Axis:** Input/paste fidelity
+**Basis:** `direct:` Requirement #1 ("Paste the exact same type of content as was in the master branch version") + `import/manual.clj:10` fixed `columns` vector; the master textarea label is literally "Yodlee manual import table".
+**Rationale:** Users' upstream copy/paste habit (and the Yodlee export shape) is the contract that must not break; the ledger named-header approach would silently change what content is valid.
+**Downsides:** Positional columns are brittle if Yodlee changes column order — but that's already the status quo, not a regression.
+**Confidence:** 90%
+**Complexity:** Low
+**Status:** Unexplored
+
+### 3. Reuse the `import.transactions` engine as the backend (req #5)
+**Description:** The import handler maps parsed rows → `:transaction/*` maps via the existing `manual->transaction` shape, then drives `import.transactions/start-import-batch :import-source/manual` + `import-transaction!` + `finish!` + `get-stats` — exactly as `import.manual/import-batch` does today. The SSR layer is presentation + pre-validation only; the categorization, rule-matching, payment/deposit clearing, synthetic-id dedupe, and audit-transact paths are untouched.
+**Axis:** Core/backend reuse
+**Basis:** `direct:` Requirement #5 ("Minimally, if at all, change any core components") + `import/manual.clj:32 import-batch` already encapsulates the whole engine call; `import/transactions.clj` is covered by `transactions_test.clj`.
+**Rationale:** This is the battle-tested core. Re-implementing it ledger-style would risk dropping validations (`categorize-transaction`) and duplicate a large, audited code path. Wrapping it keeps core change near zero.
+**Downsides:** `import-batch` returns summary stats, not per-row form-cursor errors — so the pre-validation layer (idea #4) must surface row errors *before* the engine runs.
+**Confidence:** 90%
+**Complexity:** Medium
+**Status:** Unexplored
+
+### 4. Two-tier validation: malli shape-parse + a transaction `add-errors` business layer
+**Description:** Mirror ledger's split. Tier 1: a malli `parse-form-schema` decodes the pasted TSV and coerces/validates *shape* (date parses as `MM/dd/yyyy`, amount parses, required fields present) — reusing `manual.common/parse-date`/`parse-amount` as `:decode`/predicate fns. Tier 2: a transaction-specific `add-errors`/`table->entries` adds *business* errors/warnings by reusing the predicates already encoded in `categorize-transaction`: client-not-found (`:error`), bank-account-not-found (`:error`), date before `bank-account/start-date` (`:warn`/`:not-ready`), client locked-until (`:warn`), status not `POSTED` (`:not-ready`), already-imported/extant (`:warn`). Errors are `[message status]` pairs surfaced via `flatten-errors` → form-cursor field paths.
+**Axis:** Validation architecture
+**Basis:** `direct:` Requirement #3 ("every validation maintained… but doesn't have to follow the same structure — make it like the ledger import"). Maps master validations (`manual.clj:23-30`, `transactions.clj:191-225 categorize-transaction`) onto ledger's `add-errors`/`flatten-errors` shape (`ledger.clj:380-519`).
+**Rationale:** Gives the ledger-style inline error UX while guaranteeing 1:1 validation parity — each master check becomes an explicit `add-errors` clause, which is also directly unit-testable (one test per error type, like `ledger_test/add-errors-test`).
+**Downsides:** Some checks (extant/duplicate, start-date, locked-until) need a DB read at validation time that master does lazily inside the engine — must decide whether to pre-check or let the engine's stats report them. Risk of double-validation drift if engine and pre-validator disagree.
+**Confidence:** 80%
+**Complexity:** High
+**Status:** Unexplored
+
+### 5. Editable review grid with per-row error/warning badges and a re-validate loop
+**Description:** After paste+parse, render rows into a `com/data-grid-card` where each field (date, amount, description, bank-account-code, client-code) is an editable `fc/with-field` input, with `com/validated-field` error display and a per-row alert badge+tooltip — exactly like `ledger/external-import-table-form*`. The user can fix a wrong client/bank-account code or date inline and re-submit; only clean rows import, warn-only rows are skipped, error rows block. A "Show table" toggle keeps the default view compact.
+**Axis:** UI flow & surface / validation surfacing
+**Basis:** `direct:` Requirement #2 ("follow slightly better design patterns, like how the ledger import works"). `ledger.clj:117-244` is the editable-grid implementation to copy; master has no inline correction at all (fire-and-forget modal + summary stats).
+**Rationale:** This is the concrete UX upgrade over master and the main reason to model on ledger — turning "paste, pray, read a stats blob" into "paste, see exactly which rows are wrong and why, fix them, import."
+**Downsides:** Highest-effort idea; form-cursor round-tripping of an editable grid is the trickiest part of the ledger code. If scope must shrink, a read-only review table + summary (lighter survivor) is the fallback.
+**Confidence:** 75%
+**Complexity:** High
+**Status:** Unexplored
+
+### 6. Preserve idempotent re-import via synthetic-id duplicate detection, surfaced as "already imported"
+**Description:** Keep `apply-synthetic-ids`/`synthetic-key` so re-pasting the same export is idempotent (the engine categorizes extant rows as `:extant` and skips them). Surface this in the review grid as a `:warn`-level "already imported" badge rather than silently dropping it, so the user understands why a row didn't import.
+**Axis:** Validation architecture
+**Basis:** `direct:` `import/transactions.clj:405-421 apply-synthetic-ids` + `categorize-transaction:192-225` extant handling. This is an existing master behavior that req #3 requires us to maintain.
+**Rationale:** Duplicate-safety is an easy validation to lose in a port; making it visible (vs. master's opaque stats) is a small, high-trust UX win that costs almost nothing on top of idea #5.
+**Downsides:** Requires a DB read of existing `:transaction/id`s at validation time (or reading it back from engine stats post-import).
+**Confidence:** 80%
+**Complexity:** Low
+**Status:** Unexplored
+
+### 7. Start with a failing Playwright e2e, then backfill ledger_test-style unit coverage (req #4)
+**Description:** First commit: a failing e2e (against `test-server`) that dev-logs in, navigates dashboard → transactions → Import, pastes a known-good Yodlee TSV into the paste box, asserts parsed rows render, clicks Import, and asserts the transactions appear / a "N imported" notification fires. It fails initially (no handler/nav). Then make it pass incrementally: route+page (idea #1) → parse (#2/#4 tier 1) → review grid (#5) → import via engine (#3) → business validation (#4 tier 2). Backstop with unit tests mirroring `ledger_test.clj`: `tabulate-data`/parse, each `add-errors` validation clause, and an end-to-end `import` test against Datomic. Reuse the existing `transactions_test.clj` `categorize-transaction` coverage as the validation-parity oracle.
+**Axis:** Test strategy
+**Basis:** `direct:` Requirement #4 ("Write detailed acceptance criteria, and start with a failing e2e test, making it pass over time"). `test-server.clj` already provides the browser harness + test auth; `ledger_test.clj` provides the unit-test template.
+**Rationale:** A red e2e pins down the acceptance contract before any handler exists and gives an unambiguous "done" signal; the unit layer locks in validation parity clause-by-clause so req #3 can't silently regress.
+**Downsides:** e2e clipboard paste may need a direct `type`-into-textarea path (or a test seam) since `navigator.clipboard.read()` is awkward to drive headless — plan a paste fallback the test can use.
+**Confidence:** 85%
+**Complexity:** Medium
+**Status:** Unexplored
+
+## Draft Acceptance Criteria (seed for brainstorm/plan, per req #4)
+
+**Routing & access**
+- [ ] `GET /transactions/external-import-new` renders an import page (admin-gated, same middleware as other transaction routes); 401/redirect for unauthenticated.
+- [ ] A "Import" nav entry appears under the transactions section, active on the import route.
+
+**Paste & parse (req #1)**
+- [ ] Pasting the exact master Yodlee TSV (same positional columns) parses into the same field set as `manual/tabulate-data`.
+- [ ] Header row is dropped; blank rows ignored.
+- [ ] `POST …/parse` re-renders the page with a "N rows found" banner and the review table.
+
+**Validation parity (req #3)** — each must produce a visible, row-attributed message:
+- [ ] Client not found for bank-account-code → error.
+- [ ] Bank account not found by code → error.
+- [ ] Date not `MM/dd/yyyy` / unparseable → error.
+- [ ] Amount unparseable → error.
+- [ ] Status ≠ `POSTED` → not-imported (warn/not-ready).
+- [ ] Date before `bank-account/start-date` → not-imported (not-ready).
+- [ ] Date on/before `client/locked-until` → not-imported (not-ready).
+- [ ] Already-imported (synthetic-id extant) row → skipped, surfaced as warn.
+- [ ] Missing client / bank-account / id → error.
+
+**Import (req #5, minimal core change)**
+- [ ] `POST …/import` runs the existing `import.transactions` engine via the `:import-source/manual` batch path; no change to `categorize-transaction`/`import-transaction!`/`apply-synthetic-ids`.
+- [ ] Only clean rows import; warn-only rows skipped; any error blocks (or imports clean rows + reports errors — match master's "import valid, report failed-validation").
+- [ ] Success notification reports counts (imported / skipped / errors), mirroring master's stats.
+- [ ] Re-importing the same paste is idempotent (no duplicates).
+
+**Tests (req #4)**
+- [ ] A Playwright e2e covering paste → review → import → assert, committed red first, green at the end.
+- [ ] Unit tests per validation clause + a Datomic-backed end-to-end import test, modeled on `ledger_test.clj`.
+
+## Failing-First e2e: concrete starting point
+
+Add `test/clj/auto_ap/ssr/transaction/import_test.clj` (unit) and a Playwright spec driven through `test-server`. The e2e is the first artifact and is expected to fail because no `external-import` handler is wired in `ssr/transaction.clj`. Make it green by walking ideas #1 → #2 → #5 → #3 → #4 in that order; the unit suite grows alongside #4.
+
+## Rejection Summary
+
+| # | Idea | Reason Rejected |
+|---|------|-----------------|
+| 1 | Switch paste format to ledger's named-header columns | Violates req #1 — users paste the exact Yodlee positional export; changing valid input is a silent regression |
+| 2 | Keep it a re-frame/CLJS modal | Branch eliminated the CLJS app; contradicts the whole port. (An SSR htmx *modal* was considered but rejected vs. the dedicated page — ledger uses a page and the editable review grid needs the room) |
+| 3 | Reimplement validation entirely ledger-style, ignoring `import.transactions` | Duplicates audited `categorize-transaction` logic, risks dropping validations (req #3), and churns core (violates req #5) |
+| 4 | Async/streaming import for large pastes | Scope overrun — master is synchronous; YAGNI for the manual paste workflow |
+| 5 | Add CSV file-upload alongside paste | Scope overrun — not part of the master manual-import feature |
+| 6 | Replace `import-batch` stats with a bespoke result type | Unnecessary core change; the existing stats map already carries imported/failed/sample-error |

docs/plans/2026-06-01-001-feat-manual-transaction-import-ssr-plan.md

@@ -0,0 +1,275 @@
+---
+date: 2026-06-01
+type: feat
+status: active
+plan_id: 2026-06-01-001
+title: "feat: Port manual bank-transaction import to SSR (alpine/htmx)"
+depth: standard
+origin: docs/ideation/2026-06-01-manual-transaction-import-ssr-ideation.md
+---
+
+# feat: Port Manual Bank-Transaction Import to SSR
+
+## Summary
+
+Port the master-branch "manual import transactions" feature into the SSR/alpinejs/htmx stack by implementing the `external-import` handlers that `src/cljc/auto_ap/routes/transactions.cljc` already declares but that no handler currently serves. The feature is a dedicated two-stage page — paste the same Yodlee positional-column TSV → an editable review grid with per-row error/warning badges → import — modeled directly on the SSR ledger import (`src/clj/auto_ap/ssr/ledger.clj`). Validation follows the ledger's `add-errors` shape but preserves every master validation, and the actual write reuses the existing `auto-ap.import.transactions` engine unchanged.
+
+---
+
+## Problem Frame
+
+On `master`, admins import bank transactions by pasting a tab-separated Yodlee export into a re-frame modal (`src/cljs/auto_ap/views/pages/transactions/manual.cljs`) that POSTs EDN to `/api/transactions/batch-upload`. This branch removed the ClojureScript React app and re-implemented the transactions surface server-side, but the manual-import feature was never ported — so admins on this branch cannot manually import transactions at all.
+
+The route names are already scaffolded (`::external-page`, `::external-import-page`, `::external-import-parse`, `::external-import-import` in `routes/transactions.cljc`) but `src/clj/auto_ap/ssr/transaction.clj` wires no handlers for them — they are declared dead ends. The work is to fill that gap with handlers + UI + validation + nav + tests, mirroring the already-shipped ledger import.
+
+---
+
+## Scope Boundaries
+
+**In scope**
+- A dedicated SSR import page at `/transaction2/external-import-new` (+ `/parse`, `/import` sub-routes), admin-gated with the same middleware posture as other transaction routes and the ledger import.
+- Reuse of the exact Yodlee positional-column paste format (no named-header columns).
+- An editable review grid with inline per-field editing and per-row error/warning badges (ledger-style, form-cursor driven).
+- Two-tier validation preserving every master validation, with the agreed severity split.
+- Import via the existing `auto-ap.import.transactions` engine, block-whole-batch on hard errors.
+- A transactions-section "Import" nav entry and an import-result notification.
+- A Playwright e2e (committed failing first) plus unit/integration tests modeled on `test/clj/auto_ap/ssr/ledger_test.clj`.
+
+### Deferred to Follow-Up Work
+- CSV file upload as an alternative to paste.
+- Asynchronous/streaming import for very large pastes.
+- Any change to `categorize-transaction` or engine internals.
+
+**Outside this change**
+- Named-header column format (rejected — would silently change valid input).
+- A bespoke import-result type replacing the engine's stats map.
+
+---
+
+## Key Technical Decisions
+
+1. **Full editable review grid, block-whole-batch on hard error** (from brainstorm). Any remaining hard error blocks the entire import (ledger behavior: `throw+ {:type :field-validation ...}`, re-render the grid with errors highlighted); warn-level rows skip just that row and the rest import. Rationale: with an editable grid, the user can fix fixable problems inline, so "nothing imports until clean-or-skippable" is the coherent contract.
+
+2. **Severity split between fixable errors and inherent warnings.**
+   - **Hard errors (block, must fix inline):** unparseable/invalid date (must match `MM/dd/yyyy`), unparseable amount, unknown client code (no client for the bank-account-code), unknown bank-account code, missing required fields.
+   - **Warnings (skip that row, import the rest):** status ≠ `"POSTED"`, transaction date before `bank-account/start-date`, date on/before `client/locked-until`, already-imported (synthetic-id `extant`).
+   Rationale: fixable problems are correctable by editing a cell; inherent skip-conditions are facts about the data/account that editing cannot change, so they should not block the batch — this also reproduces master's "import valid, report the rest" outcome for those rows.
+
+3. **Reuse the exact Yodlee positional paste format** (req #1). Parse with the master positional `columns` mapping (`auto-ap.import.manual/columns` + `tabulate-data` shape), not ledger's named-header `tsv->import-data`. Rationale: admins paste an unchanged Yodlee export; changing valid input is a silent regression.
+
+4. **Reuse the `import.transactions` engine unchanged** (req #5). The import handler maps reviewed rows → `:transaction/*` maps (the `auto-ap.import.manual/manual->transaction` shape) and drives `start-import-batch :import-source/manual` → `import-transaction!` → `finish!` → `get-stats`, with `apply-synthetic-ids` for dedupe — exactly as `auto-ap.import.manual/import-batch` does today. The SSR layer is presentation + pre-validation only.
+
+5. **Preview/engine parity via shared predicates** (the key design tension). The warn-level conditions shown in the grid before import (`not-ready` from start-date/locked-until, `extant`/already-imported, non-`POSTED`) and the engine's write-time `categorize-transaction` decisions must not drift. Decision: the pre-validation layer computes warn conditions by calling the **same** predicate functions the engine uses (`auto-ap.import.transactions/categorize-transaction` and its inputs — `get-existing` for extant, the bank-account `start-date`/`locked-until` checks), rather than re-deriving parallel logic. The grid is advisory display; the engine remains authoritative at write time, and because both read the same functions they agree. Hard-error (fixable) validations have no engine equivalent and live only in the pre-validation layer / malli schema.
+
+6. **Testable paste path.** The ledger import populates a hidden textarea from `navigator.clipboard` via an alpine `@click`/`paste` handler, which is awkward to drive in headless Playwright. Decision: keep the "Load from clipboard" affordance, but ensure the paste textarea is fillable and that a `pasted`/`change` trigger fires the parse `hx-post`, so the e2e can set the value and dispatch the event without the clipboard API. (Implementation detail of how the trigger is wired is deferred to execution.)
+
+---
+
+## High-Level Technical Design
+
+Two-stage flow mirroring `ssr/ledger.clj`, on the transactions surface:
+
+```
+GET  /transaction2/external-import-new          -> external-import-page      (paste form + empty review area)
+POST /transaction2/external-import-new/parse     -> external-import-parse      (decode TSV -> validate -> render editable grid)
+POST /transaction2/external-import-new/import    -> external-import-import     (re-validate -> if any hard error: re-render grid (blocked);
+                                                                                else run import.transactions engine on clean rows,
+                                                                                skip warn rows, return notification with stats)
+```
+
+*This illustrates the intended approach and is directional guidance for review, not implementation specification. The implementing agent should treat it as context, not code to reproduce.*
+
+Validation is two-tier:
+- **Tier 1 (shape, hard errors):** a malli parse-form-schema decodes the pasted TSV positionally (reusing the master column order) and coerces/flags shape problems — date parses as `MM/dd/yyyy`, amount parses, required fields present.
+- **Tier 2 (business):** a transaction `add-errors`/`table->entries` pass attaches `[message status]` pairs (`:error` / `:warn`) per row, with the hard/warn split from Decision 2, computing warn conditions from the shared engine predicates (Decision 5). `flatten-errors` maps them onto form-cursor field paths for the editable grid.
+
+---
+
+## Implementation Units
+
+Build order is **failing-e2e-first** (req #4): U1 lands the red acceptance test, then U2–U7 turn it green incrementally. Each feature-bearing unit also grows the unit-test suite in `test/clj/auto_ap/ssr/transaction/import_test.clj`.
+
+### U1. Failing e2e acceptance test + deterministic import seed
+
+**Goal:** Commit the end-to-end acceptance test (expected to fail) that defines "done", plus the deterministic test fixture it needs.
+**Requirements:** req #4; advances acceptance criteria AC-1, AC-2, AC-9, AC-10.
+**Dependencies:** none.
+**Files:**
+- `e2e/transaction-import.spec.ts` (new)
+- `test/clj/auto_ap/test_server.clj` (modify `seed-test-data` to give the seeded bank account a **fixed** `:bank-account/code`, e.g. `"TEST-CHK"`, since `test-bank-account` otherwise assigns a random code)
+**Approach:** Mirror `e2e/transaction-navigation.spec.ts` conventions (`x-clients: "mine"` header, `page.goto`, locators). The spec navigates to `/transaction2/external-import-new`, fills the paste box with a known-good Yodlee TSV whose bank-account-code/client-code match the seed (`TEST` client, `TEST-CHK` bank account), triggers parse, asserts parsed rows render in the review grid, clicks Import, and asserts a success notification with an imported count and that the imported transaction is visible on `/transaction2`. Include a second scenario pasting a row with an unknown client code and asserting a blocking error badge + that nothing imports. Drive paste by filling the textarea and dispatching the parse trigger (Decision 6), not the clipboard API.
+**Patterns to follow:** `e2e/transaction-navigation.spec.ts`, `e2e/bulk-code-transactions.spec.ts`; seed shape in `test/clj/auto_ap/test_server.clj` `seed-test-data`.
+**Test scenarios:**
+- Covers AE/AC-1, AC-2: paste valid TSV → rows render → import → "N imported" notification → transaction appears on the list page.
+- Covers AC-9: paste TSV with an unknown client code → row shows a blocking error badge, Import is blocked, no transaction created.
+- Edge: empty paste → no rows / friendly empty state (assert no crash).
+**Verification:** `npx playwright test e2e/transaction-import.spec.ts` runs and **fails** at this unit (no handler yet); the seed change does not break existing e2e specs (`npx playwright test` green except the new file).
+**Execution note:** Start red. This is the acceptance contract; do not weaken it to pass — make U2–U7 satisfy it.
+
+### U2. Wire routes and render the import page shell
+
+**Goal:** Make `/transaction2/external-import-new` serve a real page with the correct admin middleware; wire `parse`/`import` routes to placeholder handlers.
+**Requirements:** AC-1, AC-12 (auth); req #2.
+**Dependencies:** U1.
+**Files:**
+- `src/clj/auto_ap/ssr/transaction/import.clj` (new — namespace for the import handlers)
+- `src/clj/auto_ap/ssr/transaction.clj` (merge the new `key->handler` entries into the existing map at the `key->handler` def)
+**Approach:** Create `external-import-page` returning a `base-page` + `com/page` with breadcrumb ("Transactions" → "Import"), the clipboard helper script, and a forms container (initially just the paste form placeholder). Wire `::route/external-import-page`, `::route/external-import-parse`, `::route/external-import-import` into the transaction `key->handler` with the same middleware chain ledger uses for its import routes (`wrap-schema-enforce`/`wrap-form-4xx-2`/`wrap-schema-decode`/`wrap-nested-form-params` on parse/import) under the transaction page middleware (`wrap-must {:activity :import :subject :transaction}` analogous to ledger's `:subject :ledger`, `wrap-client-redirect-unauthenticated`). Confirm the correct `:activity`/`:subject` against the permissions model.
+**Patterns to follow:** `src/clj/auto_ap/ssr/ledger.clj` `external-import-page` and `key->handler` (~lines 276–318, 686–718); `src/clj/auto_ap/ssr/transaction.clj` existing `key->handler` (~line 101).
+**Test scenarios:**
+- Happy path: `GET` the page as admin → 200, renders the paste form container.
+- Error/auth: unauthenticated request → redirect/401 per `wrap-client-redirect-unauthenticated`.
+**Verification:** Page loads at the route in the running app and in `test_server`; the e2e gets past navigation (still fails later in the flow).
+
+### U3. Paste + parse using the master positional column format
+
+**Goal:** Parse the pasted Yodlee TSV (exact master columns) into rows and render them; wire the paste form's `pasted`-triggered `hx-post` to the parse handler.
+**Requirements:** req #1, req #2; AC-1, AC-3, AC-4.
+**Dependencies:** U2.
+**Files:**
+- `src/clj/auto_ap/ssr/transaction/import.clj` (add `external-import-text-form*`, `external-import-parse`, the parse malli schema, and a positional `tsv->rows` decode)
+- `test/clj/auto_ap/ssr/transaction/import_test.clj` (new)
+**Approach:** Reuse the master column order from `auto-ap.import.manual/columns` and `tabulate-data` (CSV read with `\tab`, drop header) to map positional columns. Define a malli `parse-form-schema` (ledger-style) whose `:table` field uses a `:decode/string` that runs the positional parse and a per-row `:decode/arbitrary` to build row maps; encode Tier-1 shape constraints (date `MM/dd/yyyy`, amount parses, required fields) reusing `auto-ap.import.manual.common/parse-date`/`parse-amount` semantics. `external-import-parse` re-renders the forms fragment with `:just-parsed? true`. Keep the paste textarea fillable and fire the parse trigger on a `pasted`/`change` event (Decision 6).
+**Patterns to follow:** `ssr/ledger.clj` `external-import-text-form*`, `external-import-parse`, `tsv->import-data`, `parse-form-schema` (~lines 246–375); `import/manual.clj` `columns`/`tabulate-data`; `import/manual/common.clj` `parse-date`/`parse-amount`.
+**Test scenarios:**
+- Happy path: a known Yodlee TSV string decodes to the expected row count with the expected field keys/values (positional mapping correct).
+- Header handling: first row dropped; blank rows ignored.
+- Edge: amount with currency formatting parses; amount unparseable flagged at Tier 1.
+- Edge: date not `MM/dd/yyyy` flagged at Tier 1; valid date parses.
+- Covers AC-3: pasting the exact master column layout yields the same field set master's `tabulate-data` produced.
+**Verification:** After paste, the parsed rows render (read-only at this unit is acceptable); parse unit tests green.
+
+### U4. Editable review grid with per-row error/warning badges
+
+**Goal:** Render parsed rows into an editable `data-grid` where each field is editable and per-row error/warning badges show, with a "Show table" toggle and an Import button.
+**Requirements:** req #2; AC-5, AC-6.
+**Dependencies:** U3.
+**Files:**
+- `src/clj/auto_ap/ssr/transaction/import.clj` (add `external-import-table-form*`, `external-import-form*`)
+**Approach:** Mirror `ledger/external-import-table-form*` using form-cursor (`fc/start-form`, `fc/with-field`, `fc/cursor-map`, `fc/field-value`/`field-name`/`field-errors`) and `com/data-grid-card` / `com/validated-field` / `com/text-input` / `com/money-input`. Columns reflect the transaction row shape (date, description, amount, bank-account-code, client-code, status). Per-row badge summarizes that row's error/warn state with a tooltip listing messages (red for `:error`, yellow for `:warn`). A parsed-summary banner shows row count + error/warning pill counts. Values round-trip on re-submit so inline edits persist.
+**Patterns to follow:** `ssr/ledger.clj` `external-import-table-form*` and `external-import-form*` (~lines 117–274).
+**Test scenarios:**
+- Test expectation: none for pure rendering structure beyond what U5 exercises — but include: rows with no errors render without a badge; rows with errors render a red badge; rows with only warnings render a yellow badge (assert via the rendered hiccup/markup in a handler-level test once U5 attaches errors).
+**Verification:** Parsed grid is visibly editable; badges appear once U5 attaches errors; e2e can see rows.
+
+### U5. Two-tier validation preserving every master validation
+
+**Goal:** Attach hard-error and warning statuses to rows per the severity split, reusing the engine's predicates for the warn conditions so the preview matches the engine.
+**Requirements:** req #3, req #5 (Decision 5); AC-7, AC-8, AC-9.
+**Dependencies:** U3 (Tier 1 shape errors), U4 (badges to display them).
+**Files:**
+- `src/clj/auto_ap/ssr/transaction/import.clj` (add `add-errors`, `table->entries`, `flatten-errors`, `entry-error-types` analogues)
+- `test/clj/auto_ap/ssr/transaction/import_test.clj` (extend)
+**Approach:** Build a transaction `add-errors` that, given lookups (client-by-bank-account-code, bank-account-by-code, bank-account `start-date`/`locked-until`, existing transaction ids), assigns:
+- **Hard errors:** unknown client code, unknown bank-account code, missing required fields. (Tier-1 date/amount errors already present from U3.)
+- **Warnings:** status ≠ `POSTED`; date before `bank-account/start-date`; date on/before `client/locked-until`; already-imported (synthetic-id present in existing ids).
+Compute the warn conditions by calling the same functions the engine uses — `auto-ap.import.transactions/categorize-transaction` (and its inputs `get-existing`, the `apply-synthetic-ids` key) — rather than parallel logic (Decision 5). `flatten-errors` maps `[message status]` onto form-cursor field paths so badges render against the right rows. Map every master validation explicitly (see `import/manual.clj manual->transaction` and `import/transactions.clj categorize-transaction`).
+**Patterns to follow:** `ssr/ledger.clj` `add-errors`/`table->entries`/`flatten-errors`/`entry-error-types` (~lines 380–523); `import/transactions.clj` `categorize-transaction`/`get-existing`/`apply-synthetic-ids`.
+**Test scenarios (one per validation, modeled on `ledger_test/add-errors-test`):**
+- Hard error: unknown client code → `:error` with a clear message.
+- Hard error: unknown bank-account code → `:error`.
+- Hard error: missing required field → `:error`.
+- (Tier 1) invalid date / unparseable amount → `:error`.
+- Warning: status ≠ `POSTED` → `:warn`, row skipped.
+- Warning: date before `bank-account/start-date` → `:warn`.
+- Warning: date on/before `client/locked-until` → `:warn`.
+- Warning: already-imported (extant synthetic id) → `:warn`.
+- Parity: a row the grid marks clean is categorized `:import` by `categorize-transaction`; a row marked warn-skip is categorized to the matching non-`:import` action (assert grid preview agrees with engine).
+- Pass-through: a fully valid row has no errors/warnings.
+**Verification:** Validation unit tests green; badges reflect the correct severities in the grid.
+
+### U6. Import via the existing engine, block-on-error, with notification
+
+**Goal:** Implement `external-import-import`: block the whole batch if any hard error remains; otherwise run the `import.transactions` engine on clean rows (skipping warn rows) and return a result notification.
+**Requirements:** req #5, Decisions 1 & 4; AC-2, AC-9, AC-10, AC-11.
+**Dependencies:** U5.
+**Files:**
+- `src/clj/auto_ap/ssr/transaction/import.clj` (add `rows->transactions`, `import-transactions`, `external-import-import`)
+**Approach:** Re-validate submitted (possibly edited) rows via U5. If any `:error` rows remain, `throw+ {:type :field-validation :form-errors ... :form-params ...}` and re-render the grid with errors (the `wrap-form-4xx-2` middleware handles re-render) — nothing imports. Otherwise map clean rows → `:transaction/*` maps using the `auto-ap.import.manual/manual->transaction` shape, apply `apply-synthetic-ids`, then drive `start-import-batch :import-source/manual` → `import-transaction!` (per row) → `finish!` → `get-stats`. Warn-only rows are excluded from the engine input (skipped). Return `html-response` re-rendering the form with an `hx-trigger` notification reporting counts from the engine stats (imported / skipped / not-ready / extant), mirroring master's stats surface.
+**Patterns to follow:** `ssr/ledger.clj` `import-ledger` + `external-import-import` (~lines 554–684); `import/manual.clj` `import-batch` (engine driving); `import/manual.clj` `manual->transaction`.
+**Test scenarios (modeled on `ledger_test` `import-ledger-*` tests, against Datomic via `wrap-setup`/`setup-test-data`/`admin-token`):**
+- Happy path: all-clean batch → engine imports all rows; stats report the imported count; transactions exist in the DB afterward.
+- Block-on-error: a batch with one hard-error row → throws `:field-validation`; **no** transactions are created (assert DB unchanged).
+- Warning skip: a batch with one warn-only row (e.g., non-`POSTED`) and clean rows → clean rows import, warn row skipped, stats reflect the skip.
+- Idempotency: importing the same paste twice → second run imports 0 new (extant/synthetic-id dedupe); no duplicates.
+- Integration: imported transaction carries `:import-source/manual` and is categorized/coded by the engine as it would be for any import (engine unchanged).
+**Verification:** Import unit/integration tests green; the e2e's import step succeeds and the transaction appears on the list page.
+
+### U7. Transactions "Import" nav entry + final polish
+
+**Goal:** Add an "Import" entry to the transactions section nav (parallel to the ledger import nav) and finish the parsed-summary banner / notification copy.
+**Requirements:** req #2; AC-1, AC-11.
+**Dependencies:** U2 (route exists), U6 (notification exists).
+**Files:**
+- `src/clj/auto_ap/ssr/components/aside.clj` (add a transactions "Import" nav button + mark active on `::transaction-routes/external-import-page`)
+**Approach:** Mirror the ledger import nav entry in `aside.clj` — add a sub-menu button under the transactions section linking to `::transaction-routes/external-import-page`, active-highlighted on that matched route. Confirm the banner shows row counts + error/warning pills (from U4) and the success notification copy matches the engine stats.
+**Patterns to follow:** `ssr/components/aside.clj` ledger import nav (~lines 360–366) and the transactions sub-menu (~lines 285–298).
+**Test scenarios:**
+- Test expectation: none (navigation markup) — covered indirectly by the e2e navigating via the nav link; optionally assert the nav button renders with the correct href on the import route.
+**Verification:** Full `e2e/transaction-import.spec.ts` passes; nav link is present and active on the import page.
+
+---
+
+## Acceptance Criteria
+
+**Routing & access**
+- **AC-1.** `GET /transaction2/external-import-new` renders the import page for an admin; an "Import" nav entry under the transactions section links to it and is active there.
+- **AC-12.** Unauthenticated access redirects/401s per the standard transaction-route middleware.
+
+**Paste & parse (req #1)**
+- **AC-3.** Pasting the exact master Yodlee positional TSV parses into the same field set as `auto-ap.import.manual/tabulate-data`; the header row is dropped and blank rows ignored.
+- **AC-4.** `POST .../parse` re-renders the page with a "N rows found" banner and the review grid.
+
+**Review grid (req #2)**
+- **AC-5.** Parsed rows render in an editable grid; each field is editable and inline edits persist across re-submit.
+- **AC-6.** Each row shows an error badge (red) when it has a hard error, a warning badge (yellow) when it has only warnings, and no badge when clean; badges list messages on hover.
+
+**Validation parity (req #3)** — each produces a visible, row-attributed message:
+- **AC-7.** Hard errors block: client not found, bank account not found, date not `MM/dd/yyyy`, amount unparseable, missing required field.
+- **AC-8.** Warnings skip just that row: status ≠ `POSTED`, date before `bank-account/start-date`, date on/before `client/locked-until`, already-imported.
+- **AC-9.** With any remaining hard error, clicking Import blocks the whole batch (nothing imports) and re-renders the grid with errors highlighted.
+
+**Import (req #5)**
+- **AC-2.** `POST .../import` imports the clean rows via the existing `import.transactions` engine on the `:import-source/manual` batch path; the success notification reports counts (imported / skipped / not-ready / extant).
+- **AC-10.** Re-importing the same paste is idempotent — no duplicate transactions (synthetic-id dedupe preserved).
+- **AC-11.** `categorize-transaction` and the engine internals are unchanged by this work.
+
+**Tests (req #4)**
+- The Playwright e2e `e2e/transaction-import.spec.ts` exists, was committed failing first, and passes at the end.
+- Unit/integration tests in `test/clj/auto_ap/ssr/transaction/import_test.clj` cover each validation clause and the end-to-end import flow against Datomic.
+
+---
+
+## Test Strategy
+
+- **e2e (Playwright):** `e2e/transaction-import.spec.ts`, driven through `test/clj/auto_ap/test_server.clj` (real routes, injected test auth). Committed red in U1, green by U7.
+- **Unit/integration (clojure.test):** `test/clj/auto_ap/ssr/transaction/import_test.clj`, modeled on `test/clj/auto_ap/ssr/ledger_test.clj` — pure parse/format tests, one validation test per clause, and Datomic-backed import tests via `wrap-setup` / `setup-test-data` / `admin-token`. Run with `clj-nrepl-eval -p PORT "(clojure.test/run-tests 'auto-ap.ssr.transaction.import-test)"` per AGENTS.md (preferred over `lein test`).
+- **Validation-parity oracle:** existing `test/clj/auto_ap/import/transactions_test.clj` (`categorize-transaction`) backs Decision 5 — the warn-condition predicates the grid reuses are already under test.
+
+---
+
+## System-Wide Impact
+
+- **Editing discipline (AGENTS.md):** all Clojure edits go through the clojure-mcp editing tools (or `@clojure-author`), not raw file edits; use `clojure-eval`/`clj-nrepl-eval` to compile-check and run tests. Run `lein cljfmt fix` before committing; `clj-paren-repair` on any file that won't compile.
+- **Shared component reuse:** the feature composes existing `ssr/components` (`data-grid-card`, `validated-field`, `text-input`, `money-input`, `button`, `checkbox`, `errors`, `pill`, `form-errors`) and `ssr/form-cursor` — no core-component changes expected (req #5). If a component genuinely needs a new option, prefer an additive, backward-compatible change and flag it.
+- **Test fixture change:** giving the seeded bank account a deterministic `:bank-account/code` in `test_server.clj` could affect other e2e specs that assume the random code; U1 verifies the existing suite stays green.
+- **Permissions:** confirm the `wrap-must` `:activity`/`:subject` for the import routes matches the permission model (ledger uses `{:activity :import :subject :ledger}`); use the transaction equivalent.
+
+---
+
+## Risks & Mitigations
+
+- **Preview/engine drift (highest risk).** Mitigated by Decision 5 — share the engine's predicates for warn conditions; the parity test in U5 asserts the grid and `categorize-transaction` agree.
+- **Headless clipboard paste.** Mitigated by Decision 6 — fillable textarea + explicit parse trigger so the e2e never needs `navigator.clipboard`.
+- **form-cursor round-tripping of an editable grid** is the trickiest ledger mechanic to copy; mitigate by mirroring `external-import-table-form*` closely and testing edit-persist-on-resubmit early (U4).
+- **Positional column brittleness** is inherited from master (Yodlee column order); not a regression, and out of scope to fix here.
+
+---
+
+## Deferred Implementation Notes (execution-time unknowns)
+
+- Exact helper/function names in the new `import.clj` namespace.
+- The precise malli `:decode` wiring for positional parsing (reuse vs. thin wrapper around `tabulate-data`).
+- The exact `:activity`/`:subject` keyword for the import-route `wrap-must` (verify against the permissions model).
+- The seeded bank-account code value and whether any existing e2e needs adjustment after making it deterministic.
+- Final notification/banner copy.

docs/plans/2026-06-02-001-refactor-ssr-rendering-modernization-plan.md

@@ -0,0 +1,777 @@
+# SSR Form & Wizard Simplification — Migration Plan
+
+> **Status:** Planning / for execution by an agent or engineer.
+> **Owner:** Bryce
+> **Type:** Refactor (no user-facing behavior change; parity required).
+
+This plan describes a series of low-risk migrations that make the server-side
+rendered (SSR) forms and wizards substantially simpler. It is self-contained:
+every concept needed to execute is stated here, illustrated with code snippets.
+The work is sequenced so each migration is small, reversible, and *teaches a
+skill* that makes the next migration cheaper.
+
+---
+
+## 1. Goals
+
+1. **Render forms by re-rendering the whole form** (or a precise, isolated
+   fragment) over HTMX, using hx-select to choose elements, instead of mutating 
+   the DOM in place. This removes the class of bugs around stale state, lost 
+   focus/caret, and out-of-band patching.
+2. **Root cursors at the top; never fake their position.** Cursors are fine and
+   stay — a render function may take an explicit data map *or* a cursor. What we
+   remove is the practice of **faking a cursor to start deeper** in the tree to
+   satisfy a partial render, and the duplicate `*-no-cursor*` variants that
+   fakery forces. The target: a cursor always begins at the top level of what the
+   form consumes and walks down naturally from there. (Because the whole form is
+   re-rendered each time, there is no longer any reason to fake a deep starting
+   position.)
+3. **Stop forcing single-step forms through wizard machinery.** Most "wizards"
+   are single-step; they become plain forms. Genuine multi-step flows use a
+   small data-driven engine instead of protocols + middleware stacking, and
+   **store each step's data in the session** (combined only at the end) instead
+   of round-tripping and merging an EDN snapshot — the Django `formtools` model.
+4. **Render HTML with Selmer templates** (Jinja-style) instead of Hiccup for the
+   interactive, attribute-heavy components, so Alpine/HTMX attributes are
+   first-class HTML rather than a mix of Clojure keywords and strings.
+5. **Capture the migration method in a skill** that is created after the first
+   successful migration and extended by every migration thereafter.
+
+Net effect target: large reduction in lines of code, route count, and branching
+complexity, with measurably more reuse across similar forms.
+
+---
+
+## 2. Why — the current pain (rationale)
+
+### 2.1 In-place DOM mutation is fragile
+Re-rendering only fragments and patching the rest (via morph or out-of-band
+swaps) means the server and the DOM can disagree. Keeping a focused input alive
+through a patch requires keying tricks and guards. Re-rendering the **whole
+form** and letting the typed value ride along in the form is simpler and
+correct, *provided the input the user is typing in is never inside the region
+being swapped*.
+
+### 2.2 Faking cursor positions forces duplicate functions
+A "form cursor" itself is fine. The pain comes from **faking the cursor's
+starting position** — rebinding the dynamic root deeper in the tree so a deeply
+nested render function can run against a fragment. That fakery is fragile and
+hard to follow, and it has spawned duplicate render functions: one that reads the
+faked cursor and one that takes plain params for the cases where the fake can't
+be set up.
+
+```clojure
+;; SMELL: this render fn assumes the cursor was faked to start deep at an account,
+;; so it only works when *current*/*prefix* were rebound to point there first.
+(defn account-row* [{:keys [value client-id]}]
+  (com/data-grid-row
+    (fc/with-field :transaction-account/account
+      (com/data-grid-cell
+        (account-typeahead* {:value (fc/field-value) :name (fc/field-name)})))
+    ...))
+
+;; SMELL: a second copy of the same markup, just to avoid the faked-deep cursor
+(defn account-row-no-cursor* [{:keys [account index client-id]}]
+  ...)
+```
+
+**Target:** the cursor starts at the top of the form's data and walks down
+naturally; a row render either takes explicit row data or receives a cursor the
+caller advanced step-by-step from the root — never one teleported to a deep node.
+
+### 2.3 Single-step forms wear wizard costumes
+Several forms implement a multi-step wizard protocol (5 protocols, 15+ methods),
+serialize an EDN snapshot with custom readers into hidden fields, and register
+10–20 routes with stacked middleware — all for a single-step form. That is pure
+overhead.
+
+### 2.4 Multi-step wizards round-trip and merge a snapshot
+The genuine multi-step wizards carry the whole accumulating form state as an EDN
+snapshot in hidden fields, then rebuild it each request by merging the posted
+pieces back into the snapshot. The serialization needs custom readers, the merge
+logic is error-prone, and the page payload grows with every step. The fix is to
+**store each step's data in the session under its own key and combine only at the
+end** — the Django `formtools` model (§3.3) — so no snapshot is built or merged.
+
+### 2.5 Hiccup makes Alpine/HTMX attributes ambiguous
+The same attribute is sometimes a keyword and sometimes a string in the same
+file, and event handlers must be strings while structural Alpine attrs are
+keywords. There is no rule a reader (or an LLM) can rely on:
+
+```clojure
+;; Both of these appear in one component file today:
+:x-ref  "input"      ; keyword key
+"x-ref" "hidden"     ; string key
+:x-model "value.value"
+"x-model" "search"
+"@keydown.down.prevent.stop" "tippy.show();"  ; handlers must be strings
+:x-init "..."                                  ; structural attrs are keywords
+```
+
+In a Selmer template the same markup is unambiguous plain HTML:
+
+```html
+<input x-ref="input" x-model="value.value"
+       @keydown.down.prevent.stop="tippy?.show()" />
+```
+
+---
+
+## 3. Target state (the patterns, with snippets)
+
+These four patterns are what every migration moves code *toward*. The skill
+(§5) holds the canonical, growing version of each.
+
+### 3.1 Whole-form HTMX swap doctrine
+
+Decide per interactive control, in this priority order:
+
+1. **No request** when the field affects nothing else. Its value rides along in
+   the form and is read on submit.
+   ```html
+   <!-- a memo / free-text field that influences nothing -->
+   <input name="memo" />   <!-- no hx-* at all -->
+   ```
+2. **Targeted swap of a single isolated cell** when a field's effect is purely
+   local. Give the cell a stable id and keep it out of the typed input's subtree.
+   ```html
+   <!-- selecting an account only changes the valid Location options -->
+   <select name="accounts[0][account]"
+           hx-post="/transaction/edit-form-changed"
+           hx-target="#account-location-0"
+           hx-select="#account-location-0"
+           hx-swap="outerHTML" hx-trigger="changed">
+   </select>
+   <div id="account-location-0"> ...location options... </div>
+   ```
+3. **Whole-form swap** when the change touches interdependent state (vendor,
+   add/remove row, mode toggle, $/% radio). The form's hidden state rides along,
+   so one swap keeps everything consistent — **no out-of-band swaps**.
+   ```html
+   <form id="wizard-form"
+         hx-post="/transaction/edit-form-changed"
+         hx-target="#wizard-form" hx-select="#wizard-form" hx-swap="outerHTML">
+     ...
+   </form>
+   ```
+4. **Out-of-band (OOB) swap only for genuinely disjoint DOM regions** — a global
+   flash/toast, a nav badge, a modal mounted at the document root. If you are
+   tempted to OOB something *inside the same feature*, that is a signal to
+   **restructure the DOM so the dependent element shares a common ancestor** with
+   the trigger, and use an ordinary swap. Example: put running totals in a
+   sibling `<tbody>` so an amount edit can swap totals without replacing the
+   amount input:
+   ```clojure
+   ;; totals live in their own tbody, a sibling of the input rows
+   (com/data-grid- {:rows ...
+                    :footer-tbody [:tbody {:id "account-totals"} ...]})
+
+   ;; the amount input swaps ONLY the totals tbody (never itself)
+   [:input {:name "accounts[0][amount]"
+            :hx-post "/transaction/edit-form-changed"
+            :hx-target "#account-totals" :hx-select "#account-totals"
+            :hx-swap "outerHTML" :hx-trigger "keyup changed delay:300ms"}]
+   ```
+
+**Focus invariant (must always hold):** the input the user is typing in is never
+inside the region its own request swaps.
+
+**Alpine components must survive swaps.** Null-guard every reference that depends
+on Alpine/tippy being initialised, and key a component by its server-provided
+value so a server-driven change re-initialises it instead of preserving stale
+state:
+```clojure
+;; null-guard:
+"@keydown.enter.prevent.stop" "$refs.input?.__x_tippy?.hide(); ..."
+;; key by current value so morph/replace re-inits on server change:
+(assoc attrs :key (str id "--" current-value))
+```
+
+**Selector strategy for targeted swaps (a consideration, not a mandate).**
+Rules 2 and 4 above need a stable `hx-target`/`hx-select`. The obvious approach
+— a unique `id` on every swappable element — gets noisy in repeated structures
+(e.g. a table of financial accounts where choosing an account must swap *that
+row's* dropdown). When you reach those advanced cases, consider a more
+consistent scheme instead of hand-minting ids everywhere:
+
+- **Semantic markup + data-attributes** to craft a fine-grained selector without
+  per-element ids. For example, mark rows/cells with their identity and target
+  by attribute:
+  ```html
+  <tr data-row="account" data-index="0">
+    <td data-cell="account">
+      <select hx-post="/transaction/edit-form-changed"
+              hx-target="[data-row='account'][data-index='0'] [data-cell='location']"
+              hx-select="[data-row='account'][data-index='0'] [data-cell='location']"
+              hx-swap="outerHTML" hx-trigger="changed">…</select>
+    </td>
+    <td data-cell="location">…</td>
+  </tr>
+  ```
+- **A `form-path -> id` (or `-> selector`) function**, derived the same way a
+  cursor path is, so the server and the markup agree on the target by
+  construction rather than by convention. A render fn at form-path
+  `[:accounts 0 :location]` would compute its own stable selector (id or
+  data-attribute query) from that path, mirroring §3.2's top-rooted cursor.
+
+The aim is *consistency and predictability* of swap targets in repeated/nested
+structures — pick whichever keeps targets unambiguous and easy to generate. Note
+this in `reference/swap-doctrine.md` and let the first modal that hits nested
+repeated swaps (Phase 5 / the wizards) settle on a convention for the cookbook.
+
+### 3.2 Render functions: explicit data, or a top-rooted cursor
+
+One function, data in, markup out. The data can arrive as a plain map or via a
+cursor — **as long as the cursor was rooted at the top of the form and walked
+down to here**, never faked to start at this depth.
+
+```clojure
+;; GOOD: pure, works everywhere, testable without setup
+(defn account-row [{:keys [account index client-id amount-mode]}]
+  (com/data-grid-row
+    (com/hidden {:name (str "accounts[" index "][db/id]")
+                 :value (or (:db/id account) "")})
+    (com/data-grid-cell
+      (account-typeahead* {:value (:transaction-account/account account)
+                           :name  (str "accounts[" index "][account]")
+                           :client-id client-id}))
+    ...))
+```
+
+```clojure
+;; ALSO FINE: a cursor that started at the form root and was advanced naturally.
+;; The top-level render walks the cursor; the row fn receives the dereferenced
+;; row (or the advanced cursor) — no rebinding of *current*/*prefix* to fake depth.
+(defn account-rows [accounts-cursor]
+  (for [row-cursor (fc/each accounts-cursor)]   ; advanced from the root, not faked
+    (account-row {:account @row-cursor :index (fc/index row-cursor) ...})))
+```
+
+The rule is about *where the cursor starts*, not whether you use one. If a caller
+already holds a top-rooted cursor, advance it and hand the row data (or the
+advanced cursor) to one render function. Never rebind the cursor to teleport to a
+deep node, and never keep a second `*-no-cursor*` copy of the markup.
+
+### 3.3 Forms vs. wizards (and the data-driven wizard engine)
+
+- **Single-step → plain form.** Two routes: `GET` (render) and `POST` (validate
+  + save). State is plain form fields + an entity id. No snapshot, no server
+  state, no protocol.
+  ```clojure
+  {::route/edit        (fn [req] (html-response (render-edit-form {:entity (get-entity req)})))
+   ::route/edit-submit (fn [req] (validate-and-save req))}
+  ```
+
+- **Genuinely multi-step → data-driven engine with session-stored step state.**
+
+  > **Inspiration — Django `formtools` `WizardView`.** Django's wizard does *not*
+  > round-trip a serialized blob of the whole form through the page. Each step's
+  > validated (cleaned) data is written to a **storage backend (the user session
+  > by default)** under that step's key, and the steps are combined only at the
+  > very end via `get_all_cleaned_data()`. We adopt the same model: **replace the
+  > EDN snapshot + piecewise merging with per-step form state stored in the
+  > session.** A step writes its own data under its own key; nothing is merged
+  > into a snapshot and nothing about other steps rides through the form.
+  > Refs: `formtools.wizard.views.WizardView`, its `storage` backends
+  > (`SessionStorage`), and `get_all_cleaned_data()`
+  > (https://django-formtools.readthedocs.io/en/latest/wizard.html).
+
+  A wizard is *data*:
+  ```clojure
+  (def vendor-wizard-config
+    {:steps [{:key :info     :schema info-schema     :fields [...] :render render-info-step
+              :next (fn [data] :terms)}
+             {:key :terms    :schema terms-schema    :fields [...] :render render-terms-step
+              :next (fn [data] :done)}]
+     :init-fn (fn [req] {...})
+     :submit-route "/admin/vendor/wizard/submit"
+     :done-fn (fn [all-data req] (save! all-data) (html-response "Saved"))})
+  ```
+  with a tiny engine (no protocols) whose state lives **in the session**, keyed
+  by a wizard instance id, with each step's data stored under its own step key —
+  the formtools `SessionStorage` model. No snapshot, no custom EDN readers, no
+  merge-into-snapshot:
+  ```clojure
+  ;; Storage backed by the Ring session (replaces the hidden EDN snapshot).
+  ;; Path in session: [:wizards <wizard-id> :step-data <step-key>]
+  (defn create-wizard! [session config]
+    (let [id (str (java.util.UUID/randomUUID))]
+      [id (assoc-in session [:wizards id]
+                    {:current-step (-> config :steps first :key) :step-data {}})]))
+
+  (defn put-step  [session id k data] (assoc-in  session [:wizards id :step-data k] data)) ; replace, not merge
+  (defn set-step  [session id k]      (assoc-in  session [:wizards id :current-step] k))
+  (defn get-all   [session id]        (->> (get-in session [:wizards id :step-data]) vals (apply merge)))
+  (defn forget    [session id]        (update   session :wizards dissoc id))
+
+  (defn render-wizard [{:keys [wizard-id config session request]}]
+    (let [{:keys [current-step step-data]} (get-in session [:wizards wizard-id])
+          step (first (filter #(= (:key %) current-step) (:steps config)))]
+      [:form#wizard-form {:hx-post (:submit-route config)
+                          :hx-target "#wizard-form" :hx-select "#wizard-form" :hx-swap "outerHTML"}
+       ;; only a reference token rides in the form -- not the form's state
+       (com/hidden {:name "wizard-id" :value wizard-id})
+       (com/hidden {:name "current-step" :value (name current-step)})
+       ((:render step) (assoc request :step-data (get step-data current-step {})))]))
+
+  ;; Handlers thread the (possibly updated) session back into the Ring response.
+  (defn handle-step-submit [config {:keys [session] :as request}]
+    (let [{:strs [wizard-id current-step]} (:form-params request)
+          step (first (filter #(= (:key %) (keyword current-step)) (:steps config)))
+          data (select-keys (:form-params request) (map name (:fields step)))]
+      (if-let [errors (mc/explain (:schema step) data)]
+        (-> (render-wizard {:wizard-id wizard-id :config config :session session
+                            :request (assoc request :errors errors)})
+            html-response)
+        (let [session' (put-step session wizard-id (keyword current-step) data)
+              nxt       ((:next step) data)]
+          (if (= nxt :done)
+            (-> ((:done-fn config) (get-all session' wizard-id) request)   ; combine only at the end
+                (assoc :session (forget session' wizard-id)))
+            (let [session'' (set-step session' wizard-id nxt)]
+              (-> (html-response (render-wizard {:wizard-id wizard-id :config config
+                                                 :session session'' :request request}))
+                  (assoc :session session''))))))))
+  ```
+  Two routes per wizard: open (`partial open-wizard config`) and submit
+  (`partial handle-step-submit config`). State is namespaced by `wizard-id` inside
+  the session, so multiple in-flight wizards (and tabs) don't collide, and it is
+  discarded on completion (`forget`). See Open decision 1 for the storage-backend
+  choice (Ring session store vs. a durable store for long-lived wizards).
+
+### 3.4 Selmer templates
+
+Interactive components render from Selmer templates with plain-HTML attributes.
+Selmer composes via `{% include %}` and `{% block %}`; an interop bridge lets a
+Selmer template embed Hiccup output (and vice versa) during the transition.
+
+```html
+{# templates/components/typeahead.html #}
+<div class="relative" x-data="{{ x_data|safe }}" x-model="{{ x_model }}">
+  <a class="{{ classes }}" x-ref="input" tabindex="0"
+     @keydown.down.prevent.stop="tippy?.show()"
+     @keydown.backspace="tippy?.hide(); value = {value:'', label:''}">
+    <span x-text="value.label"></span>
+  </a>
+  ...
+</div>
+```
+
+```clojure
+;; render helper + interop bridge
+(defn render [tpl ctx] (selmer/render-file tpl ctx))
+(defn hiccup->html [h] (hiccup/html h))          ; embed hiccup inside selmer via {{ frag|safe }}
+;; selmer fragment inside hiccup: [:div (hiccup/raw (render "..." ctx))]
+```
+
+---
+
+## 4. Principles
+
+1. **Strangler, not big-bang.** New engine, Selmer renderer, and the swap
+   doctrine live alongside the old code. Migrate one modal at a time behind its
+   own route. Old machinery is deleted only when its last caller is gone.
+2. **Simplest first.** Each migration is small and reversible (one commit).
+   Start with the already-proven modal, then the smallest fresh ones, and leave
+   the largest/most complex for last — by which point the skill is mature.
+3. **Skill-driven and self-reinforcing.** After the first successful migration,
+   distil the method into a skill (§5). Every subsequent migration *reads* the
+   skill first and *extends* it last.
+4. **Quality must measurably improve.** Each migration records a scorecard (§6);
+   no metric may regress for the touched modal.
+5. **Behavior parity is proven by tests, not by reading** (§7). The full e2e
+   suite must stay green after every migration.
+
+---
+
+## 5. The skill: `ssr-form-migration`
+
+**When it is created:** in **Phase 1**, immediately after — and distilled from —
+the first successful modal migration (the transaction-edit modal, whose
+whole-form swap implementation already exists and serves as the reference). The
+skill is *not* written speculatively; it encodes a method that already worked.
+
+**Where:** `.claude/skills/ssr-form-migration/` (matches the existing project
+convention, e.g. `.claude/skills/testing-conventions/SKILL.md`).
+
+**Structure:**
+```
+.claude/skills/ssr-form-migration/
+  SKILL.md                # the playbook (§8): classify → migrate → verify → record
+  reference/
+    swap-doctrine.md      # §3.1 rules, focus invariant, OOB-vs-hoist, Alpine hardening,
+                          #   target-selector strategy (semantic/data-attr/form-path->id)
+    render-functions.md   # §3.2 explicit-data or top-rooted cursor; no faked positions
+    form-vs-wizard.md     # §3.3 classification + the data-driven engine
+    selmer-conventions.md # §3.4 attr style, interop bridge, include/block patterns
+    component-cookbook.md # GROWS: typeahead, account-row, totals, money-input, mode-toggle…
+    gotchas.md            # GROWS: stale $refs, key-by-value, wizard-id GC, coercion…
+    test-recipes.md       # GROWS: how to e2e a swap; assert a Selmer render; fixture a wizard-id
+    scorecard.md          # the §6 heuristics + a running table of every migration's numbers
+```
+
+**Growth contract — the last task of every migration:**
+- Converted a component? → add its before/after to `component-cookbook.md`.
+- Hit a surprise? → one entry in `gotchas.md`.
+- Found a test pattern? → `test-recipes.md`.
+- Playbook step missing/wrong? → fix `SKILL.md`.
+- Measured the scorecard? → append the row to `scorecard.md`.
+
+**Success signal:** each migration should reuse more cookbook entries and start
+from a better scorecard baseline than the previous one. If migration N+1 is not
+easier than N, the skill-update step is being skipped — treat that as a bug.
+
+---
+
+## 6. Quality scorecard (the ratchet)
+
+Cheap to measure (`grep -c`, `wc -l`, `clj-kondo`), recorded before/after each
+migration in the commit message and `scorecard.md`. **No metric may regress for
+the touched modal.**
+
+| # | Heuristic | Measure | Target |
+|---|-----------|---------|--------|
+| 1 | Faked cursor positions (not cursors themselves) | count cursor-root rebinds (`binding` of `*current*`/`*prefix*`/`*form-data*`, or `with-field`/`with-*` used to *re-root* deeper) + `grep -c '\-no-cursor'` | → 0 (top-rooted cursors are fine) |
+| 2 | Implicit state merges (snapshot/cursor) | count merge sites | → 0 (forms); explicit `update-step!` only (wizards) |
+| 3 | Branching complexity | `clj-kondo`, or count `cond`/`condp`/`case`/nested `if` + max depth | net ↓ |
+| 4 | Lines of code | `wc -l` on the modal's file(s) | net ↓ |
+| 5 | Reuse / cross-form similarity | cookbook components reused; duplicated-block count | reuse ↑, dup ↓ |
+| 6 | Route count | count routes for the modal | → 2 (+1 for add-row) |
+| 7 | OOB swaps | `grep -c hx-swap-oob` | → 0 unless a justified disjoint-region case is documented |
+| 8 | Attribute consistency | mixed `:x-`/`"x-"` encodings in migrated template | → 0 |
+
+These are directional evidence, not targets to game. Pair them with the e2e
+parity gate (§7) so "simpler" can never mean "broken."
+
+---
+
+## 7. Testing strategy
+
+Consistent with the project's `testing-conventions` skill (test user-observable
+behavior; assert DB state directly; don't test the means).
+
+1. **Characterization e2e first.** Before changing a modal, write/confirm a
+   Playwright spec capturing its current behavior — focus/caret survival across
+   swaps, the field round-trip, validation errors, and the actual save. This
+   spec is the parity contract the refactor must keep green.
+2. **Pure-function checks via REPL.** Once render fns are pure, exercise the
+   data-prep functions with `clojure-eval` / `clj-nrepl-eval`. Assert on returned
+   data; for markup use string matches (`(re-find #"accounts\[0\]\[account\]" (str html))`)
+   — this style survives the Selmer switch. Avoid brittle structural assertions.
+3. **DB-state assertions for mutations.** If a submit writes Datomic, verify by
+   querying the DB, not by asserting on markup.
+
+**Regression gate:** the full e2e suite must stay green after every migration.
+Record the current pass/fail baseline in `test-recipes.md` at the first
+migration and never drop below it.
+
+---
+
+## 8. Per-migration playbook (the repeatable loop)
+
+This is the canonical loop each modal phase follows; it lives in `SKILL.md`.
+Modal phases below list only what is *specific* to that modal plus this loop.
+
+1. [ ] **Read the skill.** Note applicable cookbook entries and gotchas.
+2. [ ] **Classify.** Single-step → plain form (no server state). Multi-step →
+   wizard (engine + server state). When in doubt, it's a form.
+3. [ ] **Baseline the scorecard (§6).** Record before-numbers.
+4. [ ] **Characterize behavior (test-first).** Write/confirm the e2e spec.
+5. [ ] **Consolidate render functions** so they take explicit data or a
+   top-rooted cursor — remove faked cursor positions and `*-no-cursor*`
+   duplicates (heuristics 1, 2). Using a cursor is fine; faking its start is not.
+6. [ ] **Templatize in Selmer**; reuse cookbook bits, add new ones back
+   (heuristics 5, 8).
+7. [ ] **Wire HTMX per the swap doctrine** (§3.1); focus invariant intact; OOB
+   only for disjoint regions (heuristic 7).
+8. [ ] **Collapse routes** to 2 (+1 for add-row) (heuristic 6).
+9. [ ] **Verify:** modal e2e + full suite green; assert DB mutations; REPL-check
+   pure fns. Re-measure scorecard — no regressions.
+10. [ ] **Commit** one reversible feature commit; message includes the scorecard
+    delta and reused/new cookbook entries.
+11. [ ] **Feed the skill** (cookbook / gotchas / test-recipes / scorecard /
+    SKILL.md). *Not optional.*
+
+---
+
+## 9. Phases & tasks
+
+> Migration target inventory (verify line counts at execution time):
+
+| Modal | File | Steps | Target | Phase |
+|-------|------|-------|--------|-------|
+| Transaction Edit | `transaction/edit.clj` | 1 (mode toggle) | form | 2 (skill trial) |
+| Transaction Bulk Code | `transaction/bulk_code.clj` | 1 | form | 3 |
+| Sales Summary Edit | `pos/sales_summaries.clj` | 1 | form | 4 |
+| Invoice Bulk Edit | `invoices.clj` | 1 | form | 5 |
+| Transaction Rule | `admin/transaction_rules.clj` | 2 | wizard | 6 |
+| Invoice Pay | `invoices.clj` | 2 | wizard | 7 |
+| New Invoice | `invoice/new_invoice_wizard.clj` | 3 | wizard | 8 |
+| Vendor | `admin/vendors.clj` | 5 | wizard | 9 |
+| Client | `admin/clients.clj` | 7 | wizard | 10 |
+
+---
+
+### Phase 1 — Distil the skill (no app code changes)
+
+**Rationale:** the transaction-edit modal has already been migrated to the
+whole-form swap approach successfully. Capture that working method as a skill
+*now*, so every later migration is cheaper and consistent. (If the reference
+implementation is not yet on the working branch, merge it first — that is an
+acceptable prerequisite.)
+
+- [ ] Create `.claude/skills/ssr-form-migration/SKILL.md` with the playbook (§8).
+- [ ] Write `reference/swap-doctrine.md` from §3.1 (the four rules, focus
+  invariant, OOB-vs-hoist, Alpine hardening), using the real transaction-edit
+  swaps as worked examples.
+- [ ] Write `reference/render-functions.md` from §3.2 (explicit data or a
+  top-rooted cursor; remove faked positions and `*-no-cursor*` duplicates).
+- [ ] Write `reference/form-vs-wizard.md` from §3.3 (classification + engine).
+- [ ] Stub `reference/selmer-conventions.md` from §3.4, marked "validated in
+  Phase 2."
+- [ ] Seed `component-cookbook.md` with whatever transaction-edit already proved
+  (e.g. the hardened typeahead, the totals-in-sibling-`<tbody>` pattern).
+- [ ] Seed `gotchas.md` (stale `$refs`, key-by-value).
+- [ ] Seed `test-recipes.md`; record the **current full e2e pass/fail baseline**.
+- [ ] Create `scorecard.md` with the §6 table and an empty results table.
+- [ ] **Exit criteria:** an agent can read `SKILL.md` and the references and
+  understand the whole method without this plan.
+
+---
+
+### Phase 2 — Trial the skill on Transaction Edit (first test subject)
+
+**Rationale:** validate the freshly written skill against the one modal whose
+"correct" outcome we already know. This is also where Selmer + pure functions
+are completed for this modal and the Selmer conventions get written from a real,
+verified example. Target type: **plain form** (single step with a mode toggle —
+the toggle is just a `GET` with a `?mode=` query param that re-renders the form).
+
+**Foundation (do once, here):**
+- [ ] Add the `selmer` dependency to `project.clj`.
+- [ ] Build the render helper (`selmer/render-file`) and the **interop bridge**
+  (Hiccup→string for embedding in Selmer, and Selmer fragment inside Hiccup).
+- [ ] Prove interop: a throwaway Selmer page renders inside the existing layout,
+  and a Hiccup component renders inside a Selmer template.
+
+**Modal migration (run the §8 loop), specifics:**
+- [ ] Confirm/author the characterization e2e spec covering: typing in memo keeps
+  focus; selecting an account updates only its Location options; changing vendor
+  / adding / removing a row / toggling mode / toggling $-vs-% re-renders the
+  whole form correctly; amount edits update totals without losing the amount
+  caret; save round-trips.
+- [ ] Extract pure render fns: `render-simple-fields`, `render-advanced-fields`,
+  `account-row`, `account-totals` (remove any `*-no-cursor*` duplicates).
+- [ ] Convert those render fns to Selmer templates; record each as a cookbook
+  entry; finalize `selmer-conventions.md`.
+- [ ] Verify the swaps match the doctrine (whole-form for structural changes,
+  targeted cell for account→location, sibling-`<tbody>` for totals, no request
+  for memo); confirm `grep -c hx-swap-oob` is 0.
+- [ ] Collapse routes: `GET /transaction/edit` (with `?mode=`), `POST
+  /transaction/edit`, plus the single `edit-form-changed` re-render endpoint.
+- [ ] Verify (modal e2e + full suite green; DB save asserted).
+- [ ] **Feed the skill:** refine `SKILL.md` and references from anything the
+  trial revealed; append the scorecard row (this is the baseline others beat).
+- [ ] **Exit criteria:** skill-driven migration reproduces the known-good
+  behavior; Selmer conventions are validated; cookbook has ≥3 reusable entries.
+
+---
+
+### Phase 3 — Transaction Bulk Code (plain form)
+
+**Rationale:** the smallest *fresh* modal — first real test of "read the skill,
+apply it cold." Single-step form currently wearing a wizard costume.
+
+- [ ] Run the §8 loop.
+- [ ] Classify as plain form; delete the wizard protocol/record and snapshot.
+- [ ] Extract `render-bulk-code-fields`; reuse cookbook typeahead/money-input.
+- [ ] Search params preserved as plain hidden fields (no EDN snapshot).
+- [ ] Collapse 4 wizard routes → 2 (`GET` open, `POST` submit).
+- [ ] Verify bulk-code applies correctly (assert DB) + full suite green.
+- [ ] Feed the skill; append scorecard row.
+- [ ] **Exit criteria:** ≥2 cookbook entries reused; LOC, route-count, and
+  faked-cursor count all down vs. baseline.
+
+---
+
+### Phase 4 — Sales Summary Edit (plain form)
+
+**Rationale:** another single-step form; reinforces the cold-apply loop.
+
+- [ ] Run the §8 loop.
+- [ ] Classify as plain form; remove wizard record + `wrap-init-multi-form-state`.
+- [ ] Extract `render-sales-summary-fields` (pure); reuse cookbook entries.
+- [ ] Collapse 3 wizard routes → 2.
+- [ ] Verify edit saves (assert DB) + full suite green.
+- [ ] Feed the skill; append scorecard row.
+
+---
+
+### Phase 5 — Invoice Bulk Edit (plain form with rows + totals)
+
+**Rationale:** first single-step form with dynamic account rows and live totals
+— exercises the add-row endpoint and the totals-in-sibling-`<tbody>` swap
+(instead of OOB).
+
+- [ ] Run the §8 loop.
+- [ ] Extract `bulk-edit-account-row` (pure); reuse the `account-row`/`totals`
+  cookbook entries from Phase 2.
+- [ ] Add-row: a `POST` that appends a fresh row; totals re-render via the
+  sibling-`<tbody>` swap, **not** OOB.
+- [ ] **Settle a target-selector convention** for repeated/nested rows (§3.1
+  "Selector strategy"): semantic data-attributes and/or a `form-path -> selector`
+  helper, rather than hand-minted ids per element. Record the chosen convention
+  in `reference/swap-doctrine.md` + `component-cookbook.md` so later wizards reuse it.
+- [ ] Collapse 4 wizard routes → 3 (open, submit, add-row).
+- [ ] Verify add/remove rows + totals + apply (assert DB) + full suite green.
+- [ ] Feed the skill; append scorecard row.
+- [ ] **Exit criteria:** `grep -c hx-swap-oob` is 0; row/totals patterns are
+  confirmed reusable across two modals now.
+
+---
+
+### Phase 6 — Build the wizard engine + migrate Transaction Rule (2-step wizard)
+
+**Rationale:** the first genuinely multi-step modal, and the simplest one — the
+right place to introduce the data-driven engine (§3.3) and **session-stored
+per-step state** (the Django `formtools` model), replacing the EDN snapshot +
+merge.
+
+**Engine (do once, here):**
+- [ ] Create `components/wizard_state.clj` backed by the **Ring session**:
+  `create-wizard!`, `put-step` (replace step data, do **not** merge into a
+  snapshot), `set-step`, `get-all` (combine only at the end), `forget`. State is
+  namespaced by `wizard-id` inside the session (`[:wizards <id> ...]`) so tabs
+  and concurrent wizards don't collide. Each fn returns the updated session for
+  the handler to thread into the Ring response. Test the lifecycle via REPL.
+- [ ] Create `components/wizard2.clj` (`render-wizard`, `handle-step-submit`,
+  `open-wizard`) — engine threads session through and only `wizard-id` rides in
+  the form. Test render + step navigation + that no snapshot is emitted.
+- [ ] Document the engine usage and the formtools inspiration in
+  `reference/form-vs-wizard.md`.
+
+**Modal migration (run the §8 loop), specifics:**
+- [ ] Extract `render-edit-step` and `render-test-step` (the test step shows a
+  results table); keep `validate-transaction-rule` as the step `:schema`/custom check.
+- [ ] Define `transaction-rule-wizard-config` with both steps + `:done-fn`.
+- [ ] Collapse routes → 2 (open, submit).
+- [ ] Verify create / edit / run-test (assert DB) + full suite green.
+- [ ] Feed the skill; append scorecard row.
+- [ ] **Exit criteria:** engine proven on a real 2-step flow; state TTL works.
+
+---
+
+### Phase 7 — Invoice Pay (2-step wizard)
+
+**Rationale:** 2 steps with conditional rendering by payment method (e.g.,
+handwrite-check fields) — exercises the engine's `:next`/conditional branching.
+
+- [ ] Run the §8 loop.
+- [ ] Extract `render-choose-method-step` and `render-payment-details-step`.
+- [ ] Build `pay-wizard-config`; move setup logic into `:init-fn` (e.g. the
+  `invoice-by-id` lookup); branch `:next` on payment method.
+- [ ] Collapse routes → 2.
+- [ ] Verify each payment method path (assert DB) + full suite green.
+- [ ] Feed the skill; append scorecard row.
+
+---
+
+### Phase 8 — New Invoice (3-step wizard)
+
+**Rationale:** a true 3-step wizard with a conditional accounts step — the
+reference multi-step shape.
+
+- [ ] Run the §8 loop.
+- [ ] Extract `render-basic-details-step`, `render-accounts-step`,
+  `render-submit-step`; reuse the expense-account row cookbook entry.
+- [ ] Define step schemas separately; `:next` from basic-details skips accounts
+  when not customizing.
+- [ ] `:init-fn` sets defaults (e.g. date = now).
+- [ ] Add-row for expense accounts via the sibling-`<tbody>` totals pattern.
+- [ ] Collapse routes → 2 (+1 add-row).
+- [ ] Verify create with/without custom accounts (assert DB) + full suite green.
+- [ ] Feed the skill; append scorecard row.
+
+---
+
+### Phase 9 — Vendor (5-step wizard)
+
+**Rationale:** larger multi-step; by now the engine and cookbook are mature.
+
+- [ ] Run the §8 loop.
+- [ ] Extract the 5 step render fns: `render-info-step`, `render-terms-step`,
+  `render-account-step`, `render-address-step`, `render-legal-step`.
+- [ ] Build `vendor-wizard-config`; handle `:new` vs `:edit` via `:init-fn`
+  (empty vs. loaded entity).
+- [ ] Replace the conditional `hx-post`/`hx-put` logic with the engine's submit.
+- [ ] Collapse routes → 2.
+- [ ] Verify create + edit across all steps (assert DB) + full suite green.
+- [ ] Feed the skill; append scorecard row.
+
+---
+
+### Phase 10 — Client (7-step wizard) — largest, last
+
+**Rationale:** the biggest, most complex modal (nested bank accounts, location
+matches, emails, contact methods). Deliberately last, when the skill is richest.
+
+- [ ] Run the §8 loop; split extraction into sub-tasks per step.
+- [ ] Extract the 7 step render fns (`:info`, `:matches`, `:contact`,
+  `:bank-accounts`, `:integrations`, `:cash-flow`, `:other-settings`).
+- [ ] Convert each `add-new-entity-handler` (bank accounts, location matches,
+  emails, contact methods) to an add-row `POST` using the cookbook row pattern;
+  drop `fc/with-field-default` nesting.
+- [ ] Build `client-wizard-config`; `:new` vs `:edit` via `:init-fn`.
+- [ ] Collapse routes → 2 (+ add-row endpoints as needed).
+- [ ] Verify create + edit across all 7 steps thoroughly (assert DB) + full
+  suite green.
+- [ ] Feed the skill; append scorecard row.
+
+---
+
+### Phase 11 — Cleanup
+
+**Rationale:** remove the now-dead old machinery.
+
+- [ ] Delete the legacy wizard module (protocols + middleware) once no caller
+  remains; remove any v1→v2 shim.
+- [ ] Remove the Alpine morph dependency/extension if unreferenced.
+- [ ] Decide (Open decision 3) whether to extend Selmer to the remaining static
+  Hiccup, now that the skill makes it cheap.
+- [ ] Promote recurring cookbook entries into shared Selmer partials/components.
+- [ ] Final scorecard review: confirm the suite-wide LOC/route/complexity drop.
+
+---
+
+## 10. Risks & mitigations
+
+| Risk | Mitigation |
+|------|------------|
+| In-flight wizard state lost (restart / session expiry) | State lives in the session (formtools model), scoped to true multi-step wizards; plain forms hold none. Lifetime follows the session; for long-lived wizards choose a durable session backend or store (Open decision 1). `forget` on completion prevents session bloat. |
+| Mixed Hiccup/Selmer interop gets messy | Build + prove the interop bridge in Phase 2 before broad use; strangler keeps both valid. |
+| Selmer loses Hiccup's structural testability | Lean on e2e + DB assertions; unit-test the data-prep functions, not markup. |
+| Large files hide behavior (`clients.clj`, `edit.clj`) | They go last, after the skill is rich; characterization e2e first; split per step. |
+| Alpine components break across swaps | Codify hardening (null-guarded `tippy?`/`$refs`, key-by-value) as a cookbook entry applied everywhere. |
+| Heuristics get gamed (LOC golfing, fake route counts) | Directional evidence only; always paired with the e2e parity gate; review the trend, not single numbers. |
+| Skill-update step skipped under pressure | Required commit-message line (scorecard delta + reused/new entries); if N+1 isn't easier, flag it. |
+| Quality regresses silently | Ratchet rule: no metric may regress for a touched modal without a written exception in `gotchas.md`. |
+
+---
+
+## 11. Open decisions
+
+1. **Wizard state storage** — store multi-step state in the **Ring session**
+   (Django `formtools` `SessionStorage` model), keyed by `wizard-id`, none for
+   plain forms? Confirm the session backend in use (in-memory vs. durable) is
+   acceptable for in-flight wizard lifetime, or pick a durable store for
+   long-lived flows. *(recommended: session storage, scoped to multi-step
+   wizards only)*
+2. **Selmer scope** — convert only interactive/attribute-heavy components first
+   (hybrid), or all SSR files (full sweep)? *(recommended: hybrid, revisit in
+   Phase 11)*
+3. **Whole-form vs. targeted granularity defaults** — confirm the §3.1 priority
+   order (no-request → targeted cell → whole-form → OOB-only-if-disjoint) as the
+   project default. *(recommended: yes)*
+4. **First step** — start by distilling the skill (Phase 1) with the reference
+   implementation merged as a prerequisite, rather than treating the merge
+   itself as step one. *(recommended: yes)*

e2e/transaction-edit-swap.spec.ts

@@ -0,0 +1,389 @@
+import { test, expect } from '@playwright/test';
+
+// These tests cover the "post the whole form, hx-select what to swap" behaviour
+// on the transaction edit page. Each edit hits its own route, the server
+// re-renders the entire form, and the client selects what to swap back -- with
+// no out-of-band swaps and no morph extension:
+//   - discrete changes (vendor, account, location, mode, add/remove row) swap
+//     all of #wizard-form (the active action/tab round-trips through the form,
+//     so it survives the swap);
+//   - typed fields never swap the input the user is in -- the amount field swaps
+//     only the #account-totals tbody (a sibling of the input rows), and the memo
+//     posts with hx-swap=none.
+// Because the active input is never part of a swapped region, focus and caret
+// survive a plain swap.
+
+// Collect any uncaught page errors or console errors so a swap that throws
+// (e.g. a tooltip callback dereferencing a stale $refs) fails the test loudly.
+function trackErrors(page: any): string[] {
+  const errors: string[] = [];
+  page.on('pageerror', (e: any) => errors.push('pageerror: ' + e.message));
+  page.on('console', (m: any) => {
+    if (m.type() === 'error') errors.push('console: ' + m.text());
+  });
+  return errors;
+}
+
+async function openManualAdvanced(page: any, transactionIndex = 0) {
+  await page.goto('/transaction2');
+  await page.waitForSelector('table tbody tr');
+  await page
+    .locator('button[hx-get*="/transaction2/"][hx-get*="/edit"]')
+    .nth(transactionIndex)
+    .click();
+  await page.waitForSelector('#modal-holder[x-show="open"]', { state: 'visible' });
+  await page.waitForSelector('#wizardmodal');
+  await page.click('button:has-text("Manual")');
+
+  // First transaction has no accounts so it opens in "simple" mode. Switch to
+  // advanced mode (a whole-form swap) so the account grid is present.
+  const advancedLink = page.locator('a:has-text("Switch to advanced mode")');
+  if (await advancedLink.count()) {
+    await advancedLink.first().click();
+    await page.waitForSelector('#account-grid-body');
+  }
+}
+
+// Drives the vendor typeahead like a user: open the dropdown, inject a result
+// (Solr is unavailable in tests), click it, and wait for the whole-form swap.
+async function selectVendor(page: any, vendorId: number, label: string) {
+  const vendor = page
+    .locator('div[hx-post*="edit-vendor-changed"]')
+    .first()
+    .locator('div.relative[x-data]')
+    .first();
+  await vendor.locator('a[x-ref="input"]').click();
+  const search = page.locator('[data-tippy-root] input[x-model="search"]').first();
+  await search.waitFor({ state: 'visible' });
+  await search.fill('xx');
+  await vendor.evaluate((el: HTMLElement, opt: { id: number; label: string }) => {
+    (window as any).Alpine.$data(el).elements = [{ value: opt.id, label: opt.label }];
+  }, { id: vendorId, label });
+
+  const swap = page.waitForResponse(
+    (r: any) =>
+      r.url().includes('edit-vendor-changed') &&
+      r.request().method() === 'POST' &&
+      r.status() === 200
+  );
+  await page.locator('[data-tippy-root] a', { hasText: label }).first().click();
+  await swap;
+  await page.waitForTimeout(400);
+}
+
+// Removes every existing account row (each remove is its own whole-form swap), so a
+// test starts from a known-empty state regardless of what earlier tests saved
+// onto the shared transaction.
+async function clearAccounts(page: any) {
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    const removeButtons = page.locator('#account-grid-body .account-remove-action');
+    const count = await removeButtons.count();
+    if (count === 0) break;
+    await removeButtons.first().click();
+    await expect
+      .poll(async () => page.locator('#account-grid-body .account-remove-action').count())
+      .toBeLessThan(count);
+  }
+}
+
+test.describe.configure({ mode: 'serial' });
+
+test.describe('Transaction Edit whole-form swap', () => {
+  test('whole-form swaps (toggle mode, add account) do not throw', async ({ page }) => {
+    const errors = trackErrors(page);
+
+    await openManualAdvanced(page, 0);
+
+    // Add an account row -- another whole-form swap.
+    await page
+      .locator('#account-grid-body')
+      .locator('button:has-text("New account"), a:has-text("New account")')
+      .first()
+      .click();
+
+    await expect
+      .poll(async () => page.locator('#account-grid-body tbody tr.account-row').count())
+      .toBeGreaterThan(0);
+
+    // The form must survive the swap intact.
+    await expect(page.locator('#wizard-form')).toHaveCount(1);
+    expect(errors, errors.join('\n')).toEqual([]);
+  });
+
+  test('keeps focus and typed value in the amount field across a swap', async ({ page }) => {
+    const errors = trackErrors(page);
+
+    await openManualAdvanced(page, 0);
+
+    // Ensure exactly one account row exists.
+    const rows = await page.locator('#account-grid-body tbody tr.account-row').count();
+    if (rows === 0) {
+      await page
+        .locator('#account-grid-body')
+        .locator('button:has-text("New account"), a:has-text("New account")')
+        .first()
+        .click();
+      await expect
+        .poll(async () => page.locator('#account-grid-body tbody tr.account-row').count())
+        .toBeGreaterThan(0);
+    }
+
+    const amount = page.locator('.account-amount-field').first();
+    await amount.waitFor();
+
+    // Type a clean value via the keyboard. Typing fires the field's htmx trigger
+    // (keyup), which posts the whole form but swaps back only the #account-totals
+    // tbody -- a sibling of this input's row, so the input is never replaced. It's
+    // type=number (no text caret), so we assert focus + node identity + value.
+    await amount.click();
+    await amount.press('Control+a');
+
+    const amountSwap = page.waitForResponse(
+      (r: any) =>
+        r.url().includes('edit-form-changed') &&
+        r.request().method() === 'POST' &&
+        r.status() === 200
+    );
+    await amount.pressSequentially('150', { delay: 40 });
+
+    // Identify the live focused node (before the debounced swap lands) so we can
+    // prove the *same* node survives.
+    await page.evaluate(() => {
+      (window as any).__focusedAmount = document.activeElement;
+    });
+
+    await amountSwap;
+    await page.waitForTimeout(300);
+
+    const state = await page.evaluate(() => {
+      const active = document.activeElement as HTMLInputElement;
+      return {
+        sameNode: active === (window as any).__focusedAmount,
+        isAmountField: !!active && active.classList.contains('account-amount-field'),
+        value: active ? active.value : null,
+      };
+    });
+
+    // Focus must stay on the amount field after the swap...
+    expect(state.isAmountField).toBe(true);
+    // ...on the very same DOM node (the input is never part of the swapped region)...
+    expect(state.sameNode).toBe(true);
+    // ...with the value the user typed left intact.
+    expect(state.value).toBe('150');
+
+    // The TOTAL must have recomputed server-side from the posted amount and been
+    // applied via the #account-totals swap.
+    await expect(page.locator('.account-total-row #total')).toContainText('150');
+
+    expect(errors, errors.join('\n')).toEqual([]);
+  });
+
+  test('memo edits issue no request and keep their value/caret', async ({ page }) => {
+    const errors = trackErrors(page);
+
+    // Memo affects nothing else in the form, so editing it must NOT issue a
+    // request at all -- its value just rides along in the form until save.
+    let memoRequests = 0;
+    page.on('request', (r: any) => {
+      if (r.url().includes('edit-form-changed') && r.method() === 'POST') memoRequests++;
+    });
+
+    await page.goto('/transaction2');
+    await page.waitForSelector('table tbody tr');
+    await page.locator('button[hx-get*="/transaction2/"][hx-get*="/edit"]').nth(0).click();
+    await page.waitForSelector('#wizardmodal');
+
+    const memo = page.locator('#edit-memo');
+    await memo.waitFor();
+
+    // Clear any seeded memo text and type "hello".
+    await memo.click();
+    await memo.press('Control+a');
+    await memo.pressSequentially('hello', { delay: 40 });
+
+    // Drop the caret in the middle and insert a char -> "heXllo", caret -> 3.
+    await memo.evaluate((el: HTMLInputElement) => {
+      el.focus();
+      el.setSelectionRange(2, 2);
+    });
+    await page.evaluate(() => {
+      (window as any).__focusedMemo = document.activeElement;
+    });
+    await memo.press('X');
+
+    // Give the old debounce window a chance to (not) fire.
+    await page.waitForTimeout(500);
+
+    const state = await page.evaluate(() => {
+      const active = document.activeElement as HTMLInputElement;
+      return {
+        sameNode: active === (window as any).__focusedMemo,
+        id: active ? active.id : null,
+        value: active ? active.value : null,
+        caret: active ? active.selectionStart : null,
+      };
+    });
+
+    // No request fired, and the value/caret are simply intact (nothing swapped).
+    expect(memoRequests).toBe(0);
+    expect(state.id).toBe('edit-memo');
+    expect(state.sameNode).toBe(true);
+    expect(state.value).toBe('heXllo');
+    expect(state.caret).toBe(3);
+
+    expect(errors, errors.join('\n')).toEqual([]);
+  });
+
+  test('choosing an account from the typeahead does not throw and persists', async ({ page }) => {
+    const errors = trackErrors(page);
+
+    await openManualAdvanced(page, 0);
+
+    // Start from a clean, empty account row so selecting the account actually
+    // changes accountId (and fires the change-gated whole-form swap).
+    await clearAccounts(page);
+    await page
+      .locator('#account-grid-body')
+      .locator('button:has-text("New account"), a:has-text("New account")')
+      .first()
+      .click();
+    await expect
+      .poll(async () => page.locator('#account-grid-body tbody tr.account-row').count())
+      .toBeGreaterThan(0);
+
+    const row = page.locator('#account-grid-body tbody tr.account-row').first();
+    const typeahead = row.locator('div.relative[x-data]').first();
+
+    // Open the dropdown (tippy renders the popper into [data-tippy-root]).
+    await typeahead.locator('a[x-ref="input"]').click();
+    const search = page.locator('[data-tippy-root] input[x-model="search"]').first();
+    await search.waitFor({ state: 'visible' });
+
+    // Account search is backed by Solr (unavailable in tests), so type under the
+    // 3-char threshold and inject a clickable result into the typeahead state --
+    // the click handler, tippy.hide(), Alpine reactivity and the HTMX swap all run
+    // exactly as in production.
+    await search.fill('te');
+    const testInfo = await (await page.request.get('/test-info')).json();
+    const accountId: number = testInfo.accounts['test-account'];
+    await typeahead.evaluate((el: HTMLElement, id: number) => {
+      (window as any).Alpine.$data(el).elements = [{ value: id, label: 'Test Account' }];
+    }, accountId);
+
+    // Clicking the result runs `value = element; tippy.hide(); ...` and dispatches
+    // the change that fires the whole-form swap.
+    const swap = page.waitForResponse(
+      (r: any) =>
+        r.url().includes('edit-form-changed') &&
+        r.request().method() === 'POST' &&
+        r.status() === 200
+    );
+    await page.locator('[data-tippy-root] a', { hasText: 'Test Account' }).first().click();
+    await swap;
+    await page.waitForTimeout(300);
+
+    // The chosen account must survive the whole-form swap.
+    const hidden = page
+      .locator('#account-grid-body tbody tr.account-row')
+      .first()
+      .locator('input[type="hidden"][name*="transaction-account/account"]')
+      .first();
+    await expect(hidden).toHaveValue(accountId.toString());
+
+    expect(errors, errors.join('\n')).toEqual([]);
+  });
+
+  test('selecting a vendor populates its default account across the swap', async ({ page }) => {
+    const errors = trackErrors(page);
+
+    // Open the modal in simple mode (transaction 0 has no accounts).
+    await page.goto('/transaction2');
+    await page.waitForSelector('table tbody tr');
+    await page.locator('button[hx-get*="/transaction2/"][hx-get*="/edit"]').nth(0).click();
+    await page.waitForSelector('#wizardmodal');
+    await page.click('button:has-text("Manual")');
+    await page.waitForSelector('div[hx-post*="edit-vendor-changed"]');
+
+    const testInfo = await (await page.request.get('/test-info')).json();
+    const vendorId: number = testInfo.accounts.vendor;
+    const defaultAccountId: number = testInfo.accounts['test-account'];
+
+    // Drive the vendor typeahead like a user: open dropdown, inject a result
+    // (Solr is unavailable in tests), click it.
+    const vendor = page.locator('div[hx-post*="edit-vendor-changed"]').first().locator('div.relative[x-data]').first();
+    await vendor.locator('a[x-ref="input"]').click();
+    const search = page.locator('[data-tippy-root] input[x-model="search"]').first();
+    await search.waitFor({ state: 'visible' });
+    await search.fill('te');
+    await vendor.evaluate((el: HTMLElement, id: number) => {
+      (window as any).Alpine.$data(el).elements = [{ value: id, label: 'Test Vendor' }];
+    }, vendorId);
+
+    const swap = page.waitForResponse(
+      (r: any) =>
+        r.url().includes('edit-vendor-changed') &&
+        r.request().method() === 'POST' &&
+        r.status() === 200
+    );
+    await page.locator('[data-tippy-root] a', { hasText: 'Test Vendor' }).first().click();
+    await swap;
+    await page.waitForTimeout(400);
+
+    // The vendor's default account must now be reflected in the account field.
+    // Because the section is rebuilt fresh from the server (no preserved Alpine
+    // state), the server-driven account value lands without any keying tricks.
+    const accountHidden = page
+      .locator('input[type="hidden"][name*="transaction-account/account"]')
+      .first();
+    await expect(accountHidden).toHaveValue(defaultAccountId.toString());
+
+    // The displayed account label should resolve too.
+    await expect(page.locator('span[x-text="value.label"]', { hasText: 'Test Account' })).toBeVisible();
+
+    expect(errors, errors.join('\n')).toEqual([]);
+  });
+
+  test('changing the vendor a second time still updates it', async ({ page }) => {
+    const errors = trackErrors(page);
+
+    await page.goto('/transaction2');
+    await page.waitForSelector('table tbody tr');
+    await page.locator('button[hx-get*="/transaction2/"][hx-get*="/edit"]').nth(0).click();
+    await page.waitForSelector('#wizardmodal');
+    await page.click('button:has-text("Manual")');
+    await page.waitForSelector('div[hx-post*="edit-vendor-changed"]');
+
+    const testInfo = await (await page.request.get('/test-info')).json();
+    const vendor1: number = testInfo.accounts.vendor;
+    const vendor2: number = testInfo.accounts.vendor2;
+    const account1: number = testInfo.accounts['test-account'];
+    const account2: number = testInfo.accounts['second-account'];
+
+    const vendorLabel = page
+      .locator('div[hx-post*="edit-vendor-changed"] span[x-text="value.label"]')
+      .first();
+    const accountHidden = page
+      .locator('input[type="hidden"][name*="transaction-account/account"]')
+      .first();
+
+    // First vendor.
+    await selectVendor(page, vendor1, 'Test Vendor');
+    await expect(vendorLabel).toHaveText('Test Vendor');
+    await expect(accountHidden).toHaveValue(account1.toString());
+
+    // Second vendor -- the regression guard: the section (and its vendor
+    // typeahead) is rebuilt fresh on every swap, so a second change still fires
+    // its request and updates the default account.
+    await selectVendor(page, vendor2, 'Second Vendor');
+    await expect(vendorLabel).toHaveText('Second Vendor');
+    await expect(accountHidden).toHaveValue(account2.toString());
+
+    // And back again, to be sure it keeps working.
+    await selectVendor(page, vendor1, 'Test Vendor');
+    await expect(vendorLabel).toHaveText('Test Vendor');
+    await expect(accountHidden).toHaveValue(account1.toString());
+
+    expect(errors, errors.join('\n')).toEqual([]);
+  });
+});

e2e/transaction-edit.spec.ts

@@ -18,7 +18,15 @@ async function openEditModal(page: any, transactionIndex: number = 0) {
   // The modal is now single-page (Edit Transaction). Click "Manual" tab to ensure
   // the manual account coding form is active.
   await page.click('button:has-text("Manual")');
-  
+
+  // Transactions with 0-1 accounts open in "simple" mode, which has no account
+  // grid. Switch to "advanced" mode (a whole-form morph swap) so the grid the
+  // rest of these helpers manipulate is present.
+  const advancedLink = page.locator('a:has-text("Switch to advanced mode")');
+  if (await advancedLink.count()) {
+    await advancedLink.first().click();
+  }
+
   // Wait for the manual form to appear
   await page.waitForSelector('#account-grid-body');
 }
@@ -33,68 +41,33 @@ async function getTestInfo(page: any) {
 }
 
 async function selectAccountFromTypeahead(page: any, rowIndex: number, accountName: string) {
-  // The account search uses Solr which isn't available in tests.
-  // Instead, we directly set the hidden input value via JavaScript.
-  
-  // Get all rows except the new-row, total, balance, and transaction total rows
-  const allRows = page.locator('#account-grid-body tbody tr');
-  const rowCount = await allRows.count();
-  
-  // Find the row that has a hidden input for account (actual account rows)
-  let accountRow = null;
-  let accountRowIndex = 0;
-  for (let i = 0; i < rowCount; i++) {
-    const row = allRows.nth(i);
-    const hasAccountInput = await row.locator('input[name*="transaction-account/account"]').count() > 0;
-    if (hasAccountInput) {
-      if (accountRowIndex === rowIndex) {
-        accountRow = row;
-        break;
-      }
-      accountRowIndex++;
-    }
-  }
-  
-  if (!accountRow) {
-    throw new Error(`Could not find account row at index ${rowIndex}`);
-  }
-  
-  // Find the hidden input for the account
-  const hiddenInput = accountRow.locator('input[type="hidden"][name*="transaction-account/account"]').first();
-  
-  // Get account IDs from test-info endpoint
-  const testInfo = await getTestInfo(page);
+  // Account search is backed by Solr (unavailable in tests). Drive the typeahead the
+  // way a user does, using the Alpine v3 API: open the tippy dropdown, inject a result
+  // into the component's `elements`, then click it. This runs the real click handler,
+  // Alpine reactivity and the HTMX swap exactly as in production -- unlike poking the
+  // long-removed Alpine v2 `__x` internal, which silently no-ops on Alpine v3 and left
+  // the posted account empty.
   const accountKey = accountName === 'Test' ? 'test-account' : 'second-account';
+  const label = `${accountName} Account`;
+  const testInfo = await getTestInfo(page);
   const accountId = testInfo.accounts[accountKey];
-  
   if (!accountId) {
     throw new Error(`Could not find account with name ${accountName}`);
   }
-  
-  // Set the hidden input value and trigger change
-  // Also update Alpine.js data to prevent it from overwriting our value
-  await hiddenInput.evaluate((el: HTMLInputElement, value: string) => {
-    // Set the DOM value
-    el.value = value;
-    
-    // Update Alpine.js component data
-    const alpineEl = el.closest('[x-data]');
-    if (alpineEl && (alpineEl as any).__x) {
-      (alpineEl as any).__x.$data.value.value = parseInt(value);
-      (alpineEl as any).__x.$data.value.label = 'Selected Account';
-    }
-    
-    // Also update any parent Alpine model (accountId)
-    const rowEl = el.closest('tr[x-data]');
-    if (rowEl && (rowEl as any).__x) {
-      (rowEl as any).__x.$data.accountId = parseInt(value);
-    }
-    
-    el.dispatchEvent(new Event('change', { bubbles: true }));
-  }, accountId.toString());
-  
-  // Wait for any HTMX updates
-  await page.waitForTimeout(300);
+
+  const row = page.locator('#account-grid-body tbody tr.account-row').nth(rowIndex);
+  const typeahead = row.locator('div.relative[x-data]').first();
+  await typeahead.locator('a[x-ref="input"]').click();
+  const search = page.locator('[data-tippy-root] input[x-model="search"]').first();
+  await search.waitFor({ state: 'visible' });
+  await search.fill('te');
+  await typeahead.evaluate((el: any, opt: { id: number; label: string }) => {
+    (window as any).Alpine.$data(el).elements = [{ value: opt.id, label: opt.label }];
+  }, { id: accountId, label });
+  await page.locator('[data-tippy-root] a', { hasText: label }).first().click();
+
+  // Wait for the change-gated whole-form swap to settle.
+  await page.waitForTimeout(400);
 }
 
 async function findAccountRow(page: any, rowIndex: number) {
@@ -455,6 +428,93 @@ test.describe('Transaction Edit Vendor Pre-population', () => {
   });
 });
 
+// Drives the *real* vendor typeahead the way a user does: open the dropdown,
+// click a rendered result. The vendor search is backed by Solr (unavailable in
+// tests), so the result option is injected into the typeahead's Alpine
+// `elements` instead of being fetched. Everything else -- the dropdown's own
+// search input firing a native `change` on blur, the `value = element` click
+// handler, the Alpine reactivity, and the HTMX round-trip to
+// `edit-vendor-changed` -- runs exactly as in production. This is the flow that
+// regressed: a stale native `change` from the search input used to win the race
+// and revert the vendor to its previous value.
+async function selectVendorViaDropdown(page: any, vendorId: number, vendorName: string) {
+  const wrapper = page.locator('div[hx-post*="edit-vendor-changed"]').first();
+  const typeahead = wrapper.locator('div.relative[x-data]').first();
+
+  // Open the dropdown (tippy renders the popper into [data-tippy-root]).
+  await typeahead.locator('a[x-ref="input"]').click();
+
+  const search = page.locator('[data-tippy-root] input[x-model="search"]').first();
+  await search.waitFor({ state: 'visible' });
+
+  // Type under the 3-char search threshold so no Solr request fires and clears
+  // our injected option, while still dirtying the input so it fires a native
+  // `change` on blur -- the event that used to clobber the selection.
+  await search.fill('te');
+
+  // Inject a clickable result into the typeahead's Alpine state.
+  await typeahead.evaluate(
+    (el: HTMLElement, opt: { id: number; label: string }) => {
+      (window as any).Alpine.$data(el).elements = [{ value: opt.id, label: opt.label }];
+    },
+    { id: vendorId, label: vendorName }
+  );
+
+  // Click the rendered option: fires the search input's native change (stale
+  // value) AND the synthetic change carrying the new value, then HTMX swaps.
+  await page.locator('[data-tippy-root] a', { hasText: vendorName }).first().click();
+
+  await page.waitForResponse(
+    (response: any) =>
+      response.url().includes('/edit-vendor-changed') && response.status() === 200
+  );
+  await page.waitForTimeout(500);
+}
+
+// Opens the edit modal and activates the Manual tab, waiting on the vendor
+// typeahead rather than the account grid (which only exists in advanced mode).
+async function openManualVendorSection(page: any, transactionIndex: number) {
+  await page.goto('/transaction2');
+  await page.waitForSelector('table tbody tr');
+
+  const editButton = page
+    .locator('button[hx-get*="/transaction2/"][hx-get*="/edit"]')
+    .nth(transactionIndex);
+  await editButton.click();
+
+  await page.waitForSelector('#modal-holder[x-show="open"]', { state: 'visible' });
+  await page.waitForSelector('#wizardmodal');
+  await page.click('button:has-text("Manual")');
+  await page.waitForSelector('div[hx-post*="edit-vendor-changed"]');
+}
+
+test.describe('Transaction Edit Vendor Selection', () => {
+  test('selecting a vendor from the dropdown updates the displayed vendor', async ({ page }) => {
+    await openManualVendorSection(page, 3);
+
+    const testInfo = await getTestInfo(page);
+    const vendorId: number = testInfo.accounts.vendor;
+
+    await selectVendorViaDropdown(page, vendorId, 'Test Vendor');
+
+    // The displayed vendor label must reflect the selection after the HTMX
+    // round-trip. Before the fix this reverted to blank because a stale
+    // `change` event submitted the previous vendor and its response won.
+    const label = page
+      .locator('div[hx-post*="edit-vendor-changed"] span[x-text="value.label"]')
+      .first();
+    await expect(label).toHaveText('Test Vendor');
+
+    // The server-rendered hidden input must carry the newly selected vendor id.
+    const hidden = page
+      .locator(
+        'div[hx-post*="edit-vendor-changed"] input[type="hidden"][name="step-params[transaction/vendor]"]'
+      )
+      .first();
+    await expect(hidden).toHaveValue(vendorId.toString());
+  });
+});
+
 test.describe('Transaction Link Date Display', () => {
   test('should show payment date when linking to payment', async ({ page }) => {
     await openEditModalForTransaction(page, 'Transaction for payment link');

e2e/transaction-import.spec.ts

@@ -0,0 +1,125 @@
+import { test, expect } from '@playwright/test';
+
+// The SSR manual transaction import accepts the exact Yodlee positional-column
+// TSV format from the master branch. Column order (14 columns), per
+// auto-ap.import.manual/columns:
+//   0:status 1:raw-date 2:description-original 3:high-level-category
+//   4,5:(unused) 6:amount 7..11:(unused) 12:bank-account-code 13:client-code
+//
+// The test server (auto-ap.test-server) seeds client "TEST" with a bank
+// account whose code is the deterministic "TEST-CHK" (see seed-test-data).
+
+const IMPORT_PATH = '/transaction2/external-import-new';
+
+function yodleeRow(opts: {
+  status?: string;
+  date?: string;
+  description?: string;
+  category?: string;
+  amount?: string;
+  bankAccountCode?: string;
+  clientCode?: string;
+}): string {
+  const cols = new Array(14).fill('');
+  cols[0] = opts.status ?? 'POSTED';
+  cols[1] = opts.date ?? '';
+  cols[2] = opts.description ?? '';
+  cols[3] = opts.category ?? '';
+  cols[6] = opts.amount ?? '';
+  cols[12] = opts.bankAccountCode ?? '';
+  cols[13] = opts.clientCode ?? '';
+  return cols.join('\t');
+}
+
+function yodleeTsv(rows: string[]): string {
+  // First line is a header that the importer drops.
+  const header = new Array(14).fill('');
+  header[0] = 'Status';
+  header[1] = 'Date';
+  header[2] = 'Description';
+  header[6] = 'Amount';
+  header[12] = 'Bank Account';
+  header[13] = 'Client';
+  return [header.join('\t'), ...rows].join('\n');
+}
+
+async function gotoImport(page: any) {
+  await page.setExtraHTTPHeaders({ 'x-clients': '"mine"' });
+  await page.goto(IMPORT_PATH);
+}
+
+async function pasteAndParse(page: any, tsv: string) {
+  const textarea = page.locator('#parse-form textarea').first();
+  await textarea.fill(tsv);
+  // A visible "Parse" button submits the paste form (htmx swaps in the grid).
+  await page.getByRole('button', { name: /parse/i }).click();
+  await page.waitForTimeout(800);
+}
+
+test.describe('Manual Transaction Import (SSR)', () => {
+  test('renders the import page with a paste box', async ({ page }) => {
+    await gotoImport(page);
+    await expect(page.locator('#parse-form textarea').first()).toBeVisible();
+  });
+
+  test('paste -> parse -> review grid -> import a valid transaction', async ({ page }) => {
+    await gotoImport(page);
+
+    const description = 'E2E Imported Coffee';
+    const tsv = yodleeTsv([
+      yodleeRow({
+        date: '01/15/2024',
+        description,
+        category: 'Food',
+        amount: '12.50',
+        bankAccountCode: 'TEST-CHK',
+        clientCode: 'TEST',
+      }),
+    ]);
+
+    await pasteAndParse(page, tsv);
+
+    // The review grid renders the parsed row as editable inputs (the
+    // description lives in an input value, so assert on the input, not text).
+    await expect(page.locator('input[value="TEST-CHK"]').first()).toBeVisible();
+    await expect(page.locator(`input[value="${description}"]`).first()).toBeVisible();
+
+    // Import the clean batch.
+    await page.getByRole('button', { name: /^import$/i }).click();
+    await page.waitForTimeout(1000);
+
+    // The imported transaction shows up on the transactions list.
+    await page.goto('/transaction2?date-range=all');
+    await page.waitForSelector('table tbody tr');
+    await expect(page.getByText(description)).toBeVisible();
+  });
+
+  test('blocks the whole batch when a row has an unknown bank-account code', async ({ page }) => {
+    await gotoImport(page);
+
+    const description = 'E2E Blocked Row';
+    const tsv = yodleeTsv([
+      yodleeRow({
+        date: '01/16/2024',
+        description,
+        amount: '20.00',
+        bankAccountCode: 'NOPE-DOES-NOT-EXIST',
+        clientCode: 'TEST',
+      }),
+    ]);
+
+    await pasteAndParse(page, tsv);
+
+    // The grid surfaces a blocking error for the bad row. The importer reuses
+    // the master-branch message wording ("Cannot find bank account by code …").
+    await expect(page.getByText(/cannot find bank account/i).first()).toBeVisible();
+
+    // Importing does not create the transaction (batch blocked).
+    await page.getByRole('button', { name: /^import$/i }).click();
+    await page.waitForTimeout(800);
+
+    await page.goto('/transaction2?date-range=all');
+    await page.waitForSelector('table tbody tr');
+    await expect(page.getByText(description)).toHaveCount(0);
+  });
+});

playwright.config.ts

@@ -1,5 +1,11 @@
 import { defineConfig, devices } from '@playwright/test';
 
+// Allow pointing the suite at an already-running test server (e.g. one booted from a
+// specific worktree on a non-default port) via BASE_URL. When BASE_URL is set we skip
+// the auto-started webServer entirely, so parallel worktrees don't fight over :3333.
+const baseURL = process.env.BASE_URL ?? 'http://localhost:3333';
+const useExternalServer = !!process.env.BASE_URL;
+
 export default defineConfig({
   testDir: './e2e',
   fullyParallel: true,
@@ -8,15 +14,17 @@ export default defineConfig({
   workers: process.env.CI ? 1 : undefined,
   reporter: 'html',
   use: {
-    baseURL: 'http://localhost:3333',
+    baseURL,
     trace: 'on-first-retry',
   },
-  webServer: {
-    command: 'lein run -m auto-ap.test-server',
-    url: 'http://localhost:3333/test-info',
-    reuseExistingServer: !process.env.CI,
-    timeout: 120000,
-  },
+  webServer: useExternalServer
+    ? undefined
+    : {
+        command: 'lein run -m auto-ap.test-server',
+        url: 'http://localhost:3333/test-info',
+        reuseExistingServer: !process.env.CI,
+        timeout: 120000,
+      },
   projects: [
     {
       name: 'chromium',

project.clj

@@ -96,6 +96,7 @@
                   [org.clojure/core.async]]
 
                  [hiccup "2.0.0-alpha2"]
+                 [selmer "1.12.61"]
 
                  ;; needed for java 11
                  [javax.xml.bind/jaxb-api "2.4.0-b180830.0359"]

resources/public/js/htmx-disable.js

@@ -416,4 +416,64 @@ htmx.onLoad(function(content) {
       console.error('Failed to copy text to clipboard:', err);
     }
   }
+/*
+(function() {
+    var lastFocusedSelector = null;
+    var lastCursorPosition = null;
+
+    document.addEventListener('htmx:beforeSwap', function(evt) {
+        var active = document.activeElement;
+        if (active && active !== document.body) {
+            // Build a selector to find this element after swap
+            if (active.id) {
+                lastFocusedSelector = '#' + active.id;
+            } else if (active.name) {
+                lastFocusedSelector = '[name="' + active.name + '"]';
+            } else {
+                lastFocusedSelector = null;
+            }
+
+            // Save cursor position for text inputs. selectionStart is null on
+            // inputs that don't support selection (number, date, select, etc.),
+            // and calling setSelectionRange on those throws, so only capture it
+            // when it's an actual numeric caret position.
+            if (typeof active.selectionStart === 'number') {
+                lastCursorPosition = {
+                    start: active.selectionStart,
+                    end: active.selectionEnd,
+                    direction: active.selectionDirection
+                };
+            } else {
+                lastCursorPosition = null;
+            }
+        }
+    });
+
+    document.addEventListener('htmx:afterSwap', function(evt) {
+        if (lastFocusedSelector) {
+            setTimeout(function() {
+                var el = document.querySelector(lastFocusedSelector);
+                // If morph already kept focus on the right element there's nothing
+                // to do; only restore when focus was actually lost by the swap.
+                if (el && el.focus && document.activeElement !== el) {
+                    el.focus();
+                    if (lastCursorPosition && el.setSelectionRange) {
+                        try {
+                            el.setSelectionRange(
+                                lastCursorPosition.start,
+                                lastCursorPosition.end,
+                                lastCursorPosition.direction
+                            );
+                        } catch (e) {  }
+                    }
+                }
+                lastFocusedSelector = null;
+                lastCursorPosition = null;
+            }, 10);
+        }
+    });
+})();
+
+*/
+
 

resources/templates/interop-smoke.html

@@ -0,0 +1,7 @@
+<div id="interop-smoke" class="p-2">
+  <h3>{{ title }}</h3>
+  {# a Hiccup-rendered component, passed in pre-rendered and emitted verbatim #}
+  {{ hiccup_frag|safe }}
+  <input x-ref="input" x-model="value.value"
+         @keydown.down.prevent.stop="tippy?.show()" />
+</div>

src/clj/auto_ap/jobs/sales_summaries.clj

@@ -333,7 +333,8 @@
 
   (iol-ion.tx.upsert-sales-summary-ledger/upsert-sales-summary (dc/db conn) {:db/id 17592314241429})
 
-  (mark-all-dirty 5)
+  (mark-all-dirty 14)
+  
   (delete-all)
 
   (sales-summaries-v2)

src/clj/auto_ap/server.clj

@@ -62,7 +62,15 @@
     (.setHandler server stats-handler))
   (.setStopAtShutdown server true))
 
-(def ^:dynamic *http-port-override* nil)
+(def ^:dynamic *http-port-override*
+  ;; In dev, `lein mcp-repl` records the chosen HTTP port in `.http-port` so it
+  ;; stays stable across reloads. `refresh` re-evaluates this def, so reading the
+  ;; file here (rather than relying solely on an alter-var-root override that gets
+  ;; reset) keeps the port from falling back to (env :port). Absent in prod.
+  (let [f (java.io.File. ".http-port")]
+    (when (.exists f)
+      (let [p (.trim ^String (slurp f))]
+        (when (seq p) p)))))
 
 (mount/defstate port :start (Integer/parseInt (str (or *http-port-override* (env :port) "3000"))))
 

src/clj/auto_ap/ssr/admin.clj

@@ -10,8 +10,7 @@
    [bidi.bidi :as bidi]
    [clj-time.coerce :as coerce]
    [clj-time.core :as time]
-   [datomic.api :as dc]
-   [hiccup2.core :as hiccup]))
+   [datomic.api :as dc]))
 
 (defn hourly-changes []
   (let [tx-instant-attr (:db/id (dc/pull (dc/db conn) '[:db/id] :db/txInstant))
@@ -56,34 +55,68 @@
                                  [:div
                                   [:h1.text-2xl.mb-3.font-bold "Growth in clients"]
                                   [:div
-                                   [:div {:class      "w-full h-64"
-                                          :id         "client-chart"
-                                          :data-chart (hx/json {:labels ["2 years ago" "1 year ago" "today"],
-                                                                :series [(for [n    [2 1 0]
-                                                                               :let [start (time/plus (time/now) (time/years (- n)))]]
-                                                                           (->> (dc/q '[:find (count ?c)
-                                                                                        :in $
-                                                                                        :where [?c :client/code]]
-                                                                                      (dc/as-of (dc/db conn) (coerce/to-date start)))
-                                                                                first
-                                                                                first))]})}]
-                                   [:script {:lang "javascript"}
-                                    (hiccup/raw
-                                     "new Chartist.Bar('#client-chart', JSON.parse(document.getElementById('client-chart').getAttribute('data-chart')))")]]]])
+                                   [:div.w-full.h-64
+                                    [:canvas.w-full.h-full {:x-data (hx/json {:chart  nil
+                                                                              :labels ["2 years ago" "1 year ago" "today"]
+                                                                              :data   (for [n    [2 1 0]
+                                                                                            :let [start (time/plus (time/now) (time/years (- n)))]]
+                                                                                        (->> (dc/q '[:find (count ?c)
+                                                                                                     :in $
+                                                                                                     :where [?c :client/code]]
+                                                                                                   (dc/as-of (dc/db conn) (coerce/to-date start)))
+                                                                                             first
+                                                                                             first))})
+                                                            :x-init "new Chart($el, {
+                        type: 'bar',
+                        data: {
+                          labels: labels,
+                          datasets: [{
+                            label: 'Clients',
+                            data: data,
+                            borderWidth: 1
+                          }]
+                        },
+                        options: {
+                          responsive: true,
+                          maintainAspectRatio: false,
+                          scales: {
+                            y: {
+                              beginAtZero: true
+                            }
+                          }
+                        }
+                      });"}]]]]])
 
               (com/content-card {:class "w-1/2"}
                                 [:div {:class "flex flex-col px-4 py-3 space-y-3"}
                                  [:div
                                   [:h1.text-2xl.mb-3.font-bold "Changes by hour"]
                                   [:div
-                                   [:div {:class      "w-full h-64"
-                                          :id         "changes"
-                                          :data-chart (hx/json {:labels (for [n (range -24 0)]
-                                                                          (format "%d" n)),
-                                                                :series [(hourly-changes)]})}]
-                                   [:script {:lang "javascript"}
-                                    (hiccup/raw
-                                     "new Chartist.Line('#changes', JSON.parse(document.getElementById('changes').getAttribute('data-chart')))")]]]])])
+                                   [:div.w-full.h-64
+                                    [:canvas.w-full.h-full {:x-data (hx/json {:chart  nil
+                                                                              :labels (for [n (range -24 0)]
+                                                                                        (format "%d" n))
+                                                                              :data   (hourly-changes)})
+                                                            :x-init "new Chart($el, {
+                        type: 'line',
+                        data: {
+                          labels: labels,
+                          datasets: [{
+                            label: 'Changes',
+                            data: data,
+                            borderWidth: 1
+                          }]
+                        },
+                        options: {
+                          responsive: true,
+                          maintainAspectRatio: false,
+                          scales: {
+                            y: {
+                              beginAtZero: true
+                            }
+                          }
+                        }
+                      });"}]]]]])])
    "Admin"))
 
 (def key->handler

src/clj/auto_ap/ssr/admin/import_batch.clj

@@ -35,7 +35,7 @@
                           default-grid-fields-schema)]))
 
 (defn filters [request]
-  [:form {"hx-trigger"         "change delay:500ms, keyup changed from:.hot-filter delay:1000ms"
+  [:form {"hx-trigger"         "datesApplied, change delay:500ms, keyup changed from:.hot-filter delay:1000ms"
           "hx-get"             (bidi/path-for ssr-routes/only-routes
                                               ::route/table)
           "hx-target"          "#entity-table"

src/clj/auto_ap/ssr/components/aside.clj

@@ -80,9 +80,7 @@
 (defn- transaction-nav-url [request route & {:keys [default-params] :or {default-params {:date-range "month"}}}]
   (let [preserved (transaction-nav-params request)]
     (hu/url (bidi/path-for ssr-routes/only-routes route)
-            #_(if (or (:start-date preserved) (:end-date preserved))
-              preserved
-              (merge default-params preserved)))))
+            {:date-range "month"})))
 
 (defn left-aside- [{:keys [nav page-specific]} & _]
   [:aside {:id         "left-nav",
@@ -306,6 +304,12 @@
                                 :hx-boost "true"
                                 :hx-include "#transaction-filters"}
                                "Approved")
+                 (when (is-admin? (:identity request))
+                   (menu-button- {:href (bidi/path-for ssr-routes/only-routes
+                                                       ::transaction-routes/external-import-page)
+                                  :active? (= ::transaction-routes/external-import-page (:matched-route request))
+                                  :hx-boost "true"}
+                                 "Import"))
                  (when (can? (:identity request)
                              {:subject :transaction :activity :insights})
                    (menu-button- {:href (bidi/path-for ssr-routes/only-routes

src/clj/auto_ap/ssr/components/card.clj

@@ -14,5 +14,5 @@
   [:section (merge params {:class (hh/add-class " py-3 sm:py-5" (:class params))})
    [:div {:class (:max-w params "max-w-screen-2xl")}
     (into
-     [:div {:class "relative overflow-scroll shadow-md dark:bg-gray-800 sm:rounded-lg border-2 border-gray-200 dark:border-gray-900 bg-white"}]
+     [:div {:class "relative overflow-auto shadow-md dark:bg-gray-800 sm:rounded-lg border-2 border-gray-200 dark:border-gray-900 bg-white"}]
      children)]])

src/clj/auto_ap/ssr/components/data_grid.clj

@@ -45,10 +45,10 @@
     [:label {:for "checkbox-all", :class "sr-only"} "checkbox"]]])
 
 (defn data-grid-
-  [{:keys [headers thead-params id] :as params} & rest]
+  [{:keys [headers thead-params id footer-tbody] :as params} & rest]
   [:div.shrink.overflow-y-scroll
    [:table (merge {:class "w-full text-sm text-left text-gray-500 dark:text-gray-400 shrink"}
-                  (dissoc params :headers :thead-params))
+                  (dissoc params :headers :thead-params :footer-tbody))
     [:thead (update thead-params :class #(-> "text-xs text-gray-800 uppercase bg-gray-50 dark:bg-gray-700 dark:text-gray-400 group-[.raw]:sticky group-[.raw]:z-10 group-[.raw]:top-0"
                                              (hh/add-class (or % ""))))
      (into
@@ -56,7 +56,11 @@
       headers)]
     (into
      [:tbody {}]
-     rest)]])
+     rest)
+    ;; Optional second <tbody> (valid HTML) so callers can keep a stable,
+    ;; separately-swappable region in the same table -- e.g. totals rows that
+    ;; update without touching the input-bearing rows above them.
+    footer-tbody]])
 
 ;; needed for tailwind
 ;; lg:table-cell  md:table-cell

src/clj/auto_ap/ssr/components/date_range.clj

@@ -7,7 +7,7 @@
             [clj-time.core :as t]
             [clj-time.periodic :as per]))
 
-(defn date-range-field [{:keys [value id apply-button?]}]
+(defn date-range-field [{:keys [value id]}]
   [:div {:id id}
    (com/field {:label "Date Range"}
               [:div.space-y-4
@@ -17,7 +17,7 @@
                                   (com/button-group-button {:size :small :value "week" :hx-trigger "click"} "Week")
                                   (com/button-group-button {:size :small :value "month" :hx-trigger "click"} "Month")
                                   (com/button-group-button {:size :small :value "year" :hx-trigger "click"} "Year"))]
-               [:div.flex.space-x-1.items-baseline.w-full.justify-start
+               [:div.flex.space-x-1.items-baseline.w-full.justify-start {"@change.stop" ""}
                 (com/date-input {:name        "start-date"
                                  :value       (some-> (:start value)
                                                       (atime/unparse-local atime/normal-date))
@@ -31,9 +31,8 @@
                                  :placeholder "Date"
                                  :size        :small
                                  :class "shrink date-filter-input"})
-                (when apply-button?
-                  (but/button- {:color :secondary
-                                :size :small
-                                :type "button"
-                                "x-on:click" "$dispatch('datesApplied')"}
-                               "Apply"))]])])
+                (but/button- {:color :secondary
+                              :size :small
+                              :type "button"
+                              "x-on:click" "$dispatch('datesApplied')"}
+                             "Apply")]])])

src/clj/auto_ap/ssr/components/inputs.clj

@@ -51,26 +51,31 @@
                      {:x-init "$el.indeterminate = true"}))]))
 
 (defn typeahead- [params]
-  [:div.relative {:x-data (hx/json {:baseUrl (str (:url params))
-                                    :value {:value ((:value-fn params identity) (:value params)) :label ((:content-fn params identity) (:value params))}
-                                    :tippy nil
-                                    :search ""
-                                    :active -1
-                                    :elements (if ((:value-fn params identity) (:value params))
-                                                [{:value ((:value-fn params identity) (:value params)) :label ((:content-fn params identity) (:value params))}]
-                                                [])})
-                  :x-modelable "value.value"
-                  :x-model (:x-model params)}
+  [:div.relative (cond-> {:x-data (hx/json {:baseUrl (str (:url params))
+                                            :value {:value ((:value-fn params identity) (:value params)) :label ((:content-fn params identity) (:value params))}
+                                            :tippy nil
+                                            :search ""
+                                            :active -1
+                                            :elements (if ((:value-fn params identity) (:value params))
+                                                        [{:value ((:value-fn params identity) (:value params)) :label ((:content-fn params identity) (:value params))}]
+                                                        [])})
+                          :x-modelable "value.value"
+                          :x-model (:x-model params)}
+                   ;; Key the component by its current value so alpine-morph re-initialises
+                   ;; it (rather than preserving stale Alpine x-data) whenever the *server*
+                   ;; changes the value -- e.g. the default account a vendor selection
+                   ;; populates. alpine-morph keys off the `key` attribute, not `id`.
+                   (:id params) (assoc :key (str (:id params) "--" ((:value-fn params identity) (:value params)))))
    (if (:disabled params)
      [:span {:x-text "value.label"}]
-     [:a {:class                        (-> (hh/add-class (or (:class params) "") default-input-classes)
-                                            (hh/add-class "cursor-pointer"))
-          "x-tooltip.on.click"              "{content: ()=>$refs.dropdown.innerHTML, placement: 'bottom', onMount(i) {htmx.process(i.popper); }, popperOptions: {strategy: 'fixed', modifiers: [{name: 'flip', options: {fallbackPlacements: ['top']}}]}, theme: 'dropdown', allowHTML: true, interactive:true}"
-          "@keydown.down.prevent.stop"  "tippy.show();"
-          "@keydown.backspace"          "tippy.hide(); value = {value: '', label: '' }"
-          :tabindex                     0
-          :x-init                      (str  "$nextTick(() => tippy = $el.__x_tippy); " (:x-init params))
-          :x-ref                        "input"}
+     [:a {:class (-> (hh/add-class (or (:class params) "") default-input-classes)
+                     (hh/add-class "cursor-pointer"))
+          "x-tooltip.on.click" "{content: ()=>($refs.dropdown?.innerHTML ?? ''), placement: 'bottom', onMount(i) {htmx.process(i.popper); }, popperOptions: {strategy: 'fixed', modifiers: [{name: 'flip', options: {fallbackPlacements: ['top']}}]}, theme: 'dropdown', allowHTML: true, interactive:true}"
+          "@keydown.down.prevent.stop" "tippy?.show();"
+          "@keydown.backspace" "tippy?.hide(); value = {value: '', label: '' }"
+          :tabindex 0
+          :x-init (str "$nextTick(() => tippy = $el.__x_tippy); " (:x-init params))
+          :x-ref "input"}
       [:input (-> params
                   (dissoc :class)
                   (dissoc :value-fn)
@@ -81,9 +86,9 @@
 
                   (assoc
                    "x-ref" "hidden"
-                   :type    "hidden"
+                   :type "hidden"
                    ":value" "value.value"
-                   :x-init (hiccup/raw (str "$watch('value', v => $dispatch('change')); "))))]
+                   :x-init (hiccup/raw (str "$watch('value', v => { $el.value = (v && v.value != null) ? v.value : ''; $nextTick(() => $dispatch('change')); }); "))))]
       [:div.flex.w-full.justify-items-stretch
        [:span.flex-grow.text-left {"x-text" "value.label"}]
        [:div {:class "w-3 h-3 m-1 inline ml-1 justify-self-end text-gray-500 self-center"}
@@ -93,71 +98,72 @@
                       :x-tooltip "value.warning"} "!")]]])
 
    [:template {:x-ref "dropdown"}
-    [:ul.dropdown-contents {:class                     "bg-gray-100 dark:bg-gray-600  ring-1"
-                            "@keydown.escape"   "tippy.hide(); value = {value: '', label: '' };  "
+    [:ul.dropdown-contents {:class "bg-gray-100 dark:bg-gray-600  ring-1"
+                            "@keydown.escape" "$refs.input?.__x_tippy?.hide(); value = {value: '', label: '' };  "
                             :x-destroy "if ($refs.input) {$refs.input.focus();}"}
-     [:input {:type                    "text"
+     [:input {:type "text"
               :autofocus true
-              :class                   (-> (:class params)
-                                           (or "")
-                                           (hh/add-class default-input-classes)
-                                           (hh/replace-wildcard ["rounded" "border"] "border-bottom bg-gray-100 rounded-t-lg w-full"))
-              "x-model"                "search"
-              "placeholder"            (:placeholder params)
-              "@keydown.down.prevent"  "active ++; active = active >= elements.length - 1 ? elements.length - 1 : active"
-              "@keydown.up.prevent"    "active --; active = active < 0 ? 0 : active"
-              "@keydown.enter.prevent.stop" "tippy.hide(); value = elements.length > 0 ? $data.elements[active] : {'value': '', label: ''}; $refs.input.focus()"
-              "x-init"                 "$el.focus(); $watch('search', s => { if($el.value.length > 2) {fetch(addQueryParam(baseUrl, 'q', s)).then(data=>data.json()).then(data => {elements = data; active=-1; tippy.popperInstance.update()}) }})"}]
+              :class (-> (:class params)
+                         (or "")
+                         (hh/add-class default-input-classes)
+                         (hh/replace-wildcard ["rounded" "border"] "border-bottom bg-gray-100 rounded-t-lg w-full"))
+              "x-model" "search"
+              "placeholder" (:placeholder params)
+              "@change.stop" ""
+              "@keydown.down.prevent" "active ++; active = active >= elements.length - 1 ? elements.length - 1 : active"
+              "@keydown.up.prevent" "active --; active = active < 0 ? 0 : active"
+              "@keydown.enter.prevent.stop" "$refs.input?.__x_tippy?.hide(); value = elements.length > 0 ? $data.elements[active >= 0 ? active : 0] : {'value': '', label: ''}; $refs.input?.focus()"
+              "x-init" "$el.focus(); $watch('search', s => { if($el.value.length > 2) {fetch(addQueryParam(baseUrl, 'q', s)).then(data=>data.json()).then(data => {elements = data; active=-1; $refs.input?.__x_tippy?.popperInstance?.update()}) }})"}]
      [:div.dropdown-options {:class "rounded-b-lg overflow-hidden"}
       [:template {:x-for "(element, index) in elements"}
-       [:li [:a {:class           "px-4 py-2 flex gap-2 items-center outline-0 focus:bg-neutral-100 hover:bg-neutral-100 whitespace-nowrap [&.active]:bg-primary-500 [&.active]:dark:bg-primary-700  text-gray-800  dark:text-gray-100"
-                 :href            "#"
-                 ":class"         "active == index ? 'active' : ''"
+       [:li [:a {:class "px-4 py-2 flex gap-2 items-center outline-0 focus:bg-neutral-100 hover:bg-neutral-100 whitespace-nowrap [&.active]:bg-primary-500 [&.active]:dark:bg-primary-700  text-gray-800  dark:text-gray-100"
+                 :href "#"
+                 ":class" "active == index ? 'active' : ''"
 
-                 "@mouseover"     "active = index"
-                 "@mouseout"      "active = -1"
-                 "@click.prevent" "value = element; tippy.hide();  $refs.input.focus()"
-                 "x-html"         "element.label"}]]]
+                 "@mouseover" "active = index"
+                 "@mouseout" "active = -1"
+                 "@click.prevent" "value = element; $refs.input?.__x_tippy?.hide(); setTimeout(() => $refs.input?.focus(), 10)"
+                 "x-html" "element.label"}]]]
       [:template {:x-if "elements.length == 0"}
        [:li {:class "px-4 py-2 flex gap-2 items-center outline-0 focus:bg-neutral-100 hover:bg-neutral-100 whitespace-nowrap [&.active]:bg-primary-500 text-gray-800  dark:text-gray-100 text-xs "}
         "No results found"]]]]]])
 
 (defn multi-typeahead-dropdown- [params]
   [:template {:x-ref "dropdown"}
-   [:ul.dropdown-contents {:class                     "bg-gray-100 dark:bg-gray-600 rounded-lg shadow-2xl w-max z-50 ring-1 p-4"
-                           "@keydown.escape.prevent"   "tippy.hide();"
+   [:ul.dropdown-contents {:class "bg-gray-100 dark:bg-gray-600 rounded-lg shadow-2xl w-max z-50 ring-1 p-4"
+                           "@keydown.escape.prevent" "$refs.input?.__x_tippy?.hide();"
                            :x-destroy "if ($refs.input) {$refs.input.focus();}"}
     [:div {:class (-> "relative"
                       #_(hh/replace-wildcard ["rounded" "border"] "border-bottom bg-gray-100 rounded-t-lg w-full"))}
      [:div {:class "absolute inset-y-0 start-0 flex items-center ps-3 pointer-events-none"}
       [:svg {:class "w-4 h-4 text-gray-500 dark:text-gray-400", :aria-hidden "true", :xmlns "http://www.w3.org/2000/svg", :fill "none", :viewbox "0 0 20 20"}
        [:path {:stroke "currentColor", :stroke-linecap "round", :stroke-linejoin "round", :stroke-width "2", :d "m19 19-4-4m0-7A7 7 0 1 1 1 8a7 7 0 0 1 14 0Z"}]]]
-     [:input {:type                    "text"
+     [:input {:type "text"
               :class (-> (:class params)
                          (or "")
                          (hh/add-class "block w-full p-2 ps-10 text-sm text-gray-900 border border-gray-300 rounded-lg bg-gray-50 focus:ring-blue-500 focus:border-blue-500 dark:bg-gray-700 dark:border-gray-600 dark:placeholder-gray-400 dark:text-white dark:focus:ring-blue-500 dark:focus:border-blue-500")
                          (hh/add-class default-input-classes))
-              "x-model"                "search"
-              "placeholder"            (:placeholder params)
-              "@keydown.down.prevent"  "active ++; active = active >= elements.length - 1 ? elements.length - 1 : active"
-              "@keydown.up.prevent"    "active --; active = active < 0 ? 0 : active"
+              "x-model" "search"
+              "placeholder" (:placeholder params)
+              "@keydown.down.prevent" "active ++; active = active >= elements.length - 1 ? elements.length - 1 : active"
+              "@keydown.up.prevent" "active --; active = active < 0 ? 0 : active"
               "@keydown.enter.prevent.stop" "if ($data.elements[active]) { if (value.has($data.elements[active].value)) { value.delete($data.elements[active].value) } else {value.add($data.elements[active].value); lookup[$data.elements[active].value] = $data.elements[active].label} } "
-              "x-init"                 " $el.focus(); $watch('search', s => { if($el.value.length > 2) {fetch(addQueryParam(baseUrl, 'q',  s)).then(data=>data.json()).then(data => reset_elements(data)) }})"}]]
+              "x-init" " $el.focus(); $watch('search', s => { if($el.value.length > 2) {fetch(addQueryParam(baseUrl, 'q',  s)).then(data=>data.json()).then(data => reset_elements(data)) }})"}]]
     [:div.dropdown-options {:class "overflow-hidden  divide-y divide-gray-200 "}
      [:template {:x-for "(element, index) in elements"}
-      [:li  {":style" "index  == 0  && 'border: 0 !important;'"}
-       [:label {:class           "p-3 group rounded flex gap-2 items-center outline-0 focus:bg-neutral-100 hover:bg-neutral-100 whitespace-nowrap [&.active]:bg-primary-300 [&.active]:dark:bg-primary-700 [&.implied]:text-gray-500 text-gray-800  dark:text-gray-100 cursor-pointer"
+      [:li {":style" "index  == 0  && 'border: 0 !important;'"}
+       [:label {:class "p-3 group rounded flex gap-2 items-center outline-0 focus:bg-neutral-100 hover:bg-neutral-100 whitespace-nowrap [&.active]:bg-primary-300 [&.active]:dark:bg-primary-700 [&.implied]:text-gray-500 text-gray-800  dark:text-gray-100 cursor-pointer"
 
-                :href            "#"
-                ":class" (hx/json {"active"  (hx/js-fn "active==index")
+                :href "#"
+                ":class" (hx/json {"active" (hx/js-fn "active==index")
                                    "implied" (hx/js-fn "all_selected && index != 0")})
-                "@mouseover"     "active = index"
-                "@mouseout"      "active = -1"
+                "@mouseover" "active = index"
+                "@mouseout" "active = -1"
                 "@click.prevent" "toggle(element)"}
         (checkbox- {":checked" "value.has(element.value) || all_selected"
                     :class "group-[&.implied]:bg-green-200"})
         #_[:input {:type "checkbox"}]
-        [:span {"x-html"         "element.label"}]]]]
+        [:span {"x-html" "element.label"}]]]]
      [:template {:x-if "elements.length == 0"}
       [:li {:class "px-4 pt-4 flex gap-2 items-center outline-0 focus:bg-neutral-100 hover:bg-neutral-100 whitespace-nowrap [&.active]:bg-primary-500 text-gray-800  dark:text-gray-100 text-xs " "style" "border: 0 !important"}
        "No results found"]]]]])
@@ -225,7 +231,7 @@
                                     :x-init (str "$watch('value', v => $dispatch('change')); ")
                                     :search ""
                                     :active -1
-                                    :elements (cond->  [{:value "all" :label "All"}]
+                                    :elements (cond-> [{:value "all" :label "All"}]
                                                 (sequential? (:value params))
                                                 (into (map (fn [v]
                                                              {:value ((:value-fn params identity) v)
@@ -237,24 +243,24 @@
                   :x-init "value=new Set(value || []); "}
    (if (:disabled params)
      [:span {:x-text "value.label"}]
-     [:a {:class                        (-> (hh/add-class (or (:class params) "") default-input-classes)
-                                            (hh/add-class "cursor-pointer"))
-          "x-tooltip.on.click.prevent"              "{content: ()=>$refs.dropdown.innerHTML, placement: 'bottom', onMount(i) {htmx.process(i.popper); }, popperOptions: {strategy: 'fixed', modifiers: [{name: 'flip', options: {fallbackPlacements: ['top']}}]}, theme: 'dropdown', allowHTML: true, interactive:true}"
-          "@keydown.down.prevent.stop"  "tippy.show();"
-          "@keydown.backspace"          "tippy.hide(); value=new Set( []);"
-          :tabindex                     0
-          :x-init                      (str  "$nextTick(() => tippy = $el.__x_tippy); " (:x-init params))
-          :x-ref                        "input"}
+     [:a {:class (-> (hh/add-class (or (:class params) "") default-input-classes)
+                     (hh/add-class "cursor-pointer"))
+          "x-tooltip.on.click.prevent" "{content: ()=>($refs.dropdown?.innerHTML ?? ''), placement: 'bottom', onMount(i) {htmx.process(i.popper); }, popperOptions: {strategy: 'fixed', modifiers: [{name: 'flip', options: {fallbackPlacements: ['top']}}]}, theme: 'dropdown', allowHTML: true, interactive:true}"
+          "@keydown.down.prevent.stop" "$refs.input?.__x_tippy?.show();"
+          "@keydown.backspace" "$refs.input?.__x_tippy?.hide(); value=new Set( []);"
+          :tabindex 0
+          :x-init (str "$nextTick(() => tippy = $el.__x_tippy); " (:x-init params))
+          :x-ref "input"}
       [:template {:x-for "v in Array.from(value.values())"}
        [:input (-> params
                    (dissoc :class :value-fn :content-fn :placeholder :x-model)
                    (assoc
-                    :type    "hidden"
+                    :type "hidden"
                     "x-bind:value" "v"))]]
       [:template {:x-if "value.size == 0"}
        [:input (-> params
                    (dissoc :class :value-fn :content-fn :placeholder :x-model)
-                   (assoc :type    "hidden"
+                   (assoc :type "hidden"
                           :value ""))]]
       [:div.flex.w-full.justify-items-stretch
        (multi-typeahead-selected-pill- params)
@@ -296,23 +302,23 @@
 
 (defn money-input- [{:keys [size] :as params}]
   [:input
-   (->  params
-        (update :class (fnil hh/add-class "") default-input-classes)
-        (update :class hh/add-class "appearance-none text-right")
-        (update :class #(str % (use-size size)))
-        (assoc :type "number"
-               :step "0.01")
-        (dissoc :size))])
+   (-> params
+       (update :class (fnil hh/add-class "") default-input-classes)
+       (update :class hh/add-class "appearance-none text-right")
+       (update :class #(str % (use-size size)))
+       (assoc :type "number"
+              :step "0.01")
+       (dissoc :size))])
 
 (defn int-input- [{:keys [size] :as params}]
   [:input
-   (->  params
-        (update :class (fnil hh/add-class "") default-input-classes)
-        (update :class hh/add-class "appearance-none text-right")
-        (update :class #(str % (use-size size)))
-        (assoc :type "number"
-               :step "1")
-        (dissoc :size))])
+   (-> params
+       (update :class (fnil hh/add-class "") default-input-classes)
+       (update :class hh/add-class "appearance-none text-right")
+       (update :class #(str % (use-size size)))
+       (assoc :type "number"
+              :step "1")
+       (dissoc :size))])
 
 (defn date-input- [{:keys [size] :as params}]
   [:div.shrink {:x-data (hx/json {:value (:value params)
@@ -321,40 +327,40 @@
                 "x-effect" "console.log('changed to' +value)"
                 "@change-date.camel" "$dispatch('change')"}
    [:input
-    (->  params
-         (update :class (fnil hh/add-class "") default-input-classes)
-         (assoc :x-model "value")
-         (assoc "x-tooltip.on.focus" "{content: ()=>$refs.tooltip.innerHTML, theme: 'light', onMount(i) { htmx.process(i.popper); }, allowHTML: true, interactive:true}")
+    (-> params
+        (update :class (fnil hh/add-class "") default-input-classes)
+        (assoc :x-model "value")
+        (assoc "x-tooltip.on.focus" "{content: ()=>($refs.tooltip?.innerHTML ?? ''), theme: 'light', onMount(i) { htmx.process(i.popper); }, allowHTML: true, interactive:true}")
 
-         (assoc :x-init "$nextTick(() => tippy = $el.__x_tippy); ")
-         (assoc :type "text")
+        (assoc :x-init "$nextTick(() => tippy = $el.__x_tippy); ")
+        (assoc :type "text")
 
-         (assoc "autocomplete" "off")
-         (assoc "@change" "value = $event.target.value;")
+        (assoc "autocomplete" "off")
+        (assoc "@change" "value = $event.target.value;")
 
-         (assoc                              "@keydown.escape"   "tippy.hide(); ")
-         #_(assoc "hx-on" (hiccup/raw "changeDate: htmx.trigger(this, \"change\") "))
-         (update :class #(str % (use-size size) " w-full"))
-         (dissoc :size))]
+        (assoc "@keydown.escape" "$el?.__x_tippy?.hide(); ")
+        #_(assoc "hx-on" (hiccup/raw "changeDate: htmx.trigger(this, \"change\") "))
+        (update :class #(str % (use-size size) " w-full"))
+        (dissoc :size))]
    [:template {:x-ref "tooltip"}
 
     [:div.shrink
      [:div
-      (->  params
-           (update :class (fnil hh/add-class "") default-input-classes)
-           (assoc :type "text")
-           (assoc :value (:value params))
+      (-> params
+          (update :class (fnil hh/add-class "") default-input-classes)
+          (assoc :type "text")
+          (assoc :value (:value params))
                 ;; the data-date field has to be bound before the datepicker can be initialized
-           (assoc :x-init "$nextTick(() =>  { dp = initCalendar($el); ;}); ")
-           (assoc "x-effect" "if(dp) { dp.setDate(value); } ")
-           (assoc ":data-date" "value")
-           (assoc "@htmx:before-history-save" "destroyDatepicker(dp)")
-           (assoc "@htmx:before-cleanup-element" "destroyDatepicker(dp)")
-           (assoc "x-destroy" "destroyDatepicker(dp)")
-           (assoc "@change-date.camel" "value = dp.getDate(\"mm/dd/yyyy\");")
+          (assoc :x-init "$nextTick(() =>  { dp = initCalendar($el); ;}); ")
+          (assoc "x-effect" "if(dp) { dp.setDate(value); } ")
+          (assoc ":data-date" "value")
+          (assoc "@htmx:before-history-save" "destroyDatepicker(dp)")
+          (assoc "@htmx:before-cleanup-element" "destroyDatepicker(dp)")
+          (assoc "x-destroy" "destroyDatepicker(dp)")
+          (assoc "@change-date.camel" "value = dp.getDate(\"mm/dd/yyyy\");")
 
-           (update :class #(str % (use-size size) " w-full"))
-           (dissoc :size :name :x-model :x-modelable))]]]])
+          (update :class #(str % (use-size size) " w-full"))
+          (dissoc :size :name :x-model :x-modelable))]]]])
 
 (defn multi-calendar-input- [{:keys [size] :as params}]
   (let [value (str/join ", "
@@ -368,21 +374,21 @@
      [:template {:x-for "v in value"}
       [:input {:type "hidden" :name (:name params) :x-model "v"}]]
      [:div
-      (->  params
-           (update :class (fnil hh/add-class "") default-input-classes)
-           (assoc :type "text")
-           (assoc :value value)
+      (-> params
+          (update :class (fnil hh/add-class "") default-input-classes)
+          (assoc :type "text")
+          (assoc :value value)
            ;; the data-date field has to be bound before the datepicker can be initialized
-           (assoc :x-init "$nextTick(() =>  { dp = initMultiDatepicker($el, value); ;}); ")
-           (assoc "x-effect" "if(dp) { dp.setDate(Array.from(value), {clear: true}); } ")
-           (assoc ":data-date" "Array.prototype.join.call(value, ', ')")
-           (assoc "@htmx:before-history-save" "destroyDatepicker(dp)")
-           (assoc "@htmx:before-cleanup-element" "destroyDatepicker(dp)")
-           (assoc "x-destroy" "destroyDatepicker(dp)")
-           (assoc "@change-date.camel" "value = dp.getDate(\"mm/dd/yyyy\");")
+          (assoc :x-init "$nextTick(() =>  { dp = initMultiDatepicker($el, value); ;}); ")
+          (assoc "x-effect" "if(dp) { dp.setDate(Array.from(value), {clear: true}); } ")
+          (assoc ":data-date" "Array.prototype.join.call(value, ', ')")
+          (assoc "@htmx:before-history-save" "destroyDatepicker(dp)")
+          (assoc "@htmx:before-cleanup-element" "destroyDatepicker(dp)")
+          (assoc "x-destroy" "destroyDatepicker(dp)")
+          (assoc "@change-date.camel" "value = dp.getDate(\"mm/dd/yyyy\");")
 
-           (update :class #(str % (use-size size) " w-full"))
-           (dissoc :size :name :x-model :x-modelable))]]))
+          (update :class #(str % (use-size size) " w-full"))
+          (dissoc :size :name :x-model :x-modelable))]]))
 
 (defn calendar-input- [{:keys [size] :as params}]
   (let [value (:value params)]
@@ -392,21 +398,21 @@
                   :x-model (:x-model params)}
      [:input {:type "hidden" :name (:name params) :x-model "value"}]
      [:div
-      (->  params
-           (update :class (fnil hh/add-class "") default-input-classes)
-           (assoc :type "text")
-           (assoc :value value)
+      (-> params
+          (update :class (fnil hh/add-class "") default-input-classes)
+          (assoc :type "text")
+          (assoc :value value)
            ;; the data-date field has to be bound before the datepicker can be initialized
-           (assoc :x-init "$nextTick(() =>  { dp = initCalendar($el); ;}); ")
-           (assoc "x-effect" "if(dp) { dp.setDate(value); } ")
-           (assoc ":data-date" "value")
-           (assoc "@htmx:before-history-save" "destroyDatepicker(dp)")
-           (assoc "@htmx:before-cleanup-element" "destroyDatepicker(dp)")
-           (assoc "x-destroy" "destroyDatepicker(dp)")
-           (assoc "@change-date.camel" "value = dp.getDate(\"mm/dd/yyyy\");")
+          (assoc :x-init "$nextTick(() =>  { dp = initCalendar($el); ;}); ")
+          (assoc "x-effect" "if(dp) { dp.setDate(value); } ")
+          (assoc ":data-date" "value")
+          (assoc "@htmx:before-history-save" "destroyDatepicker(dp)")
+          (assoc "@htmx:before-cleanup-element" "destroyDatepicker(dp)")
+          (assoc "x-destroy" "destroyDatepicker(dp)")
+          (assoc "@change-date.camel" "value = dp.getDate(\"mm/dd/yyyy\");")
 
-           (update :class #(str % (use-size size) " w-full"))
-           (dissoc :size :name :x-model :x-modelable))]]))
+          (update :class #(str % (use-size size) " w-full"))
+          (dissoc :size :name :x-model :x-modelable))]]))
 
 (defn field-errors- [{:keys [source key]} & rest]
   (let [errors (:errors (cond-> (meta source)

src/clj/auto_ap/ssr/invoice/import.clj

@@ -56,7 +56,7 @@
     [:div {:id "exact-match-id-tag"}]))
 
 (defn filters [request]
-  [:form#invoice-filters {"hx-trigger"   "change delay:500ms, keyup changed from:.hot-filter delay:1000ms"
+  [:form#invoice-filters {"hx-trigger"   "datesApplied, change delay:500ms, keyup changed from:.hot-filter delay:1000ms"
                           "hx-get"       (bidi/path-for ssr-routes/only-routes
                                                         ::route/import-table)
                           "hx-target"    "#entity-table"

src/clj/auto_ap/ssr/ledger/common.clj

@@ -11,10 +11,10 @@
    [auto-ap.routes.transactions :as transaction-routes]
    [auto-ap.ssr-routes :as ssr-routes]
    [auto-ap.ssr.components :as com]
+   [auto-ap.ssr.components.date-range :as dr]
    [auto-ap.ssr.components.link-dropdown :refer [link-dropdown]]
    [auto-ap.ssr.grid-page-helper :as helper]
    [auto-ap.ssr.hx :as hx]
-   [auto-ap.ssr.pos.common :refer [date-range-field*]]
    [auto-ap.ssr.svg :as svg]
    [auto-ap.ssr.utils
     :refer [clj-date-schema entity-id html-response ref->enum-schema
@@ -31,7 +31,7 @@
 
 (defn exact-match-id* [request]
   (if (nat-int? (:exact-match-id (:query-params request)))
-    [:div {:x-data (hx/json {:exact_match (:exact-match-id (:query-params request))}) :id "exact-match-id-tag"}
+    [:div {:x-data (hx/json {:exact_match (:exact-match-id (:query-params request))}) :id "exact-match-id-tag" :class "filter-trigger"}
      (com/hidden {:name "exact-match-id"
                   "x-model" "exact_match"})
      (com/pill {:color :primary}
@@ -46,13 +46,14 @@
   [:div {:hx-trigger "clientSelected from:body"
          :hx-get (bidi.bidi/path-for ssr-routes/only-routes ::route/bank-account-filter)
          :hx-target "this"
-         :hx-swap "outerHTML"}
+         :hx-swap "outerHTML"
+         :class "filter-trigger"}
    (when (:client request)
      (let [bank-account-belongs-to-client? (get (set (map :db/id (:client/bank-accounts (:client request))))
                                                 (:db/id (:bank-account (:query-params request))))]
        (com/field {:label "Bank Account"}
-                  (com/radio-card {:size    :small
-                                   :name    "bank-account"
+                  (com/radio-card {:size :small
+                                   :name "bank-account"
                                    :value (or (when bank-account-belongs-to-client?
                                                 (:db/id (:bank-account (:query-params request))))
                                               "")
@@ -60,90 +61,96 @@
                                    (into [{:value ""
                                            :content "All"}]
                                          (for [ba (:client/bank-accounts (:client request))]
-                                           {:value   (:db/id ba)
+                                           {:value (:db/id ba)
                                             :content (:bank-account/name ba)}))}))))])
 
 (defn bank-account-filter [request]
   (html-response (bank-account-filter* request)))
 
 (defn filters [request]
-  [:form#ledger-filters {"hx-trigger"   "change delay:500ms, keyup changed from:.hot-filter delay:1000ms"
-                         "hx-get"       (bidi/path-for ssr-routes/only-routes
-                                                       ::route/table)
-                         "hx-target"    "#entity-table"
+  [:form#ledger-filters {"hx-trigger" "datesApplied, change delay:500ms from:.filter-trigger, keyup changed from:.hot-filter delay:1000ms"
+                         "hx-get" (bidi/path-for ssr-routes/only-routes
+                                                 ::route/table)
+                         "hx-target" "#entity-table"
                          "hx-indicator" "#entity-table"}
 
    (com/hidden {:name "status"
                 :value (some-> (:status (:query-params request)) name)})
    [:fieldset.space-y-6
     (com/field {:label "Vendor"}
-               (com/typeahead {:name        "vendor"
-                               :id          "vendor"
+               (com/typeahead {:name "vendor"
+                               :id "vendor"
                                :url (bidi/path-for ssr-routes/only-routes :vendor-search)
-                               :value       (:vendor (:query-params request))
+                               :value (:vendor (:query-params request))
                                :value-fn :db/id
-                               :content-fn :vendor/name}))
+                               :content-fn :vendor/name
+                               :class "filter-trigger"}))
     (com/field {:label "Account"}
-               (com/typeahead {:name        "account"
-                               :id          "account"
+               (com/typeahead {:name "account"
+                               :id "account"
                                :url (bidi/path-for ssr-routes/only-routes :account-search)
-                               :value       (:account (:query-params request))
+                               :value (:account (:query-params request))
                                :value-fn :db/id
                                :content-fn #(:account/name (d-accounts/clientize (dc/pull (dc/db conn) d-accounts/default-read (:db/id %))
-                                                                                 (:db/id (:client request))))}))
+                                                                                 (:db/id (:client request))))
+                               :class "filter-trigger"}))
 
     (bank-account-filter* request)
 
-    (date-range-field* request)
+    (dr/date-range-field {:value {:start (:start-date (:query-params request))
+                                  :end (:end-date (:query-params request))}
+                          :id "date-range"
+                          :apply-button? true})
     (com/field {:label "Invoice #"}
-               (com/text-input {:name        "invoice-number"
-                                :id          "invoice-number"
-                                :class       "hot-filter"
-                                :value       (:invoice-number (:query-params request))
+               (com/text-input {:name "invoice-number"
+                                :id "invoice-number"
+                                :class "hot-filter"
+                                :value (:invoice-number (:query-params request))
                                 :placeholder "e.g., ABC-456"
-                                :size        :small}))
+                                :size :small}))
 
     (com/field {:label "Account Code"}
                [:div.flex.space-x-4.items-baseline
-                (com/int-input {:name        "numeric-code-gte"
-                                :id          "numeric-code-gte"
+                (com/int-input {:name "numeric-code-gte"
+                                :id "numeric-code-gte"
                                 :hx-preserve "true"
-                                :class       "hot-filter  w-20"
-                                :value       (:numeric-code-gte (:query-params request))
+                                :class "hot-filter  w-20"
+                                :value (:numeric-code-gte (:query-params request))
                                 :placeholder "40000"
-                                :size        :small})
+                                :size :small})
                 [:div.align-baseline
                  "to"]
-                (com/int-input {:name        "numeric-code-lte"
+                (com/int-input {:name "numeric-code-lte"
                                 :hx-preserve "true"
-                                :id          "numeric-code-lte"
-                                :class       "hot-filter w-20"
-                                :value       (:numeric-code-lte (:query-params request))
+                                :id "numeric-code-lte"
+                                :class "hot-filter w-20"
+                                :value (:numeric-code-lte (:query-params request))
                                 :placeholder "50000"
-                                :size        :small})])
+                                :size :small})])
 
     (com/field {:label "Amount"}
                [:div.flex.space-x-4.items-baseline
-                (com/money-input {:name        "amount-gte"
-                                  :id          "amount-gte"
+                (com/money-input {:name "amount-gte"
+                                  :id "amount-gte"
                                   :hx-preserve "true"
-                                  :class       "hot-filter  w-20"
-                                  :value       (:amount-gte (:query-params request))
+                                  :class "hot-filter  w-20"
+                                  :value (:amount-gte (:query-params request))
                                   :placeholder "0.01"
-                                  :size        :small})
+                                  :size :small})
                 [:div.align-baseline
                  "to"]
-                (com/money-input {:name        "amount-lte"
+                (com/money-input {:name "amount-lte"
                                   :hx-preserve "true"
-                                  :id          "amount-lte"
-                                  :class       "hot-filter w-20"
-                                  :value       (:amount-lte (:query-params request))
+                                  :id "amount-lte"
+                                  :class "hot-filter w-20"
+                                  :value (:amount-lte (:query-params request))
                                   :placeholder "9999.34"
-                                  :size        :small})])
-    [:div.mt-4  {:x-data (hx/json {:onlyUnbalanced (:only-unbalanced (:query-params request))})}
+                                  :size :small})])
+    [:div.mt-4 {:x-data (hx/json {:onlyUnbalanced (:only-unbalanced (:query-params request))})}
      (com/hidden {:name "only-unbalanced"
                   ":value" "onlyUnbalanced ? 'on' : ''"})
      (com/checkbox {:value (:only-unbalanced (:query-params request))
+                    :class "filter-trigger"
                     :x-model "onlyUnbalanced"}
                    "Show unbalanced")]
     (exact-match-id* request)]])
@@ -184,12 +191,12 @@
         args query-params
         query
         (if (:exact-match-id args)
-          {:query {:find  '[?e]
-                   :in    '[$ ?e [?c ...]]
+          {:query {:find '[?e]
+                   :in '[$ ?e [?c ...]]
                    :where '[[?e :journal-entry/client ?c]]}
-           :args  [db
-                   (:exact-match-id args)
-                   valid-clients]}
+           :args [db
+                  (:exact-match-id args)
+                  valid-clients]}
           (cond-> {:query {:find []
                            :in ['$ '[?clients ?start ?end]]
                            :where '[[(iol-ion.query/scan-ledger $ ?clients ?start ?end) [[?e _ ?sort-default] ...]]]}
@@ -202,28 +209,28 @@
             (merge-query {:query {:where ['(not [?e :journal-entry/original-entity])]}})
 
             (seq (:external-id-like args))
-            (merge-query {:query {:in    ['?external-id-like]
+            (merge-query {:query {:in ['?external-id-like]
                                   :where ['[?e :journal-entry/external-id ?external-id]
                                           '[(.contains ^String ?external-id ?external-id-like)]]}
-                          :args  [(:external-id-like args)]})
+                          :args [(:external-id-like args)]})
 
             (seq (:source args))
-            (merge-query {:query {:in    ['?source]
+            (merge-query {:query {:in ['?source]
                                   :where ['[?e :journal-entry/source ?source]]}
-                          :args  [(:source args)]})
+                          :args [(:source args)]})
             (:external? route-params)
             (merge-query {:query {:where ['[?e :journal-entry/external-id]]}})
 
             (:vendor args)
-            (merge-query {:query {:in    ['?vendor-id]
+            (merge-query {:query {:in ['?vendor-id]
                                   :where ['[?e :journal-entry/vendor ?vendor-id]]}
-                          :args  [(:db/id (:vendor args))]})
+                          :args [(:db/id (:vendor args))]})
 
             (:invoice-number args)
-            (merge-query {:query {:in    ['?invoice-number]
+            (merge-query {:query {:in ['?invoice-number]
                                   :where ['[?e :journal-entry/original-entity ?oe]
                                           '[?oe :invoice/invoice-number ?invoice-number]]}
-                          :args  [(:invoice-number args)]})
+                          :args [(:invoice-number args)]})
 
             (or (:numeric-code-lte args)
                 (:numeric-code-gte args)
@@ -235,77 +242,77 @@
 
             (or (:numeric-code-gte args)
                 (:numeric-code-lte args))
-            (merge-query {:query {:in    '[?from-numeric-code ?to-numeric-code]
+            (merge-query {:query {:in '[?from-numeric-code ?to-numeric-code]
                                   :where ['[?li :journal-entry-line/account ?a]
                                           '(or-join [?a ?c]
                                                     [?a :account/numeric-code ?c]
                                                     [?a :bank-account/numeric-code ?c])
                                           '[(>= ?c ?from-numeric-code)]
                                           '[(<= ?c ?to-numeric-code)]]}
-                          :args  [(or (:numeric-code-gte args) 0) (or (:numeric-code-lte args) 99999)]})
+                          :args [(or (:numeric-code-gte args) 0) (or (:numeric-code-lte args) 99999)]})
 
             (seq (:numeric-code args))
-            (merge-query {:query {:in    '[[[?from-numeric-code ?to-numeric-code] ...]]
+            (merge-query {:query {:in '[[[?from-numeric-code ?to-numeric-code] ...]]
                                   :where ['[?li :journal-entry-line/account ?a]
                                           '(or-join [?a ?c]
                                                     [?a :account/numeric-code ?c]
                                                     [?a :bank-account/numeric-code ?c])
                                           '[(>= ?c ?from-numeric-code)]
                                           '[(<= ?c ?to-numeric-code)]]}
-                          :args  [(map (juxt :from :to) (:numeric-code args))]})
+                          :args [(map (juxt :from :to) (:numeric-code args))]})
             (seq (:account args))
-            (merge-query {:query {:in    ['?a3]
+            (merge-query {:query {:in ['?a3]
                                   :where ['[?li :journal-entry-line/account ?a3]]}
-                          :args  [(:db/id (:account args))]})
+                          :args [(:db/id (:account args))]})
 
             (:amount-gte args)
-            (merge-query {:query {:in    ['?amount-gte]
+            (merge-query {:query {:in ['?amount-gte]
                                   :where ['[?e :journal-entry/amount ?a]
                                           '[(>= ?a ?amount-gte)]]}
-                          :args  [(:amount-gte args)]})
+                          :args [(:amount-gte args)]})
 
             (:amount-lte args)
-            (merge-query {:query {:in    ['?amount-lte]
+            (merge-query {:query {:in ['?amount-lte]
                                   :where ['[?e :journal-entry/amount ?a]
                                           '[(<= ?a ?amount-lte)]]}
-                          :args  [(:amount-lte args)]})
+                          :args [(:amount-lte args)]})
 
             (:db/id (:bank-account args))
-            (merge-query {:query {:in    ['?a]
+            (merge-query {:query {:in ['?a]
                                   :where ['[?li :journal-entry-line/account ?a]]}
-                          :args  [(:db/id (:bank-account args))]})
+                          :args [(:db/id (:bank-account args))]})
 
             (:account-id args)
-            (merge-query {:query {:in    ['?a2]
+            (merge-query {:query {:in ['?a2]
                                   :where ['[?e :journal-entry/line-items ?li2]
                                           '[?li2 :journal-entry-line/account ?a2]]}
-                          :args  [(:account-id args)]})
+                          :args [(:account-id args)]})
 
             (not-empty (:location args))
-            (merge-query {:query {:in    ['?location]
+            (merge-query {:query {:in ['?location]
                                   :where ['[?li :journal-entry-line/location ?location]]}
-                          :args  [(:location args)]})
+                          :args [(:location args)]})
 
             (not-empty (:locations args))
-            (merge-query {:query {:in    ['[?location ...]]
+            (merge-query {:query {:in ['[?location ...]]
                                   :where ['[?li :journal-entry-line/location ?location]]}
-                          :args  [(:locations args)]})
+                          :args [(:locations args)]})
 
-            (:sort args) (add-sorter-fields {"client"      ['[?e :journal-entry/client ?c]
-                                                            '[?c :client/name ?sort-client]]
-                                             "date"        ['[?e :journal-entry/date ?sort-date]]
-                                             "vendor"      '[(or-join  [?e ?sort-vendor]
-                                                                       (and
-                                                                        [?e :journal-entry/vendor ?v]
-                                                                        [?v :vendor/name ?sort-vendor])
-                                                                       (and [(missing?  $ ?e :journal-entry/vendor)]
-                                                                            [(ground "") ?sort-vendor]))]
-                                             "amount"      ['[?e :journal-entry/amount ?sort-amount]]
+            (:sort args) (add-sorter-fields {"client" ['[?e :journal-entry/client ?c]
+                                                       '[?c :client/name ?sort-client]]
+                                             "date" ['[?e :journal-entry/date ?sort-date]]
+                                             "vendor" '[(or-join [?e ?sort-vendor]
+                                                                 (and
+                                                                  [?e :journal-entry/vendor ?v]
+                                                                  [?v :vendor/name ?sort-vendor])
+                                                                 (and [(missing? $ ?e :journal-entry/vendor)]
+                                                                      [(ground "") ?sort-vendor]))]
+                                             "amount" ['[?e :journal-entry/amount ?sort-amount]]
                                              "external-id" ['[?e :journal-entry/external-id ?sort-external-id]]
-                                             "source"      '[(or-join [?e ?sort-source]
-                                                                      [?e :journal-entry/source ?sort-source]
-                                                                      (and [(missing?  $ ?e :journal-entry/source)]
-                                                                           [(ground "") ?sort-source]))]}
+                                             "source" '[(or-join [?e ?sort-source]
+                                                                 [?e :journal-entry/source ?sort-source]
+                                                                 (and [(missing? $ ?e :journal-entry/source)]
+                                                                      [(ground "") ?sort-source]))]}
                                             args)
 
             true
@@ -334,11 +341,11 @@
     :journal-entry/external-id
     :db/id
     [:journal-entry/date :xform clj-time.coerce/from-date]
-    {:journal-entry/vendor  [:vendor/name :db/id]
+    {:journal-entry/vendor [:vendor/name :db/id]
      :journal-entry/original-entity [:invoice/invoice-number
                                      :invoice/source-url
                                      :transaction/description-original :db/id]
-     :journal-entry/client     [:client/name :client/code :db/id]
+     :journal-entry/client [:client/name :client/code :db/id]
      :journal-entry/line-items [:journal-entry-line/debit
                                 :journal-entry-line/location
                                 :journal-entry-line/running-balance
@@ -362,8 +369,8 @@
 (defn sum-outstanding [ids]
 
   (->>
-   (dc/q {:find  ['?id '?o]
-          :in    ['$ '[?id ...]]
+   (dc/q {:find ['?id '?o]
+          :in ['$ '[?id ...]]
           :where ['[?id :invoice/outstanding-balance ?o]]}
          (dc/db conn)
          ids)
@@ -375,8 +382,8 @@
 (defn sum-total-amount [ids]
 
   (->>
-   (dc/q {:find  ['?id '?o]
-          :in    ['$ '[?id ...]]
+   (dc/q {:find ['?id '?o]
+          :in ['$ '[?id ...]]
           :where ['[?id :invoice/total ?o]]}
          (dc/db conn)
          ids)
@@ -386,7 +393,7 @@
     0.0)))
 
 (defn fetch-page [request]
-  (let [db                                           (dc/db conn)
+  (let [db (dc/db conn)
         {ids-to-retrieve :ids matching-count :count
          all-ids :all-ids} (fetch-ids db request)]
 
@@ -410,12 +417,12 @@
         (if account-name
           [:div {:x-tooltip (hx/json (str "Running Balance: " (some->> (:journal-entry-line/running-balance jel)
                                                                        (format "$%,.2f"))))}
-           [:div.text-left.underline.cursor-pointer  {:x-ref "source"}
+           [:div.text-left.underline.cursor-pointer {:x-ref "source"}
             (:journal-entry-line/location jel) ": "
             (or (:account/numeric-code account) (:bank-account/numeric-code account))
             " - " account-name]]
           [:div.text-left (com/pill {:color :yellow} "Unassigned")])
-        [:div.text-right.text-underline  (format "$%,.2f" (key jel))]))
+        [:div.text-right.text-underline (format "$%,.2f" (key jel))]))
 
      (when-not (= 1 (count lines))
        [:div.col-span-2 (com/pill {:color :primary} "Total: " (->> lines
@@ -443,9 +450,9 @@
                                                [:to nat-int?]]]]]
                             [:numeric-code-gte {:optional true} [:maybe nat-int?]]
                             [:numeric-code-lte {:optional true} [:maybe nat-int?]]
-                            [:vendor {:optional true :default nil} [:maybe  [:entity-map {:pull [:db/id :vendor/name]}]]]
-                            [:bank-account {:optional true :default nil} [:maybe  [:entity-map {:pull [:db/id :bank-account/name]}]]]
-                            [:account {:optional true :default nil} [:maybe  [:entity-map {:pull [:db/id :account/name]}]]]
+                            [:vendor {:optional true :default nil} [:maybe [:entity-map {:pull [:db/id :vendor/name]}]]]
+                            [:bank-account {:optional true :default nil} [:maybe [:entity-map {:pull [:db/id :bank-account/name]}]]]
+                            [:account {:optional true :default nil} [:maybe [:entity-map {:pull [:db/id :account/name]}]]]
                             [:check-number {:optional true} [:maybe [:string {:decode/string strip}]]]
                             [:invoice-number {:optional true} [:maybe [:string {:decode/string strip}]]]
                             [:status {:optional true} [:maybe (ref->enum-schema "invoice-status")]]
@@ -459,17 +466,20 @@
                              [:maybe clj-date-schema]]]]))
 
 (def grid-page
-  (helper/build {:id                 "entity-table"
-                 :nav                com/main-aside-nav
+  (helper/build {:id "entity-table"
+                 :nav com/main-aside-nav
                  :check-boxes? true
                  :check-box-warning? (fn [e]
                                        (some? (:invoice/scheduled-payment e)))
-                 :page-specific-nav  filters
-                 :fetch-page         fetch-page
+                 :page-specific-nav filters
+                 :fetch-page fetch-page
                  :oob-render
                  (fn [request]
-                   [(assoc-in (date-range-field* request) [1 :hx-swap-oob] true)
-                    (assoc-in (exact-match-id* request)  [1 :hx-swap-oob] true)])
+                   [(assoc-in (dr/date-range-field {:value {:start (:start-date (:query-params request))
+                                                            :end (:end-date (:query-params request))}
+                                                    :id "date-range"
+                                                    :apply-button? true}) [1 :hx-swap-oob] true)
+                    (assoc-in (exact-match-id* request) [1 :hx-swap-oob] true)])
                  :query-schema query-schema
                  :action-buttons (fn [request]
                                    [(when-not (:external? (:route-params request)) (com/button {:color :primary
@@ -485,7 +495,7 @@
                                                      :hx-confirm "Are you sure you want to void this invoice?"}
                                                     svg/trash))
                                  (when (and (can? (:identity request) {:subject :invoice :activity :edit})
-                                            (#{:invoice-status/unpaid  :invoice-status/paid} (:invoice/status entity)))
+                                            (#{:invoice-status/unpaid :invoice-status/paid} (:invoice/status entity)))
                                    (com/icon-button {:hx-put (bidi/path-for ssr-routes/only-routes
                                                                             ::route/edit-wizard
                                                                             :db/id (:db/id entity))}
@@ -497,14 +507,14 @@
                                                                             :db/id (:db/id entity))}
                                                     svg/undo))])
 
-                 :breadcrumbs        [[:a {:href (bidi/path-for ssr-routes/only-routes ::route/page)}
-                                       "Ledger"]]
-                 :title       (fn [r]
-                                (str
-                                 (some-> r :route-params :status name str/capitalize (str " "))
-                                 "Register"))
+                 :breadcrumbs [[:a {:href (bidi/path-for ssr-routes/only-routes ::route/page)}
+                                "Ledger"]]
+                 :title (fn [r]
+                          (str
+                           (some-> r :route-params :status name str/capitalize (str " "))
+                           "Register"))
                  :entity-name "register"
-                 :route       ::route/table
+                 :route ::route/table
                  :csv-route ::route/csv
                  :break-table (fn [request entity]
                                 (cond
@@ -521,102 +531,102 @@
                                        (for [je journal-entries
                                              jel (:journal-entry/line-items je)]
                                          (merge jel je)))
-                 :headers     [{:key      "id"
-                                :name     "Id"
-                                :render-csv :db/id
-                                :render-for #{:csv}}
-                               {:key      "client"
-                                :name     "Client"
-                                :sort-key "client"
-                                :hide?    (fn [args]
-                                            (and (= (count (:clients args)) 1)
-                                                 (= 1 (count (:client/locations (:client args))))))
-                                :render   (fn [x] [:div.flex.items-center.gap-2 (-> x :journal-entry/client :client/name)])
-                                :render-csv (fn [x] (-> x :journal-entry/client :client/name))}
+                 :headers [{:key "id"
+                            :name "Id"
+                            :render-csv :db/id
+                            :render-for #{:csv}}
+                           {:key "client"
+                            :name "Client"
+                            :sort-key "client"
+                            :hide? (fn [args]
+                                     (and (= (count (:clients args)) 1)
+                                          (= 1 (count (:client/locations (:client args))))))
+                            :render (fn [x] [:div.flex.items-center.gap-2 (-> x :journal-entry/client :client/name)])
+                            :render-csv (fn [x] (-> x :journal-entry/client :client/name))}
 
-                               {:key      "vendor"
-                                :name     "Vendor"
-                                :sort-key "vendor"
-                                :render   (fn [e] (or (-> e :journal-entry/vendor :vendor/name)
-                                                      [:span.italic.text-gray-400 (-> e :journal-entry/alternate-description)]))
-                                :render-csv   (fn [e] (or (-> e :journal-entry/vendor :vendor/name)
-                                                          (-> e :journal-entry/alternate-description)))}
-                               {:key      "source"
-                                :name     "Source"
-                                :sort-key "source"
-                                :hide?    (fn [args]
-                                            (not (:external? (:route-params args))))
-                                :render   :journal-entry/source
-                                :render-csv :journal-entry/source}
-                               {:key      "external-id"
-                                :name     "External Id"
-                                :sort-key "external-id"
-                                :class "max-w-[12rem]"
-                                :hide?    (fn [args]
-                                            (not (:external? (:route-params args))))
-                                :render   (fn [x] [:p.truncate (:journal-entry/external-id x)])
-                                :render-csv :journal-entry/external-id}
-                               {:key           "date"
-                                :sort-key "date"
-                                :name          "Date"
-                                :show-starting "lg"
-                                :render        (fn [{:journal-entry/keys [date]}]
-                                                 (some-> date (atime/unparse-local atime/normal-date)))}
-                               {:key           "amount"
-                                :sort-key "amount"
-                                :name          "Amount"
-                                :show-starting "lg"
-                                :render        (fn [{:journal-entry/keys [amount]}]
-                                                 (some->> amount
-                                                          (format "$%,.2f")))}
-                               {:key           "account"
-                                :name          "Account"
-                                :sort-key "account"
-                                :class "text-right"
-                                :render-csv #(or (-> % :journal-entry-line/account :account/name)
-                                                 (-> % :journal-entry-line/account :bank-account/name))
-                                :render-for #{:csv}}
-                               {:key           "debit"
-                                :name          "Debit"
-                                :class "text-right"
-                                :render        (partial render-lines :journal-entry-line/debit)
-                                :render-csv :journal-entry-line/debit}
+                           {:key "vendor"
+                            :name "Vendor"
+                            :sort-key "vendor"
+                            :render (fn [e] (or (-> e :journal-entry/vendor :vendor/name)
+                                                [:span.italic.text-gray-400 (-> e :journal-entry/alternate-description)]))
+                            :render-csv (fn [e] (or (-> e :journal-entry/vendor :vendor/name)
+                                                    (-> e :journal-entry/alternate-description)))}
+                           {:key "source"
+                            :name "Source"
+                            :sort-key "source"
+                            :hide? (fn [args]
+                                     (not (:external? (:route-params args))))
+                            :render :journal-entry/source
+                            :render-csv :journal-entry/source}
+                           {:key "external-id"
+                            :name "External Id"
+                            :sort-key "external-id"
+                            :class "max-w-[12rem]"
+                            :hide? (fn [args]
+                                     (not (:external? (:route-params args))))
+                            :render (fn [x] [:p.truncate (:journal-entry/external-id x)])
+                            :render-csv :journal-entry/external-id}
+                           {:key "date"
+                            :sort-key "date"
+                            :name "Date"
+                            :show-starting "lg"
+                            :render (fn [{:journal-entry/keys [date]}]
+                                      (some-> date (atime/unparse-local atime/normal-date)))}
+                           {:key "amount"
+                            :sort-key "amount"
+                            :name "Amount"
+                            :show-starting "lg"
+                            :render (fn [{:journal-entry/keys [amount]}]
+                                      (some->> amount
+                                               (format "$%,.2f")))}
+                           {:key "account"
+                            :name "Account"
+                            :sort-key "account"
+                            :class "text-right"
+                            :render-csv #(or (-> % :journal-entry-line/account :account/name)
+                                             (-> % :journal-entry-line/account :bank-account/name))
+                            :render-for #{:csv}}
+                           {:key "debit"
+                            :name "Debit"
+                            :class "text-right"
+                            :render (partial render-lines :journal-entry-line/debit)
+                            :render-csv :journal-entry-line/debit}
 
-                               {:key           "credit"
-                                :name          "Credit"
-                                :class "text-right"
-                                :render        (partial render-lines :journal-entry-line/credit)
-                                :render-csv :journal-entry-line/credit}
+                           {:key "credit"
+                            :name "Credit"
+                            :class "text-right"
+                            :render (partial render-lines :journal-entry-line/credit)
+                            :render-csv :journal-entry-line/credit}
 
-                               {:key           "links"
-                                :name          "Links"
-                                :show-starting "lg"
-                                :class "w-8"
-                                :render        (fn [i]
-                                                 (link-dropdown
-                                                  (cond-> []
-                                                    (-> i :journal-entry/original-entity :invoice/invoice-number)
-                                                    (conj
-                                                     {:link (hu/url (bidi/path-for ssr-routes/only-routes
-                                                                                   ::invoice-route/all-page)
-                                                                    {:exact-match-id (:db/id (:journal-entry/original-entity i))})
-                                                      :color :primary
-                                                      :content (format "Invoice '%s'" (-> i :journal-entry/original-entity :invoice/invoice-number))})
-                                                    (-> i :journal-entry/original-entity :invoice/source-url)
-                                                    {:link  (-> i :journal-entry/original-entity :invoice/source-url)
-                                                     :color :secondary
-                                                     :content (str "File")}
+                           {:key "links"
+                            :name "Links"
+                            :show-starting "lg"
+                            :class "w-8"
+                            :render (fn [i]
+                                      (link-dropdown
+                                       (cond-> []
+                                         (-> i :journal-entry/original-entity :invoice/invoice-number)
+                                         (conj
+                                          {:link (hu/url (bidi/path-for ssr-routes/only-routes
+                                                                        ::invoice-route/all-page)
+                                                         {:exact-match-id (:db/id (:journal-entry/original-entity i))})
+                                           :color :primary
+                                           :content (format "Invoice '%s'" (-> i :journal-entry/original-entity :invoice/invoice-number))})
+                                         (-> i :journal-entry/original-entity :invoice/source-url)
+                                         {:link (-> i :journal-entry/original-entity :invoice/source-url)
+                                          :color :secondary
+                                          :content (str "File")}
 
-                                                    (-> i :journal-entry/original-entity :transaction/description-original)
-                                                    (conj
-                                                     {:link (hu/url (bidi/path-for ssr-routes/only-routes
-                                                                                   ::transaction-routes/all-page)
-                                                                    {:exact-match-id (:db/id (:journal-entry/original-entity i))})
-                                                      :color :primary
-                                                      :content (format "Transaction '%s'" (-> i :journal-entry/original-entity :transaction/description-original))})
-                                                    (-> i :journal-entry/memo)
-                                                    (conj {:color :secondary
-                                                           :content (str "Memo: " (:journal-entry/memo i))}))))
-                                :render-for #{:html}}]}))
+                                         (-> i :journal-entry/original-entity :transaction/description-original)
+                                         (conj
+                                          {:link (hu/url (bidi/path-for ssr-routes/only-routes
+                                                                        ::transaction-routes/all-page)
+                                                         {:exact-match-id (:db/id (:journal-entry/original-entity i))})
+                                           :color :primary
+                                           :content (format "Transaction '%s'" (-> i :journal-entry/original-entity :transaction/description-original))})
+                                         (-> i :journal-entry/memo)
+                                         (conj {:color :secondary
+                                                :content (str "Memo: " (:journal-entry/memo i))}))))
+                            :render-for #{:html}}]}))
 
 (def row* (partial helper/row* grid-page))

src/clj/auto_ap/ssr/payments.clj

@@ -53,7 +53,7 @@
     [:div {:id "exact-match-id-tag"}]))
 
 (defn filters [request]
-  [:form#payment-filters {"hx-trigger"   "change delay:500ms, keyup changed from:.hot-filter delay:1000ms"
+  [:form#payment-filters {"hx-trigger"   "datesApplied, change delay:500ms, keyup changed from:.hot-filter delay:1000ms"
                           "hx-get"       (bidi/path-for ssr-routes/only-routes
                                                         ::route/table)
                           "hx-target"    "#entity-table"

src/clj/auto_ap/ssr/pos/cash_drawer_shifts.clj

@@ -29,7 +29,7 @@
                           default-grid-fields-schema)]))
 
 (defn filters [params]
-  [:form {"hx-trigger" "change delay:500ms, keyup changed from:.hot-filter delay:1000ms"
+  [:form {"hx-trigger" "datesApplied, change delay:500ms, keyup changed from:.hot-filter delay:1000ms"
           "hx-get" (bidi/path-for ssr-routes/only-routes
                                   :pos-cash-drawer-shift-table)
           "hx-target" "#cash-drawer-shift-table"

src/clj/auto_ap/ssr/pos/expected_deposits.clj

@@ -34,7 +34,7 @@
                           default-grid-fields-schema)]))
 
 (defn filters [request]
-  [:form {"hx-trigger" "change delay:500ms, keyup changed from:.hot-filter delay:1000ms"
+  [:form {"hx-trigger" "datesApplied, change delay:500ms, keyup changed from:.hot-filter delay:1000ms"
           "hx-get" (bidi/path-for ssr-routes/only-routes
                                   :pos-expected-deposit-table)
           "hx-target" "#expected-deposit-table"

src/clj/auto_ap/ssr/pos/refunds.clj

@@ -29,7 +29,7 @@
                            [:client {:optional true :default nil} [:maybe  [:entity-map {:pull [:db/id :client/name]}]]]]
                           default-grid-fields-schema)]))
 (defn filters [request]
-  [:form {"hx-trigger" "change delay:500ms, keyup changed from:.hot-filter delay:1000ms"
+  [:form {"hx-trigger" "datesApplied, change delay:500ms, keyup changed from:.hot-filter delay:1000ms"
           "hx-get" (bidi/path-for ssr-routes/only-routes
                                   :pos-refund-table)
           "hx-target" "#refund-table"

src/clj/auto_ap/ssr/pos/sales_orders.clj

@@ -34,7 +34,7 @@
                           default-grid-fields-schema)]))
 
 (defn filters [request]
-  [:form {"hx-trigger"         "change delay:500ms, keyup changed from:.hot-filter delay:1000ms"
+  [:form {"hx-trigger"         "datesApplied, change delay:500ms, keyup changed from:.hot-filter delay:1000ms"
           "hx-get"             (bidi/path-for ssr-routes/only-routes
                                               :pos-sales-table)
           "hx-target"          "#sales-table"

src/clj/auto_ap/ssr/pos/sales_summaries.clj

@@ -44,7 +44,7 @@
                           default-grid-fields-schema)]))
 
 (defn filters [request]
-  [:form {"hx-trigger" "change delay:500ms, keyup changed from:.hot-filter delay:1000ms"
+  [:form {"hx-trigger" "datesApplied, change delay:500ms, keyup changed from:.hot-filter delay:1000ms"
           "hx-get" (bidi/path-for ssr-routes/only-routes
                                   ::route/table)
           "hx-target" "#entity-table"

src/clj/auto_ap/ssr/pos/tenders.clj

@@ -22,7 +22,7 @@
 ;; always should be fast
 
 (defn filters [request]
-  [:form {"hx-trigger" "change delay:500ms, keyup changed from:.hot-filter delay:1000ms"
+  [:form {"hx-trigger" "datesApplied, change delay:500ms, keyup changed from:.hot-filter delay:1000ms"
           "hx-get" (bidi/path-for ssr-routes/only-routes
                                   :pos-tender-table)
           "hx-target" "#tender-table"

src/clj/auto_ap/ssr/selmer.clj

@@ -0,0 +1,43 @@
+(ns auto-ap.ssr.selmer
+  "Selmer rendering + the Hiccup<->Selmer interop bridge for the SSR form/wizard
+   migration (see .claude/skills/ssr-form-migration). Interactive, attribute-heavy
+   components render from Selmer templates with plain-HTML Alpine/HTMX attributes;
+   the bridge lets a Selmer template embed Hiccup output and lets a Selmer fragment
+   sit inside a Hiccup tree during the strangler transition.
+
+   Templates live under resources/templates/ and are referenced by classpath-relative
+   path, e.g. (render \"templates/components/typeahead.html\" ctx)."
+  (:require
+   [hiccup.util :as hu]
+   [hiccup2.core :as h2]
+   [selmer.parser :as selmer]))
+
+(defn hiccup->html
+  "Render a Hiccup form to an HTML string so it can be embedded in a Selmer
+   context value and emitted with the |safe filter: {{ frag|safe }}."
+  [hiccup]
+  (str (h2/html {} hiccup)))
+
+(defn raw
+  "Wrap an already-rendered HTML string (e.g. from `render`) so hiccup2 emits it
+   verbatim instead of escaping it. Use to drop a Selmer fragment into a Hiccup tree:
+   [:div (sel/raw (sel/render \"...\" ctx))]."
+  [^String html]
+  (hu/raw-string html))
+
+(defn render
+  "Render a Selmer template file (classpath-relative path) with `ctx`, returning an
+   HTML string. Hiccup values in `ctx` should be pre-rendered via `hiccup->html` and
+   referenced with |safe in the template."
+  [template ctx]
+  (selmer/render-file template ctx))
+
+(defn render-str
+  "Render a Selmer template given as a string (handy for tests/REPL)."
+  [template ctx]
+  (selmer/render template ctx))
+
+(defn render->hiccup
+  "Render a Selmer template file and wrap the result for safe embedding in Hiccup."
+  [template ctx]
+  (raw (render template ctx)))

src/clj/auto_ap/ssr/transaction.clj

@@ -19,6 +19,7 @@
                                            grid-page query-schema
                                            wrap-status-from-source]]
    [auto-ap.ssr.transaction.edit :as edit :refer [transaction-account-row*]]
+   [auto-ap.ssr.transaction.import :as t-import]
    [auto-ap.ssr.utils
     :refer [apply-middleware-to-all-handlers entity-id html-response
             many-entity modal-response percentage ref->enum-schema
@@ -101,6 +102,7 @@
 (def key->handler
   (merge edit/key->handler
          bulk-code/key->handler
+         t-import/key->handler
          (apply-middleware-to-all-handlers
           {::route/page              page
            ::route/approved-page (-> page (wrap-implied-route-param :status :transaction-approval-status/approved))

src/clj/auto_ap/ssr/transaction/common.clj

@@ -316,7 +316,7 @@
                                             :content (:bank-account/name ba)}))}))))])
 
 (defn filters [request]
-  [:form#transaction-filters {"hx-trigger"   "change delay:500ms, keyup changed from:.hot-filter delay:1000ms"
+  [:form#transaction-filters {"hx-trigger"   "datesApplied, change delay:500ms, keyup changed from:.hot-filter delay:1000ms"
                               "hx-get"       (bidi/path-for ssr-routes/only-routes
                                                             ::route/table)
                               "hx-target"    "#entity-table"

src/clj/auto_ap/ssr/transaction/edit.clj

@@ -42,6 +42,8 @@
    [iol-ion.tx :refer [random-tempid]]
    [malli.core :as mc]))
 
+(declare render-full-form)
+
 (def transaction-approval-status
   {:transaction-approval-status/unapproved "Unapproved"
    :transaction-approval-status/approved "Approved"
@@ -82,6 +84,7 @@
      [:transaction/vendor {:optional true} [:maybe entity-id]]
      [:transaction/approval-status {:optional true} [:maybe (ref->enum-schema "transaction-approval-status")]]
      [:amount-mode {:optional true} [:maybe [:enum "$" "%"]]]
+     [:mode {:optional true} [:maybe [:enum "simple" "advanced"]]]
      [:transaction/accounts {:optional true}
       [:maybe
        [:vector {:coerce? true}
@@ -221,22 +224,27 @@
                                     :name (fc/field-name)
                                     :x-model "simpleAccountId"})]))
            (fc/with-field :transaction-account/location
-             (com/validated-field
-              {:label "Location"
-               :errors (fc/field-errors)
-               :x-hx-val:account-id "simpleAccountId"
-               :hx-vals (hx/json (cond-> {:name (fc/field-name)}
-                                   client-id (assoc :client-id client-id)))
-               :x-dispatch:changed "simpleAccountId"
-               :hx-trigger "changed"
-               :hx-get (bidi/path-for ssr-routes/only-routes ::route/location-select)
-               :hx-target "find *"
-               :hx-swap "outerHTML"}
-              (location-select*
-               {:name (fc/field-name)
-                :account-location (:account/location account-id)
-                :client-locations (pull-attr (dc/db conn) :client/locations client-id)
-                :value location-val})))
+             ;; Selecting the account only affects the valid Location options, so the
+             ;; change swaps just this cell -- nothing else needs to re-render.
+             [:div {:id "simple-account-location"}
+              (com/validated-field
+               {:label "Location"
+                :errors (fc/field-errors)
+                :x-hx-val:account-id "simpleAccountId"
+                :hx-vals (hx/json (cond-> {:name (fc/field-name)}
+                                    client-id (assoc :client-id client-id)))
+                :x-dispatch:changed "simpleAccountId"
+                :hx-trigger "changed"
+                :hx-post (bidi/path-for ssr-routes/only-routes ::route/edit-form-changed)
+                :hx-target "#simple-account-location"
+                :hx-select "#simple-account-location"
+                :hx-swap "outerHTML"
+                :hx-include "closest form"}
+               (location-select*
+                {:name (fc/field-name)
+                 :account-location (:account/location account-id)
+                 :client-locations (pull-attr (dc/db conn) :client/locations client-id)
+                 :value location-val}))])
            (fc/with-field :transaction-account/amount
              (com/hidden {:name (fc/field-name)
                           :value total}))]]))
@@ -244,7 +252,8 @@
       [:a.text-sm.text-blue-600.hover:underline.cursor-pointer
        {:hx-post (bidi/path-for ssr-routes/only-routes ::route/edit-wizard-toggle-mode)
         :hx-include "closest form"
-        :hx-target "#manual-coding-section"
+        :hx-target "#wizard-form"
+        :hx-select "#wizard-form"
         :hx-swap "outerHTML"}
        "Switch to advanced mode"]]]))
 
@@ -256,9 +265,10 @@
       :advanced
       :simple)))
 
-(defn transaction-account-row* [{:keys [value client-id amount-mode total]}]
+(defn transaction-account-row* [{:keys [value client-id amount-mode total index]}]
   (com/data-grid-row
    (-> {:class "account-row"
+        :id (str "account-row-" index)
         :x-data (hx/json {:show (boolean (not (fc/field-value (:new? value))))
                           :accountId (fc/field-value (:transaction-account/account value))})
         :data-key "show"
@@ -278,7 +288,9 @@
                             :x-model "accountId"}))))
    (fc/with-field :transaction-account/location
      (com/data-grid-cell
-      {}
+      {:id (str "account-location-" index)}
+      ;; Selecting an account only affects this row's valid Location options, so the
+      ;; change swaps just this cell -- nothing else needs to re-render.
       (com/validated-field
        {:errors (fc/field-errors)
         :x-hx-val:account-id "accountId"
@@ -286,9 +298,11 @@
                             client-id (assoc :client-id client-id)))
         :x-dispatch:changed "accountId"
         :hx-trigger "changed"
-        :hx-get (bidi/path-for ssr-routes/only-routes ::route/location-select)
-        :hx-target "find *"
-        :hx-swap "outerHTML"}
+        :hx-post (bidi/path-for ssr-routes/only-routes ::route/edit-form-changed)
+        :hx-target (str "#account-location-" index)
+        :hx-select (str "#account-location-" index)
+        :hx-swap "outerHTML"
+        :hx-include "closest form"}
        (location-select* {:name (fc/field-name)
                           :account-location (:account/location (cond->> (:transaction-account/account @value)
                                                                  (nat-int? (:transaction-account/account @value)) (dc/pull (dc/db conn)
@@ -300,71 +314,29 @@
       {}
       (com/validated-field
        {:errors (fc/field-errors)}
-       (if (= "%" amount-mode)
-         (com/text-input {:name (fc/field-name)
-                          :class "w-16 account-amount-field"
-                          :value (fc/field-value)
-                          :type "number"
-                          :step "0.01"})
-         (com/money-input {:name (fc/field-name)
+       (let [amount-attrs {:name (fc/field-name)
+                           :id (str "account-amount-" index)
                            :class "w-16 account-amount-field"
-                           :value (fc/field-value)})))))
+                           :value (fc/field-value)
+                           :hx-post (bidi/path-for ssr-routes/only-routes ::route/edit-form-changed)
+                           ;; Typing an amount posts the whole form but swaps back only the
+                           ;; #account-totals tbody -- a sibling of the input-bearing rows, so
+                           ;; the amount input is never replaced and the caret survives.
+                           :hx-target "#account-totals"
+                           :hx-select "#account-totals"
+                           :hx-swap "outerHTML"
+                           :hx-trigger "keyup changed delay:300ms"
+                           :hx-include "closest form"}]
+         (if (= "%" amount-mode)
+           (com/text-input (assoc amount-attrs :type "number" :step "0.01"))
+           (com/money-input amount-attrs))))))
    (com/data-grid-cell {:class "align-top"}
-                       (com/a-icon-button {"@click.prevent.stop" "show=false; setTimeout(() => $refs.p.remove(), 500)"
-                                           :class "account-remove-action"} svg/x))))
-
-(defn- account-field-name [index field]
-  (str "step-params[transaction/accounts][" index "]["
-       (if (keyword? field)
-         (str (when (namespace field)
-                (str (namespace field) "/"))
-              (name field))
-         field)
-       "]"))
-
-(defn transaction-account-row-no-cursor* [{:keys [account index client-id amount-mode total]}]
-  (com/data-grid-row
-   (-> {:class "account-row"
-        :x-data (hx/json {:show true
-                          :accountId (:transaction-account/account account)})
-        :data-key "show"
-        :x-ref "p"}
-       hx/alpine-mount-then-appear)
-   (com/hidden {:name (account-field-name index :db/id)
-                :value (or (:db/id account) "")})
-   (com/data-grid-cell
-    {}
-    (com/validated-field
-     {}
-     (account-typeahead* {:value (:transaction-account/account account)
-                          :client-id client-id
-                          :name (account-field-name index :transaction-account/account)
-                          :x-model "accountId"})))
-   (com/data-grid-cell
-    {}
-    (com/validated-field
-     {}
-     (location-select* {:name (account-field-name index :transaction-account/location)
-                        :account-location (:account/location (cond->> (:transaction-account/account account)
-                                                               (nat-int? (:transaction-account/account account)) (dc/pull (dc/db conn)
-                                                                                                                          '[:account/location])))
-                        :client-locations (pull-attr (dc/db conn) :client/locations client-id)
-                        :value (:transaction-account/location account)})))
-   (com/data-grid-cell
-    {}
-    (com/validated-field
-     {}
-     (if (= "%" amount-mode)
-       (com/text-input {:name (account-field-name index :transaction-account/amount)
-                        :class "w-16 account-amount-field"
-                        :value (:transaction-account/amount account)
-                        :type "number"
-                        :step "0.01"})
-       (com/money-input {:name (account-field-name index :transaction-account/amount)
-                         :class "w-16 account-amount-field"
-                         :value (:transaction-account/amount account)}))))
-   (com/data-grid-cell {:class "align-top"}
-                       (com/a-icon-button {"@click.prevent.stop" "show=false; setTimeout(() => $refs.p.remove(), 500)"
+                       (com/a-icon-button {:hx-post (bidi/path-for ssr-routes/only-routes ::route/edit-wizard-remove-account)
+                                           :hx-vals (hx/json {:row-index (or index 0)})
+                                           :hx-target "#wizard-form"
+                                           :hx-select "#wizard-form"
+                                           :hx-swap "outerHTML"
+                                           :hx-include "closest form"
                                            :class "account-remove-action"} svg/x))))
 
 (defn location-select [{{:keys [name account-id client-id value] :as qp} :query-params}]
@@ -450,52 +422,52 @@
                                                                      :name "step-params[amount-mode]"
                                                                      :orientation :horizontal
                                                                      :hx-post (bidi/path-for ssr-routes/only-routes ::route/toggle-amount-mode)
-                                                                     :hx-target "#account-grid-body"
+                                                                     :hx-target "#wizard-form"
+                                                                     :hx-select "#wizard-form"
                                                                      :hx-swap "outerHTML"
                                                                      :hx-include "closest form"}))
-                              (com/data-grid-header {:class "w-16"})]}
-                   (fc/cursor-map #(transaction-account-row* {:value %
-                                                              :client-id (-> request :entity :transaction/client :db/id)
-                                                              :amount-mode amount-mode
-                                                              :total total}))
+                              (com/data-grid-header {:class "w-16"})]
+                    ;; Totals live in their own <tbody id="account-totals"> so the amount
+                    ;; field refreshes them with a plain targeted swap, never swapping the
+                    ;; input-bearing rows above (which would drop the caret).
+                    :footer-tbody
+                    [:tbody {:id "account-totals"}
+                     (com/data-grid-row {:class "account-total-row"}
+                                        (com/data-grid-cell {})
+                                        (com/data-grid-cell {:class "text-right"} [:span.font-bold.text-right "TOTAL"])
+                                        (com/data-grid-cell {:id "total"
+                                                             :class "text-right"}
+                                                            (account-total* request))
+                                        (com/data-grid-cell {}))
+                     (com/data-grid-row {:class "account-balance-row"}
+                                        (com/data-grid-cell {})
+                                        (com/data-grid-cell {:class "text-right"} [:span.font-bold.text-right "BALANCE"])
+                                        (com/data-grid-cell {:id "balance"
+                                                             :class "text-right"}
+                                                            (account-balance* request))
+                                        (com/data-grid-cell {}))
+                     (com/data-grid-row {:class "account-grand-total-row"}
+                                        (com/data-grid-cell {})
+                                        (com/data-grid-cell {:class "text-right"} [:span.font-bold.text-right "TRANSACTION TOTAL"])
+                                        (com/data-grid-cell {:class "text-right"}
+                                                            (format "$%,.2f" total))
+                                        (com/data-grid-cell {}))]}
+                   (fc/cursor-map (fn [cursor]
+                                    (transaction-account-row* {:value cursor
+                                                               :client-id (-> request :entity :transaction/client :db/id)
+                                                               :amount-mode amount-mode
+                                                               :total total
+                                                               :index (last (cursor/path cursor))})))
 
-                   (com/data-grid-new-row {:colspan 4
-                                           :hx-get (bidi/path-for ssr-routes/only-routes
-                                                                  ::route/edit-wizard-new-account)
-                                           :row-offset 0
-                                           :index (count (:transaction/accounts snapshot))
-                                           :tr-params {:hx-vals (hx/json {:client-id (:transaction/client snapshot)})}}
-                                          "New account")
-                   (com/data-grid-row {:class "account-total-row"}
-                                      (com/data-grid-cell {})
-                                      (com/data-grid-cell {:class "text-right"} [:span.font-bold.text-right "TOTAL"])
-                                      (com/data-grid-cell {:id "total"
-                                                           :class "text-right"
-                                                           :hx-trigger "change from:closest form target:.amount-field"
-                                                           :hx-put (bidi.bidi/path-for ssr-routes/only-routes ::route/account-total)
-                                                           :hx-target "this"
-                                                           :hx-swap "innerHTML"}
-                                                          (account-total* request))
-                                      (com/data-grid-cell {}))
-
-                   (com/data-grid-row {:class "account-balance-row"}
-                                      (com/data-grid-cell {})
-                                      (com/data-grid-cell {:class "text-right"} [:span.font-bold.text-right "BALANCE"])
-                                      (com/data-grid-cell {:id "total"
-                                                           :class "text-right"
-                                                           :hx-trigger "change from:closest form target:.amount-field"
-                                                           :hx-put (bidi.bidi/path-for ssr-routes/only-routes ::route/account-balance)
-                                                           :hx-target "this"
-                                                           :hx-swap "innerHTML"}
-                                                          (account-balance* request))
-                                      (com/data-grid-cell {}))
-
-                   (com/data-grid-row {:class "account-grand-total-row"}
-                                      (com/data-grid-cell {})
-                                      (com/data-grid-cell {:class "text-right"} [:span.font-bold.text-right "TRANSACTION TOTAL"])
-                                      (com/data-grid-cell {:class "text-right"}
-                                                          (format "$%,.2f" total))
-                                      (com/data-grid-cell {})))))
+                   (com/data-grid-row {:class "new-row"}
+                                      (com/data-grid-cell {:colspan 4}
+                                                          (com/a-button {:hx-post (bidi/path-for ssr-routes/only-routes ::route/edit-wizard-new-account)
+                                                                         :hx-target "#wizard-form"
+                                                                         :hx-select "#wizard-form"
+                                                                         :hx-swap "outerHTML"
+                                                                         :hx-include "closest form"
+                                                                         :color :secondary}
+                                                                        "New account"))))))
 
 (defn manual-coding-section*
   "Renders the vendor field + account/location section for the manual tab.
@@ -509,11 +481,13 @@
                          (seq (:transaction/accounts snapshot)))
         row-count (count all-accounts)]
     [:div#manual-coding-section
-     (com/hidden {:name "mode" :value (name mode)})
+     (com/hidden {:name "step-params[mode]" :value (name mode)})
      [:div {:hx-trigger "change"
             :hx-post (bidi/path-for ssr-routes/only-routes ::route/edit-vendor-changed)
-            :hx-target "#manual-coding-section"
+            :hx-target "#wizard-form"
+            :hx-select "#wizard-form"
             :hx-swap "outerHTML"
+            :hx-sync "this:replace"
             :hx-include "closest form"}
       (fc/with-field :transaction/vendor
         (com/validated-field
@@ -527,17 +501,18 @@
                           :value (fc/field-value)
                           :content-fn (fn [c] (pull-attr (dc/db conn) :vendor/name c))})]))]
      (if (= mode :simple)
-       [:div {:x-data (hx/json {:simpleAccountId
-                                (let [av (-> (first all-accounts) :transaction-account/account)]
-                                  (if (map? av) (:db/id av) av))})}
-        (simple-mode-fields* request)]
+       (let [simple-account-id (let [av (-> (first all-accounts) :transaction-account/account)]
+                                 (if (map? av) (:db/id av) av))]
+         [:div {:x-data (hx/json {:simpleAccountId simple-account-id})}
+          (simple-mode-fields* request)])
        [:div
         (when (<= row-count 1)
           [:div.mb-2
            [:a.text-sm.text-blue-600.hover:underline.cursor-pointer
             {:hx-post (bidi/path-for ssr-routes/only-routes ::route/edit-wizard-toggle-mode)
              :hx-include "closest form"
-             :hx-target "#manual-coding-section"
+             :hx-target "#wizard-form"
+             :hx-select "#wizard-form"
              :hx-swap "outerHTML"}
             "Switch to simple mode"]])
         (fc/with-field :transaction/accounts
@@ -556,59 +531,7 @@
                             (assoc-in [:multi-form-state :snapshot :transaction/accounts] accounts)
                             (assoc-in [:multi-form-state :snapshot :amount-mode] new-mode))]
     (html-response
-     [:div#account-grid-body
-      (com/data-grid {:headers [(com/data-grid-header {} "Account")
-                                (com/data-grid-header {:class "w-32"} "Location")
-                                (com/data-grid-header {:class "w-16"}
-                                                      (com/radio-card {:options [{:value "$" :content "$"}
-                                                                                 {:value "%" :content "%"}]
-                                                                       :value new-mode
-                                                                       :name "step-params[amount-mode]"
-                                                                       :orientation :horizontal
-                                                                       :hx-post (bidi/path-for ssr-routes/only-routes ::route/toggle-amount-mode)
-                                                                       :hx-target "#account-grid-body"
-                                                                       :hx-swap "outerHTML"
-                                                                       :hx-include "closest form"}))
-                                (com/data-grid-header {:class "w-16"})]}
-                     (map-indexed (fn [idx account]
-                                    (transaction-account-row-no-cursor*
-                                     {:account account
-                                      :index idx
-                                      :client-id (-> updated-request :entity :transaction/client :db/id)
-                                      :amount-mode new-mode
-                                      :total total}))
-                                  accounts)
-                     (com/data-grid-new-row {:colspan 4
-                                             :hx-get (bidi/path-for ssr-routes/only-routes
-                                                                    ::route/edit-wizard-new-account)
-                                             :row-offset 0
-                                             :index (count accounts)
-                                             :tr-params {:hx-vals (hx/json {:client-id (:transaction/client snapshot)})}}
-                                            "New account")
-                     (com/data-grid-row {}
-                                        (com/data-grid-cell {})
-                                        (com/data-grid-cell {:class "text-right"} [:span.font-bold.text-right "TOTAL"])
-                                        (com/data-grid-cell {:id "total"
-                                                             :class "text-right"}
-                                                            (format "$%,.2f" (double (reduce + 0.0 (map :transaction-account/amount accounts)))))
-                                        (com/data-grid-cell {}))
-                     (com/data-grid-row {}
-                                        (com/data-grid-cell {})
-                                        (com/data-grid-cell {:class "text-right"} [:span.font-bold.text-right "BALANCE"])
-                                        (com/data-grid-cell {:id "total"
-                                                             :class "text-right"}
-                                                            (let [account-total (double (reduce + 0.0 (map :transaction-account/amount accounts)))
-                                                                  balance (- total account-total)]
-                                                              [:span {:class (when-not (dollars= 0.0 balance)
-                                                                               "text-red-300")}
-                                                               (format "$%,.2f" (double balance))]))
-                                        (com/data-grid-cell {}))
-                     (com/data-grid-row {}
-                                        (com/data-grid-cell {})
-                                        (com/data-grid-cell {:class "text-right"} [:span.font-bold.text-right "TRANSACTION TOTAL"])
-                                        (com/data-grid-cell {:class "text-right"}
-                                                            (format "$%,.2f" total))
-                                        (com/data-grid-cell {})))])))
+     (render-full-form updated-request))))
 
 (defn transaction-details-panel [tx]
   [:div.p-4.space-y-4
@@ -616,7 +539,7 @@
    [:div.space-y-3
     [:div
      [:div.text-xs.font-medium.text-gray-500 "Amount"]
-     [:div.text-sm.font-medium.text-gray-900 (format "$%,.2f" (Math/abs (:transaction/amount tx)))]]
+     [:div.text-sm.font-medium.text-gray-900 (format "$%,.2f" (Math/abs (or (:transaction/amount tx) 0.0)))]]
     [:div
      [:div.text-xs.font-medium.text-gray-500 "Date"]
      [:div.text-sm.text-gray-900 (some-> tx :transaction/date coerce/to-date-time (atime/unparse-local atime/normal-date))]]
@@ -882,9 +805,13 @@
     #_(require-approval (mut/select-keys (mm/form-schema linear-wizard) #{:transaction/client :transaction/vendor :transaction/memo :transaction/approval-status :db/id}))
     (mm/form-schema linear-wizard))
 
-  (render-step [this {{:keys [snapshot] :as multi-form-state} :multi-form-state :as request}]
+  (render-step [this {{:keys [snapshot step-params] :as multi-form-state} :multi-form-state :as request}]
     (let [tx-id (mm/get-mfs-field multi-form-state :db/id)
-          tx (d-transactions/get-by-id tx-id)]
+          tx (d-transactions/get-by-id tx-id)
+          ;; Preserve explicit mode choice from step-params; only fall back to
+          ;; row-count heuristic on initial load when no mode has been chosen.
+          mode (keyword (or (:mode step-params)
+                            (name (manual-mode-initial snapshot))))]
       (mm/default-render-step
        linear-wizard this
        :head [:div.p-2 "Edit Transaction"]
@@ -898,8 +825,12 @@
                   {:label "Memo"
                    :errors (fc/field-errors)}
                   [:div.w-96
+                   ;; Memo affects nothing else, so it issues no request at all -- its
+                   ;; value just rides along in the form (posted with the next dependent
+                   ;; change, and merged into the snapshot on save).
                    (com/text-input {:value (-> (fc/field-value))
                                     :name (fc/field-name)
+                                    :id "edit-memo"
                                     :error? (fc/field-errors)
                                     :placeholder "Optional note"})]))
                [:div {:x-data (hx/json {:activeForm (if (:transaction/payment (:entity request))
@@ -950,7 +881,7 @@
                  (transaction-rules-view request)]
                 [:div {:x-show "activeForm === 'manual'", :x-transition:enter "transition ease-out duration-500", :x-transition:enter-start "opacity-0 transform scale-95", :x-transition:enter-end "opacity-100 transform scale-100"}
                  [:div {}
-                  (manual-coding-section* (manual-mode-initial snapshot) request)
+                  (manual-coding-section* mode request)
                   (fc/with-field :transaction/approval-status
                     (com/validated-field
                      {:label "Status"
@@ -1250,7 +1181,10 @@
   [{:as request
     transaction :entity
     :keys [multi-form-state]}]
-  (let [tx-data (-> multi-form-state :snapshot (dissoc :action))
+  (let [;; :mode is a UI-only field (simple/advanced); :action/:amount-mode are control
+        ;; fields. None are Datomic attributes, so strip them before building the upsert
+        ;; (otherwise :upsert-transaction fails with :db.error/not-an-entity :mode).
+        tx-data (-> multi-form-state :snapshot (dissoc :action :mode))
         tx-id (:db/id tx-data)
         client-id (->db-id (:transaction/client tx-data))
         existing-tx (d-transactions/get-by-id tx-id)
@@ -1382,7 +1316,8 @@
      :form-params
      (-> mm/default-form-props
          (assoc :hx-post
-                (str (bidi/path-for ssr-routes/only-routes ::route/edit-submit))))
+                (str (bidi/path-for ssr-routes/only-routes ::route/edit-submit))
+                :hx-ext "response-targets"))
      :render-timeline? false))
   (steps [_]
     [:links])
@@ -1425,14 +1360,29 @@
                    (fc/with-field :transaction/accounts
                      (account-grid-body* request)))))
 
+(defn render-full-form
+  "Helper to render the complete transaction edit form for whole-form re-rendering."
+  [request]
+  (mm/render-wizard edit-wizard request))
+
+(defn edit-form-changed-handler
+  "Generic handler that re-renders the whole form. Used when any field changes
+   and we need the server to re-compute dependent fields."
+  [request]
+  (html-response
+   (render-full-form request)))
+
 (defn edit-vendor-changed-handler [request]
   (let [multi-form-state (:multi-form-state request)
         snapshot (:snapshot multi-form-state)
         step-params (:step-params multi-form-state)
-        mode (keyword (or (:mode step-params) "simple"))
+        mode (keyword (or (:mode step-params)
+                          (get (:form-params request) "mode")
+                          "simple"))
         client-id (or (:transaction/client snapshot)
                       (-> request :entity :transaction/client :db/id))
-        vendor-id (or (:transaction/vendor step-params)
+        vendor-id (or (->db-id (:transaction/vendor step-params))
+                      (->db-id (get step-params "transaction/vendor"))
                       (:transaction/vendor snapshot))
         total (Math/abs (or (-> request :entity :transaction/amount)
                             (:transaction/amount snapshot)
@@ -1440,22 +1390,32 @@
         amount-mode (or (:amount-mode snapshot) "$")
         existing-accounts (or (seq (:transaction/accounts step-params))
                               (seq (:transaction/accounts snapshot)))
-        default-account (when (and (empty? existing-accounts) vendor-id client-id)
+        ;; The form always submits an account row (even when empty with account=nil),
+        ;; so we check if any row has a meaningful account ID.
+        has-meaningful-accounts? (some #(some? (:transaction-account/account %))
+                                       existing-accounts)
+        ;; Simple mode: always populate vendor default (overwrite existing).
+        ;; Advanced mode: populate only when 0 rows OR 1 empty row.
+        should-populate? (case mode
+                           :simple true
+                           :advanced (or (empty? existing-accounts)
+                                         (and (= 1 (count existing-accounts))
+                                              (not has-meaningful-accounts?))))
+        default-account (when (and should-populate? vendor-id client-id)
                           (vendor-default-account vendor-id client-id))
         render-request
-        (if (and (empty? existing-accounts) vendor-id client-id)
-          (let [new-account (cond-> {:db/id (str (java.util.UUID/randomUUID))
-                                     :transaction-account/location (or (:account/location default-account) "Shared")
-                                     :transaction-account/amount (if (= amount-mode "%") 100.0 total)}
-                              default-account (assoc :transaction-account/account (:db/id default-account)))]
-            (-> request
-                (assoc-in [:multi-form-state :snapshot :transaction/accounts] [new-account])
-                (assoc-in [:multi-form-state :step-params :transaction/accounts] [new-account])))
-          request)]
+        (-> (if (and should-populate? vendor-id client-id)
+              (let [new-account (cond-> {:db/id (str (java.util.UUID/randomUUID))
+                                         :transaction-account/location (or (:account/location default-account) "Shared")
+                                         :transaction-account/amount (if (= amount-mode "%") 100.0 total)}
+                                  default-account (assoc :transaction-account/account (:db/id default-account)))]
+                (-> request
+                    (assoc-in [:multi-form-state :snapshot :transaction/accounts] [new-account])
+                    (assoc-in [:multi-form-state :step-params :transaction/accounts] [new-account])))
+              request)
+            (assoc-in [:multi-form-state :step-params :transaction/vendor] vendor-id))]
     (html-response
-     (fc/start-form (:multi-form-state render-request) nil
-                    (fc/with-field :step-params
-                      (manual-coding-section* mode render-request))))))
+     (render-full-form render-request))))
 
 (defn edit-wizard-toggle-mode-handler [request]
   (let [step-params (-> request :multi-form-state :step-params)
@@ -1473,7 +1433,9 @@
                 (assoc-in [:multi-form-state :snapshot :transaction/accounts]
                           (vec accounts))
                 (assoc-in [:multi-form-state :step-params :transaction/accounts]
-                          (vec accounts))))
+                          (vec accounts))
+                (assoc-in [:multi-form-state :step-params :mode]
+                          (name target-mode))))
           ;; advanced→simple: take first row only
           (let [first-row (first (or (seq (:transaction/accounts step-params))
                                      (seq (:transaction/accounts snapshot))))]
@@ -1481,11 +1443,46 @@
                 (assoc-in [:multi-form-state :snapshot :transaction/accounts]
                           (if first-row [first-row] []))
                 (assoc-in [:multi-form-state :step-params :transaction/accounts]
-                          (if first-row [first-row] [])))))]
+                          (if first-row [first-row] []))
+                (assoc-in [:multi-form-state :step-params :mode]
+                          (name target-mode)))))]
     (html-response
-     (fc/start-form (:multi-form-state render-request) nil
-                    (fc/with-field :step-params
-                      (manual-coding-section* target-mode render-request))))))
+     (render-full-form render-request))))
+
+(defn edit-wizard-new-account-handler
+  "Adds a new account row and re-renders the whole form."
+  [request]
+  (let [snapshot (-> request :multi-form-state :snapshot)
+        amount-mode (or (:amount-mode snapshot) "$")
+        total (Math/abs (or (:transaction/amount snapshot) 0.0))
+        new-account {:db/id (str (java.util.UUID/randomUUID))
+                     :new? true
+                     :transaction-account/location "Shared"
+                     :transaction-account/amount (if (= amount-mode "%") 100.0 total)}
+        accounts (vec (or (:transaction/accounts snapshot) []))
+        updated-accounts (conj accounts new-account)
+        updated-request (-> request
+                            (assoc-in [:multi-form-state :snapshot :transaction/accounts] updated-accounts)
+                            (assoc-in [:multi-form-state :step-params :transaction/accounts] updated-accounts))]
+    (html-response
+     (render-full-form updated-request))))
+
+(defn edit-wizard-remove-account-handler
+  "Removes an account row and re-renders the whole form.
+   Expects a row-index in the form params."
+  [request]
+  (let [row-index (some-> request :form-params (get "row-index") Integer/parseInt)
+        snapshot (-> request :multi-form-state :snapshot)
+        accounts (vec (or (:transaction/accounts snapshot) []))
+        updated-accounts (if (and row-index (< row-index (count accounts)))
+                           (vec (concat (subvec accounts 0 row-index)
+                                        (subvec accounts (inc row-index))))
+                           accounts)
+        updated-request (-> request
+                            (assoc-in [:multi-form-state :snapshot :transaction/accounts] updated-accounts)
+                            (assoc-in [:multi-form-state :step-params :transaction/accounts] updated-accounts))]
+    (html-response
+     (render-full-form updated-request))))
 
 (def key->handler
   (apply-middleware-to-all-handlers
@@ -1524,6 +1521,10 @@
                                 (mm/wrap-wizard edit-wizard)
                                 (wrap-entity [:multi-form-state :snapshot :db/id] d-transactions/default-read)
                                 (mm/wrap-decode-multi-form-state))
+    ::route/edit-form-changed (-> edit-form-changed-handler
+                                  (mm/wrap-wizard edit-wizard)
+                                  (wrap-entity [:multi-form-state :snapshot :db/id] d-transactions/default-read)
+                                  (mm/wrap-decode-multi-form-state))
     ::route/toggle-amount-mode (-> toggle-amount-mode
                                    (mm/wrap-wizard edit-wizard)
                                    (wrap-entity [:multi-form-state :snapshot :db/id] d-transactions/default-read)
@@ -1532,22 +1533,14 @@
                                         (mm/wrap-wizard edit-wizard)
                                         (wrap-entity [:multi-form-state :snapshot :db/id] d-transactions/default-read)
                                         (mm/wrap-decode-multi-form-state))
-    ::route/edit-wizard-new-account (->
-                                     (add-new-entity-handler [:step-params :transaction/accounts]
-                                                             (fn render [cursor request]
-                                                               (let [snapshot (-> request :multi-form-state :snapshot)
-                                                                     amount-mode (or (:amount-mode snapshot) "$")
-                                                                     total (Math/abs (or (:transaction/amount snapshot) 0.0))]
-                                                                 (transaction-account-row*
-                                                                  {:value cursor
-                                                                   :client-id (:client-id (:query-params request))
-                                                                   :amount-mode amount-mode
-                                                                   :total total})))
-                                                             (fn build-new-row [base _]
-                                                               (assoc base :transaction-account/location "Shared")))
-                                     (wrap-schema-enforce :query-schema [:map
-                                                                         [:client-id {:optional true}
-                                                                          [:maybe entity-id]]]))
+    ::route/edit-wizard-new-account (-> edit-wizard-new-account-handler
+                                        (mm/wrap-wizard edit-wizard)
+                                        (wrap-entity [:multi-form-state :snapshot :db/id] d-transactions/default-read)
+                                        (mm/wrap-decode-multi-form-state))
+    ::route/edit-wizard-remove-account (-> edit-wizard-remove-account-handler
+                                           (mm/wrap-wizard edit-wizard)
+                                           (wrap-entity [:multi-form-state :snapshot :db/id] d-transactions/default-read)
+                                           (mm/wrap-decode-multi-form-state))
 
     ::route/unlink-payment (-> unlink-payment
                                (wrap-must {:activity :edit :subject :transaction} (fn get-client [request] (-> request :entity :transaction/client)))

src/clj/auto_ap/ssr/transaction/import.clj

@@ -0,0 +1,300 @@
+(ns auto-ap.ssr.transaction.import
+  "SSR manual bank-transaction import. Mirrors the SSR ledger import
+  (auto-ap.ssr.ledger) but accepts the exact master-branch Yodlee
+  positional-column TSV and drives the existing
+  auto-ap.import.transactions engine (via auto-ap.import.manual/import-batch)
+  unchanged. Two-stage flow: paste -> editable review grid -> import."
+  (:require
+   [auto-ap.datomic :refer [conn]]
+   [auto-ap.graphql.utils :refer [assert-admin]]
+   [auto-ap.import.manual :as manual]
+   [auto-ap.import.transactions :as t]
+   [auto-ap.permissions :refer [wrap-must]]
+   [auto-ap.routes.transactions :as route]
+   [auto-ap.routes.utils :refer [wrap-client-redirect-unauthenticated]]
+   [auto-ap.ssr-routes :as ssr-routes]
+   [auto-ap.ssr.components :as com]
+   [auto-ap.ssr.form-cursor :as fc]
+   [auto-ap.ssr.hx :as hx]
+   [auto-ap.ssr.nested-form-params :refer [wrap-nested-form-params]]
+   [auto-ap.ssr.ui :refer [base-page]]
+   [auto-ap.ssr.utils
+    :refer [apply-middleware-to-all-handlers html-response
+            wrap-form-4xx-2 wrap-schema-decode wrap-schema-enforce]]
+   [bidi.bidi :as bidi]
+   [clojure.data.csv :as csv]
+   [clojure.java.io :as io]
+   [clojure.string :as str]
+   [datomic.api :as dc]
+   [malli.core :as mc]
+   [slingshot.slingshot :refer [throw+]]))
+
+;; ---------------------------------------------------------------------------
+;; Parsing (positional Yodlee columns, identical to master)
+;; ---------------------------------------------------------------------------
+
+(defn tsv->rows
+  "Decode a pasted tab-separated Yodlee export into a vector of raw column
+  vectors. Drops the header row (like auto-ap.import.manual/tabulate-data) and
+  skips blank lines. No-op when already decoded."
+  [data]
+  (if (string? data)
+    (with-open [r (io/reader (char-array data))]
+      (into []
+            (comp (drop 1)
+                  (filter (fn [row] (some (fn [c] (seq (str/trim (or c "")))) row))))
+            (csv/read-csv r :separator \tab)))
+    data))
+
+(defn vector->row
+  "Map a raw column vector onto the master positional column keys."
+  [t]
+  (if (vector? t)
+    (into {} (filter first (map vector manual/columns t)))
+    t))
+
+(def parse-form-schema
+  (mc/schema
+   [:map
+    [:table {:min 1
+             :error/message "Paste should contain at least one row to import"
+             :decode/string tsv->rows}
+     [:vector {:coerce? true}
+      [:map {:decode/arbitrary vector->row}
+       [:status {:optional true} [:maybe :string]]
+       [:raw-date {:optional true} [:maybe :string]]
+       [:description-original {:optional true} [:maybe :string]]
+       [:high-level-category {:optional true} [:maybe :string]]
+       [:amount {:optional true} [:maybe :string]]
+       [:bank-account-code {:optional true} [:maybe :string]]
+       [:client-code {:optional true} [:maybe :string]]]]]]))
+
+;; ---------------------------------------------------------------------------
+;; Validation (two-tier, preserving every master validation)
+;; ---------------------------------------------------------------------------
+
+(defn- bank-account-code->client [db]
+  (into {} (dc/q '[:find ?bac ?c
+                   :where
+                   [?c :client/bank-accounts ?ba]
+                   [?ba :bank-account/code ?bac]]
+                 db)))
+
+(defn- bank-account-code->bank-account [db]
+  (into {} (dc/q '[:find ?bac ?ba
+                   :where [?ba :bank-account/code ?bac]]
+                 db)))
+
+(defn warn-message
+  "Map a non-:import engine categorization to a [message :warn] pair, or nil
+  when the row will import cleanly."
+  [action]
+  (case action
+    :extant    ["Already imported — skipped" :warn]
+    :not-ready ["Not ready (before account start date, client locked, or not posted) — skipped" :warn]
+    :suppressed ["Suppressed — skipped" :warn]
+    nil))
+
+(defn classify-table
+  "Given parsed row maps, return {:form-errors {:table {idx [[msg status]...]}}
+  :has-errors? bool}. Hard (fixable) errors come from
+  manual/manual->transaction; warnings come from the engine's own
+  categorize-transaction so the grid preview matches what the import will do."
+  [rows]
+  (let [db            (dc/db conn)
+        client-lookup (bank-account-code->client db)
+        ba-lookup     (bank-account-code->bank-account db)
+        indexed       (map-indexed
+                       (fn [i row]
+                         (assoc (manual/manual->transaction row ba-lookup client-lookup)
+                                ::idx i))
+                       rows)
+        with-ids      (t/apply-synthetic-ids indexed)
+        ba-cache      (atom {})
+        existing-cache (atom {})
+        entries       (->> with-ids
+                           (map (fn [txn]
+                                  (let [idx  (::idx txn)
+                                        hard (mapv (fn [e] [(:info e) :error]) (:errors txn))
+                                        warn (when (and (empty? hard)
+                                                        (:transaction/bank-account txn))
+                                               (let [ba-id (:transaction/bank-account txn)
+                                                     ba    (or (get @ba-cache ba-id)
+                                                               (get (swap! ba-cache assoc ba-id
+                                                                           (dc/pull db t/bank-account-pull ba-id))
+                                                                    ba-id))
+                                                     existing (or (get @existing-cache ba-id)
+                                                                  (get (swap! existing-cache assoc ba-id
+                                                                              (t/get-existing ba-id))
+                                                                       ba-id))]
+                                                 (warn-message (t/categorize-transaction txn ba existing))))]
+                                    [idx (cond-> hard warn (conj warn))])))
+                           (sort-by first))
+        form-errors   {:table (into {} (filter (fn [[_ errs]] (seq errs)) entries))}
+        has-errors?   (boolean (some (fn [[_ errs]] (some (fn [[_ s]] (= :error s)) errs)) entries))]
+    {:form-errors form-errors
+     :has-errors? has-errors?}))
+
+;; ---------------------------------------------------------------------------
+;; Views
+;; ---------------------------------------------------------------------------
+
+(defn- row-badge [errors]
+  (when (seq errors)
+    [:div.p-1.flex.flex-col.gap-1
+     (for [[m s] errors]
+       [:div.text-xs {:class (if (= :error s) "text-red-600" "text-yellow-600")} m])]))
+
+(defn- parsed-banner [request]
+  (let [errs   (->> (:form-errors request) :table vals (mapcat identity))
+        n-err  (count (filter (fn [[_ s]] (= :error s)) errs))
+        n-warn (count (filter (fn [[_ s]] (= :warn s)) errs))
+        n-rows (count (:table (:form-params request)))]
+    [:div.bg-green-50.text-green-700.rounded.p-3.my-2
+     (format "%,d rows parsed. " n-rows)
+     (when (pos? n-err)
+       [:span.text-red-700.font-semibold (format "%d error(s) must be fixed. " n-err)])
+     (when (pos? n-warn)
+       [:span.text-yellow-700.font-semibold (format "%d warning row(s) will be skipped. " n-warn)])]))
+
+(defn external-import-text-form* [request]
+  (fc/start-form
+   (or (:form-params request) {}) (:form-errors request)
+   [:form#parse-form {:hx-post   (bidi/path-for ssr-routes/only-routes ::route/external-import-parse)
+                      :hx-target "#forms"
+                      :hx-swap   "outerHTML"}
+    (fc/with-field :table
+      [:div.flex.flex-col.gap-2
+       (com/errors {:errors (when (string? (fc/field-errors)) (fc/field-errors))})
+       (com/text-area {:name        (fc/field-name)
+                       :rows        6
+                       :class       "w-full font-mono text-xs"
+                       :placeholder "Paste your Yodlee transaction export (tab-separated, including the header row) here"})])
+    (com/button {:color :primary :type "submit"} "Parse")]))
+
+(defn external-import-table-form* [request]
+  (fc/start-form
+   (:form-params request) (:form-errors request)
+   (fc/with-field :table
+     (when (seq (fc/field-value))
+       [:div.mt-4 {:x-data (hx/json {"showTable" true})}
+        (when (:just-parsed? request)
+          (parsed-banner request))
+        [:form {:hx-post      (bidi/path-for ssr-routes/only-routes ::route/external-import-import)
+                :hx-target    "#forms"
+                :hx-swap      "outerHTML"
+                :autocomplete "off"}
+         [:div.flex.gap-4.items-center.my-2
+          (com/checkbox {"@click" "showTable=!showTable"} "Show table")
+          (com/button {:color :primary :type "submit"} "Import")]
+         [:div {:x-show "showTable"}
+          (com/data-grid-card
+           {:id        "transaction-import-data"
+            :route     nil
+            :title     "Transactions to import"
+            :paginate? false
+            :headers   [(com/data-grid-header {} "Date")
+                        (com/data-grid-header {} "Description")
+                        (com/data-grid-header {} "Amount")
+                        (com/data-grid-header {} "Bank Account")
+                        (com/data-grid-header {} "Client")
+                        (com/data-grid-header {} "Status")
+                        (com/data-grid-header {} "")]
+            :rows
+            (fc/cursor-map
+             (fn [_]
+               (let [row-errors (fc/field-errors)]
+                 (com/data-grid-row
+                  {}
+                  (com/data-grid-cell {} (fc/with-field :raw-date
+                                           (com/text-input {:value (fc/field-value) :name (fc/field-name) :class "w-28"})))
+                  (com/data-grid-cell {} (fc/with-field :description-original
+                                           (com/text-input {:value (fc/field-value) :name (fc/field-name)})))
+                  (com/data-grid-cell {} (fc/with-field :amount
+                                           (com/money-input {:value (fc/field-value) :name (fc/field-name) :class "w-28"})))
+                  (com/data-grid-cell {} (fc/with-field :bank-account-code
+                                           (com/text-input {:value (fc/field-value) :name (fc/field-name) :class "w-28"})))
+                  (com/data-grid-cell {} (fc/with-field :client-code
+                                           (com/text-input {:value (fc/field-value) :name (fc/field-name) :class "w-24"})))
+                  (com/data-grid-cell {} [:span.text-xs.text-gray-500 (fc/with-field :status (fc/field-value))])
+                  (com/data-grid-cell {:class "align-top"} (row-badge row-errors))))))}
+           nil)]]]))))
+
+(defn external-import-form* [request]
+  [:div#forms
+   (external-import-text-form* request)
+   (external-import-table-form* request)])
+
+(defn external-import-page [request]
+  (base-page
+   request
+   (com/page {:nav              com/main-aside-nav
+              :client-selection (:client-selection request)
+              :clients          (:clients request)
+              :client           (:client request)
+              :identity         (:identity request)
+              :request          request}
+             (com/breadcrumbs {}
+                              [:a {:href (bidi/path-for ssr-routes/only-routes ::route/page)} "Transactions"]
+                              [:a {:href (bidi/path-for ssr-routes/only-routes ::route/external-import-page)} "Import"])
+             (external-import-form* request))
+   "Import Transactions"))
+
+;; ---------------------------------------------------------------------------
+;; Handlers
+;; ---------------------------------------------------------------------------
+
+(defn external-import-parse [request]
+  (let [{:keys [form-errors]} (classify-table (:table (:form-params request)))]
+    (html-response
+     (external-import-form* (assoc request :form-errors form-errors :just-parsed? true)))))
+
+(defn import-transactions
+  "Validate the (possibly edited) rows. Block the whole batch when any hard
+  error remains; otherwise run the existing import engine on the rows. Returns
+  the engine stats."
+  [request]
+  (assert-admin (:identity request))
+  (let [rows (:table (:form-params request))
+        {:keys [form-errors has-errors?]} (classify-table rows)]
+    (when has-errors?
+      (throw+ {:type :field-validation
+               :form-errors form-errors
+               :form-params (:form-params request)}))
+    (let [user (or (:user/name (:identity request))
+                   (:user (:identity request))
+                   "SSR import")]
+      (manual/import-batch rows user))))
+
+(defn external-import-import [request]
+  (let [stats (import-transactions request)
+        imported   (:import-batch/imported stats 0)
+        extant     (:import-batch/extant stats 0)
+        not-ready  (:import-batch/not-ready stats 0)
+        errored    (+ (:import-batch/error stats 0) (:failed-validation stats 0))]
+    (html-response
+     (external-import-form* (assoc request :form-params {} :form-errors {}))
+     :headers {"hx-trigger"
+               (hx/json {"notification"
+                         (format "%d imported, %d already imported, %d not ready, %d errored."
+                                 imported extant not-ready errored)})})))
+
+;; ---------------------------------------------------------------------------
+;; Routing
+;; ---------------------------------------------------------------------------
+
+(def key->handler
+  (apply-middleware-to-all-handlers
+   {::route/external-import-page  external-import-page
+    ::route/external-import-parse (-> external-import-parse
+                                      (wrap-schema-enforce :form-schema parse-form-schema)
+                                      (wrap-form-4xx-2 external-import-parse)
+                                      (wrap-schema-decode :form-schema parse-form-schema))
+    ::route/external-import-import (-> external-import-import
+                                       (wrap-schema-enforce :form-schema parse-form-schema)
+                                       (wrap-form-4xx-2 external-import-parse)
+                                       (wrap-nested-form-params))}
+   (fn [h]
+     (-> h
+         (wrap-must {:activity :import :subject :transaction})
+         (wrap-client-redirect-unauthenticated)))))

src/clj/auto_ap/ssr/ui.clj

@@ -5,13 +5,13 @@
    [hiccup2.core :as hiccup]
    [auto-ap.ssr.components :as com]))
 (defn html-page [hiccup]
-  {:status  200
+  {:status 200
    :headers {"Content-Type" "text/html"}
-   :body    (str
-             "<!DOCTYPE html>"
-             (hiccup/html
-              {}
-              hiccup))})
+   :body (str
+          "<!DOCTYPE html>"
+          (hiccup/html
+           {}
+           hiccup))})
 
 (defn base-page [request contents page-name]
   (html-page
@@ -23,14 +23,12 @@
      [:title (str "Integreat | " page-name)]
      [:link {:href "/css/font.min.css", :rel "stylesheet"}]
      [:link {:rel "icon" :type "image/png" :href "/favicon.png"}]
-     [:link {:rel "stylesheet" :href "//cdn.jsdelivr.net/chartist.js/latest/chartist.min.css"}]
-     [:script {:src "//cdn.jsdelivr.net/chartist.js/latest/chartist.min.js"}]
      [:link {:rel "stylesheet", :href "/output.css"}]
      [:script {:src "https://cdn.plaid.com/link/v2/stable/link-initialize.js"}]
      [:script {:src "https://cdn.jsdelivr.net/npm/@ryangjchandler/alpine-tooltip@1.x.x/dist/cdn.min.js" :defer true}]
      [:link {:rel "stylesheet" :href "/css/tippy/tippy.css"}]
      [:link {:rel "stylesheet" :href "/css/tippy/light.css"}]
-     [:script {:src          "/js/htmx.js"
+     [:script {:src "/js/htmx.js"
                :crossorigin= "anonymous"}]
 
      [:script {:src "https://cdn.jsdelivr.net/npm/sortablejs@1.15.2/Sortable.min.js"}]
@@ -43,7 +41,7 @@
     [:script {:src "https://cdnjs.cloudflare.com/ajax/libs/Chart.js/4.4.1/chart.umd.min.js" :integrity "sha512-CQBWl4fJHWbryGE+Pc7UAxWMUMNMWzWxF4SQo9CgkJIN1kx6djDQZjh3Y8SZ1d+6I+1zze6Z7kHXO7q3UyZAWw==" :crossorigin "anonymous" :referrerpolicy "no-referrer"}]
 
     [:script {:src "https://unpkg.com/dropzone@5.9.3/dist/min/dropzone.min.js" :defer true}]
-    [:link {:rel "stylesheet" :href "https://unpkg.com/dropzone@5/dist/min/dropzone.min.css"  :type "text/css" :defer true}]
+    [:link {:rel "stylesheet" :href "https://unpkg.com/dropzone@5/dist/min/dropzone.min.css" :type "text/css" :defer true}]
     [:script {:defer true :src "/js/alpine-vals.js"}]
     [:script {:defer true :src "https://cdn.jsdelivr.net/npm/@ryangjchandler/alpine-clipboard@2.x.x/dist/alpine-clipboard.js"}]
     [:script {:defer true :src "https://cdn.jsdelivr.net/npm/@alpinejs/focus@3.x.x/dist/cdn.min.js"}]
@@ -94,14 +92,14 @@ input[type=number] {
              "x-transition:leave-end" "!bg-opacity-0"}
 
        [:div {:class "flex h-full w-full justify-stretch md:justify-center items-stretch md:items-center  "
-              "x-trap.inert.noscroll"    "open"
-              "x-trap.inert"             "open"
-              "x-show"                   "open"
-              "x-transition:enter"       "ease-out duration-300"
+              "x-trap.inert.noscroll" "open"
+              "x-trap.inert" "open"
+              "x-show" "open"
+              "x-transition:enter" "ease-out duration-300"
               "x-transition:enter-start" "!bg-opacity-0 !translate-y-32"
-              "x-transition:enter-end"   "!bg-opacity-100 !translate-y-0"
-              "x-transition:leave"       "duration-300"
+              "x-transition:enter-end" "!bg-opacity-100 !translate-y-0"
+              "x-transition:leave" "duration-300"
               "x-transition:leave-start" "!opacity-100 !translate-y-0"
-              "x-transition:leave-end"   "!opacity-0 !translate-y-32"}
+              "x-transition:leave-end" "!opacity-0 !translate-y-32"}
 
         [:div#modal-content.flex.items-center.justify-center {:class "md:p-12"}]]]]]]))

src/clj/dev_mcp.clj

@@ -9,15 +9,29 @@
   (with-open [s (ServerSocket. 0)]
     (.getLocalPort s)))
 
-(defn- mcp-repl-task [& _args]
-  "Start nREPL server and HTTP server on random ports.
+(defn- read-port [path]
+  "Read a previously-recorded port from `path`, or nil if missing/unparseable."
+  (let [f (io/file path)]
+    (when (.exists f)
+      (try (Integer/parseInt (.trim ^String (slurp f)))
+           (catch Exception _ nil)))))
 
-  Writes ports to nrepl-port and .http-port files.
-  Connect with: clj-nrepl-eval -p $(cat nrepl-port)"
-  (let [nrepl-port (available-port)
-        http-port (available-port)]
-    (spit "nrepl-port" (str nrepl-port))
-    (spit ".http-port" (str http-port))
+(defn- stable-port [path]
+  "Reuse the port recorded in `path` if present, otherwise pick a random
+  available one. Always (re)writes the file so the port stays stable for this
+  worktree across REPL restarts and reloads."
+  (let [port (or (read-port path) (available-port))]
+    (spit path (str port))
+    port))
+
+(defn- mcp-repl-task [& _args]
+  "Start nREPL server and HTTP server.
+
+  Reuses the ports recorded in nrepl-port and .http-port if present (keeping
+  them stable per worktree), otherwise picks random available ports and records
+  them. Connect with: clj-nrepl-eval -p $(cat nrepl-port)"
+  (let [nrepl-port (stable-port "nrepl-port")
+        http-port (stable-port ".http-port")]
     (println (format "nREPL port: %d (nrepl-port)" nrepl-port))
     (println (format "HTTP port:  %d (.http-port)" http-port))
     (nrepl/start-server :port nrepl-port)

src/cljc/auto_ap/routes/transactions.cljc

@@ -33,7 +33,9 @@
              "/account-total" ::account-total
              "/account-balance" ::account-balance
              "/toggle-amount-mode" ::toggle-amount-mode
+             "/edit-form-changed" ::edit-form-changed
              "/edit-wizard-new-account" ::edit-wizard-new-account
+             "/edit-wizard-remove-account" ::edit-wizard-remove-account
              "/edit-wizard-toggle-mode" ::edit-wizard-toggle-mode
              "/match-payment" ::link-payment
              "/match-autopay-invoices" ::link-autopay-invoices

test/clj/auto_ap/ssr/selmer_test.clj

@@ -0,0 +1,36 @@
+(ns auto-ap.ssr.selmer-test
+  (:require
+   [auto-ap.ssr.selmer :as sut]
+   [clojure.string :as str]
+   [clojure.test :refer [deftest is testing]]
+   [hiccup2.core :as h2]))
+
+(deftest hiccup->html
+  (testing "renders a Hiccup form to an HTML string"
+    (is (= "<span class=\"label\">A &amp; B</span>"
+           (sut/hiccup->html [:span.label "A & B"])))))
+
+(deftest selmer-embeds-hiccup
+  (testing "a Hiccup component renders inside a Selmer template via |safe"
+    (let [frag (sut/hiccup->html [:span.badge "from hiccup"])
+          out  (sut/render-str "<div>{{frag|safe}}</div>" {:frag frag})]
+      (is (str/includes? out "<span class=\"badge\">from hiccup</span>"))
+      ;; without |safe the markup would be escaped; |safe keeps it verbatim
+      (is (not (str/includes? out "&lt;span"))))))
+
+(deftest selmer-fragment-inside-hiccup
+  (testing "a Selmer fragment renders inside a Hiccup tree without double-escaping"
+    (let [sel (sut/render-str "<a href=\"{{url}}\">{{label}}</a>" {:url "/x" :label "Go"})
+          out (str (h2/html {} [:div (sut/raw sel)]))]
+      (is (= "<div><a href=\"/x\">Go</a></div>" out)))))
+
+(deftest render-file-from-classpath
+  (testing "render-file resolves a template under resources/templates and keeps plain-HTML Alpine/HTMX attrs"
+    (let [out (sut/render "templates/interop-smoke.html"
+                          {:title "Interop OK"
+                           :hiccup_frag (sut/hiccup->html [:span.badge "from hiccup"])})]
+      (is (str/includes? out "Interop OK"))
+      (is (str/includes? out "from hiccup"))
+      ;; plain-HTML attributes (the whole point of Selmer) survive unambiguously
+      (is (str/includes? out "x-model=\"value.value\""))
+      (is (str/includes? out "tippy?.show()")))))

test/clj/auto_ap/ssr/transaction/edit_simple_advanced_mode_test.clj

@@ -5,12 +5,13 @@
    [auto-ap.solr]
    [auto-ap.ssr.components.multi-modal :as mm]
    [auto-ap.ssr.form-cursor :as fc]
-   [auto-ap.ssr.transaction.edit :refer [clientize-vendor
-                                         edit-vendor-changed-handler
-                                         edit-wizard-toggle-mode-handler
-                                         location-select*
-                                         manual-coding-section*
-                                         vendor-default-account]]
+   [auto-ap.ssr.transaction.edit
+    :refer [clientize-vendor
+            edit-vendor-changed-handler
+            edit-wizard-toggle-mode-handler
+            location-select*
+            manual-coding-section*
+            vendor-default-account]]
    [clojure.test :refer [deftest is testing use-fixtures]]
    [datomic.api :as dc]
    [hiccup.core :as hiccup]))
@@ -52,7 +53,7 @@
   (testing "AC3: multi-account (2+) transaction opens in advanced mode"
     (is (= :advanced (manual-mode-initial {:db/id 123
                                            :transaction/accounts [{:transaction-account/account 1}
-                                                                   {:transaction-account/account 2}]})))
+                                                                  {:transaction-account/account 2}]})))
     (is (= :advanced (manual-mode-initial {:db/id 123
                                            :transaction/accounts [{} {} {}]})))))
 
@@ -105,7 +106,7 @@
       (is (re-find #"Test Account" body)
           "Response should contain the vendor's default account name")))
 
-  (testing "AC5: vendor selection in simple mode does NOT overwrite already-set account"
+  (testing "AC5: vendor selection in simple mode DOES overwrite already-set account"
     (let [result @(dc/transact conn [{:db/id "vendor-id"
                                       :vendor/name "Test Vendor"}
                                      {:db/id "account-id"
@@ -126,9 +127,10 @@
                                       :transaction/client "client-id"}])
           tx-id (tempid->id result "transaction-id")
           vendor-id (tempid->id result "vendor-id")
+          account-id (tempid->id result "account-id")
           other-account-id (tempid->id result "other-account-id")
           client-id (tempid->id result "client-id")
-          ;; existing-accounts already set means vendor should NOT overwrite
+          ;; existing-accounts already set — but simple mode should still overwrite
           existing-accounts [{:db/id "row-id"
                               :transaction-account/account other-account-id
                               :transaction-account/location "DT"
@@ -149,12 +151,12 @@
       ;; The handler returns an html-response; verify the body is HTML
       (is (re-find #"manual-coding-section" body)
           "Response body should contain the manual-coding-section element")
-      ;; The original account ID must still appear in the rendered HTML
-      (is (re-find (re-pattern (str other-account-id)) body)
-          "Response should contain the original (pre-existing) account ID")
-      ;; The vendor's default account ID must NOT appear — it was not used
-      (is (not (re-find (re-pattern (str (tempid->id result "account-id"))) body))
-          "Response should NOT contain the vendor's default account ID when existing account is set"))))
+      ;; The vendor's default account SHOULD appear (overwriting previous)
+      (is (re-find (re-pattern (str account-id)) body)
+          "Vendor change in simple mode should overwrite with vendor's default account")
+      ;; The previous account should NOT appear
+      (is (not (re-find (re-pattern (str other-account-id)) body))
+          "Previous account should be replaced by vendor default"))))
 
 ;;; ---------------------------------------------------------------------------
 ;;; AC6: save round-trip — manual mode saves vendor + account to DB
@@ -163,18 +165,18 @@
 (deftest save-manual-round-trip-test
   (testing "AC6: save in simple mode persists vendor/account/location — re-opening shows same values"
     (let [result @(dc/transact conn [{:db/id "vendor-id"
-                                       :vendor/name "Save Vendor"}
-                                      {:db/id "account-id"
-                                       :account/name "Save Account"
-                                       :account/type :account-type/expense}
-                                      {:db/id "client-id"
-                                       :client/code "SAVECL"
-                                       :client/locations ["DT"]}
-                                      {:db/id "transaction-id"
-                                       :transaction/amount 100.0
-                                       :transaction/date #inst "2023-01-01"
-                                       :transaction/id (str (java.util.UUID/randomUUID))
-                                       :transaction/client "client-id"}])
+                                      :vendor/name "Save Vendor"}
+                                     {:db/id "account-id"
+                                      :account/name "Save Account"
+                                      :account/type :account-type/expense}
+                                     {:db/id "client-id"
+                                      :client/code "SAVECL"
+                                      :client/locations ["DT"]}
+                                     {:db/id "transaction-id"
+                                      :transaction/amount 100.0
+                                      :transaction/date #inst "2023-01-01"
+                                      :transaction/id (str (java.util.UUID/randomUUID))
+                                      :transaction/client "client-id"}])
           tx-id (tempid->id result "transaction-id")
           vendor-id (tempid->id result "vendor-id")
           account-id (tempid->id result "account-id")
@@ -934,3 +936,384 @@
       ;; Should NOT show 'Switch to simple mode'
       (is (not (re-find #"Switch to simple mode" html))
           "AC20: Simple mode should NOT show 'Switch to simple mode' link"))))
+
+;;; ---------------------------------------------------------------------------
+;;; Bug: vendor selection gets erased on vendor-changed HTMX response
+;;; ---------------------------------------------------------------------------
+
+(deftest vendor-selection-preserved-in-htmx-response-test
+  (testing "BUG: vendor selection should be preserved when HTMX re-renders the edit form"
+    (let [result @(dc/transact conn [{:db/id "vendor-id"
+                                      :vendor/name "Test Vendor"}
+                                     {:db/id "account-id"
+                                      :account/name "Existing Account"
+                                      :account/type :account-type/expense}
+                                     {:db/id "client-id"
+                                      :client/code "VENDORCL"
+                                      :client/locations ["DT"]}
+                                     {:db/id "transaction-id"
+                                      :transaction/amount 100.0
+                                      :transaction/date #inst "2023-01-01"
+                                      :transaction/id (str (java.util.UUID/randomUUID))
+                                      :transaction/client "client-id"}])
+          tx-id (tempid->id result "transaction-id")
+          vendor-id (tempid->id result "vendor-id")
+          account-id (tempid->id result "account-id")
+          client-id (tempid->id result "client-id")
+          ;; Simulate the request after middleware decoding.
+          ;; In production, form values arrive as strings. The middleware decodes
+          ;; step-params with keyword keys but leaves values as strings.
+          existing-accounts [{:db/id "row-1"
+                              :transaction-account/account account-id
+                              :transaction-account/location "DT"
+                              :transaction-account/amount 100.0}]
+          request {:multi-form-state (mm/->MultiStepFormState
+                                      {:db/id tx-id
+                                       :transaction/client client-id
+                                       :transaction/accounts existing-accounts}
+                                      []
+                                      {:mode "simple"
+                                       ;; This is how the vendor ID arrives from the form:
+                                       ;; as a string, not a long.
+                                       :transaction/vendor (str vendor-id)
+                                       :transaction/accounts existing-accounts})
+                   :entity {:db/id tx-id
+                            :transaction/client {:db/id client-id}
+                            :transaction/amount 100.0}}
+          ;; The handler should return a successful response with the vendor
+          ;; preserved. Currently it crashes because the string vendor-id is
+          ;; not converted to a long before being passed to Datomic.
+          response (try
+                     (edit-vendor-changed-handler request)
+                     (catch Exception e
+                       {:error e}))]
+      (is (not (:error response))
+          (str "BUG: String vendor-id from form submission should be converted to long. "
+               "Server crashes with: " (some-> response :error ex-message)))
+      (when-not (:error response)
+        (is (= 200 (:status response))
+            "Response should be successful")
+        (is (re-find #"Test Vendor" (:body response))
+            "Vendor name should appear in the HTMX response")
+        (is (re-find (re-pattern (str vendor-id)) (:body response))
+            "Vendor ID should be preserved in the response HTML")))))
+
+;;; ---------------------------------------------------------------------------
+;;; Bug: vendor change does not populate account
+;;; ---------------------------------------------------------------------------
+
+(deftest vendor-change-simple-mode-overwrites-test
+  (testing "BUG: vendor change in simple mode should overwrite existing account"
+    ;; When a vendor is changed in simple mode, it should always populate
+    ;; the vendor's default account, even if an account was already set.
+    (let [result @(dc/transact conn [{:db/id "vendor-id"
+                                      :vendor/name "Vendor With Default"}
+                                     {:db/id "vendor-account-id"
+                                      :account/name "Vendor Default Account"
+                                      :account/type :account-type/expense}
+                                     {:db/id "vendor-id"
+                                      :vendor/default-account "vendor-account-id"}
+                                     {:db/id "existing-account-id"
+                                      :account/name "Previously Selected Account"
+                                      :account/type :account-type/expense}
+                                     {:db/id "client-id"
+                                      :client/code "VENDORCL"
+                                      :client/locations ["DT"]}
+                                     {:db/id "transaction-id"
+                                      :transaction/amount 100.0
+                                      :transaction/date #inst "2023-01-01"
+                                      :transaction/id (str (java.util.UUID/randomUUID))
+                                      :transaction/client "client-id"}])
+          tx-id (tempid->id result "transaction-id")
+          vendor-id (tempid->id result "vendor-id")
+          vendor-account-id (tempid->id result "vendor-account-id")
+          existing-account-id (tempid->id result "existing-account-id")
+          client-id (tempid->id result "client-id")
+          ;; Simulate form state with an already-selected account (as the form submits)
+          existing-accounts [{:db/id "row-1"
+                              :transaction-account/account existing-account-id
+                              :transaction-account/location "DT"
+                              :transaction-account/amount 100.0}]
+          request {:multi-form-state (mm/->MultiStepFormState
+                                      {:db/id tx-id
+                                       :transaction/client client-id
+                                       :transaction/accounts existing-accounts}
+                                      []
+                                      {:mode "simple"
+                                       :transaction/vendor vendor-id
+                                       :transaction/accounts existing-accounts})
+                   :entity {:db/id tx-id
+                            :transaction/client {:db/id client-id}
+                            :transaction/amount 100.0}}
+          response (edit-vendor-changed-handler request)
+          body (:body response)]
+      ;; The vendor's default account SHOULD appear (overwriting the previous)
+      (is (re-find (re-pattern (str vendor-account-id)) body)
+          "BUG: Vendor change in simple mode should overwrite with vendor's default account")
+      ;; The previously selected account should NOT appear
+      (is (not (re-find (re-pattern (str existing-account-id)) body))
+          "Previously selected account should be replaced by vendor default")
+      (is (re-find #"Vendor Default Account" body)
+          "Vendor default account name should appear"))))
+
+(deftest vendor-change-advanced-mode-empty-row-test
+  (testing "BUG: vendor change in advanced mode should populate empty row"
+    ;; In advanced mode with 1 empty row, changing vendor should populate it
+    (let [result @(dc/transact conn [{:db/id "vendor-id"
+                                      :vendor/name "Vendor With Default"}
+                                     {:db/id "vendor-account-id"
+                                      :account/name "Vendor Default Account"
+                                      :account/type :account-type/expense}
+                                     {:db/id "vendor-id"
+                                      :vendor/default-account "vendor-account-id"}
+                                     {:db/id "client-id"
+                                      :client/code "ADVEMPTYCL"
+                                      :client/locations ["DT"]}
+                                     {:db/id "transaction-id"
+                                      :transaction/amount 100.0
+                                      :transaction/date #inst "2023-01-01"
+                                      :transaction/id (str (java.util.UUID/randomUUID))
+                                      :transaction/client "client-id"}])
+          tx-id (tempid->id result "transaction-id")
+          vendor-id (tempid->id result "vendor-id")
+          vendor-account-id (tempid->id result "vendor-account-id")
+          client-id (tempid->id result "client-id")
+          ;; Simulate advanced mode with 1 empty row (account=nil, as form submits)
+          empty-row [{:db/id "row-1"
+                      :transaction-account/account nil
+                      :transaction-account/location "Shared"
+                      :transaction-account/amount 100.0}]
+          request {:multi-form-state (mm/->MultiStepFormState
+                                      {:db/id tx-id
+                                       :transaction/client client-id
+                                       :transaction/accounts empty-row}
+                                      []
+                                      {:mode "advanced"
+                                       :transaction/vendor vendor-id
+                                       :transaction/accounts empty-row})
+                   :entity {:db/id tx-id
+                            :transaction/client {:db/id client-id}
+                            :transaction/amount 100.0}}
+          response (edit-vendor-changed-handler request)
+          body (:body response)]
+      ;; The vendor's default account SHOULD appear in the row
+      (is (re-find (re-pattern (str vendor-account-id)) body)
+          "BUG: Vendor change in advanced mode with empty row should populate it")
+      (is (re-find #"Vendor Default Account" body)
+          "Vendor default account name should appear in the row"))))
+
+(deftest vendor-change-advanced-mode-filled-row-test
+  (testing "AC15b: vendor change in advanced mode with filled row should NOT overwrite"
+    ;; In advanced mode with 1 row that already has an account selected,
+    ;; changing vendor should NOT overwrite it
+    (let [result @(dc/transact conn [{:db/id "vendor-id"
+                                      :vendor/name "Vendor With Default"}
+                                     {:db/id "vendor-account-id"
+                                      :account/name "Vendor Default Account"
+                                      :account/type :account-type/expense}
+                                     {:db/id "vendor-id"
+                                      :vendor/default-account "vendor-account-id"}
+                                     {:db/id "existing-account-id"
+                                      :account/name "Manually Selected Account"
+                                      :account/type :account-type/expense}
+                                     {:db/id "client-id"
+                                      :client/code "ADVFILLEDCL"
+                                      :client/locations ["DT"]}
+                                     {:db/id "transaction-id"
+                                      :transaction/amount 100.0
+                                      :transaction/date #inst "2023-01-01"
+                                      :transaction/id (str (java.util.UUID/randomUUID))
+                                      :transaction/client "client-id"}])
+          tx-id (tempid->id result "transaction-id")
+          vendor-id (tempid->id result "vendor-id")
+          vendor-account-id (tempid->id result "vendor-account-id")
+          existing-account-id (tempid->id result "existing-account-id")
+          client-id (tempid->id result "client-id")
+          ;; Advanced mode with 1 row that already has an account
+          filled-row [{:db/id "row-1"
+                       :transaction-account/account existing-account-id
+                       :transaction-account/location "DT"
+                       :transaction-account/amount 100.0}]
+          request {:multi-form-state (mm/->MultiStepFormState
+                                      {:db/id tx-id
+                                       :transaction/client client-id
+                                       :transaction/accounts filled-row}
+                                      []
+                                      {:mode "advanced"
+                                       :transaction/vendor vendor-id
+                                       :transaction/accounts filled-row})
+                   :entity {:db/id tx-id
+                            :transaction/client {:db/id client-id}
+                            :transaction/amount 100.0}}
+          response (edit-vendor-changed-handler request)
+          body (:body response)]
+      ;; The existing account should still be there
+      (is (re-find (re-pattern (str existing-account-id)) body)
+          "Existing account should remain when vendor changes in advanced mode with filled row")
+      ;; The vendor's default account should NOT appear
+      (is (not (re-find (re-pattern (str vendor-account-id)) body))
+          "Vendor default should NOT overwrite filled row in advanced mode"))))
+
+(deftest vendor-change-advanced-mode-two-rows-test
+  (testing "AC15c: vendor change in advanced mode with 2+ rows should NOT modify any"
+    ;; In advanced mode with 2 or more rows, vendor change should not touch any row
+    (let [result @(dc/transact conn [{:db/id "vendor-id"
+                                      :vendor/name "Vendor With Default"}
+                                     {:db/id "vendor-account-id"
+                                      :account/name "Vendor Default Account"
+                                      :account/type :account-type/expense}
+                                     {:db/id "vendor-id"
+                                      :vendor/default-account "vendor-account-id"}
+                                     {:db/id "account-1"
+                                      :account/name "Account One"
+                                      :account/type :account-type/expense}
+                                     {:db/id "account-2"
+                                      :account/name "Account Two"
+                                      :account/type :account-type/expense}
+                                     {:db/id "client-id"
+                                      :client/code "ADVTWOROWCL"
+                                      :client/locations ["DT"]}
+                                     {:db/id "transaction-id"
+                                      :transaction/amount 100.0
+                                      :transaction/date #inst "2023-01-01"
+                                      :transaction/id (str (java.util.UUID/randomUUID))
+                                      :transaction/client "client-id"}])
+          tx-id (tempid->id result "transaction-id")
+          vendor-id (tempid->id result "vendor-id")
+          vendor-account-id (tempid->id result "vendor-account-id")
+          account-1 (tempid->id result "account-1")
+          account-2 (tempid->id result "account-2")
+          client-id (tempid->id result "client-id")
+          ;; Advanced mode with 2 rows
+          two-rows [{:db/id "row-1"
+                     :transaction-account/account account-1
+                     :transaction-account/location "DT"
+                     :transaction-account/amount 50.0}
+                    {:db/id "row-2"
+                     :transaction-account/account account-2
+                     :transaction-account/location "DT"
+                     :transaction-account/amount 50.0}]
+          request {:multi-form-state (mm/->MultiStepFormState
+                                      {:db/id tx-id
+                                       :transaction/client client-id
+                                       :transaction/accounts two-rows}
+                                      []
+                                      {:mode "advanced"
+                                       :transaction/vendor vendor-id
+                                       :transaction/accounts two-rows})
+                   :entity {:db/id tx-id
+                            :transaction/client {:db/id client-id}
+                            :transaction/amount 100.0}}
+          response (edit-vendor-changed-handler request)
+          body (:body response)]
+      ;; Both existing accounts should remain
+      (is (re-find (re-pattern (str account-1)) body)
+          "First row account should remain")
+      (is (re-find (re-pattern (str account-2)) body)
+          "Second row account should remain")
+      ;; Vendor default should NOT appear
+      (is (not (re-find (re-pattern (str vendor-account-id)) body))
+          "Vendor default should NOT modify rows when 2+ exist"))))
+
+(deftest vendor-change-client-specific-override-test
+  (testing "BUG: vendor change should use client-specific account override if present"
+    ;; When a vendor has a client-specific account override, changing vendor
+    ;; should populate the client-specific account, not the global default.
+    (let [result @(dc/transact conn [{:db/id "global-account-id"
+                                      :account/name "Global Default"
+                                      :account/type :account-type/expense}
+                                     {:db/id "client-specific-account-id"
+                                      :account/name "Client Specific Account"
+                                      :account/type :account-type/expense}
+                                     {:db/id "client-id"
+                                      :client/code "CLIOVERRIDE"
+                                      :client/locations ["DT"]}
+                                     {:db/id "vendor-id"
+                                      :vendor/name "Clientized Vendor"
+                                      :vendor/default-account "global-account-id"
+                                      :vendor/account-overrides [{:vendor-account-override/client "client-id"
+                                                                  :vendor-account-override/account "client-specific-account-id"}]}])
+          vendor-id (tempid->id result "vendor-id")
+          client-id (tempid->id result "client-id")
+          global-account-id (tempid->id result "global-account-id")
+          client-specific-account-id (tempid->id result "client-specific-account-id")
+          ;; Simple mode with empty account row
+          empty-row [{:db/id "row-1"
+                      :transaction-account/account nil
+                      :transaction-account/location "Shared"
+                      :transaction-account/amount 100.0}]
+          request {:multi-form-state (mm/->MultiStepFormState
+                                      {:db/id 999999
+                                       :transaction/client client-id
+                                       :transaction/accounts empty-row}
+                                      []
+                                      {:mode "simple"
+                                       :transaction/vendor vendor-id
+                                       :transaction/accounts empty-row})
+                   :entity {:db/id 999999
+                            :transaction/client {:db/id client-id}
+                            :transaction/amount 100.0}}
+          response (edit-vendor-changed-handler request)
+          body (:body response)]
+      ;; The client-specific account should appear, not the global default
+      (is (re-find (re-pattern (str client-specific-account-id)) body)
+          "BUG: Vendor change should populate client-specific account override")
+      (is (re-find #"Client Specific Account" body)
+          "Client-specific account name should appear")
+      ;; The global default should NOT appear
+      (is (not (re-find (re-pattern (str global-account-id)) body))
+          "Global vendor default should NOT appear when client override exists"))))
+
+;;; Update AC5: simple mode SHOULD overwrite existing accounts
+(deftest vendor-change-simple-mode-overwrites-ac5-test
+  (testing "AC5 UPDATED: vendor selection in simple mode DOES overwrite already-set account"
+    (let [result @(dc/transact conn [{:db/id "vendor-id"
+                                      :vendor/name "Test Vendor"}
+                                     {:db/id "account-id"
+                                      :account/name "Test Account"
+                                      :account/type :account-type/expense}
+                                     {:db/id "vendor-id"
+                                      :vendor/default-account "account-id"}
+                                     {:db/id "other-account-id"
+                                      :account/name "Other Account"
+                                      :account/type :account-type/expense}
+                                     {:db/id "client-id"
+                                      :client/code "TESTCL2"
+                                      :client/locations ["DT"]}
+                                     {:db/id "transaction-id"
+                                      :transaction/amount 100.0
+                                      :transaction/date #inst "2023-01-01"
+                                      :transaction/id (str (java.util.UUID/randomUUID))
+                                      :transaction/client "client-id"}])
+          tx-id (tempid->id result "transaction-id")
+          vendor-id (tempid->id result "vendor-id")
+          account-id (tempid->id result "account-id")
+          other-account-id (tempid->id result "other-account-id")
+          client-id (tempid->id result "client-id")
+          ;; existing-accounts already set — but simple mode should still overwrite
+          existing-accounts [{:db/id "row-id"
+                              :transaction-account/account other-account-id
+                              :transaction-account/location "DT"
+                              :transaction-account/amount 100.0}]
+          request {:multi-form-state (mm/->MultiStepFormState
+                                      {:db/id tx-id
+                                       :transaction/client client-id
+                                       :transaction/accounts existing-accounts}
+                                      []
+                                      {:mode "simple"
+                                       :transaction/vendor vendor-id
+                                       :transaction/accounts existing-accounts})
+                   :entity {:db/id tx-id
+                            :transaction/client {:db/id client-id}
+                            :transaction/amount 100.0}}
+          response (edit-vendor-changed-handler request)
+          body (:body response)]
+      ;; The handler returns an html-response; verify the body is HTML
+      (is (re-find #"manual-coding-section" body)
+          "Response body should contain the manual-coding-section element")
+      ;; The vendor's default account SHOULD appear (overwriting previous)
+      (is (re-find (re-pattern (str account-id)) body)
+          "BUG: Vendor change in simple mode should overwrite with vendor's default account")
+      ;; The previous account should NOT appear
+      (is (not (re-find (re-pattern (str other-account-id)) body))
+          "Previous account should be replaced by vendor default"))))

test/clj/auto_ap/ssr/transaction/import_test.clj

@@ -0,0 +1,164 @@
+(ns auto-ap.ssr.transaction.import-test
+  (:require
+   [auto-ap.datomic :refer [conn]]
+   [auto-ap.integration.util :refer [admin-token setup-test-data test-bank-account
+                                     test-client wrap-setup]]
+   [auto-ap.ssr.transaction.import :as sut]
+   [auto-ap.ssr.utils :refer [main-transformer]]
+   [clojure.test :refer [deftest is testing use-fixtures]]
+   [datomic.api :as dc]
+   [malli.core :as mc]
+   [slingshot.slingshot :refer [try+]]))
+
+(use-fixtures :each wrap-setup)
+
+(defn- seed-client! []
+  (setup-test-data
+   [(test-client :db/id "import-client"
+                 :client/code "TEST"
+                 :client/locations ["DT"]
+                 :client/bank-accounts [(test-bank-account :db/id "import-ba"
+                                                           :bank-account/code "TEST-CHK")])]))
+
+(defn- txn-count []
+  (or (dc/q '[:find (count ?e) . :where [?e :transaction/id]] (dc/db conn)) 0))
+
+(defn- import! [rows]
+  (sut/import-transactions {:form-params {:table rows} :identity (admin-token)}))
+
+;; =============================================================================
+;; Pure parsing — tsv->rows, vector->row, parse-form-schema
+;; =============================================================================
+
+(deftest tsv->rows-test
+  (testing "Drops the header row and parses tab-separated columns"
+    (let [tsv "Status\tDate\tDescription\nPOSTED\t01/15/2024\tCoffee"
+          rows (sut/tsv->rows tsv)]
+      (is (= 1 (count rows)))
+      (is (= ["POSTED" "01/15/2024" "Coffee"] (first rows)))))
+  (testing "Skips blank lines"
+    (is (= 1 (count (sut/tsv->rows "h1\th2\nPOSTED\tx\n\t\n")))))
+  (testing "No-op on already-decoded data"
+    (is (= [{:raw-date "x"}] (sut/tsv->rows [{:raw-date "x"}])))))
+
+(deftest vector->row-test
+  (testing "Maps the exact master positional columns"
+    (let [row (sut/vector->row
+               ["POSTED" "01/15/2024" "Coffee" "Food" "" "" "12.50" "" "" "" "" "" "TEST-CHK" "TEST"])]
+      (is (= "POSTED" (:status row)))
+      (is (= "01/15/2024" (:raw-date row)))
+      (is (= "Coffee" (:description-original row)))
+      (is (= "12.50" (:amount row)))
+      (is (= "TEST-CHK" (:bank-account-code row)))
+      (is (= "TEST" (:client-code row))))))
+
+(deftest parse-form-schema-test
+  (testing "Decodes a pasted Yodlee TSV string into row maps"
+    (let [tsv (str "Status\tDate\tDescription\t\t\t\tAmount\t\t\t\t\t\tBank\tClient\n"
+                   "POSTED\t01/15/2024\tCoffee\tFood\t\t\t12.50\t\t\t\t\t\tTEST-CHK\tTEST")
+          decoded (mc/decode sut/parse-form-schema {:table tsv} main-transformer)]
+      (is (= 1 (count (:table decoded))))
+      (is (= "TEST-CHK" (:bank-account-code (first (:table decoded))))))))
+
+;; =============================================================================
+;; Validation — classify-table (hard errors + warnings, preserving master)
+;; =============================================================================
+
+(deftest classify-hard-errors-test
+  (seed-client!)
+  (testing "Unknown bank-account code is a hard error"
+    (let [{:keys [form-errors has-errors?]}
+          (sut/classify-table [{:raw-date "01/15/2024" :amount "1.00" :bank-account-code "NOPE"}])]
+      (is has-errors?)
+      (is (some (fn [[m _]] (re-find #"bank account" m)) (get-in form-errors [:table 0])))))
+
+  (testing "Unknown client fires independently when the bank account exists but is linked to no client"
+    @(dc/transact conn [{:db/id "orphan-ba"
+                         :bank-account/code "ORPHAN-CHK"
+                         :bank-account/type :bank-account-type/check}])
+    (let [{:keys [form-errors has-errors?]}
+          (sut/classify-table [{:raw-date "01/15/2024" :amount "1.00" :bank-account-code "ORPHAN-CHK"}])
+          msgs (map first (get-in form-errors [:table 0]))]
+      (is has-errors?)
+      (is (some #(re-find #"Cannot find client" %) msgs)
+          "client-not-found error fires")
+      (is (not (some #(re-find #"bank account by code" %) msgs))
+          "bank-account-not-found error does not fire because the bank account exists")))
+
+  (testing "Invalid date is a hard error"
+    (let [{:keys [form-errors has-errors?]}
+          (sut/classify-table [{:raw-date "not-a-date" :amount "1.00" :bank-account-code "TEST-CHK"}])]
+      (is has-errors?)
+      (is (some (fn [[m _]] (re-find #"(?i)mm/dd/yyyy|date" m)) (get-in form-errors [:table 0]))))))
+
+(deftest classify-clean-test
+  (seed-client!)
+  (testing "A fully valid row produces no errors or warnings"
+    (let [{:keys [form-errors has-errors?]}
+          (sut/classify-table [{:raw-date "01/15/2024" :description-original "Coffee"
+                                :amount "12.50" :bank-account-code "TEST-CHK" :client-code "TEST"}])]
+      (is (not has-errors?))
+      (is (empty? (get-in form-errors [:table 0]))))))
+
+(deftest classify-not-ready-warning-test
+  (testing "A date before the bank-account start-date is a (skippable) warning, not an error"
+    (setup-test-data
+     [(test-client :db/id "import-client"
+                   :client/code "TEST"
+                   :client/locations ["DT"]
+                   :client/bank-accounts [(test-bank-account :db/id "import-ba"
+                                                             :bank-account/code "TEST-CHK"
+                                                             :bank-account/start-date #inst "2030-01-01")])])
+    (let [{:keys [form-errors has-errors?]}
+          (sut/classify-table [{:raw-date "01/15/2024" :description-original "Early"
+                                :amount "5.00" :bank-account-code "TEST-CHK" :client-code "TEST"}])]
+      (is (not has-errors?) "warnings do not block")
+      (is (some (fn [[_ s]] (= :warn s)) (get-in form-errors [:table 0]))))))
+
+;; =============================================================================
+;; Import flow — import-transactions (engine reuse, block, idempotency, skip)
+;; =============================================================================
+
+(deftest import-clean-test
+  (seed-client!)
+  (testing "Clean rows import via the engine and persist"
+    (let [stats (import! [{:raw-date "01/15/2024" :description-original "Coffee"
+                           :amount "12.50" :bank-account-code "TEST-CHK" :client-code "TEST"}])]
+      (is (= 1 (:import-batch/imported stats)))
+      (is (= 1 (txn-count))))))
+
+(deftest import-blocks-on-hard-error-test
+  (seed-client!)
+  (testing "Any hard error blocks the whole batch — nothing is written"
+    (is (= :blocked
+           (try+
+            (import! [{:raw-date "01/15/2024" :amount "1.00" :bank-account-code "NOPE"}])
+            :did-not-throw
+            (catch [:type :field-validation] _ :blocked))))
+    (is (= 0 (txn-count)))))
+
+(deftest import-idempotent-test
+  (seed-client!)
+  (testing "Re-importing the same paste is idempotent (extant), no duplicates"
+    (let [row [{:raw-date "01/15/2024" :description-original "Coffee"
+                :amount "12.50" :bank-account-code "TEST-CHK" :client-code "TEST"}]]
+      (import! row)
+      (let [stats (import! row)]
+        (is (= 0 (:import-batch/imported stats)))
+        (is (= 1 (:import-batch/extant stats)))
+        (is (= 1 (txn-count)))))))
+
+(deftest import-skips-warning-rows-test
+  (testing "Warning rows (not-ready) are skipped, not imported, without blocking"
+    (setup-test-data
+     [(test-client :db/id "import-client"
+                   :client/code "TEST"
+                   :client/locations ["DT"]
+                   :client/bank-accounts [(test-bank-account :db/id "import-ba"
+                                                             :bank-account/code "TEST-CHK"
+                                                             :bank-account/start-date #inst "2030-01-01")])])
+    (let [stats (import! [{:raw-date "01/15/2024" :description-original "Early"
+                           :amount "5.00" :bank-account-code "TEST-CHK" :client-code "TEST"}])]
+      (is (= 0 (:import-batch/imported stats)))
+      (is (= 1 (:import-batch/not-ready stats)))
+      (is (= 0 (txn-count))))))

test/clj/auto_ap/test_server.clj

@@ -67,7 +67,7 @@
                                 [(assoc (test-client :db/id "client-id"
                                                      :client/code "TEST"
                                                      :client/locations ["DT"])
-                                        :client/bank-accounts [(test-bank-account :db/id "bank-account-id")])
+                                        :client/bank-accounts [(test-bank-account :db/id "bank-account-id" :bank-account/code "TEST-CHK")])
                                  (test-client :db/id "client-id-2"
                                               :client/code "TEST2"
                                               :client/locations ["NY"])
@@ -100,6 +100,9 @@
                                  {:db/id "vendor-id"
                                   :vendor/name "Test Vendor"
                                   :vendor/default-account "account-id"}
+                                 {:db/id "vendor-id-2"
+                                  :vendor/name "Second Vendor"
+                                  :vendor/default-account "account-id-2"}
                                  (test-transaction :db/id "transaction-id"
                                                    :transaction/client "client-id"
                                                    :transaction/bank-account "bank-account-id"
@@ -135,19 +138,19 @@
                                                :payment/status :payment-status/pending
                                                :payment/date #inst "2023-06-15")
                                   ;; Transaction and unpaid invoice for link testing
-                                  (test-transaction :db/id "transaction-id-unpaid"
-                                                    :transaction/client "client-id"
-                                                    :transaction/bank-account "bank-account-id"
-                                                    :transaction/amount -150.0
-                                                    :transaction/description-original "Transaction for unpaid invoice link"
-                                                    :transaction/approval-status :transaction-approval-status/unapproved)
-                                   (test-transaction :db/id "transaction-id-feedback"
-                                                     :transaction/client "client-id"
-                                                     :transaction/bank-account "bank-account-id"
-                                                     :transaction/amount 400.0
-                                                     :transaction/description-original "Transaction for feedback review"
-                                                     :transaction/approval-status :transaction-approval-status/requires-feedback)
-                                  (test-invoice :db/id "invoice-unpaid-id"
+                                 (test-transaction :db/id "transaction-id-unpaid"
+                                                   :transaction/client "client-id"
+                                                   :transaction/bank-account "bank-account-id"
+                                                   :transaction/amount -150.0
+                                                   :transaction/description-original "Transaction for unpaid invoice link"
+                                                   :transaction/approval-status :transaction-approval-status/unapproved)
+                                 (test-transaction :db/id "transaction-id-feedback"
+                                                   :transaction/client "client-id"
+                                                   :transaction/bank-account "bank-account-id"
+                                                   :transaction/amount 400.0
+                                                   :transaction/description-original "Transaction for feedback review"
+                                                   :transaction/approval-status :transaction-approval-status/requires-feedback)
+                                 (test-invoice :db/id "invoice-unpaid-id"
                                                :invoice/client "client-id"
                                                :invoice/vendor "vendor-id"
                                                :invoice/total 150.0
@@ -166,7 +169,8 @@
              :second-account (get tempids "account-id-2")
              :fixed-location-account (get tempids "account-id-fixed-loc")
              :ap-account (get tempids "ap-account-id")
-             :vendor (get tempids "vendor-id")})
+             :vendor (get tempids "vendor-id")
+             :vendor2 (get tempids "vendor-id-2")})
     (reset! test-client-ids
             {:test (get tempids "client-id")
              :test2 (get tempids "client-id-2")})