fix: limit request body size on auth form handlers (gosec G120)

Datastar's NewSSE() flushes HTTP headers before SCS's session middleware
can attach the Set-Cookie header, so the session cookie never reaches the
browser after login/register/logout.

Convert login, register, and logout to standard HTML forms with HTTP
redirects, which lets SCS write cookies normally. Also fix return_url
capture on the login page (was never being stored in the session).

Add handler tests covering login, register, and logout flows.

.claude/commands/release.md

@@ -1,45 +0,0 @@
-Create a new Gitea release for this project using semantic versioning.
-
-## Current state
-
-Fetch tags and find the latest version:
-
-```
-!git fetch --tags && git tag --sort=-v:refname | head -5
-```
-
-Commits since the last release (if no tags exist, this shows all commits):
-
-```
-!git log $(git describe --tags --abbrev=0 2>/dev/null && echo "$(git describe --tags --abbrev=0)..HEAD" || echo "") --oneline
-```
-
-## Instructions
-
-1. **Determine current version** from the tag output above. If no `vX.Y.Z` tags exist, treat current version as `v0.0.0`.
-
-2. **Analyze commits** using conventional commit prefixes to pick the semver bump:
-   - Breaking changes (`!` after type, or `BREAKING CHANGE` in body) → **major** bump
-   - `feat:` → **minor** bump
-   - `fix:`, `chore:`, `deps:`, `revert:`, and everything else → **patch** bump
-   - Use the **highest** applicable bump level across all commits
-
-3. **Generate release notes** — group commits into sections:
-   - **Features** — `feat:` commits
-   - **Fixes** — `fix:` commits
-   - **Other** — everything else (`chore:`, `deps:`, `revert:`, etc.)
-   - Omit empty sections. Each commit is a bullet point with its short description (strip the prefix).
-
-4. **Present for approval** — show the user:
-   - Current version → proposed new version
-   - The full release notes
-   - The exact `tea` command that will run
-   - Ask the user to confirm before proceeding
-
-5. **Create the release** — on user approval, run:
-   ```
-   tea releases create --login gitea --repo ryan/c4 --tag <version> --target main -t "<version>" -n "<release notes>"
-   ```
-   Do NOT create a local git tag — Gitea creates it server-side.
-
-6. **Verify** — run `tea releases ls --login gitea --repo ryan/c4` to confirm the release was created.

.dockerignore

@@ -1,10 +1,10 @@
-c4
+games
-c4.db
+games.db
 data/
 deploy/
 .env
 .git
 .gitignore
 assets/css/output.css
-c4-deploy-*.tar.gz
+games-deploy-*.tar.gz
-c4-deploy-*_b64*.txt
+games-deploy-*_b64*.txt

.env.example

@@ -1,8 +1,8 @@
 # Log level (TRACE, DEBUG, INFO, WARN, ERROR). Defaults to INFO.
 # LOG_LEVEL=DEBUG
 
-# SQLite database path. Defaults to data/c4.db.
+# SQLite database path. Defaults to data/games.db.
-# DB_PATH=data/c4.db
+# DB_PATH=data/games.db
 
 # Application URL for invite links. Defaults to https://games.adriatica.io.
 # APP_URL=http://localhost:7331
@@ -12,5 +12,5 @@
 
 # Goose CLI migration config (only needed for running goose manually)
 GOOSE_DRIVER=sqlite3
-GOOSE_DBSTRING=data/c4.db?_pragma=foreign_keys(1)&_pragma=journal_mode(WAL)
+GOOSE_DBSTRING=data/games.db?_pragma=foreign_keys(1)&_pragma=journal_mode(WAL)
 GOOSE_MIGRATION_DIR=db/migrations

.gitea/workflows/deploy.yml

@@ -6,7 +6,7 @@ on:
   pull_request:
 
 env:
-  DEPLOY_DIR: /home/ryan/c4
+  DEPLOY_DIR: /home/ryan/games
 
 jobs:
   test:
@@ -48,6 +48,8 @@ jobs:
     runs-on: games
     steps:
       - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # Need full history for git describe
 
       - name: Sync to deploy directory
         run: |
@@ -59,4 +61,8 @@ jobs:
           mkdir -p $DEPLOY_DIR/data
 
       - name: Rebuild and restart
-        run: cd $DEPLOY_DIR && docker compose up -d --build --remove-orphans
+        run: |
+          cd $DEPLOY_DIR
+          VERSION=$(git describe --tags --always)
+          COMMIT=$(git rev-parse --short HEAD)
+          VERSION=$VERSION COMMIT=$COMMIT docker compose up -d --build --remove-orphans

.gitignore

@@ -19,6 +19,7 @@
 
 !.env.example
 !LICENSE
+!AGENTS.md
 
 !assets/**/*
 

.golangci.yml

@@ -35,7 +35,7 @@ formatters:
   settings:
     goimports:
       local-prefixes:
-        - github.com/ryanhamamura/c4
+        - github.com/ryanhamamura/games
 
 issues:
   exclude-rules:

AGENTS.md

@@ -0,0 +1,253 @@
+# AGENTS.md
+
+Instructions for AI coding agents working in this repository.
+
+## Quick Reference
+
+```bash
+# Development
+task live              # Hot-reload dev server (templ + tailwind + air)
+task build             # Production build to bin/games
+task run               # Build and run server
+
+# Quality
+task test              # Run all tests: go test ./...
+task lint              # Run linter: golangci-lint run
+
+# Single test
+go test -run TestName ./path/to/package
+
+# Code generation
+task build:templ       # Compile .templ files
+task build:styles      # Build TailwindCSS
+go generate ./...      # Run sqlc for DB queries
+```
+
+## Workflow Rules
+
+- **Never merge PRs without explicit user approval.** Create the PR, push changes, then wait.
+- Always use PRs via `tea` CLI - never push directly to main.
+- Write semantic commit messages focusing on "why" not "what".
+
+## Project Structure
+
+```
+games/
+├── connect4/, snake/       # Game logic packages (pure Go)
+├── features/               # Feature modules (handlers, routes, templates)
+│   ├── auth/               # Login/register
+│   ├── c4game/             # Connect 4 UI
+│   ├── snakegame/          # Snake UI
+│   ├── lobby/              # Game lobby
+│   └── common/             # Shared components, layouts
+├── chat/                   # Reusable chat room (NATS + persistence)
+├── db/                     # SQLite, migrations, sqlc queries
+├── assets/                 # Static files (embedded)
+└── config/, logging/, nats/, sessions/, router/  # Infrastructure
+```
+
+## Code Style
+
+### Imports
+
+Organize in three groups: stdlib, third-party, local. The linter enforces this.
+
+```go
+import (
+    "context"
+    "fmt"
+    "net/http"
+
+    "github.com/go-chi/chi/v5"
+    "github.com/rs/zerolog/log"
+
+    "github.com/ryanhamamura/games/connect4"
+    "github.com/ryanhamamura/games/db/repository"
+)
+```
+
+### Naming Conventions
+
+| Type | Convention | Examples |
+|------|------------|----------|
+| Files | lowercase, underscores | `config_dev.go`, `handlers.go` |
+| HTTP handlers | `Handle` prefix | `HandleGamePage`, `HandleLogin` |
+| Constructors | `New` prefix | `NewStore`, `NewRoom` |
+| Getters | `Get` prefix | `GetPlayerID`, `GetGame` |
+| Setup functions | `Setup` prefix | `SetupRoutes`, `SetupLogger` |
+| Types | PascalCase | `Game`, `Player`, `Instance` |
+| Status enums | `Status` prefix | `StatusWaitingForPlayer`, `StatusInProgress` |
+| Session keys | `Key` prefix | `KeyPlayerID`, `KeyUserID` |
+
+### Error Handling
+
+1. **Wrap errors with context:**
+   ```go
+   return fmt.Errorf("loading game %s: %w", id, err)
+   ```
+
+2. **Return (result, error) tuples:**
+   ```go
+   func loadGame(queries *repository.Queries, id string) (*Game, error)
+   ```
+
+3. **Best-effort operations** - use nolint comment:
+   ```go
+   nc.Publish(subject, nil) //nolint:errcheck // best-effort notification
+   ```
+
+4. **HTTP errors:**
+   ```go
+   http.Error(w, "game not found", http.StatusNotFound)
+   http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+   ```
+
+### Comments
+
+- Focus on **why**, not **how**. Avoid superfluous comments.
+- Package comments at top of primary file:
+  ```go
+  // Package connect4 implements Connect 4 game logic, state management, and persistence.
+  package connect4
+  ```
+- Function comments for exported functions:
+  ```go
+  // DropPiece attempts to drop a piece in the given column.
+  // Returns (row placed, success).
+  func (g *Game) DropPiece(col, playerColor int) (int, bool)
+  ```
+
+## Go Patterns
+
+### Dependency Injection via Closures
+
+Handlers receive dependencies and return `http.HandlerFunc`:
+
+```go
+func HandleGamePage(store *connect4.Store, sm *scs.SessionManager) http.HandlerFunc {
+    return func(w http.ResponseWriter, r *http.Request) {
+        // use store, sm here
+    }
+}
+```
+
+### Mutex for Concurrent Access
+
+```go
+type Store struct {
+    games   map[string]*Instance
+    gamesMu sync.RWMutex
+}
+
+func (s *Store) Get(id string) (*Instance, bool) {
+    s.gamesMu.RLock()
+    defer s.gamesMu.RUnlock()
+    inst, ok := s.games[id]
+    return inst, ok
+}
+```
+
+### Build Tags for Environment
+
+```go
+//go:build dev
+
+//go:build !dev
+```
+
+### Embedded Filesystems
+
+```go
+//go:embed assets
+var assets embed.FS
+
+//go:embed migrations/*.sql
+var MigrationFS embed.FS
+```
+
+### Graceful Shutdown
+
+```go
+eg, egctx := errgroup.WithContext(ctx)
+eg.Go(func() error { return server.ListenAndServe() })
+eg.Go(func() error {
+    <-egctx.Done()
+    return server.Shutdown(context.Background())
+})
+return eg.Wait()
+```
+
+## Templ + Datastar Patterns
+
+### SSE Connection with Disabled Cancellation
+
+Datastar cancels SSE on user interaction by default. Disable for persistent connections:
+
+```go
+data-init={ fmt.Sprintf("@get('/games/%s/events',{requestCancellation:'disabled'})", g.ID) }
+```
+
+### Prevent Script Duplication on SSE Patches
+
+Use `templ.NewOnceHandle()` for scripts in components that get patched:
+
+```go
+var scriptHandle = templ.NewOnceHandle()
+
+templ MyComponent() {
+    <div id="my-component">...</div>
+    @scriptHandle.Once() {
+        @myScript()
+    }
+}
+```
+
+### Conditional Classes with templ.KV
+
+```go
+class={
+    "status status-sm",
+    templ.KV("status-success", isConnected),
+    templ.KV("status-error", !isConnected),
+}
+```
+
+### Datastar SSE Responses
+
+```go
+sse := datastar.NewSSE(w, r)
+sse.MergeFragmentTempl(components.GameBoard(game))
+```
+
+## Tech Stack
+
+| Layer | Technology |
+|-------|------------|
+| Templates | templ (type-safe HTML) |
+| Reactivity | Datastar (SSE-driven) |
+| CSS | TailwindCSS v4 + daisyUI |
+| Router | chi/v5 |
+| Sessions | scs/v2 |
+| Database | SQLite (modernc.org/sqlite) |
+| Migrations | goose |
+| SQL codegen | sqlc |
+| Pub/sub | Embedded NATS |
+| Logging | zerolog |
+
+## Testing
+
+```bash
+# All tests
+task test
+
+# Single test
+go test -run TestDropPiece ./connect4
+
+# With verbose output
+go test -v -run TestDropPiece ./connect4
+
+# Test a package
+go test ./connect4/...
+```
+
+Use `testutil.SetupTestDB()` for tests requiring database access.

Dockerfile

@@ -1,5 +1,8 @@
 FROM docker.io/golang:1.25.4-alpine AS build
 
+ARG VERSION=dev
+ARG COMMIT=unknown
+
 RUN apk add --no-cache upx
 
 WORKDIR /src
@@ -7,12 +10,14 @@ COPY go.mod go.sum ./
 RUN go mod download
 
 COPY . .
+RUN go tool templ generate
 RUN go tool gotailwind -i assets/css/input.css -o assets/css/output.css --minify
 RUN --mount=type=cache,target=/root/.cache/go-build \
-    CGO_ENABLED=0 go build -ldflags="-s" -o /bin/c4 .
+    MODULE=$(head -1 go.mod | awk '{print $2}') && \
-RUN upx -9 -k /bin/c4
+    CGO_ENABLED=0 go build -ldflags="-s -X $MODULE/version.Version=$VERSION -X $MODULE/version.Commit=$COMMIT" -o /bin/games .
+RUN upx -9 -k /bin/games
 
 FROM scratch
 ENV PORT=8080
-COPY --from=build /bin/c4 /
+COPY --from=build /bin/games /
-ENTRYPOINT ["/c4"]
+ENTRYPOINT ["/games"]

Taskfile.yml

@@ -27,9 +27,9 @@ tasks:
       - "assets/css/output.css"
 
   build:
-    desc: Production build to bin/c4
+    desc: Production build to bin/games
     cmds:
-      - go build -o bin/c4 .
+      - go build -o bin/games .
     deps:
       - build:templ
       - build:styles
@@ -49,8 +49,8 @@ tasks:
     cmds:
       - |
         go tool air  \
-         -build.cmd "go build -tags=dev -o tmp/bin/c4 ." \
+         -build.cmd "go build -tags=dev -o tmp/bin/games ." \
-         -build.bin "tmp/bin/c4" \
+         -build.bin "tmp/bin/games" \
          -build.exclude_dir "data,bin,tmp,deploy" \
          -build.include_ext "go,templ" \
          -misc.clean_on_exit "true"
@@ -75,7 +75,7 @@ tasks:
   run:
     desc: Build and run the server
     cmds:
-      - ./bin/c4
+      - ./bin/games
     deps:
       - build
 

assets/assets.go

@@ -0,0 +1,5 @@
+// Package assets provides static file serving with build-tag switching
+// between live filesystem (dev) and embedded hashfs (prod).
+package assets
+
+const DirectoryPath = "assets"

assets/static_dev.go

@@ -0,0 +1,22 @@
+//go:build dev
+
+package assets
+
+import (
+	"net/http"
+	"os"
+
+	"github.com/rs/zerolog/log"
+)
+
+func Handler() http.Handler {
+	log.Debug().Str("path", DirectoryPath).Msg("static assets served from filesystem")
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Cache-Control", "no-store")
+		http.StripPrefix("/assets/", http.FileServerFS(os.DirFS(DirectoryPath))).ServeHTTP(w, r)
+	})
+}
+
+func StaticPath(path string) string {
+	return "/assets/" + path
+}

assets/static_prod.go

@@ -0,0 +1,26 @@
+//go:build !dev
+
+package assets
+
+import (
+	"embed"
+	"net/http"
+
+	"github.com/benbjohnson/hashfs"
+	"github.com/rs/zerolog/log"
+)
+
+var (
+	//go:embed css js
+	staticFiles embed.FS
+	staticSys   = hashfs.NewFS(staticFiles)
+)
+
+func Handler() http.Handler {
+	log.Debug().Msg("static assets are embedded with hashfs")
+	return http.StripPrefix("/assets/", hashfs.FileServer(staticSys))
+}
+
+func StaticPath(path string) string {
+	return "/assets/" + staticSys.HashName(path)
+}

chat/chat.go

@@ -3,11 +3,15 @@
 package chat
 
 import (
+	"context"
 	"encoding/json"
+	"slices"
 	"sync"
 
 	"github.com/nats-io/nats.go"
 	"github.com/rs/zerolog/log"
+
+	"github.com/ryanhamamura/games/db/repository"
 )
 
 // Message is the wire format for chat messages over NATS.
