Lastest

The Problem

Visual regression testing is either expensive, flaky, or painful to maintain.

• Cloud tools: per-screenshot pricing, cloud-only, no self-hosting
• Enterprise tools: steep learning curve, locked to specific frameworks
• Open-source tools: free but no dashboard, no collaboration, no AI, or in maintenance mode

Meanwhile, you just need to know: "Did my last commit break the UI?"

The Solution

Lastest is a free, self-hosted visual regression testing platform that records your tests, writes them with AI, runs them anywhere, and fixes them when they break — all in one tool.

1. Point it at your app
2. Record your user flows (point-and-click, no code)
3. AI generates resilient test code with multi-selector fallback
4. Every test runs inside an Embedded Browser container (EB stack required)
5. Screenshots compared with 3 diff engines (pixelmatch, SSIM, Butteraugli)
6. Review and approve visual changes — or let AI auto-classify them

When self-hosted, your data stays on your server and your screenshots never leave your infra.

Three Ways to Work

Lastest adapts to how you want to build tests — from fully manual to fully autonomous.

1. AI-Free (Manual Recording)

Open the recorder, click through your app, hit stop. Lastest captures every interaction and generates deterministic Playwright code — no AI involved, no API keys needed. You own the test code and can edit it by hand.

Best for: Teams that don't want AI, air-gapped environments, simple flows.

2. AI-Assisted (Human-in-the-Loop)

AI generates, fixes, or enhances tests — but you review and approve before anything is saved. Feed it a URL and get a test back. Import OpenAPI specs or user stories and AI extracts test cases. When a test breaks, AI proposes a fix and you decide whether to accept it.

Best for: Day-to-day development, iterating on tests, fixing breakages fast.

3. Full Autonomous (Play Agent)

One click kicks off an 11-step pipeline: check settings, select repo, set up environment, scan routes & apply testing template, plan functional areas, review plan, generate tests, run them, fix failures (up to 3 attempts per test), re-run, and report results. Uses specialized sub-agents (Orchestrator, Planner, Scout, Diver, Generator, Healer). The agent pauses and asks for help only when it hits something it can't resolve on its own. You resume and it picks up where it left off.

Best for: Onboarding a new project, generating full coverage from scratch, CI bootstrapping.

One Way to Run: Embedded Browser

Every test runs inside an Embedded Browser (EB) pod — a containerized Chromium with live CDP streaming back to the UI. There is no local-Playwright fallback and no remote-runner daemon anymore: the host never launches its own browser, and if an EB is unavailable a test fails rather than falling back. The EB stack is therefore required for every run and recording, even in local development.

• System-managed (default) — EB pods are provisioned automatically: into a local k3d cluster in dev, or your Kubernetes cluster in production, from an on-demand pool (worker-pool per build, warm-pool keep-alive, egress-restricted). One EB per test.
• Bring-your-own (BYO) — run the lastest-eb container yourself (docker run … -p 9223:9223 -p 9224:9224) and register it in Settings → Runners to get a token. This is the replacement for old "remote runners": you bring a browser on the machine/network/OS you want, not a Playwright daemon.

EB pods handle both running and recording. Builds can be triggered manually (click Run), by webhook (PR opened/updated), from CI/CD (GitHub Action or the @lastest/runner CLI, which only triggers a build and polls — execution still happens in the EB pool), or on a schedule (cron-based automation). Smart Run analyzes git diffs to run only affected tests.

Migrating from remote runners? The standalone runner daemon that executed Playwright on remote machines has been retired. To run tests on your own machine/network, register a BYO Embedded Browser instead. The @lastest/runner npm package lives on as a lightweight, browser-free CI trigger client only.

Build Once, Run Forever

Tests are recorded or generated once, then stored as code. Every subsequent run re-executes the same code, captures new screenshots, and diffs them against approved baselines.

• First run: screenshot becomes the baseline
• Every run after: new screenshot is SHA256-hashed — if it matches the baseline, instant pass (no pixel comparison needed). If it differs, the diff engine runs and you review the change.
• AI costs are one-time: AI is only used during test creation and fixing. Running tests uses zero AI — it's pure Playwright execution.
• No per-screenshot pricing on self-hosted: every run is unlimited regardless of volume.

Create tests (one-time)          Run tests (forever)
┌──────────────────────┐         ┌──────────────────────┐
│ Manual recording     │         │ Execute Playwright    │
│   — or —             │  ────▶  │ Capture screenshots   │
│ AI generation        │  save   │ Diff against baseline │
│   — or —             │         │ Review changes        │
│ Play Agent autonomy  │         │ Approve/reject        │
└──────────────────────┘         └──────────────────────┘
  AI may be used here              No AI needed here

