I want to build a simple full-stack web app.

Stack

* Frontend: Next.js + TailwindCSS
* Backend: Supabase (auth + DB)
* Contracts: Hardhat + OpenZeppelin templates
* Deploy: Vercel

Features

* Email/password login
* CRUD for a "projects" table
* Basic contract interaction (mint an ERC-721)
* Clean, responsive UI
Deliverables

* Next.js pages/components
* Supabase SQL schema + typed queries
* ERC-721 contract + deploy script
* .env.sample and local dev instructions
* Vercel deploy steps
* Fallback note: if Supabase is heavy, show Railway + Postgres swaps

Debug this snippet using first principles:

* Explain line-by-line what happens.
* State expected vs. actual behavior with a small example.
* Identify the minimal failing cause (config, logic, types, race).
* Propose smallest diff fix; only then suggest refactors.
* Include 1–2 unit tests that would have caught this bug.

Extend the base app with:

* Wallet connect (wagmi + RainbowKit)
* Dark / light mode toggle (persisted)
* "Debug seed" script for sample data

Constraints

* Show only new files or unified diffs.
* No rewrites of unchanged modules.
* Keep types strict; add brief comments where non-obvious.

Create a minimal Replit / CodeSandbox project that:

* Boots Next.js
* Connects to Supabase (read-only sample table)
* Calls ONE contract method from a public testnet

Keep configs tiny; include a single README with run steps and a link back to the full repo template.

Act as a senior full-stack engineer. Scaffold a production-ready app:

* Next.js frontend
* Supabase backend
* ERC-20 contract interaction
* Deploy via Vercel

Output

* Repo tree (files + short purpose notes)
* Minimal code to run:
  pnpm install && pnpm run dev
* Post-scaffold checklist: env vars, local DB seed, test command

Given my constraints:

* SEO pages + interactive dashboard
* CI on GitHub Actions, preview deploys
* I prefer TypeScript and pnpm

Recommend:

* State mgmt (React Query + lightweight store or single store)
* Form/validation stack
* Testing layers (unit + e2e)
* Linting/formatting presets

Explain pros/cons in 5 points; produce a single `decisions.md`.

Refactor this module to:

1. remove duplication
2. keep separate error sources
3. improve perf of list joins (N\*M → N+M if possible)

Return: refactored code + a concise "why this is better" note + 2 regression tests.

I’m stuck on X. Provide 3 alternative approaches with:

* brief explanation
* trade-offs (dev time, perf, complexity)
* the smallest experiment I can run to validate each path
  Pick 1 as default and say why.