refactor(orpc): simplify architecture following KISS principle

- Fix NotFount.tsx typo -> NotFound.tsx
- Restructure ORPC: server -> middlewares -> procedures -> handlers
- Remove std-env dependency and over-engineered ephemeral detection
- Add procedures.ts as middleware composition layer
- Use globalThis for DB singleton (survives HMR)
- Preserve context in middleware (fix context merge bug)
- Remove unused ORPCContextWithDb type

.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/settings.json

@@ -37,8 +37,7 @@
   "files.associations": {
     ".env": "dotenv",
     ".env.*": "dotenv",
-    "**/tsconfig.json": "jsonc",
-    "**/tsconfig.*.json": "jsonc",
+    "**/tsconfig*.json": "jsonc",
     "**/biome.json": "jsonc",
     "**/opencode.json": "jsonc"
   },

AGENTS.md

@@ -1,178 +1,193 @@
 # AGENTS.md - AI Coding Agent Guidelines
 
-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`.**
+TanStack Start fullstack app with Tauri desktop shell.
 
-- **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)
+| Layer | Tech |
+|-------|------|
+| Framework | TanStack Start (React SSR, file-based routing) |
+| Runtime | Bun |
+| Language | TypeScript (strict mode) |
+| Styling | Tailwind CSS v4 |
+| Database | PostgreSQL + Drizzle ORM |
+| RPC | ORPC (contract-first, type-safe) |
+| Build | Vite + Turbo |
+| Linting | Biome |
+| Desktop | Tauri v2 (optional, see `src-tauri/AGENTS.md`) |
 
-## Build / Lint / Test Commands
+## 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
+# Development
+bun dev              # Start Tauri + Vite via Turbo
+bun dev:vite         # Vite only (localhost:3000)
+bun db:studio        # Drizzle Studio
+
+# Build
+bun build            # Full build (Vite → compile → Tauri)
+bun build:vite       # Vite only (outputs to .output/)
+
+# Code Quality
+bun typecheck        # TypeScript check (tsc -b)
+bun fix              # Biome auto-fix (format + lint)
+
+# Database
+bun db:generate      # Generate migrations from schema
+bun db:migrate       # Run migrations
+bun db:push          # Push schema changes (dev only)
+
+# Testing (not configured yet)
+# When adding tests, use Vitest or Bun test runner:
+# bun test path/to/test.ts        # Single file
+# bun test -t "pattern"           # By test name
 ```
 
-### 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
+## Code Style
 
-# 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
-```
+### Formatting (Biome enforced)
 
-### 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
-```
-
-### Testing
-No test framework configured yet. When adding tests:
-```bash
-bun test path/to/test.ts              # Run single test file
-bun test -t "pattern"                 # Run tests matching pattern
-```
-
-## Code Style (TypeScript)
-
-### Formatting (Biome)
-- **Indent**: 2 spaces | **Line endings**: LF
-- **Quotes**: Single `'` | **Semicolons**: Omit (ASI)
-- **Arrow parentheses**: Always `(x) => x`
+- **Indent**: 2 spaces
+- **Line endings**: LF
+- **Quotes**: Single `'string'`
+- **Semicolons**: As needed (ASI)
+- **Arrow parens**: Always `(x) => x`
 
 ### Imports
-Biome auto-organizes. Order: 1) External packages → 2) Internal `@/*` aliases → 3) Type imports (`import type { ... }`)
+
+Biome auto-organizes. Order: external → internal (`@/*`) → type-only imports.
 
 ```typescript
 import { createFileRoute } from '@tanstack/react-router'
 import { z } from 'zod'
-import { db } from '@/server/db'
+import { db } from '@/db'
 import type { ReactNode } from 'react'
 ```
 
-### TypeScript Strictness
-- `strict: true`, `noUncheckedIndexedAccess: true`, `noImplicitOverride: true`, `verbatimModuleSyntax: true`
-- Use `@/*` path aliases (maps to `src/*`)
+### TypeScript
 
-### Naming Conventions
-| Type | Convention | Example |
-|------|------------|---------|
-| Files (utils) | kebab-case | `auth-utils.ts` |
-| Files (components) | PascalCase | `UserProfile.tsx` |
-| Components | PascalCase arrow | `const Button = () => {}` |
-| Functions | camelCase | `getUserById` |
-| Constants | UPPER_SNAKE | `MAX_RETRIES` |
-| Types/Interfaces | PascalCase | `UserProfile` |
+Strict mode with extra checks:
+- `noUncheckedIndexedAccess: true` - array/object index returns `T | undefined`
+- `noImplicitOverride: true`
+- `verbatimModuleSyntax: true`
+
+Path alias: `@/*` → `src/*`
+
+### Naming
+
+| Entity | Convention | Example |
+|--------|------------|---------|
+| Files (utils) | kebab-case | `utils.ts`, `db-provider.ts` |
+| Files (components) | PascalCase | `NotFound.tsx` |
+| Routes | TanStack conventions | `routes/index.tsx`, `routes/__root.tsx` |
+| Components | PascalCase arrow functions | `const MyComponent = () => {}` |
+| Functions | camelCase | `handleSubmit` |
+| Constants | UPPER_SNAKE_CASE | `MAX_RETRIES` |
+| Types/Interfaces | PascalCase | `TodoItem`, `RouterContext` |
 
 ### React Patterns
-- Components: arrow functions (enforced by Biome)
-- Routes: TanStack Router file conventions (`export const Route = createFileRoute(...)`)
-- Data fetching: `useSuspenseQuery(orpc.feature.list.queryOptions())`
-- Let React Compiler handle memoization (no manual `useMemo`/`useCallback`)
-
-### Error Handling
-- Use `try-catch` for async operations; throw descriptive errors
-- ORPC: Use `ORPCError` with proper codes (`NOT_FOUND`, `INPUT_VALIDATION_FAILED`)
-- Never use empty catch blocks
-
-## Database (Drizzle ORM)
 
 ```typescript
+// Components: arrow functions (Biome enforces)
+const MyComponent = ({ title }: { title: string }) => {
+  return <div>{title}</div>
+}
+
+// Routes: createFileRoute
+export const Route = createFileRoute('/')({
+  component: Home,
+  loader: async ({ context }) => {
+    await context.queryClient.ensureQueryData(orpc.todo.list.queryOptions())
+  },
+})
+
+// Data fetching: TanStack Query
+const query = useSuspenseQuery(orpc.todo.list.queryOptions())
+const mutation = useMutation(orpc.todo.create.mutationOptions())
+```
+
+### ORPC Pattern (Contract-First RPC)
+
+1. **Define contract** (`src/orpc/contracts/my-feature.ts`):
+```typescript
+import { oc } from '@orpc/contract'
+import { z } from 'zod'
+
+export const get = oc.input(z.object({ id: z.uuid() })).output(schema)
+export const create = oc.input(insertSchema).output(schema)
+```
+
+2. **Implement handler** (`src/orpc/handlers/my-feature.ts`):
+```typescript
+import { os } from '@/orpc/server'
+import { dbProvider } from '@/orpc/middlewares'
+
+export const get = os.myFeature.get
+  .use(dbProvider)
+  .handler(async ({ context, input }) => {
+    return await context.db.query.myTable.findFirst(...)
+  })
+```
+
+3. **Register** in `contract.ts` and `router.ts`
+4. **Use** in components via `orpc.myFeature.get.queryOptions()`
+
+### Drizzle Schema
+
+```typescript
+import { sql } from 'drizzle-orm'
+import { pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core'
+
 export const myTable = pgTable('my_table', {
-  id: uuid().primaryKey().default(sql`uuidv7()`),
-  name: text().notNull(),
-  createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp({ withTimezone: true }).notNull().defaultNow().$onUpdateFn(() => new Date()),
+  id: uuid('id').primaryKey().default(sql`uuidv7()`),
+  name: text('name').notNull(),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow().$onUpdateFn(() => new Date()),
 })
 ```
 
-## Environment Variables
+### Environment Variables
 
-- Use `@t3-oss/env-core` with Zod validation in `src/env.ts`
-- Server vars: no prefix | Client vars: `VITE_` prefix required
-- Never commit `.env` files
-
-## Dependency Management
-
-- All versions centralized in root `package.json` `catalog` field
-- Workspace packages use `"catalog:"` — never hardcode versions
-- Internal packages use `"workspace:*"` references
-
-## Critical Rules
-
-**DO:**
-- Run `bun fix` before committing
-- Use `@/*` path aliases (not relative imports)
-- Include `createdAt`/`updatedAt` on all tables
-- Use `catalog:` for dependency versions
-
-**DON'T:**
-- Use `npm`, `npx`, `node`, `yarn`, `pnpm` — always use `bun` / `bunx`
-- Edit `src/routeTree.gen.ts` (auto-generated)
-- Use `as any`, `@ts-ignore`, `@ts-expect-error`
-- Commit `.env` files
-- Use empty catch blocks `catch(e) {}`
-- Hardcode dependency versions in workspace packages
-
-## 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
-5. Commit with descriptive message
+- Server: no prefix (e.g., `DATABASE_URL`)
+- Client: `VITE_` prefix required
+- Validated via `@t3-oss/env-core` in `src/env.ts`
 
 ## Directory Structure
 
 ```
-.
-├── apps/
-│   ├── server/           # TanStack Start fullstack app
-│   │   ├── src/
-│   │   │   ├── client/   # ORPC client, Query client
-│   │   │   ├── components/
-│   │   │   ├── routes/   # File-based routing
-│   │   │   └── server/   # API layer + database
-│   │   │       ├── api/  # ORPC contracts, routers, middlewares
-│   │   │       └── db/   # Drizzle schema
-│   │   └── AGENTS.md
-│   └── desktop/          # Electrobun desktop shell
-│       ├── src/
-│       │   └── bun/
-│       │       └── index.ts       # Main process entry
-│       ├── electrobun.config.ts   # Electrobun configuration
-│       └── AGENTS.md
-├── packages/
-│   ├── tsconfig/         # Shared TS configs
-│   └── utils/            # Shared utilities
-├── biome.json            # Linting/formatting config
-├── turbo.json            # Turbo task orchestration
-└── package.json          # Workspace root + dependency catalog
+src/
+├── components/          # Reusable React components
+├── db/
+│   ├── schema/         # Drizzle schema definitions
+│   └── index.ts        # Database instance
+├── integrations/       # TanStack Query/Router setup
+├── lib/                # Utility functions
+├── orpc/
+│   ├── contracts/      # Input/output schemas
+│   ├── handlers/       # Server procedure implementations
+│   ├── middlewares/    # Middleware (e.g., dbProvider)
+│   ├── contract.ts     # Contract aggregation
+│   ├── router.ts       # Router composition
+│   └── client.ts       # Isomorphic client
+├── routes/             # File-based routes
+│   ├── __root.tsx      # Root layout
+│   └── api/rpc.$.ts    # ORPC HTTP endpoint
+└── env.ts              # Environment validation
 ```
 
