remove preact and create setup wizard

.project/adrs/adr-001-tech-stack.md

@@ -1,53 +1,54 @@
-# ADR-001: Go Backend with Preact Frontend
+# ADR-001: Go Server with Embedded Web Assets
 
 ## Status
 Accepted
 
 ## Context
-We need to choose a backend language/framework and frontend technology for a documentation platform with these requirements:
-- Ultra-fast performance
-- Minimal external dependencies
-- No vendor lock-in
-- Battle-tested security
-- Server-side rendering for non-interactive pages
-- Offline-capable web client
+We need a documentation platform with fast page delivery, minimal external
+dependencies, secure server-side rendering, and a straightforward deployment
+artifact.
 
 ## Decision
-**Backend**: Go 1.22+ with standard library plus minimal, well-audited packages  
-**Frontend**: Preact 10 with TypeScript, Vite build system
+Use Go 1.24+ with the standard library plus minimal, audited packages. The Go
+binary serves HTML templates and embeds its CSS, images, and small browser
+scripts. There is no separate SPA, Node dependency tree, or frontend build
+pipeline.
+
+Browser scripts progressively add editing, offline caching, WebSocket updates,
+comments, and authentication interactions to server-rendered pages.
 
 ## Consequences
 
 ### Positive
-- Go's standard library is comprehensive and security-audited
-- Single static binary deployment — no runtime dependencies
-- Preact is 10KB (vs 40KB+ React) with identical API
-- Go's `html/template` provides safe SSR with auto-escaping
-- TypeScript gives type safety without runtime overhead
-- Both ecosystems have excellent supply-chain security (Go modules with checksums, npm audit)
+- One application binary and one build toolchain
+- Go `html/template` provides auto-escaped server rendering
+- Embedded assets deploy with the server binary
+- Fewer supply-chain dependencies and fewer moving parts in CI
+- Pages remain readable before browser scripts execute
 
 ### Negative
-- Go template syntax is less expressive than JSX
-- WebSocket sync logic must be implemented manually (no framework like Socket.io)
-- Preact ecosystem smaller than React (mitigated by using mostly native APIs)
+- Template syntax is less expressive than JSX
+- Browser behavior uses small framework-free modules
+- WebSocket and offline behavior must be maintained directly
 
 ## Alternatives Considered
 
+### Separate Preact SPA
+- **Pros**: Component model, client-side routing, TypeScript ecosystem
+- **Cons**: Adds Node tooling, package dependencies, a second build pipeline,
+  and duplicate UI surfaces
+- **Rejected**: The Go-served UI already covers the application surface
+
 ### Rust + Axum
 - **Pros**: Memory safety guarantees, excellent performance
-- **Cons**: Longer compile times, smaller talent pool, steeper learning curve for team
-- **Rejected**: Go's pragmatic balance of safety and velocity better fits project timeline
-
-### Deno Fresh
-- **Pros**: Island architecture, native TypeScript, no build step
-- **Cons**: Newer ecosystem, fewer audited libraries, Deno runtime less battle-tested than Go
-- **Rejected**: Go's maturity and deployment simplicity preferred
+- **Cons**: Longer compile times and steeper learning curve
+- **Rejected**: Go better fits the project deployment model
 
 ### Next.js / React Server Components
 - **Pros**: Mature ecosystem, built-in SSR
-- **Cons**: Heavy bundle size, complex build system, RSC lock-in, many dependencies
-- **Rejected**: Violates "minimal dependencies" and "no vendor lock-in" principles
+- **Cons**: Heavy build system and more runtime complexity
+- **Rejected**: Violates the minimal dependency goal
 
 ## References
 - Go Security Policy: https://go.dev/security
-- Preact Size Comparison: https://bundlephobia.com/package/preact@10.19.3
+- Go `html/template`: https://pkg.go.dev/html/template

.project/adrs/adr-003-ssr-strategy.md

@@ -1,67 +1,55 @@
-# ADR-003: SSR Strategy - Go Templates with Preact Hydration
+# ADR-003: SSR Strategy - Go Templates with Embedded Browser Scripts
 
 ## Status
 Accepted
 
 ## Context
