fix: update match configuration to bestOf 5 and scoringType to score_v2

.svelte-kit/output/server/entries/endpoints/api/health/_server.ts.js

@@ -0,0 +1,25 @@
+import { json } from "@sveltejs/kit";
+import { d as db } from "../../../../chunks/index2.js";
+import { sql } from "drizzle-orm";
+const GET = async () => {
+  try {
+    await db.execute(sql`SELECT 1`);
+    return json({
+      status: "ok",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      uptime: process.uptime()
+    });
+  } catch (e) {
+    return json(
+      {
+        status: "error",
+        error: "Database connection failed",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      { status: 503 }
+    );
+  }
+};
+export {
+  GET
+};

.svelte-kit/output/server/entries/endpoints/api/mappools/_id_/_server.ts.js

@@ -0,0 +1,24 @@
+import { error, json } from "@sveltejs/kit";
+import { d as db, m as mappool, a as mappoolSlot } from "../../../../../chunks/index2.js";
+import { eq } from "drizzle-orm";
+const GET = async ({ params, locals }) => {
+  if (!locals.user) error(401, "Not logged in");
+  const pool = await db.query.mappool.findFirst({
+    where: eq(mappool.id, params.id)
+  });
+  if (!pool) error(404, "Mappool not found");
+  const slots = await db.query.mappoolSlot.findMany({
+    where: eq(mappoolSlot.mappoolId, params.id),
+    orderBy: (s, { asc }) => [asc(s.category), asc(s.orderInCategory)]
+  });
+  return json({ ...pool, slots });
+};
+const DELETE = async ({ params, locals }) => {
+  if (!locals.user) error(401, "Not logged in");
+  await db.delete(mappool).where(eq(mappool.id, params.id));
+  return json({ ok: true });
+};
+export {
+  DELETE,
+  GET
+};

.svelte-kit/output/server/entries/endpoints/api/mappools/_id_/slots/_server.ts.js

@@ -0,0 +1,27 @@
+import { error, json } from "@sveltejs/kit";
+import { d as db, a as mappoolSlot } from "../../../../../../chunks/index2.js";
+import { and, eq } from "drizzle-orm";
+const POST = async ({ params, request, locals }) => {
+  if (!locals.user) error(401, "Not logged in");
+  const { beatmapId, category, mods } = await request.json();
+  if (!beatmapId || !category) {
+    error(400, "beatmapId and category are required");
+  }
+  const existing = await db.query.mappoolSlot.findMany({
+    where: and(
+      eq(mappoolSlot.mappoolId, params.id),
+      eq(mappoolSlot.category, category.toUpperCase())
+    )
+  });
+  const [created] = await db.insert(mappoolSlot).values({
+    mappoolId: params.id,
+    beatmapId: String(beatmapId),
+    category: category.toUpperCase(),
+    orderInCategory: existing.length + 1,
+    mods: mods ?? []
+  }).returning();
+  return json(created, { status: 201 });
+};
+export {
+  POST
+};

.svelte-kit/output/server/entries/endpoints/api/mappools/_id_/slots/_slotId_/_server.ts.js

@@ -0,0 +1,11 @@
+import { error, json } from "@sveltejs/kit";
+import { d as db, a as mappoolSlot } from "../../../../../../../chunks/index2.js";
+import { eq } from "drizzle-orm";
+const DELETE = async ({ params, locals }) => {
+  if (!locals.user) error(401, "Not logged in");
+  await db.delete(mappoolSlot).where(eq(mappoolSlot.id, params.slotId));
+  return json({ ok: true });
+};
+export {
+  DELETE
+};

.svelte-kit/output/server/entries/endpoints/api/mappools/_server.ts.js

@@ -0,0 +1,23 @@
+import { error, json } from "@sveltejs/kit";
+import { d as db, m as mappool } from "../../../../chunks/index2.js";
+const GET = async ({ locals }) => {
+  if (!locals.user) error(401, "Not logged in");
+  const mappools = await db.query.mappool.findMany({
+    orderBy: (m, { desc }) => [desc(m.createdAt)]
+  });
+  return json(mappools);
+};
+const POST = async ({ request, locals }) => {
+  if (!locals.user) error(401, "Not logged in");
+  const { name } = await request.json();
+  if (!name?.trim()) error(400, "Name is required");
+  const [created] = await db.insert(mappool).values({
+    name: name.trim(),
+    createdBy: locals.user.id
+  }).returning();
+  return json(created, { status: 201 });
+};
+export {
+  GET,
+  POST
+};

.svelte-kit/output/server/entries/endpoints/api/matches/_id_/_server.ts.js

@@ -0,0 +1,24 @@
+import { error, json } from "@sveltejs/kit";
+import { a as cancelMatch, g as getMatchFull } from "../../../../../chunks/engine.js";
+const GET = async ({ params, locals }) => {
+  if (!locals.user) error(401, "Not logged in");
+  try {
+    const m = await getMatchFull(params.id);
+    return json(m);
+  } catch (e) {
+    error(404, e.message);
+  }
+};
+const DELETE = async ({ params, locals }) => {
+  if (!locals.user) error(401, "Not logged in");
+  try {
+    const m = await cancelMatch(params.id);
+    return json(m);
+  } catch (e) {
+    error(400, e.message);
+  }
+};
+export {
+  DELETE,
+  GET
+};

.svelte-kit/output/server/entries/endpoints/api/matches/_id_/lobby/_server.ts.js

@@ -0,0 +1,15 @@
+import { error, json } from "@sveltejs/kit";
+import { m as moveToLobby } from "../../../../../../chunks/engine.js";
+const POST = async ({ params, request, locals }) => {
+  if (!locals.user) error(401, "Not logged in");
+  const body = await request.json().catch(() => ({}));
+  try {
+    const m = await moveToLobby(params.id, body.osuLobbyId);
+    return json(m);
+  } catch (e) {
+    error(400, e.message);
+  }
+};
+export {
+  POST
+};

.svelte-kit/output/server/entries/endpoints/api/matches/_id_/pick/_server.ts.js

@@ -0,0 +1,18 @@
+import { error, json } from "@sveltejs/kit";
+import { p as pickMap } from "../../../../../../chunks/engine.js";
+const POST = async ({ params, request, locals }) => {
+  if (!locals.user) error(401, "Not logged in");
+  const { participantId, mappoolSlotId } = await request.json();
+  if (!participantId || !mappoolSlotId) {
+    error(400, "participantId and mappoolSlotId required");
+  }
+  try {
+    const game = await pickMap(params.id, participantId, mappoolSlotId);
+    return json(game);
+  } catch (e) {
+    error(400, e.message);
+  }
+};
+export {
+  POST
+};

.svelte-kit/output/server/entries/endpoints/api/matches/_id_/roll/_server.ts.js

@@ -0,0 +1,18 @@
+import { error, json } from "@sveltejs/kit";
+import { s as submitRoll } from "../../../../../../chunks/engine.js";
+const POST = async ({ params, request, locals }) => {
+  if (!locals.user) error(401, "Not logged in");
+  const { participantId, value } = await request.json();
+  if (!participantId || value == null) {
+    error(400, "participantId and value required");
+  }
+  try {
+    const m = await submitRoll(params.id, participantId, value);
+    return json(m);
+  } catch (e) {
+    error(400, e.message);
+  }
+};
+export {
+  POST
+};

.svelte-kit/output/server/entries/endpoints/api/matches/_id_/rolling/_server.ts.js

@@ -0,0 +1,14 @@
+import { error, json } from "@sveltejs/kit";
+import { b as moveToRolling } from "../../../../../../chunks/engine.js";
+const POST = async ({ params, locals }) => {
+  if (!locals.user) error(401, "Not logged in");
+  try {
+    const m = await moveToRolling(params.id);
+    return json(m);
+  } catch (e) {
+    error(400, e.message);
+  }
+};
+export {
+  POST
+};

.svelte-kit/output/server/entries/endpoints/api/matches/_id_/score/_server.ts.js

@@ -0,0 +1,18 @@
+import { error, json } from "@sveltejs/kit";
+import { d as submitGameScores } from "../../../../../../chunks/engine.js";
+const POST = async ({ request, locals }) => {
+  if (!locals.user) error(401, "Not logged in");
+  const { matchGameId, scores } = await request.json();
+  if (!matchGameId || !scores?.length) {
+    error(400, "matchGameId and scores required");
+  }
+  try {
+    const m = await submitGameScores(matchGameId, scores);
+    return json(m);
+  } catch (e) {
+    error(400, e.message);
+  }
+};
+export {
+  POST
+};

.svelte-kit/output/server/entries/endpoints/api/matches/_server.ts.js

@@ -0,0 +1,37 @@
+import { error, json } from "@sveltejs/kit";
+import { d as db } from "../../../../chunks/index2.js";
+import { c as createMatch } from "../../../../chunks/engine.js";
+const GET = async ({ locals }) => {
+  if (!locals.user) error(401, "Not logged in");
+  const matches = await db.query.match.findMany({
+    with: {
+      participants: { with: { team: true } }
+    },
+    orderBy: (m, { desc }) => [desc(m.createdAt)]
+  });
+  return json(matches);
+};
+const POST = async ({ request, locals }) => {
+  if (!locals.user) error(401, "Not logged in");
+  const body = await request.json();
+  const { name, config, mappoolId, teams } = body;
+  if (!name || !config || !mappoolId || !teams?.length) {
+    error(400, "Missing required fields");
+  }
+  try {
+    const result = await createMatch({
+      name,
+      config,
+      mappoolId,
+      teams,
+      createdBy: locals.user.id
+    });
+    return json(result, { status: 201 });
+  } catch (e) {
+    error(400, e.message);
+  }
+};
+export {
+  GET,
+  POST
+};

.svelte-kit/output/server/entries/endpoints/api/osu/beatmap/_id_/_server.ts.js

@@ -0,0 +1,14 @@
+import { error, json } from "@sveltejs/kit";
+import { g as getBeatmap } from "../../../../../../chunks/api.js";
+const GET = async ({ params, locals }) => {
+  if (!locals.user) error(401, "Not logged in");
+  try {
+    const beatmap = await getBeatmap(params.id);
+    return json(beatmap);
+  } catch {
+    error(404, "Beatmap not found");
+  }
+};
+export {
+  GET
+};

.svelte-kit/output/server/entries/endpoints/api/queue/_server.ts.js

@@ -0,0 +1,36 @@
+import { error, json } from "@sveltejs/kit";
+import { l as leaveQueue, e as getQueueStatus, j as joinQueue } from "../../../../chunks/engine.js";
+import { d as db, t as teamMember } from "../../../../chunks/index2.js";
+import { eq } from "drizzle-orm";
+const GET = async ({ locals }) => {
+  if (!locals.user) error(401, "Not logged in");
+  const status = await getQueueStatus(locals.user.id);
+  return json(status);
+};
+const POST = async ({ locals }) => {
+  if (!locals.user) error(401, "Not logged in");
+  const membership = await db.query.teamMember.findFirst({
+    where: eq(teamMember.userId, locals.user.id),
+    with: { team: true }
+  });
+  const personalTeam = membership?.team;
+  if (!personalTeam?.isPersonal) {
+    error(400, "No personal team found");
+  }
+  try {
+    const result = await joinQueue(locals.user.id, personalTeam.id);
+    return json({ matched: !!result, match: result });
+  } catch (e) {
+    error(400, e.message);
+  }
+};
+const DELETE = async ({ locals }) => {
+  if (!locals.user) error(401, "Not logged in");
+  await leaveQueue(locals.user.id);
+  return json({ ok: true });
+};
+export {
+  DELETE,
+  GET,
+  POST
+};