feat(app): add the Tauri shell for Windows and Linux (phase 15)

[hami9]

What and why

Phase 15, and the first Rust in the repository. A Tauri v2 app that opens, renders a real CanonicalProduct[], and deliberately does not fetch anything — that is phase 16.

Rust is thin, and the line is where §15 draws it. One command reporting the host, a setup hook, the WebView. Everything else is TypeScript. A rule written in Rust cannot be shared with the extension or the companion, so it gets written twice and the copies drift — and the rules most tempting to handle natively are exactly the ones where a second copy is dangerous.

The front end is vanilla TypeScript, same idiom as the popup. Not a framework: the app's reactive surface is a table, a settings pane and a confirmation step, and one language across three surfaces means whoever has read popup.ts can read this. If that stops being true it is a reason to revisit — a better one than adopting a framework because the package was new.

currency.ts is the one safety-critical file here, and it is separate so it can be reasoned about alone. §7.8: reading toman as rial multiplies every price by ten and nothing downstream catches it. Two rules live in the module rather than in the view:

• No default. undefined means unanswered, and unanswered blocks export. A pre-selected radio button is a guess wearing the costume of a decision.
• The question is only asked when it is real. If every price already states its unit there is nothing to confirm, and a prompt that fires when there is nothing to decide is one people learn to dismiss — which is how a safety step stops working.

Each choice shows what the first price becomes under that reading (460,000 against 46,000), because the ten-times difference should be visible rather than arithmetic the user does in their head.

§18's design system: the popup's warm palette at a size that is not 360px, dark and light with the override winning in both directions, Persian and English with real RTL through logical properties rather than left/right. Persian digits are a display transform only — the data stays ASCII all the way to the CSV.

The question phase 15 asked directly

Rust joins CI as its own job, not as part of npm run check.

npm run check is what somebody runs on every save. Putting a ten-minute cold cargo build — plus a hard dependency on rustup and three system libraries — in front of a typo fix in an exporter is the wrong trade when most changes to this repository never touch packages/app. A Rust failure still blocks a merge, because the gate is the workflow rather than any one npm script. There is a cargo fmt/clippy -D warnings/cargo test job on this PR and it has to pass.

Also here

Two tooling fixes of the same kind as the earlier .claude/ one: ESLint walks the directory tree rather than git, so it was linting Cargo's target/ output and Tauri's generated schemas. Both ignored. target/ and gen/ are gitignored; Cargo.lock is not, because this is a binary and the lockfile is what makes its build reproducible.

The second commit records a sequencing decision taken after seeing the app run: Windows and Linux get finished before Android starts, so the working order becomes 16, 17, 20, then 18. Phase numbers do not move — they are cited from commits, prompt files and phases.json, and renumbering to express an ordering change would invalidate all of that to say something a sentence says better. What keeps it a deferral rather than a decision to un-make later is already in this PR: the 44px touch target, the single phone breakpoint, logical properties throughout.

How it was verified

npm run check passes — 831 tests, unchanged, since this phase adds a surface rather than engine behaviour.

On Linux: cargo build succeeds, the app opens, and the shell renders the fixture. cargo fmt --check, cargo clippy --all-targets -- -D warnings and cargo test are all clean. Reviewed running by the maintainer.

Windows is not verified, which is why scripts/release/phases.json still says next for phase 15 rather than done — its own "Done when" asks for both platforms. There is a Windows machine available and that is the remaining box; a native build there is the check, not a cross-compile from Linux (see below).

Two things that are absent on purpose and would be bugs if present: the app makes no network request of any kind, and Export does not write a file. Both are phase 16.

Notes for phase 16, already written into phase-16.md

• HTTP needs no new abstraction. core already takes an injected HttpClient; the app needs one implementation over invoke, and Layer A, the crawler and politeness then work unchanged because they never knew what was underneath.
• Politeness must not be reimplemented in Rust. §10's pacing lives in core. A native shell removes the browser's rate limits, which makes §10 more important rather than less.
• Do not cross-compile. Tauri links against the platform's own WebView, so cross-compiling means cross-compiling those bindings and the bundler. Phase 20 should make the CI job a matrix over ubuntu-latest and windows-latest — a change to the runs-on line and nothing else. Windows will also need an .ico, which src-tauri/icons/ does not have yet.

Checklist

• The commits follow Conventional Commits — they decide the next version number
• npm run check passes (format, lint, typecheck, tests)
• New behaviour has tests
• No currency unit is inferred, and no field is invented to fill a blank

🤖 Generated with Claude Code