@commonpub/server 2.89.0 → 2.90.0

package/dist/contest/contest.js

@@ -1,187 +1,12 @@
-import { eq, ne, and, or, desc, sql, isNotNull, inArray } from 'drizzle-orm';
-import { contests, contestEntries, contestJudges, contestStakeholders, users, contentItems } from '@commonpub/schema';
-import { normalizePagination, countRows } from '../query.js';
-import { isContestStakeholder, isContestEditor } from './stakeholders.js';
-import { isContestJudge } from './judges.js';
-const toIso = (d) => d ? new Date(d).toISOString() : undefined;
-/**
- * The classic Submissions → Judging → Results timeline, synthesized from the
- * status + date columns for contests that haven't defined explicit stages.
- * Stable ids let `currentStageId` reference them even for legacy contests.
- */
-export function synthesizeStages(c) {
-    return [
-        { id: 'core-submission', name: 'Submissions', kind: 'submission', core: true, startsAt: toIso(c.startDate), endsAt: toIso(c.endDate) },
-        { id: 'core-review', name: 'Judging', kind: 'review', core: true, endsAt: toIso(c.judgingEndDate) ?? toIso(c.endDate) },
-        { id: 'core-results', name: 'Results', kind: 'results', core: true },
-    ];
-}
-/**
- * The contest's stage timeline: its explicit `stages` if any are defined,
- * otherwise the synthesized classic flow. The standard flow is the zero-config
- * default — a contest with no `stages` renders identically to pre-B1.
- */
-export function normalizeStages(c) {
-    return c.stages && c.stages.length > 0 ? c.stages : synthesizeStages(c);
-}
-/**
- * The stage that is currently "now": the one `currentStageId` points at (if it
- * resolves), else derived from the coarse `status`. Null while draft/cancelled
- * (nothing is running). `status` remains the behavioural source of truth for
- * gating; this is for DISPLAY (hero pill, sidebar highlight, countdown label).
- */
-export function currentStage(c) {
-    const stages = normalizeStages(c);
-    if (c.currentStageId) {
-        const found = stages.find((s) => s.id === c.currentStageId);
-        if (found)
-            return found;
-    }
-    switch (c.status) {
-        case 'draft':
-        case 'cancelled':
-            return null;
-        case 'completed':
-            return stages.find((s) => s.kind === 'results') ?? stages[stages.length - 1] ?? null;
-        case 'judging':
-            return stages.find((s) => s.kind === 'review') ?? null;
-        default: // upcoming | active | paused
-            return stages.find((s) => s.kind === 'submission') ?? stages[0] ?? null;
-    }
-}
-export async function listContests(db, filters = {}, viewer) {
-    const conditions = [];
-    if (filters.status) {
-        conditions.push(eq(contests.status, filters.status));
-    }
-    // Visibility: admins see everything. Everyone else sees `public` contests,
-    // plus — when signed in — the ones they have a relationship to so they're not
-    // hidden in the listing: their own, ones they review (stakeholder), ones they
-    // judge, and private ones whose `visibleToRoles` includes their role. (`unlisted`
-    // stays link-only; mirrors canViewContest so the listing matches per-contest access.)
-    if (viewer?.role !== 'admin') {
-        const visConds = [eq(contests.visibility, 'public')];
-        if (viewer?.userId) {
-            visConds.push(eq(contests.createdById, viewer.userId));
-            visConds.push(inArray(contests.id, db.select({ id: contestStakeholders.contestId }).from(contestStakeholders).where(eq(contestStakeholders.userId, viewer.userId))));
-            visConds.push(inArray(contests.id, db.select({ id: contestJudges.contestId }).from(contestJudges).where(eq(contestJudges.userId, viewer.userId))));
-        }
-        if (viewer?.role) {
-            visConds.push(sql `${contests.visibleToRoles} @> ${JSON.stringify([viewer.role])}::jsonb`);
-        }
-        conditions.push(visConds.length > 1 ? or(...visConds) : visConds[0]);
-        // Drafts never appear in listings except to their own owner (admins, handled
-        // above, see everything). Orthogonal to visibility — a public draft is still hidden.
-        conditions.push(viewer?.userId
-            ? or(ne(contests.status, 'draft'), eq(contests.createdById, viewer.userId))
-            : ne(contests.status, 'draft'));
-    }
-    const where = conditions.length > 0 ? and(...conditions) : undefined;
-    const { limit, offset } = normalizePagination(filters);
-    const [rows, total] = await Promise.all([
-        db
-            .select()
-            .from(contests)
-            .where(where)
-            .orderBy(desc(contests.startDate))
-            .limit(limit)
-            .offset(offset),
-        countRows(db, contests, where),
-    ]);
-    const items = rows.map((row) => ({
-        id: row.id,
-        title: row.title,
-        slug: row.slug,
-        subheading: row.subheading,
-        description: row.description,
-        bannerUrl: row.bannerUrl,
-        coverImageUrl: row.coverImageUrl,
-        status: row.status,
-        startDate: row.startDate,
-        endDate: row.endDate,
-        entryCount: row.entryCount,
-        createdAt: row.createdAt,
-    }));
-    return { items, total };
-}
-function toContestDetail(row) {
-    return {
-        id: row.id,
-        title: row.title,
-        slug: row.slug,
-        description: row.description,
-        bannerUrl: row.bannerUrl,
-        coverImageUrl: row.coverImageUrl,
-        status: row.status,
-        startDate: row.startDate,
-        endDate: row.endDate,
-        entryCount: row.entryCount,
-        createdAt: row.createdAt,
-        subheading: row.subheading,
-        rules: row.rules,
-        prizesDescription: row.prizesDescription,
-        descriptionFormat: row.descriptionFormat,
-        rulesFormat: row.rulesFormat,
-        prizesDescriptionFormat: row.prizesDescriptionFormat,
-        showPrizes: row.showPrizes,
-        stages: row.stages ?? [],
-        currentStageId: row.currentStageId ?? null,
-        prizes: row.prizes ?? null,
-        judgingCriteria: row.judgingCriteria ?? null,
-        judgingVisibility: row.judgingVisibility,
-        judgingEndDate: row.judgingEndDate,
-        communityVotingEnabled: row.communityVotingEnabled,
-        eligibleContentTypes: row.eligibleContentTypes ?? null,
-        maxEntriesPerUser: row.maxEntriesPerUser ?? null,
-        visibility: row.visibility,
-        visibleToRoles: row.visibleToRoles ?? null,
-        createdById: row.createdById,
-    };
-}
-/**
- * Whether `user` may view this contest. `public`/`unlisted` are viewable by
- * anyone (unlisted is simply hidden from listings). `private` is restricted to
- * the owner, admins, stakeholders, panel judges, and users whose role is in
- * `visibleToRoles`.
- */
-export async function canViewContest(db, contest, user) {
-    // Drafts are owner-only regardless of the visibility setting — an unlaunched
-    // contest must never be world-readable, even when its visibility is `public`.
-    if (contest.status === 'draft') {
-        if (!user)
-            return false;
-        if (user.id === contest.createdById || user.role === 'admin')
-            return true;
-        if (await isContestStakeholder(db, contest.id, user.id))
-            return true;
-        if (await isContestJudge(db, contest.id, user.id))
-            return true;
-        return false;
-    }
-    if (contest.visibility !== 'private')
-        return true;
-    if (!user)
-        return false;
-    if (user.id === contest.createdById || user.role === 'admin')
-        return true;
-    if (contest.visibleToRoles && contest.visibleToRoles.includes(user.role))
-        return true;
-    if (await isContestStakeholder(db, contest.id, user.id))
-        return true;
-    if (await isContestJudge(db, contest.id, user.id))
-        return true;
-    return false;
-}
-export async function getContestBySlug(db, slug) {
-    const rows = await db
-        .select()
-        .from(contests)
-        .where(eq(contests.slug, slug))
-        .limit(1);
-    if (rows.length === 0)
-        return null;
-    return toContestDetail(rows[0]);
-}
+import { eq, and, isNotNull } from 'drizzle-orm';
+import { contests, contestEntries, contestJudges, contestStakeholders } from '@commonpub/schema';
+import { isContestEditor } from './stakeholders.js';
+import { toContestDetail, getContestBySlug } from './read.js';
+import { calculateContestRanks } from './entries.js';
+// Contest CRUD + lifecycle. The read/listing path lives in entries.ts, the pure
+// stage helpers in stages.ts, judging/advancement in judging.ts, and the
+// per-stage submission + proposal flows in submissions.ts. This module owns the
+// create/update/delete writers and the status state machine.
 /**
  * Check if a user role is allowed to create contests based on the instance policy.
  *
@@ -203,54 +28,63 @@ export async function createContest(db, input, options) {
             throw new Error(`Insufficient permissions: contest creation requires ${policy} role`);
         }
     }
-    const [row] = await db
-        .insert(contests)
-        .values({
-        title: input.title,
-        slug: input.slug,
-        subheading: input.subheading ?? null,
-        description: input.description ?? null,
-        rules: input.rules ?? null,
-        prizesDescription: input.prizesDescription ?? null,
-        descriptionFormat: input.descriptionFormat ?? 'markdown',
-        rulesFormat: input.rulesFormat ?? 'markdown',
-        prizesDescriptionFormat: input.prizesDescriptionFormat ?? 'markdown',
-        showPrizes: input.showPrizes ?? true,
-        stages: input.stages ?? [],
-        // Only keep currentStageId if it references a stage that actually exists.
-        currentStageId: input.currentStageId && (input.stages ?? []).some((s) => s.id === input.currentStageId) ? input.currentStageId : null,
-        bannerUrl: input.bannerUrl ?? null,
-        coverImageUrl: input.coverImageUrl ?? null,
-        prizes: input.prizes ?? null,
-        judgingCriteria: input.judgingCriteria ?? null,
-        communityVotingEnabled: input.communityVotingEnabled ?? false,
-        judgingVisibility: input.judgingVisibility ?? 'judges-only',
-        eligibleContentTypes: input.eligibleContentTypes ?? null,
-        maxEntriesPerUser: input.maxEntriesPerUser ?? null,
-        visibility: input.visibility ?? 'public',
-        visibleToRoles: input.visibleToRoles ?? null,
-        startDate: new Date(input.startDate),
-        endDate: new Date(input.endDate),
-        judgingEndDate: input.judgingEndDate ? new Date(input.judgingEndDate) : null,
-        createdById: input.createdBy,
-    })
-        .returning();
-    // Single source of truth: seed the contest_judges table from any judge IDs
-    // provided at creation. The legacy `judges` jsonb column is no longer written
-    // or read — authorization + display use the table exclusively.
-    if (input.judges && input.judges.length > 0) {
-        await db
-            .insert(contestJudges)
-            .values(input.judges.map((userId) => ({ contestId: row.id, userId })))
-            .onConflictDoNothing();
-    }
-    // Seed stakeholders (view-only reviewers) from create input.
-    if (input.stakeholders && input.stakeholders.length > 0) {
-        await db
-            .insert(contestStakeholders)
-            .values(input.stakeholders.map((userId) => ({ contestId: row.id, userId })))
-            .onConflictDoNothing();
-    }
+    // Atomic: the contest row and its seeded judges/stakeholders must commit
+    // together, so a failed seed (e.g. a bad judge id) can't leave a contest
+    // missing the judges/reviewers the organizer asked for.
+    const row = await db.transaction(async (tx) => {
+        const [inserted] = await tx
+            .insert(contests)
+            .values({
+            title: input.title,
+            slug: input.slug,
+            subheading: input.subheading ?? null,
+            description: input.description ?? null,
+            rules: input.rules ?? null,
+            prizesDescription: input.prizesDescription ?? null,
+            descriptionFormat: input.descriptionFormat ?? 'markdown',
+            rulesFormat: input.rulesFormat ?? 'markdown',
+            prizesDescriptionFormat: input.prizesDescriptionFormat ?? 'markdown',
+            descriptionBlocks: input.descriptionBlocks ?? null,
+            rulesBlocks: input.rulesBlocks ?? null,
+            prizesBlocks: input.prizesBlocks ?? null,
+            showPrizes: input.showPrizes ?? true,
+            stages: input.stages ?? [],
+            // Only keep currentStageId if it references a stage that actually exists.
+            currentStageId: input.currentStageId && (input.stages ?? []).some((s) => s.id === input.currentStageId) ? input.currentStageId : null,
+            bannerUrl: input.bannerUrl ?? null,
+            coverImageUrl: input.coverImageUrl ?? null,
+            prizes: input.prizes ?? null,
+            judgingCriteria: input.judgingCriteria ?? null,
+            communityVotingEnabled: input.communityVotingEnabled ?? false,
+            judgingVisibility: input.judgingVisibility ?? 'judges-only',
+            eligibleContentTypes: input.eligibleContentTypes ?? null,
+            maxEntriesPerUser: input.maxEntriesPerUser ?? null,
+            visibility: input.visibility ?? 'public',
+            visibleToRoles: input.visibleToRoles ?? null,
+            startDate: new Date(input.startDate),
+            endDate: new Date(input.endDate),
+            judgingEndDate: input.judgingEndDate ? new Date(input.judgingEndDate) : null,
+            createdById: input.createdBy,
+        })
+            .returning();
+        // Single source of truth: seed the contest_judges table from any judge IDs
+        // provided at creation. The legacy `judges` jsonb column is no longer written
+        // or read — authorization + display use the table exclusively.
+        if (input.judges && input.judges.length > 0) {
+            await tx
+                .insert(contestJudges)
+                .values(input.judges.map((userId) => ({ contestId: inserted.id, userId })))
+                .onConflictDoNothing();
+        }
+        // Seed stakeholders (view-only reviewers) from create input.
+        if (input.stakeholders && input.stakeholders.length > 0) {
+            await tx
+                .insert(contestStakeholders)
+                .values(input.stakeholders.map((userId) => ({ contestId: inserted.id, userId })))
+                .onConflictDoNothing();
+        }
+        return inserted;
+    });
     return toContestDetail(row);
 }
 /**
@@ -286,6 +120,12 @@ export async function updateContest(db, slug, userId, data, canManage = false) {
         updates.rulesFormat = data.rulesFormat;
     if (data.prizesDescriptionFormat !== undefined)
         updates.prizesDescriptionFormat = data.prizesDescriptionFormat;
+    if (data.descriptionBlocks !== undefined)
+        updates.descriptionBlocks = data.descriptionBlocks;
+    if (data.rulesBlocks !== undefined)
+        updates.rulesBlocks = data.rulesBlocks;
+    if (data.prizesBlocks !== undefined)
+        updates.prizesBlocks = data.prizesBlocks;
     if (data.bannerUrl !== undefined)
         updates.bannerUrl = data.bannerUrl;
     if (data.coverImageUrl !== undefined)
@@ -340,361 +180,6 @@ export async function updateContest(db, slug, userId, data, canManage = false) {
     await db.update(contests).set(updates).where(eq(contests.slug, slug));
     return getContestBySlug(db, finalSlug);
 }
-/**
- * Decide whether a viewer may see aggregate entry scores, honouring the
- * contest's `judgingVisibility` setting. Pure + exhaustively testable.
- *
- * - Privileged viewers (owner / admin / panel judge) always see scores.
- * - `public`     → scores visible to everyone (during judging and after).
- * - `judges-only`→ scores hidden from the public until the contest completes.
- * - `private`    → aggregate scores never exposed to the public (ranks may
- *                  still be shown so winners can be announced).
- */
-export function shouldRevealScores(visibility, status, privileged) {
-    if (privileged)
-        return true;
-    if (visibility === 'public')
-        return true;
-    if (visibility === 'private')
-        return false;
-    return status === 'completed';
-}
-export async function listContestEntries(db, contestId, opts = {}) {
-    const revealScores = opts.revealScores ?? true;
-    const { limit, offset } = normalizePagination(opts);
-    const where = eq(contestEntries.contestId, contestId);
-    // `rank`: ranked entries first (1,2,3…), unranked last; ties broken by score
-    // then recency. `recent`: submission order (default).
-    const order = opts.orderBy === 'rank'
-        ? [
-            sql `${contestEntries.rank} asc nulls last`,
-            sql `${contestEntries.score} desc nulls last`,
-            desc(contestEntries.submittedAt),
-        ]
-        : [desc(contestEntries.submittedAt)];
-    const [rows, total] = await Promise.all([
-        db
-            .select({
-            entry: contestEntries,
-            content: {
-                title: contentItems.title,
-                slug: contentItems.slug,
-                type: contentItems.type,
-                coverImageUrl: contentItems.coverImageUrl,
-            },
-            author: {
-                displayName: users.displayName,
-                username: users.username,
-                avatarUrl: users.avatarUrl,
-            },
-        })
-            .from(contestEntries)
-            .innerJoin(contentItems, eq(contestEntries.contentId, contentItems.id))
-            .innerJoin(users, eq(contestEntries.userId, users.id))
-            .where(where)
-            .orderBy(...order)
-            .limit(limit)
-            .offset(offset),
-        countRows(db, contestEntries, where),
-    ]);
-    const items = rows.map((row) => {
-        const item = {
-            id: row.entry.id,
-            contestId: row.entry.contestId,
-            contentId: row.entry.contentId,
-            userId: row.entry.userId,
-            score: revealScores ? row.entry.score : null,
-            rank: row.entry.rank,
-            // The cohort outcome (advanced/eliminated) is public, but the per-round
-            // snapshot SCORE honours revealScores like the live aggregate — otherwise
-            // a judges-only/private contest leaks round scores through the snapshots.
-            // Rank stays (mirrors the always-exposed top-level rank, so winners can
-            // be announced).
-            stageState: revealScores
-                ? row.entry.stageState ?? []
-                : (row.entry.stageState ?? []).map((s) => ({ ...s, score: null })),
-            eliminated: isEliminated(row.entry),
-            submittedAt: row.entry.submittedAt,
-            contentTitle: row.content.title,
-            contentSlug: row.content.slug,
-            contentType: row.content.type,
-            contentCoverImageUrl: row.content.coverImageUrl,
-            authorName: row.author.displayName ?? row.author.username,
-            authorUsername: row.author.username,
-            authorAvatarUrl: row.author.avatarUrl,
-        };
-        if (opts.includeJudgeScores) {
-            item.judgeScores = (row.entry.judgeScores ?? []);
-        }
-        if (opts.includeStageSubmissions || (opts.stageSubmissionsViewerId && row.entry.userId === opts.stageSubmissionsViewerId)) {
-            item.stageSubmissions = row.entry.stageSubmissions ?? [];
-        }
-        return item;
-    });
-    return { items, total };
-}
-/**
- * One enriched entry by id — content + author info, per-stage artifacts, and
- * per-judge scores. Server-internal: the route layer gates who may see the
- * artifacts/scores (judges/owner/admin + the entrant themselves).
- */
-export async function getContestEntry(db, entryId) {
-    const rows = await db
-        .select({
-        entry: contestEntries,
-        content: {
-            title: contentItems.title,
-            slug: contentItems.slug,
-            type: contentItems.type,
-            coverImageUrl: contentItems.coverImageUrl,
-        },
-        author: {
-            displayName: users.displayName,
-            username: users.username,
-            avatarUrl: users.avatarUrl,
-        },
-    })
-        .from(contestEntries)
-        .innerJoin(contentItems, eq(contestEntries.contentId, contentItems.id))
-        .innerJoin(users, eq(contestEntries.userId, users.id))
-        .where(eq(contestEntries.id, entryId))
-        .limit(1);
-    const row = rows[0];
-    if (!row)
-        return null;
-    return {
-        id: row.entry.id,
-        contestId: row.entry.contestId,
-        contentId: row.entry.contentId,
-        userId: row.entry.userId,
-        score: row.entry.score,
-        rank: row.entry.rank,
-        stageState: row.entry.stageState ?? [],
-        eliminated: isEliminated(row.entry),
-        stageSubmissions: row.entry.stageSubmissions ?? [],
-        submittedAt: row.entry.submittedAt,
-        contentTitle: row.content.title,
-        contentSlug: row.content.slug,
-        contentType: row.content.type,
-        contentCoverImageUrl: row.content.coverImageUrl,
-        authorName: row.author.displayName ?? row.author.username,
-        authorUsername: row.author.username,
-        authorAvatarUrl: row.author.avatarUrl,
-        judgeScores: (row.entry.judgeScores ?? []),
-    };
-}
-export async function submitContestEntry(db, contestId, contentId, userId) {
-    // Validate contest exists and is active
-    const contest = await db
-        .select({
-        id: contests.id,
-        status: contests.status,
-        eligibleContentTypes: contests.eligibleContentTypes,
-        maxEntriesPerUser: contests.maxEntriesPerUser,
-    })
-        .from(contests)
-        .where(eq(contests.id, contestId))
-        .limit(1);
-    if (contest.length === 0)
-        return null;
-    const c = contest[0];
-    if (c.status !== 'active')
-        return null;
-    // Validate content exists, is published, and user owns it
-    const content = await db
-        .select({ id: contentItems.id, authorId: contentItems.authorId, status: contentItems.status, type: contentItems.type })
-        .from(contentItems)
-        .where(eq(contentItems.id, contentId))
-        .limit(1);
-    if (content.length === 0)
-        return null;
-    if (content[0].status !== 'published')
-        return null;
-    if (content[0].authorId !== userId)
-        return null;
-    // Per-contest entry eligibility: content type must be allowed (if restricted).
-    const eligible = c.eligibleContentTypes ?? null;
-    if (eligible && eligible.length > 0 && !eligible.includes(content[0].type))
-        return null;
-    // Per-user entry cap (if set).
-    if (c.maxEntriesPerUser != null) {
-        const existingCount = await countRows(db, contestEntries, and(eq(contestEntries.contestId, contestId), eq(contestEntries.userId, userId)));
-        if (existingCount >= c.maxEntriesPerUser)
-            return null;
-    }
-    // Atomic: insert the entry and bump the denormalized entryCount together, so a
-    // duplicate (onConflictDoNothing → no row) never increments and a mid-operation
-    // failure can't leave entryCount overcounting.
-    const row = await db.transaction(async (tx) => {
-        const [inserted] = await tx
-            .insert(contestEntries)
-            .values({ contestId, contentId, userId })
-            .onConflictDoNothing()
-            .returning();
-        if (!inserted)
-            return null;
-        await tx
-            .update(contests)
-            .set({ entryCount: sql `${contests.entryCount} + 1` })
-            .where(eq(contests.id, contestId));
-        return inserted;
-    });
-    if (!row)
-        return null;
-    // Fetch enriched content + author info
-    const enriched = await db
-        .select({
-        content: {
-            title: contentItems.title,
-            slug: contentItems.slug,
-            type: contentItems.type,
-            coverImageUrl: contentItems.coverImageUrl,
-        },
-        author: {
-            displayName: users.displayName,
-            username: users.username,
-            avatarUrl: users.avatarUrl,
-        },
-    })
-        .from(contentItems)
-        .innerJoin(users, eq(contentItems.authorId, users.id))
-        .where(eq(contentItems.id, contentId))
-        .limit(1);
-    const info = enriched[0];
-    return {
-        id: row.id,
-        contestId: row.contestId,
-        contentId: row.contentId,
-        userId: row.userId,
-        score: row.score,
-        rank: row.rank,
-        stageState: [], // a freshly submitted entry is in the active cohort
-        eliminated: false,
-        submittedAt: row.submittedAt,
-        contentTitle: info?.content.title ?? 'Untitled',
-        contentSlug: info?.content.slug ?? '',
-        contentType: info?.content.type ?? 'project',
-        contentCoverImageUrl: info?.content.coverImageUrl ?? null,
-        authorName: info?.author.displayName ?? info?.author.username ?? 'Unknown',
-        authorUsername: info?.author.username ?? '',
-        authorAvatarUrl: info?.author.avatarUrl ?? null,
-    };
-}
-export async function judgeContestEntry(db, entryId, score, judgeId, feedback, criteriaScores) {
-    // Get the entry and its contest (read-only validation, no lock needed).
-    const existing = await db
-        .select({
-        contestStatus: contests.status,
-        contestId: contests.id,
-        entrantId: contestEntries.userId,
-        stageState: contestEntries.stageState,
-        stages: contests.stages,
-        currentStageId: contests.currentStageId,
-        startDate: contests.startDate,
-        endDate: contests.endDate,
-        judgingEndDate: contests.judgingEndDate,
-    })
-        .from(contestEntries)
-        .innerJoin(contests, eq(contestEntries.contestId, contests.id))
-        .where(eq(contestEntries.id, entryId))
-        .limit(1);
-    if (existing.length === 0)
-        return { judged: false, error: 'Entry not found' };
-    const row = existing[0];
-    // Check contest is in judging phase
-    if (row.contestStatus !== 'judging') {
-        return { judged: false, error: 'Contest is not in judging phase' };
-    }
-    // Cohort gate (Phase B2.5): once a review stage has culled the field, entries
-    // that didn't advance are out of later rounds and can't be scored.
-    if (isEliminated({ stageState: row.stageState })) {
-        return { judged: false, error: 'This entry was not advanced and can no longer be scored' };
-    }
-    // Per-round isolation: which review round is this score for? The entry's live
-    // `score` will aggregate only THIS round's judge scores (a classic contest with
-    // no explicit stages resolves to the synthesized `core-review`, so it stays one
-    // bucket — unchanged single-round behaviour).
-    const roundStage = currentStage({
-        status: row.contestStatus,
-        startDate: row.startDate,
-        endDate: row.endDate,
-        judgingEndDate: row.judgingEndDate,
-        stages: row.stages,
-        currentStageId: row.currentStageId,
-    });
-    const roundId = roundStage && roundStage.kind === 'review' ? roundStage.id : null;
-    // Conflict of interest: a judge cannot score their own entry.
-    if (row.entrantId === judgeId) {
-        return { judged: false, error: 'You cannot judge your own entry' };
-    }
-    // Check judge authorization via contestJudges table (accepted judges only)
-    const [judgeRecord] = await db
-        .select({ id: contestJudges.id, role: contestJudges.role, acceptedAt: contestJudges.acceptedAt })
-        .from(contestJudges)
-        .where(and(eq(contestJudges.contestId, row.contestId), eq(contestJudges.userId, judgeId)))
-        .limit(1);
-    if (!judgeRecord) {
-        return { judged: false, error: 'Not authorized to judge this contest' };
-    }
-    if (!judgeRecord.acceptedAt) {
-        return { judged: false, error: 'Judge invitation has not been accepted' };
-    }
-    if (judgeRecord.role === 'guest') {
-        return { judged: false, error: 'Guest judges cannot submit scores' };
-    }
-    // Derive the overall 0–100 score. When per-criterion scores are supplied, the
-    // overall is the normalized weighted sum (sum(score)/sum(max)*100), which
-    // supports any weight scheme; otherwise use the supplied overall score.
-    let overall;
-    if (criteriaScores && criteriaScores.length > 0) {
-        const totalMax = criteriaScores.reduce((s, c) => s + c.max, 0);
-        if (totalMax <= 0)
-            return { judged: false, error: 'Invalid judging criteria' };
-        if (criteriaScores.some((c) => c.score < 0 || c.score > c.max)) {
-            return { judged: false, error: 'A criterion score is out of range' };
-        }
-        overall = Math.round((criteriaScores.reduce((s, c) => s + c.score, 0) / totalMax) * 100);
-    }
-    else if (typeof score === 'number') {
-        overall = score;
-    }
-    else {
-        return { judged: false, error: 'No score provided' };
-    }
-    // Atomic read-modify-write: lock the entry row so two judges scoring the same
-    // entry concurrently can't clobber each other's judgeScores (lost update).
-    return db.transaction(async (tx) => {
-        const [locked] = await tx
-            .select({ judgeScores: contestEntries.judgeScores })
-            .from(contestEntries)
-            .where(eq(contestEntries.id, entryId))
-            .for('update');
-        const scores = (locked?.judgeScores ?? []);
-        const record = { judgeId, score: overall, feedback };
-        if (criteriaScores && criteriaScores.length > 0)
-            record.criteriaScores = criteriaScores;
-        if (roundId)
-            record.roundId = roundId;
-        // A judge has one score per round — match on judge AND round.
-        const existingIdx = scores.findIndex((s) => s.judgeId === judgeId && (s.roundId ?? null) === (roundId ?? null));
-        if (existingIdx >= 0)
-            scores[existingIdx] = record;
-        else
-            scores.push(record);
-        // The live aggregate reflects ONLY the current round's scores, so a later
-        // judging round doesn't blend with an earlier one. Earlier rounds stay in
-        // `judgeScores` (tagged with their roundId) as history.
-        const roundScores = roundId ? scores.filter((s) => (s.roundId ?? null) === roundId) : scores;
-        const avgScore = roundScores.length
-            ? Math.round(roundScores.reduce((sum, s) => sum + s.score, 0) / roundScores.length)
-            : 0;
-        await tx
-            .update(contestEntries)
-            .set({ judgeScores: scores, score: avgScore })
-            .where(eq(contestEntries.id, entryId));
-        return { judged: true };
-    });
-}
 // --- Contest Management ---
 export async function deleteContest(db, contestId, userId, 
 /**
@@ -749,16 +234,20 @@ export async function transitionContestStatus(db, contestId, userId, newStatus,
     if (!allowed.includes(newStatus)) {
         return { transitioned: false, error: `Cannot transition from ${currentStatus} to ${newStatus}` };
     }
-    await db
-        .update(contests)
-        .set({
-        status: newStatus,
-        updatedAt: new Date(),
-    })
-        .where(eq(contests.id, contestId));
-    if (newStatus === 'completed') {
-        await calculateContestRanks(db, contestId);
-    }
+    // Status flip + (on completion) rank calculation must be atomic so we never
+    // leave a 'completed' contest with stale/partial ranks.
+    await db.transaction(async (tx) => {
+        await tx
+            .update(contests)
+            .set({
+            status: newStatus,
+            updatedAt: new Date(),
+        })
+            .where(eq(contests.id, contestId));
+        if (newStatus === 'completed') {
+            await calculateContestRanks(tx, contestId);
+        }
+    });
     // Notify contest entrants about status change (non-critical)
     try {
         const { createNotification } = await import('../notification/notification.js');
@@ -796,7 +285,7 @@ export async function transitionContestStatus(db, contestId, userId, newStatus,
                         createNotification(db, {
                             userId: entrant.userId,
                             type: 'contest',
-                            title: '🏆 You won!',
+                            title: 'You won!',
                             message: `Congratulations — you placed ${ordinalPlace(rank)} in "${contestInfo.title}"${won}!`,
                             link,
                             actorId: userId,
@@ -843,284 +332,4 @@ export async function transitionContestStatus(db, contestId, userId, newStatus,
     catch { /* non-critical */ }
     return { transitioned: true };
 }
