jettypod 4.4.118 → 4.4.121

package/apps/dashboard/scripts/tauri-build.js

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+
+/**
+ * Tauri Build Script
+ *
+ * Orchestrates the Tauri release build:
+ * 1. Validates prerequisites (cargo-tauri, signing keys)
+ * 2. Builds the Vite frontend
+ * 3. Runs `cargo tauri build` with code signing
+ * 4. Optionally uploads to R2
+ *
+ * Usage:
+ *   node scripts/tauri-build.js [--release] [--upload] [--target arm64|x64|universal]
+ *
+ * Environment variables:
+ *   APPLE_SIGNING_IDENTITY  - Code signing identity (default: "-" for ad-hoc)
+ *   APPLE_TEAM_ID           - Apple Developer Team ID (enables notarization)
+ *   APPLE_ID                - Apple ID email (for notarization)
+ *   APPLE_PASSWORD          - App-specific password (for notarization)
+ *   TAURI_SIGNING_PRIVATE_KEY     - Ed25519 private key for update signing
+ *   TAURI_SIGNING_PRIVATE_KEY_PASSWORD - Password for the signing key
+ */
+
+const { execSync, spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..');
+const TAURI_DIR = path.join(ROOT, 'src-tauri');
+const TAURI_CONF = path.join(TAURI_DIR, 'tauri.conf.json');
+const TAURI_PROD_CONF = path.join(TAURI_DIR, 'tauri.prod.conf.json');
+// Cargo uses the workspace-level target/ directory (repo root), not src-tauri/target/
+const WORKSPACE_ROOT = path.resolve(ROOT, '..', '..');
+
+// ---------------------------------------------------------------------------
+// Argument parsing
+// ---------------------------------------------------------------------------
+
+const args = process.argv.slice(2);
+const isRelease = args.includes('--release');
+const doUpload = args.includes('--upload');
+const targetArg = args.find(a => a.startsWith('--target='));
+const target = targetArg ? targetArg.split('=')[1] : null;
+
+// ---------------------------------------------------------------------------
+// Validation
+// ---------------------------------------------------------------------------
+
+function check(label, fn) {
+  process.stdout.write(`  ${label}... `);
+  try {
+    const result = fn();
+    console.log('✅');
+    return result;
+  } catch (e) {
+    console.log('❌');
+    console.error(`    ${e.message}`);
+    process.exit(1);
+  }
+}
+
+function validate() {
+  console.log('\n🔍 Validating prerequisites:\n');
+
+  check('cargo-tauri CLI', () => {
+    try {
+      execSync('cargo tauri --version 2>/dev/null', { stdio: 'pipe', env: { ...process.env, PATH: `${process.env.HOME}/.cargo/bin:${process.env.PATH}` } });
+    } catch {
+      throw new Error('cargo-tauri not found. Install with: cargo install tauri-cli');
+    }
+  });
+
+  check('Rust toolchain', () => {
+    try {
+      execSync('rustc --version 2>/dev/null', { stdio: 'pipe', env: { ...process.env, PATH: `${process.env.HOME}/.cargo/bin:${process.env.PATH}` } });
+    } catch {
+      throw new Error('Rust not found. Install from https://rustup.rs');
+    }
+  });
+
+  check('tauri.conf.json', () => {
+    if (!fs.existsSync(TAURI_CONF)) {
+      throw new Error(`Missing ${TAURI_CONF}`);
+    }
+  });
+
+  if (isRelease) {
+    check('Signing identity', () => {
+      const identity = process.env.APPLE_SIGNING_IDENTITY;
+      if (!identity || identity === '-') {
+        console.log('\n    ⚠️  Using ad-hoc signing. Set APPLE_SIGNING_IDENTITY for production.');
+      }
+    });
+
+    if (process.env.APPLE_TEAM_ID) {
+      check('Notarization credentials', () => {
+        if (!process.env.APPLE_ID) throw new Error('APPLE_ID required for notarization');
+        if (!process.env.APPLE_PASSWORD) throw new Error('APPLE_PASSWORD required for notarization');
+      });
+    }
+
+    check('Update signing key', () => {
+      if (!process.env.TAURI_SIGNING_PRIVATE_KEY) {
+        console.log('\n    ⚠️  No TAURI_SIGNING_PRIVATE_KEY set. Updates won\'t be signed.');
+      }
+    });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Build steps
+// ---------------------------------------------------------------------------
+
+function runCommand(label, cmd, opts = {}) {
+  console.log(`\n📦 ${label}...`);
+  const env = {
+    ...process.env,
+    PATH: `${process.env.HOME}/.cargo/bin:${process.env.PATH}`,
+  };
+
+  const result = spawnSync('sh', ['-c', cmd], {
+    stdio: 'inherit',
+    cwd: opts.cwd || ROOT,
+    env,
+  });
+
+  if (result.status !== 0) {
+    console.error(`\n❌ ${label} failed (exit code ${result.status})`);
+    process.exit(1);
+  }
+}
+
+function updateSigningIdentity() {
+  // Pass signing identity via APPLE_SIGNING_IDENTITY env var.
+  // Tauri reads this automatically — no need to mutate tauri.conf.json.
+  const identity = process.env.APPLE_SIGNING_IDENTITY;
+  if (identity && identity !== '-') {
+    console.log(`  Using signing identity: ${identity}`);
+  } else {
+    console.log('  Using ad-hoc signing (no APPLE_SIGNING_IDENTITY set)');
+  }
+}
+
+function buildTauri() {
+  let buildCmd = 'cargo tauri build';
+
+  if (target === 'universal') {
+    buildCmd += ' --target universal-apple-darwin';
+  } else if (target === 'arm64') {
+    buildCmd += ' --target aarch64-apple-darwin';
+  } else if (target === 'x64') {
+    buildCmd += ' --target x86_64-apple-darwin';
+  }
+
+  // Apply production config overlay for release builds
+  if (isRelease && fs.existsSync(TAURI_PROD_CONF)) {
+    buildCmd += ` --config "${TAURI_PROD_CONF}"`;
+    console.log('  Applying production config overlay (JettyPod name + clean icon)');
+  }
+
+  // Pass signing key via environment
+  const extraEnv = [];
+  if (process.env.TAURI_SIGNING_PRIVATE_KEY) {
+    extraEnv.push('TAURI_SIGNING_PRIVATE_KEY');
+  }
+  if (process.env.TAURI_SIGNING_PRIVATE_KEY_PASSWORD) {
+    extraEnv.push('TAURI_SIGNING_PRIVATE_KEY_PASSWORD');
+  }
+
+  runCommand('Building Tauri app', buildCmd, { cwd: TAURI_DIR });
+}
+
+function showArtifacts() {
+  const targetDir = path.join(WORKSPACE_ROOT, 'target');
+  // When cross-compiling, bundles go under target/{triple}/release/bundle/
+  const candidates = [
+    path.join(targetDir, 'release', 'bundle'),
+    path.join(targetDir, 'x86_64-apple-darwin', 'release', 'bundle'),
+    path.join(targetDir, 'aarch64-apple-darwin', 'release', 'bundle'),
+    path.join(targetDir, 'universal-apple-darwin', 'release', 'bundle'),
+  ];
+  const bundleDir = candidates.find(d => fs.existsSync(d)) || path.join(targetDir, 'release', 'bundle');
+
+  console.log('\n✅ Build complete! Artifacts:');
+
+  // Check for DMG files
+  const dmgDir = path.join(bundleDir, 'dmg');
+  if (fs.existsSync(dmgDir)) {
+    const dmgs = fs.readdirSync(dmgDir).filter(f => f.endsWith('.dmg'));
+    dmgs.forEach(f => {
+      const size = (fs.statSync(path.join(dmgDir, f)).size / 1024 / 1024).toFixed(1);
+      console.log(`  📀 ${f} (${size} MB)`);
+    });
+  }
+
+  // Check for app bundle
+  const macosDir = path.join(bundleDir, 'macos');
+  if (fs.existsSync(macosDir)) {
+    const apps = fs.readdirSync(macosDir).filter(f => f.endsWith('.app'));
+    apps.forEach(f => {
+      console.log(`  📱 ${f}`);
+    });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+console.log('🚀 JettyPod Tauri Build');
+console.log(`   Mode: ${isRelease ? 'RELEASE' : 'DEBUG'}`);
+console.log(`   Target: ${target || 'native'}`);
+console.log(`   Upload: ${doUpload ? 'yes' : 'no'}`);
+
+validate();
+
+if (isRelease) {
+  updateSigningIdentity();
+}
+
+buildTauri();
+showArtifacts();
+
+if (doUpload) {
+  runCommand('Uploading to R2', 'node scripts/upload-tauri-to-r2.js');
+}
+
+console.log('\n🎉 Done!\n');

package/apps/dashboard/scripts/upload-tauri-to-r2.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+/**
+ * Upload Tauri release artifacts to Cloudflare R2.
+ * Run after tauri build: node scripts/upload-tauri-to-r2.js
+ *
+ * Requires wrangler login or CLOUDFLARE_API_TOKEN env var.
+ *
+ * Uploads DMG and update signature files to R2 under the
+ * tauri/ prefix, organized by target/arch for the updater endpoint.
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const BUCKET_NAME = 'jettypod-releases';
+// Cargo uses the workspace-level target/ directory (repo root), not src-tauri/target/
+const WORKSPACE_ROOT = path.resolve(__dirname, '..', '..', '..');
+const TARGET_DIR = path.join(WORKSPACE_ROOT, 'target');
+
+// Tauri puts release bundles under target/release/bundle/
+// or target/{triple}/release/bundle/ for cross-compilation
+function findBundleDir() {
+  const candidates = [
+    path.join(TARGET_DIR, 'release', 'bundle'),
+    path.join(TARGET_DIR, 'aarch64-apple-darwin', 'release', 'bundle'),
+    path.join(TARGET_DIR, 'x86_64-apple-darwin', 'release', 'bundle'),
+    path.join(TARGET_DIR, 'universal-apple-darwin', 'release', 'bundle'),
+  ];
+
+  for (const dir of candidates) {
+    if (fs.existsSync(dir)) return dir;
+  }
+
+  return null;
+}
+
+function findArtifacts(bundleDir) {
+  const artifacts = [];
+
+  // DMG files
+  const dmgDir = path.join(bundleDir, 'dmg');
+  if (fs.existsSync(dmgDir)) {
+    for (const f of fs.readdirSync(dmgDir)) {
+      if (f.endsWith('.dmg')) {
+        artifacts.push({ name: f, path: path.join(dmgDir, f), type: 'dmg' });
+      }
+    }
+  }
+
+  // Update signature files (.tar.gz and .sig for Tauri updater)
+  const macosDir = path.join(bundleDir, 'macos');
+  if (fs.existsSync(macosDir)) {
+    for (const f of fs.readdirSync(macosDir)) {
+      if (f.endsWith('.tar.gz') || f.endsWith('.tar.gz.sig')) {
+        artifacts.push({ name: f, path: path.join(macosDir, f), type: 'update' });
+      }
+    }
+  }
+
+  return artifacts;
+}
+
+function uploadFile(artifact, r2Key) {
+  const stats = fs.statSync(artifact.path);
+  const sizeMB = (stats.size / (1024 * 1024)).toFixed(1);
+
+  process.stdout.write(`  ${r2Key} (${sizeMB} MB)... `);
+
+  try {
+    execSync(
+      `npx wrangler r2 object put "${BUCKET_NAME}/${r2Key}" --file="${artifact.path}" --remote`,
+      { stdio: 'pipe' }
+    );
+    console.log('✅');
+    return true;
+  } catch (error) {
+    console.log('❌');
+    console.error(`    ${error.message}`);
+    return false;
+  }
+}
+
+function main() {
+  console.log('🚀 Uploading Tauri release artifacts to R2...\n');
+
+  const bundleDir = findBundleDir();
+  if (!bundleDir) {
+    console.error('❌ No Tauri bundle directory found.');
+    console.error('Run `cargo tauri build` first.');
+    process.exit(1);
+  }
+
+  console.log(`Bundle dir: ${bundleDir}\n`);
+
+  const artifacts = findArtifacts(bundleDir);
+  if (artifacts.length === 0) {
+    console.error('❌ No release artifacts found.');
+    process.exit(1);
+  }
+
+  console.log(`Found ${artifacts.length} artifact(s):\n`);
+
+  let success = 0;
+  let failed = 0;
+
+  for (const artifact of artifacts) {
+    // Upload under tauri/ prefix for organization
+    const r2Key = `tauri/${artifact.name}`;
+    if (uploadFile(artifact, r2Key)) {
+      success++;
+    } else {
+      failed++;
+    }
+  }
+
+  console.log(`\n📦 Upload complete: ${success} uploaded, ${failed} failed`);
+
+  if (failed > 0) {
+    process.exit(1);
+  }
+}
+
+main();

package/apps/dashboard/scripts/ws-server.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+
+/**
+ * Standalone WebSocket server for browser dev mode.
+ *
+ * Polls the JettyPod SQLite database and cucumber-results.json for changes
+ * and broadcasts notifications to connected clients.  This is the same
+ * behaviour embedded in electron/main.js, extracted so `npm run dev` can
+ * provide live updates without Electron running.
+ *
+ * Usage:
+ *   node scripts/ws-server.js [project-path]
+ *
+ * project-path defaults to the repository root (two levels up from this script).
+ */
+
+const { WebSocketServer } = require('ws');
+const fs = require('fs');
+const path = require('path');
+
+const WS_PORT = 47808;
+const DB_POLL_MS = 500;
+
+const projectRoot = process.argv[2] || path.resolve(__dirname, '..', '..', '..');
+
+// ---------------------------------------------------------------------------
+// State
+// ---------------------------------------------------------------------------
+const clients = new Set();
+let dbPollInterval = null;
+let testResultsPollInterval = null;
+let lastDbMtimes = { db: null, wal: null };
+let lastTestResultsMtime = null;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function log(msg) {
+  console.log(`[ws-server] ${msg}`);
+}
+
+function broadcast(message) {
+  const payload = JSON.stringify(message);
+  for (const client of clients) {
+    if (client.readyState === 1) { // WebSocket.OPEN
+      client.send(payload);
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Database polling (WAL-aware)
+// ---------------------------------------------------------------------------
+function startDatabasePolling() {
+  const dbPath = path.join(projectRoot, '.jettypod', 'work.db');
+
+  if (!fs.existsSync(dbPath)) {
+    log(`Database not found at ${dbPath}, retrying in 5s...`);
+    setTimeout(startDatabasePolling, 5000);
+    return;
+  }
+
+  try {
+    const dbStats = fs.statSync(dbPath);
+    lastDbMtimes.db = dbStats.mtimeMs;
+
+    const walPath = dbPath + '-wal';
+    if (fs.existsSync(walPath)) {
+      lastDbMtimes.wal = fs.statSync(walPath).mtimeMs;
+    }
+  } catch (err) {
+    log(`Failed to get initial db stats: ${err.message}`);
+    return;
+  }
+
+  log(`Polling database for changes (WAL-aware)...`);
+
+  dbPollInterval = setInterval(() => {
+    try {
+      let changed = false;
+
+      const dbStats = fs.statSync(dbPath);
+      if (dbStats.mtimeMs !== lastDbMtimes.db) {
+        lastDbMtimes.db = dbStats.mtimeMs;
+        changed = true;
+      }
+
+      const walPath = dbPath + '-wal';
+      if (fs.existsSync(walPath)) {
+        const walStats = fs.statSync(walPath);
+        if (walStats.mtimeMs !== lastDbMtimes.wal) {
+          lastDbMtimes.wal = walStats.mtimeMs;
+          changed = true;
+        }
+      }
+
+      if (changed) {
+        broadcast({ type: 'db_change', timestamp: Date.now() });
+      }
+    } catch {
+      // File might be temporarily locked during writes — ignore
+    }
+  }, DB_POLL_MS);
+}
+
+// ---------------------------------------------------------------------------
+// Test results polling
+// ---------------------------------------------------------------------------
+function startTestResultsPolling() {
+  const testResultsPath = path.join(projectRoot, 'cucumber-results.json');
+
+  if (fs.existsSync(testResultsPath)) {
+    try {
+      lastTestResultsMtime = fs.statSync(testResultsPath).mtimeMs;
+      log(`Watching test results at ${testResultsPath}`);
+    } catch (err) {
+      log(`Failed to get initial test results stats: ${err.message}`);
+    }
+  } else {
+    log(`Test results file not found at ${testResultsPath}, will watch for creation`);
+  }
+
+  testResultsPollInterval = setInterval(() => {
+    try {
+      if (!fs.existsSync(testResultsPath)) {
+        if (lastTestResultsMtime !== null) {
+          lastTestResultsMtime = null;
+        }
+        return;
+      }
+
+      const stats = fs.statSync(testResultsPath);
+      if (stats.mtimeMs !== lastTestResultsMtime) {
+        lastTestResultsMtime = stats.mtimeMs;
+        broadcast({ type: 'test_change', timestamp: Date.now() });
+      }
+    } catch {
+      // ignore
+    }
+  }, DB_POLL_MS);
+}
+
+// ---------------------------------------------------------------------------
+// Server
+// ---------------------------------------------------------------------------
+const wss = new WebSocketServer({ port: WS_PORT });
+
+wss.on('connection', (ws) => {
+  clients.add(ws);
+  log(`Client connected. Total: ${clients.size}`);
+  ws.send(JSON.stringify({ type: 'connected', timestamp: Date.now() }));
+
+  ws.on('close', () => {
+    clients.delete(ws);
+    log(`Client disconnected. Total: ${clients.size}`);
+  });
+
+  ws.on('error', (err) => {
+    log(`Client error: ${err.message}`);
+    ws.close();
+    clients.delete(ws);
+  });
+});
+
+wss.on('error', (err) => {
+  if (err.code === 'EADDRINUSE') {
+    log(`Port ${WS_PORT} already in use (Electron running?). Exiting.`);
+    process.exit(0);
+  }
+  log(`Server error: ${err.message}`);
+});
+
+wss.on('listening', () => {
+  log(`WebSocket server running on ws://localhost:${WS_PORT}`);
+  log(`Watching project: ${projectRoot}`);
+  startDatabasePolling();
+  startTestResultsPolling();
+});
+
+// Graceful shutdown
+function shutdown() {
+  log('Shutting down...');
+  if (dbPollInterval) clearInterval(dbPollInterval);
+  if (testResultsPollInterval) clearInterval(testResultsPollInterval);
+  for (const client of clients) client.close();
+  clients.clear();
+  wss.close(() => process.exit(0));
+}
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);

package/apps/dashboard/src/main.tsx

@@ -0,0 +1,12 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import { RouterProvider } from 'react-router-dom'
+import { router } from './router'
+import '@fontsource-variable/geist-mono'
+import '../app/globals.css'
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <RouterProvider router={router} />
+  </StrictMode>
+)

package/apps/dashboard/src/router.tsx

@@ -0,0 +1,107 @@
+import { lazy, Suspense, useState, useEffect } from 'react'
+import { createBrowserRouter, Outlet } from 'react-router-dom'
+import { AppShell } from '../components/AppShell'
+import { JettyLoader } from '../components/JettyLoader'
+import { dataBridge } from '../lib/data-bridge'
+
+// Lazy-load all pages — prefetch nav targets on app load so first navigation
+// never shows a spinner. It's a desktop app; the extra chunks cost nothing.
+const dashboardImport = () => import('../app/page')
+const Dashboard = lazy(dashboardImport)
+const workDetailImport = () => import('../app/work/[id]/page')
+const WorkDetail = lazy(workDetailImport)
+const proofDashboardImport = () => import('../app/work/[id]/proof/page')
+const ProofDashboard = lazy(proofDashboardImport)
+const decisionDetailImport = () => import('../app/decision/[id]/page')
+const DecisionDetail = lazy(decisionDetailImport)
+const testsImport = () => import('../app/tests/page')
+const Tests = lazy(testsImport)
+const settingsImport = () => import('../app/settings/page')
+const Settings = lazy(settingsImport)
+const prototypesImport = () => import('../app/prototypes/page')
+const Prototypes = lazy(prototypesImport)
+
+// Kick off chunk prefetches immediately
+dashboardImport()
+workDetailImport()
+proofDashboardImport()
+decisionDetailImport()
+testsImport()
+settingsImport()
+prototypesImport()
+
+const Welcome = lazy(() => import('../app/welcome/page'))
+const Login = lazy(() => import('../app/login/page'))
+const Signup = lazy(() => import('../app/signup/page'))
+const Subscribe = lazy(() => import('../app/subscribe/page'))
+const InstallClaude = lazy(() => import('../app/install-claude/page'))
+const ConnectClaude = lazy(() => import('../app/connect-claude/page'))
+// Dev-only pages — excluded from production to reduce bundle
+const DesignSystem = import.meta.env.DEV ? lazy(() => import('../app/design-system/page')) : () => null
+const DemoGates = import.meta.env.DEV ? lazy(() => import('../app/demo/gates/page')) : () => null
+const DevSessionPrototype = import.meta.env.DEV ? lazy(() => import('../app/prototypes/dev-session/page')) : () => null
+const ProofDashboardPrototype = import.meta.env.DEV ? lazy(() => import('../app/prototypes/proof-dashboard/page')) : () => null
+const OnboardingPrototype = import.meta.env.DEV ? lazy(() => import('../app/prototypes/onboarding/page')) : () => null
+const OnboardingMadlibPrototype = import.meta.env.DEV ? lazy(() => import('../app/prototypes/onboarding-madlib/page')) : () => null
+
+function PageLoader() {
+  return (
+    <div className="h-full flex items-center justify-center bg-background">
+      <JettyLoader size={80} />
+    </div>
+  )
+}
+
+function RootLayout() {
+  const [projectName, setProjectName] = useState('JettyPod')
+
+  useEffect(() => {
+    dataBridge.getProjectRoot().then((root) => {
+      if (root) {
+        setProjectName(root.split('/').pop() || 'JettyPod')
+      }
+    })
+  }, [])
+
+  return (
+    <AppShell projectName={projectName}>
+      <Outlet />
+    </AppShell>
+  )
+}
+
+export const router = createBrowserRouter([
+  {
+    path: '/',
+    element: <RootLayout />,
+    children: [
+      {
+        // Dashboard layout route — kanban stays mounted while viewing work items.
+        // Navigating to /work/:id hides the kanban (display:none) instead of
+        // unmounting it, so returning to / is instant with no refetch.
+        element: <Suspense fallback={<PageLoader />}><Dashboard /></Suspense>,
+        children: [
+          { index: true, element: null },
+          { path: 'work/:id', element: <Suspense fallback={<PageLoader />}><WorkDetail /></Suspense> },
+          { path: 'work/:id/proof', element: <Suspense fallback={<PageLoader />}><ProofDashboard /></Suspense> },
+          { path: 'decision/:id', element: <Suspense fallback={<PageLoader />}><DecisionDetail /></Suspense> },
+        ],
+      },
+      { path: 'tests', element: <Suspense fallback={<PageLoader />}><Tests /></Suspense> },
+      { path: 'settings', element: <Suspense fallback={<PageLoader />}><Settings /></Suspense> },
+      { path: 'prototypes', element: <Suspense fallback={<PageLoader />}><Prototypes /></Suspense> },
+      { path: 'welcome', element: <Suspense fallback={<PageLoader />}><Welcome /></Suspense> },
+      { path: 'login', element: <Suspense fallback={<PageLoader />}><Login /></Suspense> },
+      { path: 'signup', element: <Suspense fallback={<PageLoader />}><Signup /></Suspense> },
+      { path: 'subscribe', element: <Suspense fallback={<PageLoader />}><Subscribe /></Suspense> },
+      { path: 'install-claude', element: <Suspense fallback={<PageLoader />}><InstallClaude /></Suspense> },
+      { path: 'connect-claude', element: <Suspense fallback={<PageLoader />}><ConnectClaude /></Suspense> },
+      { path: 'design-system', element: <Suspense fallback={<PageLoader />}><DesignSystem /></Suspense> },
+      { path: 'demo/gates', element: <Suspense fallback={<PageLoader />}><DemoGates /></Suspense> },
+      { path: 'prototypes/dev-session', element: <Suspense fallback={<PageLoader />}><DevSessionPrototype /></Suspense> },
+      { path: 'prototypes/proof-dashboard', element: <Suspense fallback={<PageLoader />}><ProofDashboardPrototype /></Suspense> },
+      { path: 'prototypes/onboarding', element: <Suspense fallback={<PageLoader />}><OnboardingPrototype /></Suspense> },
+      { path: 'prototypes/onboarding-madlib', element: <Suspense fallback={<PageLoader />}><OnboardingMadlibPrototype /></Suspense> },
+    ],
+  },
+])

package/apps/dashboard/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />