Prepare the 1.0.0 release (Phase G)

- Bump the version to 1.0.0 in package.json, Cargo.toml, tauri.conf.json and the Void template. Fingerprint goldens are unchanged. - Rewrite the README: features, data paths on Linux and Windows, backup and restore (backups contain the ERPNext API secret), bundled fonts and licences, font overrides, the ERPNext recipe, build and packaging commands, gates and known limitations. - Add docs/RELEASE.md with the release steps and a manual first-run checklist. - Void template: use a plain npm ci (the optional-dependency omit breaks vite and tsc), and note vendoring and that no OpenSSL is needed. Verified: build-xbps.sh builds voiced-1.0.0_1; it installs and removes cleanly in a clean void-glibc container with fonts, licences and fc-cache handling in place. The cross-compiled NSIS installer is 11.45 MiB and has not been run on Windows.
Verify the ERPNext integration live and fix the defects it found (Phase F4)
2026-10-04 23:56:32 +05:30 · 2026-10-04 22:09:03 +05:30 · 2026-10-04 20:57:31 +05:30 · 2026-10-04 20:33:45 +05:30 · 2026-10-04 19:50:24 +05:30
51 changed files with 11284 additions and 112 deletions
@@ -1,84 +1,181 @@
 # Voiced
-An offline-first desktop invoicing app for **Test Vendor**, built by **Bongbetic**.
+An offline-first GST invoicing desktop app for **Test Vendor**, built by **Bongbetic**.
-Voiced turns a few details into a clean, GST-ready PDF invoice. It keeps a running
+Voiced turns a few details into a clean, print-ready PDF invoice. It keeps a running invoice-number series in a
-invoice-number series in a local database, remembers your vendor and bank details, and
+local database, remembers your vendor, client and bank details, and works without an account or a network
-exports print-ready PDFs — no account, no network required.
+connection. The only optional network feature is the ERPNext push, which you configure yourself.
 Targets: Void Linux (xbps, WebKitGTK 2.50 or newer) and Windows 10/11 (NSIS installer, WebView2).
 ## Features
- **Automatic invoice numbering** — a persistent series (e.g. `INV/2026-001`) that keeps
+- **Invoices.** Automatic numbering in a persistent series (for example `INV/2026-001`) with a one-click new series,
-  counting up, with a one-click "start a new series" that resets the counter.
+  drafts, issue and cancel. An issued invoice is immutable: it stores a snapshot of the vendor, client, GST figures
- **Guided first-run setup** — your name, address, contact, PAN, GSTIN, logo, signature and
+  and layout. Line items are a fixed amount or rate x quantity (per second, minute, hour, session or unit), with
-  bank details, pre-filled from your existing invoice and editable at any time.
+  item presets.
- **Two line-item modes** — a fixed amount, or a rate × quantity where the unit can be per
+- **GST.** All money and tax maths is done in integer paise. CGST+SGST, IGST or UTGST follow from the supplier's
-  second / minute / hour / session / unit (e.g. 10 sessions × ₹2,500).
+  state and the place of supply, and a mismatch is rejected. An unregistered vendor gets a plain "Invoice" with no
- **GST support** — toggle taxes on/off and split as **CGST + SGST** (within state) or
+  tax. GSTIN, PAN, IFSC, email and phone are validated; amounts are written in Indian words.
-  **IGST** (inter-state), with live totals and Indian amount-in-words.
+- **Templates.** 14 templates: Voiced Standard (Classic) and 13 designs measured from reference originals (Linea,
- **Signatures** — attach a PNG/JPEG per invoice, or omit it and the invoice notes that it is
+  Monogram, Serenity, Crimson Grid, Tangerine Ledger, Slate Band, Teal Swoosh, Purple Pop, Citrus Split, Monolith,
-  computer-generated and needs no signature.
+  Cobalt Stripe, Marble, Highlighter). Your logo fills the template's logo slot; a few templates offer an opt-in
- **PDF export** — a print-ready A4 invoice styled to match the original `format.pdf`.
+  logo position. Specs are in `docs/templates/`.
- **Saved clients**, invoice history with re-export, and light/dark (Carbon g10/g100) themes.
+- **Page setup.** A4 or Letter, and margin presets (template, narrow 36 pt, normal 54 pt).
- **Input validation** for PAN, IFSC, GSTIN, email and phone.
+- **Export modes.** *Searchable* PDF (text layer kept) or *flattened* (pages rasterised at 300 DPI and rebuilt as
  an image-only PDF). Issued PDFs are archived by content hash, and "Original as issued" re-exports the exact
  archived bytes.
 - **Fonts.** 11 bundled font families (see "Fonts and licences"). The three commercial template faces (Now, Gotham,
  Open Sauce One) can be overridden with your own licensed files under Settings, Fonts.
 - **Clients and presets.** Saved clients with structured addresses, state and GST category; item presets.
 - **Payments.** Record payments against an issued invoice, including TDS deducted by the client. Outstanding
  balance is cash plus TDS against the invoice total.
 - **History.** Filterable invoice list, detail view with payments, and CSV or JSON export of the list.
 - **Backup and restore.** Manual and automatic daily backups of the database, assets, PDF archive and imported fonts.
 - **Export for other software.** `voiced.invoice.v1` JSON and line-item CSV for selected invoices
  (see `docs/voiced-invoice-v1.md`).
 - **ERPNext integration.** Push an invoice (as draft or submitted) with its PDF attached, and record payments, to an
  ERPNext v15 site.
 - Light and dark (Carbon g10/g100) themes.
 ## Tech stack
-| Layer     | Choice                                                              |
+| Layer   | Choice                                                                                      |
-| --------- | ------------------------------------------------------------------- |
+| ------- | ------------------------------------------------------------------------------------------- |
-| Shell     | [Tauri v2](https://v2.tauri.app/) (Rust core, WebView2 on Windows)  |
+| Shell   | [Tauri v2](https://v2.tauri.app/) (Rust core, WebKitGTK on Linux, WebView2 on Windows)      |
-| UI        | React + TypeScript + [IBM Carbon Design System](https://carbondesignsystem.com/) (`@carbon/react`) |
+| UI      | React 19 + TypeScript + [IBM Carbon](https://carbondesignsystem.com/) (`@carbon/react`)     |
-| Fonts     | IBM Plex, self-hosted (works offline)                               |
+| Storage | SQLite via `rusqlite` (bundled), numbered migrations                                        |
-| Storage   | SQLite via `rusqlite` (bundled)                                     |
+| PDF     | `@react-pdf/renderer` 4.9.0 in a Web Worker, pdf.js for preview and flattening              |
-| PDF       | `@react-pdf/renderer` with bundled IBM Plex                         |
+| ERPNext | `reqwest` with rustls (ring provider); all HTTP runs in Rust                                |
 ## Prerequisites
- **Node.js 20+** and npm
+- **Node.js 22** and npm
- **Rust** (stable) via [rustup](https://rustup.rs/)
+- **Rust** stable, via [rustup](https://rustup.rs/)
- Linux dev only: WebKitGTK 4.1, libsoup3, GTK3, librsvg, `pkg-config`, `clang`/`llvm`/`lld`
+- Linux only: WebKitGTK 4.1, libsoup3, GTK3, librsvg, `pkg-config`, `clang`/`llvm`/`lld`
 ## Development
 ```bash
 npm install
-npm run app:dev        # launches the desktop app with hot reload
+npm run app:dev        # tauri dev, served from localhost:1420 (does not exercise the tauri:// protocol)
 ```
-Other scripts:
+| Command | What it does |
 | --- | --- |
 | `npm run build` | `tsc --noEmit` and `vite build` (the type-check gate) |
 | `npm test` | `vitest run`, about 7 minutes; run on a quiet machine because load starves the sweep tests |
 | `npm run fonts:verify` | Checks the bundled fonts against `public/fonts/manifest.json` (`fonts:manifest` regenerates it) |
 | `npm run logo:measure` | Regenerates `src/pdf/templates/slots.generated.ts` from the reference PDFs; must be idempotent |
 | `npm run thumbnails` | Regenerates `public/templates/*.png` |
 | `npm run templates:compare` | reference vs Voiced side-by-side PNGs under `/tmp` |
 | `cargo test --manifest-path src-tauri/Cargo.toml` | Rust unit tests |
 | `npm run app:build` | Production build for the current platform (custom-protocol) |
-```bash
+The release procedure, including the manual first-run checklist, is in `docs/RELEASE.md`.
 npm run build          # type-check + build the web frontend
 npm run app:build      # package the app for the current platform
 ```
-## Building for Windows (cross-compile from Linux/macOS)
+## Where data lives
-Tauri only supports the MSVC target. Cross-compiling uses [`cargo-xwin`](https://github.com/rust-cross/cargo-xwin)
+The Tauri identifier is `com.bongbetic.voiced`. Voiced uses two directories, which differ only on Windows:
-and produces an **NSIS installer** plus a portable `.exe`. A `.msi` still requires a real
+
-Windows host.
+| What | Linux | Windows |
 | --- | --- | --- |
 | `app_data_dir`: database `voiced.db`, `assets/` (logos, signatures), `backups/` (`auto/`, `pre-restore-*`, pre-migration copies) | `~/.local/share/com.bongbetic.voiced/` | `%APPDATA%\com.bongbetic.voiced\` |
 | `app_local_data_dir`: `archive/<sha256>.pdf` (issued PDFs), `fonts/` (fonts you import) | `~/.local/share/com.bongbetic.voiced/` | `%LOCALAPPDATA%\com.bongbetic.voiced\` |
 On Linux `XDG_DATA_HOME` moves both. On Windows the archive and imported fonts stay out of the roaming profile so a
 growing archive and licensed font files are not copied between machines. The window size and position are kept by
 the window-state plugin in the app config directory (`~/.config/com.bongbetic.voiced/` on Linux).
 ## Backup and restore
 Settings, Data tab.
 - **Backup now** writes a zip: a consistent snapshot of `voiced.db`, `assets/`, `archive/`, `fonts/` and a
  `manifest.json` with a sha256 for every file.
 - **Automatic backup.** Once per calendar day, while the app is open, Voiced writes
  `backups/auto/voiced-auto-YYYYMMDD.zip` and keeps the newest 14.
 - **Restore** validates the zip (manifest, hashes, database integrity check) and stages it. Nothing live changes until
  the next start: use the "Restart" button or close and reopen the app. On that start the current database, assets,
  archive and fonts are moved to `backups/pre-restore-<timestamp>/` (a safety copy that is never pruned), then the
  restored files are moved in. If anything fails the app rolls back and starts on the old data. A backup from an
  older schema is migrated after restoring.
 - **Backups contain secrets.** The ERPNext API secret is stored in the SQLite database, so every backup (manual,
  automatic and pre-restore) holds it in plain form, together with your clients, invoices and bank details. Keep
  backup files on storage you trust, do not email or upload them casually, and rotate the ERPNext API key if a
  backup is lost.
 ## Fonts and licences
 Eleven families are bundled as static TTF files in `public/fonts/<family>/`, each with its `OFL.txt`: DM Sans,
 IBM Plex Mono, IBM Plex Sans, Inter, Jost, Lustria, Montserrat, Noto Sans Devanagari, Noto Sans Kannada, Open Sans
 and Poppins. All are under the SIL Open Font License 1.1. `public/fonts/manifest.json` lists every file with its
 hash and metrics, and `npm run fonts:verify` checks it. PDFs embed subsets, so the app never depends on system
 fonts.
 The Void package also installs these fonts system-wide under `/usr/share/fonts/voiced/<family>/` and each OFL text
 as `/usr/share/licenses/voiced/<family-folder>-OFL.txt`.
 **Now, Gotham and Open Sauce One** are not bundled. Voiced draws Now with Jost, Gotham with Montserrat and Open
 Sauce One with Poppins (Marble, Citrus Split and Purple Pop use these faces). If you hold a licence
 for the real fonts, import the files under Settings, Fonts (TTF, OTF or WOFF, one file per weight; WOFF2, variable
 and font-collection files are refused). Importing is your confirmation that your licence covers this use. The files
 are stored on this computer only, are included in backups, and issued invoices keep the fonts they were issued with.
 ## ERPNext integration
 Settings, Integrations. Verified live against ERPNext v15.121.6 (Frappe 15.121), with and without India Compliance
 15.32. v14 and v16 have not been tested.
 1. **Integration user.** In ERPNext create a dedicated user (type System User) with the roles **Accounts User** and
   **Sales User**. Open the user, Settings tab, API Access, Generate Keys, and copy the secret once. Accounts User
   covers invoices, payments and attachments; Sales User covers customers and addresses (Accounts User alone gets
   HTTP 403 on Customer). Do not use Administrator or System Manager keys. If you change roles, run
   `bench clear-cache`.
 2. **Rounding.** In ERPNext System Settings set Rounding Method to **Commercial Rounding**. ERPNext defaults to
   Banker's Rounding while Voiced rounds half-paise up, so some totals would differ by 1 paise. Voiced detects a
   mismatch after creating the draft, keeps it as a draft, never submits it, and names this fix.
 3. **Connect.** Enter the site address, API key and secret and run "Test connection". Use `https://` for real
   servers; plain `http://` is accepted only for `localhost`, `127.0.0.1`, `*.localhost` and `*.test`. The secret is
   never shown again, and it is not sent to a different server than the one it was saved for.
 4. **Company, accounts and units.** Pick the company, the output tax accounts (CGST, SGST, IGST), the bank account for
   payments and the unit-of-measure mapping from the loaded option lists.
 5. **Naming.** *Mirror* (default) names the ERPNext document with the Voiced number, which needs a site with API v2
   naming (Frappe 15.73 or newer). *Series* lets an ERPNext naming series name the document and puts the Voiced
   number in the remarks.
 6. **India Compliance.** Detected by the connection test. It requires a 6 or 8 digit HSN/SAC code on each row
   (checked at submit), limits document names to 16 characters (mirror mode checks this before posting), and Voiced
   always sends `is_reverse_charge` as 0 with a warning.
 Not covered: overseas and SEZ customers, multi-currency, reverse charge booked on RCM accounts, e-invoice and
 e-waybill, TLS-terminating proxies beyond plain HTTPS, and Windows. The live test setup is in
 `scripts/erpnext-e2e/README.md`.
 ## Building for Windows (NSIS, cross-compiled from Linux)
 Tauri supports only the MSVC target. [`cargo-xwin`](https://github.com/rust-cross/cargo-xwin) cross-compiles it
 and Tauri produces an **NSIS installer** (a `.msi` needs a real Windows host).
 ```bash
 # one-time setup
 rustup target add x86_64-pc-windows-msvc
 cargo install --locked cargo-xwin
-# plus NSIS (makensis), LLVM/LLD and clang on the host
+# plus makensis (NSIS), LLVM/LLD and clang on the host
-npm run app:build:windows
+npm run app:build:windows            # embeds the small WebView2 bootstrapper (needs internet if WebView2 is missing)
 npm run app:build:windows:offline    # embeds the full WebView2 runtime (over 100 MB larger), for offline machines
 ```
-Output lands in `src-tauri/target/x86_64-pc-windows-msvc/release/bundle/nsis/` and the
+Output: `src-tauri/target/x86_64-pc-windows-msvc/release/bundle/nsis/Voiced_<version>_x64-setup.exe`, and the portable
-portable binary in the sibling `release/` folder.
+binary in the sibling `release/` folder. The installer is a per-user install (`installMode: currentUser`). The
 frontend, fonts and pdf.js are compiled into the executable. Size budget: about 25 MB for the standard installer.
 `cargo tree -i aws-lc-sys --target x86_64-pc-windows-msvc` must print nothing (the TLS stack is rustls with the ring
 provider only, which cross-compiles cleanly).
-### Notes for Linux hosts without an `nsis` package
+Hosts without an `nsis` package (for example Void Linux):
-`makensis` is required for the installer, and Tauri also fetches a small NSIS plugin. On
+1. Provide `makensis` and put it on `PATH`.
-distributions that don't package NSIS (e.g. Void Linux):
+2. Point it at a full NSIS data directory (3.11 recommended, for `Win/RestartManager.nsh`) with `NSISDIR`.
 1. Provide `makensis` (e.g. extract it from your distribution's or an upstream package) and
   put it on `PATH`.
 2. Point `makensis` at a full NSIS data directory (3.11 recommended, for `Win/RestartManager.nsh`);
   it looks in the directory compiled into the binary unless `NSISDIR` is set.
 3. Pre-seed Tauri's plugin cache so it does not have to download it:
   ```
@@ -87,13 +184,10 @@ distributions that don't package NSIS (e.g. Void Linux):
   #   from https://github.com/tauri-apps/nsis-tauri-utils/releases
   ```
-With those in place, `npm run app:build:windows` produces the NSIS `-setup.exe` and the
+The installer has not been run on a real Windows machine.
 portable `voiced.exe`.
 ## Installing on Void Linux
 Two ways to get a native `.xbps` package.
 ### Prebuilt binary package (no xbps-src needed)
 ```bash
@@ -102,52 +196,91 @@ echo "repository=$(pwd)/build/void/repo" | sudo tee /etc/xbps.d/99-voiced-local.
 sudo xbps-install -Sy voiced
 ```
-Launch **Voiced** from the application menu, or run `voiced`. Remove it with
+The script runs `npx tauri build --no-bundle --features custom-protocol` (using your existing `node_modules`), stages
-`sudo xbps-remove voiced`.
+the install tree and runs `xbps-create` and `xbps-rindex`. Launch **Voiced** from the application menu or run
 `voiced`; remove it with `sudo xbps-remove voiced`.
-The package installs `/usr/bin/voiced`, a desktop entry and hicolor icons, and depends on
+The package installs `/usr/bin/voiced`, a desktop entry, hicolor icons, the bundled fonts under
-`libwebkit2gtk41`.
+`/usr/share/fonts/voiced/<family>/`, the OFL texts under `/usr/share/licenses/voiced/`, and `INSTALL` and `REMOVE`
-
+action scripts that run `fc-cache -f /usr/share/fonts/voiced` after install and removal. The `voiced/` font
-**Fonts on Void.** The package also installs the bundled TTF fonts under
+subdirectory avoids file conflicts with Void's `font-ibm-plex-ttf` and `noto-fonts-ttf`. It depends on
-`/usr/share/fonts/voiced/<family>/` and each family's OFL licence under
+`libwebkit2gtk41>=2.50`, `fontconfig`, `xdg-utils`, `hicolor-icon-theme` and `desktop-file-utils`.
 `/usr/share/licenses/voiced/`. The `voiced/` subdirectory avoids file conflicts with Void's own
 `font-ibm-plex-ttf` and `noto-fonts-ttf`. The `INSTALL` and `REMOVE` scripts in `packaging/void/`
 run `fc-cache -f /usr/share/fonts/voiced` after install and removal. `xbps-create` packs them from
 the destdir root (checked with xbps 0.60.7).
 ### Building through xbps-src
 Copy `packaging/void/template` into a `void-packages` checkout and build it the standard way:
 ```bash
 mkdir -p void-packages/srcpkgs/voiced
 cp packaging/void/template packaging/void/INSTALL packaging/void/REMOVE void-packages/srcpkgs/voiced/
 cd void-packages && ./xbps-src pkg voiced
 ```
-See the comments at the top of the template about the private source archive and checksums.
+`INSTALL` and `REMOVE` must sit next to the template; xbps-src packs them. The source is a tagged archive of the
-
+private repository (see the comments at the top of the template; `checksum=SKIP` until a tarball is published).
-## Where data lives
+xbps-src builds in a network-less chroot, so vendor the dependencies first: run `cargo vendor` in `src-tauri/` (with a
-
+`.cargo/config.toml` pointing at `vendor/`) and populate the npm cache, and include the results in the source
-| What                | Location                                                       |
+archive. The template runs `npm ci` (not `--omit=optional`: that removes
-| ------------------- | ------------------------------------------------------------- |
+the native rollup and esbuild binaries the Vite build needs, and `@napi-rs/canvas` is type-checked by `tsc`).
-| Database            | `<app-data>/voiced.db` — on Windows `%APPDATA%\com.bongbetic.voiced\` |
+No OpenSSL is needed (rustls), and the
-| Logos & signatures  | `<app-data>/assets/`                                          |
+dependencies of the ERPNext and backup code (`reqwest`, `zip`) are pure Rust.
 ## Project layout
 ```
-src/                 React + Carbon frontend
+src/                       React + Carbon frontend
-  views/             Onboarding · NewInvoice · InvoiceHistory · SeriesSettings · AppSettings
+  views/                   Onboarding, NewInvoice, InvoiceHistory, InvoiceDetail, Clients, AppSettings, SeriesSettings
-  components/        AppShell · InvoicePreview · ImagePicker
+  components/              AppShell, TemplatePicker, PageSetupControls, PdfPreview, LogoBranding,
-  pdf/               InvoiceDocument (react-pdf template)
+                           FontOverrideTable, DataBackupPanel, ErpnextSettingsPanel, RecordPaymentModal, ...
-  lib/               api · types · invoice · numberToWords · validators · format · pdf
+  hooks/                   Export, PDF preview, user fonts, shortcuts
-src-tauri/           Rust backend (Tauri commands, SQLite schema, asset store)
+  lib/                     Typed Tauri wrapper (api.ts), money, GST helpers, exportFlow, historyExport,
-public/brand/        Bongbetic + vendor brand assets
+                           invoiceExportV1, ERPNext UI helpers
-public/fonts/        IBM Plex (woff/woff2)
+  pdf/                     PDF engine
-packaging/void/      Void Linux packaging (xbps-src template + build script + desktop entry)
+    model/                 buildRenderModel (invoice -> render model)
    engine/                geometry (A4/Letter, margins), logo slots, layout fingerprint
    templates/             <family>/ with tokens.ts, plan.ts, Layout.tsx; registry.ts, catalog.ts, contract.ts
    blocks/ decor/         Shared layout blocks and decor
    fonts/                 Font registration, roles, glyph priming
    render/                renderCore, Web Worker, latest-wins client
    flatten.ts assemble.ts Rasterise at 300 DPI and rebuild an image-only PDF
 src-tauri/src/             Rust backend
  db.rs                    Schema as numbered migrations (copies the DB aside before migrating)
  gst.rs                   Integer-paise money and GST maths
  logo.rs                  Logo trimming, quantising, measuring
  commands/                Tauri commands: invoice, series, clients, payments, presets, settings, assets,
                           archive, fonts, backup, files, raw (binary IPC), erpnext, logo
  integrations/erpnext/    ERPNext client, mapping, discovery, push
  selftest.rs              Unattended real-webview self-test
 public/fonts/              Bundled TTF families, OFL texts, manifest.json (plus legacy IBM Plex web fonts)
 public/templates/          Template thumbnails
 docs/                      Template specs, voiced.invoice.v1, release checklist
 scripts/                   Font, logo, template, thumbnail and ERPNext end-to-end tooling
 packaging/void/            xbps-src template, build-xbps.sh, desktop entry, INSTALL and REMOVE scripts
 ```
 ## Tests and gates
 Before a release (details in `docs/RELEASE.md`): `npm run build`, `npm test`, `npm run fonts:verify`,
 `cargo test --manifest-path src-tauri/Cargo.toml`, and the real-webview self-test on a debug or installed build:
 ```bash
 npm run tauri -- build --debug --no-bundle --features custom-protocol
 VOICED_SELFTEST_OUT=/tmp/voiced-e2e/report.json XDG_DATA_HOME=/tmp/voiced-e2e/data \
  XDG_CONFIG_HOME=/tmp/voiced-e2e/config timeout 180 src-tauri/target/debug/voiced
 ```
 The app is inert unless `VOICED_SELFTEST_OUT` is set; `ok: true` is expected in the report. The same checks run from
 Settings, Diagnostics.
 ## Known limitations
 - Windows and WebView2 have never been run on a real machine; the NSIS installer is cross-compiled only.
 - The 13 reference-based templates are re-creations of reference designs. the reference design's content licence may restrict this, so
  ship them only in this vendor's build until it is confirmed.
 - The SAC code for the vendor's services and the signature rule still need confirmation from a chartered accountant.
 - Now, Gotham and Open Sauce One are replaced by free look-alikes unless you import licensed files.
 - ERPNext: only v15 is verified; HTTP is allowed only for local hosts; see "Not covered" above.
 - Not implemented (deferred): copies and watermarks, PDF/A, custom margins, user background textures, SVG logo
  import, CESS, composition and SEZ invoices.
 ## Ownership
 © Bongbetic. All rights reserved. This is a private application.
@@ -0,0 +1,91 @@
 # Release checklist
 Run from the repository root on a quiet machine, on a branch cut from `main`.
 ## 1. Version
 Keep these in step: `package.json` and the root entry of `package-lock.json`, `src-tauri/Cargo.toml` and
 `src-tauri/Cargo.lock` (`cargo update --offline -p voiced`), `src-tauri/tauri.conf.json`, and `version=` plus
 `revision=` in `packaging/void/template`. The PDF Creator string follows `package.json` (`src/lib/pdf.tsx`); layout
 fingerprints do not include it, so goldens stay unchanged.
 ## 2. Gates
 ```bash
 npm run build
 npm test                                   # about 7 minutes
 npm run fonts:verify
 cargo test --manifest-path src-tauri/Cargo.toml
 cargo tree -i aws-lc-sys --manifest-path src-tauri/Cargo.toml                                  # must not match
 cargo tree -i aws-lc-sys --manifest-path src-tauri/Cargo.toml --target x86_64-pc-windows-msvc  # must not match
 ```
 Real-webview self-test on the debug build:
 ```bash
 npm run tauri -- build --debug --no-bundle --features custom-protocol
 VOICED_SELFTEST_OUT=/tmp/voiced-e2e/report.json XDG_DATA_HOME=/tmp/voiced-e2e/data \
  XDG_CONFIG_HOME=/tmp/voiced-e2e/config timeout 180 src-tauri/target/debug/voiced
 ```
 `/tmp/voiced-e2e/report.json` must contain `"ok": true`. Repeat the same check on each installed build with
 Settings, Diagnostics.
 ## 3. Void package
 ```bash
 ./packaging/void/build-xbps.sh
 tar --zstd -tf build/void/repo/voiced-<version>_1.x86_64.xbps | less
 ```
 Expect `./usr/bin/voiced`, the desktop file, hicolor icons, `usr/share/fonts/voiced/<family>/*.ttf`,
 `usr/share/licenses/voiced/*-OFL.txt`, `./INSTALL` and `./REMOVE`. Then install it into a clean container:
 ```bash
 podman run --rm -v "$PWD/build/void/repo:/repo:Z" ghcr.io/void-linux/void-glibc-full sh -c '
  xbps-install -Syu xbps && xbps-install -y -R /repo voiced &&
  fc-list | grep -iE "montserrat|poppins|lustria|dm sans|inter|jost|open sans|ibm plex" &&
  ls /usr/share/licenses/voiced && ldd /usr/bin/voiced | grep "not found"; xbps-remove -y voiced'
 ```
 `ldd` must print no `not found` line, and `xbps-remove` must finish without errors. Optionally build with
 `xbps-src` in a `void-packages` checkout (see the README).
 ## 4. Windows installer
 ```bash
 npm run app:build:windows            # standard installer
 npm run app:build:windows:offline    # only for machines without internet
 ```
 Needs `cargo-xwin`, `makensis` and the NSIS plugin cache (README, "Building for Windows"). Check the size of
 `src-tauri/target/x86_64-pc-windows-msvc/release/bundle/nsis/*-setup.exe` against the budget of about 25 MB. Optional:
 sign it with `osslsigncode`. Never commit build outputs (`build/`, `dist/`, `src-tauri/target/`).
 ## 5. Manual first-run checklist (on a real machine, installed build, not `app:dev`)
 Linux and Windows. Windows has never been run on real hardware, so treat it as untested until this passes.
 - **Onboarding and Branding.** Complete first-run setup; upload a wide and a square logo, check the dark-theme
  wordmark and the signature.
 - **Template picker.** Open all 14 templates; switch A4 and Letter and the margin presets; check the logo slots.
 - **Export.** Issue an invoice; export searchable and flattened; change settings and re-export; "Original as issued"
  must be byte-identical to the archived PDF. On Windows, check file names with `/`, `:` and reserved names.
 - **Fonts.** Settings, Fonts: import a TTF for Now, Gotham or Open Sauce One (if a licensed file is at hand), confirm
  a template that uses it changes, remove it again.
 - **Clients.** Create a client with structured address and GST category; use it on an invoice.
 - **Settings tabs.** Business, Branding, Bank and payments, Invoice defaults, Numbering, Templates and export, Fonts,
  Data, Integrations: open each and save a change.
 - **History, detail and payments.** Filter the list; open an invoice; record a payment with TDS; cancel one; export
  CSV, JSON and `voiced.invoice.v1`.
 - **Data.** Backup now, change something, restore the backup, restart, confirm the data returned and that
  `backups/pre-restore-*` exists. Confirm the archive and fonts directories (Windows: under `%LOCALAPPDATA%`).
 - **Integrations.** Test connection and push an invoice to a test ERPNext (README, "ERPNext integration").
 - **Single instance.** Launch a second copy: the first window must come to the front.
 ## 6. Reference licence
 The 13 reference-based templates are re-creations of reference designs. the reference design's content licence may restrict that. Until it
 is confirmed in writing, distribute builds containing those templates only to this vendor. If the answer is no,
 remove the templates from `src/pdf/templates/registry.ts` and `catalog.ts` (Classic stays) and rebuild. Also still
 open: a chartered accountant's sign-off on the SAC code and the signature rule.
@@ -0,0 +1,51 @@
 # voiced.invoice.v1
 A neutral export of issued invoices for software Voiced has no direct integration with. Choose invoices in the
 History list (checkboxes) or open one, then use "Export selected (voiced.invoice.v1 JSON)" or "(line items CSV)".
 The code is `src/lib/invoiceExportV1.ts`; `src/lib/__golden__/invoice-v1.golden.json` is a full example.
 ## Rules
 - **Money is exact.** Every amount appears twice: `<name>_paise` (an integer) and `<name>` (a decimal string with two
  places, e.g. `"7310.10"`). Nothing is a float. Rates (percent) are decimal strings such as `"9"` or `"6.25"`.
 - **Deterministic.** The same invoices give the same bytes: fixed key order, no timestamps, input order kept.
 - **JSON file** is an array with one object per invoice; each object carries `"schema": "voiced.invoice.v1"`.
 - Cancelled invoices are included with `"cancelled": true` (their figures are kept; filter them out of sums).
 - An unregistered supplier's plain "Invoice" has `document_type: "invoice"`, all tax heads zero and no supplier GSTIN.
 ## Invoice object
 | Key | Meaning |
 | --- | --- |
 | `schema`, `number`, `issue_date`, `due_date` | `YYYY-MM-DD` dates; `due_date` is null when unset |
 | `document_type` | `tax_invoice` or `invoice` |
 | `status`, `cancelled`, `cancelled_at`, `cancel_reason` | `status` is `issued` or `cancelled` |
 | `currency`, `po_number` | always `INR` |
 | `supplier` | `name`, `address`, `gstin` (null if none), `pan`, `gst_registration`, `state {code, name}`; frozen at issue |
 | `client` | `name`, `gstin`, `gst_category`, `address {text, line1, line2, city, pincode, state}`, `place_of_supply {code, name}` |
 | `items[]` | `line`, `description`, `hsn_sac`, `quantity` (decimal string), `unit`, `rate`, `taxable_value` (each with `_paise`) |
 | `tax` | `cgst`, `sgst`, `utgst`, `igst`, each `{rate, amount_paise, amount}`; heads that do not apply are zero |
 | `totals` | `subtotal`, `discount`, `taxable_value`, `tax`, `total` (each with `_paise`), `amount_in_words` |
 | `reverse_charge`, `notes` | |
 | `payments[]` | `date`, `amount` (cash), `tds`, `mode`, `reference` (amounts with `_paise`) |
 Notes on the fields:
 - **Items.** `taxable_value` of a line is the line amount before the invoice-level discount. `totals.taxable_value` is
  `subtotal - discount`, the base the tax is charged on. A fixed-amount line has `quantity "1"` and `unit null`.
 - **UTGST.** When the supplier is in a union territory without a legislature (state codes 04, 26, 31, 35, 38) the second
  head is reported under `utgst` and `sgst` is zero.
 - **Client details.** The name, GSTIN, printed address and place of supply are frozen on the invoice. The structured
  address parts and `gst_category` come from the client's saved record at export time (null or derived from the GSTIN
  when the invoice has no saved client).
 - **Supplier snapshot.** Only name, address, GSTIN, PAN, registration and state are exported; logo paths, e-mail and
  phone are not.
 ## Line-items CSV
 One row per line item, UTF-8 with a byte order mark and CRLF line ends; text cells that a spreadsheet would read as a
 formula get a leading apostrophe. Columns: `invoice_number, issue_date, due_date, document_type, status, cancelled,
 currency, supplier_name, supplier_gstin, client_name, client_gstin, client_gst_category, place_of_supply_code,
 place_of_supply, reverse_charge, line, description, hsn_sac, quantity, unit, rate, taxable_value, invoice_discount,
 invoice_cgst, invoice_sgst, invoice_utgst, invoice_igst, invoice_total`. The `invoice_*` amounts are filled on the first
 row of each invoice only, so summing a column never counts an invoice twice.
@@ -1,12 +1,12 @@
 {
  "name": "voiced",
-  "version": "0.1.0",
+  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "voiced",
-      "version": "0.1.0",
+      "version": "1.0.0",
      "dependencies": {
        "@carbon/icons-react": "^11.89.0",
        "@carbon/react": "^1.117.0",
@@ -1,7 +1,7 @@
 {
  "name": "voiced",
  "private": true,
-  "version": "0.1.0",
+  "version": "1.0.0",
  "description": "Voiced — offline invoicing desktop app by Bongbetic",
  "type": "module",
  "author": "Bongbetic",
@@ -21,11 +21,14 @@
 #    not install them. Copy them next to the template (see the commands above).
 #    The stock x11-fonts trigger enabled by font_dirs does not run fc-cache
 #    unless mkfontdir and mkfontscale are installed, hence these scripts.
-#  * If the build machine is offline, pre-populate the npm cache and Cargo
+#  * xbps-src builds without network access: vendor the crates (`cargo vendor`
-#    registry in the masterdir before building.
+#    in src-tauri/ plus a .cargo/config.toml pointing at vendor/) and pre-populate
 #    the npm cache in the source archive or masterdir before building.
 #  * No openssl-devel: the ERPNext client uses rustls (ring); reqwest and zip are
 #    pure Rust and need no extra system libraries.
 #
 pkgname=voiced
-version=0.1.0
+version=1.0.0
 revision=1
 archs="x86_64*"
 hostmakedepends="rust nodejs pkg-config"
@@ -43,7 +46,10 @@ compression="zstd"
 font_dirs="/usr/share/fonts/voiced"
 do_build() {
-    npm install --include=dev --no-audit --no-fund
+    # Not --omit=optional: that also drops rollup's and esbuild's native binaries (they are
    # optional dependencies), so vite fails; and tsc in `npm run build` type-checks the
    # @napi-rs/canvas test helpers, so that package must be installed too.
    npm ci --no-audit --no-fund
    npm run build
    cd src-tauri
    # `custom-protocol` embeds the frontend for production; without it the app
@@ -0,0 +1,5 @@
 # frappe/erpnext v15 plus the india_compliance app (installed per site, not globally)
 FROM docker.io/frappe/erpnext:v15.121.6
 USER frappe
 RUN bench get-app --skip-assets --branch version-15 https://github.com/resilient-tech/india-compliance.git \
 && ls -1 apps > sites/apps.txt || true
@@ -0,0 +1,148 @@
 # ERPNext live end-to-end (podman)
 Runs Voiced's ERPNext integration against real ERPNext v15 sites: one plain site and one with India Compliance.
 Everything is rootless podman (`podman` and `podman-compose`, never docker). All names are prefixed `voiced-erp`.
 | File | Purpose |
 |---|---|
 | `compose.yml` | Lean stack: MariaDB, one Redis, backend (gunicorn on `127.0.0.1:8088`), one worker. Project name `voiced-erp`. |
 | `Containerfile.ic` | `frappe/erpnext:v15.121.6` plus the `india_compliance` app files (`version-15` branch). |
 | `setup.sh` | Builds the image, starts the stack, creates both sites, prepares them, writes `.env.a` and `.env.b`. |
 | `setup_site.py` | Runs inside the container: company, accounts, address, items, integration user and keys. |
 | `../../src-tauri/src/integrations/erpnext/live_tests.rs` | The `#[ignore]` Rust tests. |
 ## Reproduce
 ```bash
 cd scripts/erpnext-e2e
 ./setup.sh            # first run pulls ~2 GB of images and takes about 10 minutes
 ```
 `setup.sh` creates two sites that one backend serves by Host header:
 | Site | URL | Contents | Env file |
 |---|---|---|---|
 | `127.0.0.1` | `http://127.0.0.1:8088` | ERPNext only | `.env.a` |
 | `localhost` | `http://localhost:8088` | ERPNext + India Compliance | `.env.b` |
 Both get the company "Voiced Test Co" (abbreviation `VTC`, INR, India, fiscal year 2026-27), the output tax accounts
 `Output Tax CGST|SGST|UTGST|IGST - VTC` (India Compliance creates its own with the same names), `TDS Receivable - VTC`,
 the bank account `HDFC - VTC`, a company address, the UOMs Hour/Minute/Second, the items `VOICED-SERVICE` (stock UOM Nos)
 and `VOICED-HOURLY` (stock UOM Hour), and an integration user with a fresh API key and secret.
 `.env.*` files hold those keys; they are git-ignored (`.env.*` in the root `.gitignore`) and must never be committed.
 Run the Rust tests (they only touch the site named by the sourced env file):
 ```bash
 set -a; . scripts/erpnext-e2e/.env.a; set +a      # or .env.b for the India Compliance site
 cargo test --manifest-path src-tauri/Cargo.toml live_ -- --ignored --test-threads=1
 ```
 Environment variables the tests read:
 | Variable | Meaning |
 |---|---|
 | `ERPNEXT_URL`, `ERPNEXT_KEY`, `ERPNEXT_SECRET` | Site address and the integration user's API key and secret. |
 | `ERPNEXT_COMPANY` (`Voiced Test Co`), `ERPNEXT_ABBR` (`VTC`) | Company; account names derive from the abbreviation. |
 | `ERPNEXT_IC` | `1` on the India Compliance site; the `live_ic_*` tests skip themselves otherwise. |
 | `ERPNEXT_ROUNDING` | `banker` (ERPNext default) or `commercial`; decides what the half-paise test expects. |
 | `ERPNEXT_BANK_ACCOUNT` (`HDFC - VTC`) | Account that receives payments. |
 Each test builds its own in-memory Voiced database and a fresh invoice series (`L<time><n>/001`), so reruns never collide
 with documents from earlier runs. Switch the rounding method of a site with
 `podman exec -i voiced-erp-backend bash -c "cd /home/frappe/frappe-bench/sites && /home/frappe/frappe-bench/env/bin/python - 127.0.0.1 rounding=commercial" < setup_site.py`
 (re-run `setup.sh` or copy the printed `ERPNEXT_*` lines if you need the new key; the key is regenerated on every run).
 Tear down (touches only the `voiced-erp` project; the cached images stay):
 ```bash
 podman-compose -p voiced-erp -f compose.yml down -v
 podman volume rm voiced-erp_voiced-erp-db voiced-erp_voiced-erp-sites voiced-erp_voiced-erp-logs   # only if `down -v` left them
 ```
 Notes on rootless podman: the compose file has no healthchecks (podman's healthcheck timers need systemd), and the
 backend and worker are started by `setup.sh` after the configurator has exited.
 ## Integration user (feeds the main README)
 Create a dedicated user in ERPNext (User list, type System User) with **the roles "Accounts User" and "Sales User"**.
 Then open the user, "Settings" tab, "API Access", "Generate Keys", and copy the secret once.
 Why both (verified live on plain ERPNext and with India Compliance; `setup_site.py` creates exactly this user):
 - "Accounts User": create and submit Sales Invoices (draft, insert-and-submit, submit-later) and Payment Entries; read
  Accounts, Items, UOMs, Cost Centers, Price Lists, Item Groups, Company, the Sales Invoice naming series and (with
  India Compliance) GST Settings; attach a private PDF to the invoice.
 - "Sales User": look up and create Customers and Addresses, read Customer Groups, Territories and the tax templates.
  With "Accounts User" alone a fresh site answers HTTP 403 on Customer.
 No tax template is used (Voiced always sends explicit tax rows), so the tax-template list is only a convenience.
 Do not use Administrator or System Manager keys. Roles on a user are cached by Frappe: after changing them run
 `bench clear-cache` or the next request may still use the old set.
 ## Results (what was verified live)
 Versions: Frappe 15.121.3, ERPNext 15.121.6, India Compliance 15.32.0 (the `version-15` branch; commit `db73b3e` at the time of this run, so a later image build may differ), MariaDB 11.8,
 Redis 8.6, API v2 naming available (Frappe 15.73 or newer).
 Verified on both sites unless marked IC (India Compliance site only):
 - Connection test: user, frappe/erpnext/india_compliance versions, India Compliance detection, no warnings when the
  accounts match. Option lists load (companies, addresses, accounts, UOMs, cost centers, groups, series).
 - Sales Invoice push in mirror mode (API v2, `name` = Voiced number): CGST+SGST, IGST, discount (`apply_discount_on:
  Net Total`), fractional hours, repeated descriptions on code-less rows, item-code rows from a preset, remarks. The
  grand total, the tax amounts per head and the posting date equal Voiced's; `disable_rounded_total` works.
 - PDF attachment: uploaded through `upload_file`, `is_private` is 1.
 - Idempotency: a second push is a no-op; with the local sync row deleted, the 409 path adopts the existing document
  (no duplicate, no second PDF).
 - Submit: insert then submit in a second push (v2 `method/submit`), and series mode through the v1 `run_method` route.
 - Series mode: ERPNext names the document, the Voiced number is in `remarks`, and a lost sync row is recovered by the
  remarks lookup.
 - Payments: `get_payment_entry` plus overrides. `bank_account` is the Account name and lands in `paid_to`;
  `paid_amount = received_amount = cash`; the reference's `allocated_amount = cash + TDS`; TDS is one `deductions` row
  `{account, cost_center, amount: +TDS}`; the invoice's outstanding falls by cash + TDS; partial payments leave the rest.
 - Customer and Address shape (IC: `gstin`, `gst_category` on both; state exact name; link to the Customer).
 - IC: `place_of_supply` as `29-Karnataka`; Voiced's 38 state names equal India Compliance's `gst_state` list; HSN/SAC
  must be 6 or 8 digits (GST Settings `min_hsn_digits` was 6) and is enforced at submit; the 16-character name rule;
  GST-account warnings (mismatching CGST account, company without GST accounts, a too-long next number).
 Defects found and fixed (each has a mock-based test in the normal suite):
 1. `load_options`: the company-address list asked for the India Compliance-only `gstin` field and failed with HTTP 417
   on a plain site. It now retries without it.
 2. Code-less rows with a fractional quantity of hours/minutes failed ("Quantity cannot be a fraction ... UOM Nos"):
   ERPNext defaults the row's stock UOM to Nos without an item. Such rows now also send `stock_uom` = the row UOM.
 3. Rounding: ERPNext's default Rounding Method is Banker's Rounding; Voiced rounds half-paise up. On ties (for example
   9% of 10.50) the totals differ by 1 paise. A created document whose total differs is now a `conflict`: kept as a
   draft, never submitted, no PDF, with a message naming the fix (System Settings, Rounding Method, "Commercial
   Rounding"). The existing-document conflict message carries the same hint. With Commercial Rounding every case matched.
 4. A lost link to a client's address created a new address on every first push. The customer's matching address (same
   first line and PIN) is reused. (`creation` in the order-by is ambiguous with a Dynamic Link filter and gives HTTP 500.)
 5. A re-adopted document got a second copy of the PDF. A file of the same name is now looked up first.
 6. IC refuses `is_reverse_charge = 1` unless the tax rows are negative amounts on separate "RCM" accounts, which would
   make ERPNext's total differ from Voiced's. It is sent as 0 and the push warns.
 7. IC's 16-character rule is now checked before the POST in mirror mode (a readable, local refusal that points to series
   naming); ERPNext's own message is "Transaction Name must be 16 characters or fewer to meet GST requirements".
 8. A TDS-only payment (no cash) got ERPNext's bare "Paid Amount is mandatory"; it is refused locally with the reason.
 9. A fractional quantity on a whole-number UOM is refused by ERPNext with a readable message; Voiced appends what to
   change (unit mapping). No local pre-check: whether "Nos" is whole-number is a site setting.
 Limits and notes:
 - Rounding setting cannot be read by a restricted user, so it is detected by comparing the totals after creating the
  draft, not in the connection test.
 - With India Compliance, an invoice with a missing or short HSN/SAC is created as a draft and fails at submit; the
  readable ERPNext message ("HSN/SAC must exist and should be 6 or 8 digits long for the following row numbers") is
  shown.
 - A mirrored item row with an item code whose stock UOM differs from the row UOM works for whole quantities
  (`conversion_factor` 1); a fractional quantity needs the item's stock UOM to allow fractions.
 - One intermittent failure was seen once in the half-paise test on the India Compliance site (the push of a non-tie
  case failed; three later full runs and a single-test run passed). The cause was not captured.
 Not verified:
 - ERPNext v14 and v16 (the v16 images that exist on some machines were not used), other India Compliance versions.
 - Windows and WebView2; the Tauri commands and UI (the tests call the Rust push/payment functions directly).
 - Overseas/SEZ customers, UTGST supplier states, multi-currency, GST Settings with "Round Off GST Values" on,
  reverse charge booked on RCM accounts, e-invoice/e-waybill (India Compliance API features), a TLS or reverse-proxied
  site (only plain `http://` on a loopback address), Frappe Cloud or any site with `allow_cors` or rate limits.
@@ -0,0 +1,66 @@
 # Lean ERPNext v15 stack for Voiced's live integration tests (project name: voiced-erp).
 # db + redis + backend (gunicorn, published on 127.0.0.1:8088) + one worker. No nginx/websocket/scheduler.
 # setup.sh starts it in order (db, redis, configurator, then backend and worker); do not `up` it blindly.
 # Image: voiced-erp-ic:v15 = frappe/erpnext v15 + the india_compliance app files (see Containerfile.ic).
 name: voiced-erp
 services:
  db:
    image: docker.io/library/mariadb:11.8
    container_name: voiced-erp-db
    command:
      - --character-set-server=utf8mb4
      - --collation-server=utf8mb4_unicode_ci
      - --skip-character-set-client-handshake
      - --innodb-buffer-pool-size=256M
    environment:
      MARIADB_ROOT_PASSWORD: admin
    volumes:
      - voiced-erp-db:/var/lib/mysql
  redis:
    image: docker.io/library/redis:8.6-alpine
    container_name: voiced-erp-redis
  configurator:
    image: localhost/voiced-erp-ic:v15
    container_name: voiced-erp-configurator
    restart: "no"
    entrypoint: ["bash", "-c"]
    command:
      - >
        wait-for-it -t 120 db:3306;
        ls -1 apps > sites/apps.txt;
        bench set-config -g db_host db;
        bench set-config -gp db_port 3306;
        bench set-config -g redis_cache redis://redis:6379;
        bench set-config -g redis_queue redis://redis:6379;
        bench set-config -g redis_socketio redis://redis:6379;
        bench set-config -gp socketio_port 9000;
    volumes:
      - voiced-erp-sites:/home/frappe/frappe-bench/sites
      - voiced-erp-logs:/home/frappe/frappe-bench/logs
    depends_on:
      - db
      - redis
  backend:
    image: localhost/voiced-erp-ic:v15
    container_name: voiced-erp-backend
    ports:
      - "127.0.0.1:8088:8000"
    volumes:
      - voiced-erp-sites:/home/frappe/frappe-bench/sites
      - voiced-erp-logs:/home/frappe/frappe-bench/logs
  worker:
    image: localhost/voiced-erp-ic:v15
    container_name: voiced-erp-worker
    command: ["bench", "worker", "--queue", "short,default,long"]
    volumes:
      - voiced-erp-sites:/home/frappe/frappe-bench/sites
      - voiced-erp-logs:/home/frappe/frappe-bench/logs
 volumes:
  voiced-erp-db:
  voiced-erp-sites:
  voiced-erp-logs:
@@ -0,0 +1,42 @@
 #!/usr/bin/env bash
 # Brings up the voiced-erp podman project and prepares two ERPNext v15 sites for the live tests:
 #   127.0.0.1  plain ERPNext            -> .env.a   (URL http://127.0.0.1:8088)
 #   localhost  ERPNext + India Compliance -> .env.b (URL http://localhost:8088)
 # Both are served by the same backend; Frappe picks the site from the Host header.
 # Safe to re-run: existing sites are kept and the integration user's key is regenerated.
 set -euo pipefail
 cd "$(dirname "$0")"
 COMPOSE=(podman-compose -p voiced-erp -f compose.yml)
 IMAGE=localhost/voiced-erp-ic:v15
 BENCH_SITES=/home/frappe/frappe-bench/sites
 podman image exists "$IMAGE" || podman build -t "$IMAGE" -f Containerfile.ic .
 "${COMPOSE[@]}" up -d db redis configurator
 until [ "$(podman inspect -f '{{.State.Status}}' voiced-erp-configurator)" = exited ]; do sleep 2; done
 [ "$(podman inspect -f '{{.State.ExitCode}}' voiced-erp-configurator)" = 0 ] || { echo "configurator failed: podman logs voiced-erp-configurator" >&2; exit 1; }
 "${COMPOSE[@]}" up -d backend worker
 in_backend() { podman exec -i voiced-erp-backend bash -c "$1"; }
 for site in 127.0.0.1 localhost; do
  default=""; [ "$site" = 127.0.0.1 ] && default="--set-default"
  in_backend "test -d $BENCH_SITES/$site || bench new-site $site --mariadb-user-host-login-scope='%' \
    --admin-password=admin --db-root-username=root --db-root-password=admin --install-app erpnext $default" >/dev/null
 done
 until curl -fsS http://127.0.0.1:8088/api/method/ping >/dev/null 2>&1; do sleep 2; done
 # setup_site.py prints `ENV KEY=VALUE` lines; turn them into a sourceable env file (untracked: .env.* is ignored).
 write_env() { # site, url, file, extra args...
  local site=$1 url=$2 file=$3; shift 3
  in_backend "cd $BENCH_SITES && /home/frappe/frappe-bench/env/bin/python - $site $*" < setup_site.py \
    | sed -n 's/^ENV \([A-Z_]*\)=\(.*\)$/export \1="\2"/p' > "$file"
  echo "export ERPNEXT_URL=\"$url\"" >> "$file"
  chmod 600 "$file"
 }
 write_env 127.0.0.1 http://127.0.0.1:8088 .env.a
 write_env localhost http://localhost:8088 .env.b ic
 echo "Ready. Source .env.a (plain) or .env.b (India Compliance), then run the live tests (see README.md)."
@@ -0,0 +1,197 @@
 """Prepare one ERPNext site for Voiced's live integration tests.
 Run inside the backend container (see README.md):
    podman exec -i voiced-erp-backend python - <site> [ic] [rounding=commercial] < setup_site.py
 Creates (idempotently): the Indian company "Voiced Test Co" (abbr VTC, INR), the fiscal year, GST output tax
 accounts, a bank account, a company address, an integration user with API keys, and a few Items/UOMs.
 Prints one line `ENV KEY=VALUE` per value the Rust live tests need. Never run against a real site.
 """
 import json
 import sys
 import time
 import frappe
 SITE = sys.argv[1]
 IC = "ic" in sys.argv[2:]
 # `rounding=commercial` switches System Settings > Rounding Method (the ERPNext default is Banker's Rounding).
 ROUNDING = {"commercial": "Commercial Rounding", "banker": "Banker's Rounding"}.get(
    next((a.split("=", 1)[1] for a in sys.argv[2:] if a.startswith("rounding=")), ""), None
 )
 ABBR = "VTC"
 COMPANY = "Voiced Test Co"
 frappe.init(site=SITE, sites_path="/home/frappe/frappe-bench/sites")
 frappe.connect()
 frappe.set_user("Administrator")
 def out(key, value):
    print(f"ENV {key}={value}")
 def exists(doctype, name):
    return bool(frappe.db.exists(doctype, name))
 def insert(doc):
    d = frappe.get_doc(doc)
    d.insert(ignore_permissions=True)
    frappe.db.commit()
    return d
 # ---- 1. site, optionally India Compliance (before the wizard so it can add its own accounts) ----
 if IC and "india_compliance" not in frappe.get_installed_apps():
    from frappe.installer import install_app
    install_app("india_compliance", verbose=False)
    frappe.db.commit()
 # ---- 2. setup wizard ----
 if not frappe.db.get_single_value("System Settings", "setup_complete"):
    from frappe.desk.page.setup_wizard.setup_wizard import setup_complete
    setup_complete(
        {
            "language": "English",
            "country": "India",
            "timezone": "Asia/Kolkata",
            "currency": "INR",
            "full_name": "Voiced Admin",
            "email": "admin@voiced.test",
            "password": "admin",
            "company_name": COMPANY,
            "company_abbr": ABBR,
            "domains": ["Services"],
            "chart_of_accounts": "Standard",
            "fy_start_date": "2026-04-01",
            "fy_end_date": "2027-03-31",
            "bank_account": "HDFC",
            "setup_demo": 0,
        }
    )
    # setup_complete may run its stages on a worker; wait for it.
    for _ in range(120):
        frappe.db.rollback()
        if frappe.db.get_single_value("System Settings", "setup_complete") and exists("Company", COMPANY):
            break
        time.sleep(2)
    frappe.clear_cache()
    frappe.db.commit()
 assert exists("Company", COMPANY), "setup wizard did not create the company"
 # ---- 3. accounts ----
 duties = frappe.db.get_value("Account", {"company": COMPANY, "account_name": "Duties and Taxes", "is_group": 1}, "name")
 assert duties, "Duties and Taxes group not found"
 for head in ("CGST", "SGST", "UTGST", "IGST"):
    name = f"Output Tax {head} - {ABBR}"
    if not exists("Account", name):
        insert(
            {
                "doctype": "Account",
                "account_name": f"Output Tax {head}",
                "parent_account": duties,
                "company": COMPANY,
                "account_type": "Tax",
                "root_type": "Liability",
                "is_group": 0,
            }
        )
 tds = f"TDS Receivable - {ABBR}"
 if not exists("Account", tds):
    parent = frappe.db.get_value("Account", {"company": COMPANY, "account_name": "Current Assets", "is_group": 1}, "name")
    insert(
        {
            "doctype": "Account",
            "account_name": "TDS Receivable",
            "parent_account": parent,
            "company": COMPANY,
            "account_type": "Tax",
            "root_type": "Asset",
            "is_group": 0,
        }
    )
 # ---- 4. company address (India Compliance needs one with a GSTIN-ish state) ----
 addr_name = f"{COMPANY}-Billing"
 if not exists("Address", addr_name):
    d = {
        "doctype": "Address",
        "address_title": COMPANY,
        "address_type": "Billing",
        "address_line1": "1 Test Street",
        "city": "Mumbai",
        "state": "Maharashtra",
        "pincode": "400001",
        "country": "India",
        "links": [{"link_doctype": "Company", "link_name": COMPANY}],
    }
    if IC:
        d["gst_category"] = "Registered Regular"
        d["gstin"] = "27AAPFU0939F1ZV"
    insert(d)
 # ---- 5. items / UOMs ----
 for uom in ("Hour", "Minute", "Second"):
    if not exists("UOM", uom):
        insert({"doctype": "UOM", "uom_name": uom})
 for code, uom in (("VOICED-SERVICE", "Nos"), ("VOICED-HOURLY", "Hour")):
    if not exists("Item", code):
        d = {
            "doctype": "Item",
            "item_code": code,
            "item_name": code,
            "item_group": "Services",
            "stock_uom": uom,
            "is_stock_item": 0,
        }
        if IC:
            d["gst_hsn_code"] = "998314"
        insert(d)
 # ---- 5b. rounding method ----
 if ROUNDING:
    frappe.db.set_single_value("System Settings", "rounding_method", ROUNDING)
    frappe.db.commit()
    frappe.clear_cache()
 # ---- 6. integration user ----
 USER = f"voiced-integration@{SITE.replace('.', '-')}.test"
 # The role set that was verified live (with and without India Compliance): "Accounts User" creates and submits Sales
 # Invoices and Payment Entries and reads the accounting masters; "Sales User" adds the Customer and Address rights
 # (look up, create) and the tax-template list. Accounts User alone gets HTTP 403 on Customer.
 ROLES = ["Accounts User", "Sales User"]
 if not exists("User", USER):
    insert(
        {
            "doctype": "User",
            "email": USER,
            "first_name": "Voiced",
            "last_name": "Integration",
            "send_welcome_email": 0,
            "user_type": "System User",
            "roles": [{"role": r} for r in ROLES],
        }
    )
 user = frappe.get_doc("User", USER)
 user.set("roles", [{"role": r} for r in ROLES])
 secret = frappe.generate_hash(length=32)
 if not user.api_key:
    user.api_key = frappe.generate_hash(length=15)
 user.api_secret = secret
 user.save(ignore_permissions=True)
 frappe.db.commit()
 frappe.clear_cache(user=USER)
 frappe.clear_cache()
 out("ERPNEXT_KEY", user.api_key)
 out("ERPNEXT_SECRET", secret)
 out("ERPNEXT_COMPANY", COMPANY)
 out("ERPNEXT_ABBR", ABBR)
 out("ERPNEXT_IC", "1" if IC else "0")
 out("ERPNEXT_USER", USER)
 out("ERPNEXT_ROUNDING", "commercial" if frappe.db.get_single_value("System Settings", "rounding_method") == "Commercial Rounding" else "banker")
 print(json.dumps({"roles": ROLES}))
 frappe.destroy()
@@ -509,6 +509,16 @@ dependencies = [
 "version_check",
 ]
 [[package]]
 name = "core-foundation"
 version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
 dependencies = [
 "core-foundation-sys",
 "libc",
 ]
 [[package]]
 name = "core-foundation"
 version = "0.10.1"
@@ -532,7 +542,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "064badf302c3194842cf2c5d61f56cc88e54a759313879cdf03abdd27d0c3b97"
 dependencies = [
 "bitflags 2.13.2",
- "core-foundation",
+ "core-foundation 0.10.1",
 "core-graphics-types",
 "foreign-types",
 "libc",
@@ -545,10 +555,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d44a101f213f6c4cdc1853d4b78aef6db6bdfa3468798cc1d9912f4735013eb"
 dependencies = [
 "bitflags 2.13.2",
- "core-foundation",
+ "core-foundation 0.10.1",
 "libc",
 ]
 [[package]]
 name = "core_detect"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f8f80099a98041a3d1622845c271458a2d73e688351bf3cb999266764b81d48"
 [[package]]
 name = "cpufeatures"
 version = "0.2.17"
@@ -875,6 +891,20 @@ version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4ef6b89e5b37196644d8796de5268852ff179b44e96276cf4290264843743bb7"
 [[package]]
 name = "encoding_rs"
 version = "0.8.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e985e0451871ad22fb8d2b6b076e2028a502a0d3950998c2c5c0a4f9b5d9679"
 dependencies = [
 "cfg-if",
 "core_detect",
 "multiversion_no_op",
 "rustversion",
 "scopeguard",
 "simdutf8",
 ]
 [[package]]
 name = "endi"
 version = "1.1.1"
@@ -1244,6 +1274,17 @@ dependencies = [
 "version_check",
 ]
 [[package]]
 name = "getrandom"
 version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
 dependencies = [
 "cfg-if",
 "libc",
 "wasi",
 ]
 [[package]]
 name = "getrandom"
 version = "0.3.4"
@@ -1415,6 +1456,25 @@ dependencies = [
 "syn 2.0.119",
 ]
 [[package]]
 name = "h2"
 version = "0.4.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ef8e5e5a340588f4452631496976cf8636d4a7ecf600239fdc27615d2530bc16"
 dependencies = [
 "atomic-waker",
 "bytes",
 "fnv",
 "futures-core",
 "futures-sink",
 "http",
 "indexmap 2.14.2",
 "slab",
 "tokio",
 "tokio-util",
 "tracing",
 ]
 [[package]]
 name = "hashbrown"
 version = "0.12.3"
@@ -1531,6 +1591,7 @@ dependencies = [
 "bytes",
 "futures-channel",
 "futures-core",
 "h2",
 "http",
 "http-body",
 "httparse",
@@ -1541,6 +1602,21 @@ dependencies = [
 "want",
 ]
 [[package]]
 name = "hyper-rustls"
 version = "0.27.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dfa8e654703247911e29c23fbeaa261834bd9bb74efba2f9acddc37bfb127f53"
 dependencies = [
 "http",
 "hyper",
 "hyper-util",
 "rustls",
 "tokio",
 "tokio-rustls",
 "tower-service",
 ]
 [[package]]
 name = "hyper-util"
 version = "0.1.21"
@@ -1560,9 +1636,11 @@ dependencies = [
 "percent-encoding",
 "pin-project-lite",
 "socket2",
 "system-configuration",
 "tokio",
 "tower-service",
 "tracing",
 "windows-registry",
 ]
 [[package]]
@@ -1891,6 +1969,36 @@ dependencies = [
 "windows-sys 0.45.0",
 ]
 [[package]]
 name = "jni"
 version = "0.22.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5efd9a482cf3a427f00d6b35f14332adc7902ce91efb778580e180ff90fa3498"
 dependencies = [
 "cfg-if",
 "combine",
 "jni-macros",
 "jni-sys 0.4.1",
 "log",
 "simd_cesu8",
 "thiserror 2.0.21",
 "walkdir",
 "windows-link",
 ]
 [[package]]
 name = "jni-macros"
 version = "0.22.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a00109accc170f0bdb141fed3e393c565b6f5e072365c3bd58f5b062591560a3"
 dependencies = [
 "proc-macro2",
 "quote",
 "rustc_version",
 "simd_cesu8",
 "syn 2.0.119",
 ]
 [[package]]
 name = "jni-sys"
 version = "0.3.1"
@@ -2090,6 +2198,16 @@ version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
 [[package]]
 name = "mime_guess"
 version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e"
 dependencies = [
 "mime",
 "unicase",
 ]
 [[package]]
 name = "miniz_oxide"
 version = "0.8.9"
@@ -2152,6 +2270,12 @@ dependencies = [
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "multiversion_no_op"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "743fb55ba31b18fb1ecef6bdc9aa2743314978ac084044301a7eee33fb99a20d"
 [[package]]
 name = "ndk"
 version = "0.9.0"
@@ -2439,6 +2563,12 @@ dependencies = [
 "libc",
 ]
 [[package]]
 name = "openssl-probe"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
 [[package]]
 name = "option-ext"
 version = "0.2.0"
@@ -2866,21 +2996,31 @@ checksum = "16a1cfa75cc186dd73d5818e510e042e40927bccc9c236b061cea97e1eb08029"
 dependencies = [
 "base64 0.23.1",
 "bytes",
 "encoding_rs",
 "futures-core",
 "futures-util",
 "h2",
 "http",
 "http-body",
 "http-body-util",
 "hyper",
 "hyper-rustls",
 "hyper-util",
 "js-sys",
 "log",
 "mime",
 "mime_guess",
 "percent-encoding",
 "pin-project-lite",
 "rustls",
 "rustls-pki-types",
 "rustls-platform-verifier",
 "serde",
 "serde_json",
 "serde_urlencoded",
 "sync_wrapper",
 "tokio",
 "tokio-rustls",
 "tokio-util",
 "tower",
 "tower-http",
@@ -2916,6 +3056,20 @@ dependencies = [
 "windows-sys 0.60.2",
 ]
 [[package]]
 name = "ring"
 version = "0.17.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
 dependencies = [
 "cc",
 "cfg-if",
 "getrandom 0.2.17",
 "libc",
 "untrusted",
 "windows-sys 0.52.0",
 ]
 [[package]]
 name = "rsqlite-vfs"
 version = "0.1.1"
@@ -2979,12 +3133,91 @@ dependencies = [
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "rustls"
 version = "0.23.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0d41d731c7d2f962d1ccc364cec258de3c0e93b38c2fb3ba97ac74513048d634"
 dependencies = [
 "once_cell",
 "ring",
 "rustls-pki-types",
 "rustls-webpki",
 "subtle",
 "zeroize",
 ]
 [[package]]
 name = "rustls-native-certs"
 version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dab5152771c58876a2146916e53e35057e1a4dfa2b9df0f0305b07f611fdea4d"
 dependencies = [
 "openssl-probe",
 "rustls-pki-types",
 "schannel",
 "security-framework",
 ]
 [[package]]
 name = "rustls-pki-types"
 version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96"
 dependencies = [
 "zeroize",
 ]
 [[package]]
 name = "rustls-platform-verifier"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1167586491e2b18b8bfbb293e8180ec17c201c4f076d7cb3070ca964e7598f98"
 dependencies = [
 "core-foundation 0.10.1",
 "core-foundation-sys",
 "jni 0.22.4",
 "log",
 "once_cell",
 "rustls",
 "rustls-native-certs",
 "rustls-platform-verifier-android",
 "rustls-webpki",
 "security-framework",
 "security-framework-sys",
 "webpki-root-certs",
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "rustls-platform-verifier-android"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eec689c0bc40ff2458a5977b6619cb718087084a18e02a131c599b62d05e1a5f"
 [[package]]
 name = "rustls-webpki"
 version = "0.103.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2"
 dependencies = [
 "ring",
 "rustls-pki-types",
 "untrusted",
 ]
 [[package]]
 name = "rustversion"
 version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
 [[package]]
 name = "ryu"
 version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
 [[package]]
 name = "same-file"
 version = "1.0.6"
@@ -2994,6 +3227,15 @@ dependencies = [
 "winapi-util",
 ]
 [[package]]
 name = "schannel"
 version = "0.1.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "91c1b7e4904c873ef0710c1f407dde2e6287de2bebc1bbbf7d430bb7cbffd939"
 dependencies = [
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "schemars"
 version = "0.8.22"
@@ -3051,6 +3293,29 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 [[package]]
 name = "security-framework"
 version = "3.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
 dependencies = [
 "bitflags 2.13.2",
 "core-foundation 0.10.1",
 "core-foundation-sys",
 "libc",
 "security-framework-sys",
 ]
 [[package]]
 name = "security-framework-sys"
 version = "2.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"
 dependencies = [
 "core-foundation-sys",
 "libc",
 ]
 [[package]]
 name = "selectors"
 version = "0.38.0"
@@ -3175,6 +3440,18 @@ dependencies = [
 "serde_core",
 ]
 [[package]]
 name = "serde_urlencoded"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
 dependencies = [
 "form_urlencoded",
 "itoa",
 "ryu",
 "serde",
 ]
 [[package]]
 name = "serde_with"
 version = "3.24.0"
@@ -3272,6 +3549,22 @@ version = "0.3.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea"
 [[package]]
 name = "simd_cesu8"
 version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "11031e251abf8611c80f460e19dbdeb54a66db918e49c65a7065b46ac7aec520"
 dependencies = [
 "rustc_version",
 "simdutf8",
 ]
 [[package]]
 name = "simdutf8"
 version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
 [[package]]
 name = "siphasher"
 version = "1.0.4"
@@ -3396,6 +3689,12 @@ version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 [[package]]
 name = "subtle"
 version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 [[package]]
 name = "swift-rs"
 version = "1.0.8"
@@ -3459,6 +3758,27 @@ dependencies = [
 "syn 3.0.6",
 ]
 [[package]]
 name = "system-configuration"
 version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a13f3d0daba03132c0aa9767f98351b3488edc2c100cda2d2ec2b04f3d8d3c8b"
 dependencies = [
 "bitflags 2.13.2",
 "core-foundation 0.9.4",
 "system-configuration-sys",
 ]
 [[package]]
 name = "system-configuration-sys"
 version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4"
 dependencies = [
 "core-foundation-sys",
 "libc",
 ]
 [[package]]
 name = "system-deps"
 version = "6.2.2"
@@ -3480,7 +3800,7 @@ checksum = "f37f381f4e048e6cdf038b5705f8cf14ad108279d46eb968140a7b291aba9400"
 dependencies = [
 "bitflags 2.13.2",
 "block2",
- "core-foundation",
+ "core-foundation 0.10.1",
 "core-graphics",
 "crossbeam-channel",
 "dbus",
@@ -3490,7 +3810,7 @@ dependencies = [
 "gdkwayland-sys",
 "gdkx11-sys",
 "gtk",
- "jni",
+ "jni 0.21.1",
 "libc",
 "log",
 "ndk",
@@ -3546,7 +3866,7 @@ dependencies = [
 "gtk",
 "heck 0.5.0",
 "http",
- "jni",
+ "jni 0.21.1",
 "libc",
 "log",
 "mime",
@@ -3763,7 +4083,7 @@ dependencies = [
 "dpi",
 "gtk",
 "http",
- "jni",
+ "jni 0.21.1",
 "objc2",
 "objc2-ui-kit",
 "objc2-web-kit",
@@ -3786,7 +4106,7 @@ checksum = "7f9e7e0c9f80a5130773cfabb6df4dc924518fb1b2c923726966804634b57d22"
 dependencies = [
 "gtk",
 "http",
- "jni",
+ "jni 0.21.1",
 "log",
 "objc2",
 "objc2-app-kit",
@@ -3972,9 +4292,31 @@ dependencies = [
 "mio",
 "pin-project-lite",
 "socket2",
 "tokio-macros",
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "tokio-macros"
 version = "2.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78773a2a397f451582ce068015985c33193cf6dea8b74d2a639fe457b2f07b0e"
 dependencies = [
 "proc-macro2",
 "quote",
 "syn 3.0.6",
 ]
 [[package]]
 name = "tokio-rustls"
 version = "0.26.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c9cc2678c2cdd569ef8215e2afd7954ada2ae20b4fdd2c5fe6139a3b02d105db"
 dependencies = [
 "rustls",
 "tokio",
 ]
 [[package]]
 name = "tokio-util"
 version = "0.7.19"
@@ -3984,6 +4326,7 @@ dependencies = [
 "bytes",
 "futures-core",
 "futures-sink",
 "libc",
 "pin-project-lite",
 "tokio",
 ]
@@ -4217,6 +4560,12 @@ dependencies = [
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "unicase"
 version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142"
 [[package]]
 name = "unicode-ident"
 version = "1.0.26"
@@ -4229,6 +4578,12 @@ version = "1.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"
 [[package]]
 name = "untrusted"
 version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 [[package]]
 name = "url"
 version = "2.5.8"
@@ -4292,15 +4647,17 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 [[package]]
 name = "voiced"
-version = "0.1.0"
+version = "1.0.0"
 dependencies = [
 "base64 0.22.1",
 "chrono",
 "flate2",
 "image",
 "percent-encoding",
 "reqwest",
 "rusqlite",
 "rusqlite_migration",
 "rustls",
 "serde",
 "serde_json",
 "sha2",
@@ -4312,6 +4669,7 @@ dependencies = [
 "tauri-plugin-window-state",
 "tempfile",
 "thiserror 2.0.21",
 "tokio",
 "uuid",
 "zip",
 ]
@@ -4515,6 +4873,15 @@ dependencies = [
 "system-deps",
 ]
 [[package]]
 name = "webpki-root-certs"
 version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b96554aa2acc8ccdb7e1c9a58a7a68dd5d13bccc69cd124cb09406db612a1c9b"
 dependencies = [
 "rustls-pki-types",
 ]
 [[package]]
 name = "webview2-com"
 version = "0.39.1"
@@ -4679,6 +5046,17 @@ dependencies = [
 "windows-link",
 ]
 [[package]]
 name = "windows-registry"
 version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720"
 dependencies = [
 "windows-link",
 "windows-result",
 "windows-strings",
 ]
 [[package]]
 name = "windows-result"
 version = "0.4.1"
@@ -4706,6 +5084,15 @@ dependencies = [
 "windows-targets 0.42.2",
 ]
 [[package]]
 name = "windows-sys"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
 "windows-targets 0.52.6",
 ]
 [[package]]
 name = "windows-sys"
 version = "0.59.0"
@@ -4995,7 +5382,7 @@ dependencies = [
 "gtk",
 "http",
 "javascriptcore-rs",
- "jni",
+ "jni 0.21.1",
 "libc",
 "ndk",
 "objc2",
@@ -5156,6 +5543,12 @@ dependencies = [
 "synstructure",
 ]
 [[package]]
 name = "zeroize"
 version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e"
 [[package]]
 name = "zerotrie"
 version = "0.2.5"
@@ -1,6 +1,6 @@
 [package]
 name = "voiced"
-version = "0.1.0"
+version = "1.0.0"
 description = "Voiced — offline invoicing desktop app by Bongbetic"
 authors = ["Bongbetic"]
 edition = "2021"
@@ -31,6 +31,11 @@ flate2 = "1"
 zip = { version = "8", default-features = false, features = ["deflate-flate2"] }
 percent-encoding = "2"
 image = { version = "0.25.10", default-features = false, features = ["png", "jpeg", "webp"] }
 # ERPNext integration: all HTTP runs in Rust. TLS is rustls with the `ring` provider only (no aws-lc,
 # which does not cross-compile cleanly under cargo-xwin); roots come from the OS via rustls-platform-verifier.
 reqwest = { version = "0.13.5", default-features = false, features = ["rustls-no-provider", "http2", "charset", "system-proxy", "json", "multipart", "query"] }
 rustls = { version = "0.23", default-features = false, features = ["ring", "std", "tls12"] }
 tokio = { version = "1", features = ["time"] }
 # Desktop-only plugins (not available on mobile targets).
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
@@ -39,6 +44,7 @@ tauri-plugin-window-state = "2"
 [dev-dependencies]
 tempfile = "3"
 tokio = { version = "1", features = ["rt", "macros", "net", "io-util", "time"] }
 [features]
 # Production builds embed the frontend and serve it over the custom asset
@@ -0,0 +1,217 @@
 //! Tauri commands for the ERPNext settings: read/save the configuration, test a connection and load the
 //! lists the settings dropdowns need. The API secret never leaves this module: `erpnext_get_config` returns
 //! `apiSecretSet` only, and every command resolves a blank secret to the stored one on the Rust side.
 //! The push commands send issued invoices and payments (see `integrations::erpnext::push`); the database lock is
 //! never held across a network call.
 use crate::integrations::erpnext::client::ErpClient;
 use crate::integrations::erpnext::config::{self, ErpnextConfig, ErpnextConfigInput, ErpnextConfigView};
 use crate::integrations::erpnext::discovery::{self, ic_number_ok, ConnectionTest, ErpnextOptions, LocalFacts};
 use crate::integrations::erpnext::push::{self, PaymentPushResult, PushResult};
 use crate::integrations::SyncStatus;
 use crate::AppState;
 use rusqlite::Connection;
 use tauri::State;
 pub fn get_config_impl(conn: &Connection) -> Result<ErpnextConfigView, String> {
    Ok(config::load(conn)?.view())
 }
 /// Merges the form with the stored row (blank secret keeps the stored one) without saving.
 pub fn resolve_config(conn: &Connection, input: ErpnextConfigInput) -> Result<ErpnextConfig, String> {
    let stored = config::load(conn)?;
    input.resolve(&stored)
 }
 pub fn save_config_impl(conn: &Connection, input: ErpnextConfigInput) -> Result<ErpnextConfigView, String> {
    let cfg = resolve_config(conn, input)?;
    config::save(conn, &cfg)?;
    Ok(cfg.view())
 }
 /// What the connection test needs from the local database.
 pub fn local_facts(conn: &Connection) -> Result<LocalFacts, String> {
    let registration: String = conn
        .query_row("SELECT gst_registration FROM app_settings WHERE id = 1", [], |r| r.get(0))
        .map_err(|e| e.to_string())?;
    let mut stmt = conn
        .prepare("SELECT number FROM invoices ORDER BY id")
        .map_err(|e| e.to_string())?;
    let invalid_numbers = stmt
        .query_map([], |r| r.get::<_, String>(0))
        .map_err(|e| e.to_string())?
        .collect::<rusqlite::Result<Vec<_>>>()
        .map_err(|e| e.to_string())?
        .into_iter()
        .filter(|n| !ic_number_ok(n))
        .take(5)
        .collect();
    let next_number = conn
        .query_row(
            "SELECT prefix, padding, next_number FROM invoice_series WHERE is_active = 1 ORDER BY id DESC LIMIT 1",
            [],
            |r| Ok((r.get::<_, String>(0)?, r.get::<_, i64>(1)?, r.get::<_, i64>(2)?)),
        )
        .ok()
        .map(|(prefix, padding, next)| crate::db::format_number(&prefix, padding, next));
    Ok(LocalFacts { vendor_registered: registration != "unregistered", invalid_numbers, next_number })
 }
 #[tauri::command]
 pub fn erpnext_get_config(state: State<AppState>) -> Result<ErpnextConfigView, String> {
    let conn = state.db.lock().map_err(|e| e.to_string())?;
    get_config_impl(&conn)
 }
 /// A blank `apiSecret` keeps the stored secret; a value replaces it; `clearSecret` removes it.
 #[tauri::command]
 pub fn erpnext_save_config(state: State<AppState>, config: ErpnextConfigInput) -> Result<ErpnextConfigView, String> {
    let conn = state.db.lock().map_err(|e| e.to_string())?;
    save_config_impl(&conn, config)
 }
 /// Tests the form values as typed (saved or not). The database lock is released before any network call.
 #[tauri::command]
 pub async fn erpnext_test_connection(
    state: State<'_, AppState>,
    config: ErpnextConfigInput,
 ) -> Result<ConnectionTest, String> {
    let (cfg, local) = {
        let conn = state.db.lock().map_err(|e| e.to_string())?;
        (resolve_config(&conn, config)?, local_facts(&conn)?)
    };
    let client = ErpClient::from_config(&cfg)?;
    Ok(discovery::test_connection(&client, &cfg, &local).await?)
 }
 /// Loads the dropdown lists. Company-scoped lists use `config.company`.
 #[tauri::command]
 pub async fn erpnext_load_options(
    state: State<'_, AppState>,
    config: ErpnextConfigInput,
 ) -> Result<ErpnextOptions, String> {
    let cfg = {
        let conn = state.db.lock().map_err(|e| e.to_string())?;
        resolve_config(&conn, config)?
    };
    let client = ErpClient::from_config(&cfg)?;
    Ok(client.load_options(&cfg.company).await?)
 }
 /// A client for the saved settings, or a readable reason why there is none.
 fn saved_client(state: &AppState) -> Result<ErpClient, String> {
    let cfg = {
        let conn = state.db.lock().map_err(|e| e.to_string())?;
        config::load(&conn)?
    };
    if cfg.base_url.trim().is_empty() || cfg.api_key.trim().is_empty() || !cfg.api_secret.is_set() {
        return Err("ERPNext is not set up yet: enter the address, API key and API secret in Settings.".into());
    }
    Ok(ErpClient::from_config(&cfg)?)
 }
 /// Sends one issued invoice. `submit` omitted follows the "submit on push" setting. A failure comes back as a
 /// result with `ok: false` (and is recorded), not as an `Err`.
 #[tauri::command]
 pub async fn erpnext_push_invoice(
    state: State<'_, AppState>,
    id: i64,
    submit: Option<bool>,
 ) -> Result<PushResult, String> {
    let http = saved_client(&state)?;
    Ok(push::push_invoice(&state.db, &state.local_data_dir, &http, id, submit).await)
 }
 /// Sends several invoices one after another; one row's failure never stops the others.
 #[tauri::command]
 pub async fn erpnext_push_invoices(
    state: State<'_, AppState>,
    ids: Vec<i64>,
    submit: Option<bool>,
 ) -> Result<Vec<PushResult>, String> {
    let http = saved_client(&state)?;
    Ok(push::push_invoices(&state.db, &state.local_data_dir, &http, &ids, submit).await)
 }
 #[tauri::command]
 pub async fn erpnext_push_payment(state: State<'_, AppState>, payment_id: i64) -> Result<PaymentPushResult, String> {
    let http = saved_client(&state)?;
    Ok(push::push_payment(&state.db, &http, payment_id).await)
 }
 #[tauri::command]
 pub fn erpnext_sync_status(state: State<AppState>, id: i64) -> Result<SyncStatus, String> {
    let conn = state.db.lock().map_err(|e| e.to_string())?;
    push::sync_status(&conn, id)
 }
 /// The sync state of every invoice that has one, for the History list.
 #[tauri::command]
 pub fn erpnext_sync_statuses(state: State<AppState>) -> Result<Vec<SyncStatus>, String> {
    let conn = state.db.lock().map_err(|e| e.to_string())?;
    push::sync_statuses(&conn)
 }
 /// `<base>/app/sales-invoice/<name>` for an invoice that was sent.
 #[tauri::command]
 pub fn erpnext_open_url(state: State<AppState>, id: i64) -> Result<String, String> {
    let conn = state.db.lock().map_err(|e| e.to_string())?;
    push::open_url(&conn, id)
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    use serde_json::json;
    fn input(extra: serde_json::Value) -> ErpnextConfigInput {
        let mut base = json!({ "baseUrl": "https://erp.example.com", "apiKey": "key1", "company": "Test Co" });
        base.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
        serde_json::from_value(base).unwrap()
    }
    #[test]
    fn saved_config_is_returned_without_the_secret() {
        let conn = crate::db::open_in_memory().unwrap();
        let view = save_config_impl(&conn, input(json!({ "apiSecret": "super-secret-value", "submitOnPush": true }))).unwrap();
        assert!(view.api_secret_set);
        let shown = serde_json::to_string(&get_config_impl(&conn).unwrap()).unwrap();
        assert!(!shown.contains("super-secret-value"));
        assert!(shown.contains("\"apiSecretSet\":true"));
        assert!(shown.contains("\"company\":\"Test Co\""));
        // Saving again with a blank secret keeps it for the connection test too.
        save_config_impl(&conn, input(json!({ "company": "Other Co" }))).unwrap();
        let resolved = resolve_config(&conn, input(json!({}))).unwrap();
        assert_eq!(resolved.api_secret.expose(), "super-secret-value");
        assert_eq!(resolved.company, "Test Co");
    }
    #[test]
    fn test_values_are_resolved_without_saving() {
        let conn = crate::db::open_in_memory().unwrap();
        let resolved = resolve_config(&conn, input(json!({ "apiSecret": "typed-not-saved" }))).unwrap();
        assert_eq!(resolved.api_secret.expose(), "typed-not-saved");
        assert!(!get_config_impl(&conn).unwrap().api_secret_set);
    }
    #[test]
    fn local_facts_report_registration_numbers_and_the_next_number() {
        let conn = crate::db::open_in_memory().unwrap();
        let facts = local_facts(&conn).unwrap();
        assert!(!facts.vendor_registered);
        assert!(facts.invalid_numbers.is_empty());
        assert!(facts.next_number.is_some());
        conn.execute("UPDATE app_settings SET gst_registration = 'regular'", []).unwrap();
        conn.execute(
            "INSERT INTO invoices (number, invoice_date, created_at, updated_at)
             VALUES ('INV/2026-001', '2026-04-01', 'n', 'n'), ('INVOICE/2026/000001', '2026-04-01', 'n', 'n')",
            [],
        )
        .unwrap();
        let facts = local_facts(&conn).unwrap();
        assert!(facts.vendor_registered);
        assert_eq!(facts.invalid_numbers, ["INVOICE/2026/000001"]);
    }
 }
@@ -2,6 +2,7 @@ pub mod archive;
 pub mod assets;
 pub mod backup;
 pub mod clients;
 pub mod erpnext;
 pub mod files;
 pub mod fonts;
 pub mod invoice;
@@ -30,6 +30,9 @@ pub struct Payment {
    pub reference: String,
    pub notes: String,
    pub created_at: String,
    /// Name of the Payment Entry on ERPNext once this payment was sent; `None` until then.
    #[serde(default)]
    pub erpnext_payment_entry: Option<String>,
 }
 #[derive(Debug, Clone, Deserialize)]
@@ -127,10 +130,11 @@ fn map_payment(r: &rusqlite::Row) -> rusqlite::Result<Payment> {
        reference: r.get(6)?,
        notes: r.get(7)?,
        created_at: r.get(8)?,
        erpnext_payment_entry: r.get::<_, Option<String>>(9)?.filter(|e| !e.trim().is_empty()),
    })
 }
-const COLS: &str = "id, invoice_id, paid_on, amount_paise, tds_paise, mode, reference, notes, created_at";
+const COLS: &str = "id, invoice_id, paid_on, amount_paise, tds_paise, mode, reference, notes, created_at, erpnext_payment_entry";
 pub fn record_payment_impl(conn: &mut Connection, input: PaymentInput) -> Result<Payment, String> {
    let db = |e: rusqlite::Error| e.to_string();
@@ -10,7 +10,7 @@ const MAX_BACKUPS: usize = 10;
 const BACKUP_PREFIX: &str = "voiced-pre-v";
 /// Highest schema version, i.e. the number of entries in `migrations()`.
-pub(crate) const LATEST_VERSION: i64 = 9;
+pub(crate) const LATEST_VERSION: i64 = 11;
 #[derive(Debug, thiserror::Error)]
 pub enum DbError {
@@ -270,6 +270,81 @@ const M9: &str = r#"
 ALTER TABLE app_settings ADD COLUMN auto_backup INTEGER NOT NULL DEFAULT 1;
 "#;
 /// Version 10: ERPNext integration. `erpnext_config` is a single row (inserted here, so reading it is a plain SELECT)
 /// holding the connection, the company/account/master mapping and the toggles. `api_secret` is stored here and is never
 /// returned to the webview. `erpnext_sync` tracks what was pushed per invoice; issued invoices themselves are untouched.
 /// The remote names on clients, payments and item presets are nullable: NULL means "not linked yet".
 const M10: &str = r#"
 CREATE TABLE erpnext_config (
    id                       INTEGER PRIMARY KEY CHECK (id = 1),
    base_url                 TEXT NOT NULL DEFAULT '',
    api_key                  TEXT NOT NULL DEFAULT '',
    api_secret               TEXT NOT NULL DEFAULT '',
    extra_ca_pem             TEXT NOT NULL DEFAULT '',
    company                  TEXT NOT NULL DEFAULT '',
    company_address          TEXT NOT NULL DEFAULT '',
    naming_mode              TEXT NOT NULL DEFAULT 'mirror' CHECK (naming_mode IN ('mirror', 'series')),
    naming_series            TEXT NOT NULL DEFAULT '',
    income_account           TEXT NOT NULL DEFAULT '',
    cost_center              TEXT NOT NULL DEFAULT '',
    cgst_account             TEXT NOT NULL DEFAULT '',
    sgst_account             TEXT NOT NULL DEFAULT '',
    utgst_account            TEXT NOT NULL DEFAULT '',
    igst_account             TEXT NOT NULL DEFAULT '',
    tax_template_intra       TEXT NOT NULL DEFAULT '',
    tax_template_inter       TEXT NOT NULL DEFAULT '',
    payment_bank_account     TEXT NOT NULL DEFAULT '',
    tds_account              TEXT NOT NULL DEFAULT '',
    default_item_code        TEXT NOT NULL DEFAULT '',
    uom_map                  TEXT NOT NULL DEFAULT '{"second":"Second","minute":"Minute","hour":"Hour","session":"Nos","unit":"Nos"}',
    customer_group           TEXT NOT NULL DEFAULT '',
    territory                TEXT NOT NULL DEFAULT '',
    selling_price_list       TEXT NOT NULL DEFAULT '',
    submit_on_push           INTEGER NOT NULL DEFAULT 0,
    attach_pdf               INTEGER NOT NULL DEFAULT 1,
    auto_push_on_issue       INTEGER NOT NULL DEFAULT 0,
    create_missing_customers INTEGER NOT NULL DEFAULT 1,
    last_detect_result       TEXT NOT NULL DEFAULT '',
    updated_at               TEXT
 );
 INSERT INTO erpnext_config (id) VALUES (1);
 CREATE TABLE erpnext_sync (
    invoice_id       INTEGER PRIMARY KEY REFERENCES invoices(id),
    remote_name      TEXT NOT NULL DEFAULT '',
    remote_docstatus INTEGER NOT NULL DEFAULT 0,
    status           TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'synced', 'error')),
    last_error       TEXT NOT NULL DEFAULT '',
    payload_hash     TEXT NOT NULL DEFAULT '',
    synced_at        TEXT
 );
 ALTER TABLE clients ADD COLUMN erpnext_customer TEXT;
 ALTER TABLE clients ADD COLUMN erpnext_address TEXT;
 ALTER TABLE payments ADD COLUMN erpnext_payment_entry TEXT;
 ALTER TABLE item_presets ADD COLUMN erpnext_item_code TEXT;
 "#;
 /// Version 11: ERPNext push state. `erpnext_sync.status` gains `conflict` (the remote document exists with a different
 /// total; we never overwrite it) and `attachment_sha256` records which archived PDF was uploaded so it is never attached
 /// twice. SQLite cannot alter a CHECK constraint, so the table is rebuilt; M10 rows are copied over.
 const M11: &str = r#"
 CREATE TABLE erpnext_sync_new (
    invoice_id        INTEGER PRIMARY KEY REFERENCES invoices(id),
    remote_name       TEXT NOT NULL DEFAULT '',
    remote_docstatus  INTEGER NOT NULL DEFAULT 0,
    status            TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'synced', 'error', 'conflict')),
    last_error        TEXT NOT NULL DEFAULT '',
    payload_hash      TEXT NOT NULL DEFAULT '',
    synced_at         TEXT,
    attachment_sha256 TEXT NOT NULL DEFAULT ''
 );
 INSERT INTO erpnext_sync_new (invoice_id, remote_name, remote_docstatus, status, last_error, payload_hash, synced_at)
    SELECT invoice_id, remote_name, remote_docstatus, status, last_error, payload_hash, synced_at FROM erpnext_sync;
 DROP TABLE erpnext_sync;
 ALTER TABLE erpnext_sync_new RENAME TO erpnext_sync;
 "#;
 fn migrations() -> Migrations<'static> {
    Migrations::new(vec![
        M::up(SCHEMA),
@@ -281,6 +356,8 @@ fn migrations() -> Migrations<'static> {
        M::up(M7),
        M::up(M8),
        M::up(M9),
        M::up(M10),
        M::up(M11),
    ])
 }
@@ -786,6 +863,121 @@ CREATE INDEX IF NOT EXISTS idx_invoices_created ON invoices(created_at DESC);
        assert_eq!(rows[2].5, "unregistered");
    }
    #[test]
    fn m10_fresh_database_has_the_erpnext_tables_and_a_default_config_row() {
        let conn = open_in_memory().unwrap();
        let (naming, submit, attach, auto_push, create_customers, secret, uom): (String, i64, i64, i64, i64, String, String) = conn
            .query_row(
                "SELECT naming_mode, submit_on_push, attach_pdf, auto_push_on_issue, create_missing_customers, api_secret, uom_map
                 FROM erpnext_config WHERE id = 1",
                [],
                |r| Ok((r.get(0)?, r.get(1)?, r.get(2)?, r.get(3)?, r.get(4)?, r.get(5)?, r.get(6)?)),
            )
            .unwrap();
        assert_eq!((naming.as_str(), submit, attach, auto_push, create_customers), ("mirror", 0, 1, 0, 1));
        assert_eq!(secret, "");
        assert!(serde_json::from_str::<serde_json::Value>(&uom).is_ok());
        let rows: i64 = conn.query_row("SELECT COUNT(*) FROM erpnext_config", [], |r| r.get(0)).unwrap();
        assert_eq!(rows, 1);
        // Single row only.
        assert!(conn.execute("INSERT INTO erpnext_config (id) VALUES (2)", []).is_err());
        conn.prepare("SELECT invoice_id, remote_name, remote_docstatus, status, last_error, payload_hash, synced_at FROM erpnext_sync")
            .unwrap();
        conn.prepare("SELECT erpnext_customer, erpnext_address FROM clients").unwrap();
        conn.prepare("SELECT erpnext_payment_entry FROM payments").unwrap();
        conn.prepare("SELECT erpnext_item_code FROM item_presets").unwrap();
    }
    #[test]
    fn m10_upgrade_from_v9_keeps_existing_data_and_new_columns_are_null() {
        let mut conn = Connection::open_in_memory().unwrap();
        let v9 = vec![
            M::up(SCHEMA), M::up(M2), M::up(M3), M::up(M4), M::up(M5), M::up(M6), M::up(M7), M::up(M8), M::up(M9),
        ];
        Migrations::new(v9).to_latest(&mut conn).unwrap();
        assert_eq!(user_version(&conn), 9);
        conn.execute("INSERT INTO clients (name, gstin, created_at) VALUES ('Acme', '29ABCDE1234F1Z5', 'now')", []).unwrap();
        conn.execute("INSERT INTO item_presets (description, rate_paise, created_at) VALUES ('Design', 500000, 'now')", []).unwrap();
        conn.execute(
            "INSERT INTO invoices (number, invoice_date, created_at, updated_at) VALUES ('INV/2026-001', '2026-04-01', 'now', 'now')",
            [],
        )
        .unwrap();
        conn.execute(
            "INSERT INTO payments (invoice_id, paid_on, amount_paise, mode, created_at) VALUES (1, '2026-04-10', 12345, 'upi', 'now')",
            [],
        )
        .unwrap();
        migrations().to_latest(&mut conn).unwrap();
        assert_eq!(user_version(&conn), LATEST_VERSION);
        let (name, gstin, customer, address): (String, String, Option<String>, Option<String>) = conn
            .query_row("SELECT name, gstin, erpnext_customer, erpnext_address FROM clients", [], |r| {
                Ok((r.get(0)?, r.get(1)?, r.get(2)?, r.get(3)?))
            })
            .unwrap();
        assert_eq!((name.as_str(), gstin.as_str(), customer, address), ("Acme", "29ABCDE1234F1Z5", None, None));
        let (desc, rate, code): (String, i64, Option<String>) = conn
            .query_row("SELECT description, rate_paise, erpnext_item_code FROM item_presets", [], |r| {
                Ok((r.get(0)?, r.get(1)?, r.get(2)?))
            })
            .unwrap();
        assert_eq!((desc.as_str(), rate, code), ("Design", 500000, None));
        let (paid, entry): (i64, Option<String>) = conn
            .query_row("SELECT amount_paise, erpnext_payment_entry FROM payments", [], |r| Ok((r.get(0)?, r.get(1)?)))
            .unwrap();
        assert_eq!((paid, entry), (12345, None));
        let number: String = conn.query_row("SELECT number FROM invoices", [], |r| r.get(0)).unwrap();
        assert_eq!(number, "INV/2026-001");
        // The config row exists with defaults, and a sync row can reference the invoice.
        let enabled: i64 = conn.query_row("SELECT COUNT(*) FROM erpnext_config WHERE id = 1", [], |r| r.get(0)).unwrap();
        assert_eq!(enabled, 1);
        conn.execute("INSERT INTO erpnext_sync (invoice_id, remote_name, status) VALUES (1, 'INV/2026-001', 'synced')", []).unwrap();
        assert!(conn.execute("INSERT INTO erpnext_sync (invoice_id, status) VALUES (1, 'bogus')", []).is_err());
    }
    #[test]
    fn m11_rebuilds_the_sync_table_keeping_rows_and_allowing_conflict() {
        let mut conn = Connection::open_in_memory().unwrap();
        let v10 = vec![
            M::up(SCHEMA), M::up(M2), M::up(M3), M::up(M4), M::up(M5), M::up(M6), M::up(M7), M::up(M8), M::up(M9), M::up(M10),
        ];
        Migrations::new(v10).to_latest(&mut conn).unwrap();
        assert_eq!(user_version(&conn), 10);
        conn.execute(
            "INSERT INTO invoices (number, invoice_date, created_at, updated_at) VALUES ('INV/2026-001', '2026-04-01', 'now', 'now')",
            [],
        )
        .unwrap();
        conn.execute(
            "INSERT INTO erpnext_sync (invoice_id, remote_name, remote_docstatus, status, payload_hash, synced_at)
             VALUES (1, 'INV/2026-001', 1, 'synced', 'abc', '2026-04-02T00:00:00Z')",
            [],
        )
        .unwrap();
        assert!(conn.execute("UPDATE erpnext_sync SET status = 'conflict'", []).is_err());
        migrations().to_latest(&mut conn).unwrap();
        assert_eq!(user_version(&conn), 11);
        let row: (String, i64, String, String, String, Option<String>) = conn
            .query_row(
                "SELECT remote_name, remote_docstatus, status, payload_hash, attachment_sha256, synced_at FROM erpnext_sync WHERE invoice_id = 1",
                [],
                |r| Ok((r.get(0)?, r.get(1)?, r.get(2)?, r.get(3)?, r.get(4)?, r.get(5)?)),
            )
            .unwrap();
        assert_eq!(
            row,
            ("INV/2026-001".into(), 1, "synced".into(), "abc".into(), String::new(), Some("2026-04-02T00:00:00Z".into()))
        );
        conn.execute("UPDATE erpnext_sync SET status = 'conflict'", []).unwrap();
        assert!(conn.execute("UPDATE erpnext_sync SET status = 'bogus'", []).is_err());
        // The unique key still guards one row per invoice.
        assert!(conn.execute("INSERT INTO erpnext_sync (invoice_id, status) VALUES (1, 'error')", []).is_err());
    }
    fn build_v1_database(path: &Path) {
        let conn = Connection::open(path).unwrap();
        conn.execute_batch(V1_SCHEMA).unwrap();
@@ -0,0 +1,517 @@
 //! HTTP client for a Frappe/ERPNext site. All requests run here, in Rust: a webview `fetch` from
 //! `tauri://localhost` would be blocked by CORS.
 //!
 //! TLS is rustls with the `ring` provider (installed once, process-wide). Roots come from the OS through
 //! rustls-platform-verifier; an optional extra CA PEM is merged in for self-hosted sites.
 use super::config::{ErpnextConfig, Secret};
 use super::errors::{ErpError, ErrorKind};
 use reqwest::header::{HeaderMap, HeaderValue, ACCEPT, AUTHORIZATION, RETRY_AFTER};
 use reqwest::{Method, Url};
 use serde_json::Value;
 use std::sync::Once;
 use std::time::Duration;
 static CRYPTO_PROVIDER: Once = Once::new();
 /// Installs the ring crypto provider for rustls. Idempotent; must run before the first client is built.
 pub fn ensure_crypto_provider() {
    CRYPTO_PROVIDER.call_once(|| {
        // Err means another provider is already installed, which is fine for our purposes.
        let _ = rustls::crypto::ring::default_provider().install_default();
    });
 }
 #[derive(Debug, Clone)]
 pub struct ClientOptions {
    pub connect_timeout: Duration,
    pub read_timeout: Duration,
    pub total_timeout: Duration,
    /// Retries after the first attempt.
    pub max_retries: u32,
    pub backoff_base: Duration,
    pub max_backoff: Duration,
 }
 impl Default for ClientOptions {
    fn default() -> Self {
        ClientOptions {
            connect_timeout: Duration::from_secs(10),
            read_timeout: Duration::from_secs(30),
            total_timeout: Duration::from_secs(60),
            max_retries: 3,
            backoff_base: Duration::from_millis(500),
            max_backoff: Duration::from_secs(8),
        }
    }
 }
 /// Plain http is only for a local development site; anything else must use https.
 pub fn is_local_dev_host(host: &str) -> bool {
    let host = host.trim_end_matches('.').to_ascii_lowercase();
    host == "localhost" || host == "127.0.0.1" || host.ends_with(".localhost") || host.ends_with(".test")
 }
 /// Normalises what the user typed into `scheme://host[:port][/prefix]` without a trailing slash.
 /// A missing scheme means https, except for local development hosts, which get http.
 pub fn normalize_base_url(raw: &str) -> Result<String, ErpError> {
    let raw = raw.trim();
    if raw.is_empty() {
        return Err(ErpError::config("The ERPNext address is empty."));
    }
    let with_scheme = if raw.contains("://") {
        raw.to_string()
    } else {
        let host = raw.split(['/', ':']).next().unwrap_or("");
        let scheme = if is_local_dev_host(host) { "http" } else { "https" };
        format!("{scheme}://{raw}")
    };
    let mut url = Url::parse(&with_scheme).map_err(|e| ErpError::config(format!("The ERPNext address is not valid: {e}")))?;
    let host = url
        .host_str()
        .ok_or_else(|| ErpError::config("The ERPNext address has no host name."))?
        .to_string();
    match url.scheme() {
        "https" => {}
        "http" => {
            if !is_local_dev_host(&host) {
                return Err(ErpError::config(
                    "Use an https:// address. Plain http is only allowed for localhost, 127.0.0.1, *.localhost and *.test.",
                ));
            }
        }
        other => return Err(ErpError::config(format!("Unsupported address scheme \"{other}\"; use https://."))),
    }
    if !url.username().is_empty() || url.password().is_some() {
        return Err(ErpError::config("Do not put credentials in the address; use the API key and secret fields."));
    }
    url.set_query(None);
    url.set_fragment(None);
    Ok(url.as_str().trim_end_matches('/').to_string())
 }
 /// A file to upload through a multipart POST.
 pub struct Upload<'a> {
    pub file_name: &'a str,
    pub mime: &'a str,
    pub bytes: &'a [u8],
    pub fields: &'a [(&'a str, String)],
 }
 enum Payload<'a> {
    None,
    Json(&'a Value),
    Upload(&'a Upload<'a>),
 }
 pub struct ErpClient {
    http: reqwest::Client,
    base: Url,
    opts: ClientOptions,
    /// Strings scrubbed from every error message.
    secrets: Vec<String>,
 }
 impl std::fmt::Debug for ErpClient {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("ErpClient").field("base", &self.base.as_str()).finish_non_exhaustive()
    }
 }
 impl ErpClient {
    pub fn new(
        base_url: &str,
        api_key: &str,
        api_secret: &Secret,
        extra_ca_pem: &str,
        opts: ClientOptions,
    ) -> Result<Self, ErpError> {
        ensure_crypto_provider();
        let base = Url::parse(&normalize_base_url(base_url)?).map_err(|e| ErpError::config(e.to_string()))?;
        if api_key.trim().is_empty() || !api_secret.is_set() {
            return Err(ErpError::config("Enter the API key and API secret."));
        }
        let mut auth = HeaderValue::from_str(&format!("token {}:{}", api_key.trim(), api_secret.expose()))
            .map_err(|_| ErpError::config("The API key or secret contains characters that cannot be sent."))?;
        auth.set_sensitive(true);
        let mut headers = HeaderMap::new();
        headers.insert(AUTHORIZATION, auth);
        // Frappe answers `Accept: text/*` with HTML; always ask for JSON.
        headers.insert(ACCEPT, HeaderValue::from_static("application/json"));
        let mut builder = reqwest::Client::builder()
            .default_headers(headers)
            .user_agent(concat!("Voiced/", env!("CARGO_PKG_VERSION")))
            .connect_timeout(opts.connect_timeout)
            .read_timeout(opts.read_timeout)
            .timeout(opts.total_timeout)
            // A redirect drops the body or the auth header; surface it instead of guessing.
            .redirect(reqwest::redirect::Policy::none());
        if !extra_ca_pem.trim().is_empty() {
            let certs = reqwest::Certificate::from_pem_bundle(extra_ca_pem.trim().as_bytes())
                .map_err(|_| ErpError::config("The extra CA certificate is not valid PEM."))?;
            if certs.is_empty() {
                return Err(ErpError::config("The extra CA certificate field holds no certificate."));
            }
            builder = builder.tls_certs_merge(certs);
        }
        let http = builder
            .build()
            .map_err(|e| ErpError::config(format!("Could not set up the HTTP client: {}", error_chain(&e))))?;
        Ok(ErpClient {
            http,
            base,
            opts,
            secrets: vec![api_secret.expose().to_string(), api_key.trim().to_string()],
        })
    }
    pub fn from_config(cfg: &ErpnextConfig) -> Result<Self, ErpError> {
        Self::new(&cfg.base_url, &cfg.api_key, &cfg.api_secret, &cfg.extra_ca_pem, ClientOptions::default())
    }
    pub fn base_url(&self) -> &str {
        self.base.as_str().trim_end_matches('/')
    }
    fn url(&self, segments: &[&str]) -> Url {
        let mut url = self.base.clone();
        if let Ok(mut path) = url.path_segments_mut() {
            path.pop_if_empty().extend(segments);
        }
        url
    }
    /// GET, retried on 429, 5xx and timeouts.
    pub async fn get(&self, segments: &[&str], query: &[(&str, String)]) -> Result<Value, ErpError> {
        self.send(Method::GET, segments, query, Payload::None, true).await
    }
    /// POST with a JSON body. 429 is always retried (the server refused before doing anything). 5xx and
    /// timeouts are retried only when `idempotent` is true, because the server may have processed the
    /// request: a mirrored-name Sales Invoice is idempotent (a repeat is a 409), a series-named one is not.
    pub async fn post(&self, segments: &[&str], body: &Value, idempotent: bool) -> Result<Value, ErpError> {
        self.send(Method::POST, segments, &[], Payload::Json(body), idempotent).await
    }
    /// Multipart POST carrying one file part named `file` (the name Frappe's `upload_file` reads; the file
    /// name travels in the part's Content-Disposition) plus plain text fields. Never retried after a 5xx or
    /// timeout, because an upload that may have landed would attach the file twice.
    pub async fn post_file(&self, segments: &[&str], upload: &Upload<'_>) -> Result<Value, ErpError> {
        self.send(Method::POST, segments, &[], Payload::Upload(upload), false).await
    }
    async fn send(
        &self,
        method: Method,
        segments: &[&str],
        query: &[(&str, String)],
        payload: Payload<'_>,
        retry_ambiguous: bool,
    ) -> Result<Value, ErpError> {
        let mut attempt: u32 = 0;
        loop {
            let mut req = self.http.request(method.clone(), self.url(segments));
            if !query.is_empty() {
                req = req.query(query);
            }
            match &payload {
                Payload::None => {}
                Payload::Json(b) => req = req.json(*b),
                Payload::Upload(u) => {
                    let part = reqwest::multipart::Part::bytes(u.bytes.to_vec())
                        .file_name(u.file_name.to_string())
                        .mime_str(u.mime)
                        .map_err(|e| ErpError::config(format!("Bad upload type: {e}")))?;
                    let mut form = reqwest::multipart::Form::new();
                    for (k, v) in u.fields {
                        form = form.text(k.to_string(), v.clone());
                    }
                    req = req.multipart(form.part("file", part));
                }
            }
            let can_retry = attempt < self.opts.max_retries;
            match req.send().await {
                Ok(resp) => {
                    let status = resp.status();
                    let retry_after = resp
                        .headers()
                        .get(RETRY_AFTER)
                        .and_then(|v| v.to_str().ok())
                        .and_then(|v| v.trim().parse::<u64>().ok())
                        .map(Duration::from_secs);
                    let location = resp
                        .headers()
                        .get(reqwest::header::LOCATION)
                        .and_then(|v| v.to_str().ok())
                        .map(str::to_string);
                    let text = match resp.text().await {
                        Ok(t) => t,
                        Err(e) => {
                            if e.is_timeout() && retry_ambiguous && can_retry {
                                self.backoff(attempt, None).await;
                                attempt += 1;
                                continue;
                            }
                            return Err(self.map_transport(&e));
                        }
                    };
                    if status.is_success() {
                        return self.parse_success(&text);
                    }
                    let retryable = status.as_u16() == 429 || (status.is_server_error() && retry_ambiguous);
                    if retryable && can_retry {
                        self.backoff(attempt, retry_after).await;
                        attempt += 1;
                        continue;
                    }
                    if status.is_redirection() {
                        let to = location.unwrap_or_else(|| "another address".to_string());
                        return Err(self.scrub(ErpError::protocol(format!(
                            "The server redirected the request to {to}. Use the final address (usually https://) in the ERPNext address field."
                        ))));
                    }
                    return Err(self.scrub(ErpError::from_response(status.as_u16(), &text)));
                }
                Err(e) => {
                    if e.is_timeout() && retry_ambiguous && can_retry {
                        self.backoff(attempt, None).await;
                        attempt += 1;
                        continue;
                    }
                    return Err(self.map_transport(&e));
                }
            }
        }
    }
    async fn backoff(&self, attempt: u32, retry_after: Option<Duration>) {
        let exp = self.opts.backoff_base.saturating_mul(1u32 << attempt.min(10));
        let delay = retry_after.unwrap_or(exp).min(self.opts.max_backoff);
        tokio::time::sleep(delay).await;
    }
    fn parse_success(&self, text: &str) -> Result<Value, ErpError> {
        if text.trim().is_empty() {
            return Ok(Value::Null);
        }
        serde_json::from_str(text).map_err(|_| {
            ErpError::protocol(
                "The server did not return JSON. Check the address: it should be the root of your ERPNext site.",
            )
        })
    }
    fn scrub(&self, err: ErpError) -> ErpError {
        let secrets: Vec<&str> = self.secrets.iter().map(String::as_str).collect();
        err.redacted(&secrets)
    }
    fn map_transport(&self, e: &reqwest::Error) -> ErpError {
        let chain = error_chain(e);
        let err = if e.is_timeout() {
            ErpError::new(ErrorKind::Timeout, "The ERPNext server did not answer in time.")
        } else if e.is_connect() {
            let lower = chain.to_ascii_lowercase();
            let hint = if lower.contains("certificate") || lower.contains("unknownissuer") {
                " The certificate is not trusted: paste the site's CA certificate into the extra CA field."
            } else {
                ""
            };
            ErpError::new(ErrorKind::Network, format!("Could not connect to the ERPNext server ({chain}).{hint}"))
        } else {
            ErpError::new(ErrorKind::Network, format!("The request to ERPNext failed ({chain})."))
        };
        self.scrub(err)
    }
 }
 /// `a: b: c` for an error and its sources.
 fn error_chain(e: &dyn std::error::Error) -> String {
    let mut parts = vec![e.to_string()];
    let mut source = e.source();
    while let Some(s) = source {
        let text = s.to_string();
        if parts.last() != Some(&text) {
            parts.push(text);
        }
        source = s.source();
    }
    parts.join(": ")
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    use crate::integrations::erpnext::testutil::{client, fast_opts, reply, serve, Reply};
    use serde_json::json;
    use std::sync::atomic::Ordering;
    // ---- URL rules ----
    #[test]
    fn https_is_accepted_and_normalised() {
        assert_eq!(normalize_base_url(" https://Erp.Example.com/ ").unwrap(), "https://erp.example.com");
        assert_eq!(normalize_base_url("erp.example.com").unwrap(), "https://erp.example.com");
        assert_eq!(normalize_base_url("https://erp.example.com:8443/sub/?a=1#x").unwrap(), "https://erp.example.com:8443/sub");
    }
    #[test]
    fn http_is_only_for_local_development_hosts() {
        for ok in [
            "http://localhost:8000",
            "http://127.0.0.1:8080",
            "http://mysite.localhost:8000",
            "http://erp.test",
            "localhost:8000",
            "127.0.0.1:8000",
        ] {
            let url = normalize_base_url(ok).unwrap_or_else(|e| panic!("{ok}: {e}"));
            assert!(url.starts_with("http://"), "{ok} -> {url}");
        }
        for bad in ["http://erp.example.com", "http://192.168.1.10:8000", "http://localhost.evil.com", "http://notlocalhost"] {
            assert!(normalize_base_url(bad).is_err(), "{bad} must be refused");
        }
    }
    #[test]
    fn other_schemes_credentials_and_blanks_are_refused() {
        for bad in ["ftp://erp.example.com", "file:///etc/passwd", "https://user:pw@erp.example.com", "", "   ", "https://"] {
            assert!(normalize_base_url(bad).is_err(), "{bad:?} must be refused");
        }
    }
    #[tokio::test]
    async fn sends_token_auth_and_a_json_accept_header() {
        let mock = serve(vec![reply(200, json!({ "message": "Sample@example.com" }))]).await;
        let value = client(&mock)
            .get(&["api", "method", "frappe.auth.get_logged_user"], &[])
            .await
            .unwrap();
        assert_eq!(value["message"], "Sample@example.com");
        let raw = mock.requests.lock().unwrap()[0].to_ascii_lowercase();
        assert!(raw.starts_with("get /api/method/frappe.auth.get_logged_user "), "{raw}");
        assert!(raw.contains("authorization: token thekey:thesecret"), "{raw}");
        assert!(raw.contains("accept: application/json"), "{raw}");
    }
    #[tokio::test]
    async fn path_segments_are_percent_encoded_once() {
        let mock = serve(vec![reply(200, json!({ "data": [] }))]).await;
        client(&mock)
            .get(&["api", "resource", "Sales Invoice", "INV/2026-001"], &[("limit_page_length", "0".into())])
            .await
            .unwrap();
        let raw = mock.requests.lock().unwrap()[0].clone();
        assert!(raw.starts_with("GET /api/resource/Sales%20Invoice/AP%2F2026-001?limit_page_length=0 "), "{raw}");
    }
    #[tokio::test]
    async fn retries_429_then_succeeds() {
        let mut limited = reply(429, json!({ "message": "slow down" }));
        limited.headers.push(("Retry-After", "0".into()));
        let mock = serve(vec![limited, reply(200, json!({ "message": "ok" }))]).await;
        let value = client(&mock).get(&["api", "method", "ping"], &[]).await.unwrap();
        assert_eq!(value["message"], "ok");
        assert_eq!(mock.hits.load(Ordering::SeqCst), 2);
    }
    #[tokio::test]
    async fn persistent_500_exhausts_the_retries() {
        let mock = serve(vec![reply(500, json!({ "exception": "frappe.exceptions.ValidationError: boom" }))]).await;
        let err = client(&mock).get(&["api", "method", "ping"], &[]).await.unwrap_err();
        assert_eq!(err.kind, ErrorKind::Server);
        assert_eq!(err.message, "boom");
        assert_eq!(mock.hits.load(Ordering::SeqCst), 4, "1 attempt + 3 retries");
    }
    #[tokio::test]
    async fn validation_errors_are_not_retried() {
        let mock = serve(vec![reply(417, json!({ "_error_message": "Rate is required" }))]).await;
        let err = client(&mock)
            .post(&["api", "resource", "Sales Invoice"], &json!({ "a": 1 }), true)
            .await
            .unwrap_err();
        assert_eq!(err.kind, ErrorKind::Validation);
        assert_eq!(err.message, "Rate is required");
        assert_eq!(mock.hits.load(Ordering::SeqCst), 1);
    }
    #[tokio::test]
    async fn timeouts_are_retried_for_reads_but_not_for_ambiguous_writes() {
        let slow = Reply { delay_ms: 2_000, ..reply(200, json!({})) };
        let mock = serve(vec![slow]).await;
        let err = client(&mock).get(&["api", "method", "ping"], &[]).await.unwrap_err();
        assert_eq!(err.kind, ErrorKind::Timeout);
        assert_eq!(mock.hits.load(Ordering::SeqCst), 4);
        let slow = Reply { delay_ms: 2_000, ..reply(200, json!({})) };
        let mock = serve(vec![slow]).await;
        let err = client(&mock)
            .post(&["api", "resource", "Sales Invoice"], &json!({}), false)
            .await
            .unwrap_err();
        assert_eq!(err.kind, ErrorKind::Timeout);
        assert_eq!(mock.hits.load(Ordering::SeqCst), 1, "a write that may have landed is not repeated");
    }
    #[tokio::test]
    async fn non_idempotent_write_retries_429_but_not_500() {
        let mock = serve(vec![reply(429, json!({})), reply(200, json!({ "data": { "name": "X" } }))]).await;
        let value = client(&mock)
            .post(&["api", "resource", "Sales Invoice"], &json!({}), false)
            .await
            .unwrap();
        assert_eq!(value["data"]["name"], "X");
        assert_eq!(mock.hits.load(Ordering::SeqCst), 2);
        let mock = serve(vec![reply(500, json!({}))]).await;
        let err = client(&mock)
            .post(&["api", "resource", "Sales Invoice"], &json!({}), false)
            .await
            .unwrap_err();
        assert_eq!(err.kind, ErrorKind::Server);
        assert_eq!(mock.hits.load(Ordering::SeqCst), 1);
    }
    #[tokio::test]
    async fn redirects_are_reported_not_followed() {
        let mut moved = reply(301, json!({}));
        moved.headers.push(("Location", "https://erp.example.com/".into()));
        let mock = serve(vec![moved]).await;
        let err = client(&mock).get(&["api", "method", "ping"], &[]).await.unwrap_err();
        assert_eq!(err.kind, ErrorKind::Protocol);
        assert!(err.message.contains("https://erp.example.com/"), "{}", err.message);
        assert_eq!(mock.hits.load(Ordering::SeqCst), 1);
    }
    #[tokio::test]
    async fn html_success_page_is_a_protocol_error() {
        let mut page = reply(200, json!({}));
        page.body = "<html>login</html>".into();
        let mock = serve(vec![page]).await;
        let err = client(&mock).get(&["api", "method", "ping"], &[]).await.unwrap_err();
        assert_eq!(err.kind, ErrorKind::Protocol);
    }
    #[tokio::test]
    async fn refused_connection_is_a_network_error_without_the_secret() {
        let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
        let port = listener.local_addr().unwrap().port();
        drop(listener);
        let c = ErpClient::new(&format!("http://127.0.0.1:{port}"), "thekey", &Secret::new("thesecret"), "", fast_opts()).unwrap();
        let err = c.get(&["api", "method", "ping"], &[]).await.unwrap_err();
        assert_eq!(err.kind, ErrorKind::Network);
        assert!(!err.to_string().contains("thesecret"));
        assert!(!format!("{c:?}").contains("thesecret"));
    }
    #[test]
    fn credentials_are_required_and_a_bad_ca_is_refused() {
        assert!(ErpClient::new("https://erp.example.com", "", &Secret::new("s"), "", fast_opts()).is_err());
        assert!(ErpClient::new("https://erp.example.com", "k", &Secret::default(), "", fast_opts()).is_err());
        let err = ErpClient::new("https://erp.example.com", "k", &Secret::new("s"), "not a certificate", fast_opts()).unwrap_err();
        assert_eq!(err.kind, ErrorKind::Config);
    }
 }
@@ -0,0 +1,562 @@
 //! ERPNext connection and mapping settings (the single `erpnext_config` row).
 //!
 //! The API secret lives in the SQLite DB and is never handed back to the webview: `ErpnextConfigView`
 //! carries only `api_secret_set`. `Secret` redacts itself in `Debug`, so a stray `{:?}` cannot leak it.
 use super::client::normalize_base_url;
 use rusqlite::{params, Connection};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::collections::BTreeMap;
 /// A credential that never prints itself.
 #[derive(Clone, Default, PartialEq, Eq)]
 pub struct Secret(String);
 impl Secret {
    pub fn new(value: impl Into<String>) -> Self {
        Secret(value.into())
    }
    pub fn expose(&self) -> &str {
        &self.0
    }
    pub fn is_set(&self) -> bool {
        !self.0.is_empty()
    }
 }
 impl std::fmt::Debug for Secret {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(if self.is_set() { "Secret([redacted])" } else { "Secret(unset)" })
    }
 }
 /// How the Sales Invoice gets its name in ERPNext.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum NamingMode {
    /// The Voiced number becomes the document name (API v2, Frappe >= 15.73).
    Mirror,
    /// ERPNext assigns its own series number; the Voiced number goes into `remarks`.
    Series,
 }
 impl NamingMode {
    pub fn as_str(self) -> &'static str {
        match self {
            NamingMode::Mirror => "mirror",
            NamingMode::Series => "series",
        }
    }
    pub fn parse(s: &str) -> Result<Self, String> {
        match s {
            "mirror" => Ok(NamingMode::Mirror),
            "series" => Ok(NamingMode::Series),
            other => Err(format!("Unknown naming mode \"{other}\"")),
        }
    }
 }
 /// Voiced line unit to ERPNext UOM. Whole-number UOMs such as "Nos" reject fractional quantities,
 /// which is why hours and minutes map to their own UOMs.
 pub fn default_uom_map() -> BTreeMap<String, String> {
    [
        ("second", "Second"),
        ("minute", "Minute"),
        ("hour", "Hour"),
        ("session", "Nos"),
        ("unit", "Nos"),
    ]
    .iter()
    .map(|(k, v)| (k.to_string(), v.to_string()))
    .collect()
 }
 /// Everything stored for the integration, secret included. Backend-only.
 #[derive(Debug, Clone)]
 pub struct ErpnextConfig {
    pub base_url: String,
    pub api_key: String,
    pub api_secret: Secret,
    pub extra_ca_pem: String,
    pub company: String,
    pub company_address: String,
    pub naming_mode: NamingMode,
    pub naming_series: String,
    pub income_account: String,
    pub cost_center: String,
    pub cgst_account: String,
    pub sgst_account: String,
    pub utgst_account: String,
    pub igst_account: String,
    pub tax_template_intra: String,
    pub tax_template_inter: String,
    pub payment_bank_account: String,
    pub tds_account: String,
    pub default_item_code: String,
    pub uom_map: BTreeMap<String, String>,
    pub customer_group: String,
    pub territory: String,
    pub selling_price_list: String,
    pub submit_on_push: bool,
    pub attach_pdf: bool,
    pub auto_push_on_issue: bool,
    pub create_missing_customers: bool,
    /// JSON of the last connection test (versions, IC flag, warnings); empty if never run. Never holds secrets.
    pub last_detect_result: String,
 }
 impl Default for ErpnextConfig {
    fn default() -> Self {
        ErpnextConfig {
            base_url: String::new(),
            api_key: String::new(),
            api_secret: Secret::default(),
            extra_ca_pem: String::new(),
            company: String::new(),
            company_address: String::new(),
            naming_mode: NamingMode::Mirror,
            naming_series: String::new(),
            income_account: String::new(),
            cost_center: String::new(),
            cgst_account: String::new(),
            sgst_account: String::new(),
            utgst_account: String::new(),
            igst_account: String::new(),
            tax_template_intra: String::new(),
            tax_template_inter: String::new(),
            payment_bank_account: String::new(),
            tds_account: String::new(),
            default_item_code: String::new(),
            uom_map: default_uom_map(),
            customer_group: String::new(),
            territory: String::new(),
            selling_price_list: String::new(),
            submit_on_push: false,
            attach_pdf: true,
            auto_push_on_issue: false,
            create_missing_customers: true,
            last_detect_result: String::new(),
        }
    }
 }
 impl ErpnextConfig {
    /// ERPNext UOM for a Voiced unit; falls back to the built-in default, then to "Nos".
    pub fn uom_for(&self, unit: &str) -> String {
        if let Some(u) = self.uom_map.get(unit).filter(|u| !u.trim().is_empty()) {
            return u.trim().to_string();
        }
        default_uom_map().remove(unit).unwrap_or_else(|| "Nos".to_string())
    }
    pub fn view(&self) -> ErpnextConfigView {
        ErpnextConfigView {
            base_url: self.base_url.clone(),
            api_key: self.api_key.clone(),
            api_secret_set: self.api_secret.is_set(),
            extra_ca_pem: self.extra_ca_pem.clone(),
            company: self.company.clone(),
            company_address: self.company_address.clone(),
            naming_mode: self.naming_mode,
            naming_series: self.naming_series.clone(),
            income_account: self.income_account.clone(),
            cost_center: self.cost_center.clone(),
            cgst_account: self.cgst_account.clone(),
            sgst_account: self.sgst_account.clone(),
            utgst_account: self.utgst_account.clone(),
            igst_account: self.igst_account.clone(),
            tax_template_intra: self.tax_template_intra.clone(),
            tax_template_inter: self.tax_template_inter.clone(),
            payment_bank_account: self.payment_bank_account.clone(),
            tds_account: self.tds_account.clone(),
            default_item_code: self.default_item_code.clone(),
            uom_map: self.uom_map.clone(),
            customer_group: self.customer_group.clone(),
            territory: self.territory.clone(),
            selling_price_list: self.selling_price_list.clone(),
            submit_on_push: self.submit_on_push,
            attach_pdf: self.attach_pdf,
            auto_push_on_issue: self.auto_push_on_issue,
            create_missing_customers: self.create_missing_customers,
            last_detect_result: serde_json::from_str(&self.last_detect_result).unwrap_or(Value::Null),
        }
    }
 }
 /// What the webview sees: the same settings minus the secret.
 #[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ErpnextConfigView {
    pub base_url: String,
    pub api_key: String,
    pub api_secret_set: bool,
    pub extra_ca_pem: String,
    pub company: String,
    pub company_address: String,
    pub naming_mode: NamingMode,
    pub naming_series: String,
    pub income_account: String,
    pub cost_center: String,
    pub cgst_account: String,
    pub sgst_account: String,
    pub utgst_account: String,
    pub igst_account: String,
    pub tax_template_intra: String,
    pub tax_template_inter: String,
    pub payment_bank_account: String,
    pub tds_account: String,
    pub default_item_code: String,
    pub uom_map: BTreeMap<String, String>,
    pub customer_group: String,
    pub territory: String,
    pub selling_price_list: String,
    pub submit_on_push: bool,
    pub attach_pdf: bool,
    pub auto_push_on_issue: bool,
    pub create_missing_customers: bool,
    pub last_detect_result: Value,
 }
 /// What the webview sends to save or test. `api_secret` blank keeps the stored secret; a non-blank
 /// value replaces it; `clear_secret` removes it.
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ErpnextConfigInput {
    #[serde(default)]
    pub base_url: String,
    #[serde(default)]
    pub api_key: String,
    #[serde(default)]
    pub api_secret: String,
    #[serde(default)]
    pub clear_secret: bool,
    #[serde(default)]
    pub extra_ca_pem: String,
    #[serde(default)]
    pub company: String,
    #[serde(default)]
    pub company_address: String,
    #[serde(default = "default_naming_mode")]
    pub naming_mode: String,
    #[serde(default)]
    pub naming_series: String,
    #[serde(default)]
    pub income_account: String,
    #[serde(default)]
    pub cost_center: String,
    #[serde(default)]
    pub cgst_account: String,
    #[serde(default)]
    pub sgst_account: String,
    #[serde(default)]
    pub utgst_account: String,
    #[serde(default)]
    pub igst_account: String,
    #[serde(default)]
    pub tax_template_intra: String,
    #[serde(default)]
    pub tax_template_inter: String,
    #[serde(default)]
    pub payment_bank_account: String,
    #[serde(default)]
    pub tds_account: String,
    #[serde(default)]
    pub default_item_code: String,
    #[serde(default)]
    pub uom_map: BTreeMap<String, String>,
    #[serde(default)]
    pub customer_group: String,
    #[serde(default)]
    pub territory: String,
    #[serde(default)]
    pub selling_price_list: String,
    #[serde(default)]
    pub submit_on_push: bool,
    #[serde(default = "yes")]
    pub attach_pdf: bool,
    #[serde(default)]
    pub auto_push_on_issue: bool,
    #[serde(default = "yes")]
    pub create_missing_customers: bool,
    /// None keeps the stored value.
    #[serde(default)]
    pub last_detect_result: Option<Value>,
 }
 fn default_naming_mode() -> String {
    "mirror".to_string()
 }
 fn yes() -> bool {
    true
 }
 fn origin_of(url: &str) -> String {
    url.split('/').take(3).collect::<Vec<_>>().join("/").to_ascii_lowercase()
 }
 impl ErpnextConfigInput {
    /// Merges the form values with what is stored: trims, normalises the address, and decides which
    /// secret applies. The stored secret is never sent to a different server than it was saved for.
    pub fn resolve(self, stored: &ErpnextConfig) -> Result<ErpnextConfig, String> {
        let t = |s: &str| s.trim().to_string();
        let raw_url = self.base_url.trim();
        let base_url = if raw_url.is_empty() {
            String::new()
        } else {
            normalize_base_url(raw_url).map_err(|e| e.to_string())?
        };
        let typed_secret = self.api_secret.trim();
        let api_secret = if self.clear_secret {
            Secret::default()
        } else if !typed_secret.is_empty() {
            Secret::new(typed_secret)
        } else {
            if stored.api_secret.is_set()
                && !stored.base_url.is_empty()
                && !base_url.is_empty()
                && origin_of(&stored.base_url) != origin_of(&base_url)
            {
                return Err("The server address changed: enter the API secret again.".into());
            }
            stored.api_secret.clone()
        };
        let mut uom_map = default_uom_map();
        for (unit, uom) in &self.uom_map {
            if !uom.trim().is_empty() {
                uom_map.insert(unit.trim().to_string(), uom.trim().to_string());
            }
        }
        let last_detect_result = match &self.last_detect_result {
            Some(Value::Null) => String::new(),
            Some(v) => v.to_string(),
            None => stored.last_detect_result.clone(),
        };
        Ok(ErpnextConfig {
            base_url,
            api_key: t(&self.api_key),
            api_secret,
            extra_ca_pem: self.extra_ca_pem.trim().to_string(),
            company: t(&self.company),
            company_address: t(&self.company_address),
            naming_mode: NamingMode::parse(self.naming_mode.trim())?,
            naming_series: t(&self.naming_series),
            income_account: t(&self.income_account),
            cost_center: t(&self.cost_center),
            cgst_account: t(&self.cgst_account),
            sgst_account: t(&self.sgst_account),
            utgst_account: t(&self.utgst_account),
            igst_account: t(&self.igst_account),
            tax_template_intra: t(&self.tax_template_intra),
            tax_template_inter: t(&self.tax_template_inter),
            payment_bank_account: t(&self.payment_bank_account),
            tds_account: t(&self.tds_account),
            default_item_code: t(&self.default_item_code),
            uom_map,
            customer_group: t(&self.customer_group),
            territory: t(&self.territory),
            selling_price_list: t(&self.selling_price_list),
            submit_on_push: self.submit_on_push,
            attach_pdf: self.attach_pdf,
            auto_push_on_issue: self.auto_push_on_issue,
            create_missing_customers: self.create_missing_customers,
            last_detect_result,
        })
    }
 }
 const SELECT: &str = "SELECT base_url, api_key, api_secret, extra_ca_pem, company, company_address, naming_mode,
    naming_series, income_account, cost_center, cgst_account, sgst_account, utgst_account, igst_account,
    tax_template_intra, tax_template_inter, payment_bank_account, tds_account, default_item_code, uom_map,
    customer_group, territory, selling_price_list, submit_on_push, attach_pdf, auto_push_on_issue,
    create_missing_customers, last_detect_result FROM erpnext_config WHERE id = 1";
 pub fn load(conn: &Connection) -> Result<ErpnextConfig, String> {
    conn.query_row(SELECT, [], |r| {
        let naming: String = r.get(6)?;
        let uom_json: String = r.get(19)?;
        let mut uom_map = default_uom_map();
        if let Ok(stored) = serde_json::from_str::<BTreeMap<String, String>>(&uom_json) {
            uom_map.extend(stored.into_iter().filter(|(_, v)| !v.trim().is_empty()));
        }
        Ok(ErpnextConfig {
            base_url: r.get(0)?,
            api_key: r.get(1)?,
            api_secret: Secret::new(r.get::<_, String>(2)?),
            extra_ca_pem: r.get(3)?,
            company: r.get(4)?,
            company_address: r.get(5)?,
            naming_mode: NamingMode::parse(&naming).unwrap_or(NamingMode::Mirror),
            naming_series: r.get(7)?,
            income_account: r.get(8)?,
            cost_center: r.get(9)?,
            cgst_account: r.get(10)?,
            sgst_account: r.get(11)?,
            utgst_account: r.get(12)?,
            igst_account: r.get(13)?,
            tax_template_intra: r.get(14)?,
            tax_template_inter: r.get(15)?,
            payment_bank_account: r.get(16)?,
            tds_account: r.get(17)?,
            default_item_code: r.get(18)?,
            uom_map,
            customer_group: r.get(20)?,
            territory: r.get(21)?,
            selling_price_list: r.get(22)?,
            submit_on_push: r.get::<_, i64>(23)? != 0,
            attach_pdf: r.get::<_, i64>(24)? != 0,
            auto_push_on_issue: r.get::<_, i64>(25)? != 0,
            create_missing_customers: r.get::<_, i64>(26)? != 0,
            last_detect_result: r.get(27)?,
        })
    })
    .map_err(|e| e.to_string())
 }
 pub fn save(conn: &Connection, c: &ErpnextConfig) -> Result<(), String> {
    let uom_json = serde_json::to_string(&c.uom_map).map_err(|e| e.to_string())?;
    conn.execute(
        "UPDATE erpnext_config SET base_url = ?1, api_key = ?2, api_secret = ?3, extra_ca_pem = ?4,
            company = ?5, company_address = ?6, naming_mode = ?7, naming_series = ?8, income_account = ?9,
            cost_center = ?10, cgst_account = ?11, sgst_account = ?12, utgst_account = ?13, igst_account = ?14,
            tax_template_intra = ?15, tax_template_inter = ?16, payment_bank_account = ?17, tds_account = ?18,
            default_item_code = ?19, uom_map = ?20, customer_group = ?21, territory = ?22,
            selling_price_list = ?23, submit_on_push = ?24, attach_pdf = ?25, auto_push_on_issue = ?26,
            create_missing_customers = ?27, last_detect_result = ?28,
            updated_at = strftime('%Y-%m-%dT%H:%M:%SZ', 'now')
         WHERE id = 1",
        params![
            c.base_url,
            c.api_key,
            c.api_secret.expose(),
            c.extra_ca_pem,
            c.company,
            c.company_address,
            c.naming_mode.as_str(),
            c.naming_series,
            c.income_account,
            c.cost_center,
            c.cgst_account,
            c.sgst_account,
            c.utgst_account,
            c.igst_account,
            c.tax_template_intra,
            c.tax_template_inter,
            c.payment_bank_account,
            c.tds_account,
            c.default_item_code,
            uom_json,
            c.customer_group,
            c.territory,
            c.selling_price_list,
            c.submit_on_push as i64,
            c.attach_pdf as i64,
            c.auto_push_on_issue as i64,
            c.create_missing_customers as i64,
            c.last_detect_result,
        ],
    )
    .map_err(|e| e.to_string())?;
    Ok(())
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    fn input(extra: serde_json::Value) -> ErpnextConfigInput {
        let mut base = serde_json::json!({ "baseUrl": "https://erp.example.com/", "apiKey": "key1" });
        base.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
        serde_json::from_value(base).unwrap()
    }
    fn db() -> Connection {
        crate::db::open_in_memory().unwrap()
    }
    #[test]
    fn debug_never_prints_the_secret() {
        let cfg = ErpnextConfig { api_secret: Secret::new("s3cr3t-value"), ..Default::default() };
        assert!(!format!("{cfg:?}").contains("s3cr3t-value"));
        assert!(!format!("{:?}", Secret::new("s3cr3t-value")).contains("s3cr3t-value"));
    }
    #[test]
    fn defaults_load_from_the_migration_row() {
        let cfg = load(&db()).unwrap();
        assert_eq!(cfg.naming_mode, NamingMode::Mirror);
        assert!(!cfg.submit_on_push && cfg.attach_pdf && !cfg.auto_push_on_issue && cfg.create_missing_customers);
        assert_eq!(cfg.uom_for("hour"), "Hour");
        assert_eq!(cfg.uom_for("session"), "Nos");
        assert!(!cfg.api_secret.is_set());
    }
    #[test]
    fn round_trip_keeps_secret_server_side_only() {
        let conn = db();
        let stored = load(&conn).unwrap();
        let cfg = input(serde_json::json!({ "apiSecret": "topsecret", "company": "Test Co", "submitOnPush": true }))
            .resolve(&stored)
            .unwrap();
        save(&conn, &cfg).unwrap();
        let back = load(&conn).unwrap();
        assert_eq!(back.api_secret.expose(), "topsecret");
        assert_eq!(back.base_url, "https://erp.example.com");
        assert_eq!(back.company, "Test Co");
        assert!(back.submit_on_push);
        let view = serde_json::to_value(back.view()).unwrap();
        assert_eq!(view["apiSecretSet"], true);
        assert!(!view.to_string().contains("topsecret"));
        assert!(view.get("apiSecret").is_none());
    }
    #[test]
    fn blank_secret_keeps_and_explicit_values_replace_or_clear() {
        let conn = db();
        let first = input(serde_json::json!({ "apiSecret": "one" })).resolve(&load(&conn).unwrap()).unwrap();
        save(&conn, &first).unwrap();
        let keep = input(serde_json::json!({ "apiSecret": "  " })).resolve(&load(&conn).unwrap()).unwrap();
        assert_eq!(keep.api_secret.expose(), "one");
        let replace = input(serde_json::json!({ "apiSecret": "two" })).resolve(&load(&conn).unwrap()).unwrap();
        assert_eq!(replace.api_secret.expose(), "two");
        let clear = input(serde_json::json!({ "clearSecret": true })).resolve(&load(&conn).unwrap()).unwrap();
        assert!(!clear.api_secret.is_set());
    }
    #[test]
    fn stored_secret_is_not_reused_for_another_server() {
        let conn = db();
        let first = input(serde_json::json!({ "apiSecret": "one" })).resolve(&load(&conn).unwrap()).unwrap();
        save(&conn, &first).unwrap();
        let moved = input(serde_json::json!({ "baseUrl": "https://other.example.org" })).resolve(&load(&conn).unwrap());
        assert!(moved.unwrap_err().contains("API secret"));
        // The same server with a different path or case is still the same origin.
        let same = input(serde_json::json!({ "baseUrl": "HTTPS://ERP.example.com" })).resolve(&load(&conn).unwrap());
        assert!(same.is_ok());
    }
    #[test]
    fn invalid_address_or_naming_mode_is_rejected() {
        let stored = ErpnextConfig::default();
        assert!(input(serde_json::json!({ "baseUrl": "http://erp.example.com" })).resolve(&stored).is_err());
        assert!(input(serde_json::json!({ "namingMode": "random" })).resolve(&stored).is_err());
    }
    #[test]
    fn uom_map_merges_over_defaults() {
        let cfg = input(serde_json::json!({ "uomMap": { "hour": "Hr", "unit": "" } }))
            .resolve(&ErpnextConfig::default())
            .unwrap();
        assert_eq!(cfg.uom_for("hour"), "Hr");
        assert_eq!(cfg.uom_for("unit"), "Nos");
        assert_eq!(cfg.uom_for("minute"), "Minute");
        assert_eq!(cfg.uom_for("unheard-of"), "Nos");
    }
 }
@@ -0,0 +1,861 @@
 //! What the connected site is (versions, India Compliance), the lists the settings dropdowns need, and the
 //! connection test that turns all of it into warnings.
 use super::client::ErpClient;
 use super::config::{ErpnextConfig, NamingMode};
 use super::errors::{ErpError, ErrorKind};
 use serde::Serialize;
 use serde_json::{json, Value};
 // ---- versions and feature switches ----
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize)]
 pub struct Version {
    pub major: u32,
    pub minor: u32,
    pub patch: u32,
 }
 impl Version {
    /// Parses `15.73.2`, `v16.0.0-dev` or `15.1`; anything after the numeric part is ignored.
    pub fn parse(s: &str) -> Option<Version> {
        let s = s.trim().trim_start_matches(['v', 'V']);
        let numeric: String = s.chars().take_while(|c| c.is_ascii_digit() || *c == '.').collect();
        let mut parts = numeric.split('.').filter(|p| !p.is_empty());
        let major = parts.next()?.parse().ok()?;
        let minor = parts.next().and_then(|p| p.parse().ok()).unwrap_or(0);
        let patch = parts.next().and_then(|p| p.parse().ok()).unwrap_or(0);
        Some(Version { major, minor, patch })
    }
 }
 #[derive(Debug, Clone, Default, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ServerVersions {
    pub frappe: Option<String>,
    pub erpnext: Option<String>,
    pub india_compliance: Option<String>,
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct FeatureSwitches {
    /// API v2 keeps a posted document name verbatim (Frappe >= 15.73, or 16+).
    pub v2_naming: bool,
    /// India Compliance is installed, so the GST header and item fields apply.
    pub india_compliance: bool,
 }
 pub fn feature_switches(v: &ServerVersions) -> FeatureSwitches {
    let frappe = v.frappe.as_deref().and_then(Version::parse);
    FeatureSwitches {
        v2_naming: frappe.is_some_and(|f| (f.major, f.minor) >= (15, 73)),
        india_compliance: v.india_compliance.is_some(),
    }
 }
 /// Reads `{"message": {"frappe": {"version": "15.73.0"}, ...}}`.
 pub fn parse_versions(value: &Value) -> ServerVersions {
    let apps = value.get("message").unwrap_or(value);
    let version_of = |app: &str| -> Option<String> {
        let entry = apps.get(app)?;
        let v = entry.get("version").and_then(Value::as_str).or_else(|| entry.as_str())?;
        let v = v.trim();
        (!v.is_empty()).then(|| v.to_string())
    };
    ServerVersions {
        frappe: version_of("frappe"),
        erpnext: version_of("erpnext"),
        india_compliance: version_of("india_compliance"),
    }
 }
 // ---- number rules (India Compliance) ----
 pub const IC_MAX_NUMBER_LEN: usize = 16;
 /// India Compliance: `^[^\W_][A-Za-z0-9\-\/]{0,15}$`.
 pub fn ic_number_ok(number: &str) -> bool {
    let mut chars = number.chars();
    let Some(first) = chars.next() else { return false };
    first.is_alphanumeric()
        && number.chars().count() <= IC_MAX_NUMBER_LEN
        && chars.all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '/')
 }
 /// Length of a number generated from a Frappe naming series such as `SINV-.YY.-.#####`. A series with no
 /// `#` run gets Frappe's default five digits.
 pub fn naming_series_expanded_len(series: &str) -> usize {
    let mut len = 0;
    let mut has_digits = false;
    for part in series.split('.') {
        if part.is_empty() {
            continue;
        }
        if part.chars().all(|c| c == '#') {
            len += part.len();
            has_digits = true;
            continue;
        }
        len += match part {
            "YY" | "MM" | "DD" => 2,
            "YYYY" => 4,
            "FY" => 7,
            literal => literal.chars().count(),
        };
    }
    if !has_digits {
        len += 5;
    }
    len
 }
 // ---- options for the settings dropdowns ----
 #[derive(Debug, Clone, Serialize, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub struct OptionItem {
    /// The value to store (the document name).
    pub name: String,
    pub label: String,
    pub detail: String,
 }
 #[derive(Debug, Clone, Serialize)]
 pub struct OptionError {
    pub list: String,
    pub message: String,
 }
 #[derive(Debug, Clone, Default, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ErpnextOptions {
    pub companies: Vec<OptionItem>,
    pub company_addresses: Vec<OptionItem>,
    pub income_accounts: Vec<OptionItem>,
    pub tax_accounts: Vec<OptionItem>,
    pub tax_templates: Vec<OptionItem>,
    pub naming_series: Vec<OptionItem>,
    pub item_groups: Vec<OptionItem>,
    pub uoms: Vec<OptionItem>,
    pub cost_centers: Vec<OptionItem>,
    pub price_lists: Vec<OptionItem>,
    pub customer_groups: Vec<OptionItem>,
    pub territories: Vec<OptionItem>,
    /// Lists that could not be loaded (one failing list does not hide the rest).
    pub errors: Vec<OptionError>,
 }
 fn text<'a>(row: &'a Value, key: &str) -> &'a str {
    row.get(key).and_then(Value::as_str).unwrap_or("").trim()
 }
 fn item(row: &Value, label_key: &str, detail: String) -> Option<OptionItem> {
    let name = text(row, "name");
    if name.is_empty() {
        return None;
    }
    let label = text(row, label_key);
    Some(OptionItem {
        name: name.to_string(),
        label: if label.is_empty() { name.to_string() } else { label.to_string() },
        detail,
    })
 }
 fn join(parts: &[&str]) -> String {
    parts.iter().filter(|p| !p.is_empty()).cloned().collect::<Vec<_>>().join(" · ")
 }
 /// Parses the `naming_series` options out of a `getdoctype` response: newline-separated, first line blank.
 pub fn parse_naming_series(doctype_response: &Value) -> Vec<OptionItem> {
    let docs = doctype_response
        .get("docs")
        .or_else(|| doctype_response.get("message").and_then(|m| m.get("docs")))
        .and_then(Value::as_array);
    let Some(doc) = docs.and_then(|d| d.first()) else { return Vec::new() };
    let Some(fields) = doc.get("fields").and_then(Value::as_array) else { return Vec::new() };
    let Some(field) = fields.iter().find(|f| text(f, "fieldname") == "naming_series") else {
        return Vec::new();
    };
    text(field, "options")
        .lines()
        .map(str::trim)
        .filter(|l| !l.is_empty())
        .map(|l| OptionItem { name: l.to_string(), label: l.to_string(), detail: format!("e.g. {} digits", naming_series_expanded_len(l)) })
        .collect()
 }
 impl ErpClient {
    pub async fn get_logged_user(&self) -> Result<String, ErpError> {
        let v = self.get(&["api", "method", "frappe.auth.get_logged_user"], &[]).await?;
        let user = v.get("message").and_then(Value::as_str).unwrap_or("").trim().to_string();
        if user.is_empty() || user.eq_ignore_ascii_case("guest") {
            return Err(ErpError {
                kind: ErrorKind::Auth,
                status: None,
                message: "The API key and secret were not accepted (the site treated the request as Guest).".into(),
                exc_type: None,
            });
        }
        Ok(user)
    }
    pub async fn get_versions(&self) -> Result<ServerVersions, ErpError> {
        let v = self.get(&["api", "method", "frappe.utils.change_log.get_versions"], &[]).await?;
        Ok(parse_versions(&v))
    }
    /// `GET /api/resource/<doctype>` with every row (`limit_page_length=0`).
    pub async fn list_resource(
        &self,
        doctype: &str,
        fields: &[&str],
        filters: Value,
        order_by: &str,
    ) -> Result<Vec<Value>, ErpError> {
        let mut query = vec![
            ("fields", json!(fields).to_string()),
            ("limit_page_length", "0".to_string()),
            ("order_by", order_by.to_string()),
        ];
        if !filters.is_null() {
            query.push(("filters", filters.to_string()));
        }
        let v = self.get(&["api", "resource", doctype], &query).await?;
        Ok(v.get("data").and_then(Value::as_array).cloned().unwrap_or_default())
    }
    pub async fn load_options(&self, company: &str) -> Result<ErpnextOptions, ErpError> {
        let mut out = ErpnextOptions::default();
        let company = company.trim();
        macro_rules! load {
            ($list:literal, $target:expr, $call:expr) => {
                match $call.await {
                    Ok(rows) => $target = rows,
                    Err(e) if matches!(e.kind, ErrorKind::Auth | ErrorKind::Network | ErrorKind::Timeout | ErrorKind::Config | ErrorKind::Protocol) => {
                        return Err(e)
                    }
                    Err(e) => out.errors.push(OptionError { list: $list.to_string(), message: e.to_string() }),
                }
            };
        }
        load!("companies", out.companies, async {
            self.list_resource("Company", &["name", "company_name", "abbr", "country", "default_currency"], Value::Null, "name asc")
                .await
                .map(|rows| {
                    rows.iter()
                        .filter_map(|r| item(r, "company_name", join(&[text(r, "abbr"), text(r, "default_currency")])))
                        .collect()
                })
        });
        load!("itemGroups", out.item_groups, async {
            self.list_resource("Item Group", &["name"], Value::Null, "name asc")
                .await
                .map(|rows| rows.iter().filter_map(|r| item(r, "name", String::new())).collect())
        });
        load!("uoms", out.uoms, async {
            self.list_resource("UOM", &["name"], json!([["enabled", "=", 1]]), "name asc")
                .await
                .map(|rows| rows.iter().filter_map(|r| item(r, "name", String::new())).collect())
        });
        load!("priceLists", out.price_lists, async {
            self.list_resource("Price List", &["name"], json!([["enabled", "=", 1], ["selling", "=", 1]]), "name asc")
                .await
                .map(|rows| rows.iter().filter_map(|r| item(r, "name", String::new())).collect())
        });
        load!("customerGroups", out.customer_groups, async {
            self.list_resource("Customer Group", &["name"], json!([["is_group", "=", 0]]), "name asc")
                .await
                .map(|rows| rows.iter().filter_map(|r| item(r, "name", String::new())).collect())
        });
        load!("territories", out.territories, async {
            self.list_resource("Territory", &["name"], json!([["is_group", "=", 0]]), "name asc")
                .await
                .map(|rows| rows.iter().filter_map(|r| item(r, "name", String::new())).collect())
        });
        load!("namingSeries", out.naming_series, async {
            self.get(&["api", "method", "frappe.desk.form.load.getdoctype"], &[("doctype", "Sales Invoice".to_string())])
                .await
                .map(|v| parse_naming_series(&v))
        });
        if company.is_empty() {
            return Ok(out);
        }
        load!("companyAddresses", out.company_addresses, async {
            let filters = json!([
                ["Dynamic Link", "link_doctype", "=", "Company"],
                ["Dynamic Link", "link_name", "=", company],
                ["disabled", "=", 0]
            ]);
            let base = ["name", "address_title", "address_line1", "city", "state", "pincode"];
            let with_gstin = ["name", "address_title", "address_line1", "city", "state", "pincode", "gstin"];
            // `gstin` is a custom field added by India Compliance; a plain site rejects it ("Field not permitted").
            let rows = match self.list_resource("Address", &with_gstin, filters.clone(), "name asc").await {
                Err(e) if e.kind == ErrorKind::Validation => self.list_resource("Address", &base, filters, "name asc").await?,
                other => other?,
            };
            Ok::<_, ErpError>(
                rows.iter()
                    .filter_map(|r| {
                        item(
                            r,
                            "address_title",
                            join(&[text(r, "address_line1"), text(r, "city"), text(r, "state"), text(r, "pincode"), text(r, "gstin")]),
                        )
                    })
                    .collect(),
            )
        });
        load!("incomeAccounts", out.income_accounts, async {
            self.list_resource(
                "Account",
                &["name", "account_name", "account_type"],
                json!([["company", "=", company], ["root_type", "=", "Income"], ["is_group", "=", 0], ["disabled", "=", 0]]),
                "name asc",
            )
            .await
            .map(|rows| rows.iter().filter_map(|r| item(r, "account_name", text(r, "account_type").to_string())).collect())
        });
        load!("taxAccounts", out.tax_accounts, async {
            self.list_resource(
                "Account",
                &["name", "account_name", "account_type"],
                json!([["company", "=", company], ["account_type", "=", "Tax"], ["is_group", "=", 0], ["disabled", "=", 0]]),
                "name asc",
            )
            .await
            .map(|rows| rows.iter().filter_map(|r| item(r, "account_name", text(r, "account_type").to_string())).collect())
        });
        load!("taxTemplates", out.tax_templates, async {
            self.list_resource(
                "Sales Taxes and Charges Template",
                &["name", "title", "is_default"],
                json!([["company", "=", company], ["disabled", "=", 0]]),
                "name asc",
            )
            .await
            .map(|rows| rows.iter().filter_map(|r| item(r, "title", String::new())).collect())
        });
        load!("costCenters", out.cost_centers, async {
            self.list_resource(
                "Cost Center",
                &["name", "cost_center_name"],
                json!([["company", "=", company], ["is_group", "=", 0], ["disabled", "=", 0]]),
                "name asc",
            )
            .await
            .map(|rows| rows.iter().filter_map(|r| item(r, "cost_center_name", String::new())).collect())
        });
        Ok(out)
    }
 }
 // ---- connection test and warnings ----
 #[derive(Debug, Clone, Serialize, PartialEq, Eq)]
 pub struct Warning {
    pub code: String,
    pub message: String,
 }
 fn warn(code: &str, message: impl Into<String>) -> Warning {
    Warning { code: code.to_string(), message: message.into() }
 }
 /// Facts from the local database that the warnings need.
 #[derive(Debug, Clone, Default)]
 pub struct LocalFacts {
    pub vendor_registered: bool,
    /// Numbers of issued/cancelled invoices that India Compliance would refuse (at most a few examples).
    pub invalid_numbers: Vec<String>,
    /// The number the next invoice would get, if a series is active.
    pub next_number: Option<String>,
 }
 /// What was learned from the site. `None` means the check could not run.
 #[derive(Debug, Clone, Default)]
 pub struct RemoteFacts {
    pub versions: Option<ServerVersions>,
    pub company_address_count: Option<usize>,
    /// Rows of GST Settings -> gst_accounts, or the reason they could not be read.
    pub gst_accounts: Option<Result<Vec<Value>, String>>,
 }
 /// Checks that the configured tax accounts appear as Output accounts for the company in GST Settings.
 /// Otherwise India Compliance silently files the items as Nil-Rated.
 pub fn check_gst_accounts(rows: &[Value], cfg: &ErpnextConfig) -> Vec<Warning> {
    let for_company: Vec<&Value> = rows
        .iter()
        .filter(|r| text(r, "company") == cfg.company && matches!(text(r, "account_type"), "" | "Output"))
        .collect();
    if for_company.is_empty() {
        return vec![warn(
            "gst_accounts_not_configured",
            format!(
                "GST accounts are not configured for \"{}\" in GST Settings. India Compliance will file these invoices as Nil-Rated.",
                cfg.company
            ),
        )];
    }
    let has = |field: &str, account: &str| for_company.iter().any(|r| text(r, field) == account);
    let mut out = Vec::new();
    for (field, label, account) in [
        ("cgst_account", "CGST", cfg.cgst_account.as_str()),
        ("sgst_account", "SGST", cfg.sgst_account.as_str()),
        ("igst_account", "IGST", cfg.igst_account.as_str()),
    ] {
        if !account.is_empty() && !has(field, account) {
            out.push(warn(
                "gst_account_mismatch",
                format!("The {label} account \"{account}\" is not the {label} output account in GST Settings; GST returns would not pick the tax up."),
            ));
        }
    }
    out
 }
 /// Pure: turns the configuration and the facts gathered into the list shown after a connection test.
 pub fn build_warnings(cfg: &ErpnextConfig, local: &LocalFacts, remote: &RemoteFacts) -> Vec<Warning> {
    let mut w = Vec::new();
    let features = remote.versions.as_ref().map(feature_switches);
    let ic = features.is_some_and(|f| f.india_compliance);
    if remote.versions.is_none() {
        w.push(warn(
            "versions_unknown",
            "The site's versions could not be read, so India Compliance and API v2 naming were not detected.",
        ));
    }
    if cfg.company.is_empty() {
        w.push(warn("company_missing", "No company is selected."));
    }
    if cfg.income_account.is_empty() {
        w.push(warn(
            "income_account_missing",
            "No income account is set. Rows without an item code need one, and ERPNext has no fallback for them.",
        ));
    }
    if cfg.naming_mode == NamingMode::Mirror {
        if let Some(f) = features {
            if !f.v2_naming {
                w.push(warn(
                    "mirror_unsupported",
                    "Mirroring the Voiced number needs Frappe 15.73 or newer. Use the ERPNext series naming mode instead.",
                ));
            }
        }
    } else if cfg.naming_series.is_empty() {
        w.push(warn("naming_series_missing", "ERPNext series naming is selected but no naming series is chosen."));
    }
    if local.vendor_registered {
        if cfg.cgst_account.is_empty() || cfg.sgst_account.is_empty() || cfg.igst_account.is_empty() {
            w.push(warn(
                "tax_accounts_missing",
                "The supplier is GST-registered but the CGST, SGST and IGST accounts are not all set.",
            ));
        }
        if remote.versions.is_some() && !ic {
            w.push(warn(
                "ic_not_detected",
                "India Compliance is not installed on the site, so the GST fields (place of supply, HSN, GSTIN) will not be sent.",
            ));
        }
    }
    if ic {
        if local.vendor_registered {
            match &remote.gst_accounts {
                Some(Ok(rows)) => w.extend(check_gst_accounts(rows, cfg)),
                Some(Err(why)) => w.push(warn(
                    "gst_settings_unreadable",
                    format!("GST Settings could not be read ({why}), so the GST accounts were not checked."),
                )),
                None => {}
            }
        }
        if cfg.company_address.is_empty() {
            w.push(warn("company_address_missing", "India Compliance needs a company address on every invoice; none is selected."));
        } else if remote.company_address_count == Some(0) {
            w.push(warn("company_address_missing", "No address is linked to the company on the site."));
        }
        match cfg.naming_mode {
            NamingMode::Mirror => {
                if !local.invalid_numbers.is_empty() {
                    w.push(warn(
                        "number_invalid",
                        format!(
                            "India Compliance allows at most {IC_MAX_NUMBER_LEN} characters (letters, digits, - and /). These numbers do not qualify: {}.",
                            local.invalid_numbers.join(", ")
                        ),
                    ));
                }
                if let Some(next) = &local.next_number {
                    if !ic_number_ok(next) {
                        w.push(warn(
                            "number_invalid",
                            format!("The next invoice number {next} is longer than {IC_MAX_NUMBER_LEN} characters or has characters India Compliance refuses."),
                        ));
                    }
                }
            }
            NamingMode::Series => {
                let len = naming_series_expanded_len(&cfg.naming_series);
                if !cfg.naming_series.is_empty() && len > IC_MAX_NUMBER_LEN {
                    w.push(warn(
                        "naming_series_too_long",
                        format!(
                            "The naming series \"{}\" produces numbers of about {len} characters; India Compliance allows {IC_MAX_NUMBER_LEN}.",
                            cfg.naming_series
                        ),
                    ));
                }
            }
        }
    }
    w
 }
 #[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ConnectionTest {
    pub user: String,
    pub versions: ServerVersions,
    pub features: FeatureSwitches,
    /// Same as `features.india_compliance`, for the UI.
    pub india_compliance: bool,
    pub warnings: Vec<Warning>,
 }
 /// Runs the connection test: identity (a failure here fails the test), versions, then the checks that only
 /// produce warnings.
 pub async fn test_connection(client: &ErpClient, cfg: &ErpnextConfig, local: &LocalFacts) -> Result<ConnectionTest, ErpError> {
    let user = client.get_logged_user().await?;
    let versions = match client.get_versions().await {
        Ok(v) => Some(v),
        Err(e) if e.kind == ErrorKind::Auth => return Err(e),
        Err(_) => None,
    };
    let mut remote = RemoteFacts { versions, ..Default::default() };
    let features = remote.versions.as_ref().map(feature_switches);
    if features.is_some_and(|f| f.india_compliance) {
        if !cfg.company.is_empty() {
            remote.company_address_count = client
                .list_resource(
                    "Address",
                    &["name"],
                    json!([["Dynamic Link", "link_doctype", "=", "Company"], ["Dynamic Link", "link_name", "=", cfg.company], ["disabled", "=", 0]]),
                    "name asc",
                )
                .await
                .ok()
                .map(|rows| rows.len());
        }
        if local.vendor_registered {
            remote.gst_accounts = Some(
                client
                    .get(&["api", "resource", "GST Settings", "GST Settings"], &[])
                    .await
                    .map(|v| v.get("data").and_then(|d| d.get("gst_accounts")).and_then(Value::as_array).cloned().unwrap_or_default())
                    .map_err(|e| e.to_string()),
            );
        }
    }
    let warnings = build_warnings(cfg, local, &remote);
    let versions = remote.versions.unwrap_or_default();
    let features = feature_switches(&versions);
    Ok(ConnectionTest { user, india_compliance: features.india_compliance, features, versions, warnings })
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    fn cfg() -> ErpnextConfig {
        ErpnextConfig {
            company: "Test Co".into(),
            company_address: "Test Co-Billing".into(),
            income_account: "Sales - AC".into(),
            cgst_account: "Output CGST - AC".into(),
            sgst_account: "Output SGST - AC".into(),
            igst_account: "Output IGST - AC".into(),
            ..Default::default()
        }
    }
    fn ic_versions(frappe: &str) -> RemoteFacts {
        RemoteFacts {
            versions: Some(ServerVersions {
                frappe: Some(frappe.into()),
                erpnext: Some("15.121.6".into()),
                india_compliance: Some("15.0.0".into()),
            }),
            company_address_count: Some(1),
            gst_accounts: Some(Ok(vec![json!({
                "company": "Test Co", "account_type": "Output",
                "cgst_account": "Output CGST - AC", "sgst_account": "Output SGST - AC", "igst_account": "Output IGST - AC"
            })])),
        }
    }
    fn codes(w: &[Warning]) -> Vec<&str> {
        w.iter().map(|w| w.code.as_str()).collect()
    }
    #[test]
    fn versions_parse_leniently() {
        assert_eq!(Version::parse("15.73.2"), Some(Version { major: 15, minor: 73, patch: 2 }));
        assert_eq!(Version::parse("v16.0.0-dev"), Some(Version { major: 16, minor: 0, patch: 0 }));
        assert_eq!(Version::parse("15.1"), Some(Version { major: 15, minor: 1, patch: 0 }));
        assert_eq!(Version::parse("15.73.0-beta.2"), Some(Version { major: 15, minor: 73, patch: 0 }));
        assert_eq!(Version::parse("unknown"), None);
    }
    #[test]
    fn feature_switches_follow_the_frappe_version_and_ic_presence() {
        let v = |frappe: &str, ic: bool| ServerVersions {
            frappe: Some(frappe.into()),
            erpnext: None,
            india_compliance: ic.then(|| "15.0.0".into()),
        };
        assert!(!feature_switches(&v("15.72.9", false)).v2_naming);
        assert!(feature_switches(&v("15.73.0", false)).v2_naming);
        assert!(feature_switches(&v("16.0.0-dev", true)).v2_naming);
        assert!(feature_switches(&v("16.0.0-dev", true)).india_compliance);
        assert!(!feature_switches(&ServerVersions::default()).v2_naming);
    }
    #[test]
    fn get_versions_response_is_parsed() {
        let v = parse_versions(&json!({ "message": {
            "frappe": { "title": "Frappe Framework", "version": "15.73.0" },
            "erpnext": { "version": "15.121.6" },
            "india_compliance": { "version": "15.9.0" },
            "hrms": { "version": "15.0.0" },
        }}));
        assert_eq!(v.frappe.as_deref(), Some("15.73.0"));
        assert_eq!(v.erpnext.as_deref(), Some("15.121.6"));
        assert_eq!(v.india_compliance.as_deref(), Some("15.9.0"));
        assert!(parse_versions(&json!({ "message": { "frappe": { "version": "15.0.0" } } })).india_compliance.is_none());
    }
    #[test]
    fn india_compliance_number_rule() {
        for ok in ["INV/2026-001", "A", "1234567890123456", "AP-24-25/0001"] {
            assert!(ic_number_ok(ok), "{ok}");
        }
        for bad in ["", "12345678901234567", "_AB", "AB 01", "AB_01", "-AB", "/AB", "AB#1"] {
            assert!(!ic_number_ok(bad), "{bad}");
        }
    }
    #[test]
    fn naming_series_is_expanded_before_measuring() {
        assert_eq!(naming_series_expanded_len("SINV-.YY.-"), 5 + 2 + 1 + 5);
        assert_eq!(naming_series_expanded_len("ACC-SINV-.YYYY.-.#####"), 9 + 4 + 1 + 5);
        assert_eq!(naming_series_expanded_len("INV-.MM.-.DD.-.####"), 4 + 2 + 1 + 2 + 1 + 4);
        assert_eq!(naming_series_expanded_len("LONGPREFIX-ABC-.YYYY.-.#####"), 15 + 4 + 1 + 5);
    }
    #[test]
    fn naming_series_options_come_from_getdoctype() {
        let resp = json!({ "docs": [{ "fields": [
            { "fieldname": "customer", "options": "Customer" },
            { "fieldname": "naming_series", "options": "\nSINV-.YY.-\nACC-SINV-.YYYY.-" }
        ]}]});
        let items = parse_naming_series(&resp);
        assert_eq!(items.iter().map(|i| i.name.as_str()).collect::<Vec<_>>(), ["SINV-.YY.-", "ACC-SINV-.YYYY.-"]);
        assert!(parse_naming_series(&json!({})).is_empty());
    }
    #[test]
    fn a_healthy_ic_setup_has_no_warnings() {
        let local = LocalFacts { vendor_registered: true, invalid_numbers: vec![], next_number: Some("INV/2026-001".into()) };
        assert_eq!(build_warnings(&cfg(), &local, &ic_versions("15.73.0")), vec![]);
    }
    #[test]
    fn gst_accounts_not_configured_or_mismatched_are_flagged() {
        let local = LocalFacts { vendor_registered: true, ..Default::default() };
        let mut remote = ic_versions("15.73.0");
        remote.gst_accounts = Some(Ok(vec![]));
        assert_eq!(codes(&build_warnings(&cfg(), &local, &remote)), ["gst_accounts_not_configured"]);
        let mut remote = ic_versions("15.73.0");
        remote.gst_accounts = Some(Ok(vec![json!({ "company": "Test Co", "account_type": "Output",
            "cgst_account": "Output CGST - AC", "sgst_account": "Other SGST - AC", "igst_account": "Output IGST - AC" })]));
        let w = build_warnings(&cfg(), &local, &remote);
        assert_eq!(codes(&w), ["gst_account_mismatch"]);
        assert!(w[0].message.contains("SGST"));
        let mut remote = ic_versions("15.73.0");
        remote.gst_accounts = Some(Err("HTTP 403".into()));
        assert_eq!(codes(&build_warnings(&cfg(), &local, &remote)), ["gst_settings_unreadable"]);
    }
    #[test]
    fn long_numbers_and_series_are_flagged_under_ic_only() {
        let local = LocalFacts {
            vendor_registered: false,
            invalid_numbers: vec!["INVOICE/2026/000001".into()],
            next_number: Some("INVOICE/2026/000002".into()),
        };
        let w = build_warnings(&cfg(), &local, &ic_versions("15.73.0"));
        assert_eq!(codes(&w), ["number_invalid", "number_invalid"]);
        // Plain ERPNext has no such rule.
        let mut plain = ic_versions("15.73.0");
        plain.versions.as_mut().unwrap().india_compliance = None;
        assert!(build_warnings(&cfg(), &local, &plain).is_empty());
        let mut series = cfg();
        series.naming_mode = NamingMode::Series;
        series.naming_series = "LONGPREFIX-ABC-.YYYY.-.#####".into();
        let w = build_warnings(&series, &LocalFacts::default(), &ic_versions("15.73.0"));
        assert_eq!(codes(&w), ["naming_series_too_long"]);
    }
    #[test]
    fn missing_company_address_and_old_frappe_are_flagged() {
        let mut c = cfg();
        c.company_address.clear();
        let w = build_warnings(&c, &LocalFacts::default(), &ic_versions("15.60.0"));
        assert_eq!(codes(&w), ["mirror_unsupported", "company_address_missing"]);
        let mut remote = ic_versions("15.73.0");
        remote.company_address_count = Some(0);
        assert_eq!(codes(&build_warnings(&cfg(), &LocalFacts::default(), &remote)), ["company_address_missing"]);
    }
    #[test]
    fn required_settings_and_unknown_versions_are_flagged() {
        let w = build_warnings(&ErpnextConfig::default(), &LocalFacts { vendor_registered: true, ..Default::default() }, &RemoteFacts::default());
        assert_eq!(codes(&w), ["versions_unknown", "company_missing", "income_account_missing", "tax_accounts_missing"]);
    }
    #[test]
    fn registered_vendor_without_ic_gets_a_notice() {
        let mut remote = ic_versions("15.73.0");
        remote.versions.as_mut().unwrap().india_compliance = None;
        let w = build_warnings(&cfg(), &LocalFacts { vendor_registered: true, ..Default::default() }, &remote);
        assert_eq!(codes(&w), ["ic_not_detected"]);
    }
    // ---- against the mock server ----
    use crate::integrations::erpnext::testutil::{client, reply, serve_fn, Reply};
    fn site(line: &str) -> Reply {
        let path = line.split_whitespace().nth(1).unwrap_or("");
        if path.contains("get_logged_user") {
            reply(200, json!({ "message": "integration@example.com" }))
        } else if path.contains("get_versions") {
            reply(200, json!({ "message": {
                "frappe": { "version": "15.73.0" }, "erpnext": { "version": "15.121.6" }, "india_compliance": { "version": "15.9.0" }
            }}))
        } else if path.starts_with("/api/resource/GST%20Settings/GST%20Settings") {
            reply(200, json!({ "data": { "gst_accounts": [] } }))
        } else if path.starts_with("/api/resource/Address?") {
            reply(200, json!({ "data": [
                { "name": "Test Co-Billing", "address_title": "Test Co", "address_line1": "1 Main Rd", "city": "Mumbai", "state": "Maharashtra", "pincode": "400001", "gstin": "27AAPFU0939F1ZV" }
            ]}))
        } else if path.starts_with("/api/resource/Company?") {
            reply(200, json!({ "data": [{ "name": "Test Co", "company_name": "Test Co", "abbr": "AC", "default_currency": "INR" }] }))
        } else if path.starts_with("/api/resource/Account?") && path.contains("Income") {
            reply(200, json!({ "data": [{ "name": "Sales - AC", "account_name": "Sales", "account_type": "" }] }))
        } else if path.starts_with("/api/resource/Account?") && path.contains("Tax") {
            reply(200, json!({ "data": [{ "name": "Output CGST - AC", "account_name": "Output CGST", "account_type": "Tax" }] }))
        } else if path.starts_with("/api/resource/Price%20List?") {
            reply(403, json!({ "exc_type": "PermissionError", "_error_message": "No permission for Price List" }))
        } else if path.contains("getdoctype") {
            reply(200, json!({ "docs": [{ "fields": [{ "fieldname": "naming_series", "options": "\nSINV-.YY.-" }] }] }))
        } else if path.starts_with("/api/resource/UOM?") {
            reply(200, json!({ "data": [{ "name": "Nos" }, { "name": "Hour" }, { "name": "" }] }))
        } else {
            reply(200, json!({ "data": [] }))
        }
    }
    #[tokio::test]
    async fn connection_test_reports_user_versions_ic_and_warnings() {
        let mock = serve_fn(|_, line| site(line)).await;
        let local = LocalFacts { vendor_registered: true, next_number: Some("INV/2026-001".into()), ..Default::default() };
        let result = test_connection(&client(&mock), &cfg(), &local).await.unwrap();
        assert_eq!(result.user, "integration@example.com");
        assert_eq!(result.versions.frappe.as_deref(), Some("15.73.0"));
        assert!(result.india_compliance && result.features.v2_naming);
        assert_eq!(codes(&result.warnings), ["gst_accounts_not_configured"]);
        let json = serde_json::to_value(&result).unwrap();
        assert_eq!(json["indiaCompliance"], true);
        assert_eq!(json["features"]["v2Naming"], true);
    }
    #[tokio::test]
    async fn company_addresses_fall_back_when_the_site_has_no_gstin_field() {
        // A plain ERPNext (no India Compliance) rejects the custom `gstin` field with a 417.
        let mock = serve_fn(|_, line| {
            let path = line.split_whitespace().nth(1).unwrap_or("");
            if path.starts_with("/api/resource/Address?") && path.contains("gstin") {
                reply(417, json!({ "exc_type": "ValidationError", "_error_message": "Field not permitted in query: gstin" }))
            } else if path.starts_with("/api/resource/Address?") {
                reply(200, json!({ "data": [{ "name": "Test Co-Billing", "address_title": "Test Co", "address_line1": "1 Main Rd", "city": "Mumbai", "state": "Maharashtra", "pincode": "400001" }] }))
            } else {
                reply(200, json!({ "data": [] }))
            }
        })
        .await;
        let options = client(&mock).load_options("Test Co").await.unwrap();
        assert_eq!(options.company_addresses.len(), 1);
        assert_eq!(options.company_addresses[0].name, "Test Co-Billing");
        assert!(options.errors.iter().all(|e| e.list != "companyAddresses"), "{:?}", options.errors);
    }
    #[tokio::test]
    async fn connection_test_fails_for_the_guest_user_and_bad_credentials() {
        let mock = serve_fn(|_, _| reply(200, json!({ "message": "Guest" }))).await;
        let err = test_connection(&client(&mock), &cfg(), &LocalFacts::default()).await.unwrap_err();
        assert_eq!(err.kind, ErrorKind::Auth);
        let mock = serve_fn(|_, _| reply(401, json!({ "message": "Invalid Authorization" }))).await;
        let err = test_connection(&client(&mock), &cfg(), &LocalFacts::default()).await.unwrap_err();
        assert_eq!(err.kind, ErrorKind::Auth);
        assert!(!err.to_string().contains("thesecret"));
    }
    #[tokio::test]
    async fn options_load_per_list_and_one_failure_does_not_hide_the_rest() {
        let mock = serve_fn(|_, line| site(line)).await;
        let options = client(&mock).load_options("Test Co").await.unwrap();
        assert_eq!(options.companies.len(), 1);
        assert_eq!(options.companies[0].name, "Test Co");
        assert_eq!(options.companies[0].detail, "AC · INR");
        assert_eq!(options.company_addresses[0].name, "Test Co-Billing");
        assert!(options.company_addresses[0].detail.contains("Mumbai"));
        assert_eq!(options.income_accounts[0].name, "Sales - AC");
        assert_eq!(options.tax_accounts[0].name, "Output CGST - AC");
        assert_eq!(options.naming_series[0].name, "SINV-.YY.-");
        assert_eq!(options.uoms.iter().map(|u| u.name.as_str()).collect::<Vec<_>>(), ["Nos", "Hour"]);
        assert!(options.price_lists.is_empty());
        assert_eq!(options.errors.len(), 1);
        assert_eq!(options.errors[0].list, "priceLists");
        assert!(options.errors[0].message.contains("No permission for Price List"));
        // Company-scoped lists are skipped until a company is chosen.
        let none = client(&mock).load_options("  ").await.unwrap();
        assert!(none.income_accounts.is_empty() && none.company_addresses.is_empty());
        let requests = mock.requests.lock().unwrap().join("\n");
        assert!(requests.contains("root_type"), "income accounts are filtered by root type");
        assert!(requests.contains("limit_page_length=0"));
    }
    #[tokio::test]
    async fn options_abort_on_authentication_failure() {
        let mock = serve_fn(|_, _| reply(401, json!({ "message": "bad" }))).await;
        let err = client(&mock).load_options("Test Co").await.unwrap_err();
        assert_eq!(err.kind, ErrorKind::Auth);
        assert_eq!(mock.hits.load(std::sync::atomic::Ordering::SeqCst), 1, "stops at the first auth failure");
    }
 }
@@ -0,0 +1,427 @@
 //! Turning Frappe/ERPNext error responses into one readable message plus a machine-usable kind.
 use serde::Serialize;
 use serde_json::Value;
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
 #[serde(rename_all = "snake_case")]
 pub enum ErrorKind {
    /// 401: wrong key/secret.
    Auth,
    /// 403: the user lacks a role or permission.
    Permission,
    NotFound,
    /// 409 (or a `DuplicateEntryError`): the document already exists.
    Duplicate,
    /// 417 and other 4xx data rejections.
    Validation,
    RateLimit,
    Server,
    Timeout,
    Network,
    /// A setting is missing or invalid; nothing was sent.
    Config,
    /// The server answered, but not like a Frappe site.
    Protocol,
    /// The remote document exists with different data; Voiced never overwrites it.
    Conflict,
    /// Voiced refused before sending anything (a draft or cancelled invoice, an unsubmitted parent, bad local data).
    Precondition,
    Other,
 }
 impl ErrorKind {
    fn label(self) -> &'static str {
        match self {
            ErrorKind::Auth => "Authentication failed",
            ErrorKind::Permission => "Permission denied",
            ErrorKind::NotFound => "Not found",
            ErrorKind::Duplicate => "Already exists",
            ErrorKind::Validation => "ERPNext rejected the data",
            ErrorKind::RateLimit => "Rate limited",
            ErrorKind::Server => "ERPNext server error",
            ErrorKind::Timeout
            | ErrorKind::Network
            | ErrorKind::Config
            | ErrorKind::Protocol
            | ErrorKind::Conflict
            | ErrorKind::Precondition => "",
            ErrorKind::Other => "Request failed",
        }
    }
 }
 #[derive(Debug, Clone)]
 pub struct ErpError {
    pub kind: ErrorKind,
    pub status: Option<u16>,
    pub message: String,
    /// Frappe exception class (e.g. `DuplicateEntryError`) when the server named one.
    pub exc_type: Option<String>,
 }
 impl std::fmt::Display for ErpError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let label = self.kind.label();
        match (label.is_empty(), self.status) {
            (true, _) => f.write_str(&self.message),
            (false, Some(status)) => write!(f, "{label} (HTTP {status}): {}", self.message),
            (false, None) => write!(f, "{label}: {}", self.message),
        }
    }
 }
 impl std::error::Error for ErpError {}
 impl From<ErpError> for String {
    fn from(e: ErpError) -> String {
        e.to_string()
    }
 }
 impl ErpError {
    pub fn new(kind: ErrorKind, message: impl Into<String>) -> Self {
        ErpError { kind, status: None, message: message.into(), exc_type: None }
    }
    pub fn config(message: impl Into<String>) -> Self {
        Self::new(ErrorKind::Config, message)
    }
    pub fn protocol(message: impl Into<String>) -> Self {
        Self::new(ErrorKind::Protocol, message)
    }
    /// Builds the error for a non-2xx response.
    pub fn from_response(status: u16, body: &str) -> Self {
        let parsed = parse_error_body(body);
        let mut kind = kind_for_status(status);
        if parsed.exc_type.as_deref() == Some("DuplicateEntryError") {
            kind = ErrorKind::Duplicate;
        }
        let message = parsed.message.unwrap_or_else(|| default_status_text(status));
        ErpError { kind, status: Some(status), message, exc_type: parsed.exc_type }
    }
    /// Removes every occurrence of the given secrets from the message.
    pub fn redacted(mut self, secrets: &[&str]) -> Self {
        for s in secrets.iter().filter(|s| s.len() >= 4) {
            self.message = self.message.replace(s, "[redacted]");
        }
        self
    }
 }
 pub fn kind_for_status(status: u16) -> ErrorKind {
    match status {
        401 => ErrorKind::Auth,
        403 => ErrorKind::Permission,
        404 => ErrorKind::NotFound,
        409 => ErrorKind::Duplicate,
        429 => ErrorKind::RateLimit,
        400 | 417 | 422 => ErrorKind::Validation,
        500..=599 => ErrorKind::Server,
        _ => ErrorKind::Other,
    }
 }
 fn default_status_text(status: u16) -> String {
    let reason = reqwest::StatusCode::from_u16(status)
        .ok()
        .and_then(|s| s.canonical_reason())
        .unwrap_or("unexpected response");
    format!("HTTP {status} {reason}")
 }
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct ParsedError {
    pub message: Option<String>,
    pub exc_type: Option<String>,
 }
 const MAX_MESSAGE_CHARS: usize = 600;
 /// Extracts the human message from a Frappe error body.
 ///
 /// v2 puts `errors[]` first. v1 uses `_server_messages` (a JSON string holding a list of JSON strings,
 /// each usually an object with an HTML `message`), then `_error_message`, then `exception` (with the
 /// `frappe.exceptions.X: ` prefix dropped), then `exc_type`. A body that is not JSON (an nginx 502 page)
 /// yields its stripped text, or nothing when that is empty.
 pub fn parse_error_body(body: &str) -> ParsedError {
    let Ok(json) = serde_json::from_str::<Value>(body) else {
        let text = strip_html(body);
        let first = text.lines().find(|l| !l.trim().is_empty()).unwrap_or("").trim();
        return ParsedError { message: non_empty(truncate(first)), exc_type: None };
    };
    let Some(obj) = json.as_object() else {
        return ParsedError::default();
    };
    let mut exc_type = obj.get("exc_type").and_then(Value::as_str).map(str::to_string);
    let mut messages: Vec<String> = Vec::new();
    if let Some(errors) = obj.get("errors").and_then(Value::as_array) {
        for e in errors {
            match e {
                Value::String(s) => push_unique(&mut messages, strip_html(s)),
                Value::Object(o) => {
                    let text = o.get("message").and_then(Value::as_str).map(strip_html).filter(|m| !m.is_empty());
                    let exception = o.get("exception").and_then(Value::as_str).map(split_exception);
                    if exc_type.is_none() {
                        exc_type = o
                            .get("type")
                            .and_then(Value::as_str)
                            .map(str::to_string)
                            .or_else(|| exception.as_ref().and_then(|(t, _)| t.clone()));
                    }
                    if let Some(m) = text.or_else(|| exception.map(|(_, m)| m).filter(|m| !m.is_empty())) {
                        push_unique(&mut messages, m);
                    }
                }
                _ => {}
            }
        }
    }
    if messages.is_empty() {
        if let Some(raw) = obj.get("_server_messages").and_then(Value::as_str) {
            for m in server_messages(raw) {
                push_unique(&mut messages, m);
            }
        }
    }
    if messages.is_empty() {
        if let Some(m) = obj.get("_error_message").and_then(Value::as_str).map(strip_html).filter(|m| !m.is_empty()) {
            messages.push(m);
        }
    }
    if messages.is_empty() {
        if let Some(raw) = obj.get("exception").and_then(Value::as_str) {
            let (ty, msg) = split_exception(raw);
            if exc_type.is_none() {
                exc_type = ty;
            }
            if !msg.is_empty() {
                messages.push(msg);
            }
        }
    }
    if messages.is_empty() {
        if let Some(m) = obj.get("message").and_then(Value::as_str).map(strip_html).filter(|m| !m.is_empty()) {
            messages.push(m);
        }
    }
    if messages.is_empty() {
        if let Some(t) = &exc_type {
            messages.push(t.clone());
        }
    }
    if exc_type.is_none() {
        // v1 on Frappe 14 has no `exc_type`; the class is still named in `exception`.
        exc_type = obj.get("exception").and_then(Value::as_str).and_then(|e| split_exception(e).0);
    }
    ParsedError { message: non_empty(truncate(&messages.join("; "))), exc_type }
 }
 fn server_messages(raw: &str) -> Vec<String> {
    let Ok(Value::Array(items)) = serde_json::from_str::<Value>(raw) else {
        return Vec::new();
    };
    items
        .iter()
        .filter_map(|item| {
            let text = match item {
                Value::String(s) => match serde_json::from_str::<Value>(s) {
                    Ok(Value::Object(o)) => o.get("message").and_then(Value::as_str).unwrap_or("").to_string(),
                    _ => s.clone(),
                },
                Value::Object(o) => o.get("message").and_then(Value::as_str).unwrap_or("").to_string(),
                _ => String::new(),
            };
            let text = strip_html(&text);
            (!text.is_empty()).then_some(text)
        })
        .collect()
 }
 /// Splits `frappe.exceptions.ValidationError: Row 1: bad` into (`ValidationError`, `Row 1: bad`).
 /// A string without a dotted-identifier prefix is returned whole.
 fn split_exception(raw: &str) -> (Option<String>, String) {
    let first_line = raw.trim().lines().next().unwrap_or("").trim();
    if let Some((prefix, rest)) = first_line.split_once(": ") {
        let class_like = prefix.contains('.') || prefix.ends_with("Error") || prefix.ends_with("Exception");
        if class_like && prefix.chars().all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '.') {
            let ty = prefix.rsplit('.').next().map(str::to_string);
            return (ty, strip_html(rest));
        }
    }
    if !first_line.is_empty()
        && first_line.chars().all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '.')
        && first_line.contains('.')
    {
        // `frappe.exceptions.DoesNotExistError` with no message.
        return (first_line.rsplit('.').next().map(str::to_string), String::new());
    }
    (None, strip_html(first_line))
 }
 fn push_unique(list: &mut Vec<String>, text: String) {
    if !text.is_empty() && !list.contains(&text) {
        list.push(text);
    }
 }
 fn non_empty(s: String) -> Option<String> {
    (!s.is_empty()).then_some(s)
 }
 fn truncate(s: &str) -> String {
    if s.chars().count() <= MAX_MESSAGE_CHARS {
        return s.to_string();
    }
    let cut: String = s.chars().take(MAX_MESSAGE_CHARS).collect();
    format!("{cut}...")
 }
 /// Drops tags, decodes the common entities and collapses whitespace.
 pub fn strip_html(input: &str) -> String {
    let mut out = String::with_capacity(input.len());
    let mut in_tag = false;
    let mut tag = String::new();
    for ch in input.chars() {
        match ch {
            '<' => {
                in_tag = true;
                tag.clear();
            }
            '>' if in_tag => {
                in_tag = false;
                let name = tag.trim_start_matches('/').split_whitespace().next().unwrap_or("").to_ascii_lowercase();
                if matches!(name.as_str(), "br" | "p" | "div" | "li" | "tr" | "h1" | "h2" | "h3") {
                    out.push('\n');
                }
            }
            _ if in_tag => tag.push(ch),
            _ => out.push(ch),
        }
    }
    let decoded = out
        .replace("&nbsp;", " ")
        .replace("&lt;", "<")
        .replace("&gt;", ">")
        .replace("&quot;", "\"")
        .replace("&#39;", "'")
        .replace("&#x27;", "'")
        .replace("&amp;", "&");
    decoded
        .lines()
        .map(|l| l.split_whitespace().collect::<Vec<_>>().join(" "))
        .filter(|l| !l.is_empty())
        .collect::<Vec<_>>()
        .join("\n")
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    use serde_json::json;
    #[test]
    fn v1_server_messages_are_double_encoded_and_html_is_stripped() {
        let inner1 = json!({ "message": "<b>Row 1</b>: Account <i>Sales</i> &amp; more", "indicator": "red" }).to_string();
        let inner2 = json!({ "message": "Second <br> problem" }).to_string();
        let server_messages = serde_json::to_string(&vec![inner1, inner2]).unwrap();
        let body = json!({
            "exc_type": "ValidationError",
            "exception": "frappe.exceptions.ValidationError: ignored because messages exist",
            "_server_messages": server_messages,
        })
        .to_string();
        let parsed = parse_error_body(&body);
        assert_eq!(parsed.message.as_deref(), Some("Row 1: Account Sales & more; Second\nproblem"));
        assert_eq!(parsed.exc_type.as_deref(), Some("ValidationError"));
        let err = ErpError::from_response(417, &body);
        assert_eq!(err.kind, ErrorKind::Validation);
        assert_eq!(err.status, Some(417));
    }
    #[test]
    fn v1_falls_back_to_error_message_then_exception_then_exc_type() {
        let a = parse_error_body(&json!({ "_error_message": "Not <b>permitted</b>" }).to_string());
        assert_eq!(a.message.as_deref(), Some("Not permitted"));
        let b = parse_error_body(
            &json!({ "exception": "frappe.exceptions.DuplicateEntryError: Sales Invoice INV/1 already exists" }).to_string(),
        );
        assert_eq!(b.message.as_deref(), Some("Sales Invoice INV/1 already exists"));
        assert_eq!(b.exc_type.as_deref(), Some("DuplicateEntryError"));
        let c = parse_error_body(&json!({ "exc_type": "PermissionError" }).to_string());
        assert_eq!(c.message.as_deref(), Some("PermissionError"));
    }
    #[test]
    fn exception_prefix_is_only_dropped_when_it_looks_like_a_class_path() {
        let parsed = parse_error_body(&json!({ "exception": "Something: with a colon but no class" }).to_string());
        assert_eq!(parsed.message.as_deref(), Some("Something: with a colon but no class"));
        assert_eq!(parsed.exc_type, None);
    }
    #[test]
    fn v2_errors_array_is_joined() {
        let body = json!({
            "errors": [
                { "type": "ValidationError", "message": "Customer <b>X</b> is disabled", "exception": "frappe.exceptions.ValidationError: x" },
                { "type": "ValidationError", "exception": "frappe.exceptions.ValidationError: Row 2: rate missing" },
            ]
        })
        .to_string();
        let parsed = parse_error_body(&body);
        assert_eq!(parsed.message.as_deref(), Some("Customer X is disabled; Row 2: rate missing"));
        assert_eq!(parsed.exc_type.as_deref(), Some("ValidationError"));
    }
    #[test]
    fn non_json_bodies_use_stripped_text_or_status() {
        let html = "<html><body><h1>502 Bad Gateway</h1><hr>nginx</body></html>";
        let err = ErpError::from_response(502, html);
        assert_eq!(err.kind, ErrorKind::Server);
        assert_eq!(err.message, "502 Bad Gateway");
        let empty = ErpError::from_response(503, "");
        assert_eq!(empty.message, "HTTP 503 Service Unavailable");
    }
    #[test]
    fn statuses_map_to_kinds() {
        for (status, kind) in [
            (401, ErrorKind::Auth),
            (403, ErrorKind::Permission),
            (404, ErrorKind::NotFound),
            (409, ErrorKind::Duplicate),
            (417, ErrorKind::Validation),
            (429, ErrorKind::RateLimit),
            (500, ErrorKind::Server),
            (502, ErrorKind::Server),
            (418, ErrorKind::Other),
        ] {
            assert_eq!(ErpError::from_response(status, "").kind, kind, "status {status}");
        }
        // The exception class wins when the status is generic.
        let dup = ErpError::from_response(417, &json!({ "exc_type": "DuplicateEntryError" }).to_string());
        assert_eq!(dup.kind, ErrorKind::Duplicate);
    }
    #[test]
    fn secrets_are_redacted_from_messages() {
        let err = ErpError::new(ErrorKind::Other, "bad token abc123:topsecret in header").redacted(&["topsecret", "abc123"]);
        assert_eq!(err.message, "bad token [redacted]:[redacted] in header");
    }
    #[test]
    fn display_carries_the_status_and_hint() {
        let err = ErpError::from_response(401, &json!({ "message": "Invalid credentials" }).to_string());
        assert_eq!(err.to_string(), "Authentication failed (HTTP 401): Invalid credentials");
    }
 }
@@ -0,0 +1,755 @@
 //! Live tests against a real ERPNext site. All `#[ignore]`d: they need the stack from
 //! `scripts/erpnext-e2e/README.md` and these environment variables (the setup script prints them):
 //!
 //! - `ERPNEXT_URL`, `ERPNEXT_KEY`, `ERPNEXT_SECRET`: the integration user's credentials;
 //! - `ERPNEXT_COMPANY` (default `Voiced Test Co`) and `ERPNEXT_ABBR` (default `VTC`): the company and its
 //!   abbreviation, from which the account names (`Sales - VTC`, `Output Tax CGST - VTC` ...) are derived;
 //! - `ERPNEXT_IC=1` when the site has India Compliance (enables the IC-only tests).
 //!
 //! Run: `cargo test --manifest-path src-tauri/Cargo.toml live_ -- --ignored --test-threads=1`.
 //! Every test makes its own invoice series (unique prefix per run), so repeated runs never collide.
 use super::client::{ClientOptions, ErpClient};
 use super::config::{self, ErpnextConfig, NamingMode, Secret};
 use super::errors::ErrorKind;
 use super::discovery::{test_connection, ConnectionTest, LocalFacts};
 use super::push::{push_invoice, push_payment, PushResult};
 use crate::commands::invoice::{get_invoice_impl, issue_invoice_impl};
 use crate::commands::payments::{record_payment_impl, PaymentInput};
 use crate::commands::series::start_new_series_impl;
 use crate::models::{Invoice, InvoiceInput};
 use rusqlite::params;
 use serde_json::{json, Value};
 use sha2::{Digest, Sha256};
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Mutex;
 const VENDOR_GSTIN: &str = "27AAPFU0939F1ZV";
 const KA_GSTIN: &str = "29AABCU9603R1ZJ";
 static COUNTER: AtomicUsize = AtomicUsize::new(0);
 fn env(name: &str) -> String {
    std::env::var(name).unwrap_or_else(|_| panic!("set {name} (see scripts/erpnext-e2e/README.md)"))
 }
 fn env_or(name: &str, default: &str) -> String {
    std::env::var(name).unwrap_or_else(|_| default.to_string())
 }
 fn base36(mut n: u64, width: usize) -> String {
    const DIGITS: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyz";
    let mut out = vec![b'0'; width];
    for slot in out.iter_mut().rev() {
        *slot = DIGITS[(n % 36) as usize];
        n /= 36;
    }
    String::from_utf8(out).unwrap()
 }
 struct Live {
    db: Mutex<rusqlite::Connection>,
    dir: tempfile::TempDir,
    http: ErpClient,
    abbr: String,
    ic: bool,
    prefix: String,
 }
 impl Live {
    async fn new(edit: impl FnOnce(&mut ErpnextConfig)) -> Live {
        let abbr = env_or("ERPNEXT_ABBR", "VTC");
        let company = env_or("ERPNEXT_COMPANY", "Voiced Test Co");
        let ic = env_or("ERPNEXT_IC", "0") == "1";
        let mut cfg = ErpnextConfig {
            base_url: env("ERPNEXT_URL"),
            api_key: env("ERPNEXT_KEY"),
            api_secret: Secret::new(env("ERPNEXT_SECRET")),
            company_address: format!("{company}-Billing"),
            company,
            income_account: format!("Sales - {abbr}"),
            cgst_account: format!("Output Tax CGST - {abbr}"),
            sgst_account: format!("Output Tax SGST - {abbr}"),
            utgst_account: format!("Output Tax UTGST - {abbr}"),
            igst_account: format!("Output Tax IGST - {abbr}"),
            cost_center: format!("Main - {abbr}"),
            tds_account: format!("TDS Receivable - {abbr}"),
            payment_bank_account: env_or("ERPNEXT_BANK_ACCOUNT", &format!("HDFC - {abbr}")),
            ..Default::default()
        };
        edit(&mut cfg);
        let http = ErpClient::new(&cfg.base_url, &cfg.api_key, &cfg.api_secret, "", ClientOptions::default()).unwrap();
        let mut conn = crate::db::open_in_memory().unwrap();
        conn.execute(
            "UPDATE app_settings SET gst_registration = 'regular', vendor_gstin = ?1,
             vendor_state_code = '27', vendor_pan = 'AAPFU0939F', default_tax_type = 'cgst_sgst'",
            [VENDOR_GSTIN],
        )
        .unwrap();
        for (name, gstin, state, line1, city, pin, category) in [
            ("Voiced Live Intra Co", "", "27", "5 FC Road", "Pune", "411004", "unregistered"),
            ("Voiced Live Inter Co", KA_GSTIN, "29", "12 MG Road", "Bengaluru", "560001", "registered_regular"),
        ] {
            conn.execute(
                "INSERT INTO clients (name, address, gstin, state_code, address_line1, city, pincode, gst_category, created_at)
                 VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, 'now')",
                params![name, line1, gstin, state, line1, city, pin, category],
            )
            .unwrap();
        }
        let nanos = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos() as u64;
        let prefix = format!("L{}{}/", base36(nanos / 1_000_000, 4), base36(COUNTER.fetch_add(1, Ordering::SeqCst) as u64, 1));
        start_new_series_impl(&mut conn, &prefix, 3).unwrap();
        config::save(&conn, &cfg).unwrap();
        let live = Live { db: Mutex::new(conn), dir: tempfile::tempdir().unwrap(), http, abbr, ic, prefix };
        // The same step the UI performs before the first push.
        let ct = live.connection_test(&cfg).await;
        let mut cfg = cfg;
        cfg.last_detect_result = serde_json::to_string(&ct).unwrap();
        config::save(&live.db.lock().unwrap(), &cfg).unwrap();
        live
    }
    async fn connection_test(&self, cfg: &ErpnextConfig) -> ConnectionTest {
        let local = LocalFacts { vendor_registered: true, ..Default::default() };
        test_connection(&self.http, cfg, &local).await.expect("connection test")
    }
    fn cfg(&self) -> ErpnextConfig {
        config::load(&self.db.lock().unwrap()).unwrap()
    }
    fn save_cfg(&self, edit: impl FnOnce(&mut ErpnextConfig)) {
        let mut cfg = self.cfg();
        edit(&mut cfg);
        config::save(&self.db.lock().unwrap(), &cfg).unwrap();
    }
    fn preset(&self, description: &str, code: &str) {
        self.db
            .lock()
            .unwrap()
            .execute(
                "INSERT INTO item_presets (description, hsn_sac, mode, unit, rate_paise, sort_order, created_at, erpnext_item_code)
                 VALUES (?1, '', 'fixed', 'unit', 0, 0, 'now', ?2)",
                params![description, code],
            )
            .unwrap();
    }
    /// Issues an invoice for one of the two live clients. `extra` overrides input fields.
    fn issue(&self, intra: bool, items: Value, extra: Value) -> Invoice {
        let (client_id, name, pos, tax_type, gstin) = if intra {
            (1, "Voiced Live Intra Co", "27", "cgst_sgst", "")
        } else {
            (2, "Voiced Live Inter Co", "29", "igst", KA_GSTIN)
        };
        let mut input = json!({
            "invoiceDate": "2026-06-15",
            "dueDate": "2026-07-15",
            "clientId": client_id,
            "clientName": name,
            "clientGstin": gstin,
            "placeOfSupplyStateCode": pos,
            "taxType": tax_type,
            "taxRate": 18.0,
            "items": items,
        });
        for (k, v) in extra.as_object().unwrap() {
            input[k] = v.clone();
        }
        let input: InvoiceInput = serde_json::from_value(input).unwrap();
        let mut conn = self.db.lock().unwrap();
        let inv = issue_invoice_impl(&mut conn, self.dir.path(), input, &json!({})).unwrap();
        get_invoice_impl(&conn, inv.id).unwrap()
    }
    /// Puts a small PDF in the archive and records its hash, as exporting the invoice would.
    fn archive(&self, inv: &Invoice) {
        let bytes = minimal_pdf(&inv.number);
        let sha = format!("{:x}", Sha256::digest(&bytes));
        let dir = self.dir.path().join("archive");
        std::fs::create_dir_all(&dir).unwrap();
        std::fs::write(dir.join(format!("{sha}.pdf")), &bytes).unwrap();
        self.db
            .lock()
            .unwrap()
            .execute("UPDATE invoices SET archived_pdf_sha256 = ?1 WHERE id = ?2", params![sha, inv.id])
            .unwrap();
    }
    async fn push(&self, inv: &Invoice, submit: Option<bool>) -> PushResult {
        push_invoice(&self.db, self.dir.path(), &self.http, inv.id, submit).await
    }
    async fn doc(&self, doctype: &str, name: &str) -> Value {
        let v = self.http.get(&["api", "resource", doctype, name], &[]).await.unwrap_or_else(|e| panic!("read {doctype} {name}: {e}"));
        v["data"].clone()
    }
    async fn invoices_named(&self, number: &str) -> Vec<Value> {
        self.http
            .list_resource("Sales Invoice", &["name", "docstatus", "grand_total", "remarks"], json!([["remarks", "like", format!("%{number}%")]]), "creation asc")
            .await
            .unwrap()
    }
    async fn files_of(&self, doctype: &str, name: &str) -> Vec<Value> {
        self.http
            .list_resource(
                "File",
                &["name", "file_name", "is_private", "file_url"],
                json!([["attached_to_doctype", "=", doctype], ["attached_to_name", "=", name]]),
                "creation asc",
            )
            .await
            .unwrap()
    }
    fn payment(&self, inv: &Invoice, cash: i64, tds: i64) -> i64 {
        let mut conn = self.db.lock().unwrap();
        record_payment_impl(
            &mut conn,
            PaymentInput {
                invoice_id: inv.id,
                paid_on: "2026-06-20".into(),
                amount_paise: cash,
                tds_paise: tds,
                mode: "bank_transfer".into(),
                reference: "UTR-LIVE-1".into(),
                notes: String::new(),
            },
        )
        .unwrap()
        .id
    }
 }
 /// A tiny but structurally valid one-page PDF; Frappe parses uploaded PDFs, so a stub header is rejected.
 fn minimal_pdf(label: &str) -> Vec<u8> {
    let stream = format!("BT /F1 12 Tf 20 100 Td ({label}) Tj ET");
    let objects = [
        "<< /Type /Catalog /Pages 2 0 R >>".to_string(),
        "<< /Type /Pages /Kids [3 0 R] /Count 1 >>".to_string(),
        "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 200 200] /Contents 4 0 R /Resources << /Font << /F1 5 0 R >> >> >>".to_string(),
        format!("<< /Length {} >>\nstream\n{stream}\nendstream", stream.len()),
        "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>".to_string(),
    ];
    let mut out = b"%PDF-1.4\n".to_vec();
    let mut offsets = Vec::new();
    for (i, body) in objects.iter().enumerate() {
        offsets.push(out.len());
        out.extend(format!("{} 0 obj\n{body}\nendobj\n", i + 1).into_bytes());
    }
    let xref = out.len();
    out.extend(format!("xref\n0 {}\n0000000000 65535 f \n", objects.len() + 1).into_bytes());
    for o in offsets {
        out.extend(format!("{o:010} 00000 n \n").into_bytes());
    }
    out.extend(format!("trailer\n<< /Size {} /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n", objects.len() + 1).into_bytes());
    out
 }
 fn paise(v: &Value) -> i64 {
    (v.as_f64().unwrap_or_else(|| panic!("not a number: {v}")) * 100.0).round() as i64
 }
 fn assert_pushed(r: &PushResult) {
    assert!(r.ok, "push failed: {:?} {:?}", r.error, r.warnings);
    assert_eq!(r.status, "synced");
 }
 /// The invoice as ERPNext holds it: total equals Voiced's, tax rows are what Voiced computed.
 async fn assert_matches(live: &Live, inv: &Invoice, doc: &Value) {
    assert_eq!(paise(&doc["grand_total"]), crate::gst::rupees_to_paise(inv.total), "grand_total of {}", inv.number);
    assert_eq!(doc["rounded_total"].as_f64().unwrap_or(0.0), 0.0, "rounding is disabled");
    assert_eq!(doc["posting_date"], inv.invoice_date.as_str());
    let taxes = doc["taxes"].as_array().unwrap();
    let by_head = |needle: &str| -> Option<i64> {
        taxes
            .iter()
            .find(|t| t["account_head"].as_str().unwrap_or("").contains(needle))
            .map(|t| paise(&t["tax_amount"]))
    };
    assert_eq!(by_head("CGST").unwrap_or(0), crate::gst::rupees_to_paise(inv.cgst_amount).max(0), "CGST of {}", inv.number);
    // IGST rows contain "IGST"; "CGST" and "SGST" rows do not.
    assert_eq!(by_head("SGST").unwrap_or(0), crate::gst::rupees_to_paise(inv.sgst_amount), "SGST of {}", inv.number);
    assert_eq!(by_head("IGST").unwrap_or(0), crate::gst::rupees_to_paise(inv.igst_amount), "IGST of {}", inv.number);
    let _ = live;
 }
 // ---- connection and discovery ----
 #[tokio::test]
 #[ignore = "needs the live ERPNext stack"]
 async fn live_connection_and_options() {
    let live = Live::new(|_| {}).await;
    let cfg = live.cfg();
    let ct = live.connection_test(&cfg).await;
    println!("{}", serde_json::to_string_pretty(&ct).unwrap());
    assert!(ct.user.contains('@'));
    assert_eq!(ct.versions.frappe.as_deref().map(|v| v.starts_with("15.")), Some(true));
    assert!(ct.versions.erpnext.is_some());
    assert_eq!(ct.india_compliance, live.ic);
    assert!(ct.features.v2_naming, "frappe >= 15.73 supports v2 naming");
    let o = live.http.load_options(&cfg.company).await.unwrap();
    println!("option errors: {:?}", o.errors);
    assert!(o.errors.is_empty(), "{:?}", o.errors);
    let has = |list: &[super::discovery::OptionItem], name: &str| list.iter().any(|i| i.name == name);
    assert!(has(&o.companies, &cfg.company));
    assert!(has(&o.income_accounts, &cfg.income_account), "{:?}", o.income_accounts);
    assert!(o.tax_accounts.iter().any(|a| a.name.contains("CGST")), "{:?}", o.tax_accounts);
    assert!(has(&o.uoms, "Hour") && has(&o.uoms, "Nos"));
    assert!(!o.company_addresses.is_empty());
    assert!(!o.naming_series.is_empty());
    assert!(!o.cost_centers.is_empty() && !o.customer_groups.is_empty() && !o.territories.is_empty());
 }
 // ---- Sales Invoice mapping ----
 #[tokio::test]
 #[ignore = "needs the live ERPNext stack"]
 async fn live_push_matrix() {
    let live = Live::new(|_| {}).await;
    live.preset("Preset service", "VOICED-SERVICE");
    let hsn = |i: Value| {
        let mut i = i;
        if live.ic {
            i["hsnSac"] = json!("998314");
        }
        i
    };
    let cases: Vec<(&str, Invoice)> = vec![
        (
            "cgst_sgst",
            live.issue(true, json!([hsn(json!({"description": "Design", "mode": "fixed", "amount": 7310.0}))]), json!({})),
        ),
        (
            "igst, fractional hours",
            live.issue(
                false,
                json!([hsn(json!({"description": "Consulting", "mode": "rate", "rate": 1234.56, "unit": "hour", "quantity": 2.5}))]),
                json!({}),
            ),
        ),
        (
            "discount, repeated description",
            live.issue(
                true,
                json!([
                    hsn(json!({"description": "Logo", "mode": "fixed", "amount": 3000.0})),
                    hsn(json!({"description": "Logo", "mode": "fixed", "amount": 2000.5})),
                ]),
                json!({"discount": 500.25}),
            ),
        ),
        (
            "item code via preset",
            live.issue(
                true,
                json!([
                    hsn(json!({"description": "Preset service", "mode": "fixed", "amount": 1000.0})),
                    hsn(json!({"description": "Code-less", "mode": "fixed", "amount": 250.0})),
                ]),
                json!({"notes": "Thanks\nsecond line"}),
            ),
        ),
    ];
    for (label, inv) in &cases {
        live.archive(inv);
        let r = live.push(inv, None).await;
        println!("{label}: {} -> {} (warnings {:?})", inv.number, r.remote_name, r.warnings);
        assert_pushed(&r);
        assert!(r.created && r.attached, "{label}: {r:?}");
        assert_eq!(r.remote_name, inv.number, "mirror naming keeps the Voiced number");
        let doc = live.doc("Sales Invoice", &r.remote_name).await;
        assert_eq!(doc["docstatus"], 0);
        assert_matches(&live, inv, &doc).await;
        let files = live.files_of("Sales Invoice", &r.remote_name).await;
        assert_eq!(files.len(), 1, "{files:?}");
        assert_eq!(files[0]["is_private"], 1, "the PDF attachment is private");
    }
    // Customer and address shape, as ERPNext stored them.
    let inter = &cases[1].1;
    let doc = live.doc("Sales Invoice", &inter.number).await;
    let customer = live.doc("Customer", doc["customer"].as_str().unwrap()).await;
    assert_eq!(customer["customer_name"], "Voiced Live Inter Co");
    assert_eq!(customer["customer_type"], "Company");
    let address = live.doc("Address", doc["customer_address"].as_str().unwrap()).await;
    println!("address: {}", json!({"state": address["state"], "country": address["country"], "pincode": address["pincode"], "city": address["city"], "type": address["address_type"], "links": address["links"], "gst_category": address["gst_category"], "gstin": address["gstin"]}));
    assert_eq!(address["state"], "Karnataka");
    assert_eq!(address["country"], "India");
    assert_eq!(address["address_type"], "Billing");
    assert_eq!(address["links"][0]["link_name"], customer["name"]);
    if live.ic {
        assert_eq!(customer["gstin"], KA_GSTIN);
        assert_eq!(customer["gst_category"], "Registered Regular");
        assert_eq!(address["gstin"], KA_GSTIN);
        assert_eq!(doc["place_of_supply"], "29-Karnataka");
    }
    // A fresh local database (lost link) reuses the customer's address instead of creating another.
    let again = Live::new(|_| {}).await;
    let inv = again.issue(false, json!([{"description": "Again", "mode": "fixed", "amount": 100.0, "hsnSac": "998314"}]), json!({}));
    assert_pushed(&again.push(&inv, None).await);
    let d2 = again.doc("Sales Invoice", &inv.number).await;
    assert_eq!(d2["customer_address"], doc["customer_address"], "address reused");
    assert_eq!(d2["customer"], doc["customer"]);
 }
 #[tokio::test]
 #[ignore = "needs the live ERPNext stack"]
 async fn live_half_paise_rounding() {
    let live = Live::new(|_| {}).await;
    let banker = env_or("ERPNEXT_ROUNDING", "banker") == "banker";
    // (taxable amount, discount): 9% of 10.50 is 0.945, 18% of 0.25 is 0.045 and so on. Voiced rounds half up.
    // Half-even and half-up agree when the digit before the tie is odd (3.50 -> 0.315 -> 0.32), so only the
    // first two are certain to differ under Banker's Rounding.
    let ties = [(10.5, 0.0, true), (7310.5, 0.0, true), (3.5, 0.0, false), (0.25, 0.0, false), (99.99, 0.15, false)];
    for (amount, discount, tie) in ties {
        let inv = live.issue(
            true,
            json!([{"description": format!("Rounding {amount}"), "mode": "fixed", "amount": amount, "hsnSac": "998314"}]),
            json!({"discount": discount}),
        );
        let r = live.push(&inv, Some(true)).await;
        println!("{amount}/{discount} tie={tie} banker={banker}: ok={} {:?}", r.ok, r.error);
        if tie && banker {
            // ERPNext's Banker's Rounding disagrees by a paise: the draft is reported, kept, and never submitted.
            assert!(!r.ok && r.status == "conflict" && r.error_kind == Some(ErrorKind::Conflict), "{r:?}");
            let msg = r.error.as_deref().unwrap();
            assert!(msg.contains("Commercial Rounding") && msg.contains("does not submit"), "{msg}");
            assert_eq!(r.remote_name, inv.number);
            let doc = live.doc("Sales Invoice", &r.remote_name).await;
            assert_eq!(doc["docstatus"], 0, "a mismatching document is never submitted");
            assert!(live.files_of("Sales Invoice", &r.remote_name).await.is_empty());
            // Pushing again finds the same draft and reports the same conflict instead of creating another.
            let again = live.push(&inv, Some(true)).await;
            assert!(!again.ok && again.status == "conflict", "{again:?}");
        } else {
            assert_pushed(&r);
            assert_eq!(r.remote_docstatus, 1);
            let doc = live.doc("Sales Invoice", &r.remote_name).await;
            assert_matches(&live, &inv, &doc).await;
        }
    }
 }
 #[tokio::test]
 #[ignore = "needs the live ERPNext stack"]
 async fn live_repush_is_idempotent() {
    let live = Live::new(|_| {}).await;
    let inv = live.issue(true, json!([{"description": "Design", "mode": "fixed", "amount": 500.0, "hsnSac": "998314"}]), json!({}));
    live.archive(&inv);
    let first = live.push(&inv, None).await;
    assert_pushed(&first);
    assert!(first.created);
    // Second push with the sync row present: nothing to do.
    let again = live.push(&inv, None).await;
    assert_pushed(&again);
    assert!(again.no_op && !again.created, "{again:?}");
    // Lose the local sync state: the POST gets a 409 and the document is adopted, not duplicated.
    live.db.lock().unwrap().execute("DELETE FROM erpnext_sync", []).unwrap();
    let adopted = live.push(&inv, None).await;
    assert_pushed(&adopted);
    assert!(adopted.attached, "{adopted:?}");
    assert!(!adopted.created, "{adopted:?}");
    assert_eq!(adopted.remote_name, first.remote_name);
    let all = live
        .http
        .list_resource("Sales Invoice", &["name"], json!([["name", "=", inv.number.clone()]]), "name asc")
        .await
        .unwrap();
    assert_eq!(all.len(), 1);
    // Losing the sync row also loses the attachment hash; the adopted document must not get a second copy.
    let files = live.files_of("Sales Invoice", &first.remote_name).await;
    assert_eq!(files.len(), 1, "{files:?}");
    assert_eq!(files[0]["is_private"], 1);
 }
 #[tokio::test]
 #[ignore = "needs the live ERPNext stack"]
 async fn live_submit_paths() {
    let live = Live::new(|_| {}).await;
    // Submit while creating.
    let a = live.issue(true, json!([{"description": "A", "mode": "fixed", "amount": 100.0, "hsnSac": "998314"}]), json!({}));
    let r = live.push(&a, Some(true)).await;
    assert_pushed(&r);
    assert_eq!(r.remote_docstatus, 1);
    assert_eq!(live.doc("Sales Invoice", &r.remote_name).await["docstatus"], 1);
    // Submit an existing draft in a later push (mirror: v2 method route).
    let b = live.issue(true, json!([{"description": "B", "mode": "fixed", "amount": 200.0, "hsnSac": "998314"}]), json!({}));
    assert_pushed(&live.push(&b, Some(false)).await);
    let r = live.push(&b, Some(true)).await;
    assert_pushed(&r);
    assert_eq!(r.remote_docstatus, 1);
    assert_eq!(live.doc("Sales Invoice", &b.number).await["docstatus"], 1);
 }
 #[tokio::test]
 #[ignore = "needs the live ERPNext stack"]
 async fn live_series_naming_mode() {
    let live = Live::new(|c| c.naming_mode = NamingMode::Series).await;
    let o = live.http.load_options(&live.cfg().company).await.unwrap();
    let series = o.naming_series.first().expect("a naming series").name.clone();
    println!("series options: {:?}", o.naming_series);
    live.save_cfg(|c| c.naming_series = series.clone());
    let inv = live.issue(true, json!([{"description": "Series", "mode": "fixed", "amount": 700.0, "hsnSac": "998314"}]), json!({"notes": "note"}));
    live.archive(&inv);
    let r = live.push(&inv, Some(false)).await;
    assert_pushed(&r);
    assert!(r.created);
    assert_ne!(r.remote_name, inv.number, "series mode lets ERPNext name it");
    let doc = live.doc("Sales Invoice", &r.remote_name).await;
    assert!(doc["remarks"].as_str().unwrap().starts_with(&format!("Voiced invoice {}", inv.number)), "{}", doc["remarks"]);
    assert_matches(&live, &inv, &doc).await;
    // Lose the sync row: the remarks lookup finds the document instead of creating another.
    live.db.lock().unwrap().execute("DELETE FROM erpnext_sync", []).unwrap();
    let again = live.push(&inv, Some(false)).await;
    assert_pushed(&again);
    assert!(!again.created, "{again:?}");
    assert_eq!(again.remote_name, r.remote_name);
    assert_eq!(live.invoices_named(&inv.number).await.len(), 1);
    // Submit through the v1 run_method route.
    let s = live.push(&inv, Some(true)).await;
    assert_pushed(&s);
    assert_eq!(s.remote_docstatus, 1);
    assert_eq!(live.doc("Sales Invoice", &r.remote_name).await["docstatus"], 1);
 }
 #[tokio::test]
 #[ignore = "needs the live ERPNext stack"]
 async fn live_uom_and_quantities() {
    let live = Live::new(|_| {}).await;
    live.preset("Nos preset", "VOICED-SERVICE"); // stock UOM Nos
    live.preset("Hourly preset", "VOICED-HOURLY"); // stock UOM Hour
    let row = |desc: &str, unit: &str, qty: f64| json!([{"description": desc, "mode": "rate", "rate": 100.0, "unit": unit, "quantity": qty, "hsnSac": "998314"}]);
    let mut outcomes = Vec::new();
    for (label, desc, unit, qty) in [
        ("Hour row on a Nos item, whole qty", "Nos preset", "hour", 2.0),
        ("Hour row on a Nos item, fractional qty", "Nos preset", "hour", 1.5),
        ("Hour row on an Hour item, fractional qty", "Hourly preset", "hour", 1.5),
        ("Nos row on an Hour item, whole qty", "Hourly preset", "unit", 3.0),
        ("code-less hours, fractional qty", "Code-less hours", "hour", 1.5),
        ("code-less minutes, fractional qty", "Code-less minutes", "minute", 90.5),
        ("code-less Nos, fractional qty", "Code-less nos", "unit", 1.5),
        ("code-less Nos, whole qty", "Code-less nos whole", "unit", 4.0),
    ] {
        let inv = live.issue(true, row(desc, unit, qty), json!({}));
        let r = live.push(&inv, None).await;
        println!("{label}: ok={} {}", r.ok, r.error.clone().unwrap_or_default());
        outcomes.push((label, r.ok));
    }
    println!("{outcomes:?}");
    let ok = |l: &str| outcomes.iter().find(|(k, _)| *k == l).unwrap().1;
    assert!(ok("Hour row on an Hour item, fractional qty"));
    assert!(ok("code-less hours, fractional qty") && ok("code-less minutes, fractional qty"));
    assert!(ok("code-less Nos, whole qty"));
    assert!(!ok("code-less Nos, fractional qty"), "ERPNext refuses a fraction of a whole-number UOM");
 }
 // ---- payments ----
 #[tokio::test]
 #[ignore = "needs the live ERPNext stack"]
 async fn live_payment_entry() {
    let live = Live::new(|_| {}).await;
    let inv = live.issue(true, json!([{"description": "Billable", "mode": "fixed", "amount": 10000.0, "hsnSac": "998314"}]), json!({}));
    assert_pushed(&live.push(&inv, Some(true)).await);
    let total = crate::gst::rupees_to_paise(inv.total);
    // 10% TDS on the taxable value: 1000.00; the cash received is the rest.
    let tds = 100_000;
    let cash = total - tds;
    let pid = live.payment(&inv, cash, tds);
    let r = push_payment(&live.db, &live.http, pid).await;
    println!("payment: {r:?}");
    assert!(r.ok, "{:?}", r.error);
    let entry = r.entry_name.clone().unwrap();
    let pe = live.doc("Payment Entry", &entry).await;
    let keys = ["payment_type", "party_type", "paid_from", "paid_to", "paid_amount", "received_amount", "base_paid_amount", "base_received_amount", "total_allocated_amount", "unallocated_amount", "difference_amount", "reference_no", "reference_date", "posting_date", "bank_account", "mode_of_payment", "status"];
    println!("PE {}", json!(keys.iter().map(|k| (k.to_string(), pe[*k].clone())).collect::<serde_json::Map<_, _>>()));
    println!("PE references {}", pe["references"].as_array().unwrap().iter().map(|r| json!({"ref": r["reference_name"], "allocated": r["allocated_amount"], "total": r["total_amount"], "outstanding": r["outstanding_amount"]}).to_string()).collect::<Vec<_>>().join(","));
    println!("PE deductions {}", pe["deductions"].as_array().unwrap().iter().map(|r| json!({"account": r["account"], "cost_center": r["cost_center"], "amount": r["amount"], "description": r["description"]}).to_string()).collect::<Vec<_>>().join(","));
    assert_eq!(paise(&pe["paid_amount"]), cash);
    assert_eq!(paise(&pe["received_amount"]), cash);
    assert_eq!(paise(&pe["total_allocated_amount"]), cash + tds);
    assert_eq!(paise(&pe["difference_amount"]), 0);
    let ded = pe["deductions"].as_array().unwrap();
    assert_eq!(ded.len(), 1);
    assert_eq!(ded[0]["account"], live.cfg().tds_account.as_str());
    assert_eq!(paise(&ded[0]["amount"]), tds, "a TDS deduction row is a positive amount");
    assert_eq!(pe["reference_no"], "UTR-LIVE-1");
    assert_eq!(pe["posting_date"], "2026-06-20");
    assert_eq!(pe["paid_to"], live.cfg().payment_bank_account.as_str(), "money lands in the configured bank account");
    let inv_doc = live.doc("Sales Invoice", &inv.number).await;
    println!("outstanding after payment: {}", inv_doc["outstanding_amount"]);
    assert_eq!(pe["docstatus"], 1);
    assert_eq!(paise(&inv_doc["outstanding_amount"]), 0, "cash plus TDS settles the invoice");
    // Idempotent locally.
    let again = push_payment(&live.db, &live.http, pid).await;
    assert!(again.ok && again.already_synced);
 }
 #[tokio::test]
 #[ignore = "needs the live ERPNext stack"]
 async fn live_payment_without_tds() {
    let live = Live::new(|_| {}).await;
    let inv = live.issue(true, json!([{"description": "Plain", "mode": "fixed", "amount": 1000.0, "hsnSac": "998314"}]), json!({}));
    assert_pushed(&live.push(&inv, Some(true)).await);
    let total = crate::gst::rupees_to_paise(inv.total);
    let pid = live.payment(&inv, total / 2, 0);
    let r = push_payment(&live.db, &live.http, pid).await;
    assert!(r.ok, "{:?}", r.error);
    let inv_doc = live.doc("Sales Invoice", &inv.number).await;
    assert_eq!(paise(&inv_doc["outstanding_amount"]), total - total / 2, "partial payment leaves the rest outstanding");
 }
 // ---- India Compliance only (ERPNEXT_IC=1) ----
 fn skip_without_ic() -> bool {
    if env_or("ERPNEXT_IC", "0") != "1" {
        eprintln!("skipped: the site has no India Compliance (ERPNEXT_IC is not 1)");
        return true;
    }
    false
 }
 #[tokio::test]
 #[ignore = "needs the live ERPNext stack with India Compliance"]
 async fn live_ic_hsn_enforcement() {
    if skip_without_ic() {
        return;
    }
    let live = Live::new(|_| {}).await;
    let mut outcomes = Vec::new();
    for (label, hsn) in [("no HSN", ""), ("4-digit HSN", "9983"), ("6-digit HSN", "998314"), ("8-digit HSN", "99831400")] {
        let inv = live.issue(true, json!([{"description": format!("HSN {label}"), "mode": "fixed", "amount": 1000.0, "hsnSac": hsn}]), json!({}));
        let r = live.push(&inv, Some(true)).await;
        println!("{label}: ok={} docstatus={} err={:?}", r.ok, r.remote_docstatus, r.error);
        outcomes.push((label, r));
    }
    let get = |l: &str| &outcomes.iter().find(|(k, _)| *k == l).unwrap().1;
    assert!(get("6-digit HSN").ok && get("6-digit HSN").remote_docstatus == 1);
    assert!(get("8-digit HSN").ok && get("8-digit HSN").remote_docstatus == 1);
    for bad in ["no HSN", "4-digit HSN"] {
        let r = get(bad);
        assert!(!r.ok, "{bad} must be refused: {r:?}");
        let msg = r.error.as_deref().unwrap();
        assert!(msg.to_ascii_uppercase().contains("HSN"), "{bad}: {msg}");
    }
 }
 #[tokio::test]
 #[ignore = "needs the live ERPNext stack with India Compliance"]
 async fn live_ic_number_longer_than_16_characters() {
    if skip_without_ic() {
        return;
    }
    let live = Live::new(|_| {}).await;
    let inv = live.issue(true, json!([{"description": "Long number", "mode": "fixed", "amount": 1000.0, "hsnSac": "998314"}]), json!({}));
    // Voiced never issues such a number; this is a number imported or migrated from elsewhere.
    let long = format!("{}-EXTRA-LONG-PART", inv.number);
    assert!(long.len() > 16);
    live.db.lock().unwrap().execute("UPDATE invoices SET number = ?1 WHERE id = ?2", params![long, inv.id]).unwrap();
    let r = live.push(&inv, None).await;
    println!("long number: ok={} err={:?}", r.ok, r.error);
    assert!(!r.ok);
    let msg = r.error.as_deref().unwrap();
    assert!(msg.contains("16"), "{msg}");
 }
 #[tokio::test]
 #[ignore = "needs the live ERPNext stack with India Compliance"]
 async fn live_ic_gst_account_warnings() {
    if skip_without_ic() {
        return;
    }
    let live = Live::new(|_| {}).await;
    let local = LocalFacts { vendor_registered: true, ..Default::default() };
    let codes = |ct: &ConnectionTest| ct.warnings.iter().map(|w| w.code.clone()).collect::<Vec<_>>();
    let clean = test_connection(&live.http, &live.cfg(), &local).await.unwrap();
    assert!(clean.warnings.is_empty(), "{:?}", clean.warnings);
    let mut cfg = live.cfg();
    cfg.cgst_account = format!("Input Tax CGST - {}", live.abbr);
    let wrong = test_connection(&live.http, &cfg, &local).await.unwrap();
    assert_eq!(codes(&wrong), ["gst_account_mismatch"], "{:?}", wrong.warnings);
    let mut cfg = live.cfg();
    cfg.company = "No Such Co".into();
    let other = test_connection(&live.http, &cfg, &local).await.unwrap();
    assert!(codes(&other).contains(&"gst_accounts_not_configured".to_string()), "{:?}", other.warnings);
    // Mirror mode with a number the site would refuse.
    let local = LocalFacts { vendor_registered: true, next_number: Some("TOOLONG-INVOICE-0001".into()), ..Default::default() };
    let ct = test_connection(&live.http, &live.cfg(), &local).await.unwrap();
    assert!(codes(&ct).contains(&"number_invalid".to_string()), "{:?}", ct.warnings);
 }
 #[tokio::test]
 #[ignore = "needs the live ERPNext stack with India Compliance"]
 async fn live_ic_reverse_charge_and_gst_fields() {
    if skip_without_ic() {
        return;
    }
    let live = Live::new(|_| {}).await;
    let inv = live.issue(false, json!([{"description": "RCM service", "mode": "fixed", "amount": 1000.0, "hsnSac": "998314"}]), json!({"reverseCharge": true}));
    let r = live.push(&inv, None).await;
    // India Compliance refuses is_reverse_charge=1 without negative RCM tax rows ("Booked reverse charge is not
    // equal to applied tax amount"), whatever GST Settings say, so it is sent as 0 with a warning.
    assert_pushed(&r);
    assert!(r.warnings.iter().any(|w| w.contains("reverse charge")), "{:?}", r.warnings);
    let doc = live.doc("Sales Invoice", &r.remote_name).await;
    assert_eq!(doc["is_reverse_charge"], 0);
    assert_matches(&live, &inv, &doc).await;
    assert_eq!(doc["place_of_supply"], "29-Karnataka");
    assert_eq!(doc["company_gstin"], VENDOR_GSTIN);
    assert_eq!(doc["gst_category"], "Registered Regular");
 }
 #[tokio::test]
 #[ignore = "needs the live ERPNext stack with India Compliance"]
 async fn live_ic_state_names_match_voiced() {
    if skip_without_ic() {
        return;
    }
    let live = Live::new(|_| {}).await;
    let v = live.http.get(&["api", "method", "frappe.desk.form.load.getdoctype"], &[("doctype", "Address".to_string())]).await.unwrap();
    let docs = v["docs"].as_array().unwrap();
    let address = docs.iter().find(|d| d["name"] == "Address").unwrap();
    let options = address["fields"].as_array().unwrap().iter().find(|f| f["fieldname"] == "gst_state").expect("IC adds gst_state");
    let ic: Vec<&str> = options["options"].as_str().unwrap().lines().map(str::trim).filter(|l| !l.is_empty()).collect();
    for (code, name) in crate::gst::STATES {
        assert!(ic.contains(name), "India Compliance has no state named {name:?} ({code}); it has {ic:?}");
    }
    assert_eq!(ic.len(), crate::gst::STATES.len(), "{ic:?}");
 }
 #[tokio::test]
 #[ignore = "needs the live ERPNext stack"]
 async fn live_payment_edge_cases() {
    let live = Live::new(|_| {}).await;
    let inv = live.issue(true, json!([{"description": "Edge", "mode": "fixed", "amount": 1000.0, "hsnSac": "998314"}]), json!({}));
    // Not submitted yet: refused locally, nothing sent.
    assert_pushed(&live.push(&inv, Some(false)).await);
    let early = live.payment(&inv, 100_00, 0);
    let r = push_payment(&live.db, &live.http, early).await;
    assert!(!r.ok && r.error.as_deref().unwrap().contains("not submitted"), "{r:?}");
    assert_pushed(&live.push(&inv, Some(true)).await);
    let total = crate::gst::rupees_to_paise(inv.total);
    // TDS only (no cash): settled by deduction alone.
    let tds_only = live.payment(&inv, 0, total - 100_00);
    let r = push_payment(&live.db, &live.http, tds_only).await;
    assert!(!r.ok && r.error.as_deref().unwrap().contains("TDS only"), "{r:?}");
    // Without a configured TDS account a TDS payment is refused locally.
    live.save_cfg(|c| c.tds_account = String::new());
    let inv2 = live.issue(true, json!([{"description": "Edge 2", "mode": "fixed", "amount": 1000.0, "hsnSac": "998314"}]), json!({}));
    assert_pushed(&live.push(&inv2, Some(true)).await);
    let t = live.payment(&inv2, 100_00, 50_00);
    let r = push_payment(&live.db, &live.http, t).await;
    assert!(!r.ok && r.error.as_deref().unwrap().contains("TDS account"), "{r:?}");
 }
@@ -0,0 +1,18 @@
 //! ERPNext / Frappe integration. All HTTP runs in Rust (see `client`); `mapping` is pure and
 //! snapshot-tested; `config` owns the stored settings and the API secret.
 // Parts of this module are only used by the later UI step.
 #![allow(dead_code)]
 pub mod client;
 pub mod config;
 pub mod discovery;
 pub mod errors;
 pub mod mapping;
 pub mod push;
 #[cfg(test)]
 pub(crate) mod testutil;
 #[cfg(test)]
 mod live_tests;
@@ -0,0 +1,117 @@
 //! A tiny HTTP/1.1 mock server for client tests (one request per connection, scripted or routed replies).
 use super::client::{ClientOptions, ErpClient};
 use super::config::Secret;
 use serde_json::Value;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::TcpListener;
 pub struct Reply {
    pub status: u16,
    pub headers: Vec<(&'static str, String)>,
    pub body: String,
    /// Pause before answering, to trigger the read timeout.
    pub delay_ms: u64,
 }
 pub fn reply(status: u16, body: Value) -> Reply {
    Reply { status, headers: vec![], body: body.to_string(), delay_ms: 0 }
 }
 pub struct Mock {
    pub base: String,
    pub hits: Arc<AtomicUsize>,
    /// Raw requests (head and body) in arrival order.
    pub requests: Arc<Mutex<Vec<String>>>,
 }
 /// Serves the scripted replies in order; the last one repeats.
 pub async fn serve(script: Vec<Reply>) -> Mock {
    let script = Arc::new(script);
    serve_fn(move |i, _| {
        let r = &script[i.min(script.len() - 1)];
        Reply { status: r.status, headers: r.headers.clone(), body: r.body.clone(), delay_ms: r.delay_ms }
    })
    .await
 }
 /// Answers every request with `handler(request_index, request_line)`.
 pub async fn serve_fn(handler: impl Fn(usize, &str) -> Reply + Send + Sync + 'static) -> Mock {
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let port = listener.local_addr().unwrap().port();
    let hits = Arc::new(AtomicUsize::new(0));
    let requests = Arc::new(Mutex::new(Vec::new()));
    let (h, r) = (hits.clone(), requests.clone());
    let handler = Arc::new(handler);
    tokio::spawn(async move {
        loop {
            let Ok((mut sock, _)) = listener.accept().await else { return };
            let (h, r, handler) = (h.clone(), r.clone(), handler.clone());
            tokio::spawn(async move {
                let mut buf = Vec::new();
                let mut chunk = [0u8; 2048];
                loop {
                    let n = sock.read(&mut chunk).await.unwrap_or(0);
                    if n == 0 {
                        break;
                    }
                    buf.extend_from_slice(&chunk[..n]);
                    if let Some(end) = buf.windows(4).position(|w| w == b"\r\n\r\n") {
                        let head = String::from_utf8_lossy(&buf[..end]).to_string();
                        let want = head
                            .lines()
                            .find_map(|l| {
                                l.to_ascii_lowercase()
                                    .strip_prefix("content-length:")
                                    .map(|v| v.trim().parse::<usize>().unwrap_or(0))
                            })
                            .unwrap_or(0);
                        if buf.len() >= end + 4 + want {
                            break;
                        }
                    }
                }
                let raw = String::from_utf8_lossy(&buf).to_string();
                let request_line = raw.lines().next().unwrap_or("").to_string();
                r.lock().unwrap().push(raw);
                let i = h.fetch_add(1, Ordering::SeqCst);
                let rep = handler(i, &request_line);
                if rep.delay_ms > 0 {
                    tokio::time::sleep(Duration::from_millis(rep.delay_ms)).await;
                }
                let mut out = format!(
                    "HTTP/1.1 {} X\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n",
                    rep.status,
                    rep.body.len()
                );
                for (k, v) in &rep.headers {
                    out.push_str(&format!("{k}: {v}\r\n"));
                }
                out.push_str("\r\n");
                out.push_str(&rep.body);
                let _ = sock.write_all(out.as_bytes()).await;
                let _ = sock.shutdown().await;
            });
        }
    });
    Mock { base: format!("http://127.0.0.1:{port}"), hits, requests }
 }
 /// Short timeouts and near-zero backoff so retry tests run in milliseconds.
 pub fn fast_opts() -> ClientOptions {
    ClientOptions {
        connect_timeout: Duration::from_secs(2),
        read_timeout: Duration::from_millis(250),
        total_timeout: Duration::from_secs(5),
        max_retries: 3,
        backoff_base: Duration::from_millis(1),
        max_backoff: Duration::from_millis(5),
    }
 }
 pub fn client(mock: &Mock) -> ErpClient {
    ErpClient::new(&mock.base, "thekey", &Secret::new("thesecret"), "", fast_opts()).unwrap()
 }
@@ -0,0 +1,89 @@
 //! Outbound integrations. `InvoiceSink` is the seam between Voiced and a system that receives issued
 //! invoices (ERPNext now; a webhook, Zoho or a Tally import later). Everything target-specific lives in a
 //! submodule; the rest of the app only talks to this trait.
 // Parts of the sink API are only used by the later UI step.
 #![allow(dead_code)]
 pub mod erpnext;
 use serde::Serialize;
 use std::future::Future;
 /// What a sink reports after accepting an invoice.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct PushedInvoice {
    /// The document name on the remote system.
    pub remote_name: String,
    /// 0 draft, 1 submitted.
    pub remote_docstatus: i64,
    /// False when the remote already had this invoice (an idempotent re-push).
    pub created: bool,
    /// Non-fatal notes, e.g. "pushed without the PDF because the invoice is not archived".
    pub warnings: Vec<String>,
 }
 pub struct PushRequest {
    pub invoice_id: i64,
    /// Submit on the remote system instead of leaving a draft for review; `None` follows the sink's setting.
    pub submit: Option<bool>,
 }
 pub struct PaymentRequest {
    pub payment_id: i64,
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct PushedPayment {
    pub remote_name: String,
    /// False when the payment had already been sent (an idempotent re-push).
    pub created: bool,
 }
 /// The locally recorded sync state of one invoice. `status` is `none` until something was pushed, then
 /// `synced`, `error` or `conflict`.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct SyncStatus {
    pub invoice_id: i64,
    pub status: String,
    pub remote_name: String,
    /// 0 draft, 1 submitted.
    pub remote_docstatus: i64,
    pub last_error: String,
    pub synced_at: Option<String>,
    /// The archived PDF was uploaded to the remote document.
    pub attached: bool,
 }
 impl SyncStatus {
    pub fn none(invoice_id: i64) -> Self {
        SyncStatus {
            invoice_id,
            status: "none".into(),
            remote_name: String::new(),
            remote_docstatus: 0,
            last_error: String::new(),
            synced_at: None,
            attached: false,
        }
    }
 }
 pub trait InvoiceSink: Send + Sync {
    /// Stable identifier used in the sync table (`erpnext`, ...).
    fn id(&self) -> &'static str;
    fn push_invoice<'a>(
        &'a self,
        request: PushRequest,
    ) -> impl Future<Output = Result<PushedInvoice, String>> + Send + 'a;
    fn push_payment<'a>(
        &'a self,
        request: PaymentRequest,
    ) -> impl Future<Output = Result<PushedPayment, String>> + Send + 'a;
    /// The locally recorded state; never touches the network.
    fn status(&self, invoice_id: i64) -> Result<SyncStatus, String>;
 }
@@ -1,6 +1,7 @@
 mod commands;
 mod db;
 mod gst;
 mod integrations;
 mod logo;
 mod models;
 mod selftest;
@@ -176,6 +177,16 @@ pub fn run() {
            commands::files::get_last_export_dir,
            commands::files::reveal_in_folder,
            commands::files::open_file,
            commands::erpnext::erpnext_get_config,
            commands::erpnext::erpnext_save_config,
            commands::erpnext::erpnext_test_connection,
            commands::erpnext::erpnext_load_options,
            commands::erpnext::erpnext_push_invoice,
            commands::erpnext::erpnext_push_invoices,
            commands::erpnext::erpnext_push_payment,
            commands::erpnext::erpnext_sync_status,
            commands::erpnext::erpnext_sync_statuses,
            commands::erpnext::erpnext_open_url,
            selftest::selftest_config,
            selftest::selftest_report,
        ])
@@ -1,7 +1,7 @@
 {
  "$schema": "https://schema.tauri.app/config/2",
  "productName": "Voiced",
-  "version": "0.1.0",
+  "version": "1.0.0",
  "identifier": "com.bongbetic.voiced",
  "build": {
    "beforeDevCommand": "npm run dev",
@@ -10,6 +10,7 @@ import InvoiceDetail from "./views/InvoiceDetail";
 import Clients from "./views/Clients";
 import { ToastProvider, useToast } from "./components/ToastProvider";
 import AppSettings from "./views/AppSettings";
 import { requestSettingsTab } from "./lib/settingsTab";
 export default function App() {
  return (
@@ -89,6 +90,11 @@ function AppInner() {
    );
  }
  const openIntegrations = () => {
    requestSettingsTab("integrations");
    setView("settings");
  };
  const toggleTheme = async () => {
    const next: Settings = { ...settings, theme: settings.theme === "g100" ? "g10" : "g100" };
    setSettings(next);
@@ -115,6 +121,7 @@ function AppInner() {
          <InvoiceHistory
            settings={settings}
            active={view === "invoices"}
            onOpenSettings={openIntegrations}
            onOpen={(id) => {
              setDetailId(id);
              setView("invoice");
@@ -127,6 +134,7 @@ function AppInner() {
            invoiceId={detailId}
            settings={settings}
            onBack={() => setView("invoices")}
            onOpenSettings={openIntegrations}
            onDuplicated={(draftId) => {
              setOpenDraftId(draftId);
              setView("new");
@@ -0,0 +1,591 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
 import {
  Button,
  ComboBox,
  FileUploaderButton,
  InlineLoading,
  InlineNotification,
  PasswordInput,
  RadioButton,
  RadioButtonGroup,
  TextArea,
  TextInput,
  Tag,
  Tile,
  Toggle,
 } from "@carbon/react";
 import { Save } from "@carbon/icons-react";
 import { api } from "../lib/api";
 import type { ErpnextConfig, ErpnextConfigInput, ErpnextConnectionTest, ErpnextOptionItem, ErpnextOptions } from "../lib/erpnext";
 import {
  OPTION_LIST_LABELS,
  UOM_UNITS,
  connectionProblems,
  emptyOptions,
  hasProblems,
  mirrorSupported,
  optionErrors,
  optionText,
  sortWarnings,
  toInput,
  validateConfigForm,
  versionsLine,
  warningSeverity,
  withStoredValue,
  type FormProblems,
 } from "../lib/erpnextUi";
 import { useToast } from "./ToastProvider";
 const SEVERITY_TITLE = { error: "Needs fixing", warning: "Warning", info: "Note" } as const;
 interface PickProps {
  id: string;
  label: string;
  value: string;
  onChange: (value: string) => void;
  /** The loaded list; an empty list means "not loaded", and the field takes typed text instead. */
  items: ErpnextOptionItem[];
  /** Why this list is empty although the lists were loaded (a load error for this list). */
  error?: string;
  /** The control is switched off, with the reason shown under it. */
  disabledReason?: string;
  helper?: string;
 }
 /** A searchable dropdown over a live list, or a text box while the list has not been loaded. */
 function PickField({ id, label, value, onChange, items, error, disabledReason, helper }: PickProps) {
  const options = useMemo(() => withStoredValue(items, value), [items, value]);
  const note = disabledReason ?? error ?? helper;
  if (items.length === 0 || disabledReason) {
    return (
      <TextInput
        id={id}
        labelText={label}
        value={value}
        disabled={Boolean(disabledReason)}
        invalid={Boolean(error) && !disabledReason}
        invalidText={error}
        helperText={error ? undefined : note}
        onChange={(e) => onChange(e.target.value)}
      />
    );
  }
  return (
    <ComboBox
      id={id}
      titleText={label}
      items={options}
      itemToString={(i: ErpnextOptionItem | null) => (i ? optionText(i) : "")}
      selectedItem={options.find((o) => o.name === value) ?? null}
      onChange={({ selectedItem }: { selectedItem?: ErpnextOptionItem | null }) => onChange(selectedItem?.name ?? "")}
      shouldFilterItem={({ item, inputValue }: { item: ErpnextOptionItem; inputValue: string | null }) =>
        !inputValue || optionText(item).toLowerCase().includes(inputValue.toLowerCase())
      }
      helperText={helper}
      placeholder="Search or choose"
    />
  );
 }
 function Section({ title, children, note }: { title: string; children: React.ReactNode; note?: string }) {
  return (
    <section className="voiced-erp__section" aria-label={title}>
      <h3>{title}</h3>
      {note ? <p className="voiced-muted">{note}</p> : null}
      <div className="voiced-erp__fields">{children}</div>
    </section>
  );
 }
 /** Settings, Integrations, ERPNext. It has its own Save: the page-level Save settings button does not cover it. */
 export default function ErpnextSettingsPanel({ active }: { active: boolean }) {
  const toast = useToast();
  const [saved, setSaved] = useState<ErpnextConfig | null>(null);
  const [form, setForm] = useState<ErpnextConfigInput | null>(null);
  const [loadError, setLoadError] = useState<string | null>(null);
  const [replacing, setReplacing] = useState(false);
  const [test, setTest] = useState<ErpnextConnectionTest | null>(null);
  /** A test result from this session that is not saved yet. */
  const [testUnsaved, setTestUnsaved] = useState(false);
  const [testError, setTestError] = useState<string | null>(null);
  const [testing, setTesting] = useState(false);
  const [options, setOptions] = useState<ErpnextOptions | null>(null);
  const [loadingOptions, setLoadingOptions] = useState(false);
  const [saving, setSaving] = useState(false);
  const [showProblems, setShowProblems] = useState(false);
  const [saveError, setSaveError] = useState<string | null>(null);
  const load = useCallback(async () => {
    try {
      const cfg = await api.erpnextGetConfig();
      setSaved(cfg);
      setForm(toInput(cfg));
      setTest(cfg.lastDetectResult);
      setTestUnsaved(false);
      setLoadError(null);
    } catch (e) {
      setLoadError(String(e));
    }
  }, []);
  useEffect(() => {
    if (active && form === null) void load();
    // Reload only on first show; edits must survive switching tabs.
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [active]);
  if (loadError) {
    return <InlineNotification kind="error" lowContrast hideCloseButton title="Could not load the ERPNext settings" subtitle={loadError} />;
  }
  if (!form || !saved) return <InlineLoading description="Loading ERPNext settings" />;
  const set = <K extends keyof ErpnextConfigInput>(key: K, value: ErpnextConfigInput[K]) => setForm((f) => (f ? { ...f, [key]: value } : f));
  const secretStored = saved.apiSecretSet;
  const secretShown = secretStored && !replacing && !form.clearSecret;
  const problems: FormProblems = showProblems ? validateConfigForm(form, secretStored, test) : {};
  const connProblems = connectionProblems(form, secretStored);
  const canConnect = !hasProblems(connProblems);
  const optErrors = optionErrors(options);
  const opts = options ?? emptyOptions();
  const noCompany = !form.company.trim();
  const companyReason = noCompany ? "Pick a company first." : undefined;
  const seriesMode = form.namingMode === "series";
  const mirrorOk = mirrorSupported(test);
  const loadOptions = async (values: ErpnextConfigInput) => {
    setLoadingOptions(true);
    try {
      setOptions(await api.erpnextLoadOptions(values));
    } catch (e) {
      setOptions(null);
      toast.error("Could not load the ERPNext lists", String(e));
    } finally {
      setLoadingOptions(false);
    }
  };
  const runTest = async () => {
    setShowProblems(true);
    if (!canConnect) return;
    setTesting(true);
    setTestError(null);
    try {
      const result = await api.erpnextTestConnection(form);
      setTest(result);
      setTestUnsaved(true);
      let next = form;
      // A site that keeps no posted name cannot mirror the Voiced number.
      if (!result.features.v2Naming && form.namingMode === "mirror") {
        next = { ...form, namingMode: "series" };
        setForm(next);
      }
      await loadOptions(next);
    } catch (e) {
      setTestError(String(e));
    } finally {
      setTesting(false);
    }
  };
  const changeCompany = (company: string) => {
    const next = { ...form, company };
    setForm(next);
    // Accounts, addresses and cost centers belong to the company, so the lists are reloaded for it.
    if (options && canConnect) void loadOptions(next);
  };
  const save = async () => {
    setShowProblems(true);
    setSaveError(null);
    if (hasProblems(validateConfigForm(form, secretStored, test))) return;
    setSaving(true);
    try {
      const cfg = await api.erpnextSaveConfig({ ...form, ...(testUnsaved && test ? { lastDetectResult: test } : {}) });
      setSaved(cfg);
      setForm(toInput(cfg));
      setReplacing(false);
      setTest(cfg.lastDetectResult ?? test);
      setTestUnsaved(false);
      setShowProblems(false);
      toast.success("ERPNext settings saved");
    } catch (e) {
      const text = String(e);
      setSaveError(text);
      toast.error("Could not save the ERPNext settings", text);
    } finally {
      setSaving(false);
    }
  };
  const readPem = async (file: File | undefined) => {
    if (!file) return;
    try {
      set("extraCaPem", (await file.text()).trim());
    } catch (e) {
      toast.error("Could not read the certificate file", String(e));
    }
  };
  const secretInvalid = problems.apiSecret ?? (saveError && /secret again/i.test(saveError) ? saveError : undefined);
  return (
    <div className="voiced-stack voiced-erp">
      <div>
        <h2 className="voiced-detail__h2">ERPNext</h2>
        <p>
          Send issued invoices and payments to your ERPNext site as Sales Invoices. Everything is sent from this computer; ERPNext is never
          needed to issue an invoice.
        </p>
        <p className="voiced-muted">
          Create a dedicated ERPNext user for Voiced with only these permissions: create and submit Sales Invoice, read on the master data
          (Customer, Item, Address, Account, Company), and write on File. Use that user&rsquo;s API key and secret below. An address must be
          https://; plain http is only allowed for localhost, 127.0.0.1, *.localhost and *.test hosts.
        </p>
      </div>
      <Section title="Connection">
        <TextInput
          id="erp-baseUrl"
          labelText="Site address"
          placeholder="https://erp.example.com"
          value={form.baseUrl}
          invalid={Boolean(problems.baseUrl)}
          invalidText={problems.baseUrl}
          onChange={(e) => set("baseUrl", e.target.value)}
        />
        <TextInput
          id="erp-apiKey"
          labelText="API key"
          autoComplete="off"
          value={form.apiKey}
          invalid={Boolean(problems.apiKey)}
          invalidText={problems.apiKey}
          onChange={(e) => set("apiKey", e.target.value)}
        />
        {secretShown ? (
          <div className="voiced-erp__secret">
            <p className="voiced-erp__label" id="erp-secret-label">
              API secret
            </p>
            <p aria-labelledby="erp-secret-label">
              <Tag type="green" size="sm">
                set
              </Tag>{" "}
              <span className="voiced-muted">The secret is stored on this computer and is never shown again.</span>
            </p>
            <div className="voiced-header-action">
              <Button kind="tertiary" size="sm" onClick={() => setReplacing(true)}>
                Replace
              </Button>
              <Button kind="ghost" size="sm" onClick={() => set("clearSecret", true)}>
                Clear
              </Button>
            </div>
          </div>
        ) : (
          <div>
            <PasswordInput
              id="erp-apiSecret"
              labelText="API secret"
              autoComplete="new-password"
              value={form.apiSecret}
              invalid={Boolean(secretInvalid)}
              invalidText={secretInvalid}
              helperText={form.clearSecret ? "The stored secret is removed when you save, unless you type a new one." : undefined}
              onChange={(e) => set("apiSecret", e.target.value)}
            />
            {secretStored ? (
              <Button
                kind="ghost"
                size="sm"
                onClick={() => {
                  setReplacing(false);
                  setForm((f) => (f ? { ...f, apiSecret: "", clearSecret: false } : f));
                }}
              >
                Keep the stored secret
              </Button>
            ) : null}
          </div>
        )}
        <div>
          <TextArea
            id="erp-extraCa"
            labelText="Extra CA certificate (optional, PEM)"
            helperText="Only for a self-hosted site whose certificate is not trusted by this computer."
            rows={3}
            value={form.extraCaPem}
            onChange={(e) => set("extraCaPem", e.target.value)}
          />
          <FileUploaderButton
            labelText="Load from file…"
            buttonKind="ghost"
            size="sm"
            accept={[".pem", ".crt", ".cer"]}
            disableLabelChanges
            onChange={(e: React.ChangeEvent<HTMLInputElement>) => {
              const file = e.target.files?.[0];
              e.target.value = "";
              void readPem(file);
            }}
          />
        </div>
        <div className="voiced-header-action">
          <Button kind="secondary" size="md" onClick={() => void runTest()} disabled={testing || loadingOptions}>
            {testing ? "Testing…" : "Test connection"}
          </Button>
          {testing || loadingOptions ? <InlineLoading description={testing ? "Contacting ERPNext" : "Loading lists"} /> : null}
          {!canConnect && showProblems ? <span className="voiced-muted">Fix the address, key and secret first.</span> : null}
        </div>
        {testError ? <InlineNotification kind="error" lowContrast hideCloseButton title="Connection failed" subtitle={testError} /> : null}
        {test ? (
          <Tile className="voiced-erp__result" aria-label="Connection test result">
            <p>
              <strong>Connected as {test.user || "an unknown user"}</strong>{" "}
              <Tag type={test.indiaCompliance ? "green" : "warm-gray"} size="sm">
                {test.indiaCompliance ? "India Compliance detected" : "India Compliance not detected"}
              </Tag>
            </p>
            <p className="voiced-muted">{versionsLine(test)}</p>
            {testUnsaved ? (
              <InlineNotification
                kind="info"
                lowContrast
                hideCloseButton
                title="Save to keep this result"
                subtitle="Sending invoices needs a saved connection test."
              />
            ) : (
              <p className="voiced-muted">Last saved test result.</p>
            )}
            {sortWarnings(test.warnings).map((w, i) => {
              const severity = warningSeverity(w.code);
              return (
                <InlineNotification
                  key={`${w.code}-${i}`}
                  kind={severity}
                  lowContrast
                  hideCloseButton
                  title={SEVERITY_TITLE[severity]}
                  subtitle={w.message}
                />
              );
            })}
            {test.warnings.length === 0 ? <p className="voiced-muted">No problems found with the current settings.</p> : null}
            <p className="voiced-muted">Test again after changing the mappings below to refresh these warnings.</p>
          </Tile>
        ) : null}
      </Section>
      <Section
        title="Company and accounts"
        note={options ? "Choose from what your ERPNext site has." : "Run Test connection to choose from your site's lists; until then, type the exact names."}
      >
        {options && options.errors.length > 0 ? (
          <InlineNotification
            kind="warning"
            lowContrast
            hideCloseButton
            title="Some lists could not be loaded"
            subtitle={options.errors.map((e) => `${OPTION_LIST_LABELS[e.list] ?? e.list}: ${e.message}`).join(" ")}
          />
        ) : null}
        <PickField
          id="erp-company"
          label="Company"
          value={form.company}
          onChange={changeCompany}
          items={opts.companies}
          error={optErrors.get("companies")}
        />
        <PickField
          id="erp-companyAddress"
          label="Company address"
          value={form.companyAddress}
          onChange={(v) => set("companyAddress", v)}
          items={opts.companyAddresses}
          error={optErrors.get("companyAddresses")}
          disabledReason={companyReason}
          helper="Required by India Compliance on every invoice."
        />
        <PickField
          id="erp-incomeAccount"
          label="Income account"
          value={form.incomeAccount}
          onChange={(v) => set("incomeAccount", v)}
          items={opts.incomeAccounts}
          error={optErrors.get("incomeAccounts")}
          disabledReason={companyReason}
        />
        <PickField
          id="erp-costCenter"
          label="Cost center"
          value={form.costCenter}
          onChange={(v) => set("costCenter", v)}
          items={opts.costCenters}
          error={optErrors.get("costCenters")}
          disabledReason={companyReason}
        />
        {(
          [
            ["cgstAccount", "CGST account"],
            ["sgstAccount", "SGST account"],
            ["utgstAccount", "UTGST account"],
            ["igstAccount", "IGST account"],
          ] as const
        ).map(([key, label]) => (
          <PickField
            key={key}
            id={`erp-${key}`}
            label={label}
            value={form[key]}
            onChange={(v) => set(key, v)}
            items={opts.taxAccounts}
            error={optErrors.get("taxAccounts")}
            disabledReason={companyReason}
            helper={key === "utgstAccount" ? "Only needed when the supplier is in a union territory without a legislature." : "Must be the account set in GST Settings."}
          />
        ))}
        <TextInput
          id="erp-paymentBank"
          labelText="Payment bank account"
          helperText="The bank or cash account that receives payments, e.g. HDFC Bank - AC. Needed to send payments."
          value={form.paymentBankAccount}
          onChange={(e) => set("paymentBankAccount", e.target.value)}
        />
        <TextInput
          id="erp-tdsAccount"
          labelText="TDS account"
          helperText="The account that holds tax deducted by clients. Needed only for payments with TDS."
          value={form.tdsAccount}
          onChange={(e) => set("tdsAccount", e.target.value)}
        />
      </Section>
      <Section title="Customers and items">
        <TextInput
          id="erp-defaultItem"
          labelText="Default item code (optional)"
          helperText="Used for invoice lines without an item code of their own; a line with none is sent as a description-only row."
          value={form.defaultItemCode}
          onChange={(e) => set("defaultItemCode", e.target.value)}
        />
        <PickField
          id="erp-customerGroup"
          label="Customer group for new customers"
          value={form.customerGroup}
          onChange={(v) => set("customerGroup", v)}
          items={opts.customerGroups}
          error={optErrors.get("customerGroups")}
        />
        <PickField
          id="erp-territory"
          label="Territory for new customers"
          value={form.territory}
          onChange={(v) => set("territory", v)}
          items={opts.territories}
          error={optErrors.get("territories")}
        />
        <PickField
          id="erp-priceList"
          label="Selling price list"
          value={form.sellingPriceList}
          onChange={(v) => set("sellingPriceList", v)}
          items={opts.priceLists}
          error={optErrors.get("priceLists")}
        />
        <fieldset className="voiced-erp__uoms">
          <legend>Units of measure</legend>
          <p className="voiced-muted">The ERPNext unit used for each Voiced unit. Whole-number units such as Nos reject fractional quantities.</p>
          {UOM_UNITS.map((unit) => (
            <PickField
              key={unit}
              id={`erp-uom-${unit}`}
              label={`Voiced ${unit}`}
              value={form.uomMap[unit] ?? ""}
              onChange={(v) => setForm((f) => (f ? { ...f, uomMap: { ...f.uomMap, [unit]: v } } : f))}
              items={opts.uoms}
              error={optErrors.get("uoms")}
            />
          ))}
        </fieldset>
      </Section>
      <Section title="Invoice numbers">
        <RadioButtonGroup
          legendText="Numbering in ERPNext"
          name="erp-namingMode"
          orientation="vertical"
          valueSelected={form.namingMode}
          onChange={(value) => set("namingMode", value === "series" ? "series" : "mirror")}
        >
          <RadioButton
            id="erp-nm-mirror"
            value="mirror"
            labelText="Mirror the Voiced number (recommended)"
            disabled={!mirrorOk}
          />
          <RadioButton id="erp-nm-series" value="series" labelText="Use an ERPNext naming series" />
        </RadioButtonGroup>
        <p className="voiced-muted">
          {mirrorOk
            ? "Mirror keeps the number printed on the PDF as the ERPNext invoice name, so GST returns match. Needs Frappe 15.73 or later."
            : "Mirror is unavailable: this ERPNext version replaces a posted invoice number. The Voiced number is stored in the remarks instead."}
        </p>
        {problems.namingMode ? <p className="voiced-erp__error">{problems.namingMode}</p> : null}
        <PickField
          id="erp-namingSeries"
          label="Naming series"
          value={form.namingSeries}
          onChange={(v) => set("namingSeries", v)}
          items={opts.namingSeries}
          error={problems.namingSeries ?? optErrors.get("namingSeries")}
          disabledReason={seriesMode ? undefined : "Only used with an ERPNext naming series."}
        />
      </Section>
      <Section title="Sending">
        <Toggle
          id="erp-submit"
          labelText="Submit invoices when sending"
          labelA="Off: drafts for review"
          labelB="On: submitted"
          toggled={form.submitOnPush}
          onToggle={(v) => set("submitOnPush", v)}
        />
        <Toggle
          id="erp-attach"
          labelText="Attach the PDF"
          labelA="Off"
          labelB="On"
          toggled={form.attachPdf}
          onToggle={(v) => set("attachPdf", v)}
        />
        <Toggle
          id="erp-auto"
          labelText="Send automatically when an invoice is issued"
          labelA="Off"
          labelB="On"
          toggled={form.autoPushOnIssue}
          onToggle={(v) => set("autoPushOnIssue", v)}
        />
        <Toggle
          id="erp-customers"
          labelText="Create customers that are missing in ERPNext"
          labelA="Off"
          labelB="On"
          toggled={form.createMissingCustomers}
          onToggle={(v) => set("createMissingCustomers", v)}
        />
      </Section>
      {saveError && !secretInvalid ? <InlineNotification kind="error" lowContrast hideCloseButton title="Not saved" subtitle={saveError} /> : null}
      <div>
        <Button renderIcon={Save} onClick={() => void save()} disabled={saving}>
          {saving ? "Saving…" : "Save ERPNext settings"}
        </Button>
        <p className="voiced-muted">This tab has its own Save button; Save settings at the bottom of the page does not cover it.</p>
      </div>
    </div>
  );
 }
@@ -0,0 +1,140 @@
 import { useEffect, useRef, useState } from "react";
 import { Button, InlineLoading, Modal, RadioButton, RadioButtonGroup, Tag } from "@carbon/react";
 import { api } from "../lib/api";
 import type { ErpnextPushResult } from "../lib/erpnext";
 import { describePush, failedPush, summarizeBatch } from "../lib/erpnextUi";
 import { useReturnFocus } from "../hooks/useReturnFocus";
 export interface SendTarget {
  id: number;
  number: string;
 }
 interface Props {
  open: boolean;
  invoices: SendTarget[];
  /** Cancelled or draft invoices that were left out of the selection. */
  skipped?: number;
  /** The "submit on push" setting; the user still chooses explicitly. */
  defaultSubmit: boolean;
  onClose: () => void;
  /** Called once when a send has finished, so the list can refresh its statuses. */
  onFinished: (results: ErpnextPushResult[]) => void;
 }
 type Phase = "confirm" | "running" | "done";
 const TAG = { success: "green", info: "blue", warning: "warm-gray", error: "red" } as const;
 /** Confirm step (draft or submit), then a sequential send with progress, then per-invoice results. A failure never stops the rest. */
 export default function SendToErpnextModal({ open, invoices, skipped = 0, defaultSubmit, onClose, onFinished }: Props) {
  const [submit, setSubmit] = useState(defaultSubmit);
  const [phase, setPhase] = useState<Phase>("confirm");
  const [results, setResults] = useState<ErpnextPushResult[]>([]);
  const alive = useRef(true);
  useReturnFocus(open);
  useEffect(() => {
    alive.current = true;
    return () => {
      alive.current = false;
    };
  }, []);
  useEffect(() => {
    if (!open) return;
    setSubmit(defaultSubmit);
    setPhase("confirm");
    setResults([]);
  }, [open, defaultSubmit]);
  const run = async () => {
    setPhase("running");
    const out: ErpnextPushResult[] = [];
    for (const inv of invoices) {
      let result: ErpnextPushResult;
      try {
        result = await api.erpnextPushInvoice(inv.id, submit);
      } catch (e) {
        // Not set up, or the command itself failed: this row fails, the others still go.
        result = failedPush(inv.id, inv.number, e);
      }
      out.push(result);
      if (alive.current) setResults([...out]);
    }
    if (alive.current) setPhase("done");
    onFinished(out);
  };
  const count = invoices.length;
  const noun = count === 1 ? "invoice" : "invoices";
  if (phase === "confirm") {
    return (
      <Modal
        open={open}
        modalHeading={count === 1 ? `Send ${invoices[0]?.number} to ERPNext` : `Send ${count} invoices to ERPNext`}
        primaryButtonText={`Send ${count} ${noun}`}
        secondaryButtonText="Cancel"
        primaryButtonDisabled={count === 0}
        onRequestClose={onClose}
        onRequestSubmit={() => void run()}
      >
        <div className="voiced-stack">
          <RadioButtonGroup legendText="What should ERPNext do with it?" name="erp-send-mode" orientation="vertical" valueSelected={submit ? "submit" : "draft"} onChange={(v) => setSubmit(v === "submit")}>
            <RadioButton id="erp-send-draft" value="draft" labelText="Save as a draft for review" />
            <RadioButton id="erp-send-submit" value="submit" labelText="Submit it (posts to the books)" />
          </RadioButtonGroup>
          <p className="voiced-muted">
            An invoice that is already in ERPNext is never overwritten or created twice.
            {skipped > 0 ? ` ${skipped} cancelled ${skipped === 1 ? "invoice is" : "invoices are"} left out: cancelled invoices are never sent.` : ""}
          </p>
        </div>
      </Modal>
    );
  }
  const summary = phase === "done" ? summarizeBatch(results) : null;
  return (
    <Modal
      open={open}
      passiveModal
      modalHeading={phase === "running" ? "Sending to ERPNext" : "Send finished"}
      preventCloseOnClickOutside
      onRequestClose={() => {
        if (phase === "done") onClose();
      }}
    >
      <div className="voiced-stack">
        {phase === "running" ? (
          <InlineLoading description={`Sent ${results.length} of ${count}…`} />
        ) : (
          <p role="status">
            <strong>{summary?.title}</strong>
          </p>
        )}
        <ul className="voiced-erp__results" aria-label="Results">
          {results.map((r) => {
            const note = describePush(r);
            return (
              <li key={r.invoiceId}>
                <Tag type={TAG[note.kind]} size="sm">
                  {r.ok ? (r.noOp ? "Up to date" : r.remoteDocstatus === 1 ? "Submitted" : "Draft") : r.status === "conflict" ? "Conflict" : r.status === "refused" ? "Not sent" : "Error"}
                </Tag>{" "}
                <strong>{r.number || `#${r.invoiceId}`}</strong>
                {r.remoteName && r.ok ? <span className="voiced-muted"> {r.remoteName}</span> : null}
                {!r.ok && r.error ? <div className="voiced-muted">{r.error}</div> : null}
                {r.ok && r.warnings.length > 0 ? <div className="voiced-muted">{r.warnings.join(" ")}</div> : null}
              </li>
            );
          })}
        </ul>
        {phase === "done" ? (
          <Button kind="primary" size="md" onClick={onClose}>
            Close
          </Button>
        ) : null}
      </div>
    </Modal>
  );
 }
@@ -0,0 +1,39 @@
 import { useCallback, useState } from "react";
 import { save } from "@tauri-apps/plugin-dialog";
 import { api } from "../lib/api";
 import { exportInvoicesV1, type InvoiceExportFormat } from "../lib/invoiceExportV1";
 import { useToast } from "../components/ToastProvider";
 /** "Export as voiced.invoice.v1": JSON or line-item CSV of the given invoices, through the save dialog. */
 export function useGenericExport(): { busy: boolean; run: (ids: number[], format: InvoiceExportFormat) => Promise<void> } {
  const toast = useToast();
  const [busy, setBusy] = useState(false);
  const run = useCallback(
    async (ids: number[], format: InvoiceExportFormat) => {
      setBusy(true);
      try {
        const done = await exportInvoicesV1(
          {
            getInvoice: api.getInvoice,
            listPayments: api.listPayments,
            listClients: api.listClients,
            getLastExportDir: api.getLastExportDir,
            save: ({ defaultPath, format: fmt }) =>
              save({ defaultPath, filters: [fmt === "csv" ? { name: "CSV (line items)", extensions: ["csv"] } : { name: "JSON (voiced.invoice.v1)", extensions: ["json"] }] }),
            writeExportFile: api.writeExportFile,
            now: () => new Date(),
          },
          ids,
          format,
        );
        if (done) toast.success(`Exported ${done.count} ${done.count === 1 ? "invoice" : "invoices"}`, done.path);
      } catch (e) {
        toast.error("Could not export the invoices", String(e));
      } finally {
        setBusy(false);
      }
    },
    [toast],
  );
  return { busy, run };
 }
@@ -0,0 +1,118 @@
 [
  {
    "schema": "voiced.invoice.v1",
    "number": "INV/2026-001",
    "issue_date": "2026-04-01",
    "due_date": "2026-05-01",
    "document_type": "tax_invoice",
    "status": "issued",
    "cancelled": false,
    "cancelled_at": null,
    "cancel_reason": null,
    "currency": "INR",
    "po_number": "PO-9",
    "supplier": {
      "name": "Test Vendor",
      "address": "1 Main Rd\nPune",
      "gstin": "27AAPFU0939F1ZV",
      "pan": "AAPFU0939F",
      "gst_registration": "regular",
      "state": {
        "code": "27",
        "name": "Maharashtra"
      }
    },
    "client": {
      "name": "Client Ltd",
      "gstin": "29AABCU9603R1ZJ",
      "gst_category": "registered_regular",
      "address": {
        "text": "12 MG Road\nBengaluru 560001",
        "line1": "12 MG Road",
        "line2": null,
        "city": "Bengaluru",
        "pincode": "560001",
        "state": {
          "code": "29",
          "name": "Karnataka"
        }
      },
      "place_of_supply": {
        "code": "29",
        "name": "Karnataka"
      }
    },
    "items": [
      {
        "line": 1,
        "description": "Design",
        "hsn_sac": "998391",
        "quantity": "1",
        "unit": null,
        "rate_paise": 500010,
        "rate": "5000.10",
        "taxable_value_paise": 500010,
        "taxable_value": "5000.10"
      },
      {
        "line": 2,
        "description": "Consulting",
        "hsn_sac": null,
        "quantity": "2",
        "unit": "hour",
        "rate_paise": 115505,
        "rate": "1155.05",
        "taxable_value_paise": 231000,
        "taxable_value": "2310.00"
      }
    ],
    "tax": {
      "cgst": {
        "rate": "0",
        "amount_paise": 0,
        "amount": "0.00"
      },
      "sgst": {
        "rate": "0",
        "amount_paise": 0,
        "amount": "0.00"
      },
      "utgst": {
        "rate": "0",
        "amount_paise": 0,
        "amount": "0.00"
      },
      "igst": {
        "rate": "18",
        "amount_paise": 131400,
        "amount": "1314.00"
      }
    },
    "totals": {
      "subtotal_paise": 731010,
      "subtotal": "7310.10",
      "discount_paise": 1010,
      "discount": "10.10",
      "taxable_value_paise": 730000,
      "taxable_value": "7300.00",
      "tax_paise": 131400,
      "tax": "1314.00",
      "total_paise": 861400,
      "total": "8614.00",
      "amount_in_words": "Rupees Eight Thousand Six Hundred Fourteen Only"
    },
    "reverse_charge": false,
    "notes": "Thank you",
    "payments": [
      {
        "date": "2026-04-10",
        "amount_paise": 700000,
        "amount": "7000.00",
        "tds_paise": 70000,
        "tds": "700.00",
        "mode": "bank_transfer",
        "reference": "UTR123"
      }
    ]
  }
 ]
@@ -14,6 +14,15 @@ import type { LogoAsset } from "./logo";
 import type { Payment, PaymentInput } from "./payments";
 import type { BackupStatus, BackupSummary, PendingRestore } from "./backup";
 import type { LedgerRow } from "./historyExport";
 import type {
  ErpnextConfig,
  ErpnextConfigInput,
  ErpnextConnectionTest,
  ErpnextOptions,
  ErpnextPaymentPushResult,
  ErpnextPushResult,
  ErpnextSyncStatus,
 } from "./erpnext";
 import type { FontInspection, ImportMeta, RemoveOutcome, UserFontRow } from "./fontImport";
 export interface ArchiveStatus {
@@ -113,4 +122,24 @@ export const api = {
  getBackupStatus: () => invoke<BackupStatus>("get_backup_status"),
  setAutoBackup: (enabled: boolean) => invoke<boolean>("set_auto_backup", { enabled }),
  restartApp: () => invoke<void>("restart_app"),
  // ERPNext integration. All HTTP runs in Rust; the API secret is write-only from the webview.
  erpnextGetConfig: () => invoke<ErpnextConfig>("erpnext_get_config"),
  erpnextSaveConfig: (config: ErpnextConfigInput) => invoke<ErpnextConfig>("erpnext_save_config", { config }),
  erpnextTestConnection: (config: ErpnextConfigInput) =>
    invoke<ErpnextConnectionTest>("erpnext_test_connection", { config }),
  erpnextLoadOptions: (config: ErpnextConfigInput) => invoke<ErpnextOptions>("erpnext_load_options", { config }),
  /** `submit` omitted follows the "submit on push" setting. A failed push resolves with `ok: false`. */
  erpnextPushInvoice: (id: number, submit?: boolean) =>
    invoke<ErpnextPushResult>("erpnext_push_invoice", { id, submit: submit ?? null }),
  /** One result per distinct id, in order; a failing row never stops the rest. */
  erpnextPushInvoices: (ids: number[], submit?: boolean) =>
    invoke<ErpnextPushResult[]>("erpnext_push_invoices", { ids, submit: submit ?? null }),
  erpnextPushPayment: (paymentId: number) =>
    invoke<ErpnextPaymentPushResult>("erpnext_push_payment", { paymentId }),
  erpnextSyncStatus: (id: number) => invoke<ErpnextSyncStatus>("erpnext_sync_status", { id }),
  /** Every invoice that has a sync row (invoices never pushed are absent). */
  erpnextSyncStatuses: () => invoke<ErpnextSyncStatus[]>("erpnext_sync_statuses"),
  /** `<base>/app/sales-invoice/<name>`; rejects when the invoice was never sent. */
  erpnextOpenUrl: (id: number) => invoke<string>("erpnext_open_url", { id }),
 };
@@ -0,0 +1,154 @@
 /** Types for the ERPNext commands (see src-tauri/src/commands/erpnext.rs); the UI helpers live in erpnextUi.ts. */
 export type ErpnextNamingMode = "mirror" | "series";
 /** What the backend returns. The API secret is never included: `apiSecretSet` says whether one is stored. */
 export interface ErpnextConfig {
  baseUrl: string;
  apiKey: string;
  apiSecretSet: boolean;
  extraCaPem: string;
  company: string;
  companyAddress: string;
  namingMode: ErpnextNamingMode;
  namingSeries: string;
  incomeAccount: string;
  costCenter: string;
  cgstAccount: string;
  sgstAccount: string;
  utgstAccount: string;
  igstAccount: string;
  taxTemplateIntra: string;
  taxTemplateInter: string;
  paymentBankAccount: string;
  tdsAccount: string;
  defaultItemCode: string;
  /** Voiced unit (second, minute, hour, session, unit) to ERPNext UOM. */
  uomMap: Record<string, string>;
  customerGroup: string;
  territory: string;
  sellingPriceList: string;
  submitOnPush: boolean;
  attachPdf: boolean;
  autoPushOnIssue: boolean;
  createMissingCustomers: boolean;
  /** The last connection test, or null if none was stored. */
  lastDetectResult: ErpnextConnectionTest | null;
 }
 /**
 * What the webview sends to save or test. A blank `apiSecret` keeps the stored secret, a value replaces it,
 * and `clearSecret` removes it. `lastDetectResult` omitted keeps the stored one.
 */
 export type ErpnextConfigInput = Omit<ErpnextConfig, "apiSecretSet" | "lastDetectResult"> & {
  apiSecret: string;
  clearSecret?: boolean;
  lastDetectResult?: ErpnextConnectionTest | null;
 };
 export interface ErpnextWarning {
  code: string;
  message: string;
 }
 export interface ErpnextVersions {
  frappe: string | null;
  erpnext: string | null;
  indiaCompliance: string | null;
 }
 export interface ErpnextConnectionTest {
  user: string;
  versions: ErpnextVersions;
  features: { v2Naming: boolean; indiaCompliance: boolean };
  indiaCompliance: boolean;
  warnings: ErpnextWarning[];
 }
 export interface ErpnextOptionItem {
  /** The value to store (the document name). */
  name: string;
  label: string;
  detail: string;
 }
 export interface ErpnextOptions {
  companies: ErpnextOptionItem[];
  companyAddresses: ErpnextOptionItem[];
  incomeAccounts: ErpnextOptionItem[];
  taxAccounts: ErpnextOptionItem[];
  taxTemplates: ErpnextOptionItem[];
  namingSeries: ErpnextOptionItem[];
  itemGroups: ErpnextOptionItem[];
  uoms: ErpnextOptionItem[];
  costCenters: ErpnextOptionItem[];
  priceLists: ErpnextOptionItem[];
  customerGroups: ErpnextOptionItem[];
  territories: ErpnextOptionItem[];
  /** Lists that failed to load; the others are still filled. */
  errors: { list: string; message: string }[];
 }
 export type ErpnextErrorKind =
  | "auth"
  | "permission"
  | "not_found"
  | "duplicate"
  | "validation"
  | "rate_limit"
  | "server"
  | "timeout"
  | "network"
  | "config"
  | "protocol"
  | "conflict"
  | "precondition"
  | "other";
 /** `refused`: nothing was sent and nothing was recorded (a draft or cancelled invoice). */
 export type ErpnextPushStatus = "synced" | "error" | "conflict" | "refused";
 export interface ErpnextPushResult {
  invoiceId: number;
  number: string;
  ok: boolean;
  status: ErpnextPushStatus;
  remoteName: string;
  /** 0 draft, 1 submitted. */
  remoteDocstatus: number;
  /** Created by this call, not found already there. */
  created: boolean;
  /** Already synced with the same payload; nothing was done. */
  noOp: boolean;
  /** The archived PDF is attached on the remote document. */
  attached: boolean;
  error: string | null;
  errorKind: ErpnextErrorKind | null;
  /** Non-fatal notes, e.g. sent without the PDF because the invoice is not archived. */
  warnings: string[];
 }
 export interface ErpnextPaymentPushResult {
  paymentId: number;
  invoiceId: number;
  ok: boolean;
  entryName: string | null;
  /** Sent earlier; nothing was posted. */
  alreadySynced: boolean;
  error: string | null;
  errorKind: ErpnextErrorKind | null;
 }
 /** `none` until something was pushed. */
 export type ErpnextSyncState = "none" | "pending" | "synced" | "error" | "conflict";
 export interface ErpnextSyncStatus {
  invoiceId: number;
  status: ErpnextSyncState;
  remoteName: string;
  /** 0 draft, 1 submitted. */
  remoteDocstatus: number;
  lastError: string;
  syncedAt: string | null;
  attached: boolean;
 }
@@ -0,0 +1,7 @@
 import { openUrl } from "@tauri-apps/plugin-opener";
 import { api } from "./api";
 /** Opens the invoice's ERPNext page in the system browser (`<base>/app/sales-invoice/<name>`); rejects if it was never sent. */
 export async function openInErpnext(invoiceId: number): Promise<void> {
  await openUrl(await api.erpnextOpenUrl(invoiceId));
 }
@@ -0,0 +1,286 @@
 import { describe, expect, it, vi } from "vitest";
 import type { ErpnextConfig, ErpnextConnectionTest, ErpnextPushResult, ErpnextSyncStatus } from "./erpnext";
 import {
  autoPushIssued,
  baseUrlProblem,
  connectionProblems,
  describePaymentPush,
  describePush,
  failedPush,
  hasDetectResult,
  isConfigured,
  paymentPushDisabledReason,
  pushDisabledReason,
  summarizeBatch,
  syncTag,
  toInput,
  validateConfigForm,
  warningSeverity,
  withDefaultUoms,
  withStoredValue,
  sortWarnings,
  sendableSelection,
  formatSyncedAt,
 } from "./erpnextUi";
 const test: ErpnextConnectionTest = {
  user: "api@example.com",
  versions: { frappe: "15.80.0", erpnext: "15.70.0", indiaCompliance: "15.30.0" },
  features: { v2Naming: true, indiaCompliance: true },
  indiaCompliance: true,
  warnings: [],
 };
 const config = (patch: Partial<ErpnextConfig> = {}): ErpnextConfig => ({
  baseUrl: "https://erp.example.com",
  apiKey: "key",
  apiSecretSet: true,
  extraCaPem: "",
  company: "Test Co",
  companyAddress: "",
  namingMode: "mirror",
  namingSeries: "",
  incomeAccount: "",
  costCenter: "",
  cgstAccount: "",
  sgstAccount: "",
  utgstAccount: "",
  igstAccount: "",
  taxTemplateIntra: "",
  taxTemplateInter: "",
  paymentBankAccount: "",
  tdsAccount: "",
  defaultItemCode: "",
  uomMap: {},
  customerGroup: "",
  territory: "",
  sellingPriceList: "",
  submitOnPush: false,
  attachPdf: true,
  autoPushOnIssue: false,
  createMissingCustomers: true,
  lastDetectResult: test,
  ...patch,
 });
 const sync = (patch: Partial<ErpnextSyncStatus>): ErpnextSyncStatus => ({
  invoiceId: 1,
  status: "synced",
  remoteName: "INV/2026-001",
  remoteDocstatus: 0,
  lastError: "",
  syncedAt: null,
  attached: false,
  ...patch,
 });
 const push = (patch: Partial<ErpnextPushResult> = {}): ErpnextPushResult => ({
  invoiceId: 1,
  number: "INV/2026-001",
  ok: true,
  status: "synced",
  remoteName: "INV/2026-001",
  remoteDocstatus: 0,
  created: true,
  noOp: false,
  attached: true,
  error: null,
  errorKind: null,
  warnings: [],
  ...patch,
 });
 describe("status tags", () => {
  it("maps every sync state", () => {
    expect(syncTag(undefined)).toMatchObject({ label: "Not sent", type: "gray" });
    expect(syncTag(sync({ status: "none" })).label).toBe("Not sent");
    expect(syncTag(sync({ remoteDocstatus: 0 }))).toMatchObject({ label: "Draft in ERPNext", type: "blue" });
    expect(syncTag(sync({ remoteDocstatus: 1 }))).toMatchObject({ label: "Submitted", type: "green" });
    expect(syncTag(sync({ status: "error", lastError: "Item missing" }))).toMatchObject({ label: "Error", type: "red", tooltip: "Item missing" });
    expect(syncTag(sync({ status: "conflict", lastError: "" }))).toMatchObject({ label: "Conflict", type: "purple" });
    expect(syncTag(sync({ status: "error", lastError: "" })).tooltip).toBeTruthy();
  });
 });
 describe("configured and disabled reasons", () => {
  it("needs an address, a key and a stored secret", () => {
    expect(isConfigured(config())).toBe(true);
    expect(isConfigured(config({ baseUrl: " " }))).toBe(false);
    expect(isConfigured(config({ apiKey: "" }))).toBe(false);
    expect(isConfigured(config({ apiSecretSet: false }))).toBe(false);
    expect(isConfigured(null)).toBe(false);
  });
  it("asks for a connection test only when the vendor is registered", () => {
    const untested = config({ lastDetectResult: null });
    expect(pushDisabledReason({ cfg: untested, vendorRegistered: true })).toMatch(/Run Test connection first/);
    expect(pushDisabledReason({ cfg: untested, vendorRegistered: false })).toBeNull();
    expect(pushDisabledReason({ cfg: config(), vendorRegistered: true })).toBeNull();
    expect(hasDetectResult(null)).toBe(false);
    expect(hasDetectResult({} as ErpnextConnectionTest)).toBe(false);
    expect(pushDisabledReason({ cfg: null, vendorRegistered: false })).toMatch(/not set up/);
    expect(pushDisabledReason({ cfg: config(), vendorRegistered: false, invoiceStatus: "cancelled" })).toMatch(/Cancelled/);
    expect(pushDisabledReason({ cfg: config(), vendorRegistered: false, invoiceStatus: "issued" })).toBeNull();
  });
  it("allows a payment only against a submitted invoice, once", () => {
    const cfg = config();
    expect(paymentPushDisabledReason({ cfg, sync: undefined, entry: null })).toMatch(/Send the invoice/);
    expect(paymentPushDisabledReason({ cfg, sync: sync({ remoteDocstatus: 0 }), entry: null })).toMatch(/Submit the invoice in ERPNext first/);
    expect(paymentPushDisabledReason({ cfg, sync: sync({ remoteDocstatus: 1 }), entry: null })).toBeNull();
    expect(paymentPushDisabledReason({ cfg, sync: sync({ remoteDocstatus: 1 }), entry: "ACC-PAY-1" })).toMatch(/ACC-PAY-1/);
  });
 });
 describe("push results", () => {
  it("describes outcomes", () => {
    expect(describePush(push())).toMatchObject({ kind: "success", subtitle: "INV/2026-001 (draft)" });
    expect(describePush(push({ remoteDocstatus: 1 })).subtitle).toContain("submitted");
    expect(describePush(push({ noOp: true })).kind).toBe("info");
    const warned = describePush(push({ warnings: ["The PDF was not attached: no permission"] }));
    expect(warned.kind).toBe("warning");
    expect(warned.subtitle).toContain("no permission");
    expect(describePush(push({ ok: false, status: "refused", error: "Run Test connection first", errorKind: "precondition" })).kind).toBe("warning");
    expect(describePush(push({ ok: false, status: "conflict", error: "different total" })).title).toMatch(/conflicts/);
    expect(describePush(push({ ok: false, status: "error", error: "417", errorKind: "validation" })).kind).toBe("error");
    expect(describePaymentPush({ paymentId: 1, invoiceId: 1, ok: true, entryName: "PE-1", alreadySynced: false, error: null, errorKind: null }).kind).toBe("success");
    expect(describePaymentPush({ paymentId: 1, invoiceId: 1, ok: false, entryName: null, alreadySynced: false, error: "nope", errorKind: "other" }).kind).toBe("error");
  });
  it("turns a rejected call into a failed row", () => {
    const r = failedPush(3, "INV/3", "ERPNext is not set up yet");
    expect(r).toMatchObject({ ok: false, invoiceId: 3, number: "INV/3", error: "ERPNext is not set up yet" });
    expect(failedPush(3, "INV/3", new Error("boom")).error).toBe("boom");
  });
  it("summarises a batch", () => {
    const s = summarizeBatch([push(), push({ noOp: true }), push({ ok: false, status: "error", error: "x" })]);
    expect(s).toMatchObject({ total: 3, sent: 1, upToDate: 1, failed: 1, kind: "warning" });
    expect(s.title).toBe("1 sent, 1 already up to date, 1 failed");
    expect(summarizeBatch([push(), push()]).kind).toBe("success");
    expect(summarizeBatch([push({ ok: false })]).kind).toBe("error");
    expect(summarizeBatch([push({ warnings: ["w"] })]).kind).toBe("warning");
  });
 });
 describe("auto push on issue", () => {
  const invoice = { id: 7, number: "INV/2026-007" };
  it("does nothing when it is off or ERPNext is not set up", async () => {
    const pushFn = vi.fn();
    expect(await autoPushIssued({ getConfig: async () => config(), push: pushFn }, invoice, true)).toBeNull();
    expect(await autoPushIssued({ getConfig: async () => config({ autoPushOnIssue: true, apiSecretSet: false }), push: pushFn }, invoice, true)).toBeNull();
    expect(await autoPushIssued({ getConfig: async () => Promise.reject(new Error("db")), push: pushFn }, invoice, true)).toBeNull();
    expect(pushFn).not.toHaveBeenCalled();
  });
  it("pushes with the configured submit setting and reports the result", async () => {
    const pushFn = vi.fn(async () => push({ number: invoice.number }));
    const notice = await autoPushIssued({ getConfig: async () => config({ autoPushOnIssue: true }), push: pushFn }, invoice, true);
    expect(pushFn).toHaveBeenCalledWith(7);
    expect(notice?.kind).toBe("success");
  });
  it("never throws: a rejected push becomes an error notice", async () => {
    const notice = await autoPushIssued(
      { getConfig: async () => config({ autoPushOnIssue: true }), push: async () => Promise.reject("ERPNext is not set up yet") },
      invoice,
      false,
    );
    expect(notice).toMatchObject({ kind: "error" });
    expect(notice?.subtitle).toContain("not set up");
  });
  it("explains a missing connection test instead of pushing", async () => {
    const pushFn = vi.fn();
    const notice = await autoPushIssued({ getConfig: async () => config({ autoPushOnIssue: true, lastDetectResult: null }), push: pushFn }, invoice, true);
    expect(pushFn).not.toHaveBeenCalled();
    expect(notice?.subtitle).toMatch(/Run Test connection first/);
  });
 });
 describe("warnings", () => {
  it("ranks errors before warnings before notes", () => {
    expect(warningSeverity("gst_accounts_not_configured")).toBe("error");
    expect(warningSeverity("ic_not_detected")).toBe("warning");
    expect(warningSeverity("versions_unknown")).toBe("info");
    const sorted = sortWarnings([
      { code: "versions_unknown", message: "a" },
      { code: "company_missing", message: "b" },
      { code: "ic_not_detected", message: "c" },
    ]);
    expect(sorted.map((w) => w.code)).toEqual(["company_missing", "ic_not_detected", "versions_unknown"]);
  });
 });
 describe("settings form", () => {
  it("validates the address like the backend", () => {
    expect(baseUrlProblem("")).toMatch(/Enter/);
    expect(baseUrlProblem("https://erp.example.com")).toBeNull();
    expect(baseUrlProblem("erp.example.com")).toBeNull();
    expect(baseUrlProblem("http://erp.example.com")).toMatch(/https/);
    expect(baseUrlProblem("http://localhost:8000")).toBeNull();
    expect(baseUrlProblem("localhost:8000")).toBeNull();
    expect(baseUrlProblem("http://site.test")).toBeNull();
    expect(baseUrlProblem("http://127.0.0.1:8000")).toBeNull();
    expect(baseUrlProblem("https://user:pw@erp.example.com")).toMatch(/credentials/);
    expect(baseUrlProblem("ftp://erp.example.com")).toMatch(/https/);
  });
  it("builds the input without write-only fields and fills the UOM defaults", () => {
    const input = toInput(config({ uomMap: { hour: "Hr" } }));
    expect(input).not.toHaveProperty("apiSecretSet");
    expect(input).not.toHaveProperty("lastDetectResult");
    expect(input.apiSecret).toBe("");
    expect(input.uomMap).toEqual({ second: "Second", minute: "Minute", hour: "Hr", session: "Nos", unit: "Nos" });
    expect(withDefaultUoms({ hour: " " }).hour).toBe("Hour");
  });
  it("needs a secret only when none is stored or it is being cleared", () => {
    const form = toInput(config());
    expect(connectionProblems(form, true)).toEqual({});
    expect(connectionProblems(form, false).apiSecret).toBeTruthy();
    expect(connectionProblems({ ...form, clearSecret: true }, true).apiSecret).toBeTruthy();
    expect(connectionProblems({ ...form, clearSecret: true, apiSecret: "new" }, true)).toEqual({});
    expect(connectionProblems({ ...form, apiKey: " " }, true).apiKey).toBeTruthy();
  });
  it("validates a save: untouched is fine, series mode needs a series, mirror needs v2 naming", () => {
    const empty = toInput(config({ baseUrl: "", apiKey: "", apiSecretSet: false }));
    expect(validateConfigForm(empty, false, null)).toEqual({});
    const form = toInput(config());
    expect(validateConfigForm(form, true, test)).toEqual({});
    expect(validateConfigForm({ ...form, namingMode: "series", namingSeries: "" }, true, test).namingSeries).toBeTruthy();
    expect(validateConfigForm({ ...form, namingMode: "series", namingSeries: "SINV-.YY.-" }, true, test)).toEqual({});
    const old = { ...test, features: { v2Naming: false, indiaCompliance: true } };
    expect(validateConfigForm(form, true, old).namingMode).toBeTruthy();
    expect(validateConfigForm(form, true, null).namingMode).toBeUndefined();
  });
  it("keeps a saved value visible when the loaded list lacks it", () => {
    const items = [{ name: "A", label: "A", detail: "" }];
    expect(withStoredValue(items, "A")).toBe(items);
    expect(withStoredValue(items, "")).toBe(items);
    const out = withStoredValue(items, "Sales - AC");
    expect(out[0]).toMatchObject({ name: "Sales - AC" });
    expect(out).toHaveLength(2);
  });
 });
 describe("selection and dates", () => {
  it("leaves cancelled invoices out of a send", () => {
    const rows = [
      { id: 1, status: "issued" },
      { id: 2, status: "cancelled" },
      { id: 3, status: "issued" },
    ];
    expect(sendableSelection(rows)).toEqual({ send: [rows[0], rows[2]], skipped: 1 });
    expect(sendableSelection([])).toEqual({ send: [], skipped: 0 });
  });
  it("formats the sync time defensively", () => {
    expect(formatSyncedAt(null)).toBe("");
    expect(formatSyncedAt("not a date")).toBe("not a date");
    expect(formatSyncedAt("2026-04-01T10:30:00+00:00")).toMatch(/2026/);
  });
 });
@@ -0,0 +1,390 @@
 /** Pure helpers behind the ERPNext screens (Settings, History, invoice detail, auto-push). No UI, no Tauri. */
 import type {
  ErpnextConfig,
  ErpnextConfigInput,
  ErpnextConnectionTest,
  ErpnextOptionItem,
  ErpnextOptions,
  ErpnextPaymentPushResult,
  ErpnextPushResult,
  ErpnextSyncStatus,
  ErpnextWarning,
 } from "./erpnext";
 export type TagColor = "red" | "green" | "blue" | "gray" | "purple" | "cool-gray" | "warm-gray";
 export type NoticeKind = "success" | "info" | "warning" | "error";
 export const SETTINGS_LINK_TEXT = "Settings, Integrations";
 // ---- configuration state ----
 /** Enough saved to try a push: address, key and a stored secret. */
 export function isConfigured(cfg: Pick<ErpnextConfig, "baseUrl" | "apiKey" | "apiSecretSet"> | null | undefined): boolean {
  return Boolean(cfg && cfg.baseUrl.trim() && cfg.apiKey.trim() && cfg.apiSecretSet);
 }
 /** True when a connection test result is stored (the backend refuses a registered vendor's push without one). */
 export function hasDetectResult(result: ErpnextConnectionTest | null | undefined): boolean {
  return Boolean(result && typeof result === "object" && Object.keys(result).length > 0);
 }
 export const NOT_CONFIGURED_REASON = "ERPNext is not set up. Enter the address, API key and secret in Settings, Integrations.";
 export const RUN_TEST_REASON = "Run Test connection first (Settings, Integrations).";
 /**
 * Why an invoice cannot be sent right now, or null. The backend applies the same registered-vendor rule using the
 * supplier snapshot frozen on the invoice; the current GST registration setting is the proxy here.
 */
 export function pushDisabledReason(opts: {
  cfg: ErpnextConfig | null;
  vendorRegistered: boolean;
  invoiceStatus?: string;
 }): string | null {
  if (!isConfigured(opts.cfg)) return NOT_CONFIGURED_REASON;
  if (opts.invoiceStatus !== undefined && opts.invoiceStatus !== "issued") {
    return opts.invoiceStatus === "cancelled"
      ? "Cancelled invoices are never sent to ERPNext."
      : "Only issued invoices are sent to ERPNext.";
  }
  if (opts.vendorRegistered && !hasDetectResult(opts.cfg?.lastDetectResult)) return RUN_TEST_REASON;
  return null;
 }
 /** A payment can be posted only against a submitted invoice, once. */
 export function paymentPushDisabledReason(opts: {
  cfg: ErpnextConfig | null;
  sync: ErpnextSyncStatus | undefined;
  entry: string | null | undefined;
 }): string | null {
  if (!isConfigured(opts.cfg)) return NOT_CONFIGURED_REASON;
  if (opts.entry) return `Already sent as ${opts.entry}.`;
  if (!opts.sync || opts.sync.status !== "synced") return "Send the invoice to ERPNext first.";
  if (opts.sync.remoteDocstatus !== 1) return "Submit the invoice in ERPNext first.";
  return null;
 }
 // ---- sync status ----
 export interface SyncTag {
  label: string;
  type: TagColor;
  /** Hover text: the stored error for a failure. */
  tooltip?: string;
 }
 export function syncTag(s: ErpnextSyncStatus | undefined): SyncTag {
  if (!s || s.status === "none") return { label: "Not sent", type: "gray" };
  switch (s.status) {
    case "synced":
      return s.remoteDocstatus === 1
        ? { label: "Submitted", type: "green", tooltip: s.remoteName || undefined }
        : { label: "Draft in ERPNext", type: "blue", tooltip: s.remoteName || undefined };
    case "error":
      return { label: "Error", type: "red", tooltip: s.lastError || "The last send failed." };
    case "conflict":
      return { label: "Conflict", type: "purple", tooltip: s.lastError || "ERPNext already has a different document with this name." };
    case "pending":
      return { label: "Sending", type: "warm-gray" };
    default:
      return { label: "Not sent", type: "gray" };
  }
 }
 export function indexSyncStatuses(list: ErpnextSyncStatus[]): Map<number, ErpnextSyncStatus> {
  return new Map(list.map((s) => [s.invoiceId, s]));
 }
 /** Rows that have an ERPNext document to open. */
 export const canOpenInErpnext = (s: ErpnextSyncStatus | undefined): boolean => Boolean(s && s.remoteName);
 /** Stored sync time (RFC 3339) for display; the raw text if it cannot be parsed, blank if there is none. */
 export function formatSyncedAt(iso: string | null | undefined): string {
  if (!iso) return "";
  const d = new Date(iso);
  return Number.isNaN(d.getTime()) ? iso : d.toLocaleString("en-GB", { day: "2-digit", month: "short", year: "numeric", hour: "2-digit", minute: "2-digit" });
 }
 /** From a selection: the issued invoices that can be sent, and how many were left out (cancelled or draft). */
 export function sendableSelection<T extends { status: string }>(rows: T[]): { send: T[]; skipped: number } {
  const send = rows.filter((r) => r.status === "issued");
  return { send, skipped: rows.length - send.length };
 }
 // ---- push results ----
 export interface Notice {
  kind: NoticeKind;
  title: string;
  subtitle?: string;
 }
 const docState = (docstatus: number) => (docstatus === 1 ? "submitted" : "draft");
 /** One push outcome as a toast. Warnings turn a success into a warning toast so they are read. */
 export function describePush(r: ErpnextPushResult): Notice {
  if (r.ok) {
    const where = `${r.remoteName} (${docState(r.remoteDocstatus)})`;
    if (r.warnings.length > 0) {
      return { kind: "warning", title: `Invoice ${r.number} sent to ERPNext with notes`, subtitle: [where, ...r.warnings].join(" ") };
    }
    if (r.noOp) return { kind: "info", title: `Invoice ${r.number} is already up to date in ERPNext`, subtitle: where };
    return { kind: "success", title: `Invoice ${r.number} sent to ERPNext`, subtitle: where };
  }
  if (r.status === "refused" || r.errorKind === "precondition" || r.errorKind === "config") {
    return { kind: "warning", title: `Invoice ${r.number || r.invoiceId} was not sent`, subtitle: r.error ?? undefined };
  }
  if (r.status === "conflict") {
    return { kind: "error", title: `Invoice ${r.number} conflicts with ERPNext`, subtitle: r.error ?? undefined };
  }
  return { kind: "error", title: `Could not send invoice ${r.number || r.invoiceId}`, subtitle: r.error ?? undefined };
 }
 export function describePaymentPush(r: ErpnextPaymentPushResult): Notice {
  if (r.ok) {
    return r.alreadySynced
      ? { kind: "info", title: "Payment was already sent", subtitle: r.entryName ?? undefined }
      : { kind: "success", title: "Payment sent to ERPNext", subtitle: r.entryName ?? undefined };
  }
  return { kind: "error", title: "Could not send the payment", subtitle: r.error ?? undefined };
 }
 /** A rejected invoke (for example "ERPNext is not set up yet") turned into a result row, so a batch carries on. */
 export function failedPush(invoiceId: number, number: string, error: unknown): ErpnextPushResult {
  return {
    invoiceId,
    number,
    ok: false,
    status: "error",
    remoteName: "",
    remoteDocstatus: 0,
    created: false,
    noOp: false,
    attached: false,
    error: error instanceof Error ? error.message : String(error),
    errorKind: "other",
    warnings: [],
  };
 }
 export interface BatchSummary {
  total: number;
  sent: number;
  upToDate: number;
  failed: number;
  withNotes: number;
  kind: NoticeKind;
  title: string;
 }
 export function summarizeBatch(results: ErpnextPushResult[]): BatchSummary {
  const failed = results.filter((r) => !r.ok).length;
  const upToDate = results.filter((r) => r.ok && r.noOp && r.warnings.length === 0).length;
  const sent = results.filter((r) => r.ok).length - upToDate;
  const withNotes = results.filter((r) => r.ok && r.warnings.length > 0).length;
  const kind: NoticeKind = failed > 0 ? (failed === results.length ? "error" : "warning") : withNotes > 0 ? "warning" : "success";
  const parts = [`${sent} sent`];
  if (upToDate > 0) parts.push(`${upToDate} already up to date`);
  if (failed > 0) parts.push(`${failed} failed`);
  return { total: results.length, sent, upToDate, failed, withNotes, kind, title: parts.join(", ") };
 }
 // ---- auto-push after issue ----
 export interface AutoPushDeps {
  getConfig(): Promise<ErpnextConfig>;
  push(id: number, submit?: boolean): Promise<ErpnextPushResult>;
 }
 /**
 * Pushes a just-issued invoice when "send on issue" is on. Never throws and never blocks the issue: anything that
 * goes wrong comes back as a notice. Returns null when nothing was attempted (off, or not set up).
 */
 export async function autoPushIssued(
  deps: AutoPushDeps,
  invoice: { id: number; number: string },
  vendorRegistered: boolean,
 ): Promise<Notice | null> {
  let cfg: ErpnextConfig;
  try {
    cfg = await deps.getConfig();
  } catch {
    return null;
  }
  if (!cfg.autoPushOnIssue || !isConfigured(cfg)) return null;
  const blocked = pushDisabledReason({ cfg, vendorRegistered });
  if (blocked) return { kind: "warning", title: `Invoice ${invoice.number} was not sent to ERPNext`, subtitle: blocked };
  try {
    return describePush(await deps.push(invoice.id));
  } catch (e) {
    return describePush(failedPush(invoice.id, invoice.number, e));
  }
 }
 // ---- connection test display ----
 const ERROR_CODES = new Set([
  "company_missing",
  "company_address_missing",
  "income_account_missing",
  "tax_accounts_missing",
  "naming_series_missing",
  "naming_series_too_long",
  "number_invalid",
  "mirror_unsupported",
  "gst_accounts_not_configured",
 ]);
 const INFO_CODES = new Set(["versions_unknown", "gst_settings_unreadable"]);
 /** How loudly a test warning is shown: the ones that would make invoices land wrong are errors. */
 export function warningSeverity(code: string): "error" | "warning" | "info" {
  if (ERROR_CODES.has(code)) return "error";
  if (INFO_CODES.has(code)) return "info";
  return "warning";
 }
 export function sortWarnings(list: ErpnextWarning[]): ErpnextWarning[] {
  const rank = { error: 0, warning: 1, info: 2 } as const;
  return [...list].sort((a, b) => rank[warningSeverity(a.code)] - rank[warningSeverity(b.code)]);
 }
 export function versionsLine(test: ErpnextConnectionTest): string {
  const v = test.versions;
  const parts = [
    `Frappe ${v.frappe ?? "unknown"}`,
    `ERPNext ${v.erpnext ?? "unknown"}`,
    test.indiaCompliance ? `India Compliance ${v.indiaCompliance ?? "installed"}` : "India Compliance not detected",
  ];
  return parts.join(" · ");
 }
 // ---- settings form ----
 export const UOM_UNITS = ["second", "minute", "hour", "session", "unit"] as const;
 export const DEFAULT_UOM_MAP: Record<string, string> = {
  second: "Second",
  minute: "Minute",
  hour: "Hour",
  session: "Nos",
  unit: "Nos",
 };
 export function withDefaultUoms(map: Record<string, string> | undefined): Record<string, string> {
  const out: Record<string, string> = { ...DEFAULT_UOM_MAP };
  for (const [k, v] of Object.entries(map ?? {})) if (v.trim()) out[k] = v;
  return out;
 }
 /** What the form edits: the saved config minus the write-only fields, plus the secret being typed. */
 export function toInput(cfg: ErpnextConfig): ErpnextConfigInput {
  const { apiSecretSet: _set, lastDetectResult: _last, ...rest } = cfg;
  void _set;
  void _last;
  return { ...rest, uomMap: withDefaultUoms(rest.uomMap), apiSecret: "", clearSecret: false };
 }
 /** Mirror mode needs a Frappe that keeps a posted name; an untested site defaults to it (the backend default). */
 export function mirrorSupported(test: ErpnextConnectionTest | null): boolean {
  return test ? test.features.v2Naming : true;
 }
 export function isLocalDevHost(host: string): boolean {
  const h = host.replace(/\.$/, "").toLowerCase();
  return h === "localhost" || h === "127.0.0.1" || h.endsWith(".localhost") || h.endsWith(".test");
 }
 /** Same rules as the backend's address check, so a bad address is caught before the round trip. */
 export function baseUrlProblem(raw: string): string | null {
  const text = raw.trim();
  if (!text) return "Enter the address of your ERPNext site.";
  const withScheme = text.includes("://") ? text : `${isLocalDevHost(text.split(/[/:]/)[0] ?? "") ? "http" : "https"}://${text}`;
  let url: URL;
  try {
    url = new URL(withScheme);
  } catch {
    return "This is not a valid address, e.g. https://erp.example.com";
  }
  if (url.protocol !== "https:" && url.protocol !== "http:") return "Use an https:// address.";
  if (url.protocol === "http:" && !isLocalDevHost(url.hostname)) {
    return "Use an https:// address. Plain http is only allowed for localhost, 127.0.0.1, *.localhost and *.test.";
  }
  if (url.username || url.password) return "Do not put credentials in the address; use the API key and secret fields.";
  return null;
 }
 export interface FormProblems {
  baseUrl?: string;
  apiKey?: string;
  apiSecret?: string;
  company?: string;
  namingSeries?: string;
  namingMode?: string;
 }
 /** Problems that stop a Test connection (address, key, secret). */
 export function connectionProblems(form: ErpnextConfigInput, secretStored: boolean): FormProblems {
  const p: FormProblems = {};
  const url = baseUrlProblem(form.baseUrl);
  if (url) p.baseUrl = url;
  if (!form.apiKey.trim()) p.apiKey = "Enter the API key.";
  if (!form.apiSecret.trim() && (form.clearSecret || !secretStored)) p.apiSecret = "Enter the API secret.";
  return p;
 }
 /** Problems that stop a Save. An empty form (nothing set up) saves fine; a half-filled one does not. */
 export function validateConfigForm(form: ErpnextConfigInput, secretStored: boolean, test: ErpnextConnectionTest | null): FormProblems {
  const touched = form.baseUrl.trim() || form.apiKey.trim() || form.apiSecret.trim() || secretStored;
  if (!touched) return {};
  const p = connectionProblems(form, secretStored);
  if (form.namingMode === "series" && !form.namingSeries.trim()) p.namingSeries = "Choose or enter the naming series.";
  if (form.namingMode === "mirror" && !mirrorSupported(test)) {
    p.namingMode = "This ERPNext version does not keep a posted invoice number. Use ERPNext series.";
  }
  return p;
 }
 export const hasProblems = (p: FormProblems): boolean => Object.keys(p).length > 0;
 /** Options for a dropdown, with the saved value kept visible when the loaded list does not contain it. */
 export function withStoredValue(items: ErpnextOptionItem[], stored: string): ErpnextOptionItem[] {
  const value = stored.trim();
  if (!value || items.some((i) => i.name === value)) return items;
  return [{ name: value, label: value, detail: "saved value, not in the loaded list" }, ...items];
 }
 export const optionText = (i: ErpnextOptionItem): string => (i.detail ? `${i.label} (${i.detail})` : i.label);
 export const OPTION_LIST_LABELS: Record<string, string> = {
  companies: "Companies",
  companyAddresses: "Company addresses",
  incomeAccounts: "Income accounts",
  taxAccounts: "Tax accounts",
  taxTemplates: "Tax templates",
  namingSeries: "Naming series",
  itemGroups: "Item groups",
  uoms: "Units of measure",
  costCenters: "Cost centers",
  priceLists: "Price lists",
  customerGroups: "Customer groups",
  territories: "Territories",
 };
 /** Per-list load errors keyed by list name; the other lists stay usable. */
 export function optionErrors(options: ErpnextOptions | null): Map<string, string> {
  return new Map((options?.errors ?? []).map((e) => [e.list, e.message]));
 }
 export const emptyOptions = (): ErpnextOptions => ({
  companies: [],
  companyAddresses: [],
  incomeAccounts: [],
  taxAccounts: [],
  taxTemplates: [],
  namingSeries: [],
  itemGroups: [],
  uoms: [],
  costCenters: [],
  priceLists: [],
  customerGroups: [],
  territories: [],
  errors: [],
 });
@@ -154,7 +154,7 @@ export interface HistoryExportDeps {
  now(): Date;
 }
-function joinPath(dir: string, name: string): string {
+export function joinPath(dir: string, name: string): string {
  if (!dir) return name;
  if (/[\\/]$/.test(dir)) return `${dir}${name}`;
  return `${dir}${dir.includes("\\") && !dir.includes("/") ? "\\" : "/"}${name}`;
@@ -0,0 +1,311 @@
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { describe, expect, it } from "vitest";
 import {
  buildInvoiceDoc,
  exportInvoicesV1,
  invoiceExportName,
  LINE_CSV_HEADERS,
  loadInvoiceDocs,
  rateString,
  rupeesToPaise,
  toInvoiceJson,
  toLineItemsCsv,
  type InvoiceExportDeps,
 } from "./invoiceExportV1";
 import type { Payment } from "./payments";
 import { blankClient, type Client, type Invoice } from "./types";
 const VENDOR = (patch: Record<string, unknown> = {}) =>
  JSON.stringify({
    vendorName: "Test Vendor",
    vendorAddress: "1 Main Rd\nPune",
    vendorEmail: "a@example.com",
    vendorPhone: "999",
    vendorPan: "AAPFU0939F",
    vendorGstin: "27AAPFU0939F1ZV",
    vendorStateCode: "27",
    logoPath: "/secret/logo.png",
    signaturePath: "/secret/sig.png",
    gstRegistration: "regular",
    signatoryName: "Sample",
    ...patch,
  });
 const invoice = (patch: Partial<Invoice> = {}): Invoice => ({
  id: 1,
  number: "INV/2026-001",
  seriesId: 1,
  invoiceDate: "2026-04-01",
  dueDate: "2026-05-01",
  clientId: 5,
  clientName: "Client Ltd",
  clientAddress: "12 MG Road\nBengaluru 560001",
  clientGstin: "29AABCU9603R1ZJ",
  poNumber: "PO-9",
  placeOfSupplyStateCode: "29",
  subtotal: 7310.1,
  discount: 10.1,
  taxType: "igst",
  taxRate: 18,
  cgstAmount: 0,
  sgstAmount: 0,
  igstAmount: 1314,
  total: 8614,
  amountInWords: "Rupees Eight Thousand Six Hundred Fourteen Only",
  bankAccountId: null,
  bankSnapshot: "",
  signaturePath: null,
  notes: "Thank you",
  status: "issued",
  createdAt: "2026-04-01T00:00:00Z",
  updatedAt: "2026-04-01T00:00:00Z",
  docType: "tax_invoice",
  reverseCharge: false,
  vendorSnapshot: VENDOR(),
  snapshotOrigin: "issued",
  cancelledAt: null,
  cancelReason: "",
  archivedPdfSha256: null,
  renderPrefs: "",
  items: [
    { id: 1, description: "Design", mode: "fixed", rate: 0, unit: "unit", quantity: 1, amount: 5000.1, sortOrder: 0, hsnSac: "998391" },
    { id: 2, description: "Consulting", mode: "rate", rate: 1155.05, unit: "hour", quantity: 2, amount: 2310, sortOrder: 1, hsnSac: "" },
  ],
  totalPaise: 861400,
  ...patch,
 });
 const client: Client = {
  ...blankClient(),
  id: 5,
  name: "Client Ltd",
  stateCode: "29",
  addressLine1: "12 MG Road",
  addressLine2: "",
  city: "Bengaluru",
  pincode: "560001",
  gstCategory: "registered_regular",
 };
 const payment = (patch: Partial<Payment> = {}): Payment => ({
  id: 1,
  invoiceId: 1,
  paidOn: "2026-04-10",
  amountPaise: 700000,
  tdsPaise: 70000,
  mode: "bank_transfer",
  reference: "UTR123",
  notes: "n",
  createdAt: "x",
  ...patch,
 });
 describe("voiced.invoice.v1 document", () => {
  it("matches the golden file for a fixture invoice", () => {
    const text = toInvoiceJson([buildInvoiceDoc(invoice(), [payment()], client)]);
    const path = new URL("./__golden__/invoice-v1.golden.json", import.meta.url);
    if (!existsSync(path)) writeFileSync(path, text);
    expect(text).toBe(readFileSync(path, "utf8"));
  });
  it("is deterministic and keeps the key order", () => {
    const a = toInvoiceJson([buildInvoiceDoc(invoice(), [payment()], client)]);
    const b = toInvoiceJson([buildInvoiceDoc(invoice(), [payment()], client)]);
    expect(a).toBe(b);
    const doc = buildInvoiceDoc(invoice(), [], null);
    expect(Object.keys(doc).slice(0, 4)).toEqual(["schema", "number", "issue_date", "due_date"]);
    expect(doc.schema).toBe("voiced.invoice.v1");
  });
  it("carries every amount as exact paise and a matching decimal string", () => {
    const doc = buildInvoiceDoc(invoice(), [payment()], client);
    // Plain float multiplication is off (0.29 * 100 is 28.999999999999996); the paise must be exact integers.
    expect(0.29 * 100).not.toBe(29);
    expect(doc.totals.subtotal_paise).toBe(731010);
    expect(doc.totals.subtotal).toBe("7310.10");
    expect(doc.totals.discount).toBe("10.10");
    expect(doc.totals.taxable_value_paise).toBe(730000);
    expect(doc.totals.tax).toBe("1314.00");
    expect(doc.totals.total_paise).toBe(861400);
    expect(doc.totals.total).toBe("8614.00");
    expect(doc.items[0]).toMatchObject({ quantity: "1", unit: null, rate: "5000.10", taxable_value_paise: 500010, hsn_sac: "998391" });
    expect(doc.items[1]).toMatchObject({ quantity: "2", unit: "hour", rate: "1155.05", rate_paise: 115505, hsn_sac: null });
    expect(doc.payments[0]).toMatchObject({ amount: "7000.00", tds: "700.00", tds_paise: 70000 });
    // Every *_paise field is a safe integer and agrees with its decimal.
    const walk = (o: unknown, path: string[] = []) => {
      if (!o || typeof o !== "object") return;
      const rec = o as Record<string, unknown>;
      for (const [k, v] of Object.entries(rec)) {
        if (k.endsWith("_paise")) {
          expect(Number.isSafeInteger(v), path.concat(k).join(".")).toBe(true);
          const dec = rec[k.slice(0, -6)];
          expect(dec, path.concat(k).join(".")).toBe(`${Math.trunc((v as number) / 100)}.${String(Math.abs(v as number) % 100).padStart(2, "0")}`);
        } else walk(v, path.concat(k));
      }
    };
    walk(JSON.parse(toInvoiceJson([doc])));
  });
  it("reports the tax heads: CGST+SGST at half rate, IGST whole, none for an unregistered vendor", () => {
    const intra = buildInvoiceDoc(invoice({ taxType: "cgst_sgst", taxRate: 12.5, cgstAmount: 100.25, sgstAmount: 100.25, igstAmount: 0 }), [], client);
    expect(intra.tax.cgst).toEqual({ rate: "6.25", amount_paise: 10025, amount: "100.25" });
    expect(intra.tax.sgst).toEqual({ rate: "6.25", amount_paise: 10025, amount: "100.25" });
    expect(intra.tax.igst).toEqual({ rate: "0", amount_paise: 0, amount: "0.00" });
    expect(intra.tax.utgst.amount_paise).toBe(0);
    expect(intra.totals.tax_paise).toBe(20050);
    const inter = buildInvoiceDoc(invoice(), [], client);
    expect(inter.tax.igst).toEqual({ rate: "18", amount_paise: 131400, amount: "1314.00" });
    expect(inter.tax.cgst.rate).toBe("0");
  });
  it("moves the second head to UTGST when the supplier is in a union territory", () => {
    const doc = buildInvoiceDoc(
      invoice({ taxType: "cgst_sgst", taxRate: 18, cgstAmount: 90, sgstAmount: 90, igstAmount: 0, vendorSnapshot: VENDOR({ vendorStateCode: "04" }) }),
      [],
      client,
    );
    expect(doc.tax.sgst.amount_paise).toBe(0);
    expect(doc.tax.utgst).toEqual({ rate: "9", amount_paise: 9000, amount: "90.00" });
    expect(doc.supplier.state).toEqual({ code: "04", name: "Chandigarh" });
  });
  it("flags a cancelled invoice and keeps its figures", () => {
    const doc = buildInvoiceDoc(invoice({ status: "cancelled", cancelledAt: "2026-04-05T10:00:00Z", cancelReason: "wrong client" }), [], client);
    expect(doc).toMatchObject({ status: "cancelled", cancelled: true, cancelled_at: "2026-04-05T10:00:00Z", cancel_reason: "wrong client" });
    expect(doc.totals.total).toBe("8614.00");
    const live = buildInvoiceDoc(invoice(), [], client);
    expect(live).toMatchObject({ cancelled: false, cancelled_at: null, cancel_reason: null });
  });
  it("exports an unregistered vendor's plain invoice without tax or GSTIN", () => {
    const doc = buildInvoiceDoc(
      invoice({
        docType: "invoice",
        taxType: "none",
        taxRate: 0,
        igstAmount: 0,
        subtotal: 7300,
        discount: 0,
        total: 7300,
        totalPaise: 730000,
        clientGstin: "",
        vendorSnapshot: VENDOR({ gstRegistration: "unregistered", vendorGstin: "" }),
      }),
      [],
      null,
    );
    expect(doc.document_type).toBe("invoice");
    expect(doc.supplier).toMatchObject({ gstin: null, gst_registration: "unregistered" });
    expect(doc.totals.tax_paise).toBe(0);
    expect(doc.tax.igst.rate).toBe("0");
    expect(doc.client.gstin).toBeNull();
    expect(doc.client.gst_category).toBe("unregistered");
    expect(doc.client.address).toMatchObject({ line1: null, city: null, state: null });
  });
  it("does not leak local file paths from the supplier snapshot", () => {
    const text = toInvoiceJson([buildInvoiceDoc(invoice(), [], client)]);
    expect(text).not.toContain("/secret/");
    expect(text).not.toContain("a@example.com");
  });
  it("survives a missing or broken supplier snapshot", () => {
    for (const vendorSnapshot of ["", "not json", "null"]) {
      const doc = buildInvoiceDoc(invoice({ vendorSnapshot }), [], client);
      expect(doc.supplier).toMatchObject({ name: "", gstin: null, state: { code: "", name: "" } });
    }
  });
  it("converts rupees and rates without noise", () => {
    expect(rupeesToPaise(0.29)).toBe(29);
    expect(rupeesToPaise(-0.001)).toBe(0);
    expect(() => rupeesToPaise(Number.NaN)).toThrow();
    expect(rateString(9)).toBe("9");
    expect(rateString(2.5)).toBe("2.5");
    expect(rateString(0.1 + 0.2)).toBe("0.3");
  });
 });
 describe("line-items CSV", () => {
  it("writes a BOM, CRLF, a header and one row per line with invoice amounts on the first row only", () => {
    const csv = toLineItemsCsv([buildInvoiceDoc(invoice(), [], client)]);
    expect(csv.startsWith("")).toBe(true);
    const lines = csv.slice(1).split("\r\n");
    expect(lines[0]).toBe(LINE_CSV_HEADERS.join(","));
    expect(lines).toHaveLength(4); // header, 2 lines, trailing empty
    const first = lines[1].split(",");
    const second = lines[2].split(",");
    const col = (name: string) => LINE_CSV_HEADERS.indexOf(name);
    expect(first[col("invoice_total")]).toBe("8614.00");
    expect(second[col("invoice_total")]).toBe("");
    expect(first[col("invoice_igst")]).toBe("1314.00");
    expect(second[col("taxable_value")]).toBe("2310.00");
    expect(first[col("invoice_number")]).toBe("INV/2026-001");
  });
  it("quotes commas and quotes, and guards formulas", () => {
    const doc = buildInvoiceDoc(invoice({ items: [{ id: 1, description: '=SUM(A1), "x"', mode: "fixed", rate: 0, unit: "unit", quantity: 1, amount: 10, sortOrder: 0 }] }), [], client);
    const csv = toLineItemsCsv([doc]);
    expect(csv).toContain(`"'=SUM(A1), ""x"""`);
  });
  it("keeps an invoice with no items as one row", () => {
    const csv = toLineItemsCsv([buildInvoiceDoc(invoice({ items: [] }), [], client)]);
    expect(csv.slice(1).split("\r\n")).toHaveLength(3);
  });
 });
 describe("saving", () => {
  const deps = (over: Partial<InvoiceExportDeps> = {}): InvoiceExportDeps & { written: { path: string; text: string }[] } => {
    const written: { path: string; text: string }[] = [];
    return {
      written,
      getInvoice: async (id) => invoice({ id, number: `INV/2026-00${id}` }),
      listPayments: async () => [payment()],
      listClients: async () => [client],
      getLastExportDir: async () => "/home/a/exports",
      save: async ({ defaultPath }) => defaultPath,
      writeExportFile: async (path, bytes) => {
        written.push({ path, text: new TextDecoder().decode(bytes) });
        return path;
      },
      now: () => new Date("2026-06-01T10:00:00Z"),
      ...over,
    };
  };
  it("names the file after the invoice or the count", () => {
    const one = [buildInvoiceDoc(invoice(), [], null)];
    const now = new Date("2026-06-01T10:00:00Z");
    expect(invoiceExportName(one, "json", now)).toBe("voiced-invoice-INV-2026-001.json");
    expect(invoiceExportName(one, "csv", now)).toBe("voiced-invoice-INV-2026-001-lines.csv");
    expect(invoiceExportName([...one, ...one], "json", now)).toBe("voiced-invoices-2-2026-06-01.json");
  });
  it("writes the chosen invoices in order, once each", async () => {
    const d = deps();
    const done = await exportInvoicesV1(d, [2, 1, 2], "json");
    expect(done).toEqual({ path: "/home/a/exports/voiced-invoices-2-2026-06-01.json", count: 2 });
    const docs = JSON.parse(d.written[0].text) as { number: string }[];
    expect(docs.map((x) => x.number)).toEqual(["INV/2026-002", "INV/2026-001"]);
  });
  it("returns null when the dialog is cancelled and writes nothing", async () => {
    const d = deps({ save: async () => null });
    expect(await exportInvoicesV1(d, [1], "csv")).toBeNull();
    expect(d.written).toHaveLength(0);
  });
  it("still exports when the client list cannot be read", async () => {
    const docs = await loadInvoiceDocs(deps({ listClients: async () => Promise.reject(new Error("db")) }), [1]);
    expect(docs).toHaveLength(1);
    expect(docs[0].client.address.line1).toBeNull();
  });
  it("works without a remembered folder", async () => {
    const d = deps({ getLastExportDir: async () => Promise.reject(new Error("none")) });
    const done = await exportInvoicesV1(d, [1], "json");
    expect(done?.path).toBe("voiced-invoice-INV-2026-001.json");
  });
 });
@@ -0,0 +1,364 @@
 /**
 * The generic `voiced.invoice.v1` export: a canonical, deterministic JSON document per invoice (and a CSV of line
 * items) for software that Voiced has no direct integration with. Pure: it formats data it is handed, using integer
 * paise for every amount, and never touches Tauri. The format is described in docs/voiced-invoice-v1.md.
 */
 import { csvField, guardFormula, joinPath, paiseToDecimal } from "./historyExport";
 import type { Payment } from "./payments";
 import { INDIAN_STATES, type Client, type Invoice } from "./types";
 export const INVOICE_SCHEMA = "voiced.invoice.v1";
 /** Union territories without a legislature (mirror of `is_ut_without_legislature` in gst.rs): their second head is UTGST. */
 const UT_WITHOUT_LEGISLATURE = new Set(["04", "26", "31", "35", "38"]);
 export interface TaxHeadV1 {
  /** Percent, e.g. "9" or "2.5"; "0" when the head does not apply to the invoice. */
  rate: string;
  amount_paise: number;
  amount: string;
 }
 export interface InvoiceDocV1 {
  schema: typeof INVOICE_SCHEMA;
  number: string;
  issue_date: string;
  due_date: string | null;
  document_type: "tax_invoice" | "invoice";
  status: string;
  cancelled: boolean;
  cancelled_at: string | null;
  cancel_reason: string | null;
  currency: "INR";
  po_number: string | null;
  supplier: {
    name: string;
    address: string;
    gstin: string | null;
    pan: string | null;
    gst_registration: string;
    state: { code: string; name: string };
  };
  client: {
    name: string;
    gstin: string | null;
    gst_category: string;
    address: {
      text: string;
      line1: string | null;
      line2: string | null;
      city: string | null;
      pincode: string | null;
      state: { code: string; name: string } | null;
    };
    place_of_supply: { code: string; name: string };
  };
  items: {
    line: number;
    description: string;
    hsn_sac: string | null;
    quantity: string;
    unit: string | null;
    rate_paise: number;
    rate: string;
    taxable_value_paise: number;
    taxable_value: string;
  }[];
  tax: { cgst: TaxHeadV1; sgst: TaxHeadV1; utgst: TaxHeadV1; igst: TaxHeadV1 };
  totals: {
    subtotal_paise: number;
    subtotal: string;
    discount_paise: number;
    discount: string;
    taxable_value_paise: number;
    taxable_value: string;
    tax_paise: number;
    tax: string;
    total_paise: number;
    total: string;
    amount_in_words: string | null;
  };
  reverse_charge: boolean;
  notes: string | null;
  payments: {
    date: string;
    amount_paise: number;
    amount: string;
    tds_paise: number;
    tds: string;
    mode: string;
    reference: string | null;
  }[];
 }
 /** Rupees as stored (a REAL with two decimals) to integer paise, rounded exactly as the backend does. */
 export function rupeesToPaise(rupees: number): number {
  const paise = Math.round(rupees * 100);
  if (!Number.isSafeInteger(paise)) throw new Error(`Not an amount: ${rupees}`);
  return paise === 0 ? 0 : paise; // no negative zero
 }
 const blank = (s: string | null | undefined): string | null => {
  const t = (s ?? "").trim();
  return t === "" ? null : t;
 };
 const gstinOf = (s: string | null | undefined): string | null => {
  const t = blank(s);
  return t === null || t.toUpperCase() === "NA" ? null : t;
 };
 const stateOf = (code: string): { code: string; name: string } => ({
  code,
  name: INDIAN_STATES.find((s) => s.code === code)?.name ?? "",
 });
 /** A percentage as the shortest decimal string (9, 6.25), without binary noise. */
 export function rateString(rate: number): string {
  return String(Number(rate.toFixed(4)));
 }
 interface Snapshot {
  vendorName?: string;
  vendorAddress?: string;
  vendorGstin?: string;
  vendorPan?: string;
  vendorStateCode?: string;
  gstRegistration?: string;
 }
 function parseSnapshot(text: string): Snapshot {
  try {
    const v: unknown = text ? JSON.parse(text) : {};
    return v && typeof v === "object" ? (v as Snapshot) : {};
  } catch {
    return {};
  }
 }
 const head = (rate: number, rupees: number): TaxHeadV1 => {
  const paise = rupeesToPaise(rupees);
  return { rate: rateString(rate), amount_paise: paise, amount: paiseToDecimal(paise) };
 };
 /**
 * One invoice as `voiced.invoice.v1`. The supplier comes from the snapshot frozen at issue. The client's name, GSTIN
 * and place of supply are frozen on the invoice too; the structured address and GST category are read from the saved
 * client record (`client`, optional) because the invoice only froze the printed text.
 */
 export function buildInvoiceDoc(invoice: Invoice, payments: Payment[], client?: Client | null): InvoiceDocV1 {
  const snap = parseSnapshot(invoice.vendorSnapshot);
  const supplierState = snap.vendorStateCode ?? "";
  const isUt = UT_WITHOUT_LEGISLATURE.has(supplierState);
  const half = invoice.taxType === "cgst_sgst" ? invoice.taxRate / 2 : 0;
  const igstRate = invoice.taxType === "igst" ? invoice.taxRate : 0;
  const zero = (): TaxHeadV1 => head(0, 0);
  const secondHead = head(half, invoice.sgstAmount);
  const tax = {
    cgst: head(half, invoice.cgstAmount),
    sgst: isUt ? zero() : secondHead,
    utgst: isUt ? secondHead : zero(),
    igst: head(igstRate, invoice.igstAmount),
  };
  const subtotal = rupeesToPaise(invoice.subtotal);
  const discount = rupeesToPaise(invoice.discount);
  const totalTax = tax.cgst.amount_paise + tax.sgst.amount_paise + tax.utgst.amount_paise + tax.igst.amount_paise;
  const total = invoice.totalPaise ?? rupeesToPaise(invoice.total);
  const gstin = gstinOf(invoice.clientGstin);
  const pos = invoice.placeOfSupplyStateCode;
  const clientState = client && client.stateCode ? stateOf(client.stateCode) : null;
  return {
    schema: INVOICE_SCHEMA,
    number: invoice.number,
    issue_date: invoice.invoiceDate,
    due_date: blank(invoice.dueDate),
    document_type: invoice.docType,
    status: invoice.status,
    cancelled: invoice.status === "cancelled",
    cancelled_at: invoice.status === "cancelled" ? blank(invoice.cancelledAt) : null,
    cancel_reason: invoice.status === "cancelled" ? blank(invoice.cancelReason) : null,
    currency: "INR",
    po_number: blank(invoice.poNumber),
    supplier: {
      name: snap.vendorName ?? "",
      address: snap.vendorAddress ?? "",
      gstin: gstinOf(snap.vendorGstin),
      pan: blank(snap.vendorPan),
      gst_registration: snap.gstRegistration ?? "",
      state: stateOf(supplierState),
    },
    client: {
      name: invoice.clientName,
      gstin,
      gst_category: client?.gstCategory ?? (gstin ? "registered_regular" : "unregistered"),
      address: {
        text: invoice.clientAddress,
        line1: blank(client?.addressLine1),
        line2: blank(client?.addressLine2),
        city: blank(client?.city),
        pincode: blank(client?.pincode),
        state: clientState,
      },
      place_of_supply: stateOf(pos),
    },
    items: invoice.items.map((item, index) => {
      const fixed = item.mode === "fixed";
      const amount = rupeesToPaise(item.amount);
      const rate = fixed ? amount : rupeesToPaise(item.rate);
      return {
        line: index + 1,
        description: item.description,
        hsn_sac: blank(item.hsnSac),
        quantity: fixed ? "1" : String(item.quantity),
        unit: fixed ? null : item.unit,
        rate_paise: rate,
        rate: paiseToDecimal(rate),
        taxable_value_paise: amount,
        taxable_value: paiseToDecimal(amount),
      };
    }),
    tax,
    totals: {
      subtotal_paise: subtotal,
      subtotal: paiseToDecimal(subtotal),
      discount_paise: discount,
      discount: paiseToDecimal(discount),
      taxable_value_paise: subtotal - discount,
      taxable_value: paiseToDecimal(subtotal - discount),
      tax_paise: totalTax,
      tax: paiseToDecimal(totalTax),
      total_paise: total,
      total: paiseToDecimal(total),
      amount_in_words: blank(invoice.amountInWords),
    },
    reverse_charge: invoice.reverseCharge,
    notes: blank(invoice.notes),
    payments: payments.map((p) => ({
      date: p.paidOn,
      amount_paise: p.amountPaise,
      amount: paiseToDecimal(p.amountPaise),
      tds_paise: p.tdsPaise,
      tds: paiseToDecimal(p.tdsPaise),
      mode: p.mode,
      reference: blank(p.reference),
    })),
  };
 }
 /** The JSON file: an array of invoice documents in the given order. Same input, same bytes. */
 export function toInvoiceJson(docs: InvoiceDocV1[]): string {
  return `${JSON.stringify(docs, null, 2)}\n`;
 }
 // ---- CSV: one row per line item ----
 type Kind = "text" | "amount";
 const LINE_COLUMNS: readonly { header: string; kind: Kind; value: (d: InvoiceDocV1, line: number) => string }[] = [
  { header: "invoice_number", kind: "text", value: (d) => d.number },
  { header: "issue_date", kind: "text", value: (d) => d.issue_date },
  { header: "due_date", kind: "text", value: (d) => d.due_date ?? "" },
  { header: "document_type", kind: "text", value: (d) => d.document_type },
  { header: "status", kind: "text", value: (d) => d.status },
  { header: "cancelled", kind: "text", value: (d) => (d.cancelled ? "yes" : "no") },
  { header: "currency", kind: "text", value: (d) => d.currency },
  { header: "supplier_name", kind: "text", value: (d) => d.supplier.name },
  { header: "supplier_gstin", kind: "text", value: (d) => d.supplier.gstin ?? "" },
  { header: "client_name", kind: "text", value: (d) => d.client.name },
  { header: "client_gstin", kind: "text", value: (d) => d.client.gstin ?? "" },
  { header: "client_gst_category", kind: "text", value: (d) => d.client.gst_category },
  { header: "place_of_supply_code", kind: "text", value: (d) => d.client.place_of_supply.code },
  { header: "place_of_supply", kind: "text", value: (d) => d.client.place_of_supply.name },
  { header: "reverse_charge", kind: "text", value: (d) => (d.reverse_charge ? "yes" : "no") },
  { header: "line", kind: "text", value: (d, i) => (d.items[i] ? String(d.items[i].line) : "") },
  { header: "description", kind: "text", value: (d, i) => d.items[i]?.description ?? "" },
  { header: "hsn_sac", kind: "text", value: (d, i) => d.items[i]?.hsn_sac ?? "" },
  { header: "quantity", kind: "text", value: (d, i) => d.items[i]?.quantity ?? "" },
  { header: "unit", kind: "text", value: (d, i) => d.items[i]?.unit ?? "" },
  { header: "rate", kind: "amount", value: (d, i) => d.items[i]?.rate ?? "" },
  { header: "taxable_value", kind: "amount", value: (d, i) => d.items[i]?.taxable_value ?? "" },
  // Invoice-level amounts sit on the first row only, so summing a column never counts an invoice twice.
  { header: "invoice_discount", kind: "amount", value: (d, i) => (i === 0 ? d.totals.discount : "") },
  { header: "invoice_cgst", kind: "amount", value: (d, i) => (i === 0 ? d.tax.cgst.amount : "") },
  { header: "invoice_sgst", kind: "amount", value: (d, i) => (i === 0 ? d.tax.sgst.amount : "") },
  { header: "invoice_utgst", kind: "amount", value: (d, i) => (i === 0 ? d.tax.utgst.amount : "") },
  { header: "invoice_igst", kind: "amount", value: (d, i) => (i === 0 ? d.tax.igst.amount : "") },
  { header: "invoice_total", kind: "amount", value: (d, i) => (i === 0 ? d.totals.total : "") },
 ];
 export const LINE_CSV_HEADERS: readonly string[] = LINE_COLUMNS.map((c) => c.header);
 /** UTF-8 BOM, CRLF, header row always present; text cells are guarded against spreadsheet formulas. */
 export function toLineItemsCsv(docs: InvoiceDocV1[]): string {
  const lines: string[] = [LINE_COLUMNS.map((c) => csvField(c.header)).join(",")];
  for (const doc of docs) {
    const rows = Math.max(1, doc.items.length);
    for (let i = 0; i < rows; i++) {
      lines.push(LINE_COLUMNS.map((c) => csvField(c.kind === "text" ? guardFormula(c.value(doc, i)) : c.value(doc, i))).join(","));
    }
  }
  return `${lines.join("\r\n")}\r\n`;
 }
 // ---- saving ----
 export type InvoiceExportFormat = "json" | "csv";
 const safeName = (s: string) => s.replace(/[^A-Za-z0-9._-]+/g, "-");
 export function invoiceExportName(docs: InvoiceDocV1[], format: InvoiceExportFormat, now: Date): string {
  const base =
    docs.length === 1
      ? `voiced-invoice-${safeName(docs[0].number)}`
      : `voiced-invoices-${docs.length}-${now.toISOString().slice(0, 10)}`;
  return `${base}${format === "csv" ? "-lines" : ""}.${format}`;
 }
 export interface InvoiceExportDeps {
  getInvoice(id: number): Promise<Invoice>;
  listPayments(invoiceId: number): Promise<Payment[]>;
  listClients(): Promise<Client[]>;
  getLastExportDir(): Promise<string>;
  save(opts: { defaultPath: string; format: InvoiceExportFormat }): Promise<string | null>;
  writeExportFile(path: string, bytes: Uint8Array): Promise<string>;
  now(): Date;
 }
 /** Reads the invoices (frozen data plus payments) in the order given; the client record is optional detail. */
 export async function loadInvoiceDocs(deps: Pick<InvoiceExportDeps, "getInvoice" | "listPayments" | "listClients">, ids: number[]): Promise<InvoiceDocV1[]> {
  const unique = [...new Set(ids)];
  const loaded: { invoice: Invoice; payments: Payment[] }[] = [];
  for (const id of unique) {
    const [invoice, payments] = await Promise.all([deps.getInvoice(id), deps.listPayments(id)]);
    loaded.push({ invoice, payments });
  }
  let clients = new Map<number, Client>();
  if (loaded.some((l) => l.invoice.clientId !== null)) {
    try {
      clients = new Map((await deps.listClients()).filter((c) => c.id !== null).map((c) => [c.id as number, c]));
    } catch {
      // The structured address is extra detail; the export is complete without it.
    }
  }
  return loaded.map(({ invoice, payments }) => buildInvoiceDoc(invoice, payments, invoice.clientId === null ? null : (clients.get(invoice.clientId) ?? null)));
 }
 /** Exports the chosen invoices through the save dialog. Returns the path, or null if the dialog was cancelled. */
 export async function exportInvoicesV1(deps: InvoiceExportDeps, ids: number[], format: InvoiceExportFormat): Promise<{ path: string; count: number } | null> {
  const docs = await loadInvoiceDocs(deps, ids);
  const text = format === "csv" ? toLineItemsCsv(docs) : toInvoiceJson(docs);
  let dir = "";
  try {
    dir = await deps.getLastExportDir();
  } catch {
    // No remembered folder: the dialog opens wherever the system prefers.
  }
  const chosen = await deps.save({ defaultPath: joinPath(dir, invoiceExportName(docs, format, deps.now())), format });
  if (!chosen) return null;
  const path = (await deps.writeExportFile(chosen, new TextEncoder().encode(text))) || chosen;
  return { path, count: docs.length };
 }
@@ -23,9 +23,11 @@ export interface Payment {
  reference: string;
  notes: string;
  createdAt: string;
  /** Payment Entry name on ERPNext once the payment was sent. */
  erpnextPaymentEntry?: string | null;
 }
-export type PaymentInput = Omit<Payment, "id" | "createdAt">;
+export type PaymentInput = Omit<Payment, "id" | "createdAt" | "erpnextPaymentEntry">;
 type TagType = "red" | "green" | "blue" | "gray" | "warm-gray" | "cool-gray" | "purple";
@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { SETTINGS_TABS, loadSettingsTab, parseSettingsTab, saveSettingsTab } from "./settingsTab";
+import { SETTINGS_TABS, loadSettingsTab, parseSettingsTab, requestSettingsTab, saveSettingsTab } from "./settingsTab";
 describe("settings tab persistence", () => {
  it("maps stored ids to indexes and falls back to the first tab", () => {
@@ -14,4 +14,10 @@ describe("settings tab persistence", () => {
    expect(() => saveSettingsTab(2)).not.toThrow();
    expect(() => saveSettingsTab(99)).not.toThrow();
  });
  it("honours a requested tab once, then goes back to the stored one", () => {
    requestSettingsTab("integrations");
    expect(loadSettingsTab()).toBe(SETTINGS_TABS.findIndex((t) => t.id === "integrations"));
    expect(loadSettingsTab()).toBe(0);
  });
 });
@@ -9,6 +9,7 @@ export const SETTINGS_TABS = [
  { id: "templates", label: "Templates & export" },
  { id: "fonts", label: "Fonts" },
  { id: "data", label: "Data" },
  { id: "integrations", label: "Integrations" },
 ] as const;
 export type SettingsTabId = (typeof SETTINGS_TABS)[number]["id"];
@@ -19,8 +20,21 @@ export function parseSettingsTab(value: string | null | undefined): number {
  return index < 0 ? 0 : index;
 }
 /** A tab another screen asked for; used once by the next Settings mount, so it works without localStorage. */
 let requested: SettingsTabId | null = null;
 /** Makes the next opening of Settings land on `id` (for "Set up in Settings" links). */
 export function requestSettingsTab(id: SettingsTabId): void {
  requested = id;
 }
 /** The last Settings tab this viewer used. A per-viewer convenience only. */
 export function loadSettingsTab(): number {
  if (requested) {
    const index = parseSettingsTab(requested);
    requested = null;
    return index;
  }
  try {
    return parseSettingsTab(localStorage.getItem(KEY));
  } catch {
@@ -698,3 +698,76 @@ body {
 .voiced-detail__unarchived p {
  margin-bottom: 1rem;
 }
 /* Settings, Integrations, ERPNext */
 .voiced-erp__section > h3 {
  margin-bottom: 0.5rem;
 }
 .voiced-erp__fields {
  display: grid;
  gap: 1rem;
  max-width: 40rem;
  margin-top: 1rem;
 }
 .voiced-erp__label {
  font-size: 0.75rem;
  color: var(--cds-text-secondary);
  margin-bottom: 0.25rem;
 }
 .voiced-erp__secret > * + * {
  margin-top: 0.5rem;
 }
 .voiced-erp__result > * + * {
  margin-top: 0.75rem;
 }
 .voiced-erp__uoms {
  border: 0;
  padding: 0;
  display: grid;
  gap: 1rem;
 }
 .voiced-erp__uoms legend {
  font-size: 0.75rem;
  color: var(--cds-text-secondary);
 }
 .voiced-erp__error {
  color: var(--cds-text-error);
  font-size: 0.75rem;
 }
 /* ERPNext column and bulk-send bar on the invoices list */
 .voiced-history__bulk {
  display: flex;
  flex-wrap: wrap;
  align-items: center;
  gap: 0.5rem;
  margin-bottom: 1rem;
 }
 .voiced-erp__results {
  list-style: none;
  margin-top: 1rem;
  max-height: 16rem;
  overflow: auto;
 }
 .voiced-erp__results li {
  padding: 0.25rem 0;
  border-bottom: 1px solid var(--cds-border-subtle);
 }
 .voiced-erp__panel {
  border: 1px solid var(--cds-border-subtle);
  padding: 1rem;
 }
 .voiced-erp__panel > * + * {
  margin-top: 0.75rem;
 }
@@ -41,6 +41,7 @@ import { ImagePicker } from "../components/ImagePicker";
 import { LogoBranding } from "../components/LogoBranding";
 import DataBackupPanel from "../components/DataBackupPanel";
 import DiagnosticsPanel from "../components/DiagnosticsPanel";
 import ErpnextSettingsPanel from "../components/ErpnextSettingsPanel";
 import { FontOverrideTable } from "../components/FontOverrideTable";
 import { useToast } from "../components/ToastProvider";
 import { SETTINGS_TABS, loadSettingsTab, saveSettingsTab } from "../lib/settingsTab";
@@ -159,7 +160,7 @@ export default function AppSettings({
  return (
    <div className="voiced-page">
      <h1 className="voiced-page__title">Settings</h1>
-      <p className="voiced-page__subtitle">Business details, branding, defaults and bank accounts.</p>
+      <p className="voiced-page__subtitle">Business details, branding, defaults, bank accounts and integrations.</p>
      <Tabs selectedIndex={tab} onChange={({ selectedIndex }) => selectTab(selectedIndex)}>
        <TabList aria-label="Settings sections" contained scrollIntoView>
@@ -171,6 +172,7 @@ export default function AppSettings({
          <Tab>Templates &amp; export</Tab>
          <Tab>Fonts</Tab>
          <Tab>Data</Tab>
          <Tab>Integrations</Tab>
        </TabList>
        <TabPanels>
            <TabPanel>
@@ -516,6 +518,9 @@ export default function AppSettings({
            <TabPanel>
              <DataBackupPanel />
            </TabPanel>
            <TabPanel>
              <ErpnextSettingsPanel active={tab === SETTINGS_TABS.findIndex((t) => t.id === "integrations")} />
            </TabPanel>
        </TabPanels>
      </Tabs>
@@ -3,6 +3,7 @@ import {
  Button,
  InlineLoading,
  InlineNotification,
  Link,
  Modal,
  OverflowMenu,
  OverflowMenuItem,
@@ -28,6 +29,20 @@ import { toDraftPayload } from "../lib/draft";
 import { invoiceToFormState } from "../lib/duplicate";
 import type { ExportMode } from "../lib/filename";
 import { useInvoiceExport } from "../hooks/useInvoiceExport";
 import { useGenericExport } from "../hooks/useGenericExport";
 import { openInErpnext } from "../lib/erpnextActions";
 import type { ErpnextConfig, ErpnextPushResult, ErpnextSyncStatus } from "../lib/erpnext";
 import {
  canOpenInErpnext,
  describePaymentPush,
  describePush,
  failedPush,
  formatSyncedAt,
  isConfigured,
  paymentPushDisabledReason,
  pushDisabledReason,
  syncTag,
 } from "../lib/erpnextUi";
 import { useReturnFocus } from "../hooks/useReturnFocus";
 import ExportFeedback from "../components/ExportFeedback";
 import PdfPreview from "../components/PdfPreview";
@@ -41,6 +56,8 @@ interface Props {
  onBack: () => void;
  /** A draft was created from this invoice; the shell opens it in the New invoice form. */
  onDuplicated: (draftId: number) => void;
  /** Goes to Settings, Integrations. */
  onOpenSettings: () => void;
 }
 interface Frozen {
@@ -74,7 +91,7 @@ function Field({ label, children }: { label: string; children: React.ReactNode }
  );
 }
-export default function InvoiceDetail({ invoiceId, settings, onBack, onDuplicated }: Props) {
+export default function InvoiceDetail({ invoiceId, settings, onBack, onDuplicated, onOpenSettings }: Props) {
  const toast = useToast();
  const [invoice, setInvoice] = useState<Invoice | null>(null);
  const [payments, setPayments] = useState<Payment[]>([]);
@@ -88,6 +105,12 @@ export default function InvoiceDetail({ invoiceId, settings, onBack, onDuplicate
  const [cancelOpen, setCancelOpen] = useState(false);
  const [reason, setReason] = useState("");
  const [duplicating, setDuplicating] = useState(false);
  const [erpCfg, setErpCfg] = useState<ErpnextConfig | null>(null);
  const [erpSync, setErpSync] = useState<ErpnextSyncStatus | undefined>(undefined);
  const [lastPush, setLastPush] = useState<ErpnextPushResult | null>(null);
  const [sendingErp, setSendingErp] = useState(false);
  const [sendingPayment, setSendingPayment] = useState<number | null>(null);
  const generic = useGenericExport();
  useReturnFocus(deleteTarget !== null);
  useReturnFocus(cancelOpen);
@@ -123,14 +146,31 @@ export default function InvoiceDetail({ invoiceId, settings, onBack, onDuplicate
    }
  }, []);
  /** ERPNext is optional: when it cannot be read the panel just stays out of the way. */
  const loadErp = useCallback(async (id: number, gen: number) => {
    try {
      const [cfg, sync] = await Promise.all([api.erpnextGetConfig(), api.erpnextSyncStatus(id)]);
      if (gen !== generation.current) return;
      setErpCfg(cfg);
      setErpSync(sync);
    } catch {
      if (gen === generation.current) {
        setErpCfg(null);
        setErpSync(undefined);
      }
    }
  }, []);
  useEffect(() => {
    const gen = ++generation.current;
    setInvoice(null);
    setPdf(null);
    setArchive(null);
    setLastPush(null);
    void loadData(invoiceId, gen);
    void loadPdf(invoiceId, gen);
-  }, [invoiceId, loadData, loadPdf]);
+    void loadErp(invoiceId, gen);
  }, [invoiceId, loadData, loadPdf, loadErp]);
  const refresh = () => loadData(invoiceId, generation.current);
@@ -194,6 +234,44 @@ export default function InvoiceDetail({ invoiceId, settings, onBack, onDuplicate
    }
  };
  /** `submit` undefined keeps what the invoice already is in ERPNext. A failure is shown, never thrown. */
  const onSendErp = async (submit: boolean) => {
    if (!invoice) return;
    setSendingErp(true);
    let result: ErpnextPushResult;
    try {
      result = await api.erpnextPushInvoice(invoice.id, submit);
    } catch (e) {
      result = failedPush(invoice.id, invoice.number, e);
    }
    setLastPush(result);
    const note = describePush(result);
    toast[note.kind](note.title, note.subtitle);
    await loadErp(invoiceId, generation.current);
    setSendingErp(false);
  };
  const onOpenErp = async () => {
    try {
      await openInErpnext(invoiceId);
    } catch (e) {
      toast.error("Could not open ERPNext", String(e));
    }
  };
  const onSendPayment = async (paymentId: number) => {
    setSendingPayment(paymentId);
    try {
      const note = describePaymentPush(await api.erpnextPushPayment(paymentId));
      toast[note.kind](note.title, note.subtitle);
      await refresh();
    } catch (e) {
      toast.error("Could not send the payment", String(e));
    } finally {
      setSendingPayment(null);
    }
  };
  const onDeletePayment = async () => {
    if (!deleteTarget) return;
    const target = deleteTarget;
@@ -231,6 +309,12 @@ export default function InvoiceDetail({ invoiceId, settings, onBack, onDuplicate
  const balance = invoice.balancePaise ?? 0;
  const canPay = invoice.status === "issued" && balance > 0;
  const half = invoice.taxRate / 2;
  const erpOn = isConfigured(erpCfg);
  const erpTag = syncTag(erpSync);
  const erpBlocked = pushDisabledReason({ cfg: erpCfg, vendorRegistered: settings.gstRegistration !== "unregistered", invoiceStatus: invoice.status });
  const erpHasState = Boolean(erpSync && erpSync.status !== "none");
  const erpSubmitted = erpSync?.status === "synced" && erpSync.remoteDocstatus === 1;
  const showPaymentErp = erpOn || payments.some((p) => p.erpnextPaymentEntry);
  return (
    <div className="voiced-page voiced-detail">
@@ -284,6 +368,8 @@ export default function InvoiceDetail({ invoiceId, settings, onBack, onDuplicate
        </Button>
        <OverflowMenu aria-label="More actions" iconDescription="More actions" flipped size="md" disabled={busy}>
          <OverflowMenuItem itemText="Re-render with current template" onClick={() => onExport("searchable", "rerender")} />
          <OverflowMenuItem itemText="Export as voiced.invoice.v1 (JSON)" hasDivider onClick={() => void generic.run([invoice.id], "json")} />
          <OverflowMenuItem itemText="Export line items (CSV)" onClick={() => void generic.run([invoice.id], "csv")} />
          {invoice.status === "issued" ? (
            <OverflowMenuItem
              itemText={payments.length > 0 ? "Cancel invoice (delete payments first)" : "Cancel invoice"}
@@ -416,6 +502,104 @@ export default function InvoiceDetail({ invoiceId, settings, onBack, onDuplicate
            {invoice.notes ? <p className="voiced-detail__pre voiced-muted">{invoice.notes}</p> : null}
          </section>
          <section aria-labelledby="detail-erpnext">
            <h2 id="detail-erpnext" className="voiced-detail__h2">
              ERPNext
            </h2>
            {!erpOn && !erpHasState ? (
              <p className="voiced-muted">
                ERPNext is not set up.{" "}
                <Link
                  href="#"
                  onClick={(e: React.MouseEvent) => {
                    e.preventDefault();
                    onOpenSettings();
                  }}
                >
                  Set it up in Settings, Integrations
                </Link>
                .
              </p>
            ) : (
              <div className="voiced-erp__panel">
                <dl>
                  <Field label="Status">
                    <Tag type={erpTag.type} size="sm" title={erpTag.tooltip}>
                      {erpTag.label}
                    </Tag>
                  </Field>
                  {erpSync?.remoteName ? <Field label="ERPNext document">{erpSync.remoteName}</Field> : null}
                  {erpSync?.syncedAt ? <Field label="Last synced">{formatSyncedAt(erpSync.syncedAt)}</Field> : null}
                  {erpSync?.status === "synced" ? <Field label="PDF">{erpSync.attached ? "Attached in ERPNext" : "Not attached"}</Field> : null}
                </dl>
                {erpSync && (erpSync.status === "error" || erpSync.status === "conflict") && erpSync.lastError ? (
                  <InlineNotification
                    kind={erpSync.status === "conflict" ? "warning" : "error"}
                    lowContrast
                    hideCloseButton
                    title={erpSync.status === "conflict" ? "Conflict with ERPNext" : "The last send failed"}
                    subtitle={erpSync.lastError}
                  />
                ) : null}
                {lastPush && lastPush.warnings.length > 0 ? (
                  <InlineNotification kind="warning" lowContrast hideCloseButton title="Sent with notes" subtitle={lastPush.warnings.join(" ")} />
                ) : null}
                {erpOn ? (
                  <>
                    <div className="voiced-header-action">
                      {erpSubmitted ? (
                        <Button kind="tertiary" size="sm" disabled={sendingErp || erpBlocked !== null} onClick={() => void onSendErp(true)}>
                          {sendingErp ? "Sending…" : "Re-send"}
                        </Button>
                      ) : (
                        <>
                          <Button kind="tertiary" size="sm" disabled={sendingErp || erpBlocked !== null} onClick={() => void onSendErp(false)}>
                            {sendingErp ? "Sending…" : erpHasState ? "Re-send as draft" : "Send as draft"}
                          </Button>
                          <Button kind="primary" size="sm" disabled={sendingErp || erpBlocked !== null} onClick={() => void onSendErp(true)}>
                            Send &amp; submit
                          </Button>
                        </>
                      )}
                      {canOpenInErpnext(erpSync) ? (
                        <Button kind="ghost" size="sm" onClick={() => void onOpenErp()}>
                          Open in ERPNext
                        </Button>
                      ) : null}
                    </div>
                    {erpBlocked ? (
                      <p className="voiced-muted">
                        {erpBlocked}{" "}
                        <Link
                          href="#"
                          onClick={(e: React.MouseEvent) => {
                            e.preventDefault();
                            onOpenSettings();
                          }}
                        >
                          Open Settings
                        </Link>
                      </p>
                    ) : null}
                  </>
                ) : (
                  <p className="voiced-muted">
                    ERPNext is not set up any more, so nothing can be sent.{" "}
                    <Link
                      href="#"
                      onClick={(e: React.MouseEvent) => {
                        e.preventDefault();
                        onOpenSettings();
                      }}
                    >
                      Open Settings
                    </Link>
                  </p>
                )}
              </div>
            )}
          </section>
          <section aria-labelledby="detail-payments">
            <h2 id="detail-payments" className="voiced-detail__h2">
              Payments
@@ -432,6 +616,7 @@ export default function InvoiceDetail({ invoiceId, settings, onBack, onDuplicate
                      <TableHeader>Reference</TableHeader>
                      <TableHeader className="voiced-num">Received</TableHeader>
                      <TableHeader className="voiced-num">TDS</TableHeader>
                      {showPaymentErp ? <TableHeader>ERPNext</TableHeader> : null}
                      <TableHeader>
                        <span className="cds--assistive-text">Actions</span>
                      </TableHeader>
@@ -448,6 +633,35 @@ export default function InvoiceDetail({ invoiceId, settings, onBack, onDuplicate
                        </TableCell>
                        <TableCell className="voiced-num">{formatPaise(p.amountPaise)}</TableCell>
                        <TableCell className="voiced-num">{formatPaise(p.tdsPaise)}</TableCell>
                        {showPaymentErp ? (
                          <TableCell>
                            {p.erpnextPaymentEntry ? (
                              <>
                                <Tag type="green" size="sm">
                                  Sent
                                </Tag>{" "}
                                <span className="voiced-muted">{p.erpnextPaymentEntry}</span>
                              </>
                            ) : (
                              (() => {
                                const reason = paymentPushDisabledReason({ cfg: erpCfg, sync: erpSync, entry: p.erpnextPaymentEntry });
                                return (
                                  <>
                                    <Button
                                      kind="ghost"
                                      size="sm"
                                      disabled={reason !== null || sendingPayment !== null}
                                      onClick={() => void onSendPayment(p.id)}
                                    >
                                      {sendingPayment === p.id ? "Sending…" : "Send payment to ERPNext"}
                                    </Button>
                                    {reason ? <div className="voiced-muted">{reason}</div> : null}
                                  </>
                                );
                              })()
                            )}
                          </TableCell>
                        ) : null}
                        <TableCell>
                          <Button
                            kind="ghost"
@@ -507,7 +721,7 @@ export default function InvoiceDetail({ invoiceId, settings, onBack, onDuplicate
      >
        <p>
          {deleteTarget
-            ? `${formatPaise(deleteTarget.amountPaise + deleteTarget.tdsPaise)} (cash ${formatPaise(deleteTarget.amountPaise)}, TDS ${formatPaise(deleteTarget.tdsPaise)}) received on ${formatDate(deleteTarget.paidOn)}. The invoice balance goes back up by that amount.`
+            ? `${formatPaise(deleteTarget.amountPaise + deleteTarget.tdsPaise)} (cash ${formatPaise(deleteTarget.amountPaise)}, TDS ${formatPaise(deleteTarget.tdsPaise)}) received on ${formatDate(deleteTarget.paidOn)}. The invoice balance goes back up by that amount.${deleteTarget.erpnextPaymentEntry ? ` It was sent to ERPNext as ${deleteTarget.erpnextPaymentEntry}; that entry is not removed there.` : ""}`
            : ""}
        </p>
      </Modal>
@@ -1,6 +1,7 @@
 import { useEffect, useMemo, useState } from "react";
 import {
  Button,
  Checkbox,
  InlineLoading,
  Link,
  OverflowMenu,
@@ -43,6 +44,11 @@ import {
 import type { ExportMode } from "../lib/filename";
 import type { ExportSource } from "../lib/exportFlow";
 import { useInvoiceExport } from "../hooks/useInvoiceExport";
 import { useGenericExport } from "../hooks/useGenericExport";
 import { openInErpnext } from "../lib/erpnextActions";
 import type { ErpnextConfig, ErpnextSyncStatus } from "../lib/erpnext";
 import { canOpenInErpnext, indexSyncStatuses, isConfigured, pushDisabledReason, sendableSelection, syncTag } from "../lib/erpnextUi";
 import SendToErpnextModal, { type SendTarget } from "../components/SendToErpnextModal";
 import ExportFeedback from "../components/ExportFeedback";
 import { useToast } from "../components/ToastProvider";
 import type { InvoiceSummary, Settings } from "../lib/types";
@@ -52,6 +58,8 @@ interface Props {
  active: boolean;
  /** Opens the detail page of an invoice. */
  onOpen: (id: number) => void;
  /** Goes to Settings, Integrations. */
  onOpenSettings: () => void;
 }
 const PAGE_SIZES = [25, 50, 100];
@@ -65,7 +73,7 @@ const COLUMNS: { key: SortKey; label: string; numeric?: boolean }[] = [
  { key: "status", label: "Status" },
 ];
-export default function InvoiceHistory({ settings, active, onOpen }: Props) {
+export default function InvoiceHistory({ settings, active, onOpen, onOpenSettings }: Props) {
  const toast = useToast();
  const [rows, setRows] = useState<InvoiceSummary[]>([]);
  const [loading, setLoading] = useState(true);
@@ -76,15 +84,36 @@ export default function InvoiceHistory({ settings, active, onOpen }: Props) {
  const [pageSize, setPageSize] = useState(PAGE_SIZES[0]);
  const exp = useInvoiceExport({ settings, bank: null });
  const [exportingHistory, setExportingHistory] = useState(false);
  const [erpCfg, setErpCfg] = useState<ErpnextConfig | null>(null);
  const [syncs, setSyncs] = useState<Map<number, ErpnextSyncStatus>>(new Map());
  const [selected, setSelected] = useState<Set<number>>(new Set());
  const [sendTargets, setSendTargets] = useState<{ invoices: SendTarget[]; skipped: number } | null>(null);
  const generic = useGenericExport();
  /** One bulk call for every row's ERPNext status. ERPNext is optional, so a failure here only hides the column. */
  const loadErpnext = async () => {
    try {
      const [cfg, list] = await Promise.all([api.erpnextGetConfig(), api.erpnextSyncStatuses()]);
      setErpCfg(cfg);
      setSyncs(indexSyncStatuses(list));
    } catch {
      setErpCfg(null);
      setSyncs(new Map());
    }
  };
  const load = async () => {
    try {
-      setRows(await api.listInvoices());
+      const list = await api.listInvoices();
      setRows(list);
      // Keep only selections that still exist.
      setSelected((prev) => new Set([...prev].filter((id) => list.some((r) => r.id === id))));
    } catch (e) {
      toast.error("Could not load invoices", String(e));
    } finally {
      setLoading(false);
    }
    void loadErpnext();
  };
  // The view stays mounted, so refetch every time it is shown again (a payment may have been recorded).
@@ -113,6 +142,44 @@ export default function InvoiceHistory({ settings, active, onOpen }: Props) {
  const onSort = (key: SortKey) =>
    setSort((s) => (s.key === key ? { key, dir: s.dir === "asc" ? "desc" : "asc" } : { key, dir: key === "date" || key === "total" || key === "balance" ? "desc" : "asc" }));
  const erpOn = isConfigured(erpCfg);
  const vendorRegistered = settings.gstRegistration !== "unregistered";
  const showErpColumn = erpOn || syncs.size > 0;
  const selectedRows = rows.filter((r) => selected.has(r.id));
  const blockedReason = pushDisabledReason({ cfg: erpCfg, vendorRegistered });
  const pageAllSelected = shown.length > 0 && shown.every((r) => selected.has(r.id));
  const toggleOne = (id: number, on: boolean) =>
    setSelected((prev) => {
      const next = new Set(prev);
      if (on) next.add(id);
      else next.delete(id);
      return next;
    });
  const togglePage = (on: boolean) =>
    setSelected((prev) => {
      const next = new Set(prev);
      for (const r of shown) {
        if (on) next.add(r.id);
        else next.delete(r.id);
      }
      return next;
    });
  const askSend = (list: InvoiceSummary[]) => {
    const { send, skipped } = sendableSelection(list);
    if (send.length === 0) {
      toast.warning("Nothing to send", "Only issued invoices are sent to ERPNext.");
      return;
    }
    setSendTargets({ invoices: send.map((r) => ({ id: r.id, number: r.number })), skipped });
  };
  const onOpenErpnext = async (id: number) => {
    try {
      await openInErpnext(id);
    } catch (e) {
      toast.error("Could not open ERPNext", String(e));
    }
  };
  const onExport = async (id: number, mode: ExportMode, source: ExportSource) => {
    setBusyId(id);
    try {
@@ -259,6 +326,38 @@ export default function InvoiceHistory({ settings, active, onOpen }: Props) {
            </span>
          </div>
          <div className="voiced-history__bulk" role="group" aria-label="Actions for the selected invoices">
            <span aria-live="polite">{selected.size} selected</span>
            <Button kind="tertiary" size="md" disabled={selected.size === 0 || blockedReason !== null} onClick={() => askSend(selectedRows)}>
              Send selected to ERPNext
            </Button>
            <Button kind="ghost" size="md" disabled={selected.size === 0 || generic.busy} onClick={() => void generic.run([...selected], "json")}>
              Export selected (voiced.invoice.v1 JSON)
            </Button>
            <Button kind="ghost" size="md" disabled={selected.size === 0 || generic.busy} onClick={() => void generic.run([...selected], "csv")}>
              Export selected (line items CSV)
            </Button>
            {selected.size > 0 ? (
              <Button kind="ghost" size="md" onClick={() => setSelected(new Set())}>
                Clear selection
              </Button>
            ) : null}
            {blockedReason !== null && selected.size > 0 ? (
              <span className="voiced-muted">
                {blockedReason}{" "}
                <Link
                  href="#"
                  onClick={(e: React.MouseEvent) => {
                    e.preventDefault();
                    onOpenSettings();
                  }}
                >
                  Open Settings
                </Link>
              </span>
            ) : null}
          </div>
          {sorted.length === 0 ? (
            <div className="voiced-empty">No invoices match these filters.</div>
          ) : (
@@ -266,6 +365,9 @@ export default function InvoiceHistory({ settings, active, onOpen }: Props) {
              <Table aria-label="Invoices">
                <TableHead>
                  <TableRow>
                    <TableHeader>
                      <Checkbox id="historySelectPage" labelText="Select all invoices on this page" hideLabel checked={pageAllSelected} onChange={(_e, { checked }) => togglePage(checked)} />
                    </TableHeader>
                    {COLUMNS.map((c) => (
                      <TableHeader
                        key={c.key}
@@ -278,6 +380,7 @@ export default function InvoiceHistory({ settings, active, onOpen }: Props) {
                        {c.label}
                      </TableHeader>
                    ))}
                    {showErpColumn ? <TableHeader>ERPNext</TableHeader> : null}
                    <TableHeader>
                      <span className="cds--assistive-text">Actions</span>
                    </TableHeader>
@@ -286,8 +389,20 @@ export default function InvoiceHistory({ settings, active, onOpen }: Props) {
                <TableBody>
                  {shown.map((row) => {
                    const badge = statusBadge(row.status, row.paymentStatus);
                    const sync = syncs.get(row.id);
                    const erpTag = syncTag(sync);
                    const rowBlocked = pushDisabledReason({ cfg: erpCfg, vendorRegistered, invoiceStatus: row.status });
                    return (
                      <TableRow key={row.id} className="voiced-history__row" onClick={() => onOpen(row.id)}>
                        <TableCell onClick={(e: React.MouseEvent) => e.stopPropagation()}>
                          <Checkbox
                            id={`historySelect-${row.id}`}
                            labelText={`Select invoice ${row.number}`}
                            hideLabel
                            checked={selected.has(row.id)}
                            onChange={(_e, { checked }) => toggleOne(row.id, checked)}
                          />
                        </TableCell>
                        <TableCell>
                          <Link
                            href="#"
@@ -314,6 +429,13 @@ export default function InvoiceHistory({ settings, active, onOpen }: Props) {
                            </Tag>
                          ) : null}
                        </TableCell>
                        {showErpColumn ? (
                          <TableCell>
                            <Tag type={erpTag.type} size="sm" title={erpTag.tooltip}>
                              {erpTag.label}
                            </Tag>
                          </TableCell>
                        ) : null}
                        <TableCell onClick={(e: React.MouseEvent) => e.stopPropagation()}>
                          <OverflowMenu
                            aria-label={`Actions for invoice ${row.number}`}
@@ -325,6 +447,17 @@ export default function InvoiceHistory({ settings, active, onOpen }: Props) {
                            <OverflowMenuItem itemText="Open" onClick={() => onOpen(row.id)} />
                            <OverflowMenuItem itemText="Export PDF (original as issued)" onClick={() => void onExport(row.id, "searchable", "original")} />
                            <OverflowMenuItem itemText="Export flattened PDF" onClick={() => void onExport(row.id, "flattened", "original")} />
                            <OverflowMenuItem itemText="Export as voiced.invoice.v1 (JSON)" hasDivider onClick={() => void generic.run([row.id], "json")} />
                            {erpOn || syncs.size > 0 ? (
                              <OverflowMenuItem
                                itemText="Send to ERPNext"
                                hasDivider
                                disabled={rowBlocked !== null}
                                title={rowBlocked ?? undefined}
                                onClick={() => askSend([row])}
                              />
                            ) : null}
                            {canOpenInErpnext(sync) && erpOn ? <OverflowMenuItem itemText="Open in ERPNext" onClick={() => void onOpenErpnext(row.id)} /> : null}
                          </OverflowMenu>
                        </TableCell>
                      </TableRow>
@@ -363,6 +496,31 @@ export default function InvoiceHistory({ settings, active, onOpen }: Props) {
          )}
        </>
      )}
      {!erpOn && !loading && rows.length > 0 ? (
        <p className="voiced-muted" style={{ marginTop: "1rem" }}>
          ERPNext is not set up.{" "}
          <Link
            href="#"
            onClick={(e: React.MouseEvent) => {
              e.preventDefault();
              onOpenSettings();
            }}
          >
            Set it up in Settings, Integrations
          </Link>{" "}
          to send invoices to it.
        </p>
      ) : null}
      <SendToErpnextModal
        open={sendTargets !== null}
        invoices={sendTargets?.invoices ?? []}
        skipped={sendTargets?.skipped ?? 0}
        defaultSubmit={erpCfg?.submitOnPush ?? false}
        onClose={() => setSendTargets(null)}
        onFinished={() => void loadErpnext()}
      />
    </div>
  );
 }
@@ -59,6 +59,7 @@ import { SHORTCUT_LIST, useShortcuts } from "../hooks/useShortcuts";
 import PageSetupControls from "../components/PageSetupControls";
 import { useInvoicePdf } from "../hooks/useInvoicePdf";
 import { useInvoiceExport } from "../hooks/useInvoiceExport";
 import { autoPushIssued } from "../lib/erpnextUi";
 import ExportButton, { ExportModePicker } from "../components/ExportButton";
 import ExportFeedback from "../components/ExportFeedback";
 import { createExportDeps } from "../lib/exportDeps";
@@ -649,6 +650,16 @@ export default function NewInvoice({ settings, onSettingsChange, active, onActiv
    detachDraft();
    api.listClients().then(setClients).catch(() => {});
    void refreshDrafts();
    // "Send on issue": in the background, so it never delays or fails the issue; the result arrives as a toast.
    void autoPushIssued(
      { getConfig: api.erpnextGetConfig, push: api.erpnextPushInvoice },
      outcome.invoice,
      settings.gstRegistration !== "unregistered",
    )
      .then((note) => {
        if (note) toast[note.kind](note.title, note.subtitle);
      })
      .catch(() => {});
    // Unarchived invoices export by rendering and archiving first (see exportInvoice), so this still works.
    await exp.start(outcome.invoice, mode, "original");
    setSaving(false);
Author	SHA1	Message	Date
xavierk	23dd283a42	Prepare the 1.0.0 release (Phase G) - Bump the version to 1.0.0 in package.json, Cargo.toml, tauri.conf.json and the Void template. Fingerprint goldens are unchanged. - Rewrite the README: features, data paths on Linux and Windows, backup and restore (backups contain the ERPNext API secret), bundled fonts and licences, font overrides, the ERPNext recipe, build and packaging commands, gates and known limitations. - Add docs/RELEASE.md with the release steps and a manual first-run checklist. - Void template: use a plain npm ci (the optional-dependency omit breaks vite and tsc), and note vendoring and that no OpenSSL is needed. Verified: build-xbps.sh builds voiced-1.0.0_1; it installs and removes cleanly in a clean void-glibc container with fonts, licences and fc-cache handling in place. The cross-compiled NSIS installer is 11.45 MiB and has not been run on Windows.	2026-10-04 23:56:32 +05:30
xavierk	8dc4d85e14	Verify the ERPNext integration live and fix the defects it found (Phase F4) Ran the push flow against ERPNext 15.121.6 on a plain site and on a site with India Compliance 15.32.0 (podman, scripts/erpnext-e2e). 15 ignored live tests pass on both. Fixes, each covered by a mock-based test: - load_options no longer fails on a plain site: the India Compliance-only gstin field is dropped on a 417 and retried. - Code-less rows with fractional hours or minutes send stock_uom, since ERPNext defaults it to Nos. - A created document whose total differs from Voiced's (ERPNext's default Banker's Rounding on half-paise ties) is recorded as a conflict, kept as a draft, not submitted and not given a PDF. The message names Commercial Rounding as the fix. - An existing customer address is reused instead of creating a duplicate on every first push. A bare creation order-by is not used with a Dynamic Link filter. - A re-adopted document no longer gets a second copy of the PDF. - Reverse charge: India Compliance rejects is_reverse_charge unless tax rows are negative RCM amounts, so the flag is sent as 0 with a warning that the invoice lands as a normal taxed invoice. - The 16-character name rule is checked locally in mirror mode under India Compliance, and a TDS-only payment is refused locally with the reason. Payment Entry mapping verified: bank_account is the Account name (paid_to), paid and received amounts equal the cash received, allocated_amount is cash plus TDS, and TDS is one positive deductions row. The integration user needs the Accounts User and Sales User roles. Not verified: ERPNext v14 and v16, other India Compliance versions, the Tauri commands and UI against a live site, SEZ and overseas customers, UTGST supplier states, TLS sites, e-invoicing.	2026-10-04 22:09:03 +05:30
xavierk	2ffbf0f66c	Add the ERPNext settings UI, History and detail controls, and voiced.invoice.v1 export (Phase F3) - Settings gets an Integrations tab: connection fields with a write-only API secret, a CA PEM option, Test connection with versions and warnings, live mapping lists loaded after a test, naming mode, toggles and its own Save. - Pushing for a GST-registered vendor is refused until a connection test result is stored. The UI shows the reason and disables Send. - History shows an ERPNext status column from one bulk call, a row Send and Open in ERPNext, and a bulk Send selected with a draft-or-submit confirm step and per-row results that never abort the batch. The detail view gets an ERPNext panel and per-payment send. All of it is hidden or disabled when the integration is not configured. - Optional auto-push after issue runs in the background and never blocks or fails the issue. - Generic export: a deterministic voiced.invoice.v1 JSON (and CSV line items) for selected invoices, documented in docs/voiced-invoice-v1.md with a golden test. Money is integer paise plus a decimal string. The new screens have not been run in a webview yet. The ERPNext Payment Entry deduction fields still need a live check.	2026-10-04 20:57:31 +05:30
xavierk	d3b5fbb1b8	Add ERPNext push logic for invoices and payments (Phase F2) - ErpnextSink implements InvoiceSink. Pushing an issued invoice ensures the Customer and Address (read-back of the returned name, local PIN/state/GSTIN checks), creates the Sales Invoice, optionally submits it in a second call, and attaches the archived PDF as a private file once. - Idempotent: a mirrored-name 409 is compared by grand total (same total records as synced, different total is a conflict and never overwrites); series mode looks up an existing document by its remarks before re-posting; an identical re-push sends nothing. - Create and submit are separate calls so a draft survives a failed submit. A failed push is recorded in erpnext_sync with a readable message. Bulk push never aborts on one failing row. - Payment push requires a submitted parent, maps TDS to Payment Entry deductions and is idempotent through the stored entry name. - Migration M11 rebuilds erpnext_sync to allow a conflict status and adds attachment_sha256. - Commands for single and bulk push, payment push, sync status and the open-in-ERPNext URL, with typed wrappers. No UI yet. Tested against a mock server only. The Payment Entry deductions fields, the series-mode submit route and the payment amount semantics need a live ERPNext check.	2026-10-04 20:33:45 +05:30
xavierk	86b4d436fa	Add the ERPNext integration foundation (Phase F1) - New integrations module with an InvoiceSink seam and an ERPNext client built on reqwest with rustls (ring provider only; aws-lc is not in the dependency graph). Token auth, timeouts, retry with backoff on 429, 5xx and timeouts (POSTs only when idempotent), optional extra CA, and a rule that plain http is allowed only for localhost-style hosts. - Error extraction for Frappe v1 and v2 bodies, version and India Compliance discovery, live option loaders, and a connection test that returns warnings instead of failing. - Pure, snapshot-tested mapping from a stored invoice to a Sales Invoice (CGST+SGST, IGST, unregistered, discount, code-less rows, mirrored and series naming) that refuses to produce a payload whose totals differ from Voiced's. - Migration M10 adds erpnext_config (the API secret is never returned to the webview), erpnext_sync and the nullable ERPNext link columns. - Commands to get and save the config, test the connection and load options, with typed wrappers. No UI and no push yet. The API secret is stored in the SQLite file, so backups contain it. Nothing has run against a live ERPNext yet.	2026-10-04 19:50:24 +05:30