packwise-skills 1.0.0

package/sub-skills/desktop/tauri.md

@@ -0,0 +1,428 @@
+# Tauri 2.x Build Sub-Skill
+
+Rust backend + system WebView. Minimal footprint (2–6MB). Suitable for L1–L3 complexity projects.
+
+**Current version**: Tauri 2.11.x / Tauri CLI 2.11.x (2025-2026)
+
+> ⚠️ **Breaking changes since Tauri 2.2**: v2.10 renamed signer env vars (`TAURI_PRIVATE_KEY` → `TAURI_SIGNING_PRIVATE_KEY`). v2.8 raised iOS deployment target to 14.0. v2.5 removed `WebviewAttributes` re-export. v2.3 deprecated `Manager::unmanage`. Auto-updater plugin v2.5 removed `UpdaterBuilder::new` (use `UpdaterExt::updater_builder`). See [tauri.app/start/migrate/from-tauri-2-0](https://v2.tauri.app/start/migrate/from-tauri-2-0/).
+
+## When to Use
+
+- Frontend uses React/Vue/Svelte/Solid/Vanilla JS
+- Backend can be rewritten in Rust
+- Minimal package size required (2–6MB vs Electron's 80–120MB)
+- Mobile support needed (iOS/Android — stable since Tauri 2.0)
+- Strong sandboxing required (default permission model)
+
+## Key Features
+
+- **Mobile support** (iOS/Android) — stable and production-ready since Tauri 2.0
+- **Capabilities/Permissions system** — fine-grained, JSON-based permission model (CRITICAL for security)
+- **Plugin ecosystem**: tauri-plugin-shell, tauri-plugin-fs, tauri-plugin-http, tauri-plugin-notification, tauri-plugin-store, tauri-plugin-sql, tauri-plugin-log
+- **Type-safe IPC** — auto-generated TypeScript bindings from Rust (`invoke` API)
+- **Built-in auto-updater** — differential updates, GitHub/custom server support
+- **NSIS installer** on Windows, AppImage/DEB/RPM on Linux, DMG on macOS
+
+## Comparison with Electron
+
+| Feature | Electron 43.x | Tauri 2.11.x |
+|---------|--------------|-------------|
+| Size | 80–120MB | 2–6MB |
+| Backend | Node.js | Rust |
+| Browser engine | Bundled Chromium | System WebView |
+| Native modules | Full support | Rust crates |
+| Learning curve | Low | Medium-High (Rust) |
+| Mobile | No | Yes (iOS/Android) |
+| Security | Manual config | Sandboxed by default (capabilities) |
+| WebView2 (Windows) | Bundled | Required (pre-installed Win10 21H2+, Win11) |
+
+## Prerequisites
+
+```bash
+# Rust toolchain
+curl --proto '=https' --tlsv11.2 -sSf https://sh.rustup.rs | sh
+
+# Tauri CLI
+cargo install tauri-cli
+
+# Platform dependencies
+# Windows: WebView2 (pre-installed on Win10 21H2+), Visual Studio Build Tools
+# macOS: Xcode Command Line Tools
+# Linux: libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev
+
+# Node.js 20+ (for frontend)
+```
+
+## Project Creation
+
+```bash
+# Recommended: create with frontend framework
+npm create tauri-app@latest my-app -- --template react-ts
+# Templates available: react-ts, vue-ts, svelte-ts, solid-ts, vanilla-ts
+
+cd my-app
+npm install
+```
+
+## Core Configuration (tauri.conf.json)
+
+```json
+{
+  "productName": "MyApp",
+  "version": "1.0.0",
+  "identifier": "com.example.myapp",
+  "build": {
+    "frontendDist": "../dist",
+    "devUrl": "http://localhost:5173",
+    "beforeDevCommand": "npm run dev",
+    "beforeBuildCommand": "npm run build"
+  },
+  "app": {
+    "windows": [
+      {
+        "title": "MyApp",
+        "width": 1200,
+        "height": 800,
+        "resizable": true,
+        "fullscreen": false
+      }
+    ],
+    "security": {
+      "csp": "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; connect-src 'self' https://api.example.com"
+    }
+  },
+  "bundle": {
+    "active": true,
+    "targets": "all",
+    "icon": [
+      "icons/32x32.png",
+      "icons/128x128.png",
+      "icons/128x128@2x.png",
+      "icons/icon.ico",
+      "icons/icon.icns"
+    ],
+    "windows": {
+      "nsis": {
+        "installMode": "both"
+      }
+    },
+    "macOS": {
+      "minimumSystemVersion": "10.15"
+    },
+    "linux": {
+      "deb": {
+        "depends": ["libwebkit2gtk-4.1-0"]
+      }
+    }
+  },
+  "plugins": {
+    "shell": {
+      "open": true
+    }
+  }
+}
+```
+
+## Capabilities & Permissions (CRITICAL — Tauri 2.x Security Model)
+
+Tauri 2.x uses a **capabilities/permissions** system. Without proper configuration, your app cannot access ANY native functionality.
+
+```text
+src-tauri/
+├── capabilities/
+│   └── default.json    ← Permission declarations
+├── tauri.conf.json
+├── Cargo.toml
+├── build.rs            ← REQUIRED: `fn main() { tauri_build::build() }`
+└── src/
+    ├── main.rs         ← Desktop entry point
+    └── lib.rs          ← Shared logic (mobile + desktop)
+```
+
+```json
+// src-tauri/capabilities/default.json
+{
+  "$schema": "../gen/schemas/desktop-schema.json",
+  "identifier": "default",
+  "description": "Default capabilities for the main window",
+  "windows": ["main"],
+  "permissions": [
+    "core:default",
+    "shell:allow-open",
+    "fs:allow-read",
+    "fs:allow-write",
+    "fs:allow-exists",
+    "dialog:allow-open",
+    "dialog:allow-save",
+    "notification:default",
+    "store:default",
+    "http:default",
+    "clipboard-manager:allow-read-text",
+    "clipboard-manager:allow-write-text"
+  ]
+}
+```
+
+**Common Mistake**: Forgetting to declare permissions. The app builds and runs in dev but crashes in production with "permission denied" errors.
+
+**Common Mistake**: Using `"core:default"` without understanding what it includes. Check `src-tauri/gen/schemas/` for the full permission list.
+
+## Rust Backend Example (Correct Data Path)
+
+**Required: `src-tauri/build.rs`** — Tauri will NOT compile without this file:
+
+```rust
+// src-tauri/build.rs
+fn main() {
+    tauri_build::build()
+}
+```
+
+**Required: `[build-dependencies]` in `Cargo.toml`:**
+
+```toml
+[build-dependencies]
+tauri-build = { version = "2", features = [] }
+```
+
+```rust
+use rusqlite::Connection;
+use tauri::Manager;
+use std::sync::Mutex;
+
+struct AppState {
+    db: Mutex<Connection>,
+}
+
+#[tauri::command]
+fn get_messages(state: tauri::State<AppState>) -> Result<Vec<String>, String> {
+    let conn = state.db.lock().map_err(|e| e.to_string())?;
+    // Query database...
+    Ok(vec![])
+}
+
+pub fn run() {
+    tauri::Builder::default()
+        .setup(|app| {
+            // CORRECT: Use app_data_dir for persistent data (NOT relative path)
+            let app_data = app.path().app_data_dir()
+                .expect("Failed to get app data dir");
+            std::fs::create_dir_all(&app_data).ok();
+            let db_path = app_data.join("data.db");
+            let conn = Connection::open(&db_path)
+                .expect("Failed to open database");
+
+            app.manage(AppState {
+                db: Mutex::new(conn),
+            });
+            Ok(())
+        })
+        .invoke_handler(tauri::generate_handler![get_messages])
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}
+```
+
+**Frontend call:**
+```typescript
+import { invoke } from '@tauri-apps/api/core';
+const messages = await invoke<string[]>('get_messages');
+```
+
+## Build Commands
+
+```bash
+# Desktop
+cargo tauri build                                    # Default platform
+cargo tauri build --target x86_64-pc-windows-msvc    # Windows x64
+cargo tauri build --target aarch64-pc-windows-msvc   # Windows ARM64
+cargo tauri build --target aarch64-apple-darwin       # macOS ARM64 (Apple Silicon)
+cargo tauri build --target x86_64-apple-darwin        # macOS x64 (Intel)
+cargo tauri build --target universal-apple-darwin     # macOS Universal Binary
+cargo tauri build --target x86_64-unknown-linux-gnu   # Linux x64
+cargo tauri build --target aarch64-unknown-linux-gnu  # Linux ARM64
+
+# Mobile
+cargo tauri android init    # Initialize Android project (first time)
+cargo tauri android build   # Build Android APK/AAB
+cargo tauri ios init        # Initialize iOS project (first time, macOS only)
+cargo tauri ios build       # Build iOS IPA (macOS only)
+```
+
+## Mobile Build (iOS/Android)
+
+### Android
+
+```bash
+# Prerequisites: Android Studio, JDK 17, Android SDK 34+
+cargo tauri android init
+cargo tauri android build --target aarch64    # ARM64
+cargo tauri android build --target arm        # ARMv7
+cargo tauri android build --target x86_64     # x86_64 (emulator)
+
+# Output: src-tauri/gen/android/app/build/outputs/
+```
+
+### iOS
+
+```bash
+# Prerequisites: macOS + Xcode 15+ + Apple Developer account
+cargo tauri ios init
+cargo tauri ios build
+
+# Output: src-tauri/gen/apple/build/
+# Open in Xcode for signing and distribution
+```
+
+### Google Play Distribution
+
+```bash
+# Build AAB (Android App Bundle — required by Play Store)
+cargo tauri android build --aab
+# Output: gen/android/app/build/outputs/bundle/universalRelease/app-universal-release.aab
+
+# Build APK (for direct distribution/testing)
+cargo tauri android build --apk
+
+# Per-architecture APKs (smaller, for testing outside Play Store)
+cargo tauri android build --apk --split-per-abi
+```
+
+### iOS App Store Distribution
+
+```bash
+# Build and open Xcode for archiving
+cargo tauri ios build --open
+
+# In Xcode: Product → Archive → Distribute → App Store Connect
+```
+
+### Physical iOS Device Development
+
+```bash
+# Physical device requires dev server on local network
+# 1. Connect device via Xcode → Window → Devices and Simulators
+# 2. Run with forced IP prompt
+cargo tauri ios dev --force-ip-prompt
+
+# 3. Configure Vite to use TAURI_DEV_HOST:
+# vite.config.js:
+# const host = process.env.TAURI_DEV_HOST;
+# server: { host: host || false, port: 1420 }
+```
+
+### Android Environment Variables (Required)
+
+```bash
+# JAVA_HOME — Android Studio's bundled JBR
+# Linux: /opt/android-studio/jbr
+# macOS: /Applications/Android Studio.app/Contents/jbr/Contents/Home
+# Windows: C:\Program Files\Android\Android Studio\jbr
+
+# ANDROID_HOME
+# Linux/macOS: $HOME/Android/Sdk
+# Windows: %LocalAppData%\Android\Sdk
+
+# Rust targets for Android
+rustup target add aarch64-linux-android armv7-linux-androideabi i686-linux-android x86_64-linux-android
+
+# Rust targets for iOS
+rustup target add aarch64-apple-ios x86_64-apple-ios aarch64-apple-ios-sim
+```
+
+## Auto-Update
+
+```json
+// tauri.conf.json
+{
+  "plugins": {
+    "updater": {
+      "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIH...",
+      "endpoints": [
+        "https://releases.myapp.com/{{target}}/{{arch}}/{{current_version}}"
+      ]
+    }
+  }
+}
+```
+
+```rust
+// src-tauri/src/lib.rs
+// ⚠️ Tauri 2.5+: UpdaterBuilder::new removed, use UpdaterExt::updater_builder
+use tauri_plugin_updater::UpdaterExt;
+
+fn main() {
+    tauri::Builder::default()
+        .plugin(tauri_plugin_updater::Builder::new().build())
+        .setup(|app| {
+            let handle = app.handle().clone();
+            tauri::async_runtime::spawn(async move {
+                let update = handle.updater().check().await;
+                // Handle update notification
+            });
+            Ok(())
+        })
+        .run(tauri::generate_context!())
+        .expect("error");
+}
+```
+
+## Code Signing
+
+### Windows
+
+```bash
+# Sign the .msi or .exe after build
+signtool sign /f certificate.pfx /p password /tr http://timestamp.digicert.com /td sha256 src-tauri/target/release/bundle/msi/*.msi
+```
+
+### Auto-Update Signing (Tauri 2.10+)
+
+```bash
+# ⚠️ Environment variables RENAMED in Tauri 2.10:
+# OLD: TAURI_PRIVATE_KEY, TAURI_PRIVATE_KEY_PATH, TAURI_PRIVATE_KEY_PASSWORD
+# NEW: TAURI_SIGNING_PRIVATE_KEY, TAURI_SIGNING_PRIVATE_KEY_PATH, TAURI_SIGNING_PRIVATE_KEY_PASSWORD
+export TAURI_SIGNING_PRIVATE_KEY="dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIH..."
+export TAURI_SIGNING_PRIVATE_KEY_PASSWORD=""
+```
+
+### macOS
+
+```json
+// tauri.conf.json
+{
+  "bundle": {
+    "macOS": {
+      "signingIdentity": "Developer ID Application: Your Name (TEAM_ID)",
+      "entitlements": "entitlements.plist"
+    }
+  }
+}
+```
+
+```bash
+# Notarize after build
+xcrun notarytool submit src-tauri/target/release/bundle/dmg/*.dmg \
+  --apple-id your@email.com \
+  --password app-specific-password \
+  --team-id TEAM_ID \
+  --wait
+```
+
+## Common Pitfalls
+
+| Issue | Fix |
+|-------|-----|
+| Windows missing WebView2 | Pre-installed on Win10 21H2+. For older: download from developer.microsoft.com |
+| Linux compile failure | `sudo apt install libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev` |
+| macOS notarization | Requires Apple Developer ID ($99/year) + notarytool |
+| Slow Rust compilation | First build 5–15 min; use `cargo tauri build --debug` for faster dev builds |
+| SPA route 404 on reload | Configure `app.security.csp` in tauri.conf.json; use hash-based routing |
+| Permission denied in production | Declare capabilities in `src-tauri/capabilities/default.json` |
+| Database path wrong | Use `app.path().app_data_dir()` not relative paths |
+| Mobile build fails | Run `cargo tauri android/ios init` first; check SDK/NDK paths |
+| Auto-update not working | Ensure `pubkey` matches signing key; check endpoint URL format; env vars renamed in v2.10 (see above) |
+| `invoke` returns undefined | Check Rust command name matches `tauri::generate_handler![]` |
+| WebView2 crash on old Windows | Set `"windows": {"webviewInstallMode": {"type": "embedBootstrapper"}}` in tauri.conf.json |
+| Signer env vars not working | Tauri 2.10+ renamed: `TAURI_SIGNING_PRIVATE_KEY` (was `TAURI_PRIVATE_KEY`) |
+| `WebviewAttributes` import fails | Removed from `tauri` crate in v2.5; import from `tauri::webview::WebviewAttributes` instead |

package/sub-skills/desktop/vr-ar.md

@@ -0,0 +1,252 @@
+# VR/AR Application Build Sub-Skill
+
+Build applications for virtual reality and augmented reality headsets.
+
+**Current versions**: Meta Quest SDK v69+ / Apple visionOS 2 / SteamVR 2.x (2025-2026)
+
+## When to Use
+
+- VR games and experiences
+- AR applications (mixed reality, passthrough)
+- Enterprise VR training / simulation
+- 3D visualization tools
+- Spatial computing applications
+
+---
+
+## Meta Quest (Quest 3 / Quest Pro)
+
+### When to Use
+
+- Standalone VR (no PC required)
+- Mixed reality / passthrough AR
+- Most accessible VR platform (largest user base)
+- Unity or Unreal Engine development
+
+### Prerequisites
+
+- Unity 6000+ with Android Build Support, OR Unreal Engine 5.4+
+- Meta Quest Developer account (free): developer.oculus.com
+- Meta Quest device or Meta Quest Developer Hub (emulator)
+
+### Unity Build
+
+```bash
+# Install Meta XR SDK via Unity Package Manager:
+# Window → Package Manager → + → Add package by name:
+# com.meta.xr.sdk.all
+
+# Player Settings:
+# - XR Plug-in Management → Oculus (Android)
+# - Minimum API Level: 29 (Android 10)
+# - Target Architectures: ARM64
+# - Scripting Backend: IL2CPP
+# - Rendering: Vulkan
+
+# Build
+File → Build Settings → Android → Build
+# Output: .apk file
+
+# Sideload for testing
+adb install MyGame.apk
+```
+
+```csharp
+// Unity: Basic Quest setup
+using UnityEngine;
+using UnityEngine.XR;
+
+public class QuestSetup : MonoBehaviour
+{
+    void Start()
+    {
+        // Check passthrough support (Quest 3/Pro)
+        var passthrough = GetComponent<OVRPassthroughLayer>();
+        if (passthrough != null)
+        {
+            passthrough.enabled = true; // Enable mixed reality
+        }
+    }
+}
+```
+
+### Unreal Engine Build
+
+```bash
+# Install MetaXR plugin from Fab (Epic Games Marketplace)
+# Project Settings → Platforms → Android:
+# - Minimum SDK: 29
+# - Target SDK: 34
+# - Vulkan as default RHI
+
+# Package
+Platforms → Android → Package Project
+```
+
+### App Lab / Meta Quest Store
+
+| Platform | Review Process | Time |
+|----------|---------------|------|
+| App Lab | Automated + light review | 2–7 days |
+| Meta Quest Store | Manual curation | Weeks to months |
+| Sideload (dev) | None (developer mode) | Instant |
+
+---
+
+## Apple Vision Pro (visionOS)
+
+### When to Use
+
+- Spatial computing applications
+- Enterprise/professional AR tools
+- Immersive media experiences
+- SwiftUI-based 3D UI
+
+### Prerequisites
+
+- macOS 14+ with Xcode 15.2+
+- Apple Developer account ($99/year)
+- visionOS simulator (included in Xcode) or Vision Pro device
+
+### Build
+
+```swift
+// SwiftUI app for visionOS
+import SwiftUI
+
+@main
+struct MyApp: App {
+    var body: some Scene {
+        WindowGroup {
+            ContentView()
+        }
+        .defaultSize(width: 400, height: 300) // Window dimensions in points
+
+        // For immersive experiences:
+        // ImmersiveSpace(id: "immersiveSpace") {
+        //     ImmersiveView()
+        // }
+    }
+}
+```
+
+```bash
+# Build in Xcode
+xcodebuild -scheme MyApp -destination "generic/platform=visionOS" -configuration Release archive -archivePath build/MyApp.xcarchive
+
+# Or: Product → Archive → Distribute → App Store Connect
+```
+
+### visionOS App Types
+
+| Type | Description | Framework |
+|------|-------------|-----------|
+| **Window** | 2D app in a floating window | SwiftUI |
+| **Volume** | 3D content in a bounded space | RealityKit + SwiftUI |
+| **Full Space** | Immersive experience, full environment takeover | RealityKit + ARKit |
+| **Shared Space** | Multiple apps coexist | Default behavior |
+
+### Common Pitfalls
+
+| Issue | Fix |
+|-------|-----|
+| No physical device for testing | Use visionOS Simulator in Xcode (M1+ Mac required) |
+| App rejected for visionOS | Ensure UI adapts to spatial layout; test all window sizes |
+| RealityKit model not loading | Use .usdz or .reality format; test with Reality Composer Pro |
+| Performance issues | Use Level of Detail (LOD); limit draw calls to < 100 |
+| Immersive space won't open | Request `com.apple.developer.developer-services.access` entitlement |
+
+---
+
+## SteamVR / PC VR
+
+### When to Use
+
+- High-fidelity PC VR games
+- HTC Vive, Valve Index, Pimax headsets
+- PC-tethered Meta Quest (Link/Air Link)
+
+### Prerequisites
+
+- Unity 6000+ with OpenXR plugin, OR Unreal Engine 5.4+
+- SteamVR installed on target PC
+- OpenXR-compatible headset
+
+### Unity Build
+
+```bash
+# Install OpenXR Plugin:
+# Window → Package Manager → OpenXR Plugin
+
+# Player Settings:
+# - XR Plug-in Management → OpenXR
+# - Add interaction profiles: HTC Vive, Valve Index, Oculus Touch
+# - Build Target: Windows x64
+
+# Build as standard Windows build
+File → Build Settings → PC → Build
+```
+
+### Unreal Engine Build
+
+```bash
+# Project Settings → Plugins → enable OpenXR
+# Project Settings → Platforms → Windows → default to DirectX 12
+
+# Package as standard Windows build
+```
+
+---
+
+## AR (Mobile Augmented Reality)
+
+### When to Use
+
+- Phone/tablet AR applications
+- AR filters and effects
+- Indoor navigation
+- Product visualization
+
+### Platforms
+
+| Platform | SDK | Supported Devices |
+|----------|-----|-------------------|
+| ARKit | Apple | iPhone 6s+, iPad (2017+) |
+| ARCore | Google | Android 7.0+ with ARCore support |
+| Vuforia | Cross-platform | Wide device support |
+| 8th Wall | Web AR | Any smartphone browser |
+
+### Unity AR Build
+
+```bash
+# Install AR Foundation:
+# Window → Package Manager → AR Foundation + ARKit + ARCore
+
+# Build for iOS (ARKit) and Android (ARCore) as standard mobile builds
+```
+
+---
+
+## Selection Guide
+
+| Scenario | Recommended Platform | Engine |
+|----------|---------------------|--------|
+| VR game (standalone) | Meta Quest | Unity |
+| VR game (high-fidelity) | SteamVR (PC) | Unreal Engine |
+| Mixed reality app | Meta Quest 3 / Vision Pro | Unity |
+| Enterprise spatial app | Apple Vision Pro | Swift/RealityKit |
+| Mobile AR | ARKit + ARCore | Unity AR Foundation |
+| Web AR | 8th Wall | JavaScript |
+| VR training simulation | Meta Quest or SteamVR | Unity |
+| 3D product viewer | Web or mobile AR | Three.js / Unity |
+
+## Universal VR/AR Packaging Checklist
+
+1. **Frame rate** — maintain 90fps minimum (72fps Quest minimum); frame drops cause motion sickness
+2. **Input handling** — support hand tracking AND controllers
+3. **Comfort settings** — teleport locomotion option; vignette during movement
+4. **Spatial audio** — 3D positional audio is essential for immersion
+5. **Passthrough** — test mixed reality mode on Quest 3 / Vision Pro
+6. **App Lab first** — launch on App Lab before pursuing Quest Store
+7. **App Review guidelines** — Apple and Meta have strict VR/AR review requirements
+8. **Performance profiling** — use OVR Metrics Tool (Quest) / Instruments (visionOS)