Features

Core

• Record Browser Interactions — Point-and-click test recording via Playwright with multiple engines (custom recorder or Playwright Inspector). No code required.
• AI Test Generation — Claude generates robust test code with multi-selector fallback (data-testid → id → role → aria-label → text → css → OCR).
• Multi-Engine Visual Diffing — Three comparison engines: pixelmatch (pixel-perfect), SSIM (structural similarity), and Butteraugli (human-perception-aligned). Choose the best trade-off between speed and accuracy.
• Multi-Step Screenshots — Capture multiple labeled screenshots per test run for multi-page flow testing.
• Approval Workflow — Review visual diffs before they become baselines. Catch regressions, approve intentional changes.
• Check Modes — Unified verification control across 9 layers (visual, text, DOM, network, console, a11y, design, performance, URL), each set to enforce, log, or disable per repo — replacing scattered per-feature toggles.
• Verify Board — Per-step card board for reviewing multi-layer check results: change map, per-layer baselines, and reviewer feedback in one focused view.
• Design System Verification — Design-token comparison layer that flags drift from your design system (colors, spacing, typography) as its own check layer.
• URL Diff — Capture and diff URL trajectories across runs to catch unexpected redirects and navigation changes.
• API Tests — Headless HTTP API testing as a first-class test type (method / url / headers / query / body / auth + assertions). Runs in-process with no browser or EB dispatch, feeds the same step-comparison and verdict pipeline as browser tests, and can be generated from captured network calls. Includes a burst/load runner for firing concurrent requests at an endpoint (single up-front SSRF validation, per-connection re-check).
• Analyze URL — Pre-recording selector tuning: scans the target page, measures selector-strategy coverage (data-testid, aria, ids, …), and recommends a priority order matched to your app.
• Git-Aware Builds — Run tests per branch/commit. Compare across PRs. Track coverage.
• Branch Comparison — Dedicated compare view for side-by-side branch-to-branch test result diffing.
• Test Suites — Organize tests into ordered suites for structured execution.
• Test Versioning — Full version history with change reasons (manual edit, AI fix, AI enhance, restored).
• Test Composition — Cherry-pick tests and pin specific test versions per build via the Compose page. Override latest with any historical version.
• Functional Area Hierarchy — Organize tests into nested parent/child functional areas with drag-and-drop reordering.
• Debug Mode — Step-by-step test execution with live feedback for diagnosing failures.
• Testing Templates — One-click preset configurations for common app types: SaaS/Dashboard, Marketing Website, Canvas/WebGL, E-commerce, Documentation, Mobile-First, SPA, and CMS.
• Auto-Detect Capabilities — Recording automatically detects required browser capabilities (file upload, clipboard, downloads, network interception) and enables corresponding Playwright settings.
• Early Adopter Mode — Team-level toggle to access experimental features before general release.
• Scheduled Test Runs — Cron-based automated builds with preset schedules (daily, weekly, hourly) or custom cron expressions. Auto-disables after consecutive failures. Optional branch targeting.
• Success Criteria Tab — Parsed assertion tracking per test: see which expect() calls passed/failed with expected vs actual values, error messages, and code line references.
• WCAG 2.2 AA Compliance Scoring — Automated 0–100 accessibility score per build with severity-weighted deductions (critical/serious/moderate/minor), trend sparklines across builds, and per-test violation detail.
• Guided Onboarding — 8-step setup guide for new users: connect GitHub, configure AI, scan routes, record first test, run, set baselines, re-run, check results. Auto-detects completion.
• AI Failure Triage — Automatic classification of test failures into real regression, flaky test, environment issue, or test maintenance — with confidence scores and reasoning.
• Bug Reports — In-app bug reporting with auto-captured context (URL, viewport, console errors, failed requests, breadcrumbs), screenshot attachment, and GitHub issue creation.
• Review Todos — Branch-specific actionable items created when a reviewer flags a diff. Track review feedback as todos tied to specific builds and tests.
• Gamification (Beat the Bot) — Competitive scoring layer where humans compete against AI bots on a team leaderboard. Earn points for creating tests (+10), catching regressions (+100), approving real changes (+15), resolving review todos (+5). Small flaky-test penalty (−5, daily-capped). Seasonal play with named seasons, achievements (first test, first regression, beat-the-bot tiers), and Bug Blitz events with configurable multipliers (2–5×). Team-level toggle. Celebratory toasts on score events via SSE.
• Leaderboard — Ranked season standings for humans and bots with top-3 podium styling, per-actor breakdowns (tests created, regressions caught, flakes incurred), and "you are here" row for viewers outside the top 10.
• Public Share Links — Publish a run, build, or diff as a watermarked, publicly-viewable /r/<slug> report — no login required for viewers. Includes optional AI-written demo notes, session video (WebM with MP4 conversion + fallback), zip download of artifacts, and social-share flows with media-aware cards for X, YouTube, and TikTok. Links are revokable and reuse a stable URL on re-publish.
• Test Migration — Move tests and functional areas between Lastest instances. Connect to a remote instance via URL + API key, browse remote repos, and import with idempotent name-based upsert. Also available via REST API (GET /export + POST /import).
• API Tokens — Generate long-lived Bearer tokens (lastest_api_*) for the MCP server, VS Code extension, CI scripts, and cross-instance migration. Revokable per-user with labels.

AI-Powered

• Multiple AI Providers — Claude CLI, OpenRouter, Claude Agent SDK, direct Anthropic API, OpenAI, or Ollama (local models).
• Separate AI Diff Provider — Use a different AI provider for diff analysis than test generation.
• AI Diff Analysis — AI-powered visual diff classification (insignificant/meaningful/noise) with confidence scores and change categories.
• AI Test Fixing — Automatically fix failing tests or enhance existing ones.
• Fix-the-App Advisor — When a failure is classified as a real regression, AI produces a structured application-code fix recommendation (file, snippet, rationale, confidence) by localizing the root cause against recently-changed files. Distinct from the test healer — it patches your app, not the test — and it never auto-applies: it hands the suggestion back to you or your coding agent. Exposed via the MCP suggest_app_fix tool.
• Diff-Scoped Validation — AI validates and decides on individual visual diffs (validate_diff / decide_diff), scoping analysis to a single diff for precise, low-noise verdicts.
• Spec-Driven Testing — Import OpenAPI specs, user stories, or markdown files. AI extracts stories and generates tests automatically.
• Route Discovery — AI scans your source code to discover routes and suggest tests.
• MCP Selector Validation — Real-time selector validation on live pages via Claude MCP.
• Play Agent (Autonomous) — One-click 11-step pipeline: check settings → select repo → environment setup → scan & template → plan areas → review → generate tests → run → fix failures (up to 3 attempts) → re-run → summary. Uses specialized sub-agents (Orchestrator, Planner, Scout, Diver, Generator, Healer). Pause/resume, approve plans, skip steps.
• Agent Monitoring & Activity Feed — Real-time tracking of Play Agent sessions with step-by-step progress, SSE streaming, and session history. Monitor active/paused/completed agents from the dashboard.
• Codebase Intelligence — Automatic detection of project context (framework, CSS framework, auth, state management, API layer, key dependencies) to enrich AI prompts. 100+ package database mapping dependencies to testing recommendations.

Stabilization & Flaky Test Prevention

• Text-Region-Aware Diffing — OCR-based two-pass comparison with separate thresholds for text vs non-text regions. Reduces false positives from dynamic text and cross-OS font rendering.
• Timestamp Freezing — Replace Date.now() and new Date() with fixed values for deterministic screenshots.
• Random Value Seeding — Seed Math.random() for consistent outputs.
• Cross-OS Consistency — Bundled fonts + Chromium flags for identical screenshots across operating systems.
• Burst Capture — Multi-frame instability detection: take N screenshots and compare for stability before saving.
• Auto-Mask Dynamic Content — Automatically detect and mask timestamps, UUIDs, and relative times before comparison.
• Network Idle Waiting — Wait for network activity to settle before capture.
• DOM Stability Detection — Wait for DOM mutations to stop before screenshot.
• Third-Party Blocking — Block third-party domains with configurable allowlist, mock external images.
• Font Loading Wait — Wait for webfonts to load, or disable them entirely.
• Loading Indicator Hiding — Auto-hide spinners and loading states with custom selectors.
• Page Shift Detection — Detect vertical content shifts (inserted/deleted rows) with fuzzy row matching.

Integrations

