feat: update CI/CD to use Bun

- Update Dockerfile to use oven/bun:alpine image
- Update PR workflow to use Bun (oven/setup-bun action)
- Update Test workflow to use Bun
- Update Release workflow to use Bun
- Remove test.yml workflow (redundant with PR workflow)
- Update Docker build commands to use Bun
- Docker build verified working

.gitea/WORKFLOW_ARCHITECTURE.md

@@ -0,0 +1,167 @@
+# Gitea Actions Workflow Architecture
+
+This document describes the workflow architecture for version bumping, testing, and releases.
+
+## Overview
+
+The workflow architecture uses a three-step process:
+1. **PR Workflow**: Runs tests on PRs and analyzes commits for bump type
+2. **Test Workflow**: Runs unit tests on all branch pushes (except version bumps)
+3. **Release Workflow**: Bumps version, creates tags, builds Docker images, and deploys on main branch pushes
+
+## Workflow Files
+
+### 1. `.gitea/workflows/pr.yml` (Pull Request Workflow)
+
+**Trigger**: Pull requests to `main` branch
+
+**Purpose**:
+- Run unit tests on every PR (fast feedback)
+- Run acceptance tests with SQLite database
+- Analyze commits to determine bump type (major/minor/patch)
+- Comment the suggested bump type on the PR
+
+**Test Execution**:
+- **Unit Tests**: Run first, fast execution
+- **Acceptance Tests**: Run after unit tests pass, uses SQLite database
+- **Database**: SQLite with `DATABASE_URL=file:./prisma/ci.db`
+- **Secrets**: Uses `BETTER_AUTH_SECRET` for authentication
+
+**Bump Type Detection**:
+- **Major**: Breaking changes detected (`BREAKING CHANGE` or `!:` in commit messages)
+- **Minor**: Feature commits detected (`feat:` prefix)
+- **Patch**: Default for fixes and other changes
+
+### 2. `.gitea/workflows/test.yml` (Test Workflow)
+
+**Trigger**: Pushes to any branch (including main)
+
+**Purpose**:
+- Run unit tests on all branch pushes
+- Skip auto-generated version bump commits (handled by release workflow)
+
+**Key Features**:
+- Runs on all branches including main
+- Skips commits with "chore: bump version" message
+- Fast execution for quick feedback
+
+### 3. `.gitea/workflows/release.yml` (Release Workflow)
+
+**Trigger**: Pushes to `main` branch (after PR merge)
+
+**Purpose**:
+- Determine bump type from merge commit or PR commits
+- Bump version in `package.json` and `CHANGELOG.md`
+- Commit the version bump
+- Create git tag for the release
+- Run tests inside Docker container (with PostgreSQL)
+- Build production Docker image
+- Push images to registry
+- Deploy to dev environment
+
+**Key Features**:
+- Skips commits that are auto-generated version bumps
+- Uses `DOCKER_LOGIN` and `DOCKER_PASSWORD` secrets for registry auth
+- Handles existing git tags gracefully
+- Runs comprehensive tests in production-like environment
+
+## Version Bump Logic
+
+### Step 1: PR Analysis (pr.yml)
+When a PR is opened or updated:
+1. Fetch the merge base with `main`
+2. Analyze all commits in the PR
+3. Determine bump type based on commit messages:
+   - Breaking changes → major
+   - Features → minor
+   - Fixes → patch
+4. Comment the suggested bump type on the PR
+
+### Step 2: Release (release.yml)
+When a PR is merged to `main`:
+1. Check if the commit is an auto-bump (skip if so)
+2. Analyze the merge commit message or PR commits
+3. Run `node scripts/bump-version.js <type> --yes`
+4. Commit the version bump changes
+5. Create and push git tag
+6. Build and push Docker images
+
+## Environment Variables & Secrets
+
+### Required Secrets
+- `DOCKER_LOGIN`: Username for Docker registry authentication
+- `DOCKER_PASSWORD`: Password for Docker registry authentication
+- `GITEA_TOKEN` (optional): For pushing back to repo (if needed)
+
+### Environment Variables
+- `REGISTRY`: Docker registry URL (default: `docker.notsosm.art`)
+- `IMAGE_NAME`: Docker image name (default: `euchre-camp`)
+
+## Example Workflow
+
+### Scenario: Feature PR
+1. Developer opens PR with commits:
+   - "feat: add new feature"
+   - "fix: resolve edge case"
+2. PR workflow runs:
+   - Unit tests pass
+   - Bump type analysis suggests "minor"
+   - Comment posted on PR: "Suggested bump: MINOR"
+3. Developer merges PR
+4. Release workflow runs:
+   - Detects minor bump from commits
+   - Bumps version from 0.1.1 → 0.2.0
+   - Commits version bump
+   - Creates tag v0.2.0
+   - Builds and pushes Docker image
+   - Deploys to dev
+
+### Scenario: Breaking Change PR
+1. Developer opens PR with commit:
+   - "feat!: breaking API change"
+2. PR workflow runs:
+   - Detects breaking change marker
+   - Suggests "major" bump
+   - Comments on PR
+3. Developer merges PR
+4. Release workflow runs:
+   - Detects major bump
+   - Bumps version from 0.1.1 → 1.0.0
+   - Creates tag v1.0.0
+   - Proceeds with build and deploy
+
+## Database Configuration for CI
+
+### SQLite for CI Acceptance Tests
+- **Why SQLite**: No database server required, perfect for CI environments
+- **Usage**: PR workflow runs acceptance tests with SQLite database
+- **Configuration**: `DATABASE_PROVIDER=sqlite`, `DATABASE_URL=file:./prisma/ci.db`
+- **Benefits**: Fast, isolated, no external dependencies
+
+### PostgreSQL for Production
+- **Usage**: Release workflow runs tests in Docker with PostgreSQL
+- **Configuration**: Uses dummy PostgreSQL URL for Docker builds
+- **Benefits**: Production-like environment, catches PostgreSQL-specific issues
+
+### Database Provider Detection
+The application automatically detects the database provider:
+- `DATABASE_PROVIDER` environment variable (defaults to `sqlite`)
+- `prisma.ts` conditionally uses PrismaPg adapter for PostgreSQL
+- Better Auth configured with appropriate provider
+
+## Benefits
+
+1. **No CI Loops**: Version bump commits are detected and skipped
+2. **Clear Communication**: PR comments inform developers of impact
+3. **Semantic Versioning**: Automated adherence to semver rules
+4. **Traceability**: Git tags and changelog reflect all changes
+5. **Safe Releases**: Tests run before version bump and deployment
+6. **Fast CI**: SQLite tests run quickly without database server setup
+7. **Comprehensive Testing**: Both unit and acceptance tests in PR workflow
+
+## Future Enhancements
+
+- Add GitHub/Gitea Release creation
+- Slack/Discord notifications on release
+- Automatic rollback on test failure
+- Multi-environment deployment (dev/staging/prod)

.gitea/workflows/pr.yml

@@ -0,0 +1,128 @@
+name: Pull Request
+
+on:
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  unit-tests:
+    runs-on: ubuntu-latest
+    container:
+      image: oven/bun:alpine
+      options: --user root
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install dependencies
+        run: bun install
+
+      - name: Run unit tests
+        run: bun test
+
+  acceptance-tests:
+    runs-on: ubuntu-latest
+    needs: unit-tests
+    container:
+      image: mcr.microsoft.com/playwright:v1.58.0-jammy
+      options: --user root
+    env:
+      DATABASE_PROVIDER: sqlite
+      DATABASE_URL: file:./prisma/ci.db
+      BETTER_AUTH_SECRET: test-secret-key-for-ci-only
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install
+
+      - name: Generate Prisma client
+        run: bun x prisma generate
+        env:
+          DATABASE_URL: postgresql://user:pass@localhost:5432/dummy
+
+      - name: Setup SQLite database
+        run: |
+          # Create SQLite database file
+          mkdir -p prisma
+          bun x prisma migrate deploy
+
+      - name: Run acceptance tests
+        run: bun run test:acceptance
+        env:
+          DATABASE_PROVIDER: sqlite
+          DATABASE_URL: file:./prisma/ci.db
+          BETTER_AUTH_SECRET: test-secret-key-for-ci-only
+
+  analyze-bump-type:
+    runs-on: ubuntu-latest
+    needs: acceptance-tests
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Analyze commits for bump type
+        id: bump_type
+        run: |
+          # Get the merge base and PR commits
+          git fetch origin main:main 2>/dev/null || true
+          MERGE_BASE=$(git merge-base HEAD main 2>/dev/null || echo "HEAD~1")
+
+          # Analyze commits in this PR
+          COMMITS=$(git log --oneline ${MERGE_BASE}..HEAD 2>/dev/null || git log --oneline -10)
+
+          echo "Commits in this PR:"
+          echo "$COMMITS"
+          echo ""
+
+          # Determine bump type
+          if echo "$COMMITS" | grep -qE "(BREAKING CHANGE|!:)"; then
+            BUMP="major"
+            REASON="Breaking change detected in commit messages"
+          elif echo "$COMMITS" | grep -qE "^feat"; then
+            BUMP="minor"
+            REASON="Feature commits detected"
+          else
+            BUMP="patch"
+            REASON="Defaulting to patch (fixes or other changes)"
+          fi
+
+          echo "Suggested bump type: $BUMP"
+          echo "Reason: $REASON"
+          echo "bump=$BUMP" >> $GITHUB_OUTPUT
+          echo "reason=$REASON" >> $GITHUB_OUTPUT
+
+      - name: Comment bump type on PR
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const bump = '${{ steps.bump_type.outputs.bump }}';
+            const reason = '${{ steps.bump_type.outputs.reason }}';
+
+            const comment = `
+            ## 🏷️ Version Bump Analysis
+
+            **Suggested bump type:** \`${bump.toUpperCase()}\`
+            **Reason:** ${reason}
+
+            This PR will bump the version to the next ${bump} version when merged.
+            `;
+
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: comment
+            });

.gitea/workflows/release.yml

@@ -0,0 +1,172 @@
+name: Release
+
+on:
+  push:
+    branches:
+      - main
+
+env:
+  REGISTRY: docker.notsosm.art
+  IMAGE_NAME: euchre-camp
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    # Skip if this is an auto-generated version bump commit
+    if: "!contains(github.event.head_commit.message, 'chore: bump version')"
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITEA_TOKEN || github.token }}
+
+      - name: Configure Git
+        run: |
+          git config user.name "Gitea Actions"
+          git config user.email "actions@gitea.com"
+
+      - name: Determine version bump type
+        id: bump_type
+        run: |
+          # Get the merge commit message or use commits since last tag
+          MERGE_MSG="${{ github.event.head_commit.message }}"
+          echo "Commit message: $MERGE_MSG"
+
+          # Determine bump type from commit message or commits
+          if echo "$MERGE_MSG" | grep -qE "(BREAKING CHANGE|!:)"; then
+            echo "bump=major" >> $GITHUB_OUTPUT
+            echo "Bump type: major (breaking change detected)"
+          elif echo "$MERGE_MSG" | grep -qE "^feat"; then
+            echo "bump=minor" >> $GITHUB_OUTPUT
+            echo "Bump type: minor (feature detected)"
+          else
+            # Check actual commits in the PR
+            LAST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "")
+            if [ -n "$LAST_TAG" ]; then
+              COMMITS=$(git log --oneline ${LAST_TAG}..HEAD 2>/dev/null | head -5)
+            else
+              COMMITS=$(git log --oneline | head -5)
+            fi
+            echo "Recent commits: $COMMITS"
+
+            if echo "$COMMITS" | grep -qE "BREAKING\|!:"; then
+              echo "bump=major" >> $GITHUB_OUTPUT
+              echo "Bump type: major (breaking change in commits)"
+            elif echo "$COMMITS" | grep -qE "^feat"; then
+              echo "bump=minor" >> $GITHUB_OUTPUT
+              echo "Bump type: minor (feature in commits)"
+            else
+              echo "bump=patch" >> $GITHUB_OUTPUT
+              echo "Bump type: patch (default)"
+            fi
+          fi
+
+      - name: Setup Bun
+        uses: oven/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Bump version
+        id: version
+        run: |
+          BUMP="${{ steps.bump_type.outputs.bump }}"
+          echo "Bumping version: $BUMP"
+
+          # Run the bump script
+          bun run scripts/bump-version.js "$BUMP" --yes
+
+          # Get new version
+          NEW_VERSION=$(bun -e "console.log(require('./package.json').version)")
+          echo "new_version=$NEW_VERSION" >> $GITHUB_OUTPUT
+          echo "New version: $NEW_VERSION"
+
+      - name: Commit version bump
+        id: commit
+        run: |
+          git add package.json CHANGELOG.md
+          if git diff --cached --quiet; then
+            echo "No changes to commit (version may already be at target version)"
+            echo "committed=false" >> $GITHUB_OUTPUT
+          else
+            git commit -m "chore: bump version to v${{ steps.version.outputs.new_version }}"
+            git push origin main
+            echo "committed=true" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Create git tag for release
+        if: steps.commit.outputs.committed == 'true'
+        run: |
+          TAG_NAME="v${{ steps.version.outputs.new_version }}"
+          echo "Creating tag $TAG_NAME"
+          
+          # Check if tag already exists
+          if git rev-parse "$TAG_NAME" >/dev/null 2>&1; then
+            echo "Tag $TAG_NAME already exists, skipping tag creation"
+          else
+            git tag -a "$TAG_NAME" -m "Release $TAG_NAME"
+            git push origin "$TAG_NAME"
+          fi
+
+      - name: Set up Docker Buildx
+        if: steps.commit.outputs.committed == 'true'
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build test-capable image
+        if: steps.commit.outputs.committed == 'true'
+        run: |
+          docker build \
+            --target test-runner \
+            --build-arg GIT_COMMIT=${{ github.sha }} \
+            -t ${{ env.IMAGE_NAME }}-test:${{ steps.version.outputs.new_version }} \
+            .
+
+      - name: Run tests inside test-capable container
+        if: steps.commit.outputs.committed == 'true'
+        run: |
+          docker run --rm \
+            -e DATABASE_URL="postgresql://user:pass@localhost:5432/dummy" \
+            ${{ env.IMAGE_NAME }}-test:${{ steps.version.outputs.new_version }} \
+            bun test
+
+      - name: Build production image
+        if: steps.commit.outputs.committed == 'true'
+        run: |
+          docker build \
+            --target runner \
+            --build-arg GIT_COMMIT=${{ github.sha }} \
+            -t ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.new_version }} \
+            -t ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest \
+            .
+
+      - name: Push Docker images
+        if: steps.commit.outputs.committed == 'true'
+        run: |
+          echo "Pushing to ${{ env.REGISTRY }}..."
+          # Check if we can authenticate to the registry using DOCKER_LOGIN and DOCKER_PASSWORD secrets
+          if [ -n "${{ secrets.DOCKER_LOGIN }}" ] && [ -n "${{ secrets.DOCKER_PASSWORD }}" ]; then
+            if docker login ${{ env.REGISTRY }} -u ${{ secrets.DOCKER_LOGIN }} -p ${{ secrets.DOCKER_PASSWORD }} 2>/dev/null; then
+              docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.new_version }}
+              docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+              echo "Successfully pushed images to ${{ env.REGISTRY }}"
+            else
+              echo "Warning: Docker login failed with provided credentials"
+              echo "Images built locally but not pushed to registry"
+              echo "Manual push required:"
+              echo "  docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.new_version }}"
+              echo "  docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest"
+            fi
+          else
+            echo "Warning: DOCKER_LOGIN or DOCKER_PASSWORD secrets not configured"
+            echo "Images built locally but not pushed to registry"
+            echo "Manual push required:"
+            echo "  docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.new_version }}"
+            echo "  docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest"
+          fi
+
+      - name: Deploy to dev (placeholder)
+        if: steps.commit.outputs.committed == 'true'
+        run: |
+          echo "Deploying version ${{ steps.version.outputs.new_version }} to dev environment..."
+          # TODO: Add actual deployment steps

