Release v0.4.0-alpha.1

.github/workflows/ci.yml

@@ -0,0 +1,81 @@
+name: CI
+
+# Core, deterministic checks — the same suite local dev runs, now including the
+# frontend + contract suite (which the GitLab pipeline never ran). The heavier
+# browser e2e and the dockerized-RotorHazard live suite are gated separately
+# (see heavy.yml) per the runner-cost policy.
+on:
+  push:
+    branches: [main, devel, "milestone/**"]
+  pull_request:
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  rust:
+    name: Rust — cargo xtask ci
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt, clippy
+      - uses: Swatinem/rust-cache@v2
+      # fmt --check && clippy -D warnings && test --all && ts-rs bindings drift-check
+      - run: cargo xtask ci
+
+  audit:
+    name: Security — cargo audit
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: dtolnay/rust-toolchain@stable
+      # Cache the cargo-audit binary (and the advisory-db it fetches) so the job
+      # stays fast — it only reads Cargo.lock, it never builds the workspace.
+      - uses: Swatinem/rust-cache@v2
+        with:
+          # cargo-audit lives in ~/.cargo/bin and the advisory-db under
+          # ~/.cargo/advisory-db; key the cache so a fresh install is rare.
+          cache-bin: true
+          shared-key: cargo-audit
+      - name: Install cargo-audit
+        run: cargo install cargo-audit --locked
+      # Triaged/accepted advisories are enumerated in ./audit.toml; this fails
+      # the job on any new advisory (including real vulnerabilities).
+      - run: cargo audit
+
+  frontend:
+    name: Frontend — build/check/lint/test/contract
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 22
+          cache: npm
+          cache-dependency-path: frontend/package-lock.json
+      - name: Install deps
+        run: npm ci
+        working-directory: frontend
+      - name: Build
+        run: npm run build
+        working-directory: frontend
+      - name: Type-check
+        run: npm run check
+        working-directory: frontend
+      - name: Lint
+        run: npm run lint
+        working-directory: frontend
+      - name: Unit tests
+        run: npm test
+        working-directory: frontend
+      # The contract suite boots the real Director, so build it first.
+      - name: Build Director
+        run: cargo build -p gridfpv-app
+      - name: Contract suite (strict client↔server wire checks)
+        run: npm run contract
+        working-directory: frontend

.github/workflows/release-builds.yml

@@ -0,0 +1,107 @@
+name: Release builds
+
+# Gated, cost-aware native-app build pipeline — produces the Tauri desktop
+# PORTABLE binary (the RELEASE form of GridFPV; see src-tauri/README.md). This is
+# a PORTABLE-ONLY build: it builds with `--no-bundle`, so no installers
+# (msi/nsis/appimage/deb) are produced — just the self-contained
+# gridfpv-desktop[.exe] with the embedded frontend. This is
+# DELIBERATELY NOT part of the per-push CI (ci.yml): it does NOT run on devel,
+# on pull_request, or on every push, so dev velocity and Actions cost are
+# preserved. It only runs:
+#   - manually (workflow_dispatch — the "Run workflow" button / `gh workflow run`)
+#   - on merge to main (release builds)
+on:
+  workflow_dispatch:
+  push:
+    branches: [main]
+
+concurrency:
+  group: release-builds-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    name: ${{ matrix.os }} — Tauri portable
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            # Single-file portable: the raw self-contained gridfpv-desktop binary
+            # (frontend embedded via the embed-assets feature — no external dist).
+            portable-artifact: gridfpv-linux-portable
+            portable-path: src-tauri/target/release/gridfpv-desktop
+          - os: windows-latest
+            portable-artifact: gridfpv-windows-portable
+            portable-path: src-tauri/target/release/gridfpv-desktop.exe
+          - os: macos-latest
+            # Apple Silicon (macos-latest = arm64) — covers every modern Mac; an Intel
+            # (x86_64) leg is a matrix add if one ever turns up at the field.
+            portable-artifact: gridfpv-macos-portable
+            portable-path: src-tauri/target/release/gridfpv-desktop
+
+    steps:
+      - uses: actions/checkout@v7
+
+      # Linux-only: Tauri's webkit2gtk/GTK system deps (Windows uses the bundled
+      # WebView2 runtime and needs none of these). Mirror src-tauri/README.md.
+      - name: Install Tauri Linux system deps
+        if: matrix.os == 'ubuntu-latest'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            libwebkit2gtk-4.1-dev \
+            libgtk-3-dev \
+            librsvg2-dev \
+            libsoup-3.0-dev \
+            libjavascriptcoregtk-4.1-dev \
+            libssl-dev \
+            libayatana-appindicator3-dev
+
+      - uses: dtolnay/rust-toolchain@stable
+
+      # Cache keyed per-OS; src-tauri is a standalone workspace, so point the
+      # cache at its own lockfile so the matrix legs don't collide.
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: src-tauri
+          key: ${{ matrix.os }}
+
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 22
+          cache: npm
+          cache-dependency-path: frontend/package-lock.json
+
+      # Build the frontend (the workspace packages + the rd-console dist that the
+      # app bundles). This is exactly what tauri.conf.json's beforeBuildCommand
+      # runs (`cd frontend && npm ci && npm run build`); doing it explicitly here
+      # makes the dist build a visible, cached step and matches ci.yml's
+      # conventions (npm ci + npm run build under frontend/).
+      - name: Build frontend (rd-console dist)
+        run: |
+          npm ci
+          npm run build
+        working-directory: frontend
+
+      # PORTABLE-ONLY build: `--no-bundle` compiles the gridfpv-desktop crate (with
+      # the embedded frontend + the Windows icon) into
+      # src-tauri/target/release/gridfpv-desktop[.exe] but produces NO installers
+      # (msi/nsis/appimage/deb) — bundle.targets in tauri.conf.json is irrelevant
+      # because --no-bundle skips bundling entirely. It re-runs beforeBuildCommand
+      # (idempotent — frontend already built above).
+      - name: Build Tauri portable binary (--no-bundle)
+        run: npx -y @tauri-apps/cli@2 build --no-bundle
+        working-directory: src-tauri
+
+      # Single-file portable: the raw gridfpv-desktop binary. Because gridfpv-app is
+      # built with the embed-assets feature, the frontend dist is baked into the
+      # binary, so it self-serves the RD console with no external assets folder — a
+      # standalone executable. This is the ONLY release artifact (portable-only).
+      - name: Upload portable binary
+        uses: actions/upload-artifact@v7
+        with:
+          name: ${{ matrix.portable-artifact }}
+          path: ${{ matrix.portable-path }}
+          if-no-files-found: error