@@ -21,26 +25,47 @@ type Message struct {
 const maxMessages = 50
 
 // Room manages an in-memory message buffer and NATS pub/sub for a single
-// chat room (typically one per game).
+// chat room (typically one per game). When created with NewPersistentRoom,
+// messages are automatically loaded from and saved to the database.
 type Room struct {
 	subject  string
 	nc       *nats.Conn
 	messages []Message
 	mu       sync.Mutex
+
+	// Optional persistence; nil for ephemeral rooms (e.g. snake).
+	queries *repository.Queries
+	roomID  string
 }
 
-// NewRoom creates a chat room that publishes and subscribes on the given
+// NewRoom creates an ephemeral chat room with no database persistence.
-// NATS subject (e.g. "chat.abc123").
+func NewRoom(nc *nats.Conn, subject string) *Room {
-func NewRoom(nc *nats.Conn, subject string, initial []Message) *Room {
 	return &Room{
-		subject:  subject,
+		subject: subject,
-		nc:       nc,
+		nc:      nc,
-		messages: initial,
 	}
 }
 
-// Send publishes a message to the room's NATS subject.
+// NewPersistentRoom creates a chat room backed by the database. It loads
+// existing messages on creation and auto-saves new messages on Send.
+func NewPersistentRoom(nc *nats.Conn, subject string, queries *repository.Queries, roomID string) *Room {
+	r := &Room{
+		subject: subject,
+		nc:      nc,
+		queries: queries,
+		roomID:  roomID,
+	}
+	r.messages = r.loadMessages()
+	return r
+}
+
+// Send publishes a message to the room's NATS subject and persists it
+// if the room is backed by a database.
 func (r *Room) Send(msg Message) {
+	if r.queries != nil {
+		r.saveMessage(msg)
+	}
+
 	data, err := json.Marshal(msg)
 	if err != nil {
 		log.Error().Err(err).Str("subject", r.subject).Msg("failed to marshal chat message")
@@ -51,12 +76,11 @@ func (r *Room) Send(msg Message) {
 	}
 }
 
-// Receive processes an incoming NATS message, appending it to the buffer.
+// receive processes an incoming NATS message, appending it to the buffer.
-// Returns the new message and a snapshot of all messages.
+func (r *Room) receive(data []byte) (Message, bool) {
-func (r *Room) Receive(data []byte) (Message, []Message) {
 	var msg Message
 	if err := json.Unmarshal(data, &msg); err != nil {
-		return msg, nil
+		return msg, false
 	}
 
 	r.mu.Lock()
@@ -64,11 +88,9 @@ func (r *Room) Receive(data []byte) (Message, []Message) {
 	if len(r.messages) > maxMessages {
 		r.messages = r.messages[len(r.messages)-maxMessages:]
 	}
-	snapshot := make([]Message, len(r.messages))
-	copy(snapshot, r.messages)
 	r.mu.Unlock()
 
-	return msg, snapshot
+	return msg, true
 }
 
 // Messages returns a snapshot of the current message buffer.
@@ -80,13 +102,62 @@ func (r *Room) Messages() []Message {
 	return snapshot
 }
 
-// Subscribe creates a NATS channel subscription for the room's subject.
+// Subscribe returns a channel of parsed messages and a cleanup function.
-// Caller is responsible for unsubscribing.
+// The room handles NATS subscription internally and buffers messages.
-func (r *Room) Subscribe() (chan *nats.Msg, *nats.Subscription, error) {
+func (r *Room) Subscribe() (<-chan Message, func()) {
-	ch := make(chan *nats.Msg, 64)
+	natsCh := make(chan *nats.Msg, 64)
-	sub, err := r.nc.ChanSubscribe(r.subject, ch)
+	msgCh := make(chan Message, 64)
+
+	sub, err := r.nc.ChanSubscribe(r.subject, natsCh)
 	if err != nil {
-		return nil, nil, err
+		close(msgCh)
+		return msgCh, func() {}
 	}
-	return ch, sub, nil
+
+	go func() {
+		for natsMsg := range natsCh {
+			if msg, ok := r.receive(natsMsg.Data); ok {
+				msgCh <- msg
+			}
+		}
+		close(msgCh)
+	}()
+
+	cleanup := func() {
+		_ = sub.Unsubscribe()
+	}
+
+	return msgCh, cleanup
+}
+
+func (r *Room) saveMessage(msg Message) {
+	err := r.queries.CreateChatMessage(context.Background(), repository.CreateChatMessageParams{
+		GameID:    r.roomID,
+		Nickname:  msg.Nickname,
+		Color:     int64(msg.Slot),
+		Message:   msg.Message,
+		CreatedAt: msg.Time,
+	})
+	if err != nil {
+		log.Error().Err(err).Str("room_id", r.roomID).Msg("failed to save chat message")
+	}
+}
+
+func (r *Room) loadMessages() []Message {
+	rows, err := r.queries.GetChatMessages(context.Background(), r.roomID)
+	if err != nil {
+		return nil
+	}
+	msgs := make([]Message, len(rows))
+	for i, row := range rows {
+		msgs[i] = Message{
+			Nickname: row.Nickname,
+			Slot:     int(row.Color),
+			Message:  row.Message,
+			Time:     row.CreatedAt,
+		}
+	}
+	// DB returns newest-first; reverse for chronological display
+	slices.Reverse(msgs)
+	return msgs
 }

chat/components/chat.templ

@@ -3,7 +3,7 @@ package components
 import (
 	"fmt"
 
-	"github.com/ryanhamamura/c4/chat"
+	"github.com/ryanhamamura/games/chat"
 	"github.com/starfederation/datastar-go/datastar"
 )
 
@@ -23,16 +23,21 @@ type Config struct {
 	StopKeyPropagation bool
 }
 
+// ChatMessage renders a single chat message. Used for appending new messages via SSE.
+templ ChatMessage(m chat.Message, cfg Config) {
+	<div class={ cfg.CSSPrefix + "-chat-msg" }>
+		<span style={ fmt.Sprintf("color:%s;font-weight:bold;", cfg.Color(m.Slot)) }>
+			{ m.Nickname + ": " }
+		</span>
+		<span>{ m.Message }</span>
+	</div>
+}
+
 templ Chat(messages []chat.Message, cfg Config) {
 	<div id={ cfg.CSSPrefix + "-chat" } class={ cfg.CSSPrefix + "-chat" }>
-		<div class={ cfg.CSSPrefix + "-chat-history" }>
+		<div id={ cfg.CSSPrefix + "-chat-history" } class={ cfg.CSSPrefix + "-chat-history" }>
 			for _, m := range messages {
-				<div class={ cfg.CSSPrefix + "-chat-msg" }>
+				@ChatMessage(m, cfg)
-					<span style={ fmt.Sprintf("color:%s;font-weight:bold;", cfg.Color(m.Slot)) }>
-						{ m.Nickname + ": " }
-					</span>
-					<span>{ m.Message }</span>
-				</div>
 			}
 		</div>
 		<div class={ cfg.CSSPrefix + "-chat-input" } data-morph-ignore>
@@ -42,21 +47,20 @@ templ Chat(messages []chat.Message, cfg Config) {
 					placeholder="Chat..."
 					autocomplete="off"
 					data-bind="chatMsg"
-					data-on:keydown.stop=""
+					data-on:keydown__stop={ "evt.key === 'Enter' && " + datastar.PostSSE("%s", cfg.PostURL) }
-					data-on:keydown.key_enter={ datastar.PostSSE(cfg.PostURL) }
+			/>
-				/>
+		} else {
-			} else {
+			<input
-				<input
+				type="text"
-					type="text"
+				placeholder="Chat..."
-					placeholder="Chat..."
+				autocomplete="off"
-					autocomplete="off"
+				data-bind="chatMsg"
-					data-bind="chatMsg"
+				data-on:keydown={ "evt.key === 'Enter' && " + datastar.PostSSE("%s", cfg.PostURL) }
-					data-on:keydown.enter={ datastar.PostSSE(cfg.PostURL) }
+			/>
-				/>
+		}
-			}
+		<button
-			<button
+			type="button"
-				type="button"
+			data-on:click={ datastar.PostSSE("%s", cfg.PostURL) }
-				data-on:click={ datastar.PostSSE(cfg.PostURL) }
 			>
 				Send
 			</button>

chat/persist.go

@@ -1,45 +0,0 @@
-package chat
-
-import (
-	"context"
-	"slices"
-
-	"github.com/ryanhamamura/c4/db/repository"
-
-	"github.com/rs/zerolog/log"
-)
-
-// SaveMessage persists a chat message to the database.
-func SaveMessage(queries *repository.Queries, roomID string, msg Message) {
-	err := queries.CreateChatMessage(context.Background(), repository.CreateChatMessageParams{
-		GameID:    roomID,
-		Nickname:  msg.Nickname,
-		Color:     int64(msg.Slot),
-		Message:   msg.Message,
-		CreatedAt: msg.Time,
-	})
-	if err != nil {
-		log.Error().Err(err).Str("room_id", roomID).Msg("failed to save chat message")
-	}
-}
-
-// LoadMessages loads persisted chat messages for a room, returning them
-// in chronological order (oldest first).
-func LoadMessages(queries *repository.Queries, roomID string) []Message {
-	rows, err := queries.GetChatMessages(context.Background(), roomID)
-	if err != nil {
-		return nil
-	}
-	msgs := make([]Message, len(rows))
-	for i, r := range rows {
-		msgs[i] = Message{
-			Nickname: r.Nickname,
-			Slot:     int(r.Color),
-			Message:  r.Message,
-			Time:     r.CreatedAt,
-		}
-	}
-	// DB returns newest-first; reverse for chronological display
-	slices.Reverse(msgs)
-	return msgs
-}

config/config.go

@@ -71,6 +71,6 @@ func loadBase() *Config {
 			}
 		}(),
 		AppURL: getEnv("APP_URL", "https://games.adriatica.io"),
-		DBPath: getEnv("DB_PATH", "data/c4.db"),
+		DBPath: getEnv("DB_PATH", "data/games.db"),
 	}
 }

connect4/logic.go

@@ -1,5 +1,5 @@
-// Package game implements Connect 4 game logic, state management, and persistence.
+// Package connect4 implements Connect 4 game logic, state management, and persistence.
-package game
+package connect4
 
 // DropPiece attempts to drop a piece in the given column.
 // Returns (row placed, success).

connect4/persist.go

@@ -1,15 +1,15 @@
-package game
+package connect4
 
 import (
 	"context"
 
-	"github.com/ryanhamamura/c4/db/repository"
+	"github.com/ryanhamamura/games/db/repository"
-	"github.com/ryanhamamura/c4/player"
+	"github.com/ryanhamamura/games/player"
 
 	"github.com/rs/zerolog/log"
 )
 
-func (gi *GameInstance) save() error {
+func (gi *Instance) save() error {
 	err := saveGame(gi.queries, gi.game)
 	if err != nil {
 		log.Error().Err(err).Str("game_id", gi.game.ID).Msg("failed to save game")
@@ -17,8 +17,8 @@ func (gi *GameInstance) save() error {
 	return err
 }
 
-func (gi *GameInstance) savePlayer(player *Player, slot int) error {
+func (gi *Instance) savePlayer(p *Player, slot int) error {
-	err := saveGamePlayer(gi.queries, gi.game.ID, player, slot)
+	err := saveGamePlayer(gi.queries, gi.game.ID, p, slot)
 	if err != nil {
 		log.Error().Err(err).Str("game_id", gi.game.ID).Int("slot", slot).Msg("failed to save game player")
 	}
@@ -48,12 +48,12 @@ func saveGame(queries *repository.Queries, g *Game) error {
 	})
 }
 
-func saveGamePlayer(queries *repository.Queries, gameID string, player *Player, slot int) error {
+func saveGamePlayer(queries *repository.Queries, gameID string, p *Player, slot int) error {
 	var userID, guestPlayerID *string
-	if player.UserID != nil {
+	if p.UserID != nil {
-		userID = player.UserID
+		userID = p.UserID
 	} else {
-		id := string(player.ID)
+		id := string(p.ID)
 		guestPlayerID = &id
 	}
 
@@ -61,8 +61,8 @@ func saveGamePlayer(queries *repository.Queries, gameID string, player *Player,
 		GameID:        gameID,
 		UserID:        userID,
 		GuestPlayerID: guestPlayerID,
-		Nickname:      player.Nickname,
+		Nickname:      p.Nickname,
-		Color:         int64(player.Color),
+		Color:         int64(p.Color),
 		Slot:          int64(slot),
 	})
 }
@@ -83,13 +83,11 @@ func loadGamePlayers(queries *repository.Queries, id string) ([]*Player, error)
 	return playersFromRows(rows), nil
 }
 
-// Domain ↔ DB mapping helpers.
-
 func gameFromRow(row *repository.Game) (*Game, error) {
 	g := &Game{
 		ID:          row.ID,
 		CurrentTurn: int(row.CurrentTurn),
-		Status:      GameStatus(row.Status),
+		Status:      Status(row.Status),
 	}
 
 	if err := g.BoardFromJSON(row.Board); err != nil {

connect4/store.go

@@ -1,78 +1,78 @@
-package game
+package connect4
 
 import (
 	"context"
 	"sync"
 
-	"github.com/ryanhamamura/c4/db/repository"
+	"github.com/ryanhamamura/games/db/repository"
-	"github.com/ryanhamamura/c4/player"
+	"github.com/ryanhamamura/games/player"
 )
 
 type PlayerSession struct {
 	Player *Player
 }
 
-type GameStore struct {
+type Store struct {
-	games      map[string]*GameInstance
+	games      map[string]*Instance
 	gamesMu    sync.RWMutex
 	queries    *repository.Queries
 	notifyFunc func(gameID string)
 }
 
-func NewGameStore(queries *repository.Queries) *GameStore {
+func NewStore(queries *repository.Queries) *Store {
-	return &GameStore{
+	return &Store{
-		games:   make(map[string]*GameInstance),
+		games:   make(map[string]*Instance),
 		queries: queries,
 	}
 }
 
-func (gs *GameStore) SetNotifyFunc(f func(gameID string)) {
+func (s *Store) SetNotifyFunc(f func(gameID string)) {
-	gs.notifyFunc = f
+	s.notifyFunc = f
 }
 
-func (gs *GameStore) makeNotify(gameID string) func() {
+func (s *Store) makeNotify(gameID string) func() {
 	return func() {
-		if gs.notifyFunc != nil {
+		if s.notifyFunc != nil {
-			gs.notifyFunc(gameID)
+			s.notifyFunc(gameID)
 		}
 	}
 }
 
-func (gs *GameStore) Create() *GameInstance {
+func (s *Store) Create() *Instance {
 	id := player.GenerateID(4)
-	gi := NewGameInstance(id)
+	gi := NewInstance(id)
-	gi.queries = gs.queries
+	gi.queries = s.queries
-	gi.notify = gs.makeNotify(id)
+	gi.notify = s.makeNotify(id)
-	gs.gamesMu.Lock()
+	s.gamesMu.Lock()
-	gs.games[id] = gi
+	s.games[id] = gi
-	gs.gamesMu.Unlock()
+	s.gamesMu.Unlock()
 
-	if gs.queries != nil {
+	if s.queries != nil {
 		gi.save() //nolint:errcheck
 	}
 
 	return gi
 }
 
-func (gs *GameStore) Get(id string) (*GameInstance, bool) {
+func (s *Store) Get(id string) (*Instance, bool) {
-	gs.gamesMu.RLock()
+	s.gamesMu.RLock()
-	gi, ok := gs.games[id]
+	gi, ok := s.games[id]
-	gs.gamesMu.RUnlock()
+	s.gamesMu.RUnlock()
 
 	if ok {
 		return gi, true
 	}
 
-	if gs.queries == nil {
+	if s.queries == nil {
 		return nil, false
 	}
 
-	g, err := loadGame(gs.queries, id)
+	g, err := loadGame(s.queries, id)
 	if err != nil || g == nil {
 		return nil, false
 	}
 
-	players, _ := loadGamePlayers(gs.queries, id)
+	players, _ := loadGamePlayers(s.queries, id)
 	for _, p := range players {
 		switch p.Color {
 		case 1:
@@ -82,51 +82,51 @@ func (gs *GameStore) Get(id string) (*GameInstance, bool) {
 		}
 	}
 
-	gi = &GameInstance{
+	gi = &Instance{
 		game:    g,
-		queries: gs.queries,
+		queries: s.queries,
-		notify:  gs.makeNotify(id),
+		notify:  s.makeNotify(id),
 	}
 
-	gs.gamesMu.Lock()
+	s.gamesMu.Lock()
-	gs.games[id] = gi
+	s.games[id] = gi
-	gs.gamesMu.Unlock()
+	s.gamesMu.Unlock()
 
 	return gi, true
 }
 
-func (gs *GameStore) Delete(id string) error {
+func (s *Store) Delete(id string) error {
-	gs.gamesMu.Lock()
+	s.gamesMu.Lock()
-	delete(gs.games, id)
+	delete(s.games, id)
-	gs.gamesMu.Unlock()
+	s.gamesMu.Unlock()
 
-	if gs.queries != nil {
+	if s.queries != nil {
-		return gs.queries.DeleteGame(context.Background(), id)
+		return s.queries.DeleteGame(context.Background(), id)
 	}
 	return nil
 }
 
-type GameInstance struct {
+type Instance struct {
 	game    *Game
 	gameMu  sync.RWMutex
 	notify  func()
 	queries *repository.Queries
 }
 
-func NewGameInstance(id string) *GameInstance {
+func NewInstance(id string) *Instance {
-	return &GameInstance{
+	return &Instance{
 		game:   NewGame(id),
 		notify: func() {},
 	}
 }
 
-func (gi *GameInstance) ID() string {
+func (gi *Instance) ID() string {
 	gi.gameMu.RLock()
 	defer gi.gameMu.RUnlock()
 	return gi.game.ID
 }
 
-func (gi *GameInstance) Join(ps *PlayerSession) bool {
+func (gi *Instance) Join(ps *PlayerSession) bool {
 	gi.gameMu.Lock()
 	defer gi.gameMu.Unlock()
 
@@ -153,13 +153,13 @@ func (gi *GameInstance) Join(ps *PlayerSession) bool {
 	return true
 }
 
-func (gi *GameInstance) GetGame() *Game {
+func (gi *Instance) GetGame() *Game {
 	gi.gameMu.RLock()
 	defer gi.gameMu.RUnlock()
 	return gi.game
 }
 
-func (gi *GameInstance) GetPlayerColor(pid player.ID) int {
+func (gi *Instance) GetPlayerColor(pid player.ID) int {
 	gi.gameMu.RLock()
 	defer gi.gameMu.RUnlock()
 	for _, p := range gi.game.Players {
@@ -170,7 +170,7 @@ func (gi *GameInstance) GetPlayerColor(pid player.ID) int {
 	return 0
 }
 
-func (gi *GameInstance) CreateRematch(gs *GameStore) *GameInstance {
+func (gi *Instance) CreateRematch(s *Store) *Instance {
 	gi.gameMu.Lock()
 	defer gi.gameMu.Unlock()
 
@@ -178,13 +178,13 @@ func (gi *GameInstance) CreateRematch(gs *GameStore) *GameInstance {
 		return nil
 	}
 
-	newGI := gs.Create()
+	newGI := s.Create()
 	newID := newGI.ID()
 	gi.game.RematchGameID = &newID
 
 	if gi.queries != nil {
 		if err := gi.save(); err != nil {
-			gs.Delete(newID) //nolint:errcheck
+			s.Delete(newID) //nolint:errcheck
 			gi.game.RematchGameID = nil
 			return nil
 		}
@@ -194,7 +194,7 @@ func (gi *GameInstance) CreateRematch(gs *GameStore) *GameInstance {
 	return newGI
 }
 
-func (gi *GameInstance) DropPiece(col int, playerColor int) bool {
+func (gi *Instance) DropPiece(col int, playerColor int) bool {
 	gi.gameMu.Lock()
 	defer gi.gameMu.Unlock()
 

connect4/types.go

@@ -1,11 +1,20 @@
-package game
+package connect4
 
 import (
 	"encoding/json"
 
-	"github.com/ryanhamamura/c4/player"
+	"github.com/ryanhamamura/games/player"
 )
 
+// SubjectPrefix is the NATS subject namespace for connect4 games.
+const SubjectPrefix = "connect4"
+
+// GameSubject returns the NATS subject for game state updates.
+func GameSubject(gameID string) string { return SubjectPrefix + "." + gameID }
+
+// ChatSubject returns the NATS subject for chat messages.
+func ChatSubject(gameID string) string { return SubjectPrefix + ".chat." + gameID }
+
 type Player struct {
 	ID       player.ID
 	UserID   *string // UUID for authenticated users, nil for guests
@@ -13,10 +22,10 @@ type Player struct {
 	Color    int // 1 = Red, 2 = Yellow
 }
 
-type GameStatus int
+type Status int
 
 const (
-	StatusWaitingForPlayer GameStatus = iota
+	StatusWaitingForPlayer Status = iota
 	StatusInProgress
 	StatusWon
 	StatusDraw
@@ -27,7 +36,7 @@ type Game struct {
 	Board         [6][7]int  // 6 rows, 7 columns; 0=empty, 1=red, 2=yellow
 	Players       [2]*Player // Index 0 = creator (Red), Index 1 = joiner (Yellow)
 	CurrentTurn   int        // 1 or 2 (matches player color)
-	Status        GameStatus
+	Status        Status
 	Winner        *Player
 	WinningCells  [][2]int // Coordinates of winning 4 cells for highlighting
 	RematchGameID *string  // ID of the rematch game, if one was created

deploy/deploy.sh

@@ -1,11 +1,11 @@
 #!/usr/bin/env bash
-# Deploy the c4 binary to /opt/c4, then restart the service.
+# Deploy the games binary to /opt/games, then restart the service.
 # Works from the repo (builds first) or from an extracted tarball (pre-built binary).
 set -euo pipefail
 
 ROOT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
-INSTALL_DIR="/opt/c4"
+INSTALL_DIR="/opt/games"
-BINARY="$ROOT_DIR/c4"
+BINARY="$ROOT_DIR/games"
 
 # If Go is available and we have source, build fresh
 if [[ -f "$ROOT_DIR/go.mod" ]] && command -v go &>/dev/null; then
@@ -13,7 +13,7 @@ if [[ -f "$ROOT_DIR/go.mod" ]] && command -v go &>/dev/null; then
   (cd "$ROOT_DIR" && go tool gotailwind -i assets/css/input.css -o assets/css/output.css --minify)
 
   echo "Building binary..."
-  (cd "$ROOT_DIR" && CGO_ENABLED=0 go build -o c4 .)
+  (cd "$ROOT_DIR" && CGO_ENABLED=0 go build -o games .)
 fi
 
 if [[ ! -f "$BINARY" ]]; then
@@ -22,10 +22,10 @@ if [[ ! -f "$BINARY" ]]; then
 fi
 
 echo "Installing to $INSTALL_DIR..."
-install -o games -g games -m 755 "$BINARY" "$INSTALL_DIR/c4"
+install -o games -g games -m 755 "$BINARY" "$INSTALL_DIR/games"
 
 echo "Restarting service..."
-systemctl restart c4.service
+systemctl restart games.service
 
 echo "Done. Status:"
-systemctl status c4.service --no-pager
+systemctl status games.service --no-pager

deploy/games.service

@@ -1,13 +1,13 @@
 [Unit]
-Description=C4 Game Lobby
+Description=Games Lobby
 After=network.target
 
 [Service]
 Type=simple
 User=games
 Group=games
-WorkingDirectory=/opt/c4
+WorkingDirectory=/opt/games
-ExecStart=/opt/c4/c4
+ExecStart=/opt/games/games
 Restart=on-failure
 RestartSec=5
 
@@ -17,7 +17,7 @@ Environment=PORT=8080
 NoNewPrivileges=true
 ProtectSystem=strict
 ProtectHome=true
-ReadWritePaths=/opt/c4
+ReadWritePaths=/opt/games
 PrivateTmp=true
 
 [Install]

deploy/package.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Build the c4 binary, bundle it with deploy files into a tarball,
+# Build the games binary, bundle it with deploy files into a tarball,
 # base64-encode it, and split into 25MB chunks for transfer.
 set -euo pipefail
 
@@ -7,14 +7,14 @@ REPO_DIR="$(cd "$(dirname "$0")/.." && pwd)"
 cd "$REPO_DIR"
 
 TIMESTAMP=$(date +%Y%m%d-%H%M%S)
-TARBALL="c4-deploy-${TIMESTAMP}.tar.gz"
+TARBALL="games-deploy-${TIMESTAMP}.tar.gz"
-BASE64_FILE="c4-deploy-${TIMESTAMP}_b64.txt"
+BASE64_FILE="games-deploy-${TIMESTAMP}_b64.txt"
 
 #==============================================================================
 # Clean previous artifacts
 #==============================================================================
 echo "--- Cleaning old artifacts ---"
-rm -f ./c4 c4-deploy-*.tar.gz c4-deploy-*_b64*.txt
+rm -f ./games games-deploy-*.tar.gz games-deploy-*_b64*.txt
 
 #==============================================================================
 # Build
@@ -23,18 +23,18 @@ echo "--- Building CSS ---"
 go tool gotailwind -i assets/css/input.css -o assets/css/output.css --minify
 
 echo "--- Building binary (linux/amd64) ---"
-CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o c4 .
+CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o games .
 
 #==============================================================================
 # Verify required files
 #==============================================================================
 echo "--- Verifying files ---"
 REQUIRED_FILES=(
-  c4
+  games
   deploy/setup.sh
   deploy/deploy.sh
   deploy/reassemble.sh
-  deploy/c4.service
+  deploy/games.service
 )
 for f in "${REQUIRED_FILES[@]}"; do
   if [[ ! -f "$f" ]]; then
@@ -48,12 +48,12 @@ done
 # Create tarball
 #==============================================================================
 echo "--- Creating tarball ---"
-tar -czf "/tmp/${TARBALL}" --transform 's,^,c4/,' \
+tar -czf "/tmp/${TARBALL}" --transform 's,^,games/,' \
-  c4 \
+  games \
   deploy/setup.sh \
   deploy/deploy.sh \
   deploy/reassemble.sh \
-  deploy/c4.service
+  deploy/games.service
 
 mv "/tmp/${TARBALL}" .
 echo "  -> ${TARBALL} ($(du -h "${TARBALL}" | cut -f1))"
@@ -66,10 +66,10 @@ base64 "${TARBALL}" > "${BASE64_FILE}"
 echo "  -> ${BASE64_FILE} ($(du -h "${BASE64_FILE}" | cut -f1))"
 
 echo "--- Splitting into 25MB chunks ---"
-split -b 25M -d --additional-suffix=.txt "${BASE64_FILE}" "c4-deploy-${TIMESTAMP}_b64_part"
+split -b 25M -d --additional-suffix=.txt "${BASE64_FILE}" "games-deploy-${TIMESTAMP}_b64_part"
 rm -f "${BASE64_FILE}"
 
-CHUNKS=(c4-deploy-${TIMESTAMP}_b64_part*.txt)
+CHUNKS=(games-deploy-${TIMESTAMP}_b64_part*.txt)
 echo "  -> ${#CHUNKS[@]} chunk(s):"
 for chunk in "${CHUNKS[@]}"; do
   echo "     $chunk ($(du -h "$chunk" | cut -f1))"
@@ -83,5 +83,5 @@ echo "=== Package Complete ==="
 echo ""
 echo "Transfer the chunk files to the target server, then run:"
 echo "  ./reassemble.sh"
-echo "  cd ~/c4 && sudo ./deploy/setup.sh   # first time only"
+echo "  cd ~/games && sudo ./deploy/setup.sh   # first time only"
-echo "  cd ~/c4 && sudo ./deploy/deploy.sh"
+echo "  cd ~/games && sudo ./deploy/deploy.sh"

deploy/reassemble.sh

@@ -1,11 +1,11 @@
 #!/usr/bin/env bash
-# Reassembles base64 chunks and extracts the c4 deployment tarball.
+# Reassembles base64 chunks and extracts the games deployment tarball.
 # Expects chunk files in the current directory.
 set -euo pipefail
 
 cd "$HOME"
 
-echo "=== C4 Deployment Reassembler ==="
+echo "=== Games Deployment Reassembler ==="
 echo "Working directory: $HOME"
 echo ""
 
@@ -14,10 +14,10 @@ echo ""
 #==============================================================================
 echo "--- Finding chunk files ---"
 
-CHUNKS=($(ls -1 c4-deploy-*_b64_part*.txt 2>/dev/null | sort))
+CHUNKS=($(ls -1 games-deploy-*_b64_part*.txt 2>/dev/null | sort))
 
 if [[ ${#CHUNKS[@]} -eq 0 ]]; then
-  echo "ERROR: No chunk files found matching c4-deploy-*_b64_part*.txt"
+  echo "ERROR: No chunk files found matching games-deploy-*_b64_part*.txt"
   exit 1
 fi
 
@@ -32,8 +32,8 @@ done
 echo ""
 echo "--- Reassembling chunks ---"
 
-TIMESTAMP=$(echo "${CHUNKS[0]}" | sed -E 's/c4-deploy-([0-9]+-[0-9]+)_b64_part.*/\1/')
+TIMESTAMP=$(echo "${CHUNKS[0]}" | sed -E 's/games-deploy-([0-9]+-[0-9]+)_b64_part.*/\1/')
-TARBALL="c4-deploy-${TIMESTAMP}.tar.gz"
+TARBALL="games-deploy-${TIMESTAMP}.tar.gz"
 COMBINED="combined_b64.txt"
 
 echo "Concatenating chunks..."
@@ -58,12 +58,12 @@ fi
 echo ""
 echo "--- Archiving existing source ---"
 
-if [[ -d c4 ]]; then
+if [[ -d games ]]; then
-  rm -rf c4.bak
+  rm -rf games.bak
-  mv c4 c4.bak
+  mv games games.bak
-  echo "  -> Moved c4 -> c4.bak"
+  echo "  -> Moved games -> games.bak"
 else
-  echo "  -> No existing c4 directory"
+  echo "  -> No existing games directory"
 fi
 
 #==============================================================================
@@ -73,7 +73,7 @@ echo ""
 echo "--- Extracting tarball ---"
 
 tar -xzf "$TARBALL"
-echo "  -> Extracted to ~/c4"
+echo "  -> Extracted to ~/games"
 
 #==============================================================================
 # Cleanup
@@ -91,6 +91,6 @@ echo ""
 echo "=== Reassembly Complete ==="
 echo ""
 echo "Next steps:"
-echo "  cd ~/c4"
+echo "  cd ~/games"
 echo "  sudo ./deploy/setup.sh   # first time only"
 echo "  sudo ./deploy/deploy.sh"

deploy/setup.sh

@@ -10,20 +10,20 @@ fi
 
 # Create system user if it doesn't exist
 if ! id -u games &>/dev/null; then
-  useradd --system --shell /usr/sbin/nologin --home-dir /opt/c4 --create-home games
+  useradd --system --shell /usr/sbin/nologin --home-dir /opt/games --create-home games
   echo "Created system user: games"
 else
   echo "User 'games' already exists"
 fi
 
 # Ensure install directory exists with correct ownership
-install -d -o games -g games -m 755 /opt/c4
+install -d -o games -g games -m 755 /opt/games
-install -d -o games -g games -m 755 /opt/c4/data
+install -d -o games -g games -m 755 /opt/games/data
 
 # Install systemd unit
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-cp "$SCRIPT_DIR/c4.service" /etc/systemd/system/c4.service
+cp "$SCRIPT_DIR/games.service" /etc/systemd/system/games.service
 systemctl daemon-reload
-systemctl enable c4.service
+systemctl enable games.service
 
 echo "Setup complete. Run deploy.sh to build and start the service."

docker-compose.yml

@@ -1,7 +1,11 @@
 services:
-  c4:
+  games:
-    build: .
+    build:
-    container_name: c4
+      context: .
+      args:
+        VERSION: ${VERSION:-dev}
+        COMMIT: ${COMMIT:-unknown}
+    container_name: games
     restart: unless-stopped
     ports:
       - "8080:8080"
@@ -11,4 +15,4 @@ services:
     environment:
       - PORT=8080
     volumes:
-      - ./data:/app/data
+      - ./data:/data

features/auth/handlers.go

@@ -3,30 +3,26 @@ package auth
 import (
 	"database/sql"
 	"net/http"
+	"net/url"
 
 	"github.com/alexedwards/scs/v2"
 	"github.com/google/uuid"
-	"github.com/starfederation/datastar-go/datastar"
 
-	"github.com/ryanhamamura/c4/auth"
+	"github.com/ryanhamamura/games/auth"
-	"github.com/ryanhamamura/c4/db/repository"
+	"github.com/ryanhamamura/games/db/repository"
-	"github.com/ryanhamamura/c4/features/auth/pages"
+	"github.com/ryanhamamura/games/features/auth/pages"
+	appsessions "github.com/ryanhamamura/games/sessions"
 )
 
-type LoginSignals struct {
+func HandleLoginPage(sessions *scs.SessionManager) http.HandlerFunc {
-	Username string `json:"username"`
-	Password string `json:"password"` //nolint:gosec // form input, not stored
-}
-
-type RegisterSignals struct {
-	Username string `json:"username"`
-	Password string `json:"password"` //nolint:gosec // form input, not stored
-	Confirm  string `json:"confirm"`
-}
-
-func HandleLoginPage() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		if err := pages.LoginPage().Render(r.Context(), w); err != nil {
+		// Capture return_url so we can redirect back after login
+		if returnURL := r.URL.Query().Get("return_url"); returnURL != "" {
+			sessions.Put(r.Context(), "return_url", returnURL)
+		}
+
+		errorMsg := r.URL.Query().Get("error")
+		if err := pages.LoginPage(errorMsg).Render(r.Context(), w); err != nil {
 			http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
 		}
 	}
@@ -34,7 +30,8 @@ func HandleLoginPage() http.HandlerFunc {
 
 func HandleRegisterPage() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		if err := pages.RegisterPage().Render(r.Context(), w); err != nil {
+		errorMsg := r.URL.Query().Get("error")
+		if err := pages.RegisterPage(errorMsg).Render(r.Context(), w); err != nil {
 			http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
 		}
 	}
@@ -42,32 +39,28 @@ func HandleRegisterPage() http.HandlerFunc {
 
 func HandleLogin(queries *repository.Queries, sessions *scs.SessionManager) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		var signals LoginSignals
+		r.Body = http.MaxBytesReader(w, r.Body, 1024)
-		if err := datastar.ReadSignals(r, &signals); err != nil {
+		username := r.FormValue("username")
-			http.Error(w, err.Error(), http.StatusBadRequest)
+		password := r.FormValue("password")
-			return
-		}
 
-		sse := datastar.NewSSE(w, r)
+		user, err := queries.GetUserByUsername(r.Context(), username)
-
-		user, err := queries.GetUserByUsername(r.Context(), signals.Username)
 		if err == sql.ErrNoRows {
-			sse.MarshalAndPatchSignals(map[string]any{"error": "Invalid username or password"}) //nolint:errcheck
+			http.Redirect(w, r, "/login?error="+url.QueryEscape("Invalid username or password"), http.StatusSeeOther)
 			return
 		}
 		if err != nil {
-			sse.MarshalAndPatchSignals(map[string]any{"error": "An error occurred"}) //nolint:errcheck
+			http.Redirect(w, r, "/login?error="+url.QueryEscape("An error occurred"), http.StatusSeeOther)
 			return
 		}
-		if !auth.CheckPassword(signals.Password, user.PasswordHash) {
+		if !auth.CheckPassword(password, user.PasswordHash) {
-			sse.MarshalAndPatchSignals(map[string]any{"error": "Invalid username or password"}) //nolint:errcheck
+			http.Redirect(w, r, "/login?error="+url.QueryEscape("Invalid username or password"), http.StatusSeeOther)
 			return
 		}
 
 		sessions.RenewToken(r.Context()) //nolint:errcheck
-		sessions.Put(r.Context(), "user_id", user.ID)
+		sessions.Put(r.Context(), appsessions.KeyUserID, user.ID)
 		sessions.Put(r.Context(), "username", user.Username)
-		sessions.Put(r.Context(), "nickname", user.Username)
+		sessions.Put(r.Context(), appsessions.KeyNickname, user.Username)
 
 		redirectURL := "/"
 		if returnURL := sessions.GetString(r.Context(), "return_url"); returnURL != "" {
@@ -75,53 +68,50 @@ func HandleLogin(queries *repository.Queries, sessions *scs.SessionManager) http
 			redirectURL = returnURL
 		}
 
-		sse.Redirect(redirectURL) //nolint:errcheck
+		http.Redirect(w, r, redirectURL, http.StatusSeeOther)
 	}
 }
 
 func HandleRegister(queries *repository.Queries, sessions *scs.SessionManager) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		var signals RegisterSignals
+		r.Body = http.MaxBytesReader(w, r.Body, 1024)
-		if err := datastar.ReadSignals(r, &signals); err != nil {
+		username := r.FormValue("username")
-			http.Error(w, err.Error(), http.StatusBadRequest)
+		password := r.FormValue("password")
+		confirm := r.FormValue("confirm")
+
+		if err := auth.ValidateUsername(username); err != nil {
+			http.Redirect(w, r, "/register?error="+url.QueryEscape(err.Error()), http.StatusSeeOther)
+			return
+		}
+		if err := auth.ValidatePassword(password); err != nil {
+			http.Redirect(w, r, "/register?error="+url.QueryEscape(err.Error()), http.StatusSeeOther)
+			return
+		}
+		if password != confirm {
+			http.Redirect(w, r, "/register?error="+url.QueryEscape("Passwords do not match"), http.StatusSeeOther)
 			return
 		}
 
-		sse := datastar.NewSSE(w, r)
+		hash, err := auth.HashPassword(password)
-
-		if err := auth.ValidateUsername(signals.Username); err != nil {
-			sse.MarshalAndPatchSignals(map[string]any{"error": err.Error()}) //nolint:errcheck
-			return
-		}
-		if err := auth.ValidatePassword(signals.Password); err != nil {
-			sse.MarshalAndPatchSignals(map[string]any{"error": err.Error()}) //nolint:errcheck
-			return
-		}
-		if signals.Password != signals.Confirm {
-			sse.MarshalAndPatchSignals(map[string]any{"error": "Passwords do not match"}) //nolint:errcheck
-			return
-		}
-
-		hash, err := auth.HashPassword(signals.Password)
 		if err != nil {
-			sse.MarshalAndPatchSignals(map[string]any{"error": "An error occurred"}) //nolint:errcheck
+			http.Redirect(w, r, "/register?error="+url.QueryEscape("An error occurred"), http.StatusSeeOther)
 			return
 		}
 
 		user, err := queries.CreateUser(r.Context(), repository.CreateUserParams{
 			ID:           uuid.New().String(),
-			Username:     signals.Username,
+			Username:     username,
 			PasswordHash: hash,
 		})
 		if err != nil {
-			sse.MarshalAndPatchSignals(map[string]any{"error": "Username already taken"}) //nolint:errcheck
+			http.Redirect(w, r, "/register?error="+url.QueryEscape("Username already taken"), http.StatusSeeOther)
 			return
 		}
 
 		sessions.RenewToken(r.Context()) //nolint:errcheck
-		sessions.Put(r.Context(), "user_id", user.ID)
+		sessions.Put(r.Context(), appsessions.KeyUserID, user.ID)
 		sessions.Put(r.Context(), "username", user.Username)
-		sessions.Put(r.Context(), "nickname", user.Username)
+		sessions.Put(r.Context(), appsessions.KeyNickname, user.Username)
 
 		redirectURL := "/"
 		if returnURL := sessions.GetString(r.Context(), "return_url"); returnURL != "" {
@@ -129,6 +119,6 @@ func HandleRegister(queries *repository.Queries, sessions *scs.SessionManager) h
 			redirectURL = returnURL
 		}
 
-		sse.Redirect(redirectURL) //nolint:errcheck
+		http.Redirect(w, r, redirectURL, http.StatusSeeOther)
 	}
 }

features/auth/handlers_test.go

@@ -0,0 +1,351 @@
+package auth_test
+
+import (
+	"context"
+	"database/sql"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+	"testing"
+
+	"github.com/alexedwards/scs/v2"
+	"github.com/google/uuid"
+
+	"github.com/ryanhamamura/games/auth"
+	"github.com/ryanhamamura/games/db/repository"
+	featauth "github.com/ryanhamamura/games/features/auth"
+	"github.com/ryanhamamura/games/features/lobby"
+	appsessions "github.com/ryanhamamura/games/sessions"
+	"github.com/ryanhamamura/games/testutil"
+)
+
+// sessionCookieName is the default SCS cookie name used in tests.
+const sessionCookieName = "session"
+
+type testSetup struct {
+	db      *sql.DB
+	queries *repository.Queries
+	sm      *scs.SessionManager
+}
+
+func (s *testSetup) ctx() context.Context {
+	return context.Background()
+}
+
+func newTestSetup(t *testing.T) *testSetup {
+	t.Helper()
+	db, queries := testutil.NewTestDB(t)
+	sm := testutil.NewTestSessionManager(t, db)
+	return &testSetup{db: db, queries: queries, sm: sm}
+}
+
+// createTestUser inserts a user into the test database and returns the user ID.
+func createTestUser(t *testing.T, setup *testSetup, username, password string) string {
+	t.Helper()
+	hash, err := auth.HashPassword(password)
+	if err != nil {
+		t.Fatalf("hashing password: %v", err)
+	}
+	id := uuid.New().String()
+	_, err = setup.queries.CreateUser(setup.ctx(), repository.CreateUserParams{
+		ID:           id,
+		Username:     username,
+		PasswordHash: hash,
+	})
+	if err != nil {
+		t.Fatalf("creating test user: %v", err)
+	}
+	return id
+}
+
+// postForm sends a POST request with form-encoded body through the session middleware,
+// forwarding any cookies from a previous response.
+func postForm(handler http.Handler, path string, values url.Values, cookies []*http.Cookie) *httptest.ResponseRecorder {
+	body := strings.NewReader(values.Encode())
+	req := httptest.NewRequest(http.MethodPost, path, body)
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	for _, c := range cookies {
+		req.AddCookie(c)
+	}
+	rec := httptest.NewRecorder()
+	handler.ServeHTTP(rec, req)
+	return rec
+}
+
+// getPage sends a GET request through the session middleware, forwarding cookies.
+func getPage(handler http.Handler, path string, cookies []*http.Cookie) *httptest.ResponseRecorder {
+	req := httptest.NewRequest(http.MethodGet, path, nil)
+	for _, c := range cookies {
+		req.AddCookie(c)
+	}
+	rec := httptest.NewRecorder()
+	handler.ServeHTTP(rec, req)
+	return rec
+}
+
+// extractSessionValue makes a GET request with the given cookies to a test endpoint
+// that reads a session value, verifying the session was persisted correctly.
+func extractSessionValue(t *testing.T, setup *testSetup, cookies []*http.Cookie, key string) string {
+	t.Helper()
+	var value string
+	handler := setup.sm.LoadAndSave(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		value = setup.sm.GetString(r.Context(), key)
+	}))
+	req := httptest.NewRequest(http.MethodGet, "/check-session", nil)
+	for _, c := range cookies {
+		req.AddCookie(c)
+	}
+	rec := httptest.NewRecorder()
+	handler.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("session check returned %d", rec.Code)
+	}
+	return value
+}
+
+func TestHandleLogin_Success(t *testing.T) {
+	setup := newTestSetup(t)
+	createTestUser(t, setup, "alice", "password123")
+
+	handler := setup.sm.LoadAndSave(featauth.HandleLogin(setup.queries, setup.sm))
+	rec := postForm(handler, "/auth/login", url.Values{
+		"username": {"alice"},
+		"password": {"password123"},
+	}, nil)
+
+	if rec.Code != http.StatusSeeOther {
+		t.Errorf("expected status %d, got %d", http.StatusSeeOther, rec.Code)
+	}
+	if loc := rec.Header().Get("Location"); loc != "/" {
+		t.Errorf("expected redirect to /, got %q", loc)
+	}
+
+	// Verify the response sets a session cookie
+	cookies := rec.Result().Cookies()
+	if !hasCookie(cookies, sessionCookieName) {
+		t.Fatal("response did not set a session cookie")
+	}
+
+	// Verify session contains user data by reading it back
+	userID := extractSessionValue(t, setup, cookies, appsessions.KeyUserID)
+	if userID == "" {
+		t.Error("session does not contain user_id after login")
+	}
+	nickname := extractSessionValue(t, setup, cookies, appsessions.KeyNickname)
+	if nickname != "alice" {
+		t.Errorf("expected nickname %q, got %q", "alice", nickname)
+	}
+}
+
+func TestHandleLogin_InvalidPassword(t *testing.T) {
+	setup := newTestSetup(t)
+	createTestUser(t, setup, "alice", "password123")
+
+	handler := setup.sm.LoadAndSave(featauth.HandleLogin(setup.queries, setup.sm))
+	rec := postForm(handler, "/auth/login", url.Values{
+		"username": {"alice"},
+		"password": {"wrongpassword"},
+	}, nil)
+
+	if rec.Code != http.StatusSeeOther {
+		t.Errorf("expected status %d, got %d", http.StatusSeeOther, rec.Code)
+	}
+	loc := rec.Header().Get("Location")
+	if !strings.HasPrefix(loc, "/login?error=") {
+		t.Errorf("expected redirect to /login?error=..., got %q", loc)
+	}
+}
+
+func TestHandleLogin_UnknownUser(t *testing.T) {
+	setup := newTestSetup(t)
+
+	handler := setup.sm.LoadAndSave(featauth.HandleLogin(setup.queries, setup.sm))
+	rec := postForm(handler, "/auth/login", url.Values{
+		"username": {"nonexistent"},
+		"password": {"password123"},
+	}, nil)
+
+	if rec.Code != http.StatusSeeOther {
+		t.Errorf("expected status %d, got %d", http.StatusSeeOther, rec.Code)
+	}
+	loc := rec.Header().Get("Location")
+	if !strings.HasPrefix(loc, "/login?error=") {
+		t.Errorf("expected redirect to /login?error=..., got %q", loc)
+	}
+}
+
+func TestHandleLogin_ReturnURL(t *testing.T) {
+	setup := newTestSetup(t)
+	createTestUser(t, setup, "alice", "password123")
+
+	// First, visit the login page with a return_url to store it in the session
+	loginPageHandler := setup.sm.LoadAndSave(featauth.HandleLoginPage(setup.sm))
+	pageRec := getPage(loginPageHandler, "/login?return_url=/games/abc", nil)
+	cookies := pageRec.Result().Cookies()
+
+	// Now log in with those cookies so the handler can read return_url from session
+	loginHandler := setup.sm.LoadAndSave(featauth.HandleLogin(setup.queries, setup.sm))
+	rec := postForm(loginHandler, "/auth/login", url.Values{
+		"username": {"alice"},
+		"password": {"password123"},
+	}, cookies)
+
+	if rec.Code != http.StatusSeeOther {
+		t.Errorf("expected status %d, got %d", http.StatusSeeOther, rec.Code)
+	}
+	if loc := rec.Header().Get("Location"); loc != "/games/abc" {
+		t.Errorf("expected redirect to /games/abc, got %q", loc)
+	}
+}
+
+func TestHandleRegister_Success(t *testing.T) {
+	setup := newTestSetup(t)
+
+	handler := setup.sm.LoadAndSave(featauth.HandleRegister(setup.queries, setup.sm))
+	rec := postForm(handler, "/auth/register", url.Values{
+		"username": {"newuser"},
+		"password": {"password123"},
+		"confirm":  {"password123"},
+	}, nil)
+
+	if rec.Code != http.StatusSeeOther {
+		t.Errorf("expected status %d, got %d", http.StatusSeeOther, rec.Code)
+	}
+	if loc := rec.Header().Get("Location"); loc != "/" {
+		t.Errorf("expected redirect to /, got %q", loc)
+	}
+
+	cookies := rec.Result().Cookies()
+	if !hasCookie(cookies, sessionCookieName) {
+		t.Fatal("response did not set a session cookie")
+	}
+
+	userID := extractSessionValue(t, setup, cookies, appsessions.KeyUserID)
+	if userID == "" {
+		t.Error("session does not contain user_id after registration")
+	}
+}
+
+func TestHandleRegister_PasswordMismatch(t *testing.T) {
+	setup := newTestSetup(t)
+
+	handler := setup.sm.LoadAndSave(featauth.HandleRegister(setup.queries, setup.sm))
+	rec := postForm(handler, "/auth/register", url.Values{
+		"username": {"newuser"},
+		"password": {"password123"},
+		"confirm":  {"differentpassword"},
+	}, nil)
+
+	if rec.Code != http.StatusSeeOther {
+		t.Errorf("expected status %d, got %d", http.StatusSeeOther, rec.Code)
+	}
+	loc := rec.Header().Get("Location")
+	if !strings.Contains(loc, "Passwords+do+not+match") {
+		t.Errorf("expected error about password mismatch, got %q", loc)
+	}
+}
+
+func TestHandleRegister_InvalidUsername(t *testing.T) {
+	setup := newTestSetup(t)
+
+	handler := setup.sm.LoadAndSave(featauth.HandleRegister(setup.queries, setup.sm))
+	rec := postForm(handler, "/auth/register", url.Values{
+		"username": {"ab"}, // too short
+		"password": {"password123"},
+		"confirm":  {"password123"},
+	}, nil)
+
+	if rec.Code != http.StatusSeeOther {
+		t.Errorf("expected status %d, got %d", http.StatusSeeOther, rec.Code)
+	}
+	loc := rec.Header().Get("Location")
+	if !strings.HasPrefix(loc, "/register?error=") {
+		t.Errorf("expected redirect to /register?error=..., got %q", loc)
+	}
+}
+
+func TestHandleRegister_ShortPassword(t *testing.T) {
+	setup := newTestSetup(t)
+
+	handler := setup.sm.LoadAndSave(featauth.HandleRegister(setup.queries, setup.sm))
+	rec := postForm(handler, "/auth/register", url.Values{
+		"username": {"validuser"},
+		"password": {"short"},
+		"confirm":  {"short"},
+	}, nil)
+
+	if rec.Code != http.StatusSeeOther {
+		t.Errorf("expected status %d, got %d", http.StatusSeeOther, rec.Code)
+	}
+	loc := rec.Header().Get("Location")
+	if !strings.HasPrefix(loc, "/register?error=") {
+		t.Errorf("expected redirect to /register?error=..., got %q", loc)
+	}
+}
+
+func TestHandleRegister_DuplicateUsername(t *testing.T) {
+	setup := newTestSetup(t)
+	createTestUser(t, setup, "taken", "password123")
+
+	handler := setup.sm.LoadAndSave(featauth.HandleRegister(setup.queries, setup.sm))
+	rec := postForm(handler, "/auth/register", url.Values{
+		"username": {"taken"},
+		"password": {"password123"},
+		"confirm":  {"password123"},
+	}, nil)
+
+	if rec.Code != http.StatusSeeOther {
+		t.Errorf("expected status %d, got %d", http.StatusSeeOther, rec.Code)
+	}
+	loc := rec.Header().Get("Location")
+	if !strings.Contains(loc, "Username+already+taken") {
+		t.Errorf("expected error about duplicate username, got %q", loc)
+	}
+}
+
+func TestHandleLogout(t *testing.T) {
+	setup := newTestSetup(t)
+	createTestUser(t, setup, "alice", "password123")
+
+	// Log in first to establish a session
+	loginHandler := setup.sm.LoadAndSave(featauth.HandleLogin(setup.queries, setup.sm))
+	loginRec := postForm(loginHandler, "/auth/login", url.Values{
+		"username": {"alice"},
+		"password": {"password123"},
+	}, nil)
+	cookies := loginRec.Result().Cookies()
+
+	// Verify we're logged in
+	userID := extractSessionValue(t, setup, cookies, appsessions.KeyUserID)
+	if userID == "" {
+		t.Fatal("expected to be logged in before testing logout")
+	}
+
+	// Now log out
+	logoutHandler := setup.sm.LoadAndSave(lobby.HandleLogout(setup.sm))
+	logoutRec := postForm(logoutHandler, "/logout", nil, cookies)
+
+	if logoutRec.Code != http.StatusSeeOther {
+		t.Errorf("expected status %d, got %d", http.StatusSeeOther, logoutRec.Code)
+	}
+	if loc := logoutRec.Header().Get("Location"); loc != "/" {
+		t.Errorf("expected redirect to /, got %q", loc)
+	}
+
+	// Verify session is cleared — use the cookies from the logout response
+	logoutCookies := logoutRec.Result().Cookies()
+	userID = extractSessionValue(t, setup, logoutCookies, appsessions.KeyUserID)
+	if userID != "" {
+		t.Errorf("expected empty user_id after logout, got %q", userID)
+	}
+}
+
+func hasCookie(cookies []*http.Cookie, name string) bool {
+	for _, c := range cookies {
+		if c.Name == name {
+			return true
+		}
+	}
+	return false
+}

features/auth/pages/login.templ

@@ -1,45 +1,39 @@
 package pages
 
-import (
+import "github.com/ryanhamamura/games/features/common/layouts"
-	"github.com/ryanhamamura/c4/features/common/layouts"
-	"github.com/starfederation/datastar-go/datastar"
-)
 
-templ LoginPage() {
+templ LoginPage(errorMsg string) {
 	@layouts.Base("Login") {
-		<main class="max-w-sm mx-auto mt-8 text-center" data-signals="{username: '', password: '', error: ''}">
+		<main class="max-w-sm mx-auto mt-8 text-center">
 			<h1 class="text-3xl font-bold">Login</h1>
 			<p class="mb-4">Sign in to your account</p>
-			<div data-show="$error != ''" class="alert alert-error mb-4" data-text="$error"></div>
+			if errorMsg != "" {
-			<div>
+				<div class="alert alert-error mb-4">{ errorMsg }</div>
+			}
+			<form method="POST" action="/auth/login">
 				<fieldset class="fieldset">
 					<label class="label" for="username">Username</label>
 					<input
 						class="input input-bordered w-full"
 						id="username"
+						name="username"
 						type="text"
 						placeholder="Enter your username"
-					data-bind="username"
+						autofocus
-					data-on:keydown.key_enter={ datastar.PostSSE("/auth/login") }
+					/>
-					autofocus
-				/>
 					<label class="label" for="password">Password</label>
 					<input
 						class="input input-bordered w-full"
 						id="password"
+						name="password"
 						type="password"
 						placeholder="Enter your password"
-						data-bind="password"
-						data-on:keydown.key_enter={ datastar.PostSSE("/auth/login") }
 					/>
 				</fieldset>
-				<button
+				<button type="submit" class="btn btn-primary w-full">
-					class="btn btn-primary w-full"
-					data-on:click={ datastar.PostSSE("/auth/login") }
-				>
 					Login
 				</button>
-			</div>
+			</form>
 			<p>
 				Don't have an account? <a class="link" href="/register">Register</a>
 			</p>

features/auth/pages/register.templ

@@ -1,54 +1,47 @@
 package pages
 
-import (
+import "github.com/ryanhamamura/games/features/common/layouts"
-	"github.com/ryanhamamura/c4/features/common/layouts"
-	"github.com/starfederation/datastar-go/datastar"
-)
 
-templ RegisterPage() {
+templ RegisterPage(errorMsg string) {
 	@layouts.Base("Register") {
-		<main class="max-w-sm mx-auto mt-8 text-center" data-signals="{username: '', password: '', confirm: '', error: ''}">
+		<main class="max-w-sm mx-auto mt-8 text-center">
 			<h1 class="text-3xl font-bold">Register</h1>
 			<p class="mb-4">Create a new account</p>
-			<div data-show="$error != ''" class="alert alert-error mb-4" data-text="$error"></div>
+			if errorMsg != "" {
-			<div>
+				<div class="alert alert-error mb-4">{ errorMsg }</div>
+			}
+			<form method="POST" action="/auth/register">
 				<fieldset class="fieldset">
 					<label class="label" for="username">Username</label>
 					<input
 						class="input input-bordered w-full"
 						id="username"
+						name="username"
 						type="text"
 						placeholder="Choose a username"
-					data-bind="username"
+						autofocus
-					data-on:keydown.key_enter={ datastar.PostSSE("/auth/register") }
+					/>
-					autofocus
-				/>
 					<label class="label" for="password">Password</label>
 					<input
 						class="input input-bordered w-full"
 						id="password"
+						name="password"
 						type="password"
 						placeholder="Choose a password (min 8 chars)"
-					data-bind="password"
+					/>
-					data-on:keydown.key_enter={ datastar.PostSSE("/auth/register") }
-				/>
 					<label class="label" for="confirm">Confirm Password</label>
 					<input
 						class="input input-bordered w-full"
 						id="confirm"
+						name="confirm"
 						type="password"
 						placeholder="Confirm your password"
-						data-bind="confirm"
-						data-on:keydown.key_enter={ datastar.PostSSE("/auth/register") }
 					/>
 				</fieldset>
-				<button
+				<button type="submit" class="btn btn-primary w-full">
-					class="btn btn-primary w-full"
-					data-on:click={ datastar.PostSSE("/auth/register") }
-				>
 					Register
 				</button>
-			</div>
+			</form>
 			<p>
 				Already have an account? <a class="link" href="/login">Login</a>
 			</p>

features/auth/routes.go

@@ -5,11 +5,11 @@ import (
 	"github.com/alexedwards/scs/v2"
 	"github.com/go-chi/chi/v5"
 
-	"github.com/ryanhamamura/c4/db/repository"
+	"github.com/ryanhamamura/games/db/repository"
 )
 
 func SetupRoutes(router chi.Router, queries *repository.Queries, sessions *scs.SessionManager) {
-	router.Get("/login", HandleLoginPage())
+	router.Get("/login", HandleLoginPage(sessions))
 	router.Get("/register", HandleRegisterPage())
 	router.Post("/auth/login", HandleLogin(queries, sessions))
 	router.Post("/auth/register", HandleRegister(queries, sessions))

features/c4game/components/board.templ

@@ -3,11 +3,11 @@ package components
 import (
 	"fmt"
 
-	"github.com/ryanhamamura/c4/game"
+	"github.com/ryanhamamura/games/connect4"
 	"github.com/starfederation/datastar-go/datastar"
 )
 
-templ Board(g *game.Game, myColor int) {
+templ Board(g *connect4.Game, myColor int) {
 	<div id="c4-board" class="board">
 		for col := 0; col < 7; col++ {
 			@column(g, col, myColor)
@@ -15,8 +15,8 @@ templ Board(g *game.Game, myColor int) {
 	</div>
 }
 
-templ column(g *game.Game, colIdx int, myColor int) {
+templ column(g *connect4.Game, colIdx int, myColor int) {
-	if g.Status == game.StatusInProgress && myColor == g.CurrentTurn {
+	if g.Status == connect4.StatusInProgress && myColor == g.CurrentTurn {
 		<div
 			class="column clickable"
 			data-on:click={ datastar.PostSSE("/games/%s/drop?col=%d", g.ID, colIdx) }
@@ -34,14 +34,14 @@ templ column(g *game.Game, colIdx int, myColor int) {
 	}
 }
 
-templ cell(g *game.Game, row int, col int) {
+templ cell(g *connect4.Game, row int, col int) {
 	<div class={ cellClass(g, row, col) }></div>
 }
 
-func cellClass(g *game.Game, row, col int) string {
+func cellClass(g *connect4.Game, row, col int) string {
 	color := g.Board[row][col]
 	activeTurn := 0
-	if g.Status == game.StatusInProgress {
+	if g.Status == connect4.StatusInProgress {
 		activeTurn = g.CurrentTurn
 	}
 

features/c4game/components/status.templ

@@ -1,12 +1,12 @@
 package components
 
 import (
-	"github.com/ryanhamamura/c4/config"
+	"github.com/ryanhamamura/games/config"
-	"github.com/ryanhamamura/c4/game"
+	"github.com/ryanhamamura/games/connect4"
 	"github.com/starfederation/datastar-go/datastar"
 )
 
-templ StatusBanner(g *game.Game, myColor int) {
+templ StatusBanner(g *connect4.Game, myColor int) {
 	<div id="c4-status" class={ statusClass(g, myColor) }>
 		{ statusMessage(g, myColor) }
 		if g.IsFinished() {
@@ -30,7 +30,7 @@ templ StatusBanner(g *game.Game, myColor int) {
 	</div>
 }
 
-templ PlayerInfo(g *game.Game, myColor int) {
+templ PlayerInfo(g *connect4.Game, myColor int) {
 	<div id="c4-players" class="flex gap-8 mb-2">
 		for _, info := range playerInfoPairs(g, myColor) {
 			<div class="flex items-center gap-2">
@@ -61,36 +61,36 @@ script copyToClipboard(url string) {
 	navigator.clipboard.writeText(url)
 }
 
-func statusClass(g *game.Game, myColor int) string {
+func statusClass(g *connect4.Game, myColor int) string {
 	switch g.Status {
-	case game.StatusWaitingForPlayer:
+	case connect4.StatusWaitingForPlayer:
 		return "alert bg-base-200 text-xl font-bold"
-	case game.StatusInProgress:
+	case connect4.StatusInProgress:
 		if g.CurrentTurn == myColor {
 			return "alert alert-success text-xl font-bold"
 		}
 		return "alert bg-base-200 text-xl font-bold"
-	case game.StatusWon:
+	case connect4.StatusWon:
 		if g.Winner != nil && g.Winner.Color == myColor {
 			return "alert alert-success text-xl font-bold"
 		}
 		return "alert alert-error text-xl font-bold"
-	case game.StatusDraw:
+	case connect4.StatusDraw:
 		return "alert alert-warning text-xl font-bold"
 	}
 	return "alert bg-base-200 text-xl font-bold"
 }
 
-func statusMessage(g *game.Game, myColor int) string {
+func statusMessage(g *connect4.Game, myColor int) string {
 	switch g.Status {
-	case game.StatusWaitingForPlayer:
+	case connect4.StatusWaitingForPlayer:
 		return "Waiting for opponent..."
-	case game.StatusInProgress:
+	case connect4.StatusInProgress:
 		if g.CurrentTurn == myColor {
 			return "Your turn!"
 		}
 		return opponentName(g, myColor) + "'s turn"
-	case game.StatusWon:
+	case connect4.StatusWon:
 		if g.Winner != nil && g.Winner.Color == myColor {
 			return "You win!"
 		}
@@ -98,13 +98,13 @@ func statusMessage(g *game.Game, myColor int) string {
 			return g.Winner.Nickname + " wins!"
 		}
 		return "Game over"
-	case game.StatusDraw:
+	case connect4.StatusDraw:
 		return "It's a draw!"
 	}
 	return ""
 }
 
-func opponentName(g *game.Game, myColor int) string {
+func opponentName(g *connect4.Game, myColor int) string {
 	for _, p := range g.Players {
 		if p != nil && p.Color != myColor {
 			return p.Nickname
@@ -118,7 +118,7 @@ type playerInfoData struct {
 	Label      string
 }
 
-func playerInfoPairs(g *game.Game, myColor int) []playerInfoData {
+func playerInfoPairs(g *connect4.Game, myColor int) []playerInfoData {
 	var result []playerInfoData
 
 	var myName, oppName string

features/c4game/handlers.go

@@ -1,47 +1,23 @@
 package c4game
 
 import (
-	"fmt"
 	"net/http"
 	"strconv"
 	"time"
 
 	"github.com/alexedwards/scs/v2"
 	"github.com/go-chi/chi/v5"
-	"github.com/nats-io/nats.go"
 	"github.com/starfederation/datastar-go/datastar"
 
-	"github.com/ryanhamamura/c4/chat"
+	"github.com/ryanhamamura/games/chat"
-	chatcomponents "github.com/ryanhamamura/c4/chat/components"
+	chatcomponents "github.com/ryanhamamura/games/chat/components"
-	"github.com/ryanhamamura/c4/db/repository"
+	"github.com/ryanhamamura/games/connect4"
-	"github.com/ryanhamamura/c4/features/c4game/components"
+	"github.com/ryanhamamura/games/features/c4game/pages"
-	"github.com/ryanhamamura/c4/features/c4game/pages"
+	"github.com/ryanhamamura/games/features/c4game/services"
-	"github.com/ryanhamamura/c4/game"
+	"github.com/ryanhamamura/games/sessions"
-	"github.com/ryanhamamura/c4/sessions"
 )
 
-// c4ChatColors maps player color (1=Red, 2=Yellow) to CSS background colors.
+func HandleGamePage(store *connect4.Store, svc *services.GameService, sm *scs.SessionManager) http.HandlerFunc {
-var c4ChatColors = map[int]string{
-	0: "#4a2a3a", // color 1 stored as slot 0
-	1: "#2a4545", // color 2 stored as slot 1
-}
-
-func c4ChatColor(slot int) string {
-	if c, ok := c4ChatColors[slot]; ok {
-		return c
-	}
-	return "#666"
-}
-
-func c4ChatConfig(gameID string) chatcomponents.Config {
-	return chatcomponents.Config{
-		CSSPrefix: "c4",
-		PostURL:   fmt.Sprintf("/games/%s/chat", gameID),
-		Color:     c4ChatColor,
-	}
-}
-
-func HandleGamePage(store *game.GameStore, sm *scs.SessionManager, queries *repository.Queries) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		gameID := chi.URLParam(r, "id")
 
@@ -57,14 +33,14 @@ func HandleGamePage(store *game.GameStore, sm *scs.SessionManager, queries *repo
 
 		// Auto-join if player has a nickname but isn't in the game yet
 		if nickname != "" && gi.GetPlayerColor(playerID) == 0 {
-			p := &game.Player{
+			p := &connect4.Player{
 				ID:       playerID,
 				Nickname: nickname,
 			}
 			if userID != "" {
 				p.UserID = &userID
 			}
-			gi.Join(&game.PlayerSession{Player: p})
+			gi.Join(&connect4.PlayerSession{Player: p})
 		}
 
 		myColor := gi.GetPlayerColor(playerID)
@@ -85,16 +61,17 @@ func HandleGamePage(store *game.GameStore, sm *scs.SessionManager, queries *repo
 		}
 
 		g := gi.GetGame()
-		msgs := chat.LoadMessages(queries, gameID)
+		room := svc.ChatRoom(gameID)
 
-		if err := pages.GamePage(g, myColor, msgs, c4ChatConfig(gameID)).Render(r.Context(), w); err != nil {
+		if err := pages.GamePage(g, myColor, room.Messages(), svc.ChatConfig(gameID)).Render(r.Context(), w); err != nil {
 			http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
 		}
 	}
 }
 
-func HandleGameEvents(store *game.GameStore, nc *nats.Conn, sm *scs.SessionManager, queries *repository.Queries) http.HandlerFunc {
+func HandleGameEvents(store *connect4.Store, svc *services.GameService, sm *scs.SessionManager) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
+		ctx := r.Context()
 		gameID := chi.URLParam(r, "id")
 
 		gi, exists := store.Get(gameID)
@@ -104,47 +81,74 @@ func HandleGameEvents(store *game.GameStore, nc *nats.Conn, sm *scs.SessionManag
 		}
 
 		playerID := sessions.GetPlayerID(sm, r)
-		myColor := gi.GetPlayerColor(playerID)
 
-		sse := datastar.NewSSE(w, r, datastar.WithCompression(
+		// Subscribe to game state updates BEFORE creating SSE
-			datastar.WithBrotli(datastar.WithBrotliLevel(5)),
+		gameSub, gameCh, err := svc.SubscribeGameUpdates(gameID)
-		))
-
-		chatCfg := c4ChatConfig(gameID)
-		room := chat.NewRoom(nc, "game.chat."+gameID, chat.LoadMessages(queries, gameID))
-
-		// Send initial render
-		sendGameComponents(sse, gi, myColor, room, chatCfg)
-
-		// Subscribe to game state updates
-		gameCh := make(chan *nats.Msg, 64)
-		gameSub, err := nc.ChanSubscribe("game."+gameID, gameCh)
 		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return
 		}
 		defer gameSub.Unsubscribe() //nolint:errcheck
 
-		// Subscribe to chat messages
+		// Subscribe to chat messages BEFORE creating SSE
-		chatCh, chatSub, err := room.Subscribe()
+		chatCfg := svc.ChatConfig(gameID)
-		if err != nil {
+		room := svc.ChatRoom(gameID)
+		chatCh, cleanupChat := room.Subscribe()
+		defer cleanupChat()
+
+		// Setup heartbeat BEFORE creating SSE
+		heartbeat := time.NewTicker(1 * time.Second)
+		defer heartbeat.Stop()
+
+		// NOW create SSE
+		sse := datastar.NewSSE(w, r, datastar.WithCompression(
+			datastar.WithBrotli(datastar.WithBrotliLevel(5)),
+		))
+
+		// Define patch function
+		patchAll := func() error {
+			myColor := gi.GetPlayerColor(playerID)
+			g := gi.GetGame()
+			return sse.PatchElementTempl(pages.GameContent(g, myColor, room.Messages(), chatCfg))
+		}
+
+		// Send initial state
+		if err := patchAll(); err != nil {
 			return
 		}
-		defer chatSub.Unsubscribe() //nolint:errcheck
 
-		ctx := r.Context()
+		// Event loop
 		for {
 			select {
 			case <-ctx.Done():
 				return
+
 			case <-gameCh:
-				myColor = gi.GetPlayerColor(playerID)
+				// Drain rapid-fire notifications
-				sendGameComponents(sse, gi, myColor, room, chatCfg)
+			drainGame:
-			case msg := <-chatCh:
+				for {
-				_, snapshot := room.Receive(msg.Data)
+					select {
-				if snapshot == nil {
+					case <-gameCh:
-					continue
+					default:
+						break drainGame
+					}
 				}
-				if err := sse.PatchElementTempl(chatcomponents.Chat(snapshot, chatCfg), datastar.WithSelectorID("c4-chat")); err != nil {
+				if err := patchAll(); err != nil {
+					return
+				}
+
+			case chatMsg := <-chatCh:
+				if err := sse.PatchElementTempl(
+					chatcomponents.ChatMessage(chatMsg, chatCfg),
+					datastar.WithSelectorID("c4-chat-history"),
+					datastar.WithModeAppend(),
+				); err != nil {
+					return
+				}
+
+			case <-heartbeat.C:
+				// Heartbeat refreshes game state to keep connection alive
+				if err := patchAll(); err != nil {
 					return
 				}
 			}
@@ -152,7 +156,7 @@ func HandleGameEvents(store *game.GameStore, nc *nats.Conn, sm *scs.SessionManag
 	}
 }
 
-func HandleDropPiece(store *game.GameStore, sm *scs.SessionManager) http.HandlerFunc {
+func HandleDropPiece(store *connect4.Store, sm *scs.SessionManager) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		gameID := chi.URLParam(r, "id")
 
@@ -181,7 +185,7 @@ func HandleDropPiece(store *game.GameStore, sm *scs.SessionManager) http.Handler
 	}
 }
 
-func HandleSendChat(store *game.GameStore, nc *nats.Conn, sm *scs.SessionManager, queries *repository.Queries) http.HandlerFunc {
+func HandleSendChat(store *connect4.Store, svc *services.GameService, sm *scs.SessionManager) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		gameID := chi.URLParam(r, "id")
 
@@ -228,9 +232,7 @@ func HandleSendChat(store *game.GameStore, nc *nats.Conn, sm *scs.SessionManager
 			Message:  signals.ChatMsg,
 			Time:     time.Now().UnixMilli(),
 		}
-		chat.SaveMessage(queries, gameID, msg)
+		room := svc.ChatRoom(gameID)
-
-		room := chat.NewRoom(nc, "game.chat."+gameID, nil)
 		room.Send(msg)
 
 		sse := datastar.NewSSE(w, r)
@@ -238,7 +240,7 @@ func HandleSendChat(store *game.GameStore, nc *nats.Conn, sm *scs.SessionManager
 	}
 }
 
-func HandleSetNickname(store *game.GameStore, sm *scs.SessionManager) http.HandlerFunc {
+func HandleSetNickname(store *connect4.Store, sm *scs.SessionManager) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		gameID := chi.URLParam(r, "id")
 
@@ -263,20 +265,20 @@ func HandleSetNickname(store *game.GameStore, sm *scs.SessionManager) http.Handl
 			return
 		}
 
-		sm.Put(r.Context(), "nickname", signals.Nickname)
+		sm.Put(r.Context(), sessions.KeyNickname, signals.Nickname)
 
 		playerID := sessions.GetPlayerID(sm, r)
 		userID := sessions.GetUserID(sm, r)
 
 		if gi.GetPlayerColor(playerID) == 0 {
-			p := &game.Player{
+			p := &connect4.Player{
 				ID:       playerID,
 				Nickname: signals.Nickname,
 			}
 			if userID != "" {
 				p.UserID = &userID
 			}
-			gi.Join(&game.PlayerSession{Player: p})
+			gi.Join(&connect4.PlayerSession{Player: p})
 		}
 
 		sse := datastar.NewSSE(w, r)
@@ -284,7 +286,7 @@ func HandleSetNickname(store *game.GameStore, sm *scs.SessionManager) http.Handl
 	}
 }
 
-func HandleRematch(store *game.GameStore, sm *scs.SessionManager) http.HandlerFunc {
+func HandleRematch(store *connect4.Store, sm *scs.SessionManager) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		gameID := chi.URLParam(r, "id")
 
@@ -302,13 +304,3 @@ func HandleRematch(store *game.GameStore, sm *scs.SessionManager) http.HandlerFu
 		}
 	}
 }
-
-// sendGameComponents patches all game-related SSE components.
-func sendGameComponents(sse *datastar.ServerSentEventGenerator, gi *game.GameInstance, myColor int, room *chat.Room, chatCfg chatcomponents.Config) {
-	g := gi.GetGame()
-
-	sse.PatchElementTempl(components.Board(g, myColor), datastar.WithSelectorID("c4-board"))                 //nolint:errcheck
-	sse.PatchElementTempl(components.StatusBanner(g, myColor), datastar.WithSelectorID("c4-status"))         //nolint:errcheck
-	sse.PatchElementTempl(components.PlayerInfo(g, myColor), datastar.WithSelectorID("c4-players"))          //nolint:errcheck
-	sse.PatchElementTempl(chatcomponents.Chat(room.Messages(), chatCfg), datastar.WithSelectorID("c4-chat")) //nolint:errcheck
-}

features/c4game/pages/game.templ

@@ -1,37 +1,45 @@
 package pages
 
 import (
-	"github.com/ryanhamamura/c4/chat"
+	"fmt"
-	chatcomponents "github.com/ryanhamamura/c4/chat/components"
+
-	"github.com/ryanhamamura/c4/features/c4game/components"
+	"github.com/ryanhamamura/games/chat"
-	sharedcomponents "github.com/ryanhamamura/c4/features/common/components"
+	chatcomponents "github.com/ryanhamamura/games/chat/components"
-	"github.com/ryanhamamura/c4/features/common/layouts"
+	"github.com/ryanhamamura/games/connect4"
-	"github.com/ryanhamamura/c4/game"
+	"github.com/ryanhamamura/games/features/c4game/components"
-	"github.com/starfederation/datastar-go/datastar"
+	sharedcomponents "github.com/ryanhamamura/games/features/common/components"
+	"github.com/ryanhamamura/games/features/common/layouts"
 )
 
-templ GamePage(g *game.Game, myColor int, messages []chat.Message, chatCfg chatcomponents.Config) {
+templ GamePage(g *connect4.Game, myColor int, messages []chat.Message, chatCfg chatcomponents.Config) {
 	@layouts.Base("Connect 4") {
 		<main
 			class="flex flex-col items-center gap-4 p-4"
 			data-signals="{chatMsg: ''}"
-			data-init={ datastar.GetSSE("/games/%s/events", g.ID) }
+			data-init={ fmt.Sprintf("@get('/games/%s/events',{requestCancellation:'disabled'})", g.ID) }
 		>
-			@sharedcomponents.BackToLobby()
+			@GameContent(g, myColor, messages, chatCfg)
-			@sharedcomponents.StealthTitle("text-3xl font-bold")
-			@components.PlayerInfo(g, myColor)
-			@components.StatusBanner(g, myColor)
-			<div class="c4-game-area">
-				@components.Board(g, myColor)
-				@chatcomponents.Chat(messages, chatCfg)
-			</div>
-			if g.Status == game.StatusWaitingForPlayer {
-				@components.InviteLink(g.ID)
-			}
 		</main>
 	}
 }
 
+templ GameContent(g *connect4.Game, myColor int, messages []chat.Message, chatCfg chatcomponents.Config) {
+	<div id="game-content">
+		@sharedcomponents.LiveClock()
+		@sharedcomponents.BackToLobby()
+		@sharedcomponents.StealthTitle("text-3xl font-bold")
+		@components.PlayerInfo(g, myColor)
+		@components.StatusBanner(g, myColor)
+		<div class="c4-game-area">
+			@components.Board(g, myColor)
+			@chatcomponents.Chat(messages, chatCfg)
+		</div>
+		if g.Status == connect4.StatusWaitingForPlayer {
+			@components.InviteLink(g.ID)
+		}
+	</div>
+}
+
 templ JoinPage(gameID string) {
 	@layouts.Base("Connect 4 - Join") {
 		@sharedcomponents.GameJoinPrompt(

features/c4game/routes.go

@@ -4,24 +4,22 @@ package c4game
 import (
 	"github.com/alexedwards/scs/v2"
 	"github.com/go-chi/chi/v5"
-	"github.com/nats-io/nats.go"
 
-	"github.com/ryanhamamura/c4/db/repository"
+	"github.com/ryanhamamura/games/connect4"
-	"github.com/ryanhamamura/c4/game"
+	"github.com/ryanhamamura/games/features/c4game/services"
 )
 
 func SetupRoutes(
 	router chi.Router,
-	store *game.GameStore,
+	store *connect4.Store,
-	nc *nats.Conn,
+	svc *services.GameService,
 	sessions *scs.SessionManager,
-	queries *repository.Queries,
 ) {
 	router.Route("/games/{id}", func(r chi.Router) {
-		r.Get("/", HandleGamePage(store, sessions, queries))
+		r.Get("/", HandleGamePage(store, svc, sessions))
-		r.Get("/events", HandleGameEvents(store, nc, sessions, queries))
+		r.Get("/events", HandleGameEvents(store, svc, sessions))
 		r.Post("/drop", HandleDropPiece(store, sessions))
-		r.Post("/chat", HandleSendChat(store, nc, sessions, queries))
+		r.Post("/chat", HandleSendChat(store, svc, sessions))
 		r.Post("/join", HandleSetNickname(store, sessions))
 		r.Post("/rematch", HandleRematch(store, sessions))
 	})

features/c4game/services/game_service.go

@@ -0,0 +1,70 @@
+// Package services provides the game service layer for Connect 4,
+// handling NATS subscriptions and chat room management.
+package services
+
+import (
+	"fmt"
+
+	"github.com/nats-io/nats.go"
+
+	"github.com/ryanhamamura/games/chat"
+	chatcomponents "github.com/ryanhamamura/games/chat/components"
+	"github.com/ryanhamamura/games/connect4"
+	"github.com/ryanhamamura/games/db/repository"
+)
+
+// c4ChatColors maps player slot (0-indexed) to CSS background colors.
+var c4ChatColors = map[int]string{
+	0: "#4a2a3a", // Red player
+	1: "#2a4545", // Yellow player
+}
+
+func c4ChatColor(slot int) string {
+	if c, ok := c4ChatColors[slot]; ok {
+		return c
+	}
+	return "#666"
+}
+
+// GameService manages NATS subscriptions and chat for Connect 4 games.
+type GameService struct {
+	nc      *nats.Conn
+	queries *repository.Queries
+}
+
+// NewGameService creates a new game service.
+func NewGameService(nc *nats.Conn, queries *repository.Queries) *GameService {
+	return &GameService{
+		nc:      nc,
+		queries: queries,
+	}
+}
+
+// SubscribeGameUpdates returns a NATS subscription and channel for game state updates.
+func (s *GameService) SubscribeGameUpdates(gameID string) (*nats.Subscription, <-chan *nats.Msg, error) {
+	ch := make(chan *nats.Msg, 64)
+	sub, err := s.nc.ChanSubscribe(connect4.GameSubject(gameID), ch)
+	if err != nil {
+		return nil, nil, fmt.Errorf("subscribing to game updates: %w", err)
+	}
+	return sub, ch, nil
+}
+
+// ChatConfig returns the chat configuration for a game.
+func (s *GameService) ChatConfig(gameID string) chatcomponents.Config {
+	return chatcomponents.Config{
+		CSSPrefix: "c4",
+		PostURL:   fmt.Sprintf("/games/%s/chat", gameID),
+		Color:     c4ChatColor,
+	}
+}
+
+// ChatRoom returns a persistent chat room for a game.
+func (s *GameService) ChatRoom(gameID string) *chat.Room {
+	return chat.NewPersistentRoom(s.nc, connect4.ChatSubject(gameID), s.queries, gameID)
+}
+
+// PublishGameUpdate sends a notification that the game state has changed.
+func (s *GameService) PublishGameUpdate(gameID string) error {
+	return s.nc.Publish(connect4.GameSubject(gameID), nil)
+}

features/common/components/shared.templ

@@ -1,6 +1,10 @@
 package components
 
-import "github.com/starfederation/datastar-go/datastar"
+import (
+	"time"
+
+	"github.com/starfederation/datastar-go/datastar"
+)
 
 templ BackToLobby() {
 	<a class="link text-sm opacity-70" href="/">&larr; Back</a>
@@ -28,7 +32,7 @@ templ NicknamePrompt(returnPath string) {
 					type="text"
 					placeholder="Enter your nickname"
 					data-bind="nickname"
-					data-on:keydown.key_enter={ datastar.PostSSE("%s", returnPath) }
+					data-on:keydown={ "evt.key === 'Enter' && " + datastar.PostSSE("%s", returnPath) }
 					required
 					autofocus
 				/>
@@ -44,6 +48,15 @@ templ NicknamePrompt(returnPath string) {
 	</main>
 }
 
+// LiveClock shows the current server time, updated every second via SSE.
+// If the clock stops updating, users know the connection is stale.
+templ LiveClock() {
+	<div class="fixed top-2 right-2 flex items-center gap-1.5 text-xs opacity-60 font-mono">
+		<div style="width: 6px; height: 6px; border-radius: 50%; background-color: #22c55e;"></div>
+		{ time.Now().Format("15:04:05") }
+	</div>
+}
+
 templ GameJoinPrompt(loginURL string, registerURL string, gamePath string) {
 	<main class="max-w-sm mx-auto mt-8 text-center">
 		<h1 class="text-3xl font-bold">Join Game</h1>

features/common/layouts/base.templ

@@ -1,6 +1,10 @@
 package layouts
 
-import "github.com/ryanhamamura/c4/config"
+import (
+	"github.com/ryanhamamura/games/assets"
+	"github.com/ryanhamamura/games/config"
+	"github.com/ryanhamamura/games/version"
+)
 
 templ Base(title string) {
 	<!DOCTYPE html>
@@ -8,14 +12,17 @@ templ Base(title string) {
 		<head>
 			<title>{ title }</title>
 			<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=0"/>
-			<script defer type="module" src="/assets/js/datastar.js"></script>
+			<script defer type="module" src={ assets.StaticPath("js/datastar.js") }></script>
-			<link href="/assets/css/output.css" rel="stylesheet" type="text/css"/>
+			<link href={ assets.StaticPath("css/output.css") } rel="stylesheet" type="text/css"/>
 		</head>
 		<body class="flex flex-col h-screen">
 			if config.Global.Environment == config.Dev {
 				<div data-init="@get('/reload', {retryMaxCount: 1000, retryInterval:20, retryMaxWaitMs:200})"></div>
 			}
 			{ children... }
+			<footer class="fixed bottom-1 right-2 text-xs text-gray-500">
+				{ version.Version }
+			</footer>
 		</body>
 	</html>
 }

features/lobby/components/gamelist.templ

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/ryanhamamura/c4/game"
+	"github.com/ryanhamamura/games/connect4"
 	"github.com/starfederation/datastar-go/datastar"
 )
 
@@ -46,10 +46,10 @@ templ gameListEntry(g GameListItem) {
 }
 
 func statusText(g GameListItem) string {
-	switch game.GameStatus(g.Status) {
+	switch connect4.Status(g.Status) {
-	case game.StatusWaitingForPlayer:
+	case connect4.StatusWaitingForPlayer:
 		return "Waiting for opponent"
-	case game.StatusInProgress:
+	case connect4.StatusInProgress:
 		if g.IsMyTurn {
 			return "Your turn!"
 		}
@@ -59,10 +59,10 @@ func statusText(g GameListItem) string {
 }
 
 func statusClass(g GameListItem) string {
-	switch game.GameStatus(g.Status) {
+	switch connect4.Status(g.Status) {
-	case game.StatusWaitingForPlayer:
+	case connect4.StatusWaitingForPlayer:
 		return "text-sm opacity-60"
-	case game.StatusInProgress:
+	case connect4.StatusInProgress:
 		if g.IsMyTurn {
 			return "text-sm text-success font-bold"
 		}

features/lobby/handlers.go

@@ -7,11 +7,12 @@ import (
 	"strconv"
 	"time"
 
-	"github.com/ryanhamamura/c4/db/repository"
+	"github.com/ryanhamamura/games/connect4"
-	lobbycomponents "github.com/ryanhamamura/c4/features/lobby/components"
+	"github.com/ryanhamamura/games/db/repository"
-	"github.com/ryanhamamura/c4/features/lobby/pages"
+	lobbycomponents "github.com/ryanhamamura/games/features/lobby/components"
-	"github.com/ryanhamamura/c4/game"
+	"github.com/ryanhamamura/games/features/lobby/pages"
-	"github.com/ryanhamamura/c4/snake"
+	appsessions "github.com/ryanhamamura/games/sessions"
+	"github.com/ryanhamamura/games/snake"
 
 	"github.com/alexedwards/scs/v2"
 	"github.com/go-chi/chi/v5"
@@ -21,7 +22,7 @@ import (
 // HandleLobbyPage renders the main lobby page with active games for logged-in users.
 func HandleLobbyPage(queries *repository.Queries, sessions *scs.SessionManager, snakeStore *snake.SnakeStore) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		userID := sessions.GetString(r.Context(), "user_id")
+		userID := sessions.GetString(r.Context(), appsessions.KeyUserID)
 		username := sessions.GetString(r.Context(), "username")
 		isLoggedIn := userID != ""
 
@@ -80,7 +81,7 @@ func HandleLobbyPage(queries *repository.Queries, sessions *scs.SessionManager,
 }
 
 // HandleCreateGame reads the nickname signal, creates a connect4 game, and redirects via SSE.
-func HandleCreateGame(store *game.GameStore, sessions *scs.SessionManager) http.HandlerFunc {
+func HandleCreateGame(store *connect4.Store, sessions *scs.SessionManager) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		type Signals struct {
 			Nickname string `json:"nickname"`
@@ -95,7 +96,7 @@ func HandleCreateGame(store *game.GameStore, sessions *scs.SessionManager) http.
 			return
 		}
 
-		sessions.Put(r.Context(), "nickname", signals.Nickname)
+		sessions.Put(r.Context(), appsessions.KeyNickname, signals.Nickname)
 
 		gi := store.Create()
 		sse := datastar.NewSSE(w, r)
@@ -104,7 +105,7 @@ func HandleCreateGame(store *game.GameStore, sessions *scs.SessionManager) http.
 }
 
 // HandleDeleteGame deletes a connect4 game and redirects to the lobby.
-func HandleDeleteGame(store *game.GameStore, sessions *scs.SessionManager) http.HandlerFunc {
+func HandleDeleteGame(store *connect4.Store, sessions *scs.SessionManager) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		gameID := chi.URLParam(r, "id")
 		if gameID == "" {
@@ -137,7 +138,7 @@ func HandleCreateSnakeGame(snakeStore *snake.SnakeStore, sessions *scs.SessionMa
 			return
 		}
 
-		sessions.Put(r.Context(), "nickname", signals.Nickname)
+		sessions.Put(r.Context(), appsessions.KeyNickname, signals.Nickname)
 
 		mode := snake.ModeMultiplayer
 		if r.URL.Query().Get("mode") == "solo" {
@@ -170,7 +171,6 @@ func HandleLogout(sessions *scs.SessionManager) http.HandlerFunc {
 			return
 		}
 
-		sse := datastar.NewSSE(w, r)
+		http.Redirect(w, r, "/", http.StatusSeeOther)
-		sse.ExecuteScript("window.location.href='/'") //nolint:errcheck
 	}
 }

features/lobby/pages/lobby.templ

@@ -3,10 +3,10 @@ package pages
 import (
 	"fmt"
 
-	"github.com/ryanhamamura/c4/features/common/components"
+	"github.com/ryanhamamura/games/features/common/components"
-	"github.com/ryanhamamura/c4/features/common/layouts"
+	"github.com/ryanhamamura/games/features/common/layouts"
-	lobbycomponents "github.com/ryanhamamura/c4/features/lobby/components"
+	lobbycomponents "github.com/ryanhamamura/games/features/lobby/components"
-	"github.com/ryanhamamura/c4/snake"
+	"github.com/ryanhamamura/games/snake"
 	"github.com/starfederation/datastar-go/datastar"
 )
 
@@ -20,13 +20,11 @@ templ LobbyPage(data LobbyData) {
 			if data.IsLoggedIn {
 				<div class="flex justify-center items-center gap-4 mb-4 p-2 bg-base-200 rounded-lg">
 					<span>Logged in as <strong>{ data.Username }</strong></span>
-					<button
+					<form method="POST" action="/logout" class="inline">
-						type="button"
+						<button type="submit" class="btn btn-ghost btn-sm">
-						class="btn btn-ghost btn-sm"
+							Logout
-						data-on:click={ datastar.PostSSE("/logout") }
+						</button>
-					>
+					</form>
-						Logout
-					</button>
 				</div>
 			} else {
 				<div class="alert text-sm mb-4">
@@ -73,7 +71,7 @@ templ LobbyPage(data LobbyData) {
 							placeholder="Enter your nickname"
 							data-bind="nickname"
 							required
-							data-on:keydown.enter={ datastar.PostSSE("/games") }
+							data-on:keydown={ "evt.key === 'Enter' && " + datastar.PostSSE("/games") }
 						/>
 					</fieldset>
 					<button

features/lobby/pages/types.go

@@ -1,6 +1,6 @@
 package pages
 
-import "github.com/ryanhamamura/c4/features/lobby/components"
+import "github.com/ryanhamamura/games/features/lobby/components"
 
 // SnakeGameListItem represents a joinable snake game in the lobby.
 type SnakeGameListItem struct {

features/lobby/routes.go

@@ -2,9 +2,9 @@
 package lobby
 
 import (
-	"github.com/ryanhamamura/c4/db/repository"
+	"github.com/ryanhamamura/games/connect4"
-	"github.com/ryanhamamura/c4/game"
+	"github.com/ryanhamamura/games/db/repository"
-	"github.com/ryanhamamura/c4/snake"
+	"github.com/ryanhamamura/games/snake"
 
 	"github.com/alexedwards/scs/v2"
 	"github.com/go-chi/chi/v5"
@@ -14,7 +14,7 @@ func SetupRoutes(
 	router chi.Router,
 	queries *repository.Queries,
 	sessions *scs.SessionManager,
-	store *game.GameStore,
+	store *connect4.Store,
 	snakeStore *snake.SnakeStore,
 ) {
 	router.Get("/", HandleLobbyPage(queries, sessions, snakeStore))

features/snakegame/components/board.templ

@@ -3,7 +3,7 @@ package components
 import (
 	"fmt"
 
-	"github.com/ryanhamamura/c4/snake"
+	"github.com/ryanhamamura/games/snake"
 )
 
 func cellSizeForGrid(width, height int) int {

features/snakegame/components/status.templ

@@ -5,8 +5,8 @@ import (
 	"math"
 	"time"
 
-	"github.com/ryanhamamura/c4/config"
+	"github.com/ryanhamamura/games/config"
-	"github.com/ryanhamamura/c4/snake"
+	"github.com/ryanhamamura/games/snake"
 	"github.com/starfederation/datastar-go/datastar"
 )
 

features/snakegame/handlers.go

@@ -1,40 +1,24 @@
 package snakegame
 
 import (
-	"fmt"
+	"errors"
 	"net/http"
 	"strconv"
+	"time"
 
 	"github.com/alexedwards/scs/v2"
 	"github.com/go-chi/chi/v5"
-	"github.com/nats-io/nats.go"
 	"github.com/starfederation/datastar-go/datastar"
 
-	"github.com/ryanhamamura/c4/chat"
+	"github.com/ryanhamamura/games/chat"
-	chatcomponents "github.com/ryanhamamura/c4/chat/components"
+	chatcomponents "github.com/ryanhamamura/games/chat/components"
-	"github.com/ryanhamamura/c4/features/snakegame/components"
+	"github.com/ryanhamamura/games/features/snakegame/pages"
-	"github.com/ryanhamamura/c4/features/snakegame/pages"
+	"github.com/ryanhamamura/games/features/snakegame/services"
-	"github.com/ryanhamamura/c4/sessions"
+	"github.com/ryanhamamura/games/sessions"
-	"github.com/ryanhamamura/c4/snake"
+	"github.com/ryanhamamura/games/snake"
 )
 
-func snakeChatColor(slot int) string {
+func HandleSnakePage(snakeStore *snake.SnakeStore, svc *services.GameService, sm *scs.SessionManager) http.HandlerFunc {
-	if slot >= 0 && slot < len(snake.SnakeColors) {
-		return snake.SnakeColors[slot]
-	}
-	return "#666"
-}
-
-func snakeChatConfig(gameID string) chatcomponents.Config {
-	return chatcomponents.Config{
-		CSSPrefix:          "snake",
-		PostURL:            fmt.Sprintf("/snake/%s/chat", gameID),
-		Color:              snakeChatColor,
-		StopKeyPropagation: true,
-	}
-}
-
-func HandleSnakePage(snakeStore *snake.SnakeStore, sm *scs.SessionManager) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		gameID := chi.URLParam(r, "id")
 		si, ok := snakeStore.Get(gameID)
@@ -76,13 +60,14 @@ func HandleSnakePage(snakeStore *snake.SnakeStore, sm *scs.SessionManager) http.
 		}
 
 		sg := si.GetGame()
-		if err := pages.GamePage(sg, mySlot, nil, snakeChatConfig(gameID), gameID).Render(r.Context(), w); err != nil {
+		chatCfg := svc.ChatConfig(gameID)
+		if err := pages.GamePage(sg, mySlot, nil, chatCfg, gameID).Render(r.Context(), w); err != nil {
 			http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
 		}
 	}
 }
 
-func HandleSnakeEvents(snakeStore *snake.SnakeStore, nc *nats.Conn, sm *scs.SessionManager) http.HandlerFunc {
+func HandleSnakeEvents(snakeStore *snake.SnakeStore, svc *services.GameService, sm *scs.SessionManager) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		gameID := chi.URLParam(r, "id")
 		si, ok := snakeStore.Get(gameID)
@@ -94,44 +79,59 @@ func HandleSnakeEvents(snakeStore *snake.SnakeStore, nc *nats.Conn, sm *scs.Sess
 		playerID := sessions.GetPlayerID(sm, r)
 		mySlot := si.GetPlayerSlot(playerID)
 
-		sse := datastar.NewSSE(w, r, datastar.WithCompression(
+		// Subscribe to game updates BEFORE creating SSE (following portigo pattern)
-			datastar.WithBrotli(datastar.WithBrotliLevel(5)),
+		gameSub, gameCh, err := svc.SubscribeGameUpdates(gameID)
-		))
-
-		chatCfg := snakeChatConfig(gameID)
-
-		// Send initial render
-		sg := si.GetGame()
-		sse.PatchElementTempl(components.Board(sg))                        //nolint:errcheck
-		sse.PatchElementTempl(components.StatusBanner(sg, mySlot, gameID)) //nolint:errcheck
-		sse.PatchElementTempl(components.PlayerList(sg, mySlot))           //nolint:errcheck
-		if sg.Mode == snake.ModeMultiplayer {
-			sse.PatchElementTempl(chatcomponents.Chat(nil, chatCfg)) //nolint:errcheck
-			if sg.Status == snake.StatusWaitingForPlayers || sg.Status == snake.StatusCountdown {
-				sse.PatchElementTempl(components.InviteLink(gameID)) //nolint:errcheck
-			}
-		}
-
-		// Subscribe to game updates via NATS
-		gameCh := make(chan *nats.Msg, 64)
-		gameSub, err := nc.ChanSubscribe("snake."+gameID, gameCh)
 		if err != nil {
+			http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
 			return
 		}
 		defer gameSub.Unsubscribe() //nolint:errcheck
 
-		// Chat subscription (multiplayer only)
+		sse := datastar.NewSSE(w, r, datastar.WithCompression(
-		var chatCh chan *nats.Msg
+			datastar.WithBrotli(datastar.WithBrotliLevel(5)),
-		var chatSub *nats.Subscription
+		))
-		var room *chat.Room
 
+		chatCfg := svc.ChatConfig(gameID)
+
+		// Chat room (multiplayer only)
+		var room *chat.Room
+		sg := si.GetGame()
 		if sg.Mode == snake.ModeMultiplayer {
-			room = chat.NewRoom(nc, "snake.chat."+gameID, nil)
+			room = svc.ChatRoom(gameID)
-			chatCh, chatSub, err = room.Subscribe()
+		}
-			if err != nil {
+
-				return
+		chatMessages := func() []chat.Message {
+			if room == nil {
+				return nil
 			}
-			defer chatSub.Unsubscribe() //nolint:errcheck
+			return room.Messages()
+		}
+
+		patchAll := func() error {
+			si, ok = snakeStore.Get(gameID)
+			if !ok {
+				return errors.New("game not found")
+			}
+			mySlot = si.GetPlayerSlot(playerID)
+			sg = si.GetGame()
+			return sse.PatchElementTempl(pages.GameContent(sg, mySlot, chatMessages(), chatCfg, gameID))
+		}
+
+		// Send initial render
+		if err := patchAll(); err != nil {
+			return
+		}
+
+		heartbeat := time.NewTicker(1 * time.Second)
+		defer heartbeat.Stop()
+
+		// Chat subscription (multiplayer only)
+		var chatCh <-chan chat.Message
+		var cleanupChat func()
+
+		if room != nil {
+			chatCh, cleanupChat = room.Subscribe()
+			defer cleanupChat()
 		}
 
 		ctx := r.Context()
@@ -140,6 +140,12 @@ func HandleSnakeEvents(snakeStore *snake.SnakeStore, nc *nats.Conn, sm *scs.Sess
 			case <-ctx.Done():
 				return
 
+			case <-heartbeat.C:
+				// Heartbeat refreshes game state to keep connection alive
+				if err := patchAll(); err != nil {
+					return
+				}
+
 			case <-gameCh:
 				// Drain backed-up game updates
 				for {
@@ -150,31 +156,20 @@ func HandleSnakeEvents(snakeStore *snake.SnakeStore, nc *nats.Conn, sm *scs.Sess
 					}
 				}
 			drained:
-				si, ok = snakeStore.Get(gameID)
+				if err := patchAll(); err != nil {
-				if !ok {
-					return
-				}
-				mySlot = si.GetPlayerSlot(playerID)
-				sg = si.GetGame()
-				if err := sse.PatchElementTempl(components.Board(sg)); err != nil {
-					return
-				}
-				if err := sse.PatchElementTempl(components.StatusBanner(sg, mySlot, gameID)); err != nil {
-					return
-				}
-				if err := sse.PatchElementTempl(components.PlayerList(sg, mySlot)); err != nil {
 					return
 				}
 
-			case msg := <-chatCh:
+			case chatMsg, ok := <-chatCh:
-				if msg == nil {
+				if !ok {
 					continue
 				}
-				_, snapshot := room.Receive(msg.Data)
+				err := sse.PatchElementTempl(
-				if snapshot == nil {
+					chatcomponents.ChatMessage(chatMsg, chatCfg),
-					continue
+					datastar.WithSelectorID("snake-chat-history"),
-				}
+					datastar.WithModeAppend(),
-				if err := sse.PatchElementTempl(chatcomponents.Chat(snapshot, chatCfg)); err != nil {
+				)
+				if err != nil {
 					return
 				}
 			}
@@ -214,7 +209,7 @@ type chatSignals struct {
 	ChatMsg string `json:"chatMsg"`
 }
 
-func HandleSendChat(snakeStore *snake.SnakeStore, nc *nats.Conn, sm *scs.SessionManager) http.HandlerFunc {
+func HandleSendChat(snakeStore *snake.SnakeStore, svc *services.GameService, sm *scs.SessionManager) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		gameID := chi.URLParam(r, "id")
 		si, ok := snakeStore.Get(gameID)
@@ -247,7 +242,7 @@ func HandleSendChat(snakeStore *snake.SnakeStore, nc *nats.Conn, sm *scs.Session
 			Message:  signals.ChatMsg,
 		}
 
-		room := chat.NewRoom(nc, "snake.chat."+gameID, nil)
+		room := svc.ChatRoom(gameID)
 		room.Send(msg)
 
 		sse := datastar.NewSSE(w, r)
@@ -278,7 +273,7 @@ func HandleSetNickname(snakeStore *snake.SnakeStore, sm *scs.SessionManager) htt
 			return
 		}
 
-		sm.Put(r.Context(), "nickname", signals.Nickname)
+		sm.Put(r.Context(), sessions.KeyNickname, signals.Nickname)
 
 		playerID := sessions.GetPlayerID(sm, r)
 		userID := sessions.GetUserID(sm, r)

features/snakegame/pages/game.templ

@@ -3,12 +3,12 @@ package pages
 import (
 	"fmt"
 
-	"github.com/ryanhamamura/c4/chat"
+	"github.com/ryanhamamura/games/chat"
-	chatcomponents "github.com/ryanhamamura/c4/chat/components"
+	chatcomponents "github.com/ryanhamamura/games/chat/components"
-	"github.com/ryanhamamura/c4/features/common/components"
+	"github.com/ryanhamamura/games/features/common/components"
-	"github.com/ryanhamamura/c4/features/common/layouts"
+	"github.com/ryanhamamura/games/features/common/layouts"
-	snakecomponents "github.com/ryanhamamura/c4/features/snakegame/components"
+	snakecomponents "github.com/ryanhamamura/games/features/snakegame/components"
-	"github.com/ryanhamamura/c4/snake"
+	"github.com/ryanhamamura/games/snake"
 	"github.com/starfederation/datastar-go/datastar"
 )
 
@@ -33,33 +33,40 @@ templ GamePage(sg *snake.SnakeGame, mySlot int, messages []chat.Message, chatCfg
 		<main
 			class="snake-wrapper flex flex-col items-center gap-4 p-4"
 			data-signals={ `{"chatMsg":""}` }
-			data-init={ datastar.GetSSE("/snake/%s/events", gameID) }
+			data-init={ fmt.Sprintf("@get('/snake/%s/events',{requestCancellation:'disabled'})", gameID) }
-			data-on:keydown.throttle_100ms={ keydownScript(gameID) }
+			data-on:keydown__throttle.100ms={ keydownScript(gameID) }
 			tabindex="0"
 		>
-			@components.BackToLobby()
+			@GameContent(sg, mySlot, messages, chatCfg, gameID)
-			<h1 class="text-3xl font-bold">~~~~</h1>
-			@snakecomponents.PlayerList(sg, mySlot)
-			@snakecomponents.StatusBanner(sg, mySlot, gameID)
-			if sg.Status == snake.StatusInProgress || sg.Status == snake.StatusFinished {
-				if sg.Mode == snake.ModeMultiplayer {
-					<div class="snake-game-area">
-						@snakecomponents.Board(sg)
-						@chatcomponents.Chat(messages, chatCfg)
-					</div>
-				} else {
-					@snakecomponents.Board(sg)
-				}
-			} else if sg.Mode == snake.ModeMultiplayer {
-				@chatcomponents.Chat(messages, chatCfg)
-			}
-			if sg.Mode == snake.ModeMultiplayer && (sg.Status == snake.StatusWaitingForPlayers || sg.Status == snake.StatusCountdown) {
-				@snakecomponents.InviteLink(gameID)
-			}
 		</main>
 	}
 }
 
+templ GameContent(sg *snake.SnakeGame, mySlot int, messages []chat.Message, chatCfg chatcomponents.Config, gameID string) {
+	<div id="game-content">
+		@components.LiveClock()
+		@components.BackToLobby()
+		<h1 class="text-3xl font-bold">~~~~</h1>
+		@snakecomponents.PlayerList(sg, mySlot)
+		@snakecomponents.StatusBanner(sg, mySlot, gameID)
+		if sg.Status == snake.StatusInProgress || sg.Status == snake.StatusFinished {
+			if sg.Mode == snake.ModeMultiplayer {
+				<div class="snake-game-area">
+					@snakecomponents.Board(sg)
+					@chatcomponents.Chat(messages, chatCfg)
+				</div>
+			} else {
+				@snakecomponents.Board(sg)
+			}
+		} else if sg.Mode == snake.ModeMultiplayer {
+			@chatcomponents.Chat(messages, chatCfg)
+		}
+		if sg.Mode == snake.ModeMultiplayer && (sg.Status == snake.StatusWaitingForPlayers || sg.Status == snake.StatusCountdown) {
+			@snakecomponents.InviteLink(gameID)
+		}
+	</div>
+}
+
 templ JoinPage(gameID string) {
 	@layouts.Base("Snake - Join") {
 		@components.GameJoinPrompt(

features/snakegame/routes.go

@@ -4,17 +4,17 @@ package snakegame
 import (
 	"github.com/alexedwards/scs/v2"
 	"github.com/go-chi/chi/v5"
-	"github.com/nats-io/nats.go"
 
-	"github.com/ryanhamamura/c4/snake"
+	"github.com/ryanhamamura/games/features/snakegame/services"
+	"github.com/ryanhamamura/games/snake"
 )
 
-func SetupRoutes(router chi.Router, snakeStore *snake.SnakeStore, nc *nats.Conn, sessions *scs.SessionManager) {
+func SetupRoutes(router chi.Router, snakeStore *snake.SnakeStore, svc *services.GameService, sessions *scs.SessionManager) {
 	router.Route("/snake/{id}", func(r chi.Router) {
-		r.Get("/", HandleSnakePage(snakeStore, sessions))
+		r.Get("/", HandleSnakePage(snakeStore, svc, sessions))
-		r.Get("/events", HandleSnakeEvents(snakeStore, nc, sessions))
+		r.Get("/events", HandleSnakeEvents(snakeStore, svc, sessions))
 		r.Post("/dir", HandleSetDirection(snakeStore, sessions))
-		r.Post("/chat", HandleSendChat(snakeStore, nc, sessions))
+		r.Post("/chat", HandleSendChat(snakeStore, svc, sessions))
 		r.Post("/join", HandleSetNickname(snakeStore, sessions))
 		r.Post("/rematch", HandleRematch(snakeStore, sessions))
 	})

features/snakegame/services/game_service.go

@@ -0,0 +1,62 @@
+// Package services provides the game service layer for Snake,
+// handling NATS subscriptions and chat room management.
+package services
+
+import (
+	"fmt"
+
+	"github.com/nats-io/nats.go"
+
+	"github.com/ryanhamamura/games/chat"
+	chatcomponents "github.com/ryanhamamura/games/chat/components"
+	"github.com/ryanhamamura/games/snake"
+)
+
+func snakeChatColor(slot int) string {
+	if slot >= 0 && slot < len(snake.SnakeColors) {
+		return snake.SnakeColors[slot]
+	}
+	return "#666"
+}
+
+// GameService manages NATS subscriptions and chat for Snake games.
+type GameService struct {
+	nc *nats.Conn
+}
+
+// NewGameService creates a new game service.
+func NewGameService(nc *nats.Conn) *GameService {
+	return &GameService{
+		nc: nc,
+	}
+}
+
+// SubscribeGameUpdates returns a NATS subscription and channel for game state updates.
+func (s *GameService) SubscribeGameUpdates(gameID string) (*nats.Subscription, <-chan *nats.Msg, error) {
+	ch := make(chan *nats.Msg, 64)
+	sub, err := s.nc.ChanSubscribe(snake.GameSubject(gameID), ch)
+	if err != nil {
+		return nil, nil, fmt.Errorf("subscribing to game updates: %w", err)
+	}
+	return sub, ch, nil
+}
+
+// ChatConfig returns the chat configuration for a game.
+func (s *GameService) ChatConfig(gameID string) chatcomponents.Config {
+	return chatcomponents.Config{
+		CSSPrefix:          "snake",
+		PostURL:            fmt.Sprintf("/snake/%s/chat", gameID),
+		Color:              snakeChatColor,
+		StopKeyPropagation: true,
+	}
+}
+
+// ChatRoom returns a chat room for a game (ephemeral, not persisted).
+func (s *GameService) ChatRoom(gameID string) *chat.Room {
+	return chat.NewRoom(s.nc, snake.ChatSubject(gameID))
+}
+
+// PublishGameUpdate sends a notification that the game state has changed.
+func (s *GameService) PublishGameUpdate(gameID string) error {
+	return s.nc.Publish(snake.GameSubject(gameID), nil)
+}

go.mod

@@ -1,4 +1,4 @@
-module github.com/ryanhamamura/c4
+module github.com/ryanhamamura/games
 
 go 1.25.4
 
@@ -68,6 +68,7 @@ require (
 	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.12 // indirect
 	github.com/aws/aws-sdk-go-v2/service/sts v1.41.5 // indirect
 	github.com/aws/smithy-go v1.24.0 // indirect
+	github.com/benbjohnson/hashfs v0.2.2 // indirect
 	github.com/bep/godartsass/v2 v2.5.0 // indirect
 	github.com/bep/golibsass v1.2.0 // indirect
 	github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d // indirect
@@ -170,6 +171,9 @@ require (
 	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/riza-io/grpc-go v0.2.0 // indirect
 	github.com/sajari/fuzzy v1.0.0 // indirect
+	github.com/samber/lo v1.52.0 // indirect
+	github.com/samber/slog-common v0.20.0 // indirect
+	github.com/samber/slog-zerolog/v2 v2.9.1 // indirect
 	github.com/segmentio/asm v1.2.1 // indirect
 	github.com/sethvargo/go-retry v0.3.0 // indirect
 	github.com/shopspring/decimal v1.4.0 // indirect

go.sum

@@ -136,6 +136,8 @@ github.com/aymanbagabas/go-udiff v0.3.1/go.mod h1:G0fsKmG+P6ylD0r6N/KgQD/nWzgfnl
 github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
 github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
 github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
+github.com/benbjohnson/hashfs v0.2.2 h1:vFZtksphM5LcnMRFctj49jCUkCc7wp3NP6INyfjkse4=
+github.com/benbjohnson/hashfs v0.2.2/go.mod h1:7OMXaMVo1YkfiIPxKrl7OXkUTUgWjmsAKyR+E6xDIRM=
 github.com/bep/clocks v0.5.0 h1:hhvKVGLPQWRVsBP/UB7ErrHYIO42gINVbvqxvYTPVps=
 github.com/bep/clocks v0.5.0/go.mod h1:SUq3q+OOq41y2lRQqH5fsOoxN8GbxSiT6jvoVVLCVhU=
 github.com/bep/debounce v1.2.1 h1:v67fRdBA9UQu2NhLFXrSg0Brw7CexQekrBwDMM8bzeY=
@@ -565,6 +567,12 @@ github.com/rs/zerolog v1.34.0/go.mod h1:bJsvje4Z08ROH4Nhs5iH600c3IkWhwp44iRc54W6
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/sajari/fuzzy v1.0.0 h1:+FmwVvJErsd0d0hAPlj4CxqxUtQY/fOoY0DwX4ykpRY=
 github.com/sajari/fuzzy v1.0.0/go.mod h1:OjYR6KxoWOe9+dOlXeiCJd4dIbED4Oo8wpS89o0pwOo=
+github.com/samber/lo v1.52.0 h1:Rvi+3BFHES3A8meP33VPAxiBZX/Aws5RxrschYGjomw=
+github.com/samber/lo v1.52.0/go.mod h1:4+MXEGsJzbKGaUEQFKBq2xtfuznW9oz/WrgyzMzRoM0=
+github.com/samber/slog-common v0.20.0 h1:WaLnm/aCvBJSk5nR5aXZTFBaV0B47A+AEaEOiZDeUnc=
+github.com/samber/slog-common v0.20.0/go.mod h1:+Ozat1jgnnE59UAlmNX1IF3IByHsODnnwf9jUcBZ+m8=
+github.com/samber/slog-zerolog/v2 v2.9.1 h1:RMOq8XqzfuGx1X0TEIlS9OXbbFmqLY2/wJppghz66YY=
+github.com/samber/slog-zerolog/v2 v2.9.1/go.mod h1:DQYYve14WgCRN/XnKeHl4266jXK0DgYkYXkfZ4Fp98k=
 github.com/sebdah/goldie/v2 v2.8.0 h1:dZb9wR8q5++oplmEiJT+U/5KyotVD+HNGCAc5gNr8rc=
 github.com/sebdah/goldie/v2 v2.8.0/go.mod h1:oZ9fp0+se1eapSRjfYbsV/0Hqhbuu3bJVvKI/NNtssI=
 github.com/segmentio/asm v1.2.1 h1:DTNbBqs57ioxAD4PrArqftgypG4/qNpXoJx8TVXxPR0=

logging/log.go

@@ -6,7 +6,7 @@ import (
 	stdlog "log"
 	"os"
 
-	"github.com/ryanhamamura/c4/config"
+	"github.com/ryanhamamura/games/config"
 
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"

logging/middleware.go

@@ -5,10 +5,11 @@ import (
 	"net/http"
 	"time"
 
-	"github.com/ryanhamamura/c4/config"
+	"github.com/go-chi/chi/v5/middleware"
-
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
+
+	"github.com/ryanhamamura/games/config"
 )
 
 const (
@@ -64,25 +65,15 @@ func colorLatency(d time.Duration, useColor bool) string {
 	}
 }
 
-type responseWriter struct {
-	http.ResponseWriter
-	status int
-}
-
-func (rw *responseWriter) WriteHeader(code int) {
-	rw.status = code
-	rw.ResponseWriter.WriteHeader(code)
-}
-
 func RequestLogger(logger *zerolog.Logger, env config.Environment) func(http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			start := time.Now()
-			rw := &responseWriter{ResponseWriter: w}
+			ww := middleware.NewWrapResponseWriter(w, r.ProtoMajor)
 
-			next.ServeHTTP(rw, r)
+			next.ServeHTTP(ww, r)
 
-			status := rw.status
+			status := ww.Status()
 			if status == 0 {
 				status = http.StatusOK
 			}

main.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"context"
-	"embed"
 	"fmt"
 	"log/slog"
 	"net"
@@ -11,31 +10,35 @@ import (
 	"syscall"
 	"time"
 
-	"github.com/ryanhamamura/c4/config"
-	"github.com/ryanhamamura/c4/db"
-	"github.com/ryanhamamura/c4/db/repository"
-	"github.com/ryanhamamura/c4/game"
-	"github.com/ryanhamamura/c4/logging"
-	appnats "github.com/ryanhamamura/c4/nats"
-	"github.com/ryanhamamura/c4/router"
-	"github.com/ryanhamamura/c4/sessions"
-	"github.com/ryanhamamura/c4/snake"
-
 	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/chi/v5/middleware"
 	"github.com/rs/zerolog/log"
+	slogzerolog "github.com/samber/slog-zerolog/v2"
 	"golang.org/x/sync/errgroup"
-)
 
-//go:embed assets
+	"github.com/ryanhamamura/games/config"
-var assets embed.FS
+	"github.com/ryanhamamura/games/connect4"
+	"github.com/ryanhamamura/games/db"
+	"github.com/ryanhamamura/games/db/repository"
+	"github.com/ryanhamamura/games/logging"
+	appnats "github.com/ryanhamamura/games/nats"
+	"github.com/ryanhamamura/games/router"
+	"github.com/ryanhamamura/games/sessions"
+	"github.com/ryanhamamura/games/snake"
+	"github.com/ryanhamamura/games/version"
+)
 
 func main() {
 	ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
 	defer cancel()
 
 	cfg := config.Global
-	logging.SetupLogger(cfg.Environment, cfg.LogLevel)
+	zerologLogger := logging.SetupLogger(cfg.Environment, cfg.LogLevel)
+	slog.SetDefault(slog.New(slogzerolog.Option{
+		Level:       slogzerolog.ZeroLogLeveler{Logger: zerologLogger},
+		Logger:      zerologLogger,
+		NoTimestamp: true,
+	}.NewZerologHandler()))
 
 	if err := run(ctx); err != nil && err != http.ErrServerClosed {
 		log.Fatal().Err(err).Msg("server error")
@@ -45,7 +48,7 @@ func main() {
 func run(ctx context.Context) error {
 	cfg := config.Global
 	addr := fmt.Sprintf("%s:%s", cfg.Host, cfg.Port)
-	slog.Info("server starting", "addr", addr)
+	slog.Info("server starting", "addr", addr, "version", version.Version, "commit", version.Commit)
 	defer slog.Info("server shutdown complete")
 
 	eg, egctx := errgroup.WithContext(ctx)
@@ -71,14 +74,14 @@ func run(ctx context.Context) error {
 	defer cleanupNATS()
 
 	// Game stores
-	store := game.NewGameStore(queries)
+	store := connect4.NewStore(queries)
 	store.SetNotifyFunc(func(gameID string) {
-		nc.Publish("game."+gameID, nil) //nolint:errcheck // best-effort notification
+		nc.Publish(connect4.GameSubject(gameID), nil) //nolint:errcheck // best-effort notification
 	})
 
 	snakeStore := snake.NewSnakeStore(queries)
 	snakeStore.SetNotifyFunc(func(gameID string) {
-		nc.Publish("snake."+gameID, nil) //nolint:errcheck // best-effort notification
+		nc.Publish(snake.GameSubject(gameID), nil) //nolint:errcheck // best-effort notification
 	})
 
 	// Router
@@ -90,7 +93,7 @@ func run(ctx context.Context) error {
 		sessionManager.LoadAndSave,
 	)
 
-	router.SetupRoutes(r, queries, sessionManager, nc, store, snakeStore, assets)
+	router.SetupRoutes(r, queries, sessionManager, nc, store, snakeStore)
 
 	// HTTP server
 	srv := &http.Server{
@@ -100,6 +103,10 @@ func run(ctx context.Context) error {
 		BaseContext: func(l net.Listener) context.Context {
 			return egctx
 		},
+		ErrorLog: slog.NewLogLogger(
+			slog.Default().Handler(),
+			slog.LevelError,
+		),
 	}
 
 	eg.Go(func() error {

router/router.go

@@ -2,24 +2,25 @@
 package router
 
 import (
-	"embed"
-	"io/fs"
 	"net/http"
 	"sync"
 
-	"github.com/ryanhamamura/c4/config"
-	"github.com/ryanhamamura/c4/db/repository"
-	"github.com/ryanhamamura/c4/features/auth"
-	"github.com/ryanhamamura/c4/features/c4game"
-	"github.com/ryanhamamura/c4/features/lobby"
-	"github.com/ryanhamamura/c4/features/snakegame"
-	"github.com/ryanhamamura/c4/game"
-	"github.com/ryanhamamura/c4/snake"
-
 	"github.com/alexedwards/scs/v2"
 	"github.com/go-chi/chi/v5"
 	"github.com/nats-io/nats.go"
 	"github.com/starfederation/datastar-go/datastar"
+
+	"github.com/ryanhamamura/games/assets"
+	"github.com/ryanhamamura/games/config"
+	"github.com/ryanhamamura/games/connect4"
+	"github.com/ryanhamamura/games/db/repository"
+	"github.com/ryanhamamura/games/features/auth"
+	"github.com/ryanhamamura/games/features/c4game"
+	c4services "github.com/ryanhamamura/games/features/c4game/services"
+	"github.com/ryanhamamura/games/features/lobby"
+	"github.com/ryanhamamura/games/features/snakegame"
+	snakeservices "github.com/ryanhamamura/games/features/snakegame/services"
+	"github.com/ryanhamamura/games/snake"
 )
 
 func SetupRoutes(
@@ -27,23 +28,25 @@ func SetupRoutes(
 	queries *repository.Queries,
 	sessions *scs.SessionManager,
 	nc *nats.Conn,
-	store *game.GameStore,
+	store *connect4.Store,
 	snakeStore *snake.SnakeStore,
-	assets embed.FS,
 ) {
 	// Static assets
-	subFS, _ := fs.Sub(assets, "assets")
+	router.Handle("/assets/*", assets.Handler())
-	router.Handle("/assets/*", http.StripPrefix("/assets/", http.FileServerFS(subFS)))
 
 	// Hot-reload for development
 	if config.Global.Environment == config.Dev {
 		setupReload(router)
 	}
 
+	// Services
+	c4Svc := c4services.NewGameService(nc, queries)
+	snakeSvc := snakeservices.NewGameService(nc)
+
 	auth.SetupRoutes(router, queries, sessions)
 	lobby.SetupRoutes(router, queries, sessions, store, snakeStore)
-	c4game.SetupRoutes(router, store, nc, sessions, queries)
+	c4game.SetupRoutes(router, store, c4Svc, sessions)
-	snakegame.SetupRoutes(router, snakeStore, nc, sessions)
+	snakegame.SetupRoutes(router, snakeStore, snakeSvc, sessions)
 }
 
 func setupReload(router chi.Router) {

sessions/sessions.go

@@ -8,12 +8,19 @@ import (
 	"net/http"
 	"time"
 
-	"github.com/ryanhamamura/c4/player"
+	"github.com/ryanhamamura/games/player"
 
 	"github.com/alexedwards/scs/sqlite3store"
 	"github.com/alexedwards/scs/v2"
 )
 
+// Session key names.
+const (
+	KeyPlayerID = "player_id"
+	KeyUserID   = "user_id"
+	KeyNickname = "nickname"
+)
+
 // SetupSessionManager creates a configured session manager backed by SQLite.
 // Returns the manager and a cleanup function the caller should defer.
 func SetupSessionManager(db *sql.DB) (*scs.SessionManager, func()) {
@@ -23,10 +30,10 @@ func SetupSessionManager(db *sql.DB) (*scs.SessionManager, func()) {
 	sessionManager := scs.New()
 	sessionManager.Store = store
 	sessionManager.Lifetime = 30 * 24 * time.Hour
-	sessionManager.Cookie.Name = "c4_session"
+	sessionManager.Cookie.Name = "games_session"
 	sessionManager.Cookie.Path = "/"
 	sessionManager.Cookie.HttpOnly = true
-	sessionManager.Cookie.Secure = true
+	sessionManager.Cookie.Secure = false
 	sessionManager.Cookie.SameSite = http.SameSiteLaxMode
 
 	slog.Info("session manager configured")
@@ -38,12 +45,12 @@ func SetupSessionManager(db *sql.DB) (*scs.SessionManager, func()) {
 // Authenticated users get their user UUID; guests get a random ID that
 // is generated and persisted on first access.
 func GetPlayerID(sm *scs.SessionManager, r *http.Request) player.ID {
-	pid := sm.GetString(r.Context(), "player_id")
+	pid := sm.GetString(r.Context(), KeyPlayerID)
 	if pid == "" {
 		pid = player.GenerateID(8)
-		sm.Put(r.Context(), "player_id", pid)
+		sm.Put(r.Context(), KeyPlayerID, pid)
 	}
-	if userID := sm.GetString(r.Context(), "user_id"); userID != "" {
+	if userID := sm.GetString(r.Context(), KeyUserID); userID != "" {
 		return player.ID(userID)
 	}
 	return player.ID(pid)
@@ -51,10 +58,10 @@ func GetPlayerID(sm *scs.SessionManager, r *http.Request) player.ID {
 
 // GetUserID returns the authenticated user's UUID, or empty string for guests.
 func GetUserID(sm *scs.SessionManager, r *http.Request) string {
-	return sm.GetString(r.Context(), "user_id")
+	return sm.GetString(r.Context(), KeyUserID)
 }
 
 // GetNickname returns the player's display name from the session.
 func GetNickname(sm *scs.SessionManager, r *http.Request) string {
-	return sm.GetString(r.Context(), "nickname")
+	return sm.GetString(r.Context(), KeyNickname)
 }

snake/persist.go

@@ -3,8 +3,8 @@ package snake
 import (
 	"context"
 
-	"github.com/ryanhamamura/c4/db/repository"
+	"github.com/ryanhamamura/games/db/repository"
-	"github.com/ryanhamamura/c4/player"
+	"github.com/ryanhamamura/games/player"
 
 	"github.com/rs/zerolog/log"
 )

snake/store.go

@@ -4,8 +4,8 @@ import (
 	"context"
 	"sync"
 
-	"github.com/ryanhamamura/c4/db/repository"
+	"github.com/ryanhamamura/games/db/repository"
-	"github.com/ryanhamamura/c4/player"
+	"github.com/ryanhamamura/games/player"
 )
 
 type SnakeStore struct {

snake/types.go

@@ -4,9 +4,18 @@ import (
 	"encoding/json"
 	"time"
 
-	"github.com/ryanhamamura/c4/player"
+	"github.com/ryanhamamura/games/player"
 )
 
+// SubjectPrefix is the NATS subject namespace for snake games.
+const SubjectPrefix = "snake"
+
+// GameSubject returns the NATS subject for game state updates.
+func GameSubject(gameID string) string { return SubjectPrefix + "." + gameID }
+
+// ChatSubject returns the NATS subject for chat messages.
+func ChatSubject(gameID string) string { return SubjectPrefix + ".chat." + gameID }
+
 type Direction int
 
 const (

testutil/db.go

@@ -8,8 +8,8 @@ import (
 	"io/fs"
 	"testing"
 
-	"github.com/ryanhamamura/c4/db"
+	"github.com/ryanhamamura/games/db"
-	"github.com/ryanhamamura/c4/db/repository"
+	"github.com/ryanhamamura/games/db/repository"
 
 	"github.com/pressly/goose/v3"
 	_ "modernc.org/sqlite"

version/version.go

@@ -0,0 +1,10 @@
+// Package version holds build-time version information injected via ldflags.
+package version
+
+// Version and Commit are set at build time via:
+//
+//	-ldflags "-X github.com/ryanhamamura/games/version.Version=... -X github.com/ryanhamamura/games/version.Commit=..."
+var (
+	Version = "dev"
+	Commit  = "unknown"
+)