• GitHub — OAuth login, repo sync, PR comments, webhook-triggered builds, reusable GitHub Action.
• GitLab — OAuth login (self-hosted supported), MR comments, webhook triggers.
• Google OAuth — Sign in with Google.
• Google Sheets — Use spreadsheet data as test data sources with per-team OAuth, multi-tab support, custom header rows, fixed ranges, and caching.
• Notifications — Slack, Discord, custom webhooks, and GitHub/GitLab PR comments for build results.
• Email — Team invitation emails via Resend.

Infrastructure

• Smart Run — Analyzes git diffs to run only tests affected by your changes.
• Embedded Browser (only execution path) — Containerized Chromium with CDP live streaming back to the UI. Records and runs every test — no local Playwright, no remote-runner daemon. System-managed EBs run in an on-demand Kubernetes pool (one test per browser, worker-pool per build, warm-pool keep-alive, busy-state tracking with graceful reaping during deploys, restricted pod egress); BYO EBs are lastest-eb containers you host and register yourself. JPEG streaming with configurable quality/framerate, WebSocket auth, concurrent contexts. If no EB is available the run fails — the host never launches its own browser.
• CI Trigger CLI (@lastest/runner) — Lightweight, browser-free npm client that triggers a build on your Lastest server and polls for results (writes GITHUB_OUTPUT / GITHUB_STEP_SUMMARY, exits non-zero on failure or --fail-on-changes). Execution runs server-side in the EB pool; the old distributed-execution runner daemon has been retired.
• Parallel Test Execution — Configurable max parallel tests bounds the embedded-browser pool per build. CNI burst protection throttles pod creation to avoid networking storms.
• Docker Deployment — Production-ready multi-stage Docker setup based on official Playwright image with persistent volumes.
• MCP Server — Model Context Protocol server (@lastest/mcp-server) exposing a consolidated, resource-oriented surface of 24 tools for AI agent integration: run/verify tests, review and decide diffs, approve baselines, create/heal tests, suggest app fixes, publish shares, check coverage. Install via npx @lastest/mcp-server.
• VSCode Extension API — REST + SSE API (/api/v1/) for IDE integration.
• Accessibility Audits — Automated axe-core checks on every screenshot capture with WCAG 2.2 AA compliance scoring.
• Network & Console Tracking — Capture network requests and browser console errors during test runs.
• Secrets Encrypted at Rest — OAuth tokens and AI provider API keys are encrypted in the database; provider keys are never serialized to the browser.
• Server-Side Quotas — Run-minute and project limits are enforced server-side (used by hosted billing tiers; unbounded when self-hosted).
• Customer-Code Isolation — Customer and AI-authored test code is evaluated inside EB pods, never in the host process; MCP browser agents route through EB pods with a mandatory CDP endpoint.

Advanced

• Ignore Regions — Mask dynamic areas (timestamps, ads, counters) from diff comparison with configurable mask styles (solid-color or placeholder-text).
• Planned Screenshots — Compare against design files (Figma exports, etc.) with separate planned vs actual diff tracking.
• Branch Baseline Management — Fork baselines per branch, merge back on PR merge, promote test versions across branches. SHA256-based carry-forward matching.
• Setup & Teardown Orchestration — Repository-default multi-step setup and teardown sequences, build-level execution, and per-test overrides with skip/add extra steps. Supports Playwright (browser), API (HTTP seeding), and test-as-setup/teardown script types. Teardown errors are non-blocking.
• App State Inspection — Access internal app state during tests (window.__APP_STATE__, Redux stores, etc.) for complex assertions.
• Selector Stats — Track selector success/failure rates and response times for automatic optimization recommendations.
• Diff Sensitivity — Configurable pixel/percentage thresholds for unchanged/flaky/changed classification.
• AI Prompt Logs — Full audit trail of all AI requests and responses.
• Background Jobs — Queue tracking for long-running operations (AI scans, builds).
• Diff Engine Benchmarks — Built-in benchmark framework comparing all three diff engines across synthetic test scenarios with timing and accuracy metrics.

Team & Auth

• Multi-Tenant Teams — Slug-based team workspaces with invitations.
• Role-Based Access — Owner, admin, member, viewer roles.
• Multiple Auth Methods — Email/password (Argon2 hashing), GitHub OAuth, GitLab OAuth, Google OAuth via better-auth.
• Email Invitations — Send team invitations via Resend with verification and password reset tokens.
• Billing (hosted) — Stripe subscriptions for hosted deployments: Starter / Growth / Pro tiers, monthly + yearly, checkout + customer portal, period-end downgrades, immediate prorated upgrades. Self-hosted instances run free with billing disabled (no Stripe keys needed).

Quick Start

Local dev