-export async function withdrawContestEntry(db, entryId, userId) {
-    const existing = await db
-        .select({
-        entry: contestEntries,
-        contestStatus: contests.status,
-    })
-        .from(contestEntries)
-        .innerJoin(contests, eq(contestEntries.contestId, contests.id))
-        .where(eq(contestEntries.id, entryId))
-        .limit(1);
-    if (existing.length === 0)
-        return { withdrawn: false, error: 'Entry not found' };
-    const row = existing[0];
-    if (row.entry.userId !== userId)
-        return { withdrawn: false, error: 'Not the entry owner' };
-    if (row.contestStatus !== 'active') {
-        return { withdrawn: false, error: 'Can only withdraw from active contests' };
-    }
-    await db.delete(contestEntries).where(eq(contestEntries.id, entryId));
-    await db
-        .update(contests)
-        .set({ entryCount: sql `GREATEST(${contests.entryCount} - 1, 0)` })
-        .where(eq(contests.id, row.entry.contestId));
-    return { withdrawn: true };
-}
-export async function calculateContestRanks(db, contestId) {
-    // Assign ranks by score with RANK() so tied scores share a rank (1, 1, 3…).
-    // Only scored entries are ranked; entries that were never judged keep a null
-    // rank rather than being handed an arbitrary trailing position.
-    // Eliminated entries (culled at a prior review stage, Phase B2) are excluded
-    // from ranking — only the surviving cohort competes for the final placements.
-    await db.execute(sql `
-    UPDATE ${contestEntries}
-    SET rank = ranked.rn
-    FROM (
-      SELECT id, RANK() OVER (ORDER BY score DESC) AS rn
-      FROM ${contestEntries}
-      WHERE contest_id = ${contestId} AND score IS NOT NULL
-        AND NOT (stage_state @> '[{"status":"eliminated"}]'::jsonb)
-    ) AS ranked
-    WHERE ${contestEntries}.id = ranked.id
-  `);
-    // Clear ranks for entries with no score (unjudged) or that were eliminated.
-    await db.execute(sql `
-    UPDATE ${contestEntries}
-    SET rank = NULL
-    WHERE contest_id = ${contestId}
-      AND (score IS NULL OR stage_state @> '[{"status":"eliminated"}]'::jsonb)
-  `);
-}
-/** True when an entry was culled at some review stage (Phase B2 cohort gate). */
-export function isEliminated(entry) {
-    return !!entry.stageState?.some((s) => s.status === 'eliminated');
-}
-// --- Per-stage submission artifacts (proposal → prototype) ---
-/**
- * Validate an entrant's artifact fields against the stage's template. Pure +
- * exhaustively testable. Domain checks, not just shape: unknown keys rejected
- * (no smuggling values outside the template), required fields must be
- * non-blank, and `url` fields must be real http(s) URLs — `javascript:` and
- * friends are known-bad payloads, not "strings that look url-ish".
- */
-export function validateStageArtifactFields(template, fields) {
-    const byKey = new Map(template.map((f) => [f.key, f]));
-    for (const key of Object.keys(fields)) {
-        if (!byKey.has(key))
-            return { ok: false, error: `Unknown field: ${key}` };
-        if (typeof fields[key] !== 'string')
-            return { ok: false, error: `Invalid value for ${key}` };
-        if (fields[key].length > 4000)
-            return { ok: false, error: `${byKey.get(key).label} is too long (max 4000 characters)` };
-    }
-    const clean = {};
-    for (const field of template) {
-        const raw = fields[field.key] ?? '';
-        const value = raw.trim();
-        if (!value) {
-            if (field.required)
-                return { ok: false, error: `${field.label} is required` };
-            continue; // optional + blank ⇒ omit from the snapshot
-        }
-        if (field.type === 'url') {
-            // Scheme allow-list FIRST (https?:// only), then structural URL parse.
-            if (!/^https?:\/\//i.test(value))
-                return { ok: false, error: `${field.label} must be an http(s) URL` };
-            try {
-                const u = new URL(value);
-                if (!u.hostname)
-                    return { ok: false, error: `${field.label} must be a valid URL` };
-            }
-            catch {
-                return { ok: false, error: `${field.label} must be a valid URL` };
-            }
-        }
-        clean[field.key] = value;
-    }
-    return { ok: true, fields: clean };
-}
-/**
- * Submit (or update) an entrant's per-stage artifact: the filled template
- * values for one `submission` stage, snapshotted onto the entry's
- * `stageSubmissions`. Owner-only. The stage must be the contest's CURRENT
- * stage while the contest is `active` (status stays the gating truth — the
- * organizer maps a later submission round back to `active` when advancing).
- * Re-submitting while the stage is open replaces that stage's artifact.
- * Cohort gate: an entry culled at a prior review stage can no longer submit.
- */
-export async function submitStageArtifact(db, entryId, stageId, fields, userId) {
-    const fail = (error) => ({ submitted: false, error });
-    const existing = await db
-        .select({
-        entrantId: contestEntries.userId,
-        stageState: contestEntries.stageState,
-        contestStatus: contests.status,
-        stages: contests.stages,
-        currentStageId: contests.currentStageId,
-        startDate: contests.startDate,
-        endDate: contests.endDate,
-        judgingEndDate: contests.judgingEndDate,
-    })
-        .from(contestEntries)
-        .innerJoin(contests, eq(contestEntries.contestId, contests.id))
-        .where(eq(contestEntries.id, entryId))
-        .limit(1);
-    if (existing.length === 0)
-        return fail('Entry not found');
-    const row = existing[0];
-    if (row.entrantId !== userId)
-        return fail('Not the entry owner');
-    if (row.contestStatus !== 'active') {
-        return fail('Stage submissions are only open while the contest is active');
-    }
-    const source = {
-        status: row.contestStatus,
-        startDate: row.startDate,
-        endDate: row.endDate,
-        judgingEndDate: row.judgingEndDate,
-        stages: row.stages,
-        currentStageId: row.currentStageId,
-    };
-    const stages = normalizeStages(source);
-    const stage = stages.find((s) => s.id === stageId);
-    if (!stage)
-        return fail('Unknown stage');
-    if (stage.kind !== 'submission')
-        return fail('This stage does not accept submissions');
-    const template = stage.submissionTemplate ?? [];
-    if (template.length === 0)
-        return fail('This stage has no submission template');
-    const current = currentStage(source);
-    if (current?.id !== stageId)
-        return fail('This stage is not currently open');
-    // Cohort gate: once a review cut culled the field, eliminated entries are
-    // out of every later round (mirrors judgeContestEntry's gate).
-    if (isEliminated({ stageState: row.stageState })) {
-        return fail('This entry was not advanced and can no longer submit');
-    }
-    const validated = validateStageArtifactFields(template, fields);
-    if (!validated.ok)
-        return fail(validated.error);
-    // Atomic read-modify-write: lock the entry row so two concurrent saves of
-    // the same artifact can't clobber each other (same pattern as judgeScores).
-    return db.transaction(async (tx) => {
-        const [locked] = await tx
-            .select({ stageSubmissions: contestEntries.stageSubmissions })
-            .from(contestEntries)
-            .where(eq(contestEntries.id, entryId))
-            .for('update');
-        const submissions = (locked?.stageSubmissions ?? []);
-        const record = { stageId, fields: validated.fields, submittedAt: new Date().toISOString() };
-        const idx = submissions.findIndex((s) => s.stageId === stageId);
-        if (idx >= 0)
-            submissions[idx] = record;
-        else
-            submissions.push(record);
-        await tx
-            .update(contestEntries)
-            .set({ stageSubmissions: submissions })
-            .where(eq(contestEntries.id, entryId));
-        return { submitted: true, stageSubmissions: submissions };
-    });
-}
-/**
- * Phase B2 — apply an advancement cut at a review stage: the surviving cohort
- * (entries not already eliminated) is split into advancers + eliminated, the
- * round's score/rank is snapshotted into each entry's `stageState`, and the
- * contest's `currentStageId` moves to the next stage. Idempotent per stage —
- * re-running replaces that stage's `stageState` rows rather than duplicating them.
- * Owner-gated. `topN` ties broken by score → rank → id for determinism.
- */
-export async function advanceContestStage(db, contestId, userId, input, canManage = false) {
-    const fail = (error) => ({ advanced: false, advancedCount: 0, eliminatedCount: 0, error });
-    const [contest] = await db
-        .select({
-        createdById: contests.createdById,
-        status: contests.status,
-        stages: contests.stages,
-        currentStageId: contests.currentStageId,
-        startDate: contests.startDate,
-        endDate: contests.endDate,
-        judgingEndDate: contests.judgingEndDate,
-    })
-        .from(contests)
-        .where(eq(contests.id, contestId))
-        .limit(1);
-    if (!contest)
-        return fail('Contest not found');
-    if (contest.createdById !== userId && !canManage && !(await isContestEditor(db, contestId, userId))) {
-        return fail('Not authorized to manage this contest');
-    }
-    const stages = normalizeStages(contest);
-    const idx = stages.findIndex((s) => s.id === input.reviewStageId);
-    if (idx < 0)
-        return fail('Unknown stage');
-    if (stages[idx].kind !== 'review')
-        return fail('Advancement applies to review stages only');
-    const rows = await db
-        .select({ id: contestEntries.id, userId: contestEntries.userId, score: contestEntries.score, rank: contestEntries.rank, stageState: contestEntries.stageState })
-        .from(contestEntries)
-        .where(eq(contestEntries.contestId, contestId));
-    // Only the running cohort (not already eliminated) is subject to the cut.
-    const eligible = rows.filter((r) => !isEliminated(r));
-    let advancedIds;
-    if (input.mode === 'manual') {
-        const picked = new Set(input.advancedEntryIds ?? []);
-        advancedIds = new Set(eligible.filter((e) => picked.has(e.id)).map((e) => e.id));
-    }
-    else {
-        const n = Math.max(0, input.topN ?? 0);
-        const sorted = [...eligible].sort((a, b) => (b.score ?? -Infinity) - (a.score ?? -Infinity) ||
-            (a.rank ?? Infinity) - (b.rank ?? Infinity) ||
-            a.id.localeCompare(b.id));
-        advancedIds = new Set(sorted.slice(0, n).map((e) => e.id));
-    }
-    let advancedCount = 0;
-    let eliminatedCount = 0;
-    for (const e of eligible) {
-        const isAdv = advancedIds.has(e.id);
-        const prior = (e.stageState ?? []).filter((s) => s.stageId !== input.reviewStageId);
-        const next = [...prior, { stageId: input.reviewStageId, status: isAdv ? 'advanced' : 'eliminated', score: e.score ?? null, rank: e.rank ?? null }];
-        await db.update(contestEntries).set({ stageState: next }).where(eq(contestEntries.id, e.id));
-        if (isAdv)
-            advancedCount++;
-        else
-            eliminatedCount++;
-    }
-    const nextStage = stages[idx + 1];
-    if (nextStage) {
-        await db.update(contests).set({ currentStageId: nextStage.id, updatedAt: new Date() }).where(eq(contests.id, contestId));
-    }
-    // Notify entrants of the outcome (non-critical, de-duped by user).
-    try {
-        const { createNotification } = await import('../notification/notification.js');
-        const [info] = await db.select({ title: contests.title, slug: contests.slug }).from(contests).where(eq(contests.id, contestId)).limit(1);
-        if (info) {
-            const nextName = nextStage?.name ?? 'the next stage';
-            const seen = new Set();
-            for (const e of eligible) {
-                if (seen.has(e.userId))
-                    continue;
-                seen.add(e.userId);
-                const adv = advancedIds.has(e.id);
-                createNotification(db, {
-                    userId: e.userId,
-                    type: 'contest',
-                    title: adv ? '✅ You advanced!' : 'Contest update',
-                    message: adv
-                        ? `Your entry advanced to ${nextName} in "${info.title}".`
-                        : `Your entry wasn't selected to continue in "${info.title}".`,
-                    link: `/contests/${info.slug}`,
-                    actorId: userId,
-                }).catch(() => { });
-            }
-        }
-    }
-    catch {
-        /* non-critical */
-    }
-    return { advanced: true, advancedCount, eliminatedCount };
-}
 //# sourceMappingURL=contest.js.map