refactor(server): 改用 Vite 原生 tsconfig 路径解析

- todo.router: create 错误码 NOT_FOUND → INTERNAL_SERVER_ERROR，remove 增加存在性检查
- __root: devtools 仅在 DEV 环境渲染
- Electron: 添加 will-navigate 导航拦截、显式安全 webPreferences、deny-all 权限请求
- sidecar: 空 catch 块补充意图注释，新增 lastResolvedUrl getter
- todo.contract: 硬编码 omit 改用 generatedFieldKeys
- router: QueryClient 添加 staleTime/retry 默认值
- turbo: build 任务精细化 inputs 提升缓存命中率
- fields: id() 改为模块私有

.sisyphus/plans/electrobun-prod-mode.md

@@ -1,798 +0,0 @@
-# Electrobun Desktop: Production Mode via Child Process Architecture
-
-## TL;DR
-
-> **Quick Summary**: Redesign the Electrobun desktop app to support production mode by spawning the TanStack Start server as a child process. Currently only dev mode works (hardcoded `localhost:3000`). The desktop will detect dev/prod mode, spawn the server with `PORT=0` in prod, parse the actual port from stdout, and open the BrowserWindow.
->
-> **Deliverables**:
-> - Rewritten `apps/desktop/src/bun/index.ts` with dev/prod mode support
-> - Updated `apps/desktop/electrobun.config.ts` with `build.copy` and platform configs
-> - Cross-workspace build dependency in turbo pipeline
-> - Updated `apps/desktop/AGENTS.md` reflecting new architecture
->
-> **Estimated Effort**: Medium
-> **Parallel Execution**: YES - 2 waves
-> **Critical Path**: Tasks 1,2,3 (parallel) → Task 4 → Task 5
-
----
-
-## Context
-
-### Original Request
-Redesign the Electrobun desktop app to support production mode. The desktop app should spawn the TanStack Start server as a child process, detect dev vs prod mode at runtime, use system-assigned ports for security, and handle server lifecycle (crash, quit).
-
-### Confirmed Decisions
-- **Architecture**: Desktop spawns server as child process via `Bun.spawn`
-- **Server artifact**: `.output/server/index.mjs` (not compiled binary) — Electrobun already bundles Bun
-- **Port strategy**: `PORT=0` (system-assigned), `HOST=127.0.0.1`
-- **Dev/Prod detection**: `process.env.ELECTROBUN_BUILD_ENV` (see Defaults Applied below)
-- **Target platforms**: All (Linux, macOS, Windows)
-- **DATABASE_URL**: Pass-through via env var, no special handling
-- **Crash handling**: MVP — log error to stderr, exit process
-
-### Research Findings
-
-**Electrobun APIs (verified from source code):**
-- `build.copy` supports paths outside the project directory (e.g., `../server/.output`). Source paths are resolved relative to the project root. Destinations map into `Resources/app/` in the bundle.
-- `PATHS` exported from `electrobun/bun` provides `RESOURCES_FOLDER` (absolute path to `Resources/`) and `VIEWS_FOLDER` (`Resources/app/views/`).
-- `process.execPath` in a bundled Electrobun app points to the bundled Bun binary.
-- `Electrobun.events.on('before-quit', callback)` fires before app quit. Callback receives an event with `response({ allow: false })` to cancel quit.
-- `ELECTROBUN_BUILD_ENV` is set by the Electrobun CLI: `"dev"` for `electrobun dev`, `"stable"` for `electrobun build --env=stable`.
-
-**Server startup behavior (verified from built output):**
-- `.output/server/index.mjs` uses `Bun.serve` via the `h3+srvx` adapter (Nitro bun preset).
-- Startup log format: `➜ Listening on: http://<address>:<port>/`
-- The log uses the actual assigned address/port, not the requested one. So `PORT=0` will log the real port.
-- `DATABASE_URL` is validated at startup via Zod (`@t3-oss/env-core`). Missing = immediate crash.
-- The `.output/server/` directory contains `index.mjs` plus `_libs/` with bundled dependencies.
-
-**Turbo pipeline:**
-- Root `turbo.json` has `build.dependsOn: ["^build"]` which only builds workspace *dependencies*.
-- Desktop does NOT depend on server in `package.json`, so `^build` won't trigger server build.
-- Need explicit cross-workspace dependency via desktop's `turbo.json`.
-
-### Metis Review
-**Identified Gaps** (addressed):
-- Dev/prod detection mechanism: Switched from custom `ELECTROBUN_DEV` to built-in `ELECTROBUN_BUILD_ENV`
-- Server startup timeout: Added explicit timeout with error reporting
-- Port parsing failure: Plan includes fallback and error handling
-- Server crash during runtime: Watching `subprocess.exited` promise
-- `cwd` for spawned server: Must set to server directory for relative import resolution
-- Cross-platform considerations: `ELECTROBUN_BUILD_ENV` works everywhere (no `cross-env` needed)
-
-### Unknowns Resolved
-
-| Unknown | Resolution |
-|---------|------------|
-| Does `build.copy` support paths outside project? | **YES** — uses `cpSync` with source resolved from project root. `../server/.output` works. |
-| Runtime API for resolving bundled resource paths? | **`PATHS.RESOURCES_FOLDER`** from `electrobun/bun`. Copied files land in `Resources/app/{dest}/`. |
-| Does Nitro log actual port with PORT=0? | **YES** — format: `➜ Listening on: http://<addr>:<port>/` via h3+srvx adapter. |
-| How does Electrobun detect dev mode? | **`ELECTROBUN_BUILD_ENV`** env var set by CLI. Values: `dev`, `canary`, `stable`. |
-
----
-
-## Work Objectives
-
-### Core Objective
-Enable the Electrobun desktop app to run in production mode by spawning the TanStack Start server as a managed child process, while preserving existing dev mode behavior.
-
-### Concrete Deliverables
-- `apps/desktop/src/bun/index.ts` — Complete rewrite with dual-mode support
-- `apps/desktop/electrobun.config.ts` — `build.copy` + all-platform configs
-- `apps/desktop/turbo.json` — Cross-workspace build dependency
-- `apps/desktop/AGENTS.md` — Accurate documentation of new architecture
-
-### Definition of Done
-- [ ] `bun typecheck` passes from monorepo root (zero errors)
-- [ ] `bun build` from root succeeds: server builds first, then desktop bundles server output
-- [ ] `bun dev` from root still starts both apps (dev mode preserved)
-- [ ] Desktop `index.ts` has zero hardcoded URLs (all dynamic)
-
-### Must Have
-- Dev mode: poll external `localhost:3000`, open window when ready (existing behavior, refactored)
-- Prod mode: spawn server via `Bun.spawn`, parse port from stdout, open window
-- Server bound to `127.0.0.1` only (no network exposure)
-- `PORT=0` for system-assigned port (no conflicts)
-- Server process killed on app quit (via `before-quit` event)
-- Server crash detection (watch `exited` promise, log error, exit app)
-- Startup timeout with clear error message
-- Server `cwd` set to its own directory (for relative import resolution)
-- `DATABASE_URL` passed through from parent environment
-
-### Must NOT Have (Guardrails)
-- No hardcoded port numbers (not even 3000 — use a named constant `DEV_SERVER_URL`)
-- No `as any`, `@ts-ignore`, or `@ts-expect-error`
-- No empty catch blocks — always handle or re-throw
-- No `npm`, `npx`, `node` — Bun only
-- No manual `useMemo`/`useCallback` (not relevant here, but per project rules)
-- No suppressed type errors — fix them properly
-- No custom env var for dev detection — use built-in `ELECTROBUN_BUILD_ENV`
-- No compiled server binary — use `.output/server/index.mjs` with bundled Bun
-- Do NOT edit `apps/server/` — only `apps/desktop/` files change
-- Do NOT add `@furtherverse/server` as a package dependency of desktop (use turbo cross-workspace dependency instead)
-
----
-
-## Verification Strategy
-
-> **UNIVERSAL RULE: ZERO HUMAN INTERVENTION**
->
-> ALL tasks in this plan MUST be verifiable WITHOUT any human action.
-> Every criterion is verified by running a command or using a tool.
-
-### Test Decision
-- **Infrastructure exists**: NO (no test framework in this project)
-- **Automated tests**: NO (per project state — `AGENTS.md` says "No test framework configured yet")
-- **Framework**: None
-- **Agent-Executed QA**: ALWAYS (mandatory for all tasks)
-
----
-
-## Execution Strategy
-
-### Parallel Execution Waves
-
-```
-Wave 1 (Start Immediately — all independent, different files):
-├── Task 1: Update electrobun.config.ts (build.copy + platform configs)
-├── Task 2: Update turbo.json (cross-workspace build dependency)
-└── Task 3: Rewrite index.ts (complete dev/prod mode implementation)
-
-Wave 2 (After Wave 1 — needs final state of all files):
-├── Task 4: Rewrite AGENTS.md (documentation reflecting new architecture)
-└── Task 5: End-to-end verification (typecheck + build pipeline)
-```
-
-### Dependency Matrix
-
-| Task | Depends On | Blocks | Can Parallelize With |
-|------|------------|--------|---------------------|
-| 1 | None | 4, 5 | 2, 3 |
-| 2 | None | 4, 5 | 1, 3 |
-| 3 | None | 4, 5 | 1, 2 |
-| 4 | 1, 2, 3 | 5 | None |
-| 5 | 1, 2, 3, 4 | None | None (final) |
-
-### Agent Dispatch Summary
-
-| Wave | Tasks | Recommended Agents |
-|------|-------|-------------------|
-| 1 | 1, 2, 3 | Tasks 1,2: `delegate_task(category="quick")`. Task 3: `delegate_task(category="unspecified-high")` |
-| 2 | 4, 5 | Task 4: `delegate_task(category="writing")`. Task 5: `delegate_task(category="quick")` |
-
----
-
-## TODOs
-
-- [ ] 1. Update `apps/desktop/electrobun.config.ts` — Add build.copy and platform configs
-
-  **What to do**:
-  - Add `build.copy` to include the server's Nitro build output in the desktop bundle:
-    ```typescript
-    copy: {
-      '../server/.output': 'server-output',
-    }
-    ```
-    This copies `apps/server/.output/` (the entire Nitro build output) into `Resources/app/server-output/` in the Electrobun bundle. The full server entry point will be at `Resources/app/server-output/server/index.mjs`.
-  - Add `macOS` platform config block (currently only `linux` exists):
-    ```typescript
-    macOS: {
-      bundleCEF: true,
-    }
-    ```
-  - Add `windows` platform config block:
-    ```typescript
-    windows: {
-      bundleCEF: true,
-    }
-    ```
-  - Verify the exact property names by checking Electrobun's `ElectrobunConfig` type definition. The `linux` block already uses `bundleCEF: true`, so follow the same pattern for other platforms. If the type doesn't support `macOS`/`windows` yet, skip those and leave a `// TODO:` comment explaining what's needed.
-  - Preserve existing config values exactly (app name, identifier, version, bun entrypoint, linux config).
-
-  **Must NOT do**:
-  - Do not change the app name, identifier, or version
-  - Do not change the bun entrypoint path
-  - Do not remove the existing `linux` config
-  - Do not add dependencies or scripts
-
-  **Recommended Agent Profile**:
-  - **Category**: `quick`
-    - Reason: Single file, small config change, clear specification
-  - **Skills**: `[]`
-    - No specialized skills needed — straightforward TypeScript config edit
-  - **Skills Evaluated but Omitted**:
-    - `frontend-ui-ux`: No UI work involved
-
-  **Parallelization**:
-  - **Can Run In Parallel**: YES
-  - **Parallel Group**: Wave 1 (with Tasks 2, 3)
-  - **Blocks**: Tasks 4, 5
-  - **Blocked By**: None (can start immediately)
-
-  **References**:
-
-  **Pattern References** (existing code to follow):
-  - `apps/desktop/electrobun.config.ts` — Current config structure. The `linux.bundleCEF: true` pattern should be replicated for other platforms. The `build.bun.entrypoint` key shows where build config lives.
-
-  **API/Type References** (contracts to implement against):
-  - The `ElectrobunConfig` type from `electrobun` — imported via `import type { ElectrobunConfig } from 'electrobun'`. Check its definition (likely in `node_modules/electrobun/`) to verify exact property names for `copy`, `macOS`, `windows`.
-
-  **External References**:
-  - Electrobun `build.copy` syntax: copies source (relative to project root) into `Resources/app/{dest}/` in the bundle. Uses `cpSync` with `dereference: true`.
-
-  **WHY Each Reference Matters**:
-  - `electrobun.config.ts`: You're editing this file — need to know its current shape to preserve existing values
-  - `ElectrobunConfig` type: Must match the type definition exactly — don't guess property names
-
-  **Acceptance Criteria**:
-  - [ ] `build.copy` key exists with `'../server/.output': 'server-output'` mapping
-  - [ ] Platform configs added for all three platforms (or TODO comments if types don't support them)
-  - [ ] Existing config values unchanged (app.name = 'Desktop', etc.)
-  - [ ] File passes `bun typecheck` (no type errors)
-
-  **Agent-Executed QA Scenarios:**
-
-  ```
-  Scenario: Config file is valid TypeScript with correct types
-    Tool: Bash
-    Preconditions: None
-    Steps:
-      1. Run: bun typecheck (from apps/desktop/)
-      2. Assert: Exit code 0
-      3. Assert: No errors mentioning electrobun.config.ts
-    Expected Result: TypeScript compilation succeeds
-    Evidence: Terminal output captured
-
-  Scenario: build.copy key has correct structure
-    Tool: Bash (grep)
-    Preconditions: File has been edited
-    Steps:
-      1. Read apps/desktop/electrobun.config.ts
-      2. Assert: Contains '../server/.output'
-      3. Assert: Contains 'server-output'
-      4. Assert: File still contains 'satisfies ElectrobunConfig'
-    Expected Result: Config has copy mapping and type annotation
-    Evidence: File contents
-  ```
-
-  **Commit**: YES (groups with 2)
-  - Message: `feat(desktop): add build.copy for server bundle and platform configs`
-  - Files: `apps/desktop/electrobun.config.ts`
-  - Pre-commit: `bun typecheck` (from `apps/desktop/`)
-
----
-
-- [ ] 2. Update `apps/desktop/turbo.json` — Add cross-workspace build dependency
-
-  **What to do**:
-  - Add `dependsOn` to the existing `build` task to ensure the server builds before the desktop:
-    ```json
-    {
-      "tasks": {
-        "build": {
-          "dependsOn": ["@furtherverse/server#build"],
-          "outputs": ["build/**", "artifacts/**"]
-        }
-      }
-    }
-    ```
-  - This tells Turbo: "before running `build` for `@furtherverse/desktop`, first run `build` for `@furtherverse/server`."
-  - This ensures `apps/server/.output/` exists when `electrobun build` runs and tries to `build.copy` from `../server/.output`.
-  - Preserve the existing `outputs` array exactly.
-
-  **Must NOT do**:
-  - Do not modify the root `turbo.json` — only `apps/desktop/turbo.json`
-  - Do not remove existing `outputs`
-  - Do not add other tasks or change other config
-
-  **Recommended Agent Profile**:
-  - **Category**: `quick`
-    - Reason: Single file, one-line JSON change
-  - **Skills**: `[]`
-    - No specialized skills needed
-  - **Skills Evaluated but Omitted**:
-    - `git-master`: Commit will be grouped with Task 1
-
-  **Parallelization**:
-  - **Can Run In Parallel**: YES
-  - **Parallel Group**: Wave 1 (with Tasks 1, 3)
-  - **Blocks**: Tasks 4, 5
-  - **Blocked By**: None (can start immediately)
-
-  **References**:
-
-  **Pattern References** (existing code to follow):
-  - `apps/desktop/turbo.json` — Current file with `build.outputs` already defined. You're adding `dependsOn` alongside it.
-  - `turbo.json` (root) — Shows existing turbo patterns like `build.dependsOn: ["^build"]`. The root already uses `^build` for workspace dependencies, but since desktop doesn't list server as a package dependency, we need an explicit cross-workspace reference.
-
-  **API/Type References**:
-  - Turbo `dependsOn` syntax: `"@furtherverse/server#build"` means "run the `build` task in the `@furtherverse/server` workspace".
-
-  **Documentation References**:
-  - `apps/server/package.json` — The package name is `@furtherverse/server` (verify this is the exact name used in the `dependsOn` reference).
-
-  **WHY Each Reference Matters**:
-  - `apps/desktop/turbo.json`: You're editing this file — preserve existing outputs
-  - `apps/server/package.json`: Need exact package name for the cross-workspace reference
-  - Root `turbo.json`: Context for existing turbo patterns in this project
-
-  **Acceptance Criteria**:
-  - [ ] `apps/desktop/turbo.json` has `dependsOn: ["@furtherverse/server#build"]` in the build task
-  - [ ] Existing `outputs` array is preserved
-  - [ ] Valid JSON (no syntax errors)
-
-  **Agent-Executed QA Scenarios:**
-
-  ```
-  Scenario: turbo.json is valid JSON with correct structure
-    Tool: Bash
-    Preconditions: File has been edited
-    Steps:
-      1. Run: bun -e "JSON.parse(require('fs').readFileSync('apps/desktop/turbo.json', 'utf8'))"
-      2. Assert: Exit code 0 (valid JSON)
-      3. Read the file and verify structure contains both dependsOn and outputs
-    Expected Result: Valid JSON with both keys present
-    Evidence: Terminal output captured
-
-  Scenario: Turbo resolves the cross-workspace dependency
-    Tool: Bash
-    Preconditions: turbo.json updated
-    Steps:
-      1. Run: bunx turbo build --dry-run --filter=@furtherverse/desktop (from monorepo root)
-      2. Assert: Output shows @furtherverse/server#build runs BEFORE @furtherverse/desktop#build
-    Expected Result: Server build is listed as a dependency in the dry-run output
-    Evidence: Terminal output showing task execution order
-  ```
-
-  **Commit**: YES (groups with 1)
-  - Message: `feat(desktop): add build.copy for server bundle and platform configs`
-  - Files: `apps/desktop/turbo.json`
-  - Pre-commit: Valid JSON check
-
----
-
-- [ ] 3. Rewrite `apps/desktop/src/bun/index.ts` — Complete dev/prod mode implementation
-
-  **What to do**:
-
-  This is the core task. Completely rewrite `index.ts` to support both dev and prod modes. The new file should have this structure:
-
-  **A. Imports and Constants**:
-  ```typescript
-  import Electrobun, { BrowserWindow } from 'electrobun/bun'
-  // Import PATHS — verify exact import syntax from electrobun/bun type definitions
-  // It may be: import { PATHS } from 'electrobun/bun'
-  // Or it may be on the Electrobun default export: Electrobun.PATHS
-  // CHECK the type definitions in node_modules/electrobun/ before writing
-  import { join, dirname } from 'path'
-
-  const DEV_SERVER_URL = 'http://localhost:3000'
-  const SERVER_READY_TIMEOUT_MS = 30_000
-  const PORT_PATTERN = /Listening on:?\s*https?:\/\/[^\s:]+:(\d+)/
-  ```
-
-  **B. `isDev()` function**:
-  - Check `process.env.ELECTROBUN_BUILD_ENV === 'dev'`
-  - If `ELECTROBUN_BUILD_ENV` is not set, default to `true` (dev mode) — safe fallback
-  - Return a boolean
-
-  **C. `getServerEntryPath()` function**:
-  - Use `PATHS.RESOURCES_FOLDER` (or equivalent) to resolve the bundled server entry
-  - Path: `join(PATHS.RESOURCES_FOLDER, 'app', 'server-output', 'server', 'index.mjs')`
-  - **IMPORTANT**: Verify `PATHS.RESOURCES_FOLDER` points to `Resources/` and that `build.copy` destinations land in `Resources/app/`. If the pathing is different, adjust accordingly. The executor MUST verify by checking Electrobun's source or type definitions.
-
-  **D. `waitForServer(url, timeoutMs)` function** (preserved from current code):
-  - Polls a URL with `fetch` HEAD requests
-  - Returns `true` when server responds with `response.ok`
-  - Returns `false` on timeout
-  - Uses `Bun.sleep(100)` between attempts
-  - Catches fetch errors silently (server not up yet)
-
-  **E. `spawnServer()` function** (NEW — the critical piece):
-  - Returns a `Promise<{ process: Subprocess; url: string }>`
-  - Implementation:
-    1. Resolve the server entry path via `getServerEntryPath()`
-    2. Resolve the server directory via `dirname(serverEntryPath)` — used as `cwd`
-    3. Spawn with `Bun.spawn`:
-       ```typescript
-       const serverProc = Bun.spawn([process.execPath, serverEntryPath], {
-         cwd: serverDir,
-         env: {
-           ...process.env,
-           PORT: '0',
-           HOST: '127.0.0.1',
-         },
-         stdout: 'pipe',
-         stderr: 'pipe',
-       })
-       ```
-    4. Read stdout as a stream to find the port:
-       - Use `serverProc.stdout` (a `ReadableStream<Uint8Array>`)
-       - Create a reader, accumulate chunks into a text buffer
-       - Test buffer against `PORT_PATTERN` regex after each chunk
-       - When match found: extract port, resolve promise with `{ process: serverProc, url: 'http://127.0.0.1:${port}' }`
-    5. Implement a timeout:
-       - Use `setTimeout` to reject the promise after `SERVER_READY_TIMEOUT_MS`
-       - On timeout, kill the server process before rejecting
-    6. Handle early exit:
-       - If stdout ends (stream done) before port is found, reject with error
-       - Include any stderr output in the error message for debugging
-
-  **F. `main()` async function**:
-  - Log startup message
-  - Branch on `isDev()`:
-    - **Dev mode**:
-      1. Log: "Dev mode: waiting for external server..."
-      2. Call `waitForServer(DEV_SERVER_URL)`
-      3. If timeout: log error with instructions (`"Run: bun dev in apps/server"`), `process.exit(1)`
-      4. Set `serverUrl = DEV_SERVER_URL`
-    - **Prod mode**:
-      1. Log: "Production mode: starting embedded server..."
-      2. Call `spawnServer()`
-      3. If error: log error, `process.exit(1)`
-      4. Store returned `process` and `url`
-  - Create `BrowserWindow` with the resolved `serverUrl`:
-    ```typescript
-    new BrowserWindow({
-      title: 'Furtherverse',
-      url: serverUrl,
-      frame: { x: 100, y: 100, width: 1200, height: 800 },
-      renderer: 'cef',
-    })
-    ```
-  - Register lifecycle handlers:
-    - `Electrobun.events.on('before-quit', ...)`: Kill server process if it exists
-    - Watch `serverProcess.exited` (if in prod mode): When server exits unexpectedly, log the exit code and stderr, then `process.exit(1)`
-
-  **G. Top-level execution**:
-  ```typescript
-  main().catch((error) => {
-    console.error('Failed to start:', error)
-    process.exit(1)
-  })
-  ```
-
-  **Critical implementation details**:
-  - The `PORT_PATTERN` regex must handle multiple log formats:
-    - `➜ Listening on: http://localhost:54321/` (srvx format)
-    - `Listening on http://127.0.0.1:54321` (node-server format)
-    - `Listening on http://[::]:54321` (IPv6 format)
-  - The regex `/Listening on:?\s*https?:\/\/[^\s:]+:(\d+)/` captures the port from all these formats.
-  - `cwd` MUST be set to the server directory (`dirname(serverEntryPath)`), not the app root. Nitro resolves internal `_libs/` imports relative to its directory.
-  - `process.execPath` in an Electrobun bundle points to the bundled Bun binary — this is what runs the server.
-  - `stderr: 'pipe'` — capture stderr for crash diagnostics but don't block on it during startup.
-
-  **Must NOT do**:
-  - Do not hardcode port numbers anywhere (use `PORT=0` and parse result)
-  - Do not use `as any` or type assertions to work around issues
-  - Do not use `child_process` module — use `Bun.spawn` (native Bun API)
-  - Do not bind server to `0.0.0.0` — always use `127.0.0.1`
-  - Do not leave the `waitForServer` function unused in dev mode
-  - Do not use synchronous I/O for stdout reading
-
-  **Recommended Agent Profile**:
-  - **Category**: `unspecified-high`
-    - Reason: Complex async logic (stream parsing, subprocess lifecycle, timeout management), multiple code paths (dev/prod), error handling across process boundaries. This is the architectural centerpiece.
-  - **Skills**: `[]`
-    - No specialized skills needed — pure Bun/TypeScript with Electrobun APIs
-  - **Skills Evaluated but Omitted**:
-    - `frontend-ui-ux`: No UI work — this is backend/process management code
-    - `playwright`: No browser testing needed for this task
-
-  **Parallelization**:
-  - **Can Run In Parallel**: YES
-  - **Parallel Group**: Wave 1 (with Tasks 1, 2)
-  - **Blocks**: Tasks 4, 5
-  - **Blocked By**: None (can start immediately — edits a different file from Tasks 1, 2)
-
-  **References**:
-
-  **Pattern References** (existing code to follow):
-  - `apps/desktop/src/bun/index.ts` — Current implementation. Preserve the `waitForServer` polling pattern (slightly refactored). Keep the `BrowserWindow` config (title, frame dimensions, renderer). Keep the top-level `main().catch(...)` pattern.
-  - `apps/desktop/src/bun/index.ts:1` — Current import: `import Electrobun, { BrowserWindow } from 'electrobun/bun'`. Extend this to also import `PATHS` (verify exact export name from type definitions).
-
-  **API/Type References** (contracts to implement against):
-  - `electrobun/bun` module — Exports `Electrobun` (default), `BrowserWindow` (named), and `PATHS` (named — verify). Check `node_modules/electrobun/` for exact type definitions.
-  - `Bun.spawn` API — Returns `Subprocess` with `.stdout` (ReadableStream when piped), `.stderr`, `.exited` (Promise<number>), `.kill()`.
-  - `PATHS.RESOURCES_FOLDER` — Absolute path to `Resources/` directory in the bundle. Verify by reading the Paths.ts source in electrobun package.
-
-  **Documentation References**:
-  - `apps/desktop/AGENTS.md` — Mentions production mode architecture (aspirational, but gives intent)
-
-  **External References**:
-  - Electrobun lifecycle events: `Electrobun.events.on('before-quit', callback)` — callback can call `event.response({ allow: false })` to cancel. Source: `electrobun/src/bun/core/Utils.ts`.
-  - Electrobun `PATHS`: Source at `electrobun/src/bun/core/Paths.ts`. Contains `RESOURCES_FOLDER` and `VIEWS_FOLDER`.
-  - Bun `Subprocess` docs: `stdout` is `ReadableStream<Uint8Array>` when `stdout: 'pipe'`.
-
-  **WHY Each Reference Matters**:
-  - Current `index.ts`: Preserving the `waitForServer` pattern, `BrowserWindow` config, and error handling style. You're rewriting this file, so understand what to keep vs. replace.
-  - `electrobun/bun` types: MUST verify `PATHS` export name and shape before using it. Don't assume — check.
-  - `Bun.spawn` API: Core to the entire prod mode implementation. Understand `stdout` stream reading.
-  - Lifecycle events: `before-quit` is where server cleanup happens. Understand the event contract.
-
-  **Acceptance Criteria**:
-  - [ ] File compiles: `bun typecheck` passes (from `apps/desktop/`)
-  - [ ] No hardcoded port numbers (grep for `:3000` — should only appear in `DEV_SERVER_URL` constant)
-  - [ ] `isDev()` function uses `process.env.ELECTROBUN_BUILD_ENV`
-  - [ ] `spawnServer()` uses `PORT=0`, `HOST=127.0.0.1`, `process.execPath`
-  - [ ] `spawnServer()` sets `cwd` to `dirname(serverEntryPath)`
-  - [ ] `before-quit` handler kills server process
-  - [ ] Server crash watcher exists (watches `subprocess.exited`)
-  - [ ] Timeout handling exists in both dev and prod paths
-  - [ ] All Biome rules pass: `bun fix` produces no changes
-
-  **Agent-Executed QA Scenarios:**
-
-  ```
-  Scenario: File compiles with zero type errors
-    Tool: Bash
-    Preconditions: File has been rewritten
-    Steps:
-      1. Run: bun typecheck (from apps/desktop/)
-      2. Assert: Exit code 0
-      3. Assert: No errors in output
-    Expected Result: Clean TypeScript compilation
-    Evidence: Terminal output captured
-
-  Scenario: No hardcoded ports outside DEV_SERVER_URL
-    Tool: Bash (grep)
-    Preconditions: File has been rewritten
-    Steps:
-      1. Search apps/desktop/src/bun/index.ts for literal ':3000'
-      2. Assert: Only occurrence is in the DEV_SERVER_URL constant definition
-      3. Search for literal '3000' — should only appear once
-    Expected Result: Port 3000 only in constant, nowhere else
-    Evidence: Grep output
-
-  Scenario: Code passes Biome lint/format
-    Tool: Bash
-    Preconditions: File has been rewritten
-    Steps:
-      1. Run: bun fix (from apps/desktop/)
-      2. Run: git diff apps/desktop/src/bun/index.ts
-      3. Assert: No diff (bun fix made no changes)
-    Expected Result: Code already conforms to Biome rules
-    Evidence: Empty git diff
-
-  Scenario: Required patterns present in source
-    Tool: Bash (grep)
-    Preconditions: File has been rewritten
-    Steps:
-      1. Grep for 'ELECTROBUN_BUILD_ENV' — Assert: found
-      2. Grep for 'Bun.spawn' — Assert: found
-      3. Grep for 'process.execPath' — Assert: found
-      4. Grep for 'PORT.*0' — Assert: found
-      5. Grep for '127.0.0.1' — Assert: found
-      6. Grep for 'before-quit' — Assert: found
-      7. Grep for '.exited' — Assert: found (crash watcher)
-      8. Grep for 'dirname' — Assert: found (cwd for server)
-    Expected Result: All required patterns present
-    Evidence: Grep results for each pattern
-  ```
-
-  **Commit**: YES
-  - Message: `feat(desktop): implement production mode with child process server`
-  - Files: `apps/desktop/src/bun/index.ts`
-  - Pre-commit: `bun typecheck && bun fix`
-
----
-
-- [ ] 4. Rewrite `apps/desktop/AGENTS.md` — Document new architecture
-
-  **What to do**:
-  - Completely rewrite `AGENTS.md` to reflect the actual implemented architecture
-  - Document:
-    - **Architecture overview**: Desktop spawns server as child process in prod, connects to external server in dev
-    - **Dev mode**: How it works (polls localhost:3000, requires server running separately)
-    - **Prod mode**: How it works (spawns server from bundle, PORT=0, parses port from stdout)
-    - **Environment detection**: `ELECTROBUN_BUILD_ENV` values (`dev`, `canary`, `stable`)
-    - **Build pipeline**: Server must build before desktop (turbo dependency), `build.copy` bundles output
-    - **Key files**: `src/bun/index.ts` (main process), `electrobun.config.ts` (build config)
-    - **Environment variables**: `DATABASE_URL` (required, passed to server), `ELECTROBUN_BUILD_ENV` (auto-set by CLI)
-    - **Server lifecycle**: Spawned on start, killed on quit, crash = exit
-    - **Commands**: `bun dev`, `bun build`, `bun typecheck`, `bun fix`
-  - Follow the style and conventions of the root `AGENTS.md` and `apps/server/AGENTS.md`
-  - Be factual — only document what actually exists, not aspirational features
-
-  **Must NOT do**:
-  - Do not document features that don't exist
-  - Do not copy content from the server's AGENTS.md verbatim
-  - Do not include implementation details that belong in code comments
-
-  **Recommended Agent Profile**:
-  - **Category**: `writing`
-    - Reason: Documentation task requiring clear technical writing
-  - **Skills**: `[]`
-    - No specialized skills needed
-  - **Skills Evaluated but Omitted**:
-    - `frontend-ui-ux`: Not a UI task
-
-  **Parallelization**:
-  - **Can Run In Parallel**: NO
-  - **Parallel Group**: Wave 2
-  - **Blocks**: Task 5
-  - **Blocked By**: Tasks 1, 2, 3 (needs to know final state of all files)
-
-  **References**:
-
-  **Pattern References** (existing code to follow):
-  - `AGENTS.md` (root) — Follow same structure: Overview, Build Commands, Code Style, Directory Structure sections
-  - `apps/server/AGENTS.md` — Follow same style for app-specific documentation. Use this as a template for tone and detail level.
-
-  **Content References** (what to document):
-  - `apps/desktop/src/bun/index.ts` — The rewritten file (Task 3 output). Document its behavior, not its code.
-  - `apps/desktop/electrobun.config.ts` — The updated config (Task 1 output). Document build.copy and platform configs.
-  - `apps/desktop/turbo.json` — The updated turbo config (Task 2 output). Document the build dependency.
-
-  **WHY Each Reference Matters**:
-  - Root `AGENTS.md`: Template for documentation style
-  - Server `AGENTS.md`: Template for app-specific docs
-  - All Task 1-3 outputs: The actual implemented behavior that must be accurately documented
-
-  **Acceptance Criteria**:
-  - [ ] File exists and is valid Markdown
-  - [ ] Documents dev mode behavior accurately
-  - [ ] Documents prod mode behavior accurately
-  - [ ] Documents `ELECTROBUN_BUILD_ENV` mechanism
-  - [ ] Documents build pipeline (server → desktop dependency)
-  - [ ] Documents `DATABASE_URL` requirement
-  - [ ] Does NOT mention features that don't exist
-  - [ ] Follows conventions from root `AGENTS.md`
-
-  **Agent-Executed QA Scenarios:**
-
-  ```
-  Scenario: AGENTS.md contains all required sections
-    Tool: Bash (grep)
-    Preconditions: File has been rewritten
-    Steps:
-      1. Grep for 'dev' or 'Dev' — Assert: found (dev mode documented)
-      2. Grep for 'prod' or 'Prod' or 'production' — Assert: found (prod mode documented)
-      3. Grep for 'ELECTROBUN_BUILD_ENV' — Assert: found
-      4. Grep for 'DATABASE_URL' — Assert: found
-      5. Grep for 'child process' or 'spawn' — Assert: found (architecture documented)
-      6. Grep for 'bun dev' — Assert: found (commands documented)
-      7. Grep for 'bun build' — Assert: found (commands documented)
-    Expected Result: All key topics are covered
-    Evidence: Grep results
-
-  Scenario: No aspirational/unimplemented features documented
-    Tool: Bash (grep)
-    Preconditions: File has been rewritten
-    Steps:
-      1. Grep for 'TODO' or 'planned' or 'future' or 'coming soon' — Assert: not found (or minimal)
-      2. Grep for 'auto-update' — Assert: not found (not implemented)
-      3. Grep for 'tray' — Assert: not found (not implemented)
-    Expected Result: Only implemented features documented
-    Evidence: Grep results showing no aspirational content
-  ```
-
-  **Commit**: YES
-  - Message: `docs(desktop): rewrite AGENTS.md to reflect production mode architecture`
-  - Files: `apps/desktop/AGENTS.md`
-  - Pre-commit: None (Markdown file)
-
----
-
-- [ ] 5. End-to-end verification — Typecheck and build pipeline
-
-  **What to do**:
-  - Run full monorepo typecheck to ensure no type errors were introduced
-  - Run full monorepo build to verify:
-    1. Server builds first (produces `.output/`)
-    2. Desktop builds second (copies server output into bundle)
-    3. No build errors
-  - Run Biome formatting/linting check on all changed files
-  - Verify dev mode still works conceptually (no runtime test — just verify the code path exists)
-
-  **Must NOT do**:
-  - Do not fix issues in server code — only desktop code
-  - Do not modify any files unless fixing issues found during verification
-  - Do not skip any verification step
-
-  **Recommended Agent Profile**:
-  - **Category**: `quick`
-    - Reason: Running commands and checking output, no creative work
-  - **Skills**: `[]`
-    - No specialized skills needed
-  - **Skills Evaluated but Omitted**:
-    - `playwright`: No browser testing in this verification
-
-  **Parallelization**:
-  - **Can Run In Parallel**: NO
-  - **Parallel Group**: Wave 2 (sequential after Task 4)
-  - **Blocks**: None (final task)
-  - **Blocked By**: Tasks 1, 2, 3, 4
-
-  **References**:
-
-  **Documentation References**:
-  - `AGENTS.md` (root) — Build/Lint/Test commands: `bun typecheck`, `bun fix`, `bun build`
-  - `apps/desktop/package.json` — Desktop-specific scripts
-
-  **WHY Each Reference Matters**:
-  - Root `AGENTS.md`: Canonical list of verification commands
-  - Desktop `package.json`: Desktop-specific build/typecheck commands
-
-  **Acceptance Criteria**:
-  - [ ] `bun typecheck` (monorepo root) exits with code 0
-  - [ ] `bun build` (monorepo root) exits with code 0
-  - [ ] `bun fix` (monorepo root) produces no changes (all code formatted)
-  - [ ] Build output shows server building before desktop
-  - [ ] Desktop build output includes server bundle (verify in build artifacts)
-
-  **Agent-Executed QA Scenarios:**
-
-  ```
-  Scenario: Monorepo typecheck passes
-    Tool: Bash
-    Preconditions: All tasks 1-4 completed
-    Steps:
-      1. Run: bun typecheck (from monorepo root)
-      2. Assert: Exit code 0
-      3. Assert: No error output
-    Expected Result: Zero type errors across entire monorepo
-    Evidence: Terminal output captured
-
-  Scenario: Monorepo build succeeds with correct order
-    Tool: Bash
-    Preconditions: All tasks 1-4 completed
-    Steps:
-      1. Run: bun build (from monorepo root)
-      2. Assert: Exit code 0
-      3. Assert: Output shows @furtherverse/server build task runs
-      4. Assert: Output shows @furtherverse/desktop build task runs AFTER server
-    Expected Result: Build pipeline executes in correct order
-    Evidence: Terminal output showing task order
-
-  Scenario: Biome finds no issues
-    Tool: Bash
-    Preconditions: All tasks 1-4 completed
-    Steps:
-      1. Run: bun fix (from monorepo root)
-      2. Run: git diff
-      3. Assert: No changes (all code already formatted)
-    Expected Result: All code passes Biome rules
-    Evidence: Empty git diff
-
-  Scenario: Desktop build artifacts include server bundle
-    Tool: Bash
-    Preconditions: Build succeeded
-    Steps:
-      1. Search desktop build output directory for server-output/ or index.mjs
-      2. Assert: Server files are present in the desktop bundle
-    Expected Result: Server bundle is included in desktop build output
-    Evidence: File listing of build artifacts
-  ```
-
-  **Commit**: NO (verification only — no file changes unless fixing issues)
-
----
-
-## Commit Strategy
-
-| After Task(s) | Message | Files | Verification |
-|---------------|---------|-------|--------------|
-| 1, 2 | `feat(desktop): add build.copy for server bundle and cross-workspace build dependency` | `electrobun.config.ts`, `turbo.json` | `bun typecheck` |
-| 3 | `feat(desktop): implement production mode with child process server` | `src/bun/index.ts` | `bun typecheck && bun fix` |
-| 4 | `docs(desktop): rewrite AGENTS.md to reflect production mode architecture` | `AGENTS.md` | None |
-| 5 | (no commit — verification only) | — | — |
-
----
-
-## Success Criteria
-
-### Verification Commands
-```bash
-bun typecheck          # Expected: exit 0, no errors
-bun build              # Expected: exit 0, server builds before desktop
-bun fix                # Expected: no changes (already formatted)
-```
-
-### Final Checklist
-- [ ] All "Must Have" features present in `index.ts`
-- [ ] All "Must NOT Have" exclusions verified absent
-- [ ] All 3 verification commands pass
-- [ ] `AGENTS.md` accurately reflects implemented architecture
-- [ ] Server output is bundled into desktop build via `build.copy`
-- [ ] Turbo builds server before desktop

.vscode/extensions.json

@@ -2,11 +2,8 @@
   "recommendations": [
     "biomejs.biome",
     "hverlin.mise-vscode",
-    "mikestead.dotenv",
     "oven.bun-vscode",
     "redhat.vscode-yaml",
-    "rust-lang.rust-analyzer",
-    "tamasfe.even-better-toml",
-    "tauri-apps.tauri-vscode"
+    "tamasfe.even-better-toml"
   ]
 }