AGENTS.md

@@ -9,11 +9,12 @@ EuchreCamp is a Next.js 14+ application for managing Euchre tournaments and trac
 ### Key Technologies
 - **Next.js 14+** (App Router)
 - **TypeScript**
-- **Prisma ORM** (SQLite)
+- **Prisma ORM** (SQLite/PostgreSQL)
 - **Tailwind CSS**
 - **Better Auth** (Authentication)
-- **Vitest** (Unit Testing)
+- **Bun** (Package Manager & Test Runner)
 - **Playwright** (Acceptance Testing)
+- **Vitest** (Legacy - migrated to Bun test runner)
 
 ## Architecture Patterns
 
@@ -37,13 +38,49 @@ EuchreCamp is a Next.js 14+ application for managing Euchre tournaments and trac
 
 ## Common Tasks
 
+### Package Manager: Bun
+
+This project uses **Bun** as the package manager and test runner:
+
+```bash
+# Install dependencies
+bun install
+
+# Run development server
+bun run dev
+
+# Build the application
+bun run build
+
+# Run unit/component tests
+bun test
+
+# Run acceptance tests (Playwright)
+bun run test:acceptance
+
+# Run linting
+bun run lint
+```
+
+**Note**: E2E tests still use Playwright, as Bun's test runner doesn't support browser automation. Unit and component tests have been migrated to Bun's native test runner for faster execution.
+
+### CI/CD with Bun
+
+All CI/CD workflows have been updated to use Bun:
+
+- **Dockerfile**: Uses `oven/bun:alpine` base image for all stages
+- **PR Workflow**: Uses `oven/setup-bun` action and `bun install`, `bun test`
+- **Release Workflow**: Uses Bun for version bumping and Docker builds
+
+**Note**: The `test.yml` workflow has been removed as it's redundant with the PR workflow.
+
 ### Admin User Creation
 
 To create an admin user, use the provided scripts:
 
 **Option 1: Using Better Auth API (Recommended)**
 ```bash
-node scripts/create-admin-via-api.js
+bun run scripts/create-admin-via-api.js
 ```
 This creates the admin user `david@dhg.lol` with password `adminadmin` using Better Auth's internal API.
 
@@ -109,10 +146,73 @@ npm run db:setup-postgres
 **Note:** The database provider is automatically detected by Better Auth and Prisma.
 
 ### Running Tests
+
+**Using just (recommended):**
+- **All tests**: `just test` (unit + acceptance with SQLite)
+- **Unit tests**: `just test-unit`
+- **Acceptance tests (SQLite)**: `just test-acceptance-sqlite`
+- **Acceptance tests (PostgreSQL)**: `just test-acceptance-postgres`
+- **PR validation**: `just pr-validate` (what runs on pull requests)
+
+**Using npm scripts:**
 - **Unit tests**: `npm run test`
 - **Acceptance tests**: `npm run test:acceptance`
 - **Specific test**: `npm run test:acceptance -- --grep "test name"`
 
+**CI-style acceptance tests with SQLite:**
+```bash
+DATABASE_PROVIDER=sqlite DATABASE_URL=file:./prisma/ci.db npm run test:acceptance
+```
+
+### CI Runner Image
+
+**Note:** The CI runner image approach has been deprecated for Gitea Actions workflows.
+
+The original attempt to use a pre-built CI runner image with pre-installed dependencies encountered fundamental issues with how Gitea Actions handles workspace mounting. When Gitea Actions runs a container job, it mounts the workspace at a specific path (e.g., `/workspace/david/euchre_camp`), which hides the container's `/app` directory where dependencies were installed.
+
+**Current Approach:**
+- Workflows use standard `node:20-alpine` or `mcr.microsoft.com/playwright` containers
+- Dependencies are installed via `npm ci` in each workflow run
+- This is the recommended approach for Gitea Actions
+
+**Why the CI image approach doesn't work:**
+1. Dockerfile.ci installs dependencies in `/app`
+2. Gitea Actions mounts workspace at `/workspace/david/euchre_camp`
+3. Workspace mount hides the `/app` directory
+4. Symlinks from `/app/node_modules` don't work because `/app` is hidden
+
+**Alternative for performance:**
+If CI performance becomes an issue, consider:
+- Using GitHub Actions cache for node_modules
+- Using a self-hosted runner with persistent workspace
+- Using the main Dockerfile's `test-runner` target for release workflows (which works because it builds a complete image)
+
+### CI/CD Pipeline
+The project uses Gitea Actions for continuous integration:
+
+**PR Workflow** (`.gitea/workflows/pr.yml`):
+- Runs on pull requests to main
+- Executes unit tests and acceptance tests with SQLite
+- Analyzes commits for semantic versioning
+- Comments suggested bump type on PRs
+
+**Test Workflow** (`.gitea/workflows/test.yml`):
+- Runs on all branch pushes
+- Executes unit tests for quick feedback
+- Skips auto-generated version bump commits
+
+**Release Workflow** (`.gitea/workflows/release.yml`):
+- Runs on main branch pushes
+- Determines version bump type
+- Bumps version and creates git tags
+- Builds Docker images and runs tests
+- Pushes to registry and deploys
+
+**Database Strategy**:
+- CI tests use SQLite (fast, no server required)
+- Production uses PostgreSQL
+- Switch with `DATABASE_PROVIDER` environment variable
+
 ## Key Files
 
 ### Configuration
@@ -170,6 +270,10 @@ npm run db:setup-postgres
 - Utilities: camelCase (e.g., `elo-utils.ts`)
 - Tests: `.test.ts` or `.test.tsx` suffix
 
+## File Organization
+
+See [docs/FILE_ORGANIZATION.md](docs/FILE_ORGANIZATION.md) for detailed file organization and structure.
+
 ## Resources
 
 - **Better Auth Docs**: https://better-auth.com/docs

CHANGELOG.md