-## See Also
+## Critical Rules
 
-- `apps/server/AGENTS.md` - Detailed TanStack Start / ORPC patterns
-- `apps/desktop/AGENTS.md` - Electrobun desktop development guide
+- **DO NOT** edit `src/routeTree.gen.ts` (auto-generated)
+- **DO NOT** commit `.env` files
+- **MUST** run `bun fix` before commits
+- **MUST** use `@/*` path alias (not relative imports)
+- **MUST** use React Compiler (no manual memoization needed)
+- **MUST** use `Readonly<T>` for immutable props
+
+## Git Workflow
+
+1. Make changes following style guide
+2. Run `bun fix` (format + lint)
+3. Run `bun typecheck` (type safety)
+4. Test with `bun dev`
+5. Commit with descriptive message

apps/desktop/.gitignore

@@ -1,3 +0,0 @@
-# Electrobun build output
-build/
-artifacts/

apps/desktop/AGENTS.md

@@ -1,131 +0,0 @@
-# AGENTS.md - Desktop App Guidelines
-
-Thin Electrobun 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`.**
-
-- **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
-
-## 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.
-
-## 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
-```
-
-## Directory Structure
-
-```
-.
-├── 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)
-```
-
-## 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.
-
-## Production Architecture
-
-### 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.
-
-### 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**: A free port is pre-allocated via `node:net` (`createServer` on `127.0.0.1:0`), then passed to the server as the `PORT` environment variable.
-- **Readiness Check**: The main process polls the server URL with `fetch` until it responds, rather than parsing stdout.
-- **Retry**: If the server fails to become ready (timeout or early exit), the process is killed and a new attempt is made with a fresh port (up to 3 retries).
-- **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.
-
-## Environment Detection
-
-The application determines its environment via the `ELECTROBUN_BUILD_ENV` variable, automatically set by the Electrobun CLI:
-
-```typescript
-const isDev = () => {
-  const env = process.env.ELECTROBUN_BUILD_ENV
-  return !env || env === 'dev'
-}
-```
-
-- **dev**: Development mode (connects to external host).
-- **canary / stable**: Production mode (starts embedded server).
-
-## 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')
-```
-
-## Critical Rules
-
-**DO:**
-- Use arrow functions for all components and utility functions.
-- Ensure `apps/server` is built before building `apps/desktop` (handled by Turbo).
-- Pre-allocate a free port and pass it via `PORT` env var instead of parsing stdout.
-- Handle server process termination to avoid orphan processes.
-- 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 `as any` or `@ts-ignore`.

apps/desktop/electrobun.config.ts

@@ -1,27 +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',
-    },
-    targets: 'win-x64',
-    linux: {
-      bundleCEF: true,
-    },
-    mac: {
-      bundleCEF: false,
-    },
-    win: {
-      bundleCEF: false,
-    },
-  },
-} satisfies ElectrobunConfig

apps/desktop/package.json

@@ -1,19 +0,0 @@
-{
-  "name": "@furtherverse/desktop",
-  "version": "1.0.0",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "build": "electrobun build --env=stable",
-    "dev": "electrobun build && electrobun dev",
-    "fix": "biome check --write",
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "electrobun": "catalog:"
-  },
-  "devDependencies": {
-    "@furtherverse/tsconfig": "workspace:*",
-    "@types/bun": "catalog:"
-  }
-}

apps/desktop/src/bun/index.ts

@@ -1,166 +0,0 @@
-import { createServer } from 'node:net'
-import { dirname, join } from 'node:path'
-import { BrowserWindow, PATHS } from 'electrobun/bun'
-
-const DEV_SERVER_URL = 'http://localhost:3000'
-const SERVER_READY_TIMEOUT_MS = 5_000
-const MAX_SPAWN_RETRIES = 3
-
-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 getFreePort = (): Promise<number> => {
-  return new Promise((resolve, reject) => {
-    const srv = createServer()
-    srv.unref()
-    srv.once('error', reject)
-    srv.listen({ port: 0, host: '127.0.0.1', exclusive: true }, () => {
-      const addr = srv.address()
-      if (addr && typeof addr === 'object') {
-        const port = addr.port
-        srv.close((err) => (err ? reject(err) : resolve(port)))
-      } else {
-        srv.close(() => reject(new Error('Unexpected address() result')))
-      }
-    })
-  })
-}
-
-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)
-
-  for (let attempt = 1; attempt <= MAX_SPAWN_RETRIES; attempt++) {
-    const port = await getFreePort()
-    const url = `http://127.0.0.1:${port}`
-
-    const serverProc = Bun.spawn([process.execPath, serverEntryPath], {
-      cwd: serverDir,
-      env: {
-        ...process.env,
-        PORT: String(port),
-        HOST: '127.0.0.1',
-      },
-      stdio: ['ignore', 'inherit', 'inherit'],
-    })
-
-    const ready = await Promise.race([
-      waitForServer(url),
-      serverProc.exited.then((code) => {
-        throw new Error(`Server exited with code ${code} before becoming ready`)
-      }),
-    ])
-
-    if (ready) {
-      return { process: serverProc, url }
-    }
-
-    serverProc.kill()
-    await serverProc.exited
-    console.warn(
-      `Server failed to become ready on port ${port} (attempt ${attempt}/${MAX_SPAWN_RETRIES})`,
-    )
-  }
-
-  throw new Error(`Server failed to start after ${MAX_SPAWN_RETRIES} attempts`)
-}
-
-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/tsconfig.json

@@ -1,6 +0,0 @@
-{
-  "extends": "@furtherverse/tsconfig/bun.json",
-  "compilerOptions": {
-    "lib": ["ESNext", "DOM", "DOM.Iterable"]
-  }
-}

apps/desktop/turbo.json

@@ -1,10 +0,0 @@
-{
-  "$schema": "../../node_modules/turbo/schema.json",
-  "extends": ["//"],
-  "tasks": {
-    "build": {
-      "dependsOn": ["@furtherverse/server#build"],
-      "outputs": ["build/**", "artifacts/**"]
-    }
-  }
-}

apps/server/AGENTS.md