.vscode/settings.json

@@ -1,49 +1,42 @@
 {
-  // Disable the default formatter & linter, use biome instead
-  "prettier.enable": false,
-  "eslint.enable": false,
-
-  // Auto fix
-  "editor.codeActionsOnSave": {
-    "source.fixAll.biome": "explicit",
-    "source.organizeImports.biome": "explicit"
-  },
-  "editor.defaultFormatter": "biomejs.biome",
-  "editor.formatOnSave": true,
   "[javascript]": {
     "editor.defaultFormatter": "biomejs.biome"
   },
   "[javascriptreact]": {
     "editor.defaultFormatter": "biomejs.biome"
   },
-  "[typescript]": {
-    "editor.defaultFormatter": "biomejs.biome"
-  },
-  "[typescriptreact]": {
-    "editor.defaultFormatter": "biomejs.biome"
-  },
   "[json]": {
     "editor.defaultFormatter": "biomejs.biome"
   },
   "[jsonc]": {
     "editor.defaultFormatter": "biomejs.biome"
   },
-  "[yaml]": {
-    "editor.defaultFormatter": "redhat.vscode-yaml"
-  },
   "[toml]": {
     "editor.defaultFormatter": "tamasfe.even-better-toml"
   },
+  "[typescript]": {
+    "editor.defaultFormatter": "biomejs.biome"
+  },
+  "[typescriptreact]": {
+    "editor.defaultFormatter": "biomejs.biome"
+  },
+  "[yaml]": {
+    "editor.defaultFormatter": "redhat.vscode-yaml"
+  },
+  "editor.codeActionsOnSave": {
+    "source.fixAll.biome": "explicit",
+    "source.organizeImports.biome": "explicit"
+  },
+  "editor.defaultFormatter": "biomejs.biome",
+  "editor.formatOnSave": true,
   "files.associations": {
     ".env": "dotenv",
     ".env.*": "dotenv",
-    "**/tsconfig.json": "jsonc",
-    "**/tsconfig.*.json": "jsonc",
     "**/biome.json": "jsonc",
-    "**/opencode.json": "jsonc"
+    "**/opencode.json": "jsonc",
+    "**/tsconfig.*.json": "jsonc",
+    "**/tsconfig.json": "jsonc"
   },
-
-  // TanStack Router
   "files.readonlyInclude": {
     "**/routeTree.gen.ts": true
   },

AGENTS.md

@@ -4,48 +4,71 @@ Guidelines for AI agents working in this Bun monorepo.
 
 ## Project Overview
 
-> **This project uses [Bun](https://bun.sh) exclusively as both the JavaScript runtime and package manager. Do NOT use Node.js / npm / yarn / pnpm. All commands start with `bun` — use `bun install` for dependencies and `bun run` / `bun <script>` for scripts. Never use `npm`, `npx`, or `node`.**
+> **This project uses [Bun](https://bun.sh) exclusively as both the JavaScript runtime and package manager. Do NOT use Node.js / npm / yarn / pnpm. All commands start with `bun` — use `bun install` for dependencies and `bun run <script>` for scripts. Always prefer `bun run <script>` over `bun <script>` to avoid conflicts with Bun built-in subcommands (e.g. `bun build` invokes Bun's bundler, NOT your package.json script). Never use `npm`, `npx`, or `node`.**
 
 - **Monorepo**: Bun workspaces + Turborepo orchestration
 - **Runtime**: Bun (see `mise.toml` for version) — **NOT Node.js**
 - **Package Manager**: Bun — **NOT npm / yarn / pnpm**
 - **Apps**:
   - `apps/server` - TanStack Start fullstack web app (see `apps/server/AGENTS.md`)
-  - `apps/desktop` - Electrobun desktop shell, loads server in native window (see `apps/desktop/AGENTS.md`)
-- **Packages**: `packages/utils`, `packages/tsconfig` (shared configs)
+  - `apps/desktop` - Electron desktop shell, sidecar server pattern (see `apps/desktop/AGENTS.md`)
+- **Packages**: `packages/tsconfig` (shared TS configs)
 
 ## Build / Lint / Test Commands
 
 ### Root Commands (via Turbo)
 ```bash
-bun dev            # Start all apps in dev mode
-bun build          # Build all apps
-bun fix            # Lint + format (Biome auto-fix)
-bun typecheck      # TypeScript check across monorepo
+bun run dev              # Start all apps in dev mode
+bun run build            # Build all apps
+bun run compile          # Compile server to standalone binary (current platform)
+bun run compile:darwin   # Compile server for macOS (arm64 + x64)
+bun run compile:linux    # Compile server for Linux (x64 + arm64)
+bun run compile:windows  # Compile server for Windows x64
+bun run dist             # Package desktop distributable (current platform)
+bun run dist:linux       # Package desktop for Linux (x64 + arm64)
+bun run dist:mac         # Package desktop for macOS (arm64 + x64)
+bun run dist:win         # Package desktop for Windows x64
+bun run fix              # Lint + format (Biome auto-fix)
+bun run typecheck        # TypeScript check across monorepo
 ```
 
 ### Server App (`apps/server`)
 ```bash
-bun dev                   # Vite dev server (localhost:3000)
-bun build                 # Production build -> .output/
-bun compile               # Compile to standalone binary
-bun fix                   # Biome auto-fix
-bun typecheck             # TypeScript check
+bun run dev                   # Vite dev server (localhost:3000)
+bun run build                 # Production build -> .output/
+bun run compile               # Compile to standalone binary (current platform)
+bun run compile:darwin        # Compile for macOS (arm64 + x64)
+bun run compile:darwin:arm64  # Compile for macOS arm64
+bun run compile:darwin:x64    # Compile for macOS x64
+bun run compile:linux         # Compile for Linux (x64 + arm64)
+bun run compile:linux:arm64   # Compile for Linux arm64
+bun run compile:linux:x64     # Compile for Linux x64
+bun run compile:windows       # Compile for Windows (default: x64)
+bun run compile:windows:x64   # Compile for Windows x64
+bun run fix                   # Biome auto-fix
+bun run typecheck             # TypeScript check
 
 # Database (Drizzle)
-bun db:generate           # Generate migrations from schema
-bun db:migrate            # Run migrations
-bun db:push               # Push schema (dev only)
-bun db:studio             # Open Drizzle Studio
+bun run db:generate           # Generate migrations from schema
+bun run db:migrate            # Run migrations
+bun run db:push               # Push schema (dev only)
+bun run db:studio             # Open Drizzle Studio
 ```
 
 ### Desktop App (`apps/desktop`)
 ```bash
-bun dev                   # Start Electrobun dev mode (requires server dev running)
-bun build                 # Build canary release
-bun build:stable          # Build stable release
-bun fix                   # Biome auto-fix
-bun typecheck             # TypeScript check
+bun run dev                   # electron-vite dev mode (requires server dev running)
+bun run build                 # electron-vite build (main + preload)
+bun run dist                  # Build + package for current platform
+bun run dist:linux            # Build + package for Linux (x64 + arm64)
+bun run dist:linux:x64        # Build + package for Linux x64
+bun run dist:linux:arm64      # Build + package for Linux arm64
+bun run dist:mac              # Build + package for macOS (arm64 + x64)
+bun run dist:mac:arm64        # Build + package for macOS arm64
+bun run dist:mac:x64          # Build + package for macOS x64
+bun run dist:win              # Build + package for Windows x64
+bun run fix                   # Biome auto-fix
+bun run typecheck             # TypeScript check
 ```
 
 ### Testing
@@ -97,7 +120,13 @@ import type { ReactNode } from 'react'
 - ORPC: Use `ORPCError` with proper codes (`NOT_FOUND`, `INPUT_VALIDATION_FAILED`)
 - Never use empty catch blocks
 
-## Database (Drizzle ORM)
+## Database (Drizzle ORM v1 beta + postgres-js)
+
+- **ORM**: Drizzle ORM `1.0.0-beta` (RQBv2)
+- **Driver**: `drizzle-orm/postgres-js` (NOT `bun-sql`)
+- **Validation**: `drizzle-orm/zod` (built-in, NOT separate `drizzle-zod` package)
+- **Relations**: Defined via `defineRelations()` in `src/server/db/relations.ts` (contains schema info, so `drizzle()` only needs `{ relations }`)
+- **Query style**: RQBv2 object syntax (`orderBy: { createdAt: 'desc' }`, `where: { id: 1 }`)
 
 ```typescript
 export const myTable = pgTable('my_table', {
@@ -120,13 +149,22 @@ export const myTable = pgTable('my_table', {
 - Workspace packages use `"catalog:"` — never hardcode versions
 - Internal packages use `"workspace:*"` references
 
+## Development Principles
+
+> **These principles apply to ALL code changes. Agents MUST follow them on every task.**
+
+1. **No backward compatibility** — This project is in rapid iteration. Always use the latest API and patterns. Never keep deprecated code paths or old API fallbacks "just in case".
+2. **Always sync documentation** — When code changes, immediately update all related documentation (`AGENTS.md`, `README.md`, inline code examples). Code and docs must never drift apart. This includes updating code snippets in docs when imports, APIs, or patterns change.
+3. **Forward-only migration** — When upgrading dependencies, fully adopt the new API. Don't mix old and new patterns in the same codebase.
+
 ## Critical Rules
 
 **DO:**
-- Run `bun fix` before committing
+- Run `bun run fix` before committing
 - Use `@/*` path aliases (not relative imports)
 - Include `createdAt`/`updatedAt` on all tables
 - Use `catalog:` for dependency versions
+- Update `AGENTS.md` and other docs whenever code patterns change
 
 **DON'T:**
 - Use `npm`, `npx`, `node`, `yarn`, `pnpm` — always use `bun` / `bunx`
@@ -135,13 +173,14 @@ export const myTable = pgTable('my_table', {
 - Commit `.env` files
 - Use empty catch blocks `catch(e) {}`
 - Hardcode dependency versions in workspace packages
+- Leave docs out of sync with code changes
 
 ## Git Workflow
 
 1. Make changes following style guide
-2. `bun fix` - auto-format and lint
-3. `bun typecheck` - verify types
-4. `bun dev` - test locally
+2. `bun run fix` - auto-format and lint
+3. `bun run typecheck` - verify types
+4. `bun run dev` - test locally
 5. Commit with descriptive message
 
 ## Directory Structure
@@ -151,22 +190,24 @@ export const myTable = pgTable('my_table', {
 ├── apps/
 │   ├── server/           # TanStack Start fullstack app
 │   │   ├── src/
-│   │   │   ├── client/   # ORPC client, Query client
+│   │   │   ├── client/   # ORPC client + TanStack Query utils
 │   │   │   ├── components/
 │   │   │   ├── routes/   # File-based routing
 │   │   │   └── server/   # API layer + database
 │   │   │       ├── api/  # ORPC contracts, routers, middlewares
 │   │   │       └── db/   # Drizzle schema
 │   │   └── AGENTS.md
-│   └── desktop/          # Electrobun desktop shell
+│   └── desktop/          # Electron desktop shell
 │       ├── src/
-│       │   └── bun/
-│       │       └── index.ts       # Main process entry
-│       ├── electrobun.config.ts   # Electrobun configuration
+│       │   ├── main/
+│       │   │   └── index.ts       # Main process entry
+│       │   └── preload/
+│       │       └── index.ts       # Preload script
+│       ├── electron.vite.config.ts
+│       ├── electron-builder.yml   # Packaging config
 │       └── AGENTS.md
 ├── packages/
-│   ├── tsconfig/         # Shared TS configs
-│   └── utils/            # Shared utilities
+│   └── tsconfig/         # Shared TS configs
 ├── biome.json            # Linting/formatting config
 ├── turbo.json            # Turbo task orchestration
 └── package.json          # Workspace root + dependency catalog
@@ -175,4 +216,4 @@ export const myTable = pgTable('my_table', {
 ## See Also
 
 - `apps/server/AGENTS.md` - Detailed TanStack Start / ORPC patterns
-- `apps/desktop/AGENTS.md` - Electrobun desktop development guide
+- `apps/desktop/AGENTS.md` - Electron desktop development guide

apps/desktop/.gitignore

@@ -1,3 +1,3 @@
-# Electrobun build output
-build/
-artifacts/
+# electron-vite build output
+out/
+dist/

apps/desktop/AGENTS.md

@@ -1,36 +1,39 @@
 # AGENTS.md - Desktop App Guidelines
 
-Thin Electrobun shell hosting the fullstack server app.
+Thin Electron shell hosting the fullstack server app.
 
 ## Tech Stack
 
-> **⚠️ This project uses Bun — NOT Node.js / npm. All commands use `bun`. Never use `npm`, `npx`, or `node`.**
+> **⚠️ This project uses Bun as the package manager. Runtime is Electron (Node.js). Always use `bun run <script>` (not `bun <script>`) to avoid conflicts with Bun built-in subcommands. Never use `npm`, `npx`, `yarn`, or `pnpm`.**
 
-- **Type**: Electrobun desktop application
-- **Design**: Server-driven desktop (thin native shell hosting web app)
-- **Runtime**: Bun (Main process) + CEF (Chromium Embedded Framework)
-- **Framework**: Electrobun
-- **Build**: Electrobun CLI + Turborepo
+- **Type**: Electron desktop shell
+- **Design**: Server-driven desktop (thin native window hosting web app)
+- **Runtime**: Electron (Main/Renderer) + Sidecar server binary (Bun-compiled)
+- **Build Tool**: electron-vite (Vite-based, handles main + preload builds)
+- **Packager**: electron-builder (installers, signing, auto-update)
+- **Orchestration**: Turborepo
 
 ## Architecture
 
-- **Server-driven design**: The desktop app is a "thin" native shell. It does not contain UI or business logic; it merely hosts the `apps/server` TanStack Start application in a native window.
-- **Dev mode**: Connects to an external Vite dev server at `localhost:3000`. Requires `apps/server` to be running separately.
-- **Prod mode**: Spawns an embedded TanStack Start server (Nitro) as a child process and loads the dynamically assigned local URL.
-- **Config**: `electrobun.config.ts` manages app metadata (identifier, name), build entries, and asset bundling.
+- **Server-driven design**: The desktop app is a "thin" native shell. It does not contain UI or business logic; it opens a BrowserWindow pointing to the `apps/server` TanStack Start application.
+- **Dev mode**: Opens a BrowserWindow pointing to `localhost:3000`. Requires `apps/server` to be running separately (Turbo handles this).
+- **Production mode**: Spawns a compiled server binary (from `resources/`) as a sidecar process, waits for readiness, then loads its URL.
 
 ## Commands
 
 ```bash
-# Development
-bun dev                    # Start Electrobun dev mode (requires server dev running)
-
-# Build
-bun build                  # Build stable release (all platforms)
-
-# Code Quality
-bun fix                    # Biome auto-fix
-bun typecheck              # TypeScript check
+bun run dev                    # electron-vite dev (requires server dev running)
+bun run build                  # electron-vite build (main + preload)
+bun run dist                   # Build + package for current platform
+bun run dist:linux             # Build + package for Linux (x64 + arm64)
+bun run dist:linux:x64         # Build + package for Linux x64
+bun run dist:linux:arm64       # Build + package for Linux arm64
+bun run dist:mac               # Build + package for macOS (arm64 + x64)
+bun run dist:mac:arm64         # Build + package for macOS arm64
+bun run dist:mac:x64           # Build + package for macOS x64
+bun run dist:win               # Build + package for Windows x64
+bun run fix                    # Biome auto-fix
+bun run typecheck              # TypeScript check
 ```
 
 ## Directory Structure
@@ -38,93 +41,55 @@ bun typecheck              # TypeScript check
 ```
 .
 ├── src/
-│   └── bun/
-│       └── index.ts       # Main process entry (Window management + server lifecycle)
-├── electrobun.config.ts   # App metadata and build/copy configuration
-├── package.json           # Scripts and dependencies
-├── turbo.json             # Build pipeline dependencies (depends on server build)
-└── AGENTS.md              # Desktop guidelines (this file)
+│   ├── main/
+│   │   └── index.ts       # Main process (server lifecycle + BrowserWindow)
+│   └── preload/
+│       └── index.ts       # Preload script (security isolation)
+├── resources/             # Sidecar binaries (gitignored, copied from server build)
+├── out/                   # electron-vite build output (gitignored)
+├── electron.vite.config.ts
+├── electron-builder.yml   # Packaging configuration
+├── package.json
+├── turbo.json
+└── AGENTS.md
 ```
 
 ## Development Workflow
 
-1. **Start server**: In `apps/server`, run `bun dev`.
-2. **Start desktop**: In `apps/desktop`, run `bun dev`.
-3. **Connection**: The desktop app polls `localhost:3000` until responsive, then opens the native window.
+1. **Start server**: `bun run dev` in `apps/server` (or use root `bun run dev` via Turbo).
+2. **Start desktop**: `bun run dev` in `apps/desktop`.
+3. **Connection**: Main process polls `localhost:3000` until responsive, then opens BrowserWindow.
 
-## Production Architecture
+## Production Build Workflow
 
-### Build Pipeline
-The desktop build is orchestrated by Turbo. It depends on the server's production build:
-- `turbo.json`: `@furtherverse/desktop#build` depends on `@furtherverse/server#build`.
-- `electrobun.config.ts`: Copies `../server/.output` to `server-output` folder within the app bundle.
+From monorepo root, run `bun run dist` to execute the full pipeline automatically (via Turbo task dependencies):
 
-### Server Lifecycle
-In production, the main process manages the embedded server:
-- **Spawn**: Spawns server from `server-output/server/index.mjs` using `Bun.spawn`.
-- **Port Allocation**: Server is started with `PORT=0` and `HOST=127.0.0.1`.
-- **Port Detection**: The main process parses the server's `stdout` using a regex to find the dynamically assigned port.
-- **Lifecycle**: The server process is tied to the app; it is killed on `SIGTERM`, `SIGINT`, or app exit. If the server process crashes, the app exits with an error.
+1. **Build server**: `apps/server` → `vite build` → `.output/`
+2. **Compile server**: `apps/server` → `bun compile.ts --target ...` → `out/server-{os}-{arch}`
+3. **Package desktop**: `apps/desktop` → `electron-vite build` + `electron-builder` → distributable
 
-## Environment Detection
+The `electron-builder.yml` `extraResources` config reads binaries directly from `../server/out/`, no manual copy needed.
 
-The application determines its environment via the `ELECTROBUN_BUILD_ENV` variable, automatically set by the Electrobun CLI:
+To build for a specific platform explicitly, use `bun run dist:linux` / `bun run dist:mac` / `bun run dist:win` in `apps/desktop`.
+For single-arch output, use `bun run dist:linux:x64`, `bun run dist:linux:arm64`, `bun run dist:mac:x64`, or `bun run dist:mac:arm64`.
 
-```typescript
-const isDev = () => {
-  const env = process.env.ELECTROBUN_BUILD_ENV
-  return !env || env === 'dev'
-}
-```
+## Development Principles
 
-- **dev**: Development mode (connects to external host).
-- **canary / stable**: Production mode (starts embedded server).
+> **These principles apply to ALL code changes. Agents MUST follow them on every task.**
 
-## Environment Variables
-
-- `ELECTROBUN_BUILD_ENV`: Auto-set by CLI. Determines whether to use local dev server or embedded server.
-- `DATABASE_URL`: Required by the server process. Must be passed through from the parent environment to the spawned child process.
-
-## Electrobun Patterns
-
-### BrowserWindow Configuration
-The main window uses the CEF renderer for consistency across platforms.
-
-```typescript
-new BrowserWindow({
-  title: 'Furtherverse',
-  url: serverUrl,
-  frame: {
-    x: 100,
-    y: 100,
-    width: 1200,
-    height: 800,
-  },
-  renderer: 'cef',
-})
-```
-
-### Path Aliases
-The main process uses `electrobun/bun` for native APIs and `PATHS` for locating bundled assets.
-
-```typescript
-import { BrowserWindow, PATHS } from 'electrobun/bun'
-
-// Locate the embedded server bundle
-const serverEntryPath = join(PATHS.VIEWS_FOLDER, '..', 'server-output', 'server', 'index.mjs')
-```
+1. **No backward compatibility** — This project is in rapid iteration. Always use the latest API and patterns. Never keep deprecated code paths or old API fallbacks.
+2. **Always sync documentation** — When code changes, immediately update all related documentation (`AGENTS.md`, `README.md`, inline code examples). Code and docs must never drift apart.
+3. **Forward-only migration** — When upgrading dependencies, fully adopt the new API. Don't mix old and new patterns.
 
 ## Critical Rules
 
 **DO:**
-- Use arrow functions for all components and utility functions.
-- Ensure `apps/server` is built before building `apps/desktop` (handled by Turbo).
-- Parse the server's stdout for the port instead of hardcoding ports in production.
-- Handle server process termination to avoid orphan processes.
+- Use arrow functions for all utility functions.
+- Keep the desktop app as a thin shell — no UI or business logic.
 - Use `catalog:` for all dependency versions in `package.json`.
 
 **DON'T:**
-- Use `npm`, `npx`, `node`, `yarn`, or `pnpm`. Always use `bun`.
-- Hardcode `localhost:3000` for production builds.
-- Include UI components or business logic in the desktop app (keep it thin).
+- Use `npm`, `npx`, `yarn`, or `pnpm`. Use `bun` for package management.
+- Include UI components or business logic in the desktop app.
 - Use `as any` or `@ts-ignore`.
+- Leave docs out of sync with code changes.

apps/desktop/biome.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "../../node_modules/@biomejs/biome/configuration_schema.json",
+  "extends": "//",
+  "css": {
+    "parser": {
+      "tailwindDirectives": true
+    }
+  }
+}

apps/desktop/electrobun.config.ts

@@ -1,26 +0,0 @@
-import type { ElectrobunConfig } from 'electrobun'
-
-export default {
-  app: {
-    name: 'Desktop',
-    identifier: 'com.furtherverse.desktop',
-    version: '1.0.0',
-  },
-  build: {
-    bun: {
-      entrypoint: 'src/bun/index.ts',
-    },
-    copy: {
-      '../server/.output': 'server-output',
-    },
-    mac: {
-      bundleCEF: true,
-    },
-    win: {
-      bundleCEF: true,
-    },
-    linux: {
-      bundleCEF: true,
-    },
-  },
-} satisfies ElectrobunConfig

apps/desktop/electron-builder.yml

@@ -0,0 +1,48 @@
+# yaml-language-server: $schema=https://raw.githubusercontent.com/electron-userland/electron-builder/refs/heads/master/packages/app-builder-lib/scheme.json
+appId: com.furtherverse.desktop
+productName: Furtherverse
+executableName: furtherverse
+
+npmRebuild: false
+asarUnpack:
+  - resources/**
+
+files:
+  - "!**/.vscode/*"
+  - "!src/*"
+  - "!electron.vite.config.{js,ts,mjs,cjs}"
+  - "!{.env,.env.*,bun.lock}"
+  - "!{tsconfig.json,tsconfig.node.json}"
+  - "!{AGENTS.md,README.md,CHANGELOG.md}"
+
+# macOS
+mac:
+  target:
+    - dmg
+  category: public.app-category.productivity
+  extraResources:
+    - from: ../server/out/server-darwin-${arch}
+      to: server
+dmg:
+  artifactName: ${productName}-${version}-${os}-${arch}.${ext}
+
+# Windows
+win:
+  target:
+    - portable
+  extraResources:
+    - from: ../server/out/server-windows-${arch}.exe
+      to: server.exe
+portable:
+  artifactName: ${productName}-${version}-${os}-${arch}-Portable.${ext}
+
+# Linux
+linux:
+  target:
+    - AppImage
+  category: Utility
+  extraResources:
+    - from: ../server/out/server-linux-${arch}
+      to: server
+appImage:
+  artifactName: ${productName}-${version}-${os}-${arch}.${ext}

apps/desktop/electron.vite.config.ts

@@ -0,0 +1,11 @@
+import tailwindcss from '@tailwindcss/vite'
+import react from '@vitejs/plugin-react'
+import { defineConfig } from 'electron-vite'
+
+export default defineConfig({
+  main: {},
+  preload: {},
+  renderer: {
+    plugins: [react(), tailwindcss()],
+  },
+})

apps/desktop/package.json

@@ -2,18 +2,36 @@
   "name": "@furtherverse/desktop",
   "version": "1.0.0",
   "private": true,
-  "type": "module",
+  "main": "out/main/index.js",
   "scripts": {
-    "build": "electrobun build --env=stable --targets=all",
-    "dev": "electrobun build && electrobun dev",
+    "build": "electron-vite build",
+    "dev": "electron-vite dev --watch",
+    "dist": "electron-builder",
+    "dist:linux": "bun run dist:linux:x64 && bun run dist:linux:arm64",
+    "dist:linux:arm64": "electron-builder --linux --arm64",
+    "dist:linux:x64": "electron-builder --linux --x64",
+    "dist:mac": "bun run dist:mac:arm64 && bun run dist:mac:x64",
+    "dist:mac:arm64": "electron-builder --mac --arm64",
+    "dist:mac:x64": "electron-builder --mac --x64",
+    "dist:win": "electron-builder --win --x64",
     "fix": "biome check --write",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc -b"
   },
   "dependencies": {
-    "electrobun": "catalog:"
+    "motion": "catalog:",
+    "react": "catalog:",
+    "react-dom": "catalog:",
+    "tree-kill": "catalog:"
   },
   "devDependencies": {
     "@furtherverse/tsconfig": "workspace:*",
-    "@types/bun": "catalog:"
+    "@tailwindcss/vite": "catalog:",
+    "@types/node": "catalog:",
+    "@vitejs/plugin-react": "catalog:",
+    "electron": "catalog:",
+    "electron-builder": "catalog:",
+    "electron-vite": "catalog:",
+    "tailwindcss": "catalog:",
+    "vite": "catalog:"
   }
 }

apps/desktop/src/bun/index.ts

@@ -1,173 +0,0 @@
-import { dirname, join } from 'node:path'
-import { BrowserWindow, PATHS } from 'electrobun/bun'
-
-const DEV_SERVER_URL = 'http://localhost:3000'
-const SERVER_READY_TIMEOUT_MS = 30_000
-const PORT_PATTERN = /Listening on:?\s*https?:\/\/[^\s:]+:(\d+)/
-
-const isDev = (): boolean => {
-  const env = process.env.ELECTROBUN_BUILD_ENV
-  return !env || env === 'dev'
-}
-
-const getServerEntryPath = (): string => {
-  return join(PATHS.VIEWS_FOLDER, '..', 'server-output', 'server', 'index.mjs')
-}
-
-const waitForServer = async (
-  url: string,
-  timeoutMs = SERVER_READY_TIMEOUT_MS,
-): Promise<boolean> => {
-  const start = Date.now()
-  while (Date.now() - start < timeoutMs) {
-    try {
-      const response = await fetch(url, { method: 'HEAD' })
-      if (response.ok) return true
-    } catch (_) {
-      // Server not up yet, retry after sleep
-    }
-    await Bun.sleep(100)
-  }
-  return false
-}
-
-const spawnServer = async (): Promise<{
-  process: ReturnType<typeof Bun.spawn>
-  url: string
-}> => {
-  const serverEntryPath = getServerEntryPath()
-  const serverDir = dirname(serverEntryPath)
-
-  const serverProc = Bun.spawn([process.execPath, serverEntryPath], {
-    cwd: serverDir,
-    env: {
-      ...process.env,
-      PORT: '0',
-      HOST: '127.0.0.1',
-    },
-    stdout: 'pipe',
-    stderr: 'pipe',
-  })
-
-  const port = await new Promise<string>((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      serverProc.kill()
-      reject(
-        new Error(`Server did not start within ${SERVER_READY_TIMEOUT_MS}ms`),
-      )
-    }, SERVER_READY_TIMEOUT_MS)
-
-    const reader = serverProc.stdout.getReader()
-    let buffer = ''
-
-    const read = async () => {
-      try {
-        while (true) {
-          const { done, value } = await reader.read()
-          if (done) {
-            clearTimeout(timeout)
-            reject(new Error('Server process exited before reporting port'))
-            return
-          }
-
-          const text = new TextDecoder().decode(value)
-          buffer += text
-          process.stdout.write(text)
-
-          const match = PORT_PATTERN.exec(buffer)
-          if (match?.[1]) {
-            clearTimeout(timeout)
-            resolve(match[1])
-            return
-          }
-        }
-      } catch (err) {
-        clearTimeout(timeout)
-        reject(err)
-      }
-    }
-
-    serverProc.exited.then((code) => {
-      clearTimeout(timeout)
-      reject(new Error(`Server exited with code ${code} before becoming ready`))
-    })
-
-    read()
-  })
-
-  return { process: serverProc, url: `http://127.0.0.1:${port}` }
-}
-
-const main = async () => {
-  console.log('Starting Furtherverse Desktop...')
-
-  let serverUrl: string
-  let serverProcess: ReturnType<typeof Bun.spawn> | null = null
-
-  if (isDev()) {
-    console.log('Dev mode: waiting for external server at', DEV_SERVER_URL)
-    const ready = await waitForServer(DEV_SERVER_URL)
-    if (!ready) {
-      console.error(
-        'Dev server not responding. Make sure to run: bun dev in apps/server',
-      )
-      process.exit(1)
-    }
-    console.log('Dev server ready!')
-    serverUrl = DEV_SERVER_URL
-  } else {
-    console.log('Production mode: starting embedded server...')
-    try {
-      const server = await spawnServer()
-      serverProcess = server.process
-      serverUrl = server.url
-      console.log('Server ready at', serverUrl)
-    } catch (err) {
-      console.error('Failed to start embedded server:', err)
-      process.exit(1)
-    }
-  }
-
-  new BrowserWindow({
-    title: 'Furtherverse',
-    url: serverUrl,
-    frame: {
-      x: 100,
-      y: 100,
-      width: 1200,
-      height: 800,
-    },
-    renderer: 'cef',
-  })
-
-  if (serverProcess) {
-    const cleanup = () => {
-      if (serverProcess) {
-        serverProcess.kill()
-        serverProcess = null
-      }
-    }
-
-    process.on('exit', cleanup)
-    process.on('SIGTERM', () => {
-      cleanup()
-      process.exit(0)
-    })
-    process.on('SIGINT', () => {
-      cleanup()
-      process.exit(0)
-    })
-
-    serverProcess.exited.then((code) => {
-      if (serverProcess) {
-        console.error(`Server exited unexpectedly with code ${code}`)
-        process.exit(1)
-      }
-    })
-  }
-}
-
-main().catch((error) => {
-  console.error('Failed to start:', error)
-  process.exit(1)
-})

apps/desktop/src/main/index.ts

@@ -0,0 +1,198 @@
+import { join } from 'node:path'
+import { app, BrowserWindow, dialog, session, shell } from 'electron'
+import { createSidecarRuntime } from './sidecar'
+
+const DEV_SERVER_URL = 'http://localhost:3000'
+const SAFE_EXTERNAL_PROTOCOLS = new Set(['https:', 'http:', 'mailto:'])
+
+let mainWindow: BrowserWindow | null = null
+let windowCreationPromise: Promise<void> | null = null
+let isQuitting = false
+
+const showErrorAndQuit = (title: string, detail: string) => {
+  if (isQuitting) {
+    return
+  }
+
+  dialog.showErrorBox(title, detail)
+  app.quit()
+}
+
+const sidecar = createSidecarRuntime({
+  devServerUrl: DEV_SERVER_URL,
+  isPackaged: app.isPackaged,
+  resourcesPath: process.resourcesPath,
+  isQuitting: () => isQuitting,
+  onUnexpectedStop: (detail) => {
+    showErrorAndQuit('Service Stopped', detail)
+  },
+})
+
+const toErrorMessage = (error: unknown): string => (error instanceof Error ? error.message : String(error))
+
+const canOpenExternally = (url: string): boolean => {
+  try {
+    const parsed = new URL(url)
+    return SAFE_EXTERNAL_PROTOCOLS.has(parsed.protocol)
+  } catch {
+    return false
+  }
+}
+
+const loadSplash = async (windowRef: BrowserWindow) => {
+  if (process.env.ELECTRON_RENDERER_URL) {
+    await windowRef.loadURL(process.env.ELECTRON_RENDERER_URL)
+    return
+  }
+
+  await windowRef.loadFile(join(__dirname, '../renderer/index.html'))
+}
+
+const createWindow = async () => {
+  if (mainWindow && !mainWindow.isDestroyed()) {
+    mainWindow.focus()
+    return
+  }
+
+  const windowRef = new BrowserWindow({
+    width: 1200,
+    height: 800,
+    show: false,
+    webPreferences: {
+      preload: join(__dirname, '../preload/index.js'),
+      sandbox: true,
+      contextIsolation: true,
+      nodeIntegration: false,
+    },
+  })
+  mainWindow = windowRef
+
+  windowRef.webContents.setWindowOpenHandler(({ url }) => {
+    if (!canOpenExternally(url)) {
+      if (!app.isPackaged) {
+        console.warn(`Blocked external URL: ${url}`)
+      }
+
+      return { action: 'deny' }
+    }
+
+    void shell.openExternal(url)
+    return { action: 'deny' }
+  })
+
+  windowRef.webContents.on('will-navigate', (event, url) => {
+    const allowed = [DEV_SERVER_URL, sidecar.lastResolvedUrl].filter((v): v is string => v != null)
+    const isAllowed = allowed.some((origin) => url.startsWith(origin))
+
+    if (!isAllowed) {
+      event.preventDefault()
+
+      if (canOpenExternally(url)) {
+        void shell.openExternal(url)
+      } else if (!app.isPackaged) {
+        console.warn(`Blocked navigation to: ${url}`)
+      }
+    }
+  })
+
+  windowRef.on('closed', () => {
+    if (mainWindow === windowRef) {
+      mainWindow = null
+    }
+  })
+
+  try {
+    await loadSplash(windowRef)
+  } catch (error) {
+    if (mainWindow === windowRef) {
+      mainWindow = null
+    }
+
+    if (!windowRef.isDestroyed()) {
+      windowRef.destroy()
+    }
+
+    throw error
+  }
+
+  if (!windowRef.isDestroyed()) {
+    windowRef.show()
+  }
+
+  const targetUrl = await sidecar.resolveUrl()
+  if (isQuitting || windowRef.isDestroyed()) {
+    return
+  }
+
+  try {
+    await windowRef.loadURL(targetUrl)
+  } catch (error) {
+    if (mainWindow === windowRef) {
+      mainWindow = null
+    }
+
+    if (!windowRef.isDestroyed()) {
+      windowRef.destroy()
+    }
+
+    throw error
+  }
+}
+
+const ensureWindow = async () => {
+  if (windowCreationPromise) {
+    return windowCreationPromise
+  }
+
+  windowCreationPromise = createWindow().finally(() => {
+    windowCreationPromise = null
+  })
+
+  return windowCreationPromise
+}
+
+const beginQuit = () => {
+  isQuitting = true
+  sidecar.stop()
+}
+
+const handleWindowCreationError = (error: unknown, context: string) => {
+  console.error(`${context}:`, error)
+  showErrorAndQuit(
+    "App Couldn't Start",
+    app.isPackaged
+      ? 'A required component failed to start. Please reinstall the app.'
+      : `${context}: ${toErrorMessage(error)}`,
+  )
+}
+
+app
+  .whenReady()
+  .then(() => {
+    session.defaultSession.setPermissionRequestHandler((_webContents, _permission, callback) => {
+      callback(false)
+    })
+
+    return ensureWindow()
+  })
+  .catch((error) => {
+    handleWindowCreationError(error, 'Failed to create window')
+  })
+
+app.on('window-all-closed', () => {
+  if (process.platform !== 'darwin') {
+    app.quit()
+  }
+})
+
+app.on('activate', () => {
+  if (isQuitting || BrowserWindow.getAllWindows().length > 0) {
+    return
+  }
+
+  ensureWindow().catch((error) => {
+    handleWindowCreationError(error, 'Failed to re-create window')
+  })
+})
+
+app.on('before-quit', beginQuit)

apps/desktop/src/main/sidecar.ts

@@ -0,0 +1,256 @@
+import { type ChildProcess, spawn } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { createServer } from 'node:net'
+import { join } from 'node:path'
+import killProcessTree from 'tree-kill'
+
+const SERVER_HOST = '127.0.0.1'
+const SERVER_READY_TIMEOUT_MS = 10_000
+const SERVER_REQUEST_TIMEOUT_MS = 1_500
+const SERVER_POLL_INTERVAL_MS = 250
+const SERVER_PROBE_PATHS = ['/api/health', '/']
+
+type SidecarState = {
+  process: ChildProcess | null
+  startup: Promise<string> | null
+  url: string | null
+}
+
+type SidecarRuntimeOptions = {
+  devServerUrl: string
+  isPackaged: boolean
+  resourcesPath: string
+  isQuitting: () => boolean
+  onUnexpectedStop: (detail: string) => void
+}
+
+type SidecarRuntime = {
+  resolveUrl: () => Promise<string>
+  stop: () => void
+  lastResolvedUrl: string | null
+}
+
+const sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms))
+
+const isProcessAlive = (processToCheck: ChildProcess | null): processToCheck is ChildProcess => {
+  if (!processToCheck || !processToCheck.pid) {
+    return false
+  }
+
+  return processToCheck.exitCode === null && !processToCheck.killed
+}
+
+const getAvailablePort = (): Promise<number> =>
+  new Promise((resolve, reject) => {
+    const server = createServer()
+    server.listen(0, () => {
+      const addr = server.address()
+      if (!addr || typeof addr === 'string') {
+        server.close()
+        reject(new Error('Failed to resolve port'))
+        return
+      }
+
+      server.close(() => resolve(addr.port))
+    })
+    server.on('error', reject)
+  })
+
+const isServerReady = async (url: string): Promise<boolean> => {
+  for (const probePath of SERVER_PROBE_PATHS) {
+    try {
+      const probeUrl = new URL(probePath, `${url}/`)
+      const response = await fetch(probeUrl, {
+        method: 'GET',
+        cache: 'no-store',
+        signal: AbortSignal.timeout(SERVER_REQUEST_TIMEOUT_MS),
+      })
+
+      if (response.status < 500) {
+        if (probePath === '/api/health' && response.status === 404) {
+          continue
+        }
+
+        return true
+      }
+    } catch {
+      // Expected: probe request fails while server is still starting up
+    }
+  }
+
+  return false
+}
+
+const waitForServer = async (url: string, isQuitting: () => boolean, processRef?: ChildProcess): Promise<boolean> => {
+  const start = Date.now()
+  while (Date.now() - start < SERVER_READY_TIMEOUT_MS && !isQuitting()) {
+    if (processRef && processRef.exitCode !== null) {
+      return false
+    }
+
+    if (await isServerReady(url)) {
+      return true
+    }
+
+    await sleep(SERVER_POLL_INTERVAL_MS)
+  }
+
+  return false
+}
+
+const resolveBinaryPath = (resourcesPath: string): string => {
+  const binaryName = process.platform === 'win32' ? 'server.exe' : 'server'
+  return join(resourcesPath, binaryName)
+}
+
+const formatUnexpectedStopMessage = (
+  isPackaged: boolean,
+  code: number | null,
+  signal: NodeJS.Signals | null,
+): string => {
+  if (isPackaged) {
+    return 'The background service stopped unexpectedly. Please restart the app.'
+  }
+
+  return `Server process exited unexpectedly (code ${code ?? 'unknown'}, signal ${signal ?? 'none'}).`
+}
+
+export const createSidecarRuntime = (options: SidecarRuntimeOptions): SidecarRuntime => {
+  const state: SidecarState = {
+    process: null,
+    startup: null,
+    url: null,
+  }
+
+  const resetState = (processRef?: ChildProcess) => {
+    if (processRef && state.process !== processRef) {
+      return
+    }
+
+    state.process = null
+    state.url = null
+  }
+
+  const stop = () => {
+    const runningServer = state.process
+    resetState()
+
+    if (!runningServer?.pid || runningServer.exitCode !== null) {
+      return
+    }
+
+    killProcessTree(runningServer.pid, 'SIGTERM', (error?: Error) => {
+      if (error) {
+        console.error('Failed to stop server process:', error)
+      }
+    })
+  }
+
+  const attachLifecycleHandlers = (processRef: ChildProcess) => {
+    processRef.on('error', (error) => {
+      if (state.process !== processRef) {
+        return
+      }
+
+      const hadReadyServer = state.url !== null
+      resetState(processRef)
+
+      if (!options.isQuitting() && hadReadyServer) {
+        options.onUnexpectedStop('The background service crashed unexpectedly. Please restart the app.')
+        return
+      }
+
+      console.error('Failed to start server process:', error)
+    })
+
+    processRef.on('exit', (code, signal) => {
+      if (state.process !== processRef) {
+        return
+      }
+
+      const hadReadyServer = state.url !== null
+      resetState(processRef)
+
+      if (!options.isQuitting() && hadReadyServer) {
+        options.onUnexpectedStop(formatUnexpectedStopMessage(options.isPackaged, code, signal))
+      }
+    })
+  }
+
+  const startPackagedServer = async (): Promise<string> => {
+    if (state.url && isProcessAlive(state.process)) {
+      return state.url
+    }
+
+    if (state.startup) {
+      return state.startup
+    }
+
+    state.startup = (async () => {
+      const binaryPath = resolveBinaryPath(options.resourcesPath)
+      if (!existsSync(binaryPath)) {
+        throw new Error(`Sidecar server binary is missing: ${binaryPath}`)
+      }
+
+      if (options.isQuitting()) {
+        throw new Error('Application is shutting down.')
+      }
+
+      const port = await getAvailablePort()
+      const nextServerUrl = `http://${SERVER_HOST}:${port}`
+      const processRef = spawn(binaryPath, [], {
+        env: {
+          ...process.env,
+          HOST: SERVER_HOST,
+          PORT: String(port),
+        },
+        stdio: 'ignore',
+        windowsHide: true,
+      })
+
+      processRef.unref()
+      state.process = processRef
+      attachLifecycleHandlers(processRef)
+
+      const ready = await waitForServer(nextServerUrl, options.isQuitting, processRef)
+      if (ready && isProcessAlive(processRef)) {
+        state.url = nextServerUrl
+        return nextServerUrl
+      }
+
+      const failureReason =
+        processRef.exitCode !== null
+          ? `The service exited early (code ${processRef.exitCode}).`
+          : `The service did not respond at ${nextServerUrl} within 10 seconds.`
+
+      stop()
+      throw new Error(failureReason)
+    })().finally(() => {
+      state.startup = null
+    })
+
+    return state.startup
+  }
+
+  const resolveUrl = async (): Promise<string> => {
+    if (options.isPackaged) {
+      return startPackagedServer()
+    }
+
+    const ready = await waitForServer(options.devServerUrl, options.isQuitting)
+    if (!ready) {
+      throw new Error('Dev server not responding. Run `bun dev` in apps/server first.')
+    }
+
+    state.url = options.devServerUrl
+    return options.devServerUrl
+  }
+
+  return {
+    resolveUrl,
+    stop,
+    get lastResolvedUrl() {
+      return state.url
+    },
+  }
+}

apps/desktop/src/preload/index.ts

@@ -0,0 +1 @@
+export {}

apps/desktop/src/renderer/components/SplashApp.tsx

@@ -0,0 +1,33 @@
+import { motion } from 'motion/react'
+import logoImage from '../assets/logo.png'
+
+export const SplashApp = () => {
+  return (
+    <main className="m-0 flex h-screen w-screen cursor-default select-none items-center justify-center overflow-hidden bg-white font-sans antialiased">
+      <motion.section
+        animate={{ opacity: 1, y: 0 }}
+        className="flex flex-col items-center gap-8"
+        initial={{ opacity: 0, y: 4 }}
+        transition={{
+          duration: 1,
+          ease: [0.16, 1, 0.3, 1],
+        }}
+      >
+        <img alt="Logo" className="h-20 w-auto object-contain" draggable={false} src={logoImage} />
+
+        <div className="relative h-[4px] w-36 overflow-hidden rounded-full bg-zinc-100">
+          <motion.div
+            animate={{ x: '100%' }}
+            className="h-full w-full bg-zinc-800"
+            initial={{ x: '-100%' }}
+            transition={{
+              duration: 2,
+              ease: [0.4, 0, 0.2, 1],
+              repeat: Infinity,
+            }}
+          />
+        </div>
+      </motion.section>
+    </main>
+  )
+}

apps/desktop/src/renderer/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Furtherverse</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="./main.tsx"></script>
+  </body>
+</html>

apps/desktop/src/renderer/main.tsx

@@ -0,0 +1,11 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import { SplashApp } from './components/SplashApp'
+import './styles.css'
+
+// biome-ignore lint/style/noNonNullAssertion: 一定存在
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <SplashApp />
+  </StrictMode>,
+)

apps/desktop/src/renderer/styles.css

@@ -0,0 +1 @@
+@import "tailwindcss";

apps/desktop/tsconfig.app.json

@@ -0,0 +1,8 @@
+{
+  "extends": "@furtherverse/tsconfig/react.json",
+  "compilerOptions": {
+    "composite": true,
+    "types": ["vite/client"]
+  },
+  "include": ["src/renderer/**/*"]
+}

apps/desktop/tsconfig.json

@@ -1,6 +1,11 @@
 {
-  "extends": "@furtherverse/tsconfig/bun.json",
-  "compilerOptions": {
-    "lib": ["ESNext", "DOM", "DOM.Iterable"]
-  }
+  "files": [],
+  "references": [
+    {
+      "path": "./tsconfig.app.json"
+    },
+    {
+      "path": "./tsconfig.node.json"
+    }
+  ]
 }

apps/desktop/tsconfig.node.json

@@ -0,0 +1,8 @@
+{
+  "extends": "@furtherverse/tsconfig/base.json",
+  "compilerOptions": {
+    "composite": true,
+    "types": ["node"]
+  },
+  "include": ["src/main/**/*", "src/preload/**/*", "electron.vite.config.ts"]
+}

apps/desktop/turbo.json

@@ -3,8 +3,39 @@
   "extends": ["//"],
   "tasks": {
     "build": {
-      "dependsOn": ["@furtherverse/server#build"],
-      "outputs": ["build/**", "artifacts/**"]
+      "outputs": ["out/**"]
+    },
+    "dist": {
+      "dependsOn": ["build", "@furtherverse/server#compile"],
+      "outputs": ["dist/**"]
+    },
+    "dist:linux": {
+      "dependsOn": ["build", "@furtherverse/server#compile:linux:arm64", "@furtherverse/server#compile:linux:x64"],
+      "outputs": ["dist/**"]
+    },
+    "dist:linux:arm64": {
+      "dependsOn": ["build", "@furtherverse/server#compile:linux:arm64"],
+      "outputs": ["dist/**"]
+    },
+    "dist:linux:x64": {
+      "dependsOn": ["build", "@furtherverse/server#compile:linux:x64"],
+      "outputs": ["dist/**"]
+    },
+    "dist:mac": {
+      "dependsOn": ["build", "@furtherverse/server#compile:darwin:arm64", "@furtherverse/server#compile:darwin:x64"],
+      "outputs": ["dist/**"]
+    },
+    "dist:mac:arm64": {
+      "dependsOn": ["build", "@furtherverse/server#compile:darwin:arm64"],
+      "outputs": ["dist/**"]
+    },
+    "dist:mac:x64": {
+      "dependsOn": ["build", "@furtherverse/server#compile:darwin:x64"],
+      "outputs": ["dist/**"]
+    },
+    "dist:win": {
+      "dependsOn": ["build", "@furtherverse/server#compile:windows:x64"],
+      "outputs": ["dist/**"]
     }
   }
 }

apps/server/AGENTS.md

@@ -4,14 +4,14 @@ TanStack Start fullstack web app with ORPC (contract-first RPC).
 
 ## Tech Stack
 
-> **⚠️ This project uses Bun — NOT Node.js / npm. All commands use `bun`. Never use `npm`, `npx`, or `node`.**
+> **⚠️ This project uses Bun — NOT Node.js / npm. All commands use `bun`. Always use `bun run <script>` (not `bun <script>`) to avoid conflicts with Bun built-in subcommands. Never use `npm`, `npx`, or `node`.**
 
 - **Framework**: TanStack Start (React 19 SSR, file-based routing)
 - **Runtime**: Bun — **NOT Node.js**
 - **Package Manager**: Bun — **NOT npm / yarn / pnpm**
 - **Language**: TypeScript (strict mode)
 - **Styling**: Tailwind CSS v4
-- **Database**: PostgreSQL + Drizzle ORM
+- **Database**: PostgreSQL + Drizzle ORM v1 beta (`drizzle-orm/postgres-js`, RQBv2)
 - **State**: TanStack Query v5
 - **RPC**: ORPC (contract-first, type-safe)
 - **Build**: Vite + Nitro
@@ -20,25 +20,33 @@ TanStack Start fullstack web app with ORPC (contract-first RPC).
 
 ```bash
 # Development
-bun dev                    # Vite dev server (localhost:3000)
-bun db:studio              # Drizzle Studio GUI
+bun run dev                    # Vite dev server (localhost:3000)
+bun run db:studio              # Drizzle Studio GUI
 
 # Build
-bun build                  # Production build → .output/
-bun compile                # Compile to standalone binary
+bun run build                  # Production build → .output/
+bun run compile                # Compile to standalone binary (current platform, depends on build)
+bun run compile:darwin         # Compile for macOS (arm64 + x64)
+bun run compile:darwin:arm64   # Compile for macOS arm64
+bun run compile:darwin:x64     # Compile for macOS x64
+bun run compile:linux          # Compile for Linux (x64 + arm64)
+bun run compile:linux:arm64    # Compile for Linux arm64
+bun run compile:linux:x64      # Compile for Linux x64
+bun run compile:windows        # Compile for Windows (default: x64)
+bun run compile:windows:x64    # Compile for Windows x64
 
 # Code Quality
-bun fix                    # Biome auto-fix
-bun typecheck              # TypeScript check
+bun run fix                    # Biome auto-fix
+bun run typecheck              # TypeScript check
 
 # Database
-bun db:generate            # Generate migrations from schema
-bun db:migrate             # Run migrations
-bun db:push                # Push schema directly (dev only)
+bun run db:generate            # Generate migrations from schema
+bun run db:migrate             # Run migrations
+bun run db:push                # Push schema directly (dev only)
 
 # Testing (not yet configured)
-bun test path/to/test.ts   # Run single test
-bun test -t "pattern"      # Run tests matching pattern
+bun test path/to/test.ts       # Run single test
+bun test -t "pattern"          # Run tests matching pattern
 ```
 
 ## Directory Structure
@@ -46,25 +54,29 @@ bun test -t "pattern"      # Run tests matching pattern
 ```
 src/
 ├── client/                # Client-side code
-│   ├── orpc.client.ts     # ORPC isomorphic client
-│   └── query-client.ts    # TanStack Query client
+│   └── orpc.ts            # ORPC client + TanStack Query utils (single entry point)
 ├── components/            # React components
 ├── routes/                # TanStack Router file routes
 │   ├── __root.tsx         # Root layout
 │   ├── index.tsx          # Home page
 │   └── api/
-│       └── rpc.$.ts       # ORPC HTTP endpoint
+│       ├── $.ts           # OpenAPI handler + Scalar docs
+│       ├── health.ts      # Health check endpoint
+│       └── rpc.$.ts       # ORPC RPC handler
 ├── server/                # Server-side code
 │   ├── api/               # ORPC layer
 │   │   ├── contracts/     # Input/output schemas (Zod)
 │   │   ├── middlewares/   # Middleware (db provider, auth)
 │   │   ├── routers/       # Handler implementations
+│   │   ├── interceptors.ts # Shared error interceptors
 │   │   ├── context.ts     # Request context
 │   │   ├── server.ts      # ORPC server instance
 │   │   └── types.ts       # Type exports
 │   └── db/
 │       ├── schema/        # Drizzle table definitions
-│       └── index.ts       # Database instance
+│       ├── fields.ts      # Shared field builders (id, createdAt, updatedAt)
+│       ├── relations.ts   # Drizzle relations (defineRelations, RQBv2)
+│       └── index.ts       # Database instance (postgres-js driver)
 ├── env.ts                 # Environment variable validation
 ├── router.tsx             # Router configuration
 ├── routeTree.gen.ts       # Auto-generated (DO NOT EDIT)
@@ -76,7 +88,7 @@ src/
 ### 1. Define Contract (`src/server/api/contracts/feature.contract.ts`)
 ```typescript
 import { oc } from '@orpc/contract'
-import { createSelectSchema } from 'drizzle-zod'
+import { createSelectSchema } from 'drizzle-orm/zod'
 import { z } from 'zod'
 import { featureTable } from '@/server/db/schema'
 
@@ -93,7 +105,9 @@ import { db } from '../middlewares'
 import { os } from '../server'
 
 export const list = os.feature.list.use(db).handler(async ({ context }) => {
-  return await context.db.query.featureTable.findMany()
+  return await context.db.query.featureTable.findMany({
+    orderBy: { createdAt: 'desc' },
+  })
 })
 ```
 
@@ -111,14 +125,20 @@ export const router = os.router({ feature })
 ### 4. Use in Components
 ```typescript
 import { useSuspenseQuery, useMutation } from '@tanstack/react-query'
-import { orpc } from '@/client/orpc.client'
+import { orpc } from '@/client/orpc'
 
 const { data } = useSuspenseQuery(orpc.feature.list.queryOptions())
 const mutation = useMutation(orpc.feature.create.mutationOptions())
 ```
 
-## Database Schema (Drizzle)
+## Database (Drizzle ORM v1 beta)
 
+- **Driver**: `drizzle-orm/postgres-js` (NOT `bun-sql`)
+- **Validation**: `drizzle-orm/zod` (built-in, NOT separate `drizzle-zod` package)
+- **Relations**: Defined via `defineRelations()` in `src/server/db/relations.ts`
+- **Query**: RQBv2 — use `db.query.tableName.findMany()` with object-style `orderBy` and `where`
+
+### Schema Definition
 ```typescript
 import { pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core'
 import { sql } from 'drizzle-orm'
@@ -131,6 +151,43 @@ export const myTable = pgTable('my_table', {
 })
 ```
 
+### Relations (RQBv2)
+```typescript
+// src/server/db/relations.ts
+import { defineRelations } from 'drizzle-orm'
+import * as schema from './schema'
+
+export const relations = defineRelations(schema, (r) => ({
+  // Define relations here using r.one / r.many / r.through
+}))
+```
+
+### DB Instance
+```typescript
+// src/server/db/index.ts
+import { drizzle } from 'drizzle-orm/postgres-js'
+import { relations } from '@/server/db/relations'
+// In RQBv2, relations already contain schema info — no separate schema import needed
+
+const db = drizzle({
+  connection: env.DATABASE_URL,
+  relations,
+})
+```
+
+### RQBv2 Query Examples
+```typescript
+// Object-style orderBy (NOT callback style)
+const todos = await db.query.todoTable.findMany({
+  orderBy: { createdAt: 'desc' },
+})
+
+// Object-style where
+const todo = await db.query.todoTable.findFirst({
+  where: { id: someId },
+})
+```
+
 ## Code Style
 
 ### Formatting (Biome)
@@ -189,13 +246,24 @@ export const env = createEnv({
 })
 ```
 
+## Development Principles
+
+> **These principles apply to ALL code changes. Agents MUST follow them on every task.**
+
+1. **No backward compatibility** — This project is in rapid iteration. Always use the latest API and patterns. Never keep deprecated code paths or old API fallbacks.
+2. **Always sync documentation** — When code changes, immediately update all related documentation (`AGENTS.md`, `README.md`, inline code examples). Code and docs must never drift apart.
+3. **Forward-only migration** — When upgrading dependencies, fully adopt the new API. Don't mix old and new patterns.
+
 ## Critical Rules
 
 **DO:**
-- Run `bun fix` before committing
+- Run `bun run fix` before committing
 - Use `@/*` path aliases
 - Include `createdAt`/`updatedAt` on all tables
 - Use `ORPCError` with proper codes
+- Use `drizzle-orm/zod` (NOT `drizzle-zod`) for schema validation
+- Use RQBv2 object syntax for `orderBy` and `where`
+- Update `AGENTS.md` and other docs whenever code patterns change
 
 **DON'T:**
 - Use `npm`, `npx`, `node`, `yarn`, `pnpm` — always use `bun` / `bunx`
@@ -203,3 +271,9 @@ export const env = createEnv({
 - Use `as any`, `@ts-ignore`, `@ts-expect-error`
 - Commit `.env` files
 - Use empty catch blocks
+- Import from `drizzle-zod` (use `drizzle-orm/zod` instead)
+- Use RQBv1 callback-style `orderBy` / old `relations()` API
+- Use `drizzle-orm/bun-sql` driver (use `drizzle-orm/postgres-js`)
+- Pass `schema` to `drizzle()` constructor (only `relations` is needed in RQBv2)
+- Import `os` from `@orpc/server` in middleware — use `@/server/api/server` (the local typed instance)
+- Leave docs out of sync with code changes

apps/server/biome.json

@@ -3,5 +3,10 @@
   "extends": "//",
   "files": {
     "includes": ["**", "!**/routeTree.gen.ts"]
+  },
+  "css": {
+    "parser": {
+      "tailwindDirectives": true
+    }
   }
 }

apps/server/build.ts

@@ -1,111 +0,0 @@
-import { rm } from 'node:fs/promises'
-import path from 'node:path'
-import process from 'node:process'
-
-const ALL_TARGETS = [
-  'bun-windows-x64',
-  'bun-darwin-arm64',
-  'bun-darwin-x64',
-  'bun-linux-x64',
-  'bun-linux-arm64',
-] as const
-
-type BunTarget = (typeof ALL_TARGETS)[number]
-
-const ENTRYPOINT = '.output/server/index.mjs'
-const OUTDIR = 'out'
-const OUTFILE_BASE = 'server'
-
-const DEFAULT_TARGETS: BunTarget[] = [
-  'bun-windows-x64',
-  'bun-darwin-arm64',
-  'bun-linux-x64',
-]
-
-const suffixFor = (target: BunTarget) => target.replace('bun-', '')
-
-const isTarget = (value: string): value is BunTarget =>
-  (ALL_TARGETS as readonly string[]).includes(value)
-
-const parseTargets = (): BunTarget[] => {
-  const args = process.argv.slice(2)
-  const targets: string[] = []
-
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i]
-    const next = args[i + 1]
-    if (arg === '--target' && next) {
-      targets.push(next)
-      i++
-    } else if (arg === '--targets' && next) {
-      targets.push(...next.split(','))
-      i++
-    }
-  }
-
-  if (targets.length === 0) return DEFAULT_TARGETS
-
-  const invalid = targets.filter((t) => !isTarget(t))
-  if (invalid.length) {
-    throw new Error(
-      `Unknown target(s): ${invalid.join(', ')}\nAllowed: ${ALL_TARGETS.join(', ')}`,
-    )
-  }
-  return targets as BunTarget[]
-}
-
-const buildOne = async (target: BunTarget) => {
-  const suffix = suffixFor(target)
-  const outfile = `${OUTFILE_BASE}-${suffix}`
-
-  const result = await Bun.build({
-    entrypoints: [ENTRYPOINT],
-    outdir: OUTDIR,
-    compile: {
-      outfile,
-      target,
-    },
-  })
-
-  if (!result.success) {
-    throw new Error(
-      `Build failed for ${target}:\n${result.logs.map(String).join('\n')}`,
-    )
-  }
-
-  return {
-    target,
-    outputs: result.outputs.map((o) => path.relative('.', o.path)),
-  }
-}
-
-const main = async () => {
-  const targets = parseTargets()
-
-  await rm(OUTDIR, { recursive: true, force: true })
-  console.log(`✓ 已清理输出目录: ${OUTDIR}`)
-
-  // Bun cross-compile 不支持真正并行，逐目标串行构建
-  const results: Awaited<ReturnType<typeof buildOne>>[] = []
-  for (const target of targets) {
-    const start = Date.now()
-    process.stdout.write(`🔨 构建 ${target}... `)
-    const result = await buildOne(target)
-    results.push(result)
-    console.log(`完成 (${Date.now() - start}ms)`)
-  }
-
-  console.log('\n📦 构建完成:')
-  for (const r of results) {
-    console.log(`  ${r.target}:`)
-    for (const p of r.outputs) {
-      console.log(`    - ${p}`)
-    }
-  }
-}
-
-main().catch((err) => {
-  console.error('\n❌ 构建失败:')
-  console.error(err instanceof Error ? err.message : err)
-  process.exit(1)
-})

apps/server/compile.ts

@@ -0,0 +1,64 @@
+import { mkdir, rm } from 'node:fs/promises'
+import { parseArgs } from 'node:util'
+
+const ENTRYPOINT = '.output/server/index.mjs'
+const OUTDIR = 'out'
+
+const SUPPORTED_TARGETS: readonly Bun.Build.CompileTarget[] = [
+  'bun-windows-x64',
+  'bun-darwin-arm64',
+  'bun-darwin-x64',
+  'bun-linux-x64',
+  'bun-linux-arm64',
+]
+
+const isSupportedTarget = (value: string): value is Bun.Build.CompileTarget =>
+  (SUPPORTED_TARGETS as readonly string[]).includes(value)
+
+const { values } = parseArgs({
+  options: { target: { type: 'string' } },
+  strict: true,
+  allowPositionals: false,
+})
+
+const resolveTarget = (): Bun.Build.CompileTarget => {
+  if (values.target !== undefined) {
+    if (!isSupportedTarget(values.target)) {
+      throw new Error(`Invalid target: ${values.target}\nAllowed: ${SUPPORTED_TARGETS.join(', ')}`)
+    }
+    return values.target
+  }
+
+  const os = process.platform === 'win32' ? 'windows' : process.platform
+  const candidate = `bun-${os}-${process.arch}`
+  if (!isSupportedTarget(candidate)) {
+    throw new Error(`Unsupported host: ${process.platform}-${process.arch}`)
+  }
+  return candidate
+}
+
+const main = async () => {
+  const target = resolveTarget()
+  const suffix = target.replace('bun-', '')
+  const outfile = `server-${suffix}`
+
+  await mkdir(OUTDIR, { recursive: true })
+  await Promise.all([rm(`${OUTDIR}/${outfile}`, { force: true }), rm(`${OUTDIR}/${outfile}.exe`, { force: true })])
+
+  const result = await Bun.build({
+    entrypoints: [ENTRYPOINT],
+    outdir: OUTDIR,
+    compile: { outfile, target },
+  })
+
+  if (!result.success) {
+    throw new Error(result.logs.map(String).join('\n'))
+  }
+
+  console.log(`✓ ${target} → ${OUTDIR}/${outfile}`)
+}
+
+main().catch((err) => {
+  console.error('❌', err instanceof Error ? err.message : err)
+  process.exit(1)
+})

apps/server/package.json

@@ -4,18 +4,25 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "build": "vite build",
-    "compile": "bun build.ts",
+    "build": "bunx --bun vite build",
+    "compile": "bun compile.ts",
+    "compile:darwin": "bun run compile:darwin:arm64 && bun run compile:darwin:x64",
+    "compile:darwin:arm64": "bun compile.ts --target bun-darwin-arm64",
+    "compile:darwin:x64": "bun compile.ts --target bun-darwin-x64",
+    "compile:linux": "bun run compile:linux:x64 && bun run compile:linux:arm64",
+    "compile:linux:arm64": "bun compile.ts --target bun-linux-arm64",
+    "compile:linux:x64": "bun compile.ts --target bun-linux-x64",
+    "compile:windows": "bun run compile:windows:x64",
+    "compile:windows:x64": "bun compile.ts --target bun-windows-x64",
     "db:generate": "drizzle-kit generate",
     "db:migrate": "drizzle-kit migrate",
     "db:push": "drizzle-kit push",
     "db:studio": "drizzle-kit studio",
-    "dev": "vite dev",
+    "dev": "bunx --bun vite dev",
     "fix": "biome check --write",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@furtherverse/utils": "workspace:*",
     "@orpc/client": "catalog:",
     "@orpc/contract": "catalog:",
     "@orpc/openapi": "catalog:",
@@ -28,7 +35,6 @@
     "@tanstack/react-router-ssr-query": "catalog:",
     "@tanstack/react-start": "catalog:",
     "drizzle-orm": "catalog:",
-    "drizzle-zod": "catalog:",
     "postgres": "catalog:",
     "react": "catalog:",
     "react-dom": "catalog:",
@@ -48,7 +54,6 @@
     "drizzle-kit": "catalog:",
     "nitro": "catalog:",
     "tailwindcss": "catalog:",
-    "vite": "catalog:",
-    "vite-tsconfig-paths": "catalog:"
+    "vite": "catalog:"
   }
 }