Running tests requires the Embedded Browser stack — there is no local-Playwright fallback. Bring up the database, the host app, and the k3d EB cluster together:

git clone https://github.com/las-team/lastest.git
cd lastest
docker compose up -d         # postgres on :5432 (named volume `lastest-pgdata`)
pnpm install

# Configure env (required before pnpm dev — without EB_PROVISIONER the app
# starts but no test can ever provision an Embedded Browser).
cp .env.example .env.local
cat >> .env.local <<EOF
EB_PROVISIONER=kubernetes
EB_NAMESPACE=lastest
EB_IMAGE=lastest-embedded-browser:latest
LASTEST_URL=http://host.k3d.internal:3000
SYSTEM_EB_TOKEN=$(openssl rand -hex 32)
EOF

pnpm db:push                 # apply schema
pnpm stack                   # REQUIRED: create k3d cluster + build/import EB image
pnpm dev                     # http://localhost:3000

Open http://localhost:3000.

• Stop the DB: docker compose down (data persists in the lastest-pgdata volume).
• Wipe the DB: docker compose down -v.

Embedded Browser stack (required for any test run)

The dev app runs on the host while EB pods are dynamically provisioned into a local k3d cluster — one EB per test. Without pnpm stack running, no test can execute or record.

pnpm stack           # create k3d cluster, build + import the EB image
pnpm stack:status    # cluster + EB jobs + host /api/health
pnpm stack:logs      # tail EB pod logs
pnpm stack:refresh   # rebuild the EB image after editing packages/embedded-browser
pnpm stack:stop      # delete the cluster

The .env.local keys the EB stack requires (already added by the Quick Start block above):

EB_PROVISIONER=kubernetes
EB_NAMESPACE=lastest
EB_IMAGE=lastest-embedded-browser:latest
LASTEST_URL=http://host.k3d.internal:3000
SYSTEM_EB_TOKEN=<openssl rand -hex 32>
DATABASE_URL=postgresql://lastest:lastest@localhost:5432/lastest

Note on defaults: EB_PROVISIONER defaults to 'none' in code, so omitting it lets pnpm dev start cleanly but every test will silently fail to provision an EB. Always set it for any environment that runs tests.

See k8s/ and scripts/k3d-*.sh for the manifests and bootstrap scripts.

First steps

1. Create an account (local, no external auth required)
2. Add a repository and set its local path or connect GitHub/GitLab
3. Click Record — interact with your app, Lastest captures everything
4. AI generates test code automatically
5. Run the test — screenshots are captured and diffed against baselines
6. Review visual changes and approve or reject

Requirements

• Docker: Docker 20+ with Compose v2
• Node.js: 18+ and pnpm 10.x
• Required for running/recording tests: k3d ≥ 5.6, kubectl, openssl (the EB stack — no local-Playwright fallback)

How It Works

┌──────────────────┐     ┌─────────────┐     ┌─────────────┐
│   Create Tests   │ ──▶ │   Run       │ ──▶ │   Review    │
│                  │     │             │     │             │
│ Record manually  │     │ Embedded    │     │ Approve/    │
│ AI-assisted      │     │ Browser or  │     │ Reject      │
│ Play Agent auto  │     │ remote/CI   │     │ changes     │
└──────────────────┘     └─────────────┘     └─────────────┘
   One-time cost           No AI per run      New baseline
   (AI optional)           (pure Playwright)  saved

Core Flow

1. Create: Build tests your way — record manually in the browser, let AI generate from a URL or spec, or let the Play Agent autonomously scan your entire app.

2. Run: Every test executes inside an Embedded Browser pod — provisioned on demand, one per test, and streamed live to the UI. Trigger from the UI, a webhook, a schedule, or CI/CD via the @lastest/runner trigger CLI. Screenshots are captured at key steps. No AI needed — pure Playwright execution at zero cost. There is no local-Playwright fallback and no remote-runner daemon; the EB stack is required.

3. Compare: New screenshots are diffed against baselines using your chosen engine (pixelmatch, SSIM, or Butteraugli). Text-region-aware comparison available. Accessibility audits run automatically.

4. Review: Visual diffs are classified (unchanged/flaky/changed). AI can optionally auto-classify with confidence scores. Approve intentional changes — they become the new baseline.

5. Fix: When tests break, AI can propose fixes (human-in-the-loop) or the Play Agent can fix and re-run autonomously. When a failure is a real regression, the Fix-the-App Advisor can instead suggest a fix to your application code (never auto-applied). Or edit the code by hand — your choice.