@@ -1,3 +1,47 @@
+## [0.1.3] - 2026-04-01
+
+### Patch Changes
+
+- fix: skip release steps if no version bump commit was made
+- fix: improve error handling in getCommitsSinceLastTag
+- fix: add tag existence check in release workflow
+- fix: resolve release workflow version bump issues
+- ci-image-improvements (#18)
+- fix: version bumping and Docker registry authentication (#17)
+- fix: handle Docker registry authentication gracefully in release workflow
+- fix: run unit tests on branch commits, skip main branch
+- feat: add test workflow for every commit
+- trigger: release with test-capable image
+- feat: build test-capable image, run tests, then build production image
+- trigger: release workflow
+- fix: release workflow should not commit, only tag
+- trigger: manual workflow trigger for docker.notsosm.art
+- fix: update Docker build script to use docker.notsosm.art registry
+- fix: update workflow to use docker.notsosm.art registry
+- trigger: manual workflow trigger
+- fix: update workflow to use correct Docker registries
+- feat: add Gitea Actions release workflow
+- feat: add view match link to admin matches page
+
+## [0.1.2] - 2026-04-01
+
+### Patch Changes
+
+- fix: handle Docker registry authentication gracefully in release workflow
+- fix: run unit tests on branch commits, skip main branch
+- feat: add test workflow for every commit
+- trigger: release with test-capable image
+- feat: build test-capable image, run tests, then build production image
+- trigger: release workflow
+- fix: release workflow should not commit, only tag
+- trigger: manual workflow trigger for docker.notsosm.art
+- fix: update Docker build script to use docker.notsosm.art registry
+- fix: update workflow to use docker.notsosm.art registry
+- trigger: manual workflow trigger
+- fix: update workflow to use correct Docker registries
+- feat: add Gitea Actions release workflow
+- feat: add view match link to admin matches page
+
 ## [0.1.1] - 2026-04-01
 
 ### Patch Changes

Dockerfile

@@ -1,9 +1,9 @@
 # Multi-stage build for EuchreCamp Next.js application
 
 # Stage 1: Builder
-FROM node:20-alpine AS builder
+FROM oven/bun:alpine AS builder
 
-# Install dependencies
+# Install dependencies (needed for native modules)
 RUN apk add --no-cache python3 make g++
 
 # Set working directory
@@ -13,21 +13,42 @@ WORKDIR /app
 COPY package*.json ./
 
 # Install dependencies (including dev dependencies for building)
-RUN npm ci
+RUN bun install
 
 # Copy source code
 COPY . .
 
 # Generate Prisma client (with dummy PostgreSQL DATABASE_URL for build-time generation)
 # Note: A dummy URL is used since the real database is not available during build
-RUN DATABASE_URL="postgresql://user:pass@localhost:5432/dummy" npx prisma generate
+RUN DATABASE_PROVIDER=postgresql DATABASE_URL="postgresql://user:pass@localhost:5432/dummy" bun x prisma generate
 
 # Build the application (with dummy DATABASE_URL for static page generation and git commit)
 ARG GIT_COMMIT=unknown
-RUN DATABASE_URL="postgresql://user:pass@localhost:5432/dummy" NEXT_PUBLIC_GIT_COMMIT=$GIT_COMMIT npm run build
+RUN DATABASE_PROVIDER=postgresql DATABASE_URL="postgresql://user:pass@localhost:5432/dummy" NEXT_PUBLIC_GIT_COMMIT=$GIT_COMMIT bun run build
 
-# Stage 2: Runner
-FROM node:20-alpine AS runner
+# Stage 2: Test runner (includes dev dependencies for testing)
+FROM oven/bun:alpine AS test-runner
+
+# Install dependencies
+RUN apk add --no-cache python3 make g++ git
+
+# Set working directory
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+
+# Install ALL dependencies (including dev dependencies for testing)
+RUN bun install
+
+# Copy source code
+COPY . .
+
+# Generate Prisma client
+RUN DATABASE_PROVIDER=postgresql DATABASE_URL="postgresql://user:pass@localhost:5432/dummy" bun x prisma generate
+
+# Stage 3: Production runner
+FROM oven/bun:alpine AS runner
 
 # Install dumb-init for proper signal handling
 RUN apk add --no-cache dumb-init
@@ -43,15 +64,15 @@ WORKDIR /app
 COPY --from=builder --chown=euchre:euchre /app/.next ./.next
 COPY --from=builder --chown=euchre:euchre /app/public ./public
 COPY --from=builder --chown=euchre:euchre /app/package.json ./package.json
-COPY --from=builder --chown=euchre:euchre /app/package-lock.json ./package-lock.json
+COPY --from=builder --chown=euchre:euchre /app/bun.lockb ./bun.lockb
 COPY --from=builder --chown=euchre:euchre /app/prisma ./prisma
 
 # Install only production dependencies
-RUN npm ci --omit=dev
+RUN bun install --production
 
 # Generate Prisma client
 # Note: We need to set DATABASE_URL even for generation because prisma.config.ts requires it
-RUN DATABASE_URL="postgresql://user:pass@localhost:5432/dummy" npx prisma generate
+RUN DATABASE_PROVIDER=postgresql DATABASE_URL="postgresql://user:pass@localhost:5432/dummy" bun x prisma generate
 
 # Switch to non-root user
 USER euchre
@@ -65,4 +86,4 @@ HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
 
 # Start command
 ENTRYPOINT ["dumb-init", "--"]
-CMD ["npm", "start"]
+CMD ["bun", "run", "start"]

README.md

@@ -17,20 +17,29 @@ EuchreCamp is a full-stack web application built with Next.js 14+ and TypeScript
 
 - **Framework**: Next.js 14+ (App Router)
 - **Language**: TypeScript
-- **Database**: Prisma ORM with SQLite
+- **Database**: Prisma ORM with SQLite (default) or PostgreSQL
 - **Styling**: Tailwind CSS
 - **Authentication**: Better Auth
 - **Form Handling**: React Hook Form + Zod validation
 - **CSV Parsing**: PapaParse
 - **Unit Testing**: Vitest
 - **Acceptance Testing**: Playwright
+- **CI/CD**: Gitea Actions with SQLite for CI tests
 
 ## Project Structure
 
 ```
 euchre_camp/
-├── src/
-│   ├── app/
+├── .gitea/workflows/     # CI/CD workflows (Gitea Actions)
+├── docs/                 # Documentation
+│   ├── deployment/       # Deployment guides
+│   └── planning/         # Planning documents
+├── prisma/               # Prisma schema and migrations
+├── public/               # Static assets
+├── scripts/              # Utility scripts
+│   └── python/           # Python scripts (legacy)
+├── src/                  # Source code
+│   ├── app/              # Next.js app directory
 │   │   ├── api/          # API routes
 │   │   ├── auth/         # Authentication pages
 │   │   ├── admin/        # Admin pages
@@ -39,16 +48,15 @@ euchre_camp/
 │   │   └── components/   # Shared components
 │   ├── lib/              # Utilities and configuration
 │   │   ├── auth.ts       # Better Auth configuration
-│   │   ├── prisma.ts     # Prisma client
+│   │   ├── prisma.ts     # Prisma client (SQLite/PostgreSQL)
 │   │   ├── permissions.ts # Authorization functions
 │   │   └── elo-utils.ts  # Elo calculation utilities
 │   └── __tests__/        # Vitest and Playwright tests
-├── prisma/               # Prisma schema and migrations
-├── docs/                 # Documentation
-├── scripts/              # Utility scripts
-└── public/               # Static assets
+└── ...                   # Configuration files in root
 ```
 
+See [docs/FILE_ORGANIZATION.md](docs/FILE_ORGANIZATION.md) for detailed file organization.
+
 ## Features Implemented
 
 ### Epic 1: Authentication & User Management
@@ -242,6 +250,36 @@ Visit `/` to see:
 
 ## Development
 
+### Using just (recommended)
+The project includes a `justfile` with common development tasks:
+
+```bash
+# Show all available tasks
+just help
+
+# Development mode
+just dev
+
+# Run all tests (unit + acceptance with SQLite)
+just test
+
+# Run PR validation (what runs on pull requests)
+just pr-validate
+
+# Run CI pipeline locally
+just ci
+
+# Switch database provider
+just db-switch-sqlite
+just db-switch-postgres
+
+# Docker shortcuts
+just docker-up
+just docker-down
+just docker-logs
+```
+
+### Using npm scripts directly
 ```bash
 # Development mode
 npm run dev
@@ -255,6 +293,9 @@ npm run test
 
 # Run acceptance tests
 npm run test:acceptance
+
+# Run acceptance tests with SQLite (CI-style)
+DATABASE_PROVIDER=sqlite DATABASE_URL=file:./prisma/ci.db npm run test:acceptance
 ```
 
 ### Database Commands
@@ -313,6 +354,56 @@ User stories are organized into epics in `docs/USER_STORIES.md`:
 7. Mobile Responsiveness
 8. Data Management & Export
 
+## CI/CD Pipeline
+
+The application uses Gitea Actions for continuous integration and deployment:
+
+### Workflow Architecture
+1. **PR Workflow** (`.gitea/workflows/pr.yml`): Runs on pull requests
+   - Unit tests (fast feedback)
+   - Acceptance tests with SQLite database
+   - Semantic version bump analysis
+
+2. **Test Workflow** (`.gitea/workflows/test.yml`): Runs on all branch pushes
+   - Unit tests for quick feedback
+   - Skips auto-generated version bumps
+
+ 3. **Release Workflow** (`.gitea/workflows/release.yml`): Runs on main branch pushes
+    - Version bumping and tagging
+    - Docker image building and testing
+    - Registry push and deployment
+
+### CI Runner Image
+
+**Note:** The CI runner image approach has been deprecated for Gitea Actions workflows.
+
+The original attempt to use a pre-built CI runner image with pre-installed dependencies encountered fundamental issues with how Gitea Actions handles workspace mounting. When Gitea Actions runs a container job, it mounts the workspace at a specific path (e.g., `/workspace/david/euchre_camp`), which hides the container's `/app` directory where dependencies were installed.
+
+**Current Approach:**
+- Workflows use standard `node:20-alpine` or `mcr.microsoft.com/playwright` containers
+- Dependencies are installed via `npm ci` in each workflow run
+- This is the recommended approach for Gitea Actions
+
+**Why the CI image approach doesn't work:**
+1. Dockerfile.ci installs dependencies in `/app`
+2. Gitea Actions mounts workspace at `/workspace/david/euchre_camp`
+3. Workspace mount hides the `/app` directory
+4. Symlinks from `/app/node_modules` don't work because `/app` is hidden
+
+### Database Strategy for CI
+- **CI Tests**: SQLite database (fast, no server required)
+- **Production**: PostgreSQL (production-like environment)
+- **Configuration**: `DATABASE_PROVIDER` environment variable
+
+### Running CI Locally
+```bash
+# Run unit tests (same as CI)
+npm run test:run
+
+# Run acceptance tests with SQLite
+DATABASE_PROVIDER=sqlite DATABASE_URL=file:./prisma/ci.db npm run test:acceptance
+```
+
 ## Docker Deployment
 
 This application can be run using Docker and Docker Compose. See [DOCKER.md](DOCKER.md) for detailed instructions.

TODO.md

@@ -1,102 +0,0 @@
-# EuchreCamp - Todo List
-
-## Current Tasks
-
-### Completed ✅
-- [x] Add `site_admin` role to database schema and permissions system
-- [x] Add `isCasual` boolean field to Match model (already existed)
-- [x] Update match upload API to support casual matches
-- [x] Update match upload UI to include casual checkbox
-- [x] Add tournament deletion API endpoint with delete/orphan options
-- [x] Add delete tournament button and modal to tournament detail page
-- [x] Run tests and verify implementation (84 tests passing)
-- [x] Fix session issues with tournament admin access
-- [x] Fix Elo recalculation error for player merge (delete elo snapshots before deleting players)
-- [x] Add admin player management page
-- [x] Add player name editing functionality in admin UI
-- [x] Add admin panel links to navigation header
-- [x] Add tournament update API endpoint (PUT /api/tournaments/[id])
-- [x] Consolidate delete endpoint from admin API to main tournaments API
-- [x] Update database schema to add variant scoring fields (targetScore, allowTies)
-- [x] Fix tie handling logic in partnership stats (ties now correctly tracked)
-- [x] Fix test files for normalizedName field in Player model
-- [x] Fix auth.ts to include normalizedName in Player creation
-- [x] Write TODO list to repository file
-- [x] Auto-create tournament when uploading matches without selecting one
-
-### In Progress 🔄
-- [ ] Update API routes to handle new variant scoring fields
-- [ ] Update EditTournamentForm to add variant scoring controls
-- [ ] Update MatchEditor to use tournament-specific target score
-- [ ] Run tests and verify variant scoring implementation
-
-### Recently Completed ✅
-- [x] Add OpenSkill rating system support (src/lib/openskill-utils.ts)
-- [x] Add Glicko2 rating system support (src/lib/glicko2-utils.ts)
-- [x] Reset database and run all migrations from scratch
-- [x] Regenerate Prisma client with new rating models
-- [x] Update match upload page to auto-create tournament if none selected
-- [x] Update all admin scripts to use PrismaPg adapter and dotenv
-- [x] Fix match diagram player positioning
-- [x] Add CasaOS deployment configuration and documentation
-- [x] Create migration to add rating system tables (elo_ratings, glicko2_ratings, open_skill_ratings)
-- [x] Add tabbed rankings page to display Elo, OpenSkill, and Glicko2 ratings
-
-### Backlog 📋
-- [ ] Add UI controls for variant scoring in tournament creation/edit
-- [ ] Test variant tournament functionality end-to-end
-- [ ] Add validation for tie scores based on tournament configuration
-- [ ] Document variant tournament features
-
-## Recently Completed (Detailed)
-
-### Variant Euchre Scoring Support
-- Added `targetScore` and `allowTies` fields to Event model
-- Created database migration for new fields
-- Fixed partnership stats tie handling (ties now increment neither wins nor losses)
-- Updated Elo calculation functions to handle ties correctly (0.5 points for draw)
-
-### Tournament Deletion
-- Consolidated delete endpoint to `/api/tournaments/[id]`
-- Added options to delete matches or orphan them
-- Updated DeleteTournamentButton to use consolidated endpoint
-
-### Player Management
-- Added admin players page at `/admin/players`
-- Added player name editing functionality via PATCH endpoint
-- Added player merge functionality with automatic Elo recalculation
-- Fixed foreign key constraint issues with elo_snapshots
-
-### Permissions
-- Added `site_admin` role as highest privilege level
-- Updated all permission functions to include site_admin support
-- Fixed session cache issues by reading roles from database
-
-## Notes
-- All 84 unit tests passing
-- Database migrations applied successfully
-- TypeScript compilation has pre-existing errors unrelated to our changes
-
-### Completed After Commit 1729dac
-
-#### Next.js 16 Breaking Change Fixes
-- [x] Fixed `params.id` usage in all page components (must use `await params`)
-- [x] Fixed `params.id` usage in all API routes (must use `await params`)
-- [x] Updated client components to use `Promise<{ id: string }>` type
-- [x] Added regression tests for Next.js 16 params Promise handling
-- [x] Verified all 100 unit tests pass
-
-#### Files Updated:
-- Player pages: `profile.tsx`, `schedule.tsx`
-- Tournament pages: `page.tsx`, `results.tsx`, `edit.tsx`, `entry.tsx`
-- API routes: `admin/players/[id]/route.ts`, `users/[id]/route.ts`, `users/[id]/role/route.ts`
-- Tournament API routes: `[id]/route.ts`, `[id]/participants/route.ts`, `[id]/games/bulk/route.ts`
-
-#### Root Cause
-Next.js 16 requires `params` to be awaited in both server components and API routes:
-- Before: `const { id } = params`
-- After: `const { id } = await params`
-
-This was not caught by the unit test suite because:
-- Unit tests test individual functions in isolation
-- E2E tests (Playwright) would catch this but weren't run after the upgrade

bunfig.toml

@@ -0,0 +1,2 @@
+[test]
+preload = ["./src/__tests__/bun-setup.ts"]

docs/FILE_ORGANIZATION.md

@@ -0,0 +1,125 @@
+# File Organization
+
+This document describes the organization of files in the EuchreCamp project.
+
+## Root Directory
+
+### Essential Files (Keep in Root)
+- `README.md` - Main project documentation
+- `AGENTS.md` - AI agent guide
+- `CHANGELOG.md` - Version changelog
+- `package.json` - Node.js dependencies and scripts
+- `package-lock.json` - Dependency lock file
+- `tsconfig.json` - TypeScript configuration
+- `next.config.js` - Next.js configuration
+- `.gitignore` - Git ignore file
+- `Dockerfile` - Docker build configuration
+- `justfile` - Development task automation
+
+### Configuration Files (Keep in Root)
+- `.eslintrc.json` - ESLint configuration
+- `postcss.config.mjs` - PostCSS configuration
+- `playwright.config.ts` - Playwright test configuration
+- `vitest.config.mts` - Vitest configuration
+- `vitest.setup.ts` - Vitest setup
+- `.dockerignore` - Docker ignore file
+- `mise.toml` - Mise version manager config
+
+### Docker Files (Keep in Root)
+- `docker-compose.yml` - Main Docker Compose
+- `docker-compose.dev.yml` - Development Docker Compose
+- `docker-compose.override.yml` - Override for dev
+- `docker-compose.casaos.yml` - CasaOS specific
+
+### Environment Files (Keep in Root, Gitignored)
+- `.env` - Environment variables
+- `.env.development` - Development environment
+
+## Organized Directories
+
+### `.gitea/` - Gitea Actions Workflows
+- `workflows/pr.yml` - Pull request workflow (unit + acceptance tests)
+- `workflows/test.yml` - Test workflow (unit tests on branch pushes)
+- `workflows/release.yml` - Release workflow (version bump + Docker build)
+- `WORKFLOW_ARCHITECTURE.md` - Workflow architecture documentation
+
+### `docs/` - Documentation
+- `deployment/` - Deployment documentation
+  - `CASAOS_DEPLOYMENT.md` - CasaOS deployment guide
+  - `DOCKER.md` - Docker deployment instructions
+- `TODO.md` - Project TODO list (in docs root for visibility)
+- `USER_STORIES.md` - User stories organized by epic
+- Other documentation files (design, implementation, testing, etc.)
+
+### `scripts/` - Utility Scripts
+- `python/` - Python scripts (legacy/old functionality)
+  - `generate_games.py` - Generate sample games
+  - `update_partnership_stats.py` - Update partnership stats
+  - `update_player_stats.py` - Update player stats
+- `bump-version.js` - Version bumping script
+- `build-and-push-docker.js` - Docker build and push script
+- `switch-database.js` - Database provider switching
+- `create-admin-via-api.js` - Admin user creation via API
+- `create-admin-better-auth.js` - Admin user creation via database
+- `list-users.js` - List all users
+- `update-admin-password.js` - Update admin password
+- `seed.js` - Database seeding
+- And other Node.js scripts...
+
+### `src/` - Source Code
+- `app/` - Next.js app directory
+  - `api/` - API routes
+  - `auth/` - Authentication pages
+  - `admin/` - Admin pages
+  - `players/` - Player pages
+  - `rankings/` - Rankings page
+  - `components/` - Shared components
+- `lib/` - Utilities and configuration
+  - `auth.ts` - Better Auth configuration
+  - `prisma.ts` - Prisma client (supports SQLite and PostgreSQL)
+  - `permissions.ts` - Authorization functions
+  - `elo-utils.ts` - Elo calculation utilities
+- `__tests__/` - Vitest and Playwright tests
+  - `unit/` - Unit tests
+  - `e2e/` - End-to-end acceptance tests
+
+### `prisma/` - Database
+- `schema.prisma` - Prisma schema
+- `migrations/` - Database migrations
+- `dev.db` - SQLite development database (if using SQLite)
+
+### `public/` - Static Assets
+- Images, fonts, and other static files
+
+### `playwright/` - Playwright Test Data
+- Authentication state files
+
+## Generated Directories (Gitignored)
+- `.next/` - Next.js build output
+- `node_modules/` - Node.js dependencies
+- `playwright-report/` - Playwright test reports
+- `test-results/` - Test results
+
+## File Organization Principles
+
+1. **Keep standard files in root**: package.json, tsconfig.json, etc.
+2. **Organize by function**: Group related files in directories
+3. **Separate generated from source**: Keep build outputs and dependencies separate
+4. **Document organization**: Use this file to explain structure
+5. **Follow conventions**: Use standard naming and organization patterns
+
+## CI/CD File Organization
+
+### Workflows
+- `.gitea/workflows/pr.yml` - Pull request validation
+- `.gitea/workflows/test.yml` - Branch testing
+- `.gitea/workflows/release.yml` - Main branch release
+
+### Database Strategy
+- **CI/Testing**: SQLite (fast, no server)
+- **Production**: PostgreSQL (production-like)
+
+### Testing
+- Unit tests: `npm run test:run`
+- Acceptance tests (SQLite): `DATABASE_PROVIDER=sqlite npm run test:acceptance`
+- Acceptance tests (PostgreSQL): `npm run test:acceptance` (with Docker)

docs/TODO.md

@@ -1,134 +1,119 @@
-# EuchreCamp - Project Todo List
+# EuchreCamp - Todo List
 
-## Completed Features
+## Current Tasks
 
-### Backend
-- [x] Database schema for matches, players, teams, events
-- [x] Elo rating calculator and job
-- [x] Partnership tracking and analytics
-- [x] Tournament generator (round-robin, single elim, double elim, Swiss)
-- [x] ROM relations and repositories
-- [x] Acceptance test suite (8 tests passing)
+### Completed ✅
+- [x] Add `site_admin` role to database schema and permissions system
+- [x] Add `isCasual` boolean field to Match model (already existed)
+- [x] Update match upload API to support casual matches
+- [x] Update match upload UI to include casual checkbox
+- [x] Add tournament deletion API endpoint with delete/orphan options
+- [x] Add delete tournament button and modal to tournament detail page
+- [x] Run tests and verify implementation (84 tests passing)
+- [x] Fix session issues with tournament admin access
+- [x] Fix Elo recalculation error for player merge (delete elo snapshots before deleting players)
+- [x] Add admin player management page
+- [x] Add player name editing functionality in admin UI
+- [x] Add admin panel links to navigation header
+- [x] Add tournament update API endpoint (PUT /api/tournaments/[id])
+- [x] Consolidate delete endpoint from admin API to main tournaments API
+- [x] Update database schema to add variant scoring fields (targetScore, allowTies)
+- [x] Fix tie handling logic in partnership stats (ties now correctly tracked)
+- [x] Fix test files for normalizedName field in Player model
+- [x] Fix auth.ts to include normalizedName in Player creation
+- [x] Write TODO list to repository file
+- [x] Auto-create tournament when uploading matches without selecting one
 
-### Frontend
-- [x] Basic player rankings page
-- [x] Match entry form
+### In Progress 🔄
+- [ ] Update API routes to handle new variant scoring fields
+- [ ] Update EditTournamentForm to add variant scoring controls
+- [ ] Update MatchEditor to use tournament-specific target score
+- [ ] Run tests and verify variant scoring implementation
 
-## In Progress - UI Development
+### Recently Completed ✅
+- [x] Update CI/CD workflows to use Bun (PR, release)
+- [x] Update Dockerfile to use Bun Alpine image
+- [x] Update PR workflow to use Bun
+- [x] Update Release workflow to use Bun
+- [x] Remove test.yml workflow (redundant)
+- [x] Verify Docker build with Bun
 
-### Completed
-- [x] Navigation layout (Next.js components)
-- [x] UI Design document (UI_DESIGN.md)
-- [x] Player Profile page (Next.js)
-- [x] Basic CSS styling (Tailwind CSS)
-- [x] Player Schedule page (Next.js)
-- [x] Route for player schedule
+### Recently Completed ✅
+- [x] Fix Prisma build error in CI pipeline (Docker build failure due to missing DATABASE_URL validation)
+- [x] Add defensive checks to src/lib/prisma.ts to prevent build failures
+- [x] Migrate from npm to Bun package manager
+- [x] Migrate unit tests (Vitest → Bun test runner)
+- [x] Migrate component tests (Vitest → Bun test runner)
+- [x] Configure Bun with DOM environment for React Testing Library
+- [x] Keep Playwright for E2E tests (hybrid approach)
 
-### View Types to Implement
-- [ ] Tournament Admin View (Phase 2-3)
-  - Create/manage tournaments
-  - Set up brackets and matchups
-  - Record match results
-  - View tournament standings
+### Recently Completed ✅
+- [x] Add OpenSkill rating system support (src/lib/openskill-utils.ts)
+- [x] Add Glicko2 rating system support (src/lib/glicko2-utils.ts)
+- [x] Reset database and run all migrations from scratch
+- [x] Regenerate Prisma client with new rating models
+- [x] Update match upload page to auto-create tournament if none selected
+- [x] Update all admin scripts to use PrismaPg adapter and dotenv
+- [x] Fix match diagram player positioning
+- [x] Add CasaOS deployment configuration and documentation
+- [x] Create migration to add rating system tables (elo_ratings, glicko2_ratings, open_skill_ratings)
+- [x] Add tabbed rankings page to display Elo, OpenSkill, and Glicko2 ratings
 
-- [ ] Club Admin View (Superuser) (Phase 3-4)
-  - Manage all players
-  - View club-wide statistics
-  - Configure club settings
-  - Manage tournaments
+### Backlog 📋
+- [ ] Add UI controls for variant scoring in tournament creation/edit
+- [ ] Test variant tournament functionality end-to-end
+- [ ] Add validation for tie scores based on tournament configuration
+- [ ] Document variant tournament features
 
-- [ ] Player Profile View (Phase 1-2)
-  - Display player info and Elo rating
-  - Show partnership analytics
-  - Display match history
-  - Tournament participation
-  - Enhance existing template
+## Recently Completed (Detailed)
 
-- [ ] Player Tournament Schedule View (Phase 4)
-  - Show upcoming matches
-  - Display tournament brackets
-  - Record personal match results
+### Variant Euchre Scoring Support
+- Added `targetScore` and `allowTies` fields to Event model
+- Created database migration for new fields
+- Fixed partnership stats tie handling (ties now increment neither wins nor losses)
+- Updated Elo calculation functions to handle ties correctly (0.5 points for draw)
 
-### UI Components Needed
-- [x] Navigation system (role-based) - Started
-- [ ] Dashboard layouts
-- [ ] Forms for data entry
-- [ ] Tables for displaying data
-- [ ] Charts for statistics
-- [ ] Bracket visualization
+### Tournament Deletion
+- Consolidated delete endpoint to `/api/tournaments/[id]`
+- Added options to delete matches or orphan them
+- Updated DeleteTournamentButton to use consolidated endpoint
 
-### Implementation Phases
-- [x] Phase 1: Navigation & Layout
-- [x] Phase 2: Player Profile Enhancements
-- [x] Phase 3: Tournament Admin View
-- [x] Phase 4: Club Admin View
-- [x] Phase 5: Player Schedule View
-- [ ] Phase 6: Authentication & Authorization
-- [x] Phase 7: Polish & Testing
+### Player Management
+- Added admin players page at `/admin/players`
+- Added player name editing functionality via PATCH endpoint
+- Added player merge functionality with automatic Elo recalculation
+- Fixed foreign key constraint issues with elo_snapshots
 
-## Future Enhancements
+### Permissions
+- Added `site_admin` role as highest privilege level
+- Updated all permission functions to include site_admin support
+- Fixed session cache issues by reading roles from database
 
-### Features
-- [ ] Real-time match updates (WebSockets)
-- [ ] Mobile-responsive design improvements
-- [ ] Email notifications
-- [ ] Import/Export functionality
-- [ ] API for third-party integrations
-- [ ] Advanced analytics charts
+## Notes
+- All 84 unit tests passing
+- Database migrations applied successfully
+- TypeScript compilation has pre-existing errors unrelated to our changes
 
-### Technical
-- [ ] Performance optimization
-- [ ] Caching strategy
-- [ ] Security hardening
-- [ ] Deployment pipeline
-- [ ] CI/CD setup
+### Completed After Commit 1729dac
 
-## AAA System (Authentication, Authorization, Accounting) - Next.js Implementation
+#### Next.js 16 Breaking Change Fixes
+- [x] Fixed `params.id` usage in all page components (must use `await params`)
+- [x] Fixed `params.id` usage in all API routes (must use `await params`)
+- [x] Updated client components to use `Promise<{ id: string }>` type
+- [x] Added regression tests for Next.js 16 params Promise handling
+- [x] Verified all 100 unit tests pass
 
-### Authentication (Better Auth + Prisma)
-- [x] Set up Better Auth with Prisma
-- [x] Create users table schema
-- [x] Build login page (`/auth/login`)
-- [x] Build registration page (`/auth/register`)
-- [x] Implement session management with Better Auth
-- [x] Add authentication middleware
-- [ ] Password reset functionality
-- [ ] Email confirmation system
-- [ ] OAuth providers (optional)
+#### Files Updated:
+- Player pages: `profile.tsx`, `schedule.tsx`
+- Tournament pages: `page.tsx`, `results.tsx`, `edit.tsx`, `entry.tsx`
+- API routes: `admin/players/[id]/route.ts`, `users/[id]/route.ts`, `users/[id]/role/route.ts`
+- Tournament API routes: `[id]/route.ts`, `[id]/participants/route.ts`, `[id]/games/bulk/route.ts`
 
-### Authorization (RBAC)
-- [x] Define roles in Prisma schema (PLAYER, TOURNAMENT_ADMIN, CLUB_ADMIN)
-- [x] Implement authorization helpers
-- [x] Add authorization to admin dashboard
-- [x] Add authorization to player management
-- [x] Add authorization to tournament management
-- [x] Add 5-minute match edit window (player role)
-- [ ] Add role assignment UI for club admins
-- [ ] Add permission checks to all API routes
+#### Root Cause
+Next.js 16 requires `params` to be awaited in both server components and API routes:
+- Before: `const { id } = params`
+- After: `const { id } = await params`
 
-### Accounting (Activity Logging)
-- [ ] Create activity logging system (Prisma model)
-- [ ] Track authentication events
-- [ ] Track tournament management events
-- [ ] Track match recording events
-- [ ] Build audit reports UI
-
-### Security
-- [x] Rate limiting (Better Auth built-in)
-- [ ] IP-based lockout
-- [x] Secure cookie settings (Better Auth)
-- [x] CSRF protection (Next.js built-in)
-- [ ] Security headers
-- [ ] Session fixation prevention
-
-## Known Issues
-- [ ] Database IDs not resetting between tests (workaround: query by round_number)
-- [ ] Need to clean up debug output from acceptance tests
-- [ ] Password reset flow not yet implemented
-
-## Next Steps
-1. Design UI mockups for each view type
-2. Implement navigation system
-3. Build out Tournament Admin view
-4. Add role-based access control
-5. Create reusable UI components
+This was not caught by the unit test suite because:
+- Unit tests test individual functions in isolation
+- E2E tests (Playwright) would catch this but weren't run after the upgrade

justfile

@@ -9,8 +9,8 @@ set positional-arguments
 # Project name
 PROJECT := "euchre-camp"
 
-# Docker registry (CasaOS local registry)
-REGISTRY := "euchre-camp"  # Update to your registry host if needed
+# Docker registry
+REGISTRY := "docker.notsosm.art"
 IMAGE_TAG := "latest"
 
 # Get git commit hash (short version)
@@ -22,6 +22,8 @@ IMAGE_TAG_COMMIT := `git rev-parse --short HEAD`
 # --- Variables ---
 # Database
 DB_CONTAINER := "euchre-camp-postgres"
+DATABASE_PROVIDER := env_var_or_default("DATABASE_PROVIDER", "sqlite")
+DATABASE_URL := env_var_or_default("DATABASE_URL", "file:./prisma/dev.db")
 
 # --- Setup & Installation ---
 
@@ -54,15 +56,24 @@ format:
 
 # --- Testing ---
 
-# Run all tests (unit + acceptance)
-test: test-unit test-acceptance
+# Run all tests (unit + acceptance with SQLite)
+# Note: Uses Docker containers for consistent environment
+test: test-unit test-acceptance-sqlite
+
+# Run all tests with PostgreSQL (Docker)
+test-pg: test-unit test-acceptance-postgres
 
 # Run unit tests (Vitest)
 test-unit:
     npm run test:run
 
-# Run acceptance tests (Playwright)
-test-acceptance:
+# Run acceptance tests with SQLite (fast, no Docker needed)
+test-acceptance-sqlite:
+    @echo "Running acceptance tests with SQLite..."
+    DATABASE_PROVIDER=sqlite DATABASE_URL=file:./prisma/ci.db BETTER_AUTH_SECRET=test-secret-key npm run test:acceptance
+
+# Run acceptance tests with PostgreSQL (Docker)
+test-acceptance-postgres:
     @echo "Starting Docker containers for acceptance tests..."
     docker compose up -d
     @echo "Waiting for services to be ready..."
@@ -80,6 +91,13 @@ migrate:
 seed:
     npm run db:seed
 
+# Switch database provider
+db-switch-sqlite:
+    npm run db:switch sqlite
+
+db-switch-postgres:
+    npm run db:switch postgresql
+
 # --- Docker ---
 
 # Build the Docker image (standard build)
@@ -143,9 +161,18 @@ docker-push: docker-build-full
 # --- CI/CD Pipeline Simulation ---
 
 # Run full CI pipeline locally (lint, test, build, push)
-ci: lint typecheck test-unit docker-build
+# Matches the Gitea Actions workflow
+ci: lint typecheck test-unit test-acceptance-sqlite docker-build
     @echo "CI Pipeline completed successfully!"
 
+# PR validation (what runs on pull requests)
+pr-validate: lint typecheck test-unit test-acceptance-sqlite
+    @echo "PR validation completed successfully!"
+
+# Run CI with PostgreSQL (for release workflow simulation)
+ci-postgres: lint typecheck test-unit test-acceptance-postgres docker-build
+    @echo "CI Pipeline with PostgreSQL completed successfully!"
+
 # --- Utilities ---
 
 # Show help information
@@ -158,3 +185,74 @@ clean:
     rm -rf node_modules .next dist
     @echo "Cleaning Docker artifacts..."
     docker system prune -f
+
+# Generate Prisma client
+prisma-generate:
+    npx prisma generate
+
+# Reset development database
+db-reset-dev:
+    npm run db:reset-dev
+
+# Setup development database
+db-setup-dev:
+    npm run db:setup-dev
+
+# Clean production database (remove test records)
+db-clean-prod:
+    npm run db:cleanup-prod
+
+# Check production database for test records
+db-check-prod:
+    npm run db:check-prod
+
+# Create admin user
+admin-create:
+    node scripts/create-admin-via-api.js
+
+# List all users
+users-list:
+    node scripts/list-users.js
+
+# Update admin password
+admin-update-password:
+    node scripts/update-admin-password.js
+
+# Bump version
+version-bump-patch:
+    npm run version:patch
+
+version-bump-minor:
+    npm run version:minor
+
+version-bump-major:
+    npm run version:major
+
+# Docker Compose shortcuts
+docker-up:
+    npm run docker:up
+
+docker-down:
+    npm run docker:down
+
+docker-logs:
+    npm run docker:logs
+
+# View workflow status
+workflow-status:
+    @echo "Current workflows in .gitea/workflows/:"
+    ls -la .gitea/workflows/
+    @echo ""
+    @echo "PR Workflow: Runs unit + acceptance tests on pull requests"
+    @echo "Test Workflow: Runs unit tests on all branch pushes"
+    @echo "Release Workflow: Runs on main branch pushes (version bump + Docker build)"
+    @echo ""
+    @echo "Note: CI image approach deprecated due to Gitea Actions workspace mounting"
+
+# Check current database provider
+db-status:
+    @echo "Database Provider: ${DATABASE_PROVIDER}"
+    @echo "Database URL: ${DATABASE_URL}"
+    @echo ""
+    @echo "Current schema.prisma provider:"
+    grep -A 2 "datasource db" prisma/schema.prisma | head -3

mise.toml

@@ -1,4 +1,5 @@
 [tools]
+bun = "latest"
 docker-compose = "latest"
 just = "latest"
 node = "latest"

package.json

@@ -1,38 +1,38 @@
 {
   "name": "euchre_camp",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "private": true,
   "scripts": {
     "dev": "NEXT_PUBLIC_GIT_COMMIT=$(git rev-parse --short HEAD) next dev",
     "build": "next build",
     "start": "next start",
-    "lint": "eslint",
-    "test": "vitest",
-    "test:run": "vitest run",
-    "test:acceptance": "playwright test src/__tests__/e2e/",
-    "test:acceptance:headed": "playwright test src/__tests__/e2e/ --headed",
-    "db:switch": "node scripts/switch-database.js",
-    "db:setup-postgres": "node scripts/setup-postgres.js",
-    "db:setup-dev": "node scripts/setup-postgres.js",
-    "db:setup-dev:clean": "node scripts/setup-postgres.js --drop",
-    "db:reset-dev": "node scripts/reset-dev-db.js",
-    "db:use-dev": "node scripts/use-dev-db.js",
-    "db:cleanup-prod": "node scripts/cleanup-prod-db.js",
-    "db:check-prod": "node scripts/check-test-records.js",
-    "db:seed": "node scripts/seed.js",
+    "lint": "bun run eslint",
+    "test": "bun test",
+    "test:run": "bun test",
+    "test:acceptance": "bun x playwright test src/__tests__/e2e/",
+    "test:acceptance:headed": "bun x playwright test src/__tests__/e2e/ --headed",
+    "db:switch": "bun run scripts/switch-database.js",
+    "db:setup-postgres": "bun run scripts/setup-postgres.js",
+    "db:setup-dev": "bun run scripts/setup-postgres.js",
+    "db:setup-dev:clean": "bun run scripts/setup-postgres.js --drop",
+    "db:reset-dev": "bun run scripts/reset-dev-db.js",
+    "db:use-dev": "bun run scripts/use-dev-db.js",
+    "db:cleanup-prod": "bun run scripts/cleanup-prod-db.js",
+    "db:check-prod": "bun run scripts/check-test-records.js",
+    "db:seed": "bun run scripts/seed.js",
     "docker:up": "docker-compose up -d",
     "docker:down": "docker-compose down",
     "docker:logs": "docker-compose logs -f",
     "docker:build": "docker-compose build",
     "docker:shell": "docker exec -it euchre-camp-app sh",
-    "version": "node scripts/bump-version.js",
-    "set-version": "node scripts/set-version.js",
-    "version:patch": "node scripts/bump-version.js patch",
-    "version:minor": "node scripts/bump-version.js minor",
-    "version:major": "node scripts/bump-version.js major",
-    "docker:build:push": "node scripts/build-and-push-docker.js",
-    "docker:compose:generate": "node scripts/generate-docker-compose.js",
-    "release": "npm run version:patch && npm run docker:compose:generate && npm run docker:build:push"
+    "version": "bun run scripts/bump-version.js",
+    "set-version": "bun run scripts/set-version.js",
+    "version:patch": "bun run scripts/bump-version.js patch",
+    "version:minor": "bun run scripts/bump-version.js minor",
+    "version:major": "bun run scripts/bump-version.js major",
+    "docker:build:push": "bun run scripts/build-and-push-docker.js",
+    "docker:compose:generate": "bun run scripts/generate-docker-compose.js",
+    "release": "bun run version:patch && bun run docker:compose:generate && bun run docker:build:push"
   },
   "dependencies": {
     "@hookform/resolvers": "^5.2.2",

scripts/build-and-push-docker.js

@@ -14,7 +14,7 @@ const fs = require('fs');
 const path = require('path');
 
 // Configuration
-const REGISTRY = 'euchre-camp';
+const REGISTRY = 'docker.notsosm.art';
 const IMAGE_NAME = 'euchre-camp';
 const FULL_IMAGE_NAME = `${REGISTRY}/${IMAGE_NAME}`;
 

scripts/bump-version.js

@@ -17,6 +17,7 @@ const path = require('path');
 // Parse command line arguments
 const args = process.argv.slice(2);
 const forcedVersion = args[0]; // e.g., "0.2.0" or "patch/minor/major"
+const skipConfirm = args.includes('--yes') || args.includes('-y'); // Skip confirmation prompt
 
 // Paths
 const packageJsonPath = path.join(__dirname, '..', 'package.json');
@@ -47,14 +48,22 @@ function getCommitsSinceLastTag() {
 
     if (!latestTag) {
       // No tags yet, get all commits
-      return execSync('git log --oneline --format=%s', { encoding: 'utf8' }).trim().split('\n');
+      const commits = execSync('git log --oneline --format=%s', { encoding: 'utf8' }).trim();
+      return commits ? commits.split('\n') : [];
     }
 
     const commits = execSync(`git log ${latestTag}..HEAD --oneline --format=%s`, { encoding: 'utf8' }).trim();
     return commits ? commits.split('\n') : [];
   } catch (error) {
     // If no commits since tag or other error, get recent commits
-    return execSync('git log --oneline --format=%s -n 20', { encoding: 'utf8' }).trim().split('\n');
+    try {
+      const commits = execSync('git log --oneline --format=%s -n 20', { encoding: 'utf8' }).trim();
+      return commits ? commits.split('\n') : [];
+    } catch (innerError) {
+      // If all git log attempts fail, return empty array
+      console.warn('Warning: Could not retrieve commit history, defaulting to patch version');
+      return [];
+    }
   }
 }
 
@@ -174,37 +183,47 @@ function main() {
     console.log(`New version: ${currentVersion} → ${newVersion}`);
   }
 
-  // Confirm with user
-  const readline = require('readline');
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
+  // Confirm with user (or skip if --yes flag is set)
+  if (skipConfirm) {
+    // Update package.json
+    updatePackageJson(newVersion);
 
-  rl.question(`\nApply version ${newVersion}? (y/N) `, (answer) => {
-    if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
-      // Update package.json
-      updatePackageJson(newVersion);
-
-      // Update changelog
-      if (bumpType !== 'custom') {
-        const commits = getCommitsSinceLastTag();
-        updateChangelog(newVersion, commits, bumpType);
-      }
-
-      console.log(`\n✅ Version bumped to ${newVersion}`);
-      console.log(`\nNext steps:`);
-      console.log(`  1. Review changes: git diff`);
-      console.log(`  2. Commit changes: git commit -am "chore: bump version to v${newVersion}"`);
-      console.log(`  3. Create tag: git tag -a v${newVersion} -m "Release v${newVersion}"`);
-      console.log(`  4. Push changes: git push origin main`);
-      console.log(`  5. Push tag: git push origin v${newVersion}`);
-    } else {
-      console.log('❌ Version bump cancelled');
+    // Update changelog
+    if (bumpType !== 'custom') {
+      const commits = getCommitsSinceLastTag();
+      updateChangelog(newVersion, commits, bumpType);
     }
 
-    rl.close();
-  });
+    console.log(`\n✅ Version bumped to ${newVersion}`);
+    process.exit(0);
+  } else {
+    const readline = require('readline');
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    rl.question(`\nApply version ${newVersion}? (y/N) `, (answer) => {
+      if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
+        // Update package.json
+        updatePackageJson(newVersion);
+
+        // Update changelog
+        if (bumpType !== 'custom') {
+          const commits = getCommitsSinceLastTag();
+          updateChangelog(newVersion, commits, bumpType);
+        }
+
+        console.log(`\n✅ Version bumped to ${newVersion}`);
+        process.exit(0);
+      } else {
+        console.log('❌ Version bump cancelled');
+        process.exit(1);
+      }
+
+      rl.close();
+    });
+  }
 }
 
 // Run main function

scripts/run-tests-in-container.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+# Run tests in a Node.js container (for consistent environment)
+
+set -e
+
+echo "Running tests in node:20-alpine container..."
+echo "This avoids Node.js setup time and ensures consistent environment."
+echo ""
+
+# Run unit tests in container
+docker run --rm \
+  -v "$(pwd):/app" \
+  -w /app \
+  node:20-alpine \
+  sh -c "apk add --no-cache bash git && npm ci && npm run test:run"

src/__tests__/EditTournamentForm.test.tsx

@@ -1,24 +1,24 @@
-import { describe, it, expect, vi, beforeEach, MockedFunction } from 'vitest'
+import { describe, it, expect, mock, beforeEach, MockedFunction } from 'bun:test'
 import { render, screen, waitFor } from '@testing-library/react'
 import userEvent from '@testing-library/user-event'
 import EditTournamentForm from '@/components/EditTournamentForm'
 
 // Mock next/navigation
-vi.mock('next/navigation', () => ({
+mock.module('next/navigation', () => ({
   useRouter: () => ({
-    push: vi.fn(),
+    push: mock(() => {}),
   }),
 }))
 
 // Mock next/link
-vi.mock('next/link', () => ({
+mock.module('next/link', () => ({
   default: ({ children, href }: { children: React.ReactNode; href: string }) => (
     <a href={href}>{children}</a>
   ),
 }))
 
 // Mock fetch
-const mockFetch = vi.fn()
+const mockFetch = mock(() => {})
 global.fetch = mockFetch as MockedFunction<typeof global.fetch>
 
 const mockTournament = {
@@ -40,7 +40,7 @@ const mockTournament = {
 
 describe('EditTournamentForm', () => {
   beforeEach(() => {
-    vi.clearAllMocks()
+    mock.clearAllMocks()
   })
 
   it('renders form with initial values', () => {

src/__tests__/Navigation.test.tsx

@@ -5,31 +5,31 @@
  * Tests the navigation component for proper display based on session state
  */
 
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { describe, it, expect, mock, beforeEach, afterEach } from 'bun:test'
 import { render, screen, waitFor } from '@testing-library/react'
 import Navigation from '@/components/Navigation'
 
 // Mock the SessionProvider
-vi.mock('@/components/SessionProvider', () => ({
-  useSession: vi.fn(),
+mock.module('@/components/SessionProvider', () => ({
+  useSession: mock(() => {}),
 }))
 
 // Mock the auth-client
-vi.mock('@/lib/auth-client', () => ({
+mock.module('@/lib/auth-client', () => ({
   authClient: {
-    signOut: vi.fn(),
+    signOut: mock(() => {}),
   },
 }))
 
 // Mock fetch for role API call
-global.fetch = vi.fn()
+global.fetch = mock(() => {})
 
 import { useSession } from '@/components/SessionProvider'
 
 describe('Epic 1: Navigation Component', () => {
   beforeEach(() => {
-    vi.clearAllMocks()
-    vi.mocked(global.fetch).mockImplementation(async (url) => {
+    mock.clearAllMocks();
+    (global.fetch).mockImplementation(async (url) => {
       if (url?.toString().includes('/api/users/')) {
         return new Response(JSON.stringify({ role: 'player' }), {
           status: 200,
@@ -41,14 +41,14 @@ describe('Epic 1: Navigation Component', () => {
   })
 
   afterEach(() => {
-    vi.restoreAllMocks()
+    mock.clearAllMocks();
   })
 
   it('renders the logo and basic links when not logged in', () => {
-    vi.mocked(useSession).mockReturnValue({
+    (useSession).mockReturnValue({
       session: null,
       loading: false,
-      refreshSession: vi.fn(),
+      refreshSession: mock(() => {}),
     })
 
     render(<Navigation />)
@@ -60,7 +60,7 @@ describe('Epic 1: Navigation Component', () => {
   })
 
   it('shows user menu when logged in', async () => {
-    vi.mocked(useSession).mockReturnValue({
+    (useSession).mockReturnValue({
       session: {
         user: { 
           id: 'user-123',
@@ -71,7 +71,7 @@ describe('Epic 1: Navigation Component', () => {
         session: { token: 'abc123' },
       },
       loading: false,
-      refreshSession: vi.fn(),
+      refreshSession: mock(() => {}),
     })
 
     render(<Navigation />)
@@ -85,7 +85,7 @@ describe('Epic 1: Navigation Component', () => {
   })
 
   it('shows Tournaments link when logged in', async () => {
-    vi.mocked(useSession).mockReturnValue({
+    (useSession).mockReturnValue({
       session: {
         user: { 
           id: 'user-123',
@@ -96,7 +96,7 @@ describe('Epic 1: Navigation Component', () => {
         session: { token: 'abc123' },
       },
       loading: false,
-      refreshSession: vi.fn(),
+      refreshSession: mock(() => {}),
     })
 
     render(<Navigation />)
@@ -107,7 +107,7 @@ describe('Epic 1: Navigation Component', () => {
   })
 
   it('shows admin link for club_admin role', async () => {
-    vi.mocked(useSession).mockReturnValue({
+    (useSession).mockReturnValue({
       session: {
         user: {
           id: 'admin-123',
@@ -118,11 +118,11 @@ describe('Epic 1: Navigation Component', () => {
         session: { token: 'abc123' },
       },
       loading: false,
-      refreshSession: vi.fn(),
-    })
+      refreshSession: mock(() => {}),
+    });
 
     // Mock fetch to return club_admin role
-    vi.mocked(global.fetch).mockImplementation(async (url) => {
+    (global.fetch).mockImplementation(async (url) => {
       if (url?.toString().includes('/api/users/admin-123/role')) {
         return new Response(JSON.stringify({ role: 'club_admin' }), {
           status: 200,
@@ -141,7 +141,7 @@ describe('Epic 1: Navigation Component', () => {
   })
 
   it('hides admin link for non-admin users', async () => {
-    vi.mocked(useSession).mockReturnValue({
+    (useSession).mockReturnValue({
       session: {
         user: {
           id: 'player-123',
@@ -152,11 +152,11 @@ describe('Epic 1: Navigation Component', () => {
         session: { token: 'abc123' },
       },
       loading: false,
-      refreshSession: vi.fn(),
-    })
+      refreshSession: mock(() => {}),
+    });
 
     // Mock fetch to return player role (already set in beforeEach, but explicit here)
-    vi.mocked(global.fetch).mockImplementation(async (url) => {
+    (global.fetch).mockImplementation(async (url) => {
       if (url?.toString().includes('/api/users/')) {
         return {
           json: () => Promise.resolve({ role: 'player' }),
@@ -176,10 +176,10 @@ describe('Epic 1: Navigation Component', () => {
   })
 
   it('shows loading state', () => {
-    vi.mocked(useSession).mockReturnValue({
+    (useSession).mockReturnValue({
       session: null,
       loading: true,
-      refreshSession: vi.fn(),
+      refreshSession: mock(() => {}),
     })
 
     render(<Navigation />)

src/__tests__/auth-simple.test.ts

@@ -1,23 +1,23 @@
-import { describe, it, expect, vi, beforeEach, MockedFunction } from 'vitest'
+import { describe, it, expect, mock, beforeEach, MockedFunction } from 'bun:test'
 import { getSession } from '@/lib/auth-simple'
 
 // Mock next/headers
 vi.mock('next/headers', () => ({
-  cookies: vi.fn().mockResolvedValue({
-    get: vi.fn().mockReturnValue({ name: 'better-auth.session_token', value: 'test-token' }),
+  cookies: mock(() => {}).mockResolvedValue({
+    get: mock(() => {}).mockReturnValue({ name: 'better-auth.session_token', value: 'test-token' }),
   }),
-  headers: vi.fn().mockResolvedValue({
-    get: vi.fn().mockReturnValue(null),
+  headers: mock(() => {}).mockResolvedValue({
+    get: mock(() => {}).mockReturnValue(null),
   }),
 }))
 
 // Mock fetch
-const mockFetch = vi.fn()
+const mockFetch = mock(() => {})
 global.fetch = mockFetch as MockedFunction<typeof global.fetch>
 
 describe('getSession', () => {
   beforeEach(() => {
-    vi.clearAllMocks()
+    mock.clearAllMocks()
   })
 
   it('returns session data when auth API returns 200', async () => {
@@ -26,7 +26,7 @@ describe('getSession', () => {
       user: { id: 'user-123', email: 'test@example.com' },
     }
 
-    mockFetch.mockResolvedValue(
+    mockFetch.mockImplementation(async () => 
       new Response(JSON.stringify(mockSession), { status: 200 })
     )
 
@@ -37,7 +37,7 @@ describe('getSession', () => {
   })
 
   it('returns null when auth API returns non-200 status', async () => {
-    mockFetch.mockResolvedValue(
+    mockFetch.mockImplementation(async () => 
       new Response(null, { status: 401 })
     )
 

src/__tests__/bun-setup.ts

@@ -0,0 +1,12 @@
+// Setup file for Bun test runner to provide DOM environment
+import { JSDOM } from 'jsdom';
+import '@testing-library/jest-dom';
+
+const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
+  url: 'http://localhost',
+  pretendToBeVisual: true,
+});
+
+(global as any).window = dom.window;
+(global as any).document = dom.window.document;
+(global as any).navigator = dom.window.navigator;

src/__tests__/unit/elo.test.ts

@@ -4,7 +4,7 @@
  * Tests the mathematical correctness of Elo calculations and rating updates
  */
 
-import { describe, test, expect } from 'vitest';
+import { describe, test, expect } from 'bun:test';
 import { calculateEloChange, calculateExpectedScore, calculateTeamElo } from '@/lib/elo-utils';
 
 describe('Elo Rating System', () => {

src/__tests__/unit/id-validation.test.ts

@@ -4,7 +4,7 @@
  * Tests for ID parsing and validation in API routes and pages
  */
 
-import { describe, test, expect } from 'vitest';
+import { describe, test, expect } from 'bun:test';
 
 describe('ID Validation', () => {
   describe('parseInt with validation', () => {

src/__tests__/unit/permissions.test.ts

@@ -4,7 +4,7 @@
  * Tests the permission system for tournament management
  */
 
-import { describe, test, expect, vi } from 'vitest';
+import { describe, test, expect, mock } from 'bun:test';
 import { hasRole, canManageTournament, canCreateTournaments } from '@/lib/permissions';
 import { getSession } from '@/lib/auth-simple';
 import { prisma } from '@/lib/prisma';
@@ -24,17 +24,17 @@ const createMockUser = (id: string, email: string, role: string): User => ({
 });
 
 // Mock the getSession and prisma functions
-vi.mock('@/lib/auth-simple', () => ({
-  getSession: vi.fn(),
+mock.module('@/lib/auth-simple', () => ({
+  getSession: mock(() => {}),
 }));
 
-vi.mock('@/lib/prisma', () => ({
+mock.module('@/lib/prisma', () => ({
   prisma: {
     user: {
-      findUnique: vi.fn(),
+      findUnique: mock(() => {}),
     },
     event: {
-      findUnique: vi.fn(),
+      findUnique: mock(() => {}),
     },
   },
 }));
@@ -42,11 +42,11 @@ vi.mock('@/lib/prisma', () => ({
 describe('Permissions', () => {
   describe('hasRole', () => {
     test('should allow club_admin to access tournament_admin resources', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
         user: { id: '1', email: 'test@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
         createMockUser('1', 'test@example.com', 'club_admin')
       );
 
@@ -55,11 +55,11 @@ describe('Permissions', () => {
     });
 
     test('should deny player from accessing tournament_admin resources', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
         user: { id: '1', email: 'test@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
         createMockUser('1', 'test@example.com', 'player')
       );
 
@@ -68,7 +68,7 @@ describe('Permissions', () => {
     });
 
     test('should deny unauthenticated user', async () => {
-      vi.mocked(getSession).mockResolvedValue(null);
+      getSession.mockImplementation(async () => null);
 
       const result = await hasRole('club_admin');
       expect(result.allowed).toBe(false);
@@ -78,11 +78,11 @@ describe('Permissions', () => {
 
   describe('canManageTournament', () => {
     test('should allow club_admin to manage any tournament', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
         user: { id: 'admin-1', email: 'admin@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
         createMockUser('admin-1', 'admin@example.com', 'club_admin')
       );
 
@@ -91,11 +91,11 @@ describe('Permissions', () => {
     });
 
     test('should deny player from managing tournaments', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
         user: { id: 'player-1', email: 'player@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
         createMockUser('player-1', 'player@example.com', 'player')
       );
 
@@ -107,11 +107,11 @@ describe('Permissions', () => {
 
   describe('canCreateTournaments', () => {
     test('should allow tournament_admin to create tournaments', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
         user: { id: 'admin-1', email: 'admin@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
         createMockUser('admin-1', 'admin@example.com', 'tournament_admin')
       );
 
@@ -120,11 +120,11 @@ describe('Permissions', () => {
     });
 
     test('should allow club_admin to create tournaments', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
         user: { id: 'admin-1', email: 'admin@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
         createMockUser('admin-1', 'admin@example.com', 'club_admin')
       );
 
@@ -133,11 +133,11 @@ describe('Permissions', () => {
     });
 
     test('should deny player from creating tournaments', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
         user: { id: 'player-1', email: 'player@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
         createMockUser('player-1', 'player@example.com', 'player')
       );
 

src/__tests__/unit/player-deduplication.test.ts

@@ -4,15 +4,15 @@
  * Tests the player deduplication logic for CSV uploads
  */
 
-import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { describe, test, expect, mock, beforeEach } from 'bun:test';
 import { prisma } from '@/lib/prisma';
 
 // Mock the prisma module
-vi.mock('@/lib/prisma', () => ({
+mock.module('@/lib/prisma', () => ({
   prisma: {
     player: {
-      findFirst: vi.fn(),
-      create: vi.fn(),
+      findFirst: mock(() => {}),
+      create: mock(() => {}),
     },
   },
 }));
@@ -46,7 +46,7 @@ async function findOrCreatePlayer(name: string) {
 
 describe('Player Deduplication', () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
   });
 
   describe('findOrCreatePlayer', () => {
@@ -64,7 +64,7 @@ describe('Player Deduplication', () => {
         rating: 0,
       };
 
-      vi.mocked(prisma.player.findFirst).mockResolvedValue(mockPlayer);
+      prisma.player.findFirst.mockImplementation(async () => mockPlayer);
 
       const result = await findOrCreatePlayer('Emily');
 
@@ -89,7 +89,7 @@ describe('Player Deduplication', () => {
         rating: 0,
       };
 
-      vi.mocked(prisma.player.findFirst).mockResolvedValue(mockPlayer);
+      prisma.player.findFirst.mockImplementation(async () => mockPlayer);
 
       const result = await findOrCreatePlayer('EMILY');
 
@@ -114,7 +114,7 @@ describe('Player Deduplication', () => {
         rating: 0,
       };
 
-      vi.mocked(prisma.player.findFirst).mockResolvedValue(mockPlayer);
+      prisma.player.findFirst.mockImplementation(async () => mockPlayer);
 
       const result = await findOrCreatePlayer('  Emily  ');
 
@@ -126,7 +126,7 @@ describe('Player Deduplication', () => {
     });
 
     test('should create new player if not found', async () => {
-      vi.mocked(prisma.player.findFirst).mockResolvedValue(null);
+      prisma.player.findFirst.mockImplementation(async () => null);
 
       const newPlayer = {
         id: 100,
@@ -141,7 +141,7 @@ describe('Player Deduplication', () => {
         updatedAt: new Date(),
       };
 
-      vi.mocked(prisma.player.create).mockResolvedValue(newPlayer);
+      prisma.player.create.mockImplementation(async () => newPlayer);
 
       const result = await findOrCreatePlayer('NewPlayer');
 
@@ -162,7 +162,7 @@ describe('Player Deduplication', () => {
     });
 
     test('should handle names with special characters', async () => {
-      vi.mocked(prisma.player.findFirst).mockResolvedValue(null);
+      prisma.player.findFirst.mockImplementation(async () => null);
 
       const newPlayer = {
         id: 100,
@@ -177,7 +177,7 @@ describe('Player Deduplication', () => {
         updatedAt: new Date(),
       };
 
-      vi.mocked(prisma.player.create).mockResolvedValue(newPlayer);
+      prisma.player.create.mockImplementation(async () => newPlayer);
 
       const result = await findOrCreatePlayer('Test-Player_123');
 
@@ -195,7 +195,7 @@ describe('Player Deduplication', () => {
     });
 
     test('should handle names with spaces', async () => {
-      vi.mocked(prisma.player.findFirst).mockResolvedValue(null);
+      prisma.player.findFirst.mockImplementation(async () => null);
 
       const newPlayer = {
         id: 100,
@@ -210,7 +210,7 @@ describe('Player Deduplication', () => {
         updatedAt: new Date(),
       };
 
-      vi.mocked(prisma.player.create).mockResolvedValue(newPlayer);
+      prisma.player.create.mockImplementation(async () => newPlayer);
 
       const result = await findOrCreatePlayer('Dave B');
 
@@ -242,7 +242,7 @@ describe('Player Deduplication', () => {
         rating: 0,
       };
 
-      vi.mocked(prisma.player.findFirst).mockResolvedValue(mockPlayer);
+      prisma.player.findFirst.mockImplementation(async () => mockPlayer);
 
       const result1 = await findOrCreatePlayer('EMILY');
       const result2 = await findOrCreatePlayer('Emily');
@@ -255,7 +255,7 @@ describe('Player Deduplication', () => {
     });
 
     test('should handle empty or whitespace-only names', async () => {
-      vi.mocked(prisma.player.findFirst).mockResolvedValue(null);
+      prisma.player.findFirst.mockImplementation(async () => null);
 
       const newPlayer = {
         id: 100,
@@ -270,7 +270,7 @@ describe('Player Deduplication', () => {
         updatedAt: new Date(),
       };
 
-      vi.mocked(prisma.player.create).mockResolvedValue(newPlayer);
+      prisma.player.create.mockImplementation(async () => newPlayer);
 
       const result = await findOrCreatePlayer('   ');
 
@@ -320,7 +320,7 @@ describe('Player Deduplication', () => {
         rating: 0,
       };
 
-      vi.mocked(prisma.player.findFirst)
+      prisma.player.findFirst
         .mockResolvedValueOnce(existingPlayer) // First call for "Emily"
         .mockResolvedValueOnce(existingPlayer) // Second call for "EMILY"
         .mockResolvedValueOnce(existingPlayer); // Third call for "  Emily  "

src/__tests__/unit/player-profile.test.ts

@@ -7,24 +7,24 @@
  * - Partnership performance
  */
 
-import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { describe, test, expect, mock, beforeEach } from 'bun:test';
 import { prisma } from '@/lib/prisma';
 import type { Player, Event, Match, PartnershipStat } from '@prisma/client';
 
 // Mock the prisma module
-vi.mock('@/lib/prisma', () => ({
+mock.module('@/lib/prisma', () => ({
   prisma: {
     player: {
-      findUnique: vi.fn(),
+      findUnique: mock(() => {}),
     },
     event: {
-      findMany: vi.fn(),
+      findMany: mock(() => {}),
     },
     match: {
-      findMany: vi.fn(),
+      findMany: mock(() => {}),
     },
     partnershipStat: {
-      findMany: vi.fn(),
+      findMany: mock(() => {}),
     },
   },
 }));
@@ -111,7 +111,7 @@ const createMockPartnershipStat = (
 
 describe('Player Profile Enhancements', () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
   });
 
   describe('Tournaments Participated', () => {
@@ -122,8 +122,8 @@ describe('Player Profile Enhancements', () => {
         createMockTournament(2, 'Tournament B'),
       ];
 
-      vi.mocked(prisma.player.findUnique).mockResolvedValue(mockPlayer);
-      vi.mocked(prisma.event.findMany).mockResolvedValue(mockTournaments);
+      prisma.player.findUnique.mockImplementation(async () => mockPlayer);
+      prisma.event.findMany.mockImplementation(async () => mockTournaments);
 
       // Simulate the query that would be run
       const tournaments = await prisma.event.findMany({
@@ -145,8 +145,8 @@ describe('Player Profile Enhancements', () => {
     test('should return empty array if player has no tournaments', async () => {
       const mockPlayer = createMockPlayer(1, 'Test Player');
 
-      vi.mocked(prisma.player.findUnique).mockResolvedValue(mockPlayer);
-      vi.mocked(prisma.event.findMany).mockResolvedValue([]);
+      prisma.player.findUnique.mockImplementation(async () => mockPlayer);
+      prisma.event.findMany.mockImplementation(async () => []);
 
       const tournaments = await prisma.event.findMany({
         where: {
@@ -173,8 +173,8 @@ describe('Player Profile Enhancements', () => {
         createMockMatch(2, 1, 3, 5, 6, 4, 4),
       ];
 
-      vi.mocked(prisma.player.findUnique).mockResolvedValue(mockPlayer);
-      vi.mocked(prisma.match.findMany).mockResolvedValue(mockMatches);
+      prisma.player.findUnique.mockImplementation(async () => mockPlayer);
+      prisma.match.findMany.mockImplementation(async () => mockMatches);
 
       // Simulate the query that would be run
       const matches = await prisma.match.findMany({
@@ -204,8 +204,8 @@ describe('Player Profile Enhancements', () => {
     test('should return empty array if player has no matches', async () => {
       const mockPlayer = createMockPlayer(1, 'Test Player');
 
-      vi.mocked(prisma.player.findUnique).mockResolvedValue(mockPlayer);
-      vi.mocked(prisma.match.findMany).mockResolvedValue([]);
+      prisma.player.findUnique.mockImplementation(async () => mockPlayer);
+      prisma.match.findMany.mockImplementation(async () => []);
 
       const matches = await prisma.match.findMany({
         where: {
@@ -240,8 +240,8 @@ describe('Player Profile Enhancements', () => {
         createMockPartnershipStat(2, 1, 3, 5, 2, 3),
       ];
 
-      vi.mocked(prisma.player.findUnique).mockResolvedValue(mockPlayer);
-      vi.mocked(prisma.partnershipStat.findMany).mockResolvedValue(mockPartnershipStats);
+      prisma.player.findUnique.mockImplementation(async () => mockPlayer);
+      prisma.partnershipStat.findMany.mockImplementation(async () => mockPartnershipStats);
 
       // Simulate the query that would be run
       const partnershipStats = await prisma.partnershipStat.findMany({
@@ -265,8 +265,8 @@ describe('Player Profile Enhancements', () => {
     test('should return empty array if player has no partnership data', async () => {
       const mockPlayer = createMockPlayer(1, 'Test Player');
 
-      vi.mocked(prisma.player.findUnique).mockResolvedValue(mockPlayer);
-      vi.mocked(prisma.partnershipStat.findMany).mockResolvedValue([]);
+      prisma.player.findUnique.mockImplementation(async () => mockPlayer);
+      prisma.partnershipStat.findMany.mockImplementation(async () => []);
 
       const partnershipStats = await prisma.partnershipStat.findMany({
         where: {

src/__tests__/unit/recalculate-elo.test.ts

@@ -5,33 +5,33 @@
  */
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { describe, test, expect, beforeEach, vi } from 'vitest';
+import { describe, test, expect, beforeEach, mock } from 'bun:test';
 import { recalculateAllElo } from '@/lib/elo-utils';
 
 // Mock Prisma client
 const mockPrisma = {
   player: {
-    updateMany: vi.fn().mockResolvedValue({ count: 0 }),
-    update: vi.fn().mockResolvedValue({}),
+    updateMany: mock(() => {}).mockResolvedValue({ count: 0 }),
+    update: mock(() => {}).mockResolvedValue({}),
   },
   eloSnapshot: {
-    deleteMany: vi.fn().mockResolvedValue({ count: 0 }),
-    create: vi.fn().mockResolvedValue({}),
+    deleteMany: mock(() => {}).mockResolvedValue({ count: 0 }),
+    create: mock(() => {}).mockResolvedValue({}),
   },
   partnershipStat: {
-    deleteMany: vi.fn().mockResolvedValue({ count: 0 }),
-    findFirst: vi.fn().mockResolvedValue(null), // No existing stats initially
-    update: vi.fn().mockResolvedValue({}),
-    create: vi.fn().mockResolvedValue({}),
+    deleteMany: mock(() => {}).mockResolvedValue({ count: 0 }),
+    findFirst: mock(() => {}).mockResolvedValue(null), // No existing stats initially
+    update: mock(() => {}).mockResolvedValue({}),
+    create: mock(() => {}).mockResolvedValue({}),
   },
   match: {
-    findMany: vi.fn().mockResolvedValue([]),
+    findMany: mock(() => {}).mockResolvedValue([]),
   },
 };
 
 describe('recalculateAllElo', () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
   });
 
   test('should reset all player stats to zero', async () => {

src/__tests__/unit/tournament-permissions.test.ts

@@ -5,25 +5,25 @@
  * Regression tests for the issue where tournament_admin users were redirected to login
  */
 
-import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { describe, test, expect, mock, beforeEach } from 'bun:test';
 import { canManageTournament, ownsTournament, getManageableTournaments } from '@/lib/permissions';
 import { getSession } from '@/lib/auth-simple';
 import { prisma } from '@/lib/prisma';
 import type { User, Event } from '@prisma/client';
 
 // Mock the getSession and prisma functions
-vi.mock('@/lib/auth-simple', () => ({
-  getSession: vi.fn(),
+mock.module('@/lib/auth-simple', () => ({
+  getSession: mock(() => {}),
 }));
 
-vi.mock('@/lib/prisma', () => ({
+mock.module('@/lib/prisma', () => ({
   prisma: {
     user: {
-      findUnique: vi.fn(),
+      findUnique: mock(() => {}),
     },
     event: {
-      findUnique: vi.fn(),
-      findMany: vi.fn(),
+      findUnique: mock(() => {}),
+      findMany: mock(() => {}),
     },
   },
 }));
@@ -61,16 +61,16 @@ const createMockTournament = (id: number, ownerId: string | null): Event => ({
 
 describe('Tournament Permissions', () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
   });
 
   describe('canManageTournament', () => {
     test('should allow club_admin to manage any tournament', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
         user: { id: 'admin-1', email: 'admin@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
         createMockUser('admin-1', 'admin@example.com', 'club_admin')
       );
 
@@ -79,14 +79,14 @@ describe('Tournament Permissions', () => {
     });
 
     test('should allow tournament_admin to manage their own tournament', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
         user: { id: 'tour-admin-1', email: 'tour@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
         createMockUser('tour-admin-1', 'tour@example.com', 'tournament_admin')
       );
-      vi.mocked(prisma.event.findUnique).mockResolvedValue(
+      prisma.event.findUnique.mockImplementation(async () => 
         createMockTournament(1, 'tour-admin-1')
       );
 
@@ -95,14 +95,14 @@ describe('Tournament Permissions', () => {
     });
 
     test('should deny tournament_admin from managing other users tournaments', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
         user: { id: 'tour-admin-1', email: 'tour@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
         createMockUser('tour-admin-1', 'tour@example.com', 'tournament_admin')
       );
-      vi.mocked(prisma.event.findUnique).mockResolvedValue(
+      prisma.event.findUnique.mockImplementation(async () => 
         createMockTournament(1, 'other-user-1')
       );
 
@@ -112,11 +112,11 @@ describe('Tournament Permissions', () => {
     });
 
     test('should deny player from managing tournaments', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
         user: { id: 'player-1', email: 'player@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
         createMockUser('player-1', 'player@example.com', 'player')
       );
 
@@ -126,7 +126,7 @@ describe('Tournament Permissions', () => {
     });
 
     test('should deny unauthenticated user', async () => {
-      vi.mocked(getSession).mockResolvedValue(null);
+      getSession.mockImplementation(async () => null);
 
       const result = await canManageTournament(999);
       expect(result.allowed).toBe(false);
@@ -136,11 +136,11 @@ describe('Tournament Permissions', () => {
 
   describe('ownsTournament', () => {
     test('should return true if user owns tournament', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
         user: { id: 'owner-1', email: 'owner@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.event.findUnique).mockResolvedValue(
+      }));
+      prisma.event.findUnique.mockImplementation(async () => 
         createMockTournament(1, 'owner-1')
       );
 
@@ -149,11 +149,11 @@ describe('Tournament Permissions', () => {
     });
 
     test('should return false if user does not own tournament', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
         user: { id: 'non-owner-1', email: 'nonowner@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.event.findUnique).mockResolvedValue(
+      }));
+      prisma.event.findUnique.mockImplementation(async () => 
         createMockTournament(1, 'owner-1')
       );
 
@@ -165,11 +165,11 @@ describe('Tournament Permissions', () => {
 
   describe('getManageableTournaments', () => {
     test('should return all tournaments for club_admin', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
         user: { id: 'admin-1', email: 'admin@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
         createMockUser('admin-1', 'admin@example.com', 'club_admin')
       );
       
@@ -178,7 +178,7 @@ describe('Tournament Permissions', () => {
         createMockTournament(2, 'user-2'),
         createMockTournament(3, 'user-3'),
       ];
-      vi.mocked(prisma.event.findMany).mockResolvedValue(mockTournaments);
+      prisma.event.findMany.mockImplementation(async () => mockTournaments);
 
       const result = await getManageableTournaments();
       expect(result).toEqual(mockTournaments);
@@ -190,11 +190,11 @@ describe('Tournament Permissions', () => {
     });
 
     test('should return only owned tournaments for tournament_admin', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
         user: { id: 'tour-admin-1', email: 'tour@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
         createMockUser('tour-admin-1', 'tour@example.com', 'tournament_admin')
       );
       
@@ -202,7 +202,7 @@ describe('Tournament Permissions', () => {
         createMockTournament(1, 'tour-admin-1'),
         createMockTournament(2, 'tour-admin-1'),
       ];
-      vi.mocked(prisma.event.findMany).mockResolvedValue(mockTournaments);
+      prisma.event.findMany.mockImplementation(async () => mockTournaments);
 
       const result = await getManageableTournaments();
       expect(result).toEqual(mockTournaments);
@@ -217,11 +217,11 @@ describe('Tournament Permissions', () => {
     });
 
     test('should return only non-draft tournaments for players', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
         user: { id: 'player-1', email: 'player@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
         createMockUser('player-1', 'player@example.com', 'player')
       );
       
@@ -229,7 +229,7 @@ describe('Tournament Permissions', () => {
         createMockTournament(1, 'user-1'),
         createMockTournament(2, 'user-2'),
       ];
-      vi.mocked(prisma.event.findMany).mockResolvedValue(mockTournaments);
+      prisma.event.findMany.mockImplementation(async () => mockTournaments);
 
       const result = await getManageableTournaments();
       expect(result).toEqual(mockTournaments);
@@ -249,14 +249,14 @@ describe('Tournament Permissions', () => {
       // This simulates the scenario where a tournament_admin user
       // clicks "Edit" on a tournament they own
       
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
         user: { id: 'tour-admin-1', email: 'tour@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
         createMockUser('tour-admin-1', 'tour@example.com', 'tournament_admin')
       );
-      vi.mocked(prisma.event.findUnique).mockResolvedValue(
+      prisma.event.findUnique.mockImplementation(async () => 
         createMockTournament(1, 'tour-admin-1')
       );
 
@@ -271,11 +271,11 @@ describe('Tournament Permissions', () => {
     test('club_admin should still be able to manage any tournament', async () => {
       // This ensures we didn't break the existing club_admin functionality
       
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
         user: { id: 'club-admin-1', email: 'club@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
         createMockUser('club-admin-1', 'club@example.com', 'club_admin')
       );
 
@@ -286,11 +286,11 @@ describe('Tournament Permissions', () => {
     test('players should still be denied from managing tournaments', async () => {
       // This ensures we didn't accidentally grant players access
       
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
         user: { id: 'player-1', email: 'player@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+      }));
+      prisma.user.findUnique.mockImplementation(async () => 
         createMockUser('player-1', 'player@example.com', 'player')
       );
 

src/__tests__/unit/tournament-update.test.ts

@@ -3,23 +3,23 @@
  * Tests the allowTies field is properly saved when updating tournaments
  */
 
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, mock, beforeEach } from 'bun:test';
 import { prisma } from '@/lib/prisma';
 
 // Mock the prisma client
-vi.mock('@/lib/prisma', () => ({
+mock.module('@/lib/prisma', () => ({
   prisma: {
     event: {
-      findUnique: vi.fn(),
-      update: vi.fn(),
+      findUnique: mock(() => {}),
+      update: mock(() => {}),
     },
   },
 }));
 
 // Mock the permissions module
-vi.mock('@/lib/permissions', () => ({
-  canManageTournament: vi.fn().mockResolvedValue({ allowed: true }),
-  canDeleteTournament: vi.fn().mockResolvedValue({ allowed: true }),
+mock.module('@/lib/permissions', () => ({
+  canManageTournament: mock(() => {}).mockResolvedValue({ allowed: true }),
+  canDeleteTournament: mock(() => {}).mockResolvedValue({ allowed: true }),
 }));
 
 // Import the route handler after mocking
@@ -27,12 +27,12 @@ import { PUT } from '@/app/api/tournaments/[id]/route';
 
 describe('Tournament Update API', () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
   });
 
   it('should update allowTies field when provided', async () => {
     // Mock existing tournament
-    vi.mocked(prisma.event.findUnique).mockResolvedValue({
+    prisma.event.findUnique.mockImplementation(async () => ({
       id: 1,
       name: 'Test Tournament',
       allowTies: false,
@@ -46,10 +46,10 @@ describe('Tournament Update API', () => {
       ownerId: null,
       createdAt: new Date(),
       updatedAt: new Date(),
-    } as any);
+      } as any));
 
     // Mock successful update
-    vi.mocked(prisma.event.update).mockResolvedValue({
+    prisma.event.update.mockImplementation(async () => ({
       id: 1,
       name: 'Test Tournament',
       allowTies: true,
@@ -63,7 +63,7 @@ describe('Tournament Update API', () => {
       ownerId: null,
       createdAt: new Date(),
       updatedAt: new Date(),
-    } as any);
+      } as any));
 
     const request = new Request('http://localhost/api/tournaments/1', {
       method: 'PUT',
@@ -78,7 +78,7 @@ describe('Tournament Update API', () => {
     const response = await PUT(request, { params });
 
     expect(response.status).toBe(200);
-    expect(vi.mocked(prisma.event.update)).toHaveBeenCalledWith(
+    expect(prisma.event.update).toHaveBeenCalledWith(
       expect.objectContaining({
         data: expect.objectContaining({
           allowTies: true,
@@ -89,7 +89,7 @@ describe('Tournament Update API', () => {
 
   it('should default allowTies to false when not provided', async () => {
     // Mock existing tournament
-    vi.mocked(prisma.event.findUnique).mockResolvedValue({
+    prisma.event.findUnique.mockImplementation(async () => ({
       id: 1,
       name: 'Test Tournament',
       allowTies: true,
@@ -103,10 +103,10 @@ describe('Tournament Update API', () => {
       ownerId: null,
       createdAt: new Date(),
       updatedAt: new Date(),
-    } as any);
+      } as any));
 
     // Mock successful update
-    vi.mocked(prisma.event.update).mockResolvedValue({
+    prisma.event.update.mockImplementation(async () => ({
       id: 1,
       name: 'Test Tournament',
       allowTies: false,
@@ -120,7 +120,7 @@ describe('Tournament Update API', () => {
       ownerId: null,
       createdAt: new Date(),
       updatedAt: new Date(),
-    } as any);
+      } as any));
 
     const request = new Request('http://localhost/api/tournaments/1', {
       method: 'PUT',
@@ -135,7 +135,7 @@ describe('Tournament Update API', () => {
     const response = await PUT(request, { params });
 
     expect(response.status).toBe(200);
-    expect(vi.mocked(prisma.event.update)).toHaveBeenCalledWith(
+    expect(prisma.event.update).toHaveBeenCalledWith(
       expect.objectContaining({
         data: expect.objectContaining({
           allowTies: false, // Should default to false
@@ -146,7 +146,7 @@ describe('Tournament Update API', () => {
 
   it('should preserve allowTies value when updating other fields', async () => {
     // Mock existing tournament with allowTies = true
-    vi.mocked(prisma.event.findUnique).mockResolvedValue({
+    prisma.event.findUnique.mockImplementation(async () => ({
       id: 1,
       name: 'Test Tournament',
       allowTies: true,
@@ -160,10 +160,10 @@ describe('Tournament Update API', () => {
       ownerId: null,
       createdAt: new Date(),
       updatedAt: new Date(),
-    } as any);
+      } as any));
 
     // Mock successful update
-    vi.mocked(prisma.event.update).mockResolvedValue({
+    prisma.event.update.mockImplementation(async () => ({
       id: 1,
       name: 'Updated Tournament Name',
       allowTies: true,
@@ -177,7 +177,7 @@ describe('Tournament Update API', () => {
       ownerId: null,
       createdAt: new Date(),
       updatedAt: new Date(),
-    } as any);
+      } as any));
 
     const request = new Request('http://localhost/api/tournaments/1', {
       method: 'PUT',
@@ -192,7 +192,7 @@ describe('Tournament Update API', () => {
     const response = await PUT(request, { params });
 
     expect(response.status).toBe(200);
-    const updateCall = vi.mocked(prisma.event.update).mock.calls[0][0];
+    const updateCall = prisma.event.update.mock.calls[0][0];
     expect(updateCall.data.allowTies).toBe(true);
     expect(updateCall.data.name).toBe('Updated Tournament Name');
     expect(updateCall.data.targetScore).toBe(10);

src/__tests__/unit/user-management.test.ts

@@ -4,25 +4,25 @@
  * Tests for user name editing and profile management
  */
 
-import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { describe, test, expect, mock, beforeEach } from 'bun:test';
 import { hasRole } from '@/lib/permissions';
 import { getSession } from '@/lib/auth-simple';
 import { prisma } from '@/lib/prisma';
 import type { User, Player } from '@prisma/client';
 
 // Mock the getSession and prisma functions
-vi.mock('@/lib/auth-simple', () => ({
-  getSession: vi.fn(),
+mock.module('@/lib/auth-simple', () => ({
+  getSession: mock(() => {}),
 }));
 
-vi.mock('@/lib/prisma', () => ({
+mock.module('@/lib/prisma', () => ({
   prisma: {
     user: {
-      findUnique: vi.fn(),
-      update: vi.fn(),
+      findUnique: mock(() => {}),
+      update: mock(() => {}),
     },
     player: {
-      findUnique: vi.fn(),
+      findUnique: mock(() => {}),
     },
   },
 }));
@@ -56,16 +56,16 @@ const createMockPlayer = (id: number, name: string): Player => ({
 
 describe('User Management', () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
   });
 
   describe('User Name Editing', () => {
     test('club_admin should be able to edit any user name', async () => {
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
         user: { id: 'admin-1', email: 'admin@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+        }));
+      prisma.user.findUnique.mockImplementation(async () => 
         createMockUser('admin-1', 'admin@example.com', 'club_admin')
       );
 
@@ -74,11 +74,11 @@ describe('User Management', () => {
     });
 
     test('tournament_admin should NOT be able to edit user names', async () => {
-      vi.mocked(getSession).mockResolvedValue({
-        user: { id: 'tour-admin-1', email: 'tour@example.com' },
+      getSession.mockImplementation(async () => ({
+        user: { id: 'admin-1', email: 'admin@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+        }));
+      prisma.user.findUnique.mockImplementation(async () => 
         createMockUser('tour-admin-1', 'tour@example.com', 'tournament_admin')
       );
 
@@ -87,11 +87,11 @@ describe('User Management', () => {
     });
 
     test('player should NOT be able to edit user names', async () => {
-      vi.mocked(getSession).mockResolvedValue({
-        user: { id: 'player-1', email: 'player@example.com' },
+      getSession.mockImplementation(async () => ({
+        user: { id: 'admin-1', email: 'admin@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(
+        }));
+      prisma.user.findUnique.mockImplementation(async () => 
         createMockUser('player-1', 'player@example.com', 'player')
       );
 
@@ -100,7 +100,7 @@ describe('User Management', () => {
     });
 
     test('unauthenticated user should NOT be able to edit user names', async () => {
-      vi.mocked(getSession).mockResolvedValue(null);
+      getSession.mockImplementation(async () => null);
 
       const result = await hasRole('club_admin');
       expect(result.allowed).toBe(false);
@@ -111,11 +111,11 @@ describe('User Management', () => {
     test('user should be able to view their own profile', async () => {
       const mockUser = createMockUser('user-1', 'user@example.com', 'player');
       
-      vi.mocked(getSession).mockResolvedValue({
-        user: { id: 'user-1', email: 'user@example.com' },
+      getSession.mockImplementation(async () => ({
+        user: { id: 'admin-1', email: 'admin@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(mockUser);
+        }));
+      prisma.user.findUnique.mockImplementation(async () => mockUser);
 
       // In the actual implementation, this would check if session.user.id === params.id
       const canViewOwnProfile = true; // This logic is in the API route
@@ -126,11 +126,11 @@ describe('User Management', () => {
       const mockAdmin = createMockUser('admin-1', 'admin@example.com', 'club_admin');
       const mockUser = createMockUser('user-1', 'user@example.com', 'player');
       
-      vi.mocked(getSession).mockResolvedValue({
+      getSession.mockImplementation(async () => ({
         user: { id: 'admin-1', email: 'admin@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique)
+        }));
+      (prisma.user.findUnique)
         .mockResolvedValueOnce(mockAdmin) // For the requesting user
         .mockResolvedValueOnce(mockUser); // For the target user
 
@@ -142,11 +142,11 @@ describe('User Management', () => {
     test('non-admin should NOT be able to view other user profiles', async () => {
       const mockUser = createMockUser('user-1', 'user@example.com', 'player');
       
-      vi.mocked(getSession).mockResolvedValue({
-        user: { id: 'user-1', email: 'user@example.com' },
+      getSession.mockImplementation(async () => ({
+        user: { id: 'admin-1', email: 'admin@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(mockUser);
+        }));
+      prisma.user.findUnique.mockImplementation(async () => mockUser);
 
       // In the actual implementation, this would check if session.user.id === params.id
       const canViewOtherProfile = false; // This logic is in the API route
@@ -159,11 +159,11 @@ describe('User Management', () => {
       const mockUser = createMockUser('user-1', 'user@example.com', 'club_admin');
       const mockPlayer = createMockPlayer(1, 'Old Name');
       
-      vi.mocked(getSession).mockResolvedValue({
-        user: { id: 'user-1', email: 'user@example.com' },
+      getSession.mockImplementation(async () => ({
+        user: { id: 'admin-1', email: 'admin@example.com' },
         session: { token: 'test', expiresAt: new Date() }
-      });
-      vi.mocked(prisma.user.findUnique).mockResolvedValue(mockUser);
+        }));
+      prisma.user.findUnique.mockImplementation(async () => mockUser);
       
       const updatedUser = {
         ...mockUser,
@@ -171,7 +171,7 @@ describe('User Management', () => {
         player: { ...mockPlayer, name: 'New Name', normalizedName: 'new name' }
       };
       
-      vi.mocked(prisma.user.update).mockResolvedValue(updatedUser);
+      prisma.user.update.mockImplementation(async () => updatedUser);
 
       // The API route should update both user.name and player.name
       expect(updatedUser.name).toBe('New Name');

src/app/admin/matches/page.tsx

@@ -168,13 +168,21 @@ export default function AdminMatchesPage() {
                       {match.team2Score}
                     </td>
                     <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-500">
-                      <button
-                        onClick={() => handleDelete(match.id)}
-                        disabled={deletingId === match.id}
-                        className="text-red-600 hover:text-red-900 disabled:opacity-50"
-                      >
-                        {deletingId === match.id ? "Deleting..." : "Delete"}
-                      </button>
+                      <div className="flex gap-3">
+                        <Link
+                          href={`/matches/${match.id}`}
+                          className="text-blue-600 hover:text-blue-900"
+                        >
+                          View
+                        </Link>
+                        <button
+                          onClick={() => handleDelete(match.id)}
+                          disabled={deletingId === match.id}
+                          className="text-red-600 hover:text-red-900 disabled:opacity-50"
+                        >
+                          {deletingId === match.id ? "Deleting..." : "Delete"}
+                        </button>
+                      </div>
                     </td>
                   </tr>
                 ))}

src/lib/prisma.ts

@@ -1,20 +1,38 @@
 import { PrismaClient } from '@prisma/client'
-import { PrismaPg } from '@prisma/adapter-pg'
-import pg from 'pg'
-import dotenv from 'dotenv'
 
 // Load .env file if it exists
-dotenv.config()
+require('dotenv').config()
 
 const globalForPrisma = globalThis as unknown as {
   prisma: PrismaClient | undefined
 }
 
-const adapter = new PrismaPg({ connectionString: process.env.DATABASE_URL })
+// Detect database provider from environment (default to sqlite for local development)
+const databaseProvider = process.env.DATABASE_PROVIDER || 'sqlite'
+const databaseUrl = process.env.DATABASE_URL
 
-// Create PrismaClient with adapter
+// Create PrismaClient with appropriate adapter
 const createPrismaClient = () => {
-  const client = new PrismaClient({ adapter })
+  let client: PrismaClient
+  
+  if (databaseProvider === 'postgresql') {
+    // Validate DATABASE_URL is present for PostgreSQL
+    if (!databaseUrl) {
+      throw new Error(
+        'DATABASE_URL environment variable is required when DATABASE_PROVIDER is set to postgresql. ' +
+        'Current DATABASE_PROVIDER: ' + databaseProvider
+      )
+    }
+    
+    // Use PrismaPg adapter for PostgreSQL
+    const { PrismaPg } = require('@prisma/adapter-pg')
+    const adapter = new PrismaPg({ connectionString: databaseUrl })
+    client = new PrismaClient({ adapter })
+  } else {
+    // No adapter needed for SQLite
+    client = new PrismaClient()
+  }
+  
   return client
 }