apps/server/src/client/orpc.client.ts

@@ -1,24 +0,0 @@
-import { createORPCClient } from '@orpc/client'
-import { RPCLink } from '@orpc/client/fetch'
-import { createRouterClient } from '@orpc/server'
-import { createIsomorphicFn } from '@tanstack/react-start'
-import { getRequestHeaders } from '@tanstack/react-start/server'
-import { router } from '@/server/api/routers'
-import type { RouterClient } from '@/server/api/types'
-
-const getORPCClient = createIsomorphicFn()
-  .server(() =>
-    createRouterClient(router, {
-      context: () => ({
-        headers: getRequestHeaders(),
-      }),
-    }),
-  )
-  .client(() => {
-    const link = new RPCLink({
-      url: `${window.location.origin}/api/rpc`,
-    })
-    return createORPCClient<RouterClient>(link)
-  })
-
-export const orpc: RouterClient = getORPCClient()

apps/server/src/client/orpc.ts

@@ -0,0 +1,53 @@
+import { createORPCClient } from '@orpc/client'
+import { RPCLink } from '@orpc/client/fetch'
+import { createRouterClient } from '@orpc/server'
+import { createTanstackQueryUtils } from '@orpc/tanstack-query'
+import { createIsomorphicFn } from '@tanstack/react-start'
+import { getRequestHeaders } from '@tanstack/react-start/server'
+import { router } from '@/server/api/routers'
+import type { RouterClient } from '@/server/api/types'
+
+const getORPCClient = createIsomorphicFn()
+  .server(() =>
+    createRouterClient(router, {
+      context: () => ({
+        headers: getRequestHeaders(),
+      }),
+    }),
+  )
+  .client(() => {
+    const link = new RPCLink({
+      url: `${window.location.origin}/api/rpc`,
+    })
+    return createORPCClient<RouterClient>(link)
+  })
+
+const client: RouterClient = getORPCClient()
+
+export const orpc = createTanstackQueryUtils(client, {
+  experimental_defaults: {
+    todo: {
+      create: {
+        mutationOptions: {
+          onSuccess: (_, __, ___, ctx) => {
+            ctx.client.invalidateQueries({ queryKey: orpc.todo.list.key() })
+          },
+        },
+      },
+      update: {
+        mutationOptions: {
+          onSuccess: (_, __, ___, ctx) => {
+            ctx.client.invalidateQueries({ queryKey: orpc.todo.list.key() })
+          },
+        },
+      },
+      remove: {
+        mutationOptions: {
+          onSuccess: (_, __, ___, ctx) => {
+            ctx.client.invalidateQueries({ queryKey: orpc.todo.list.key() })
+          },
+        },
+      },
+    },
+  },
+})