@@ -1,205 +0,0 @@
-# AGENTS.md - Server App Guidelines
-
-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`.**
-
-- **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
-- **State**: TanStack Query v5
-- **RPC**: ORPC (contract-first, type-safe)
-- **Build**: Vite + Nitro
-
-## Commands
-
-```bash
-# Development
-bun dev                    # Vite dev server (localhost:3000)
-bun db:studio              # Drizzle Studio GUI
-
-# Build
-bun build                  # Production build → .output/
-bun compile                # Compile to standalone binary
-
-# Code Quality
-bun fix                    # Biome auto-fix
-bun typecheck              # TypeScript check
-
-# Database
-bun db:generate            # Generate migrations from schema
-bun db:migrate             # Run migrations
-bun 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
-```
-
-## Directory Structure
-
-```
-src/
-├── client/                # Client-side code
-│   ├── orpc.client.ts     # ORPC isomorphic client
-│   └── query-client.ts    # TanStack Query client
-├── components/            # React components
-├── routes/                # TanStack Router file routes
-│   ├── __root.tsx         # Root layout
-│   ├── index.tsx          # Home page
-│   └── api/
-│       └── rpc.$.ts       # ORPC HTTP endpoint
-├── server/                # Server-side code
-│   ├── api/               # ORPC layer
-│   │   ├── contracts/     # Input/output schemas (Zod)
-│   │   ├── middlewares/   # Middleware (db provider, auth)
-│   │   ├── routers/       # Handler implementations
-│   │   ├── context.ts     # Request context
-│   │   ├── server.ts      # ORPC server instance
-│   │   └── types.ts       # Type exports
-│   └── db/
-│       ├── schema/        # Drizzle table definitions
-│       └── index.ts       # Database instance
-├── env.ts                 # Environment variable validation
-├── router.tsx             # Router configuration
-├── routeTree.gen.ts       # Auto-generated (DO NOT EDIT)
-└── styles.css             # Tailwind entry
-```
-
-## ORPC Pattern
-
-### 1. Define Contract (`src/server/api/contracts/feature.contract.ts`)
-```typescript
-import { oc } from '@orpc/contract'
-import { createSelectSchema } from 'drizzle-zod'
-import { z } from 'zod'
-import { featureTable } from '@/server/db/schema'
-
-const selectSchema = createSelectSchema(featureTable)
-
-export const list = oc.input(z.void()).output(z.array(selectSchema))
-export const create = oc.input(insertSchema).output(selectSchema)
-```
-
-### 2. Implement Router (`src/server/api/routers/feature.router.ts`)
-```typescript
-import { ORPCError } from '@orpc/server'
-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()
-})
-```
-
-### 3. Register in Index Files
-```typescript
-// src/server/api/contracts/index.ts
-import * as feature from './feature.contract'
-export const contract = { feature }
-
-// src/server/api/routers/index.ts
-import * as feature from './feature.router'
-export const router = os.router({ feature })
-```
-
-### 4. Use in Components
-```typescript
-import { useSuspenseQuery, useMutation } from '@tanstack/react-query'
-import { orpc } from '@/client/orpc.client'
-
-const { data } = useSuspenseQuery(orpc.feature.list.queryOptions())
-const mutation = useMutation(orpc.feature.create.mutationOptions())
-```
-
-## Database Schema (Drizzle)
-
-```typescript
-import { pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core'
-import { sql } from 'drizzle-orm'
-
-export const myTable = pgTable('my_table', {
-  id: uuid().primaryKey().default(sql`uuidv7()`),
-  name: text().notNull(),
-  createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp({ withTimezone: true }).notNull().defaultNow().$onUpdateFn(() => new Date()),
-})
-```
-
-## Code Style
-
-### Formatting (Biome)
-- **Indent**: 2 spaces
-- **Quotes**: Single `'`
-- **Semicolons**: Omit (ASI)
-- **Arrow parens**: Always `(x) => x`
-
-### Imports
-Biome auto-organizes:
-1. External packages
-2. Internal `@/*` aliases
-3. Type imports (`import type { ... }`)
-
-```typescript
-import { createFileRoute } from '@tanstack/react-router'
-import { z } from 'zod'
-import { db } from '@/server/db'
-import type { ReactNode } from 'react'
-```
-
-### TypeScript
-- `strict: true`
-- `noUncheckedIndexedAccess: true` - array access returns `T | undefined`
-- Use `@/*` path aliases (maps to `src/*`)
-
-### Naming
-| Type | Convention | Example |
-|------|------------|---------|
-| Files (utils) | kebab-case | `auth-utils.ts` |
-| Files (components) | PascalCase | `UserProfile.tsx` |
-| Components | PascalCase arrow | `const Button = () => {}` |
-| Functions | camelCase | `getUserById` |
-| Types | PascalCase | `UserProfile` |
-
-### React
-- Use arrow functions for components (Biome enforced)
-- Use `useSuspenseQuery` for guaranteed data
-- Let React Compiler handle memoization (no manual `useMemo`/`useCallback`)
-
-## Environment Variables
-
-```typescript
-// src/env.ts - using @t3-oss/env-core
-import { createEnv } from '@t3-oss/env-core'
-import { z } from 'zod'
-
-export const env = createEnv({
-  server: {
-    DATABASE_URL: z.string().url(),
-  },
-  clientPrefix: 'VITE_',
-  client: {
-    VITE_API_URL: z.string().optional(),
-  },
-})
-```
-
-## Critical Rules
-
-**DO:**
-- Run `bun fix` before committing
-- Use `@/*` path aliases
-- Include `createdAt`/`updatedAt` on all tables
-- Use `ORPCError` with proper codes
-
-**DON'T:**
-- Use `npm`, `npx`, `node`, `yarn`, `pnpm` — always use `bun` / `bunx`
-- Edit `src/routeTree.gen.ts` (auto-generated)
-- Use `as any`, `@ts-ignore`, `@ts-expect-error`
-- Commit `.env` files
-- Use empty catch blocks

apps/server/biome.json

@@ -1,7 +0,0 @@
-{
-  "$schema": "../../node_modules/@biomejs/biome/configuration_schema.json",
-  "extends": "//",
-  "files": {
-    "includes": ["**", "!**/routeTree.gen.ts"]
-  }
-}

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/package.json

@@ -1,54 +0,0 @@
-{
-  "name": "@furtherverse/server",
-  "version": "1.0.0",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "build": "vite build",
-    "compile": "bun build.ts",
-    "db:generate": "drizzle-kit generate",
-    "db:migrate": "drizzle-kit migrate",
-    "db:push": "drizzle-kit push",
-    "db:studio": "drizzle-kit studio",
-    "dev": "vite dev",
-    "fix": "biome check --write",
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "@furtherverse/utils": "workspace:*",
-    "@orpc/client": "catalog:",
-    "@orpc/contract": "catalog:",
-    "@orpc/openapi": "catalog:",
-    "@orpc/server": "catalog:",
-    "@orpc/tanstack-query": "catalog:",
-    "@orpc/zod": "catalog:",
-    "@t3-oss/env-core": "catalog:",
-    "@tanstack/react-query": "catalog:",
-    "@tanstack/react-router": "catalog:",
-    "@tanstack/react-router-ssr-query": "catalog:",
-    "@tanstack/react-start": "catalog:",
-    "drizzle-orm": "catalog:",
-    "drizzle-zod": "catalog:",
-    "postgres": "catalog:",
-    "react": "catalog:",
-    "react-dom": "catalog:",
-    "uuid": "catalog:",
-    "zod": "catalog:"
-  },
-  "devDependencies": {
-    "@furtherverse/tsconfig": "workspace:*",
-    "@tailwindcss/vite": "catalog:",
-    "@tanstack/devtools-vite": "catalog:",
-    "@tanstack/react-devtools": "catalog:",
-    "@tanstack/react-query-devtools": "catalog:",
-    "@tanstack/react-router-devtools": "catalog:",
-    "@types/bun": "catalog:",
-    "@vitejs/plugin-react": "catalog:",
-    "babel-plugin-react-compiler": "catalog:",
-    "drizzle-kit": "catalog:",
-    "nitro": "catalog:",
-    "tailwindcss": "catalog:",
-    "vite": "catalog:",
-    "vite-tsconfig-paths": "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/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/routes/api/$.ts

@@ -1,86 +0,0 @@
-import { OpenAPIHandler } from '@orpc/openapi/fetch'
-import { OpenAPIReferencePlugin } from '@orpc/openapi/plugins'
-import { ORPCError, onError, ValidationError } 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 { router } from '@/server/api/routers'
-
-const handler = new OpenAPIHandler(router, {
-  plugins: [
-    new OpenAPIReferencePlugin({
-      docsProvider: 'scalar',
-      schemaConverters: [new ZodToJsonSchemaConverter()],
-      specGenerateOptions: {
-        info: {
-          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,
-        })
-      }
-    }),
-  ],
-})
-
-export const Route = createFileRoute('/api/$')({
-  server: {
-    handlers: {
-      ANY: async ({ request }) => {
-        const { response } = await handler.handle(request, {
-          prefix: '/api',
-          context: {
-            headers: request.headers,
-          },
-        })
-
-        return response ?? new Response('Not Found', { status: 404 })
-      },
-    },
-  },
-})

apps/server/src/server/api/context.ts

@@ -1,25 +0,0 @@
-import type { DB } from '@/server/db'
-
-/**
- * 基础 Context - 所有请求都包含的上下文
- */
-export interface BaseContext {
-  headers: Headers
-}
-
-/**
- * 数据库 Context - 通过 db middleware 扩展
- */
-export interface DBContext extends BaseContext {
-  db: DB
-}
-
-/**
- * 认证 Context - 通过 auth middleware 扩展（未来使用）
- *
- * @example
- * export interface AuthContext extends DBContext {
- *   userId: string
- *   user: User
- * }
- */

apps/server/src/server/api/contracts/index.ts

@@ -1,7 +0,0 @@
-import * as todo from './todo.contract'
-
-export const contract = {
-  todo,
-}
-
-export type Contract = typeof contract

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

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

apps/server/src/server/api/middlewares/index.ts

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

apps/server/src/server/api/routers/index.ts

@@ -1,6 +0,0 @@
-import { os } from '../server'
-import * as todo from './todo.router'
-
-export const router = os.router({
-  todo,
-})

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

@@ -1,5 +0,0 @@
-import { implement } from '@orpc/server'
-import type { BaseContext } from './context'
-import { contract } from './contracts'
-
-export const os = implement(contract).$context<BaseContext>()

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

@@ -1,27 +0,0 @@
-import { drizzle } from 'drizzle-orm/postgres-js'
-import { env } from '@/env'
-import * as schema from '@/server/db/schema'
-
-export const createDB = () =>
-  drizzle({
-    connection: {
-      url: env.DATABASE_URL,
-      prepare: true,
-    },
-    schema,
-  })
-
-export type DB = ReturnType<typeof createDB>
-
-export const getDB = (() => {
-  let db: DB | null = null
-
-  return (singleton = true): DB => {
-    if (!singleton) {
-      return createDB()
-    }
-
-    db ??= createDB()
-    return db
-  }
-})()

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

@@ -1,8 +0,0 @@
-import { boolean, pgTable, text } from 'drizzle-orm/pg-core'
-import { generatedFields } from './utils/field'
-
-export const todoTable = pgTable('todo', {
-  ...generatedFields,
-  title: text('title').notNull(),
-  completed: boolean('completed').notNull().default(false),
-})

apps/server/src/server/db/schema/utils/field.ts

@@ -1,58 +0,0 @@
-import { sql } from 'drizzle-orm'
-import { timestamp, uuid } from 'drizzle-orm/pg-core'
-import { v7 as uuidv7 } from 'uuid'
-
-// id
-
-export const id = (name: string) => uuid(name)
-export const pk = (name: string, strategy?: 'native' | 'extension') => {
-  switch (strategy) {
-    // PG 18+
-    case 'native':
-      return id(name).primaryKey().default(sql`uuidv7()`)
-
-    // PG 13+ with extension
-    case 'extension':
-      return id(name).primaryKey().default(sql`uuid_generate_v7()`)
-
-    // Any PG version
-    default:
-      return id(name)
-        .primaryKey()
-        .$defaultFn(() => uuidv7())
-  }
-}
-
-// timestamp
-
-export const createdAt = (name = 'created_at') =>
-  timestamp(name, { withTimezone: true }).notNull().defaultNow()
-
-export const updatedAt = (name = 'updated_at') =>
-  timestamp(name, { withTimezone: true })
-    .notNull()
-    .defaultNow()
-    .$onUpdateFn(() => new Date())
-
-// generated fields
-
-export const generatedFields = {
-  id: pk('id'),
-  createdAt: createdAt('created_at'),
-  updatedAt: updatedAt('updated_at'),
-}
-
-// Helper to create omit keys from generatedFields
-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
-      return acc
-    },
-    {} as Record<keyof T, true>,
-  )
-}
-
-export const generatedFieldKeys = createGeneratedFieldKeys(generatedFields)