.gitignore

@@ -1,6 +1,13 @@
 # Rust build artifacts
 /target/
 
+# Tauri native-app build artifacts. `src-tauri` is the release-only desktop crate
+# (excluded from the workspace; built with `cargo tauri build`). Its own `target/` and
+# Tauri's generated `gen/` (capability schemas) are derived — never committed. The bundled
+# RD-console dist is built fresh by the `beforeBuildCommand`, so it's ignored too.
+/src-tauri/target/
+/src-tauri/gen/
+
 # Claude Code local state (agent worktrees, etc.)
 .claude/
 
@@ -12,3 +19,20 @@
 
 # Local reverse-engineering / analysis artifacts (not part of the project)
 pyghidra_mcp_projects/
+
+# Frontend monorepo (frontend/)
+frontend/node_modules/
+frontend/**/node_modules/
+frontend/**/dist/
+frontend/**/build/
+frontend/**/.svelte-kit/
+frontend/**/.vite/
+frontend/**/*.tsbuildinfo
+frontend/.eslintcache
+
+# Playwright e2e run artifacts + downloaded browser binaries (never committed)
+frontend/test-results/
+frontend/playwright-report/
+frontend/blob-report/
+frontend/.playwright/
+frontend/e2e-artifacts/

CLAUDE.md

@@ -0,0 +1,41 @@
+# GridFPV — Project Rules
+
+Standing rules for working in this repo. These bind every change (human or agent).
+
+## Display: always use the friendly name, never a raw id
+
+**Anywhere a value that has a human-friendly name is shown to a user, render the
+friendly name — never the raw unique id / ref / uuid / node seat.**
+
+This applies to *every* surface: tables, lists, dropdowns (the visible label —
+the option `value` may stay the raw ref), page headers, section legends, audit /
+log lines, graph and chart labels, toasts, tooltips, confirmation dialogs, and
+error messages.
+
+Go through the **shared resolvers** — never re-derive a name inline (that's how
+they drift):
+
+- **Competitor ref → callsign:** `createCompetitorNameResolver`
+  (`frontend/apps/rd-console/src/lib/competitorName.ts`)
+- **Heat id → "‹Round› Heat N" / main tier / custom label:** `heatNameById`
+  (`frontend/apps/rd-console/src/lib/heats.ts`)
+- **Pilot id → callsign**, **round id → round label**, **class id → class name**,
+  **frequency/channel → band+channel label** (`channels.ts`) — same principle; use
+  the existing helper, or add one.
+
+Rules of thumb:
+
+- Raw ids/refs are **wire handles only**. The UI layer resolves them before display.
+- Resolve from a **durable source** (the entity's own record / a projection), not
+  just live/current state — so **finished, non-current, or not-yet-running**
+  entities still resolve (e.g. marshaling a *finished* heat must still show
+  callsigns; a node-seeded heat must resolve `node-0` → the bound pilot).
+- A resolver may fall back to the raw ref as a **last resort**, but any **new**
+  display that shows an entity MUST go through the resolver, not print the id.
+- When you add a new entity type that has an id **and** a name, add/extend a
+  resolver and use it everywhere that entity is shown.
+
+*Why this is a rule:* friendly-name leaks have been a recurring bug class —
+Live control, the global header, marshaling (audit / ruling / protests / add-lap),
+graph labels, and heat names have each leaked raw ids at some point. Treat a raw
+id reaching the screen as a bug.