apps/server/src/client/query-client.ts

@@ -1,30 +0,0 @@
-import { createTanstackQueryUtils } from '@orpc/tanstack-query'
-import { orpc as orpcClient } from './orpc.client'
-
-export const orpc = createTanstackQueryUtils(orpcClient, {
-  experimental_defaults: {
-    todo: {
-      create: {
-        mutationOptions: {
-          onSuccess: (_, __, ___, ctx) => {
-            ctx.client.invalidateQueries({ queryKey: orpc.todo.list.key() })
-          },
-        },
-      },
-      update: {
-        mutationOptions: {
-          onSuccess: (_, __, ___, ctx) => {
-            ctx.client.invalidateQueries({ queryKey: orpc.todo.list.key() })
-          },
-        },
-      },
-      remove: {
-        mutationOptions: {
-          onSuccess: (_, __, ___, ctx) => {
-            ctx.client.invalidateQueries({ queryKey: orpc.todo.list.key() })
-          },
-        },
-      },
-    },
-  },
-})

apps/server/src/routeTree.gen.ts

@@ -10,6 +10,7 @@
 
 import { Route as rootRouteImport } from './routes/__root'
 import { Route as IndexRouteImport } from './routes/index'
+import { Route as ApiHealthRouteImport } from './routes/api/health'
 import { Route as ApiSplatRouteImport } from './routes/api/$'
 import { Route as ApiRpcSplatRouteImport } from './routes/api/rpc.$'
 