apps/server/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "@furtherverse/tsconfig/react.json",
-  "compilerOptions": {
-    "baseUrl": ".",
-    "paths": {
-      "@/*": ["./src/*"]
-    }
-  }
-}

apps/server/turbo.json

@@ -1,13 +0,0 @@
-{
-  "$schema": "../../node_modules/turbo/schema.json",
-  "extends": ["//"],
-  "tasks": {
-    "build": {
-      "env": ["NODE_ENV", "VITE_*"],
-      "outputs": [".output/**"]
-    },
-    "compile": {
-      "outputs": ["out/**"]
-    }
-  }
-}

biome.json

@@ -6,6 +6,7 @@
     "useIgnoreFile": true
   },
   "files": {
+    "includes": ["**", "!**/routeTree.gen.ts"],
     "ignoreUnknown": false
   },
   "formatter": {

build.ts

@@ -0,0 +1,289 @@
+import { Schema } from '@effect/schema'
+import { $ } from 'bun'
+import { Console, Context, Data, Effect, Layer } from 'effect'
+
+// ============================================================================
+// Domain Models & Schema
+// ============================================================================
+
+const targetMap = {
+  'bun-windows-x64': 'x86_64-pc-windows-msvc',
+  'bun-darwin-arm64': 'aarch64-apple-darwin',
+  'bun-darwin-x64': 'x86_64-apple-darwin',
+  'bun-linux-x64': 'x86_64-unknown-linux-gnu',
+  'bun-linux-arm64': 'aarch64-unknown-linux-gnu',
+} as const
+
+const BunTargetSchema = Schema.Literal(
+  'bun-windows-x64',
+  'bun-darwin-arm64',
+  'bun-darwin-x64',
+  'bun-linux-x64',
+  'bun-linux-arm64',
+)
+
+type BunTarget = Schema.Schema.Type<typeof BunTargetSchema>
+
+const BuildConfigSchema = Schema.Struct({
+  entrypoint: Schema.String.pipe(Schema.nonEmptyString()),
+  outputDir: Schema.String.pipe(Schema.nonEmptyString()),
+  targets: Schema.Array(BunTargetSchema).pipe(Schema.minItems(1)),
+})
+
+type BuildConfig = Schema.Schema.Type<typeof BuildConfigSchema>
+
+const BuildResultSchema = Schema.Struct({
+  target: BunTargetSchema,
+  outputs: Schema.Array(Schema.String),
+})
+
+type BuildResult = Schema.Schema.Type<typeof BuildResultSchema>
+
+// ============================================================================
+// Error Models (使用 Data.TaggedError)
+// ============================================================================
+
+class CleanError extends Data.TaggedError('CleanError')<{
+  readonly dir: string
+  readonly cause: unknown
+}> {}
+
+class BuildError extends Data.TaggedError('BuildError')<{
+  readonly target: BunTarget
+  readonly cause: unknown
+}> {}
+
+class ConfigError extends Data.TaggedError('ConfigError')<{
+  readonly message: string
+  readonly cause: unknown
+}> {}
+
+// ============================================================================
+// Services
+// ============================================================================
+
+/**
+ * 配置服务
+ */
+class BuildConfigService extends Context.Tag('BuildConfigService')<
+  BuildConfigService,
+  BuildConfig
+>() {
+  /**
+   * 从原始数据创建并验证配置
+   */
+  static fromRaw = (raw: unknown) =>
+    Effect.gen(function* () {
+      const decoded = yield* Schema.decodeUnknown(BuildConfigSchema)(raw)
+      return decoded
+    }).pipe(
+      Effect.catchAll((error) =>
+        Effect.fail(
+          new ConfigError({
+            message: '配置验证失败',
+            cause: error,
+          }),
+        ),
+      ),
+    )
+
+  /**
+   * 默认配置 Layer
+   */
+  static readonly Live = Layer.effect(
+    BuildConfigService,
+    BuildConfigService.fromRaw({
+      entrypoint: '.output/server/index.mjs',
+      // outputDir: 'out',
+      outputDir: 'src-tauri/binaries',
+      targets: ['bun-windows-x64', 'bun-darwin-arm64', 'bun-linux-x64'],
+    }),
+  )
+}
+
+/**
+ * 文件系统服务
+ */
+class FileSystemService extends Context.Tag('FileSystemService')<
+  FileSystemService,
+  {
+    readonly cleanDir: (dir: string) => Effect.Effect<void, CleanError>
+  }
+>() {
+  static readonly Live = Layer.succeed(FileSystemService, {
+    cleanDir: (dir: string) =>
+      Effect.tryPromise({
+        try: async () => {
+          await $`rm -rf ${dir}`
+        },
+        catch: (cause: unknown) =>
+          new CleanError({
+            dir,
+            cause,
+          }),
+      }),
+  })
+}
+
+/**
+ * 构建服务
+ */
+class BuildService extends Context.Tag('BuildService')<
+  BuildService,
+  {
+    readonly buildForTarget: (
+      config: BuildConfig,
+      target: BunTarget,
+    ) => Effect.Effect<BuildResult, BuildError>
+    readonly buildAll: (
+      config: BuildConfig,
+    ) => Effect.Effect<ReadonlyArray<BuildResult>, BuildError>
+  }
+>() {
+  static readonly Live = Layer.succeed(BuildService, {
+    buildForTarget: (config: BuildConfig, target: BunTarget) =>
+      Effect.gen(function* () {
+        yield* Console.log(`🔨 开始构建: ${target}`)
+
+        const output = yield* Effect.tryPromise({
+          try: () =>
+            Bun.build({
+              entrypoints: [config.entrypoint],
+              compile: {
+                outfile: `app-${targetMap[target]}`,
+                target: target,
+              },
+              outdir: config.outputDir,
+            }),
+          catch: (cause: unknown) =>
+            new BuildError({
+              target,
+              cause,
+            }),
+        })
+
+        const paths = output.outputs.map((item: { path: string }) => item.path)
+
+        return {
+          target,
+          outputs: paths,
+        } satisfies BuildResult
+      }),
+
+    buildAll: (config: BuildConfig) =>
+      Effect.gen(function* () {
+        const effects = config.targets.map((target) =>
+          Effect.gen(function* () {
+            yield* Console.log(`🔨 开始构建: ${target}`)
+
+            const output = yield* Effect.tryPromise({
+              try: () =>
+                Bun.build({
+                  entrypoints: [config.entrypoint],
+                  compile: {
+                    outfile: `app-${targetMap[target]}`,
+                    target: target,
+                  },
+                  outdir: config.outputDir,
+                }),
+              catch: (cause: unknown) =>
+                new BuildError({
+                  target,
+                  cause,
+                }),
+            })
+
+            const paths = output.outputs.map(
+              (item: { path: string }) => item.path,
+            )
+
+            return {
+              target,
+              outputs: paths,
+            } satisfies BuildResult
+          }),
+        )
+        return yield* Effect.all(effects, { concurrency: 'unbounded' })
+      }),
+  })
+}
+
+/**
+ * 报告服务
+ */
+class ReporterService extends Context.Tag('ReporterService')<
+  ReporterService,
+  {
+    readonly printSummary: (
+      results: ReadonlyArray<BuildResult>,
+    ) => Effect.Effect<void>
+  }
+>() {
+  static readonly Live = Layer.succeed(ReporterService, {
+    printSummary: (results: ReadonlyArray<BuildResult>) =>
+      Effect.gen(function* () {
+        yield* Console.log('\n📦 构建完成:')
+        for (const result of results) {
+          yield* Console.log(`  ${result.target}:`)
+          for (const path of result.outputs) {
+            yield* Console.log(`    - ${path}`)
+          }
+        }
+      }),
+  })
+}
+
+// ============================================================================
+// Main Program
+// ============================================================================
+
+const program = Effect.gen(function* () {
+  const config = yield* BuildConfigService
+  const fs = yield* FileSystemService
+  const builder = yield* BuildService
+  const reporter = yield* ReporterService
+
+  // 1. 清理输出目录
+  yield* fs.cleanDir(config.outputDir)
+  yield* Console.log(`✓ 已清理输出目录: ${config.outputDir}`)
+
+  // 2. 并行构建所有目标
+  const results = yield* builder.buildAll(config)
+
+  // 3. 输出构建摘要
+  yield* reporter.printSummary(results)
+
+  return results
+})
+
+// ============================================================================
+// Layer Composition
+// ============================================================================
+
+const MainLayer = Layer.mergeAll(
+  BuildConfigService.Live,
+  FileSystemService.Live,
+  BuildService.Live,
+  ReporterService.Live,
+)
+
+// ============================================================================
+// Runner
+// ============================================================================
+
+const runnable = program.pipe(
+  Effect.provide(MainLayer),
+  Effect.catchTags({
+    CleanError: (error) =>
+      Console.error(`❌ 清理目录失败: ${error.dir}`, error.cause),
+    BuildError: (error) =>
+      Console.error(`❌ 构建失败 [${error.target}]:`, error.cause),
+    ConfigError: (error) =>
+      Console.error(`❌ 配置错误: ${error.message}`, error.cause),
+  }),
+  Effect.tapErrorCause((cause) => Console.error('❌ 未预期的错误:', cause)),
+)
+
+Effect.runPromise(runnable).catch(() => {
+  process.exit(1)
+})

bunfig.toml

@@ -1,2 +0,0 @@
-[install]
-publicHoistPattern = ["@types/*", "bun-types", "nitro*"]

drizzle.config.ts

@@ -3,7 +3,7 @@ import { env } from '@/env'
 
 export default defineConfig({
   out: './drizzle',
-  schema: './src/server/db/schema/index.ts',
+  schema: './src/db/schema/index.ts',
   dialect: 'postgresql',
   dbCredentials: {
     url: env.DATABASE_URL,

mise.toml

@@ -1,3 +1,4 @@
 [tools]
-bun = "1"
 node = "24"
+bun = "1"
+rust = 'latest'

package.json

@@ -1,65 +1,64 @@
 {
-  "name": "@furtherverse/monorepo",
-  "version": "1.0.0",
+  "name": "fullstack-starter",
   "private": true,
   "type": "module",
-  "workspaces": [
-    "apps/*",
-    "packages/*"
-  ],
   "scripts": {
-    "build": "turbo run build",
-    "compile": "turbo run compile",
-    "dev": "turbo run dev",
-    "fix": "turbo run fix",
-    "typecheck": "turbo run typecheck"
+    "build": "turbo build:tauri",
+    "build:compile": "bun build.ts",
+    "build:tauri": "NO_STRIP=1 tauri build",
+    "build:vite": "vite build",
+    "db:generate": "drizzle-kit generate",
+    "db:migrate": "drizzle-kit migrate",
+    "db:push": "drizzle-kit push",
+    "db:studio": "drizzle-kit studio",
+    "dev": "turbo dev:tauri",
+    "dev:tauri": "tauri dev",
+    "dev:vite": "vite dev",
+    "fix": "biome check --write",
+    "typecheck": "tsc -b"
   },
-  "devDependencies": {
-    "@biomejs/biome": "^2.3.14",
-    "turbo": "^2.8.3",
-    "typescript": "^5.9.3"
-  },
-  "catalog": {
-    "@biomejs/biome": "^2.3.11",
+  "dependencies": {
     "@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",
     "@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.4",
-    "@tanstack/react-router-devtools": "^1.158.4",
-    "@tanstack/react-router-ssr-query": "^1.158.4",
-    "@tanstack/react-start": "^1.159.0",
-    "@types/bun": "^1.3.8",
-    "@types/node": "^24.3.0",
-    "@vitejs/plugin-react": "^5.1.3",
-    "babel-plugin-react-compiler": "^1.0.0",
-    "drizzle-kit": "^0.31.8",
+    "@tanstack/react-router": "^1.158.1",
+    "@tanstack/react-router-ssr-query": "^1.158.1",
+    "@tanstack/react-start": "^1.158.3",
+    "@tauri-apps/api": "^2.10.1",
     "drizzle-orm": "^0.45.1",
     "drizzle-zod": "^0.8.3",
-    "electrobun": "^1.12.0-beta.1",
-    "nitro": "npm:nitro-nightly@3.0.1-20260206-171553-bc737c0c",
-    "ohash": "^2.0.11",
     "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",
-    "uuid": "^13.0.0",
-    "vite": "^8.0.0-beta.13",
-    "vite-tsconfig-paths": "^6.0.5",
     "zod": "^4.3.6"
   },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.14",
+    "@effect/platform": "^0.94.3",
+    "@effect/schema": "^0.75.5",
+    "@tailwindcss/vite": "^4.1.18",
+    "@tanstack/devtools-vite": "^0.4.1",
+    "@tanstack/react-devtools": "^0.9.4",
+    "@tanstack/react-query-devtools": "^5.91.3",
+    "@tanstack/react-router-devtools": "^1.158.1",
+    "@tauri-apps/cli": "^2.10.0",
+    "@types/bun": "^1.3.8",
+    "@vitejs/plugin-react": "^5.1.3",
+    "babel-plugin-react-compiler": "^1.0.0",
+    "drizzle-kit": "^0.31.8",
+    "effect": "^3.19.16",
+    "nitro": "npm:nitro-nightly@latest",
+    "tailwindcss": "^4.1.18",
+    "turbo": "^2.8.3",
+    "typescript": "^5.9.3",
+    "vite": "^8.0.0-beta.13",
+    "vite-tsconfig-paths": "^6.0.5"
+  },
   "overrides": {
-    "@types/node": "catalog:"
+    "@tanstack/query-core": "^5.90.20"
   }
 }

packages/tsconfig/base.json

@@ -1,26 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "display": "Base",
-  "compilerOptions": {
-    "target": "esnext",
-    "lib": ["ESNext"],
-    "module": "preserve",
-    "skipLibCheck": true,
-
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "moduleDetection": "force",
-    "noEmit": true,
-
-    "strict": true,
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "erasableSyntaxOnly": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedSideEffectImports": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true
-  },
-  "exclude": ["node_modules"]
-}

packages/tsconfig/bun.json

@@ -1,8 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "display": "Bun",
-  "extends": "./base.json",
-  "compilerOptions": {
-    "types": ["bun-types"]
-  }
-}

packages/tsconfig/package.json

@@ -1,11 +0,0 @@
-{
-  "name": "@furtherverse/tsconfig",
-  "version": "1.0.0",
-  "private": true,
-  "type": "module",
-  "exports": {
-    "./base.json": "./base.json",
-    "./bun.json": "./bun.json",
-    "./react.json": "./react.json"
-  }
-}

packages/tsconfig/react.json

@@ -1,9 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "display": "React",
-  "extends": "./base.json",
-  "compilerOptions": {
-    "lib": ["ESNext", "DOM", "DOM.Iterable"],
-    "jsx": "react-jsx"
-  }
-}

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'

src-tauri/.gitignore

@@ -0,0 +1,10 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+
+# Generated by Tauri
+# will have schema files for capabilities auto-completion
+/gen/schemas
+
+# Tauri Sidecar
+binaries/

src-tauri/AGENTS.md

@@ -0,0 +1,357 @@
+# AGENTS.md - Tauri Shell 项目开发指南
+
+本文档为 AI 编程助手和开发者提供项目规范、构建命令和代码风格指南。
+
+## 项目概览
+
+- **项目类型**: Tauri v2 桌面应用（轻量级壳子）
+- **后端**: Rust (Edition 2021)
+- **架构**: Sidecar 模式 - Sidecar App 承载主要业务逻辑
+- **设计理念**: Tauri 仅提供原生桌面能力（文件对话框、系统通知等），Web 逻辑全部由 Sidecar App 处理
+- **开发模式**: 使用 localhost:3000（需手动启动开发服务器）
+- **生产模式**: 自动启动 Sidecar 二进制
+- **异步运行时**: Tokio
+- **Rust 版本**: 1.92.0+
+- **工具管理**: 使用 mise 管理 Rust 和 Tauri CLI 版本（见 `mise.toml`）
+
+## 构建、测试、运行命令
+
+### 开发运行
+```bash
+# 开发模式运行 (需要先启动开发服务器)
+# 终端 1: 启动前端开发服务器
+bun run dev
+
+# 终端 2: 启动 Tauri 应用
+tauri dev
+
+# 或者使用单命令并行启动（需要配置 package.json）
+bun run dev:tauri
+```
+
+**开发模式说明**：
+- 开发模式下，Tauri 直接连接到 `localhost:3000`（不启动 sidecar 二进制）
+- 需要手动运行 `bun run dev` 来启动开发服务器
+- 支持热重载（HMR），无需重启 Tauri 应用
+
+### 构建
+```bash
+# 开发构建 (debug mode)
+cargo build
+
+# 生产构建
+cargo build --release
+
+# Tauri 应用打包 (生成安装程序)
+tauri build
+```
+
+### 代码检查
+```bash
+# 编译检查 (不生成二进制)
+cargo check
+
+# Clippy 代码质量检查
+cargo clippy
+
+# Clippy 严格模式 (所有警告视为错误)
+cargo clippy -- -D warnings
+
+# 代码格式化检查
+cargo fmt -- --check
+
+# 自动格式化代码
+cargo fmt
+```
+
+### 测试
+```bash
+# 运行所有测试
+cargo test
+
+# 运行单个测试 (按名称过滤)
+cargo test test_function_name
+
+# 运行特定模块的测试
+cargo test module_name::
+
+# 显示测试输出 (包括 println!)
+cargo test -- --nocapture
+
+# 运行单个测试并显示输出
+cargo test test_name -- --nocapture
+```
+
+### 清理
+```bash
+# 清理构建产物
+cargo clean
+```
+
+## 项目结构
+
+```
+app-desktop/
+├── src/
+│   ├── main.rs          # 入口文件 (仅调用 lib::run)
+│   ├── lib.rs           # 核心应用逻辑 (注册插件、命令、状态)
+│   ├── commands/
+│   │   └── mod.rs       # 原生桌面功能命令 (文件对话框、通知等)
+│   └── sidecar.rs       # Sidecar 进程管理 (启动、端口扫描、清理)
+├── binaries/            # Sidecar 二进制文件
+│   └── app-*   # Sidecar App 可执行文件 (示例: app)
+├── capabilities/        # Tauri v2 权限配置
+│   └── default.json
+├── icons/               # 应用图标资源
+├── gen/schemas/         # 自动生成的 Schema (不要手动编辑)
+├── Cargo.toml          # Rust 项目配置
+├── tauri.conf.json     # Tauri 应用配置
+├── build.rs            # Rust 构建脚本
+└── mise.toml           # 开发工具版本管理
+```
+
+## Rust 代码风格指南
+
+### 导入 (Imports)
+
+- 使用标准库、外部 crate、当前 crate 的顺序，用空行分隔
+- 按字母顺序排列
+- 优先使用具体导入而非通配符 `*`
+
+```rust
+// ✅ 推荐
+use std::sync::Mutex;
+use std::time::Duration;
+
+use tauri::Manager;
+use tauri_plugin_shell::ShellExt;
+use tauri_plugin_shell::process::{CommandEvent, CommandChild};
+
+// ❌ 避免
+use tauri::*;
+```
+
+### 命名规范
+
+- **函数和变量**: `snake_case`
+- **类型、结构体、枚举、Trait**: `PascalCase`
+- **常量和静态变量**: `SCREAMING_SNAKE_CASE`
+- **生命周期参数**: 简短小写字母，如 `'a`, `'b`
+
+```rust
+// ✅ 推荐
+struct SidecarProcess(Mutex<Option<CommandChild>>);
+const DEFAULT_PORT: u16 = 3000;
+async fn find_available_port(start: u16) -> u16 { }
+
+// ❌ 避免
+struct sidecar_process { }
+const defaultPort: u16 = 3000;
+```
+
+### 类型注解
+
+- 函数参数必须有类型注解
+- 函数返回值必须明确声明 (除非返回 `()`)
+- 优先使用具体类型而非 `impl Trait` (除非必要)
+- 使用 `&str` 而非 `String` 作为只读字符串参数
+
+```rust
+// ✅ 推荐
+#[tauri::command]
+fn greet(name: &str) -> String {
+    format!("Hello, {}!", name)
+}
+
+async fn is_port_available(port: u16) -> bool {
+    tokio::net::TcpListener::bind(format!("127.0.0.1:{}", port))
+        .await
+        .is_ok()
+}
+```
+
+### 错误处理
+
+- 使用 `Result<T, E>` 返回可能失败的操作
+- 使用 `expect()` 时提供有意义的错误消息 (中文)
+- 避免 `unwrap()` 在生产代码中，除非逻辑上保证不会 panic
+- 使用 `?` 操作符传播错误
+- 记录关键错误信息到控制台
+
+```rust
+// ✅ 推荐
+let sidecar = app_handle
+    .shell()
+    .sidecar("app")
+    .expect("无法找到 app sidecar");
+
+let (mut rx, child) = sidecar.spawn().expect("启动 sidecar 失败");
+
+// 日志记录
+eprintln!("✗ Sidecar App 启动失败");
+println!("✓ Sidecar App 启动成功！");
+
+// ❌ 避免
+let data = read_file().unwrap();  // 无上下文信息
+```
+
+### 异步代码
+
+- 使用 `async/await` 而非手动创建 Future
+- Tauri 内部使用 `tauri::async_runtime::spawn` 启动异步任务
+- 使用 Tokio 的异步 API (如 `tokio::net::TcpListener`)
+- 避免阻塞异步运行时 (使用 `tokio::task::spawn_blocking`)
+
+```rust
+// ✅ 推荐
+tauri::async_runtime::spawn(async move {
+    let port = find_available_port(3000).await;
+    // ...
+});
+```
+
+### 格式化
+
+- 使用 `cargo fmt` 自动格式化
+- 缩进: 4 空格
+- 行宽: 100 字符 (rustfmt 默认)
+- 结构体和枚举的字段每行一个 (如果超过一定长度)
+- 链式调用适当换行提高可读性
+
+### 注释
+
+- 使用中文注释说明复杂逻辑
+- 代码块前添加简短说明注释
+- 避免显而易见的注释
+
+```rust
+// ✅ 推荐
+// 全局状态：存储 Sidecar App 进程句柄
+struct SidecarProcess(Mutex<Option<CommandChild>>);
+
+// 检查端口是否可用
+async fn is_port_available(port: u16) -> bool { }
+```
+
+## Tauri 特定规范
+
+### 模块组织
+
+- **`lib.rs`**: 主入口，负责注册插件、命令、状态管理
+- **`commands/mod.rs`**: 所有 Tauri 命令集中定义，命令必须是 `pub fn`
+- **`sidecar.rs`**: Sidecar 进程管理逻辑，导出公共 API（`spawn_sidecar`, `cleanup_sidecar_process`）
+
+```rust
+// lib.rs - 模块声明
+mod commands;
+mod sidecar;
+
+use sidecar::SidecarProcess;
+
+// 注册命令时使用模块路径
+.invoke_handler(tauri::generate_handler![commands::greet])
+```
+
+### 命令定义
+
+- 使用 `#[tauri::command]` 宏标记命令
+- 命令函数必须是公开的或在 `invoke_handler` 中注册
+- 参数类型必须实现 `serde::Deserialize`
+- 返回类型必须实现 `serde::Serialize`
+
+```rust
+#[tauri::command]
+fn greet(name: &str) -> String {
+    format!("Hello, {}!", name)
+}
+
+// 在 Builder 中注册
+.invoke_handler(tauri::generate_handler![greet])
+```
+
+### 状态管理
+
+- 使用 `app.manage()` 注册全局状态
+- 状态必须实现 `Send + Sync`
+- 使用 `Mutex` 或 `RwLock` 保证线程安全
+
+```rust
+struct SidecarProcess(Mutex<Option<CommandChild>>);
+
+// 注册状态
+app.manage(SidecarProcess(Mutex::new(None)));
+
+// 访问状态
+if let Some(state) = app_handle.try_state::<SidecarProcess>() {
+    *state.0.lock().unwrap() = Some(child);
+}
+```
+
+### Sidecar 进程管理
+
+- Sidecar 二进制必须在 `tauri.conf.json` 的 `bundle.externalBin` 中声明
+- 使用 `app.shell().sidecar()` 启动 sidecar
+- 在应用退出时清理子进程 (监听 `RunEvent::ExitRequested`)
+
+```rust
+// 启动 sidecar
+let sidecar = app_handle
+    .shell()
+    .sidecar("app")
+    .expect("无法找到 app sidecar")
+    .env("PORT", port.to_string());
+
+// 清理进程
+match event {
+    tauri::RunEvent::ExitRequested { .. } | tauri::RunEvent::Exit => {
+        if let Some(child) = process.take() {
+            let _ = child.kill();
+        }
+    }
+    _ => {}
+}
+```
+
+## 依赖管理
+
+- 在 `Cargo.toml` 中明确声明依赖版本
+- 使用语义化版本 (如 `"2"` 表示兼容 2.x.x)
+- 仅启用需要的 feature 以减少编译时间和二进制大小
+
+```toml
+tauri = { version = "2", features = [] }
+tauri-plugin-opener = "2"
+tauri-plugin-shell = "2"
+serde = { version = "1", features = ["derive"] }
+tokio = { version = "1", features = ["net"] }
+```
+
+## 开发工具
+
+推荐安装以下 VSCode 扩展:
+- `tauri-apps.tauri-vscode` - Tauri 官方支持
+- `rust-lang.rust-analyzer` - Rust 语言服务器
+
+## 最佳实践
+
+1. **开发环境配置**: 
+   - 开发模式下需先启动前端开发服务器（`bun run dev`），再启动 Tauri（`tauri dev`）
+   - 生产构建自动打包 sidecar 二进制，无需额外配置
+2. **进程生命周期**: 始终在应用退出时清理子进程和资源
+3. **端口管理**: 
+   - 开发模式固定使用 3000 端口（与开发服务器匹配）
+   - 生产模式使用端口扫描避免硬编码端口冲突
+4. **超时处理**: 异步操作设置合理的超时时间 (如 5 秒)
+5. **日志**: 使用表情符号 (✓/✗/🔧/🚀) 和中文消息提供清晰的状态反馈
+6. **错误退出**: 关键错误时调用 `std::process::exit(1)`
+7. **窗口配置**: 使用 `WebviewWindowBuilder` 动态创建窗口
+
+## 提交代码前检查清单
+
+- [ ] `cargo fmt` 格式化通过
+- [ ] `cargo clippy` 无警告
+- [ ] `cargo check` 编译通过
+- [ ] `cargo test` 测试通过
+- [ ] 更新相关注释和文档
+- [ ] 检查是否有 `unwrap()` 需要替换为 `expect()`
+- [ ] 验证 Tauri 应用正常启动和退出

src-tauri/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "app-desktop"
+version = "0.1.0"
+description = "A Tauri App"
+authors = ["imbytecat"]
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+# The `_lib` suffix may seem redundant but it is necessary
+# to make the lib name unique and wouldn't conflict with the bin name.
+# This seems to be only an issue on Windows, see https://github.com/rust-lang/cargo/issues/8519
+name = "app_desktop_lib"
+crate-type = ["staticlib", "cdylib", "rlib"]
+
+[build-dependencies]
+tauri-build = { version = "2", features = [] }
+
+[dependencies]
+tauri = { version = "2", features = [] }
+tauri-plugin-shell = "2"
+serde = { version = "1", features = ["derive"] }
+tokio = { version = "1", features = ["net"] }

src-tauri/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    tauri_build::build()
+}