Development & Review Flow

End-to-end view of how Lastest fits into a CI/CD workflow — from git push through preview-env validation to merge approval.

Embedded Browser Execution

All test execution happens in Embedded Browser pods. When a build starts, the Lastest server provisions EB pods on demand into the Kubernetes cluster (k3d locally, your cluster in production) — one browser per test, bounded by a per-build worker pool with warm-pool keep-alive. Each pod runs Playwright, streams its screen live over CDP, captures screenshots, and reports results back. Pod egress is restricted and pod creation is throttled (CNI burst protection). The host process never launches a browser; if no EB is available, the run fails rather than falling back.

For CI/CD, the @lastest/runner CLI creates a build over HTTP and polls for the result — it carries no browser and executes nothing locally; the EB pool does all the work server-side.

Why Lastest

Comparison

What makes Lastest different

• Record + AI generate + run + diff + approve in one self-hosted tool — no competitor does all five
• Embedded browser execution: every test runs in a containerized browser with live CDP streaming — no local Playwright install and no remote-runner daemon; trigger and poll builds from CI with the lightweight, browser-free @lastest/runner CLI
• Headless API testing: test backend endpoints (methods, headers, auth, assertions) alongside your visual tests, through the same verdict pipeline — with a burst/load runner for endpoints
• Public share links: publish any run or diff as a watermarked, login-free /r/ report with AI demo notes, session video, and X/YouTube/TikTok social cards
• Fix-the-app advisor: for real regressions, AI suggests the fix to your application code (file, snippet, rationale), not just the test
• Autonomous Play Agent: one-click 11-step pipeline scans routes, generates tests, runs them, fixes failures, and reports results
• AI auto-fix: tests break as your UI evolves, Lastest fixes them automatically
• Self-hosted with unlimited screenshots — no per-screenshot pricing, no volume limits when you run it on your own infra
• Your data never leaves your server — screenshots stay local, no cloud dependency
• MCP server with 24 consolidated tools — let AI agents (Claude, etc.) run tests, review diffs, heal failures, and suggest app-code fixes autonomously
• Scheduled test runs — cron-based automation with smart failure handling
• WCAG 2.2 AA compliance scoring — automated 0–100 accessibility score per build with trend tracking
• 6 AI providers including OpenAI and Ollama — run AI completely locally with zero API costs
• Agent monitoring — real-time SSE activity feed tracking Play Agent progress step-by-step
• Codebase intelligence — auto-detects your stack to generate better, more relevant tests
• Spec-driven testing — feed it OpenAPI specs, user stories, or markdown files and get tests back
• 3 diff engines — pixelmatch, SSIM, and Butteraugli with OCR-based text-region-aware comparison
• 12 stabilization features — timestamp freezing, random seeding, burst capture, auto-masking, DOM/network stability, and more
• Auto-capability detection — recordings auto-detect clipboard, upload, download, and network needs
• Gamification — "Beat the Bot" leaderboard with seasonal scoring, achievements, and Bug Blitz multiplier events
• Cross-instance migration — export/import tests between Lastest deployments via REST API or in-app UI

Commands

pnpm dev          # Start development server on localhost:3000
pnpm build        # Production build
pnpm start        # Start production server
pnpm lint         # Run ESLint
pnpm test         # Run unit tests (Vitest)
pnpm test:watch   # Run unit tests in watch mode
pnpm test:coverage # Run tests with coverage report
pnpm test:ui      # Run tests with Vitest UI
pnpm db:studio    # Open Drizzle Studio for database inspection
pnpm db:push      # Push schema changes to database
pnpm db:generate  # Generate Drizzle migrations
pnpm db:reset     # Reset database (drops all tables + removes screenshots/baselines)
pnpm db:seed      # Seed test data
pnpm test:visual  # Run visual tests via CLI (see below)

# Local k3d cluster — hosts dynamically-provisioned EB Job pods (no app, no db)
pnpm stack              # create cluster + build/import EB image
pnpm stack:refresh      # rebuild + import EB image (alias of stack:refresh:eb)
pnpm stack:refresh:eb   # same
pnpm stack:status       # cluster + EB jobs/pods + host /api/health
pnpm stack:logs         # tail EB pod logs
pnpm stack:stop         # delete cluster

Tech Guides

In-depth docs for every integration live on the Lastest Wiki. The README keeps things at a glance — click through for flags, payloads, and CI examples.

| Guide | What it covers | Wiki | | ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------