@@ -18,6 +19,11 @@ const IndexRoute = IndexRouteImport.update({
   path: '/',
   getParentRoute: () => rootRouteImport,
 } as any)
+const ApiHealthRoute = ApiHealthRouteImport.update({
+  id: '/api/health',
+  path: '/api/health',
+  getParentRoute: () => rootRouteImport,
+} as any)
 const ApiSplatRoute = ApiSplatRouteImport.update({
   id: '/api/$',
   path: '/api/$',
@@ -32,30 +38,34 @@ const ApiRpcSplatRoute = ApiRpcSplatRouteImport.update({
 export interface FileRoutesByFullPath {
   '/': typeof IndexRoute
   '/api/$': typeof ApiSplatRoute
+  '/api/health': typeof ApiHealthRoute
   '/api/rpc/$': typeof ApiRpcSplatRoute
 }
 export interface FileRoutesByTo {
   '/': typeof IndexRoute
   '/api/$': typeof ApiSplatRoute
+  '/api/health': typeof ApiHealthRoute
   '/api/rpc/$': typeof ApiRpcSplatRoute
 }
 export interface FileRoutesById {
   __root__: typeof rootRouteImport
   '/': typeof IndexRoute
   '/api/$': typeof ApiSplatRoute
+  '/api/health': typeof ApiHealthRoute
   '/api/rpc/$': typeof ApiRpcSplatRoute
 }
 export interface FileRouteTypes {
   fileRoutesByFullPath: FileRoutesByFullPath
-  fullPaths: '/' | '/api/$' | '/api/rpc/$'
+  fullPaths: '/' | '/api/$' | '/api/health' | '/api/rpc/$'
   fileRoutesByTo: FileRoutesByTo
-  to: '/' | '/api/$' | '/api/rpc/$'
-  id: '__root__' | '/' | '/api/$' | '/api/rpc/$'
+  to: '/' | '/api/$' | '/api/health' | '/api/rpc/$'
+  id: '__root__' | '/' | '/api/$' | '/api/health' | '/api/rpc/$'
   fileRoutesById: FileRoutesById
 }
 export interface RootRouteChildren {
   IndexRoute: typeof IndexRoute
   ApiSplatRoute: typeof ApiSplatRoute
+  ApiHealthRoute: typeof ApiHealthRoute
   ApiRpcSplatRoute: typeof ApiRpcSplatRoute
 }
 
@@ -68,6 +78,13 @@ declare module '@tanstack/react-router' {
       preLoaderRoute: typeof IndexRouteImport
       parentRoute: typeof rootRouteImport
     }
+    '/api/health': {
+      id: '/api/health'
+      path: '/api/health'
+      fullPath: '/api/health'
+      preLoaderRoute: typeof ApiHealthRouteImport
+      parentRoute: typeof rootRouteImport
+    }
     '/api/$': {
       id: '/api/$'
       path: '/api/$'
@@ -88,6 +105,7 @@ declare module '@tanstack/react-router' {
 const rootRouteChildren: RootRouteChildren = {
   IndexRoute: IndexRoute,
   ApiSplatRoute: ApiSplatRoute,
+  ApiHealthRoute: ApiHealthRoute,
   ApiRpcSplatRoute: ApiRpcSplatRoute,
 }
 export const routeTree = rootRouteImport

apps/server/src/router.tsx

@@ -5,7 +5,14 @@ import type { RouterContext } from './routes/__root'
 import { routeTree } from './routeTree.gen'
 
 export const getRouter = () => {
-  const queryClient = new QueryClient()
+  const queryClient = new QueryClient({
+    defaultOptions: {
+      queries: {
+        staleTime: 30 * 1000,
+        retry: 1,
+      },
+    },
+  })
 
   const router = createRouter({
     routeTree,

apps/server/src/routes/__root.tsx

@@ -1,15 +1,11 @@
 import { TanStackDevtools } from '@tanstack/react-devtools'
 import type { QueryClient } from '@tanstack/react-query'
 import { ReactQueryDevtoolsPanel } from '@tanstack/react-query-devtools'
-import {
-  createRootRouteWithContext,
-  HeadContent,
-  Scripts,
-} from '@tanstack/react-router'
+import { createRootRouteWithContext, HeadContent, Scripts } from '@tanstack/react-router'
 import { TanStackRouterDevtoolsPanel } from '@tanstack/react-router-devtools'
 import type { ReactNode } from 'react'
 import { ErrorComponent } from '@/components/Error'
-import { NotFoundComponent } from '@/components/NotFount'
+import { NotFoundComponent } from '@/components/NotFound'
 import appCss from '@/styles.css?url'
 
 export interface RouterContext {
@@ -50,21 +46,23 @@ function RootDocument({ children }: Readonly<{ children: ReactNode }>) {
       </head>
       <body>
         {children}
-        <TanStackDevtools
-          config={{
-            position: 'bottom-right',
-          }}
-          plugins={[
-            {
-              name: 'TanStack Router',
-              render: <TanStackRouterDevtoolsPanel />,
-            },
-            {
-              name: 'TanStack Query',
-              render: <ReactQueryDevtoolsPanel />,
-            },
-          ]}
-        />
+        {import.meta.env.DEV && (
+          <TanStackDevtools
+            config={{
+              position: 'bottom-right',
+            }}
+            plugins={[
+              {
+                name: 'TanStack Router',
+                render: <TanStackRouterDevtoolsPanel />,
+              },
+              {
+                name: 'TanStack Query',
+                render: <ReactQueryDevtoolsPanel />,
+              },
+            ]}
+          />
+        )}
         <Scripts />
       </body>
     </html>

apps/server/src/routes/api/$.ts

@@ -1,10 +1,10 @@
 import { OpenAPIHandler } from '@orpc/openapi/fetch'
 import { OpenAPIReferencePlugin } from '@orpc/openapi/plugins'
-import { ORPCError, onError, ValidationError } from '@orpc/server'
+import { onError } from '@orpc/server'
 import { ZodToJsonSchemaConverter } from '@orpc/zod/zod4'
 import { createFileRoute } from '@tanstack/react-router'
-import { z } from 'zod'
 import { name, version } from '@/../package.json'
+import { handleValidationError, logError } from '@/server/api/interceptors'
 import { router } from '@/server/api/routers'
 
 const handler = new OpenAPIHandler(router, {
@@ -17,55 +17,13 @@ const handler = new OpenAPIHandler(router, {
           title: name,
           version,
         },
-        // components: {
-        //   securitySchemes: {
-        //     bearerAuth: {
-        //       type: 'http',
-        //       scheme: 'bearer',
-        //     },
-        //   },
-        // },
       },
       docsPath: '/docs',
       specPath: '/spec.json',
     }),
   ],
-  interceptors: [
-    onError((error) => {
-      console.error(error)
-    }),
-  ],
-  clientInterceptors: [
-    onError((error) => {
-      if (
-        error instanceof ORPCError &&
-        error.code === 'BAD_REQUEST' &&
-        error.cause instanceof ValidationError
-      ) {
-        // If you only use Zod you can safely cast to ZodIssue[]
-        const zodError = new z.ZodError(
-          error.cause.issues as z.core.$ZodIssue[],
-        )
-
-        throw new ORPCError('INPUT_VALIDATION_FAILED', {
-          status: 422,
-          message: z.prettifyError(zodError),
-          data: z.flattenError(zodError),
-          cause: error.cause,
-        })
-      }
-
-      if (
-        error instanceof ORPCError &&
-        error.code === 'INTERNAL_SERVER_ERROR' &&
-        error.cause instanceof ValidationError
-      ) {
-        throw new ORPCError('OUTPUT_VALIDATION_FAILED', {
-          cause: error.cause,
-        })
-      }
-    }),
-  ],
+  interceptors: [onError(logError)],
+  clientInterceptors: [onError(handleValidationError)],
 })
 
 export const Route = createFileRoute('/api/$')({

apps/server/src/routes/api/health.ts

@@ -0,0 +1,27 @@
+import { createFileRoute } from '@tanstack/react-router'
+import { name, version } from '@/../package.json'
+
+const createHealthResponse = (): Response =>
+  Response.json(
+    {
+      status: 'ok',
+      service: name,
+      version,
+      timestamp: new Date().toISOString(),
+    },
+    {
+      status: 200,
+      headers: {
+        'cache-control': 'no-store',
+      },
+    },
+  )
+
+export const Route = createFileRoute('/api/health')({
+  server: {
+    handlers: {
+      GET: async () => createHealthResponse(),
+      HEAD: async () => new Response(null, { status: 200 }),
+    },
+  },
+})

apps/server/src/routes/api/rpc.$.ts

@@ -1,46 +1,12 @@
-import { ORPCError, onError, ValidationError } from '@orpc/server'
+import { onError } from '@orpc/server'
 import { RPCHandler } from '@orpc/server/fetch'
 import { createFileRoute } from '@tanstack/react-router'
-import { z } from 'zod'
+import { handleValidationError, logError } from '@/server/api/interceptors'
 import { router } from '@/server/api/routers'
 
 const handler = new RPCHandler(router, {
-  interceptors: [
-    onError((error) => {
-      console.error(error)
-    }),
-  ],
-  clientInterceptors: [
-    onError((error) => {
-      if (
-        error instanceof ORPCError &&
-        error.code === 'BAD_REQUEST' &&
-        error.cause instanceof ValidationError
-      ) {
-        // If you only use Zod you can safely cast to ZodIssue[]
-        const zodError = new z.ZodError(
-          error.cause.issues as z.core.$ZodIssue[],
-        )
-
-        throw new ORPCError('INPUT_VALIDATION_FAILED', {
-          status: 422,
-          message: z.prettifyError(zodError),
-          data: z.flattenError(zodError),
-          cause: error.cause,
-        })
-      }
-
-      if (
-        error instanceof ORPCError &&
-        error.code === 'INTERNAL_SERVER_ERROR' &&
-        error.cause instanceof ValidationError
-      ) {
-        throw new ORPCError('OUTPUT_VALIDATION_FAILED', {
-          cause: error.cause,
-        })
-      }
-    }),
-  ],
+  interceptors: [onError(logError)],
+  clientInterceptors: [onError(handleValidationError)],
 })
 
 export const Route = createFileRoute('/api/rpc/$')({

apps/server/src/routes/index.tsx

@@ -1,8 +1,8 @@
 import { useMutation, useSuspenseQuery } from '@tanstack/react-query'
 import { createFileRoute } from '@tanstack/react-router'
-import type { ChangeEventHandler, FormEventHandler } from 'react'
+import type { ChangeEventHandler, SubmitEventHandler } from 'react'
 import { useState } from 'react'
-import { orpc } from '@/client/query-client'
+import { orpc } from '@/client/orpc'
 
 export const Route = createFileRoute('/')({
   component: Todos,
@@ -19,7 +19,7 @@ function Todos() {
   const updateMutation = useMutation(orpc.todo.update.mutationOptions())
   const deleteMutation = useMutation(orpc.todo.remove.mutationOptions())
 
-  const handleCreateTodo: FormEventHandler<HTMLFormElement> = (e) => {
+  const handleCreateTodo: SubmitEventHandler<HTMLFormElement> = (e) => {
     e.preventDefault()
     if (newTodoTitle.trim()) {
       createMutation.mutate({ title: newTodoTitle.trim() })
@@ -53,9 +53,7 @@ function Todos() {
         {/* Header */}
         <div className="flex items-end justify-between">
           <div>
-            <h1 className="text-3xl font-bold text-slate-900 tracking-tight">
-              我的待办
-            </h1>
+            <h1 className="text-3xl font-bold text-slate-900 tracking-tight">我的待办</h1>
             <p className="text-slate-500 mt-1">保持专注，逐个击破</p>
           </div>
           <div className="text-right">
@@ -63,9 +61,7 @@ function Todos() {
               {completedCount}
               <span className="text-slate-400 text-lg">/{totalCount}</span>
             </div>
-            <div className="text-xs font-medium text-slate-400 uppercase tracking-wider">
-              已完成
-            </div>
+            <div className="text-xs font-medium text-slate-400 uppercase tracking-wider">已完成</div>
           </div>
         </div>
 
@@ -112,18 +108,11 @@ function Todos() {
                   stroke="currentColor"
                   aria-hidden="true"
                 >
-                  <path
-                    strokeLinecap="round"
-                    strokeLinejoin="round"
-                    strokeWidth={1.5}
-                    d="M12 6v6m0 0v6m0-6h6m-6 0H6"
-                  />
+                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M12 6v6m0 0v6m0-6h6m-6 0H6" />
                 </svg>
               </div>
               <p className="text-slate-500 text-lg font-medium">没有待办事项</p>
-              <p className="text-slate-400 text-sm mt-1">
-                输入上方内容添加您的第一个任务
-              </p>
+              <p className="text-slate-400 text-sm mt-1">输入上方内容添加您的第一个任务</p>
             </div>
           ) : (
             todos.map((todo) => (
@@ -151,11 +140,7 @@ function Todos() {
                       strokeWidth={3}
                       aria-hidden="true"
                     >
-                      <path
-                        strokeLinecap="round"
-                        strokeLinejoin="round"
-                        d="M5 13l4 4L19 7"
-                      />
+                      <path strokeLinecap="round" strokeLinejoin="round" d="M5 13l4 4L19 7" />
                     </svg>
                   )}
                 </button>

apps/server/src/server/api/contracts/todo.contract.ts

@@ -1,25 +1,14 @@
 import { oc } from '@orpc/contract'
-import {
-  createInsertSchema,
-  createSelectSchema,
-  createUpdateSchema,
-} from 'drizzle-zod'
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/zod'
 import { z } from 'zod'
+import { generatedFieldKeys } from '@/server/db/fields'
 import { todoTable } from '@/server/db/schema'
 
 const selectSchema = createSelectSchema(todoTable)
 
-const insertSchema = createInsertSchema(todoTable).omit({
-  id: true,
-  createdAt: true,
-  updatedAt: true,
-})
+const insertSchema = createInsertSchema(todoTable).omit(generatedFieldKeys)
 
-const updateSchema = createUpdateSchema(todoTable).omit({
-  id: true,
-  createdAt: true,
-  updatedAt: true,
-})
+const updateSchema = createUpdateSchema(todoTable).omit(generatedFieldKeys)
 
 export const list = oc.input(z.void()).output(z.array(selectSchema))
 

apps/server/src/server/api/interceptors.ts

@@ -0,0 +1,26 @@
+import { ORPCError, ValidationError } from '@orpc/server'
+import { z } from 'zod'
+
+export const logError = (error: unknown) => {
+  console.error(error)
+}
+
+export const handleValidationError = (error: unknown) => {
+  if (error instanceof ORPCError && error.code === 'BAD_REQUEST' && error.cause instanceof ValidationError) {
+    // If you only use Zod you can safely cast to ZodIssue[] (per ORPC official docs)
+    const zodError = new z.ZodError(error.cause.issues as z.core.$ZodIssue[])
+
+    throw new ORPCError('INPUT_VALIDATION_FAILED', {
+      status: 422,
+      message: z.prettifyError(zodError),
+      data: z.flattenError(zodError),
+      cause: error.cause,
+    })
+  }
+
+  if (error instanceof ORPCError && error.code === 'INTERNAL_SERVER_ERROR' && error.cause instanceof ValidationError) {
+    throw new ORPCError('OUTPUT_VALIDATION_FAILED', {
+      cause: error.cause,
+    })
+  }
+}

apps/server/src/server/api/middlewares/db.middleware.ts

@@ -1,4 +1,4 @@
-import { os } from '@orpc/server'
+import { os } from '@/server/api/server'
 import { getDB } from '@/server/db'
 
 export const db = os.middleware(async ({ context, next }) => {

apps/server/src/server/api/routers/todo.router.ts

@@ -6,44 +6,35 @@ import { os } from '../server'
 
 export const list = os.todo.list.use(db).handler(async ({ context }) => {
   const todos = await context.db.query.todoTable.findMany({
-    orderBy: (todos, { desc }) => [desc(todos.createdAt)],
+    orderBy: { createdAt: 'desc' },
   })
   return todos
 })
 
-export const create = os.todo.create
-  .use(db)
-  .handler(async ({ context, input }) => {
-    const [newTodo] = await context.db
-      .insert(todoTable)
-      .values(input)
-      .returning()
+export const create = os.todo.create.use(db).handler(async ({ context, input }) => {
+  const [newTodo] = await context.db.insert(todoTable).values(input).returning()
 
-    if (!newTodo) {
-      throw new ORPCError('NOT_FOUND')
-    }
+  if (!newTodo) {
+    throw new ORPCError('INTERNAL_SERVER_ERROR', { message: 'Failed to create todo' })
+  }
 
-    return newTodo
-  })
+  return newTodo
+})
 
-export const update = os.todo.update
-  .use(db)
-  .handler(async ({ context, input }) => {
-    const [updatedTodo] = await context.db
-      .update(todoTable)
-      .set(input.data)
-      .where(eq(todoTable.id, input.id))
-      .returning()
+export const update = os.todo.update.use(db).handler(async ({ context, input }) => {
+  const [updatedTodo] = await context.db.update(todoTable).set(input.data).where(eq(todoTable.id, input.id)).returning()
 
-    if (!updatedTodo) {
-      throw new ORPCError('NOT_FOUND')
-    }
+  if (!updatedTodo) {
+    throw new ORPCError('NOT_FOUND')
+  }
 
-    return updatedTodo
-  })
+  return updatedTodo
+})
 
-export const remove = os.todo.remove
-  .use(db)
-  .handler(async ({ context, input }) => {
-    await context.db.delete(todoTable).where(eq(todoTable.id, input.id))
-  })
+export const remove = os.todo.remove.use(db).handler(async ({ context, input }) => {
+  const [deleted] = await context.db.delete(todoTable).where(eq(todoTable.id, input.id)).returning({ id: todoTable.id })
+
+  if (!deleted) {
+    throw new ORPCError('NOT_FOUND')
+  }
+})

apps/server/src/server/api/types.ts

@@ -1,8 +1,4 @@
-import type {
-  ContractRouterClient,
-  InferContractRouterInputs,
-  InferContractRouterOutputs,
-} from '@orpc/contract'
+import type { ContractRouterClient, InferContractRouterInputs, InferContractRouterOutputs } from '@orpc/contract'
 import type { Contract } from './contracts'
 
 export type RouterClient = ContractRouterClient<Contract>

apps/server/src/server/db/fields.ts

@@ -4,7 +4,7 @@ import { v7 as uuidv7 } from 'uuid'
 
 // id
 
-export const id = (name: string) => uuid(name)
+const id = (name: string) => uuid(name)
 export const pk = (name: string, strategy?: 'native' | 'extension') => {
   switch (strategy) {
     // PG 18+
@@ -25,8 +25,7 @@ export const pk = (name: string, strategy?: 'native' | 'extension') => {
 
 // timestamp
 
-export const createdAt = (name = 'created_at') =>
-  timestamp(name, { withTimezone: true }).notNull().defaultNow()
+export const createdAt = (name = 'created_at') => timestamp(name, { withTimezone: true }).notNull().defaultNow()
 
 export const updatedAt = (name = 'updated_at') =>
   timestamp(name, { withTimezone: true })
@@ -43,9 +42,7 @@ export const generatedFields = {
 }
 
 // Helper to create omit keys from generatedFields
-const createGeneratedFieldKeys = <T extends Record<string, unknown>>(
-  fields: T,
-): Record<keyof T, true> => {
+const createGeneratedFieldKeys = <T extends Record<string, unknown>>(fields: T): Record<keyof T, true> => {
   return Object.keys(fields).reduce(
     (acc, key) => {
       acc[key as keyof T] = true

apps/server/src/server/db/index.ts

@@ -1,14 +1,11 @@
 import { drizzle } from 'drizzle-orm/postgres-js'
 import { env } from '@/env'
-import * as schema from '@/server/db/schema'
+import { relations } from '@/server/db/relations'
 
 export const createDB = () =>
   drizzle({
-    connection: {
-      url: env.DATABASE_URL,
-      prepare: true,
-    },
-    schema,
+    connection: env.DATABASE_URL,
+    relations,
   })
 
 export type DB = ReturnType<typeof createDB>

apps/server/src/server/db/relations.ts

@@ -0,0 +1,4 @@
+import { defineRelations } from 'drizzle-orm'
+import * as schema from './schema'
+
+export const relations = defineRelations(schema, (_r) => ({}))

apps/server/src/server/db/schema/todo.ts

@@ -1,5 +1,5 @@
 import { boolean, pgTable, text } from 'drizzle-orm/pg-core'
-import { generatedFields } from './utils/field'
+import { generatedFields } from '../fields'
 
 export const todoTable = pgTable('todo', {
   ...generatedFields,

apps/server/turbo.json

@@ -4,9 +4,43 @@
   "tasks": {
     "build": {
       "env": ["NODE_ENV", "VITE_*"],
+      "inputs": ["src/**", "public/**", "package.json", "tsconfig.json", "vite.config.ts"],
       "outputs": [".output/**"]
     },
     "compile": {
+      "dependsOn": ["build"],
+      "outputs": ["out/**"]
+    },
+    "compile:darwin": {
+      "dependsOn": ["build"],
+      "outputs": ["out/**"]
+    },
+    "compile:darwin:arm64": {
+      "dependsOn": ["build"],
+      "outputs": ["out/**"]
+    },
+    "compile:darwin:x64": {
+      "dependsOn": ["build"],
+      "outputs": ["out/**"]
+    },
+    "compile:linux": {
+      "dependsOn": ["build"],
+      "outputs": ["out/**"]
+    },
+    "compile:linux:arm64": {
+      "dependsOn": ["build"],
+      "outputs": ["out/**"]
+    },
+    "compile:linux:x64": {
+      "dependsOn": ["build"],
+      "outputs": ["out/**"]
+    },
+    "compile:windows": {
+      "dependsOn": ["build"],
+      "outputs": ["out/**"]
+    },
+    "compile:windows:x64": {
+      "dependsOn": ["build"],
       "outputs": ["out/**"]
     }
   }

apps/server/vite.config.ts

@@ -4,17 +4,11 @@ import { tanstackStart } from '@tanstack/react-start/plugin/vite'
 import react from '@vitejs/plugin-react'
 import { nitro } from 'nitro/vite'
 import { defineConfig } from 'vite'
-import tsconfigPaths from 'vite-tsconfig-paths'
 
 export default defineConfig({
   clearScreen: false,
   plugins: [
     tanstackDevtools(),
-    nitro({
-      preset: 'bun',
-      serveStatic: 'inline',
-    }),
-    tsconfigPaths(),
     tailwindcss(),
     tanstackStart(),
     react({
@@ -22,12 +16,16 @@ export default defineConfig({
         plugins: ['babel-plugin-react-compiler'],
       },
     }),
+    nitro({
+      preset: 'bun',
+      serveStatic: 'inline',
+    }),
   ],
+  resolve: {
+    tsconfigPaths: true,
+  },
   server: {
     port: 3000,
     strictPort: true,
-    watch: {
-      ignored: ['**/src-tauri/**'],
-    },
   },
 })

biome.json

@@ -11,7 +11,8 @@
   "formatter": {
     "enabled": true,
     "indentStyle": "space",
-    "lineEnding": "lf"
+    "lineEnding": "lf",
+    "lineWidth": 120
   },
   "linter": {
     "enabled": true,

package.json

@@ -10,53 +10,57 @@
   "scripts": {
     "build": "turbo run build",
     "compile": "turbo run compile",
+    "compile:darwin": "turbo run compile:darwin",
+    "compile:linux": "turbo run compile:linux",
+    "compile:windows": "turbo run compile:windows",
     "dev": "turbo run dev",
+    "dist": "turbo run dist",
+    "dist:linux": "turbo run dist:linux",
+    "dist:mac": "turbo run dist:mac",
+    "dist:win": "turbo run dist:win",
     "fix": "turbo run fix",
     "typecheck": "turbo run typecheck"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.14",
-    "turbo": "^2.8.3",
+    "@biomejs/biome": "^2.4.8",
+    "turbo": "^2.8.20",
     "typescript": "^5.9.3"
   },
   "catalog": {
-    "@biomejs/biome": "^2.3.11",
-    "@orpc/client": "^1.13.4",
-    "@orpc/contract": "^1.13.4",
-    "@orpc/openapi": "^1.13.4",
-    "@orpc/server": "^1.13.4",
-    "@orpc/tanstack-query": "^1.13.4",
-    "@orpc/zod": "^1.13.4",
+    "@orpc/client": "^1.13.9",
+    "@orpc/contract": "^1.13.9",
+    "@orpc/openapi": "^1.13.9",
+    "@orpc/server": "^1.13.9",
+    "@orpc/tanstack-query": "^1.13.9",
+    "@orpc/zod": "^1.13.9",
     "@t3-oss/env-core": "^0.13.10",
-    "@tailwindcss/vite": "^4.1.18",
-    "@tanstack/devtools-vite": "^0.5.0",
-    "@tanstack/react-devtools": "^0.9.4",
-    "@tanstack/react-query": "^5.90.20",
-    "@tanstack/react-query-devtools": "^5.91.3",
-    "@tanstack/react-router": "^1.158.1",
-    "@tanstack/react-router-devtools": "^1.158.1",
-    "@tanstack/react-router-ssr-query": "^1.158.1",
-    "@tanstack/react-start": "^1.158.3",
-    "@types/bun": "^1.3.8",
-    "@types/node": "^24.3.0",
-    "@vitejs/plugin-react": "^5.1.3",
+    "@tailwindcss/vite": "^4.2.2",
+    "@tanstack/devtools-vite": "^0.5.5",
+    "@tanstack/react-devtools": "^0.9.13",
+    "@tanstack/react-query": "^5.94.4",
+    "@tanstack/react-query-devtools": "^5.94.4",
+    "@tanstack/react-router": "^1.168.1",
+    "@tanstack/react-router-devtools": "^1.166.10",
+    "@tanstack/react-router-ssr-query": "^1.166.10",
+    "@tanstack/react-start": "^1.167.2",
+    "@types/bun": "^1.3.11",
+    "@types/node": "^24.12.0",
+    "@vitejs/plugin-react": "^5.2.0",
     "babel-plugin-react-compiler": "^1.0.0",
-    "drizzle-kit": "^0.31.8",
-    "drizzle-orm": "^0.45.1",
-    "drizzle-zod": "^0.8.3",
-    "electrobun": "0.8.0",
-    "nitro": "npm:nitro-nightly@3.0.1-20260206-171553-bc737c0c",
-    "ohash": "^2.0.11",
+    "drizzle-kit": "1.0.0-beta.15-859cf75",
+    "drizzle-orm": "1.0.0-beta.15-859cf75",
+    "electron": "^34.0.0",
+    "electron-builder": "^26.8.1",
+    "electron-vite": "^5.0.0",
+    "motion": "^12.38.0",
+    "nitro": "npm:nitro-nightly@3.0.1-20260320-182900-2218d454",
     "postgres": "^3.4.8",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
-    "systeminformation": "^5.30.7",
-    "tailwindcss": "^4.1.18",
-    "turbo": "^2.7.5",
-    "typescript": "^5.9.3",
+    "tailwindcss": "^4.2.2",
+    "tree-kill": "^1.2.2",
     "uuid": "^13.0.0",
-    "vite": "^8.0.0-beta.13",
-    "vite-tsconfig-paths": "^6.0.5",
+    "vite": "^8.0.1",
     "zod": "^4.3.6"
   },
   "overrides": {

packages/utils/package.json

@@ -1,20 +0,0 @@
-{
-  "name": "@furtherverse/utils",
-  "version": "1.0.0",
-  "private": true,
-  "type": "module",
-  "imports": {
-    "#*": "./src/*"
-  },
-  "exports": {
-    ".": "./src/index.ts",
-    "./*": "./src/*.ts"
-  },
-  "dependencies": {
-    "ohash": "catalog:",
-    "systeminformation": "catalog:"
-  },
-  "devDependencies": {
-    "@furtherverse/tsconfig": "workspace:*"
-  }
-}

packages/utils/src/fingerprint.ts

@@ -1,29 +0,0 @@
-import { hash } from 'ohash'
-import si from 'systeminformation'
-
-async function getSystemInfo() {
-  const [uuid, baseboard, bios, system, diskLayout, networkInterfaces] =
-    await Promise.all([
-      si.uuid(),
-      si.baseboard(),
-      si.bios(),
-      si.system(),
-      si.diskLayout(),
-      si.networkInterfaces(),
-    ])
-
-  return {
-    uuid,
-    baseboard,
-    bios,
-    system,
-    diskLayout,
-    networkInterfaces,
-  }
-}
-
-export async function getHardwareFingerprint() {
-  const systemInfo = await getSystemInfo()
-
-  return hash(systemInfo)
-}

packages/utils/src/index.ts

@@ -1 +0,0 @@
-export * from './fingerprint'

turbo.json

@@ -6,9 +6,6 @@
     "build": {
       "dependsOn": ["^build"]
     },
-    "compile": {
-      "dependsOn": ["build"]
-    },
     "dev": {
       "cache": false,
       "persistent": true
@@ -17,12 +14,7 @@
       "cache": false
     },
     "typecheck": {
-      "inputs": [
-        "package.json",
-        "tsconfig.json",
-        "tsconfig.*.json",
-        "**/*.{ts,tsx,d.ts}"
-      ],
+      "inputs": ["package.json", "tsconfig.json", "tsconfig.*.json", "**/*.{ts,tsx,d.ts}"],
       "outputs": []
     }
   },