src-tauri/capabilities/default.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "../gen/schemas/desktop-schema.json",
+  "identifier": "default",
+  "description": "Capability for the main window",
+  "windows": ["main"],
+  "local": true,
+  "remote": {
+    "urls": [
+      "http://localhost:*",
+      "http://127.0.0.1:*",
+      "http{s}?://localhost(:\\d+)?/*"
+    ]
+  },
+  "permissions": [
+    "core:default",
+    "core:window:allow-set-title",
+    {
+      "identifier": "shell:allow-execute",
+      "allow": [
+        {
+          "name": "binaries/app",
+          "sidecar": true
+        }
+      ]
+    }
+  ]
+}

src-tauri/src/commands/mod.rs

@@ -0,0 +1,8 @@
+// 原生桌面功能命令
+// 未来可能包含: 文件对话框、系统通知、剪贴板等
+
+// 示例命令 (可根据需要删除或替换)
+#[tauri::command]
+pub fn greet(name: &str) -> String {
+    format!("Hello, {}! You've been greeted from Rust!", name)
+}

src-tauri/src/lib.rs

@@ -0,0 +1,33 @@
+use tauri::Manager;
+
+// 模块声明
+mod commands;
+mod sidecar;
+
+use sidecar::SidecarProcess;
+
+#[cfg_attr(mobile, tauri::mobile_entry_point)]
+pub fn run() {
+    tauri::Builder::default()
+        .plugin(tauri_plugin_shell::init())
+        .setup(|app| {
+            // 注册全局状态
+            app.manage(SidecarProcess(std::sync::Mutex::new(None)));
+
+            // 启动 Sidecar 进程
+            let app_handle = app.handle().clone();
+            sidecar::spawn_sidecar(app_handle);
+
+            Ok(())
+        })
+        .invoke_handler(tauri::generate_handler![commands::greet])
+        .build(tauri::generate_context!())
+        .expect("error while building tauri application")
+        .run(|app_handle, event| {
+            // 监听应用退出事件，清理 Sidecar 进程
+            if let tauri::RunEvent::Exit = event {
+                // 只在 Exit 事件时清理，避免重复执行
+                sidecar::cleanup_sidecar_process(app_handle);
+            }
+        });
+}