-The application needs to serve document pages that are readable without JavaScript (for performance and accessibility), while providing rich interactivity (comments, editing, search) when JavaScript is available. We need a server-side rendering strategy that works with our Go backend and Preact frontend.
+Document pages must be readable quickly and safely while still supporting
+editing, authentication, comments, offline caching, and real-time updates.
 
 ## Decision
-**Strategy C**: Go's `html/template` renders initial HTML for all pages. Preact hydrates interactive components on the client.
+Go `html/template` renders complete HTML pages. The server embeds and serves
+small framework-free browser scripts for progressive enhancement.
 
 ### Implementation Details
 
 1. **Server Rendering**:
-   - Go handlers query database for document content
-   - Markdown parsed to HTML server-side (Goldmark)
-   - `html/template` renders full page with document HTML embedded
-   - No JavaScript required for reading
+   - Go handlers query document and account data
+   - Goldmark parses Markdown to HTML server-side
+   - `html/template` renders complete pages
+   - Pages are readable before JavaScript executes
 
-2. **Client Hydration**:
-   - Preact components mount into designated DOM containers
-   - Comments, search, editor are Preact islands
-   - Static content remains server-rendered HTML
-   - `preact-iso` handles client-side navigation between pages
-
-3. **Data Passing**:
-   - Initial state embedded as JSON in `<script type="application/json">` tags
-   - Preact reads initial state during hydration, avoids extra API calls
-   - CSP nonce applied to all inline scripts
+2. **Browser Enhancement**:
+   - Embedded scripts handle editing, comments, authentication, offline cache,
+     service-worker behavior, and WebSocket updates
+   - Native browser APIs are preferred over a client framework
+   - There is no separate SPA route or frontend build pipeline
 
 ## Consequences
 
 ### Positive
-- First contentful paint is instant (pure HTML)
-- SEO-friendly without extra complexity
-- Graceful degradation: works without JS
-- Go templates are auto-escaping XSS-safe
-- No V8/JS runtime embedded in Go binary
-- Smaller client bundle (only interactive components)
+- Fast first contentful paint
+- Auto-escaped templates
+- One deployable application artifact
+- Small browser payloads and no Node build dependency
+- Interactive features stay close to their HTTP endpoints
 
 ### Negative
-- Some code duplication: markdown parsing logic in both Go and JS (for preview)
-- Template syntax is verbose compared to JSX
-- Hydration can cause flicker if not carefully managed
-- Client state must reconcile with server-rendered HTML
+- Browser modules need direct DOM event handling
+- Shared UI abstractions require deliberate maintenance
+- More complex browser interactions need focused integration tests
 
 ## Alternatives Considered
 
-### Go Templates Only (No Preact)
-- **Pros**: Zero client JS, maximum performance
-- **Cons**: No interactive features (comments, real-time sync, search)
-- **Rejected**: Doesn't meet collaboration requirements
+### Separate Hydrated SPA
+- **Pros**: Component framework and client-side routing
+- **Cons**: Duplicates UI paths and introduces a second toolchain
+- **Rejected**: The server-rendered UI already supports the required behavior
 
-### Embedded JS Runtime (QuickJS/V8)
-- **Pros**: True isomorphic rendering, JSX templates
-- **Cons**: Adds C dependency, complex build, larger binary, security surface area
-- **Rejected**: Violates minimal dependency principle
-
-### Preact SSR via WASM
-- **Pros**: Same templates on server and client
-- **Cons**: WASM overhead, complex build pipeline, slower than Go templates
-- **Rejected**: Go templates are faster and simpler
+### Embedded JS Runtime
+- **Pros**: Isomorphic rendering
+- **Cons**: Larger binary and additional security surface
+- **Rejected**: Go templates are simpler
 
 ## References
-- Go html/template security: https://pkg.go.dev/html/template
-- Preact hydration: https://preactjs.com/guide/v10/server-side-rendering
-- Islands Architecture: https://jasonformat.com/islands-architecture/
+- Go `html/template`: https://pkg.go.dev/html/template