src-tauri/src/main.rs

@@ -0,0 +1,6 @@
+// Prevents additional console window on Windows in release, DO NOT REMOVE!!
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+fn main() {
+    app_desktop_lib::run()
+}

src-tauri/src/sidecar.rs

@@ -0,0 +1,166 @@
+use std::sync::Mutex;
+use std::time::Duration;
+
+use tauri::Manager;
+use tauri_plugin_shell::process::{CommandChild, CommandEvent};
+use tauri_plugin_shell::ShellExt;
+
+// ===== 配置常量 =====
+
+/// Sidecar App 启动超时时间（秒）
+const STARTUP_TIMEOUT_SECS: u64 = 5;
+
+/// 默认起始端口
+const DEFAULT_PORT: u16 = 3000;
+
+/// 端口扫描范围（从起始端口开始扫描的端口数量）
+const PORT_SCAN_RANGE: u16 = 100;
+
+/// 窗口默认宽度
+const DEFAULT_WINDOW_WIDTH: f64 = 1200.0;
+
+/// 窗口默认高度
+const DEFAULT_WINDOW_HEIGHT: f64 = 800.0;
+
+/// 窗口标题
+const WINDOW_TITLE: &str = "Tauri App";
+
+// ===== 数据结构 =====
+
+/// 全局状态：存储 Sidecar 进程句柄
+pub struct SidecarProcess(pub Mutex<Option<CommandChild>>);
+
+// 检查端口是否可用（未被占用）
+async fn is_port_available(port: u16) -> bool {
+    tokio::net::TcpListener::bind(format!("127.0.0.1:{}", port))
+        .await
+        .is_ok()
+}
+
+// 查找可用端口
+async fn find_available_port(start: u16) -> u16 {
+    for port in start..start + PORT_SCAN_RANGE {
+        if is_port_available(port).await {
+            return port;
+        }
+    }
+    start // 回退到起始端口
+}
+
+/// 启动 Sidecar 进程并创建主窗口
+pub fn spawn_sidecar(app_handle: tauri::AppHandle) {
+    // 检测是否为开发模式
+    let is_dev = cfg!(debug_assertions);
+
+    if is_dev {
+        // 开发模式：直接创建窗口连接到 Vite 开发服务器
+        println!("🔧 开发模式");
+
+        match tauri::WebviewWindowBuilder::new(
+            &app_handle,
+            "main",
+            tauri::WebviewUrl::External("http://localhost:3000".parse().unwrap()),
+        )
+        .title(WINDOW_TITLE)
+        .inner_size(DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT)
+        .center()
+        .build()
+        {
+            Ok(_) => println!("✓ 开发窗口创建成功"),
+            Err(e) => {
+                eprintln!("✗ 窗口创建失败: {}", e);
+            }
+        }
+
+        return;
+    }
+
+    // 生产模式：启动 sidecar 二进制
+    tauri::async_runtime::spawn(async move {
+        println!("🚀 生产模式");
+
+        // 查找可用端口
+        let port = find_available_port(DEFAULT_PORT).await;
+        println!("使用端口: {}", port);
+
+        // 启动 sidecar
+        let sidecar = app_handle
+            .shell()
+            .sidecar("app")
+            .expect("无法找到 app")
+            .env("PORT", port.to_string());
+
+        let (mut rx, child) = sidecar.spawn().expect("启动 sidecar 失败");
+
+        // 保存进程句柄到全局状态
+        if let Some(state) = app_handle.try_state::<SidecarProcess>() {
+            *state.0.lock().unwrap() = Some(child);
+        }
+
+        // 监听 stdout，等待服务器就绪信号
+        let start_time = std::time::Instant::now();
+        let timeout = Duration::from_secs(STARTUP_TIMEOUT_SECS);
+        let mut app_ready = false;
+
+        while let Some(event) = rx.recv().await {
+            if let CommandEvent::Stdout(line) = event {
+                let output = String::from_utf8_lossy(&line);
+                println!("App: {}", output);
+
+                // 检测 App 启动成功的标志
+                if output.contains("Listening on:") || output.contains("localhost") {
+                    app_ready = true;
+                    println!("✓ App 启动成功！");
+
+                    // 创建主窗口
+                    let url = format!("http://localhost:{}", port);
+                    tauri::WebviewWindowBuilder::new(
+                        &app_handle,
+                        "main",
+                        tauri::WebviewUrl::External(url.parse().unwrap()),
+                    )
+                    .title(WINDOW_TITLE)
+                    .inner_size(DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT)
+                    .center()
+                    .build()
+                    .expect("创建窗口失败");
+
+                    break;
+                }
+            }
+
+            // 超时检查
+            if start_time.elapsed() > timeout {
+                eprintln!("✗ 启动超时: App 未能在 {} 秒内启动", STARTUP_TIMEOUT_SECS);
+                break;
+            }
+        }
+
+        if !app_ready {
+            eprintln!("✗ App 启动失败");
+            std::process::exit(1);
+        }
+    });
+}
+
+/// 清理 Sidecar 进程 (在应用退出时调用)
+pub fn cleanup_sidecar_process(app_handle: &tauri::AppHandle) {
+    let is_dev = cfg!(debug_assertions);
+
+    if is_dev {
+        // 开发模式：退出时发送异常信号（exit 1），让 Turbo 停止 Vite 服务器
+        println!("🔧 开发模式退出，终止所有依赖任务...");
+        std::process::exit(1);
+    }
+
+    // 生产模式：正常清理 sidecar 进程
+    println!("应用退出，正在清理 Sidecar 进程...");
+    if let Some(state) = app_handle.try_state::<SidecarProcess>() {
+        if let Ok(mut process) = state.0.lock() {
+            if let Some(child) = process.take() {
+                let _ = child.kill();
+                println!("✓ Sidecar 进程已终止");
+            }
+        }
+    }
+}

src-tauri/tauri.conf.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://schema.tauri.app/config/2",
+  "productName": "app-desktop",
+  "version": "0.1.0",
+  "identifier": "com.imbytecat.app-desktop",
+  "app": {
+    "withGlobalTauri": true,
+    "windows": [],
+    "security": {
+      "csp": null
+    }
+  },
+  "bundle": {
+    "active": true,
+    "targets": "all",
+    "icon": [
+      "icons/32x32.png",
+      "icons/128x128.png",
+      "icons/128x128@2x.png",
+      "icons/icon.icns",
+      "icons/icon.ico"
+    ],
+    "externalBin": ["binaries/app"]
+  }
+}

src/db/index.ts

@@ -0,0 +1,13 @@
+import { drizzle } from 'drizzle-orm/postgres-js'
+import * as schema from '@/db/schema'
+import { env } from '@/env'
+
+export function createDb() {
+  return drizzle({
+    connection: {
+      url: env.DATABASE_URL,
+      prepare: true,
+    },
+    schema,
+  })
+}

src/db/schema/todo.ts

@@ -0,0 +1,15 @@
+import { sql } from 'drizzle-orm'
+import { boolean, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core'
+
+export const todoTable = pgTable('todo', {
+  id: uuid('id').primaryKey().default(sql`uuidv7()`),
+  title: text('title').notNull(),
+  completed: boolean('completed').notNull().default(false),
+  createdAt: timestamp('created_at', { withTimezone: true })
+    .notNull()
+    .defaultNow(),
+  updatedAt: timestamp('updated_at', { withTimezone: true })
+    .notNull()
+    .defaultNow()
+    .$onUpdateFn(() => new Date()),
+})

src/integrations/tanstack-query/devtools.tsx

@@ -0,0 +1,7 @@
+import type { TanStackDevtoolsReactPlugin } from '@tanstack/react-devtools'
+import { ReactQueryDevtoolsPanel } from '@tanstack/react-query-devtools'
+
+export const devtools = {
+  name: 'TanStack Query',
+  render: <ReactQueryDevtoolsPanel />,
+} satisfies TanStackDevtoolsReactPlugin

src/integrations/tanstack-query/index.ts

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

src/integrations/tanstack-router/devtools.tsx

@@ -0,0 +1,7 @@
+import type { TanStackDevtoolsReactPlugin } from '@tanstack/react-devtools'
+import { TanStackRouterDevtoolsPanel } from '@tanstack/react-router-devtools'
+
+export const devtools = {
+  name: 'TanStack Router',
+  render: <TanStackRouterDevtoolsPanel />,
+} satisfies TanStackDevtoolsReactPlugin

src/integrations/tanstack-router/index.ts

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

src/orpc/client.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 './router'
+import type { RouterClient } from './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() })
+          },
+        },
+      },
+    },
+  },
+})

src/orpc/contract.ts

@@ -0,0 +1,5 @@
+import * as todo from './contracts/todo'
+
+export const contract = {
+  todo,
+}

src/orpc/contracts/todo.ts

@@ -5,7 +5,7 @@ import {
   createUpdateSchema,
 } from 'drizzle-zod'
 import { z } from 'zod'
-import { todoTable } from '@/server/db/schema'
+import { todoTable } from '@/db/schema'
 
 const selectSchema = createSelectSchema(todoTable)
 

src/orpc/handlers/todo.ts

@@ -1,19 +1,17 @@
 import { ORPCError } from '@orpc/server'
 import { eq } from 'drizzle-orm'
-import { todoTable } from '@/server/db/schema'
-import { db } from '../middlewares'
-import { os } from '../server'
+import { todoTable } from '@/db/schema'
+import { baseProcedure } from '@/orpc/procedures'
 
-export const list = os.todo.list.use(db).handler(async ({ context }) => {
+export const list = baseProcedure.todo.list.handler(async ({ context }) => {
   const todos = await context.db.query.todoTable.findMany({
     orderBy: (todos, { desc }) => [desc(todos.createdAt)],
   })
   return todos
 })
 
-export const create = os.todo.create
-  .use(db)
-  .handler(async ({ context, input }) => {
+export const create = baseProcedure.todo.create.handler(
+  async ({ context, input }) => {
     const [newTodo] = await context.db
       .insert(todoTable)
       .values(input)
@@ -24,11 +22,11 @@ export const create = os.todo.create
     }
 
     return newTodo
-  })
+  },
+)
 
-export const update = os.todo.update
-  .use(db)
-  .handler(async ({ context, input }) => {
+export const update = baseProcedure.todo.update.handler(
+  async ({ context, input }) => {
     const [updatedTodo] = await context.db
       .update(todoTable)
       .set(input.data)
@@ -40,10 +38,11 @@ export const update = os.todo.update
     }
 
     return updatedTodo
-  })
+  },
+)
 
-export const remove = os.todo.remove
-  .use(db)
-  .handler(async ({ context, input }) => {
+export const remove = baseProcedure.todo.remove.handler(
+  async ({ context, input }) => {
     await context.db.delete(todoTable).where(eq(todoTable.id, input.id))
-  })
+  },
+)

src/orpc/index.ts

@@ -0,0 +1,2 @@
+export { orpc } from './client'
+export * from './types'

src/orpc/middlewares/db.ts

@@ -0,0 +1,17 @@
+import { createDb } from '@/db'
+import { os } from '@/orpc/server'
+
+export type Database = ReturnType<typeof createDb>
+
+const globalForDb = globalThis as { __db?: Database }
+
+function getDb(): Database {
+  globalForDb.__db ??= createDb()
+  return globalForDb.__db
+}
+
+export const dbProvider = os.middleware(async ({ context, next }) => {
+  return next({
+    context: { ...context, db: getDb() },
+  })
+})

src/orpc/middlewares/index.ts

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

src/orpc/procedures.ts

@@ -0,0 +1,4 @@
+import { dbProvider } from './middlewares/db'
+import { os } from './server'
+
+export const baseProcedure = os.use(dbProvider)

src/orpc/router.ts

@@ -0,0 +1,6 @@
+import * as todo from './handlers/todo'
+import { os } from './server'
+
+export const router = os.router({
+  todo,
+})

src/orpc/server.ts

@@ -0,0 +1,8 @@
+import { implement } from '@orpc/server'
+import { contract } from './contract'
+
+export type ORPCContext = {
+  headers?: Headers
+}
+
+export const os = implement(contract).$context<ORPCContext>()

src/orpc/types.ts

@@ -3,8 +3,9 @@ import type {
   InferContractRouterInputs,
   InferContractRouterOutputs,
 } from '@orpc/contract'
-import type { Contract } from './contracts'
+import type { contract } from './contract'
 
+export type Contract = typeof contract
 export type RouterClient = ContractRouterClient<Contract>
 export type RouterInputs = InferContractRouterInputs<Contract>
 export type RouterOutputs = InferContractRouterOutputs<Contract>

src/routeTree.gen.ts

@@ -10,7 +10,6 @@
 
 import { Route as rootRouteImport } from './routes/__root'
 import { Route as IndexRouteImport } from './routes/index'
-import { Route as ApiSplatRouteImport } from './routes/api/$'
 import { Route as ApiRpcSplatRouteImport } from './routes/api/rpc.$'
 
 const IndexRoute = IndexRouteImport.update({
@@ -18,11 +17,6 @@ const IndexRoute = IndexRouteImport.update({
   path: '/',
   getParentRoute: () => rootRouteImport,
 } as any)
-const ApiSplatRoute = ApiSplatRouteImport.update({
-  id: '/api/$',
-  path: '/api/$',
-  getParentRoute: () => rootRouteImport,
-} as any)
 const ApiRpcSplatRoute = ApiRpcSplatRouteImport.update({
   id: '/api/rpc/$',
   path: '/api/rpc/$',
@@ -31,31 +25,27 @@ const ApiRpcSplatRoute = ApiRpcSplatRouteImport.update({
 
 export interface FileRoutesByFullPath {
   '/': typeof IndexRoute
-  '/api/$': typeof ApiSplatRoute
   '/api/rpc/$': typeof ApiRpcSplatRoute
 }
 export interface FileRoutesByTo {
   '/': typeof IndexRoute
-  '/api/$': typeof ApiSplatRoute
   '/api/rpc/$': typeof ApiRpcSplatRoute
 }
 export interface FileRoutesById {
   __root__: typeof rootRouteImport
   '/': typeof IndexRoute
-  '/api/$': typeof ApiSplatRoute
   '/api/rpc/$': typeof ApiRpcSplatRoute
 }
 export interface FileRouteTypes {
   fileRoutesByFullPath: FileRoutesByFullPath
-  fullPaths: '/' | '/api/$' | '/api/rpc/$'
+  fullPaths: '/' | '/api/rpc/$'
   fileRoutesByTo: FileRoutesByTo
-  to: '/' | '/api/$' | '/api/rpc/$'
-  id: '__root__' | '/' | '/api/$' | '/api/rpc/$'
+  to: '/' | '/api/rpc/$'
+  id: '__root__' | '/' | '/api/rpc/$'
   fileRoutesById: FileRoutesById
 }
 export interface RootRouteChildren {
   IndexRoute: typeof IndexRoute
-  ApiSplatRoute: typeof ApiSplatRoute
   ApiRpcSplatRoute: typeof ApiRpcSplatRoute
 }
 
@@ -68,13 +58,6 @@ declare module '@tanstack/react-router' {
       preLoaderRoute: typeof IndexRouteImport
       parentRoute: typeof rootRouteImport
     }
-    '/api/$': {
-      id: '/api/$'
-      path: '/api/$'
-      fullPath: '/api/$'
-      preLoaderRoute: typeof ApiSplatRouteImport
-      parentRoute: typeof rootRouteImport
-    }
     '/api/rpc/$': {
       id: '/api/rpc/$'
       path: '/api/rpc/$'
@@ -87,7 +70,6 @@ declare module '@tanstack/react-router' {
 
 const rootRouteChildren: RootRouteChildren = {
   IndexRoute: IndexRoute,
-  ApiSplatRoute: ApiSplatRoute,
   ApiRpcSplatRoute: ApiRpcSplatRoute,
 }
 export const routeTree = rootRouteImport

src/routes/__root.tsx

@@ -1,15 +1,15 @@
 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 { 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 { devtools as queryDevtools } from '@/integrations/tanstack-query'
+import { devtools as routerDevtools } from '@/integrations/tanstack-router'
 import appCss from '@/styles.css?url'
 
 export interface RouterContext {
@@ -27,7 +27,7 @@ export const Route = createRootRouteWithContext<RouterContext>()({
         content: 'width=device-width, initial-scale=1',
       },
       {
-        title: 'Furtherverse',
+        title: 'Fullstack Starter',
       },
     ],
     links: [
@@ -54,16 +54,7 @@ function RootDocument({ children }: Readonly<{ children: ReactNode }>) {
           config={{
             position: 'bottom-right',
           }}
-          plugins={[
-            {
-              name: 'TanStack Router',
-              render: <TanStackRouterDevtoolsPanel />,
-            },
-            {
-              name: 'TanStack Query',
-              render: <ReactQueryDevtoolsPanel />,
-            },
-          ]}
+          plugins={[routerDevtools, queryDevtools]}
         />
         <Scripts />
       </body>

src/routes/api/rpc.$.ts

@@ -2,7 +2,7 @@ import { ORPCError, onError, ValidationError } from '@orpc/server'
 import { RPCHandler } from '@orpc/server/fetch'
 import { createFileRoute } from '@tanstack/react-router'
 import { z } from 'zod'
-import { router } from '@/server/api/routers'
+import { router } from '@/orpc/router'
 
 const handler = new RPCHandler(router, {
   interceptors: [
@@ -49,9 +49,7 @@ export const Route = createFileRoute('/api/rpc/$')({
       ANY: async ({ request }) => {
         const { response } = await handler.handle(request, {
           prefix: '/api/rpc',
-          context: {
-            headers: request.headers,
-          },
+          context: {},
         })
 
         return response ?? new Response('Not Found', { status: 404 })

src/routes/index.tsx

@@ -1,8 +1,10 @@
 import { useMutation, useSuspenseQuery } from '@tanstack/react-query'
 import { createFileRoute } from '@tanstack/react-router'
+import { isTauri } from '@tauri-apps/api/core'
+import { getCurrentWindow } from '@tauri-apps/api/window'
 import type { ChangeEventHandler, FormEventHandler } from 'react'
-import { useState } from 'react'
-import { orpc } from '@/client/query-client'
+import { useEffect, useState } from 'react'
+import { orpc } from '@/orpc'
 
 export const Route = createFileRoute('/')({
   component: Todos,
@@ -19,6 +21,11 @@ function Todos() {
   const updateMutation = useMutation(orpc.todo.update.mutationOptions())
   const deleteMutation = useMutation(orpc.todo.remove.mutationOptions())
 
+  useEffect(() => {
+    if (!isTauri()) return
+    getCurrentWindow().setTitle('待办事项')
+  }, [])
+
   const handleCreateTodo: FormEventHandler<HTMLFormElement> = (e) => {
     e.preventDefault()
     if (newTodoTitle.trim()) {