award badges

pb_migrations/1759244692_created_activities.js

@@ -0,0 +1,108 @@
+/// <reference path="../pb_data/types.d.ts" />
+migrate((app) => {
+  const collection = new Collection({
+    "createRule": null,
+    "deleteRule": null,
+    "fields": [
+      {
+        "autogeneratePattern": "[a-z0-9]{15}",
+        "hidden": false,
+        "id": "text3208210256",
+        "max": 15,
+        "min": 15,
+        "name": "id",
+        "pattern": "^[a-z0-9]+$",
+        "presentable": false,
+        "primaryKey": true,
+        "required": true,
+        "system": true,
+        "type": "text"
+      },
+      {
+        "autogeneratePattern": "",
+        "hidden": false,
+        "id": "text1579384326",
+        "max": 0,
+        "min": 0,
+        "name": "name",
+        "pattern": "",
+        "presentable": false,
+        "primaryKey": false,
+        "required": false,
+        "system": false,
+        "type": "text"
+      },
+      {
+        "hidden": false,
+        "id": "json4225120046",
+        "maxSize": 0,
+        "name": "arguments",
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "json"
+      },
+      {
+        "cascadeDelete": false,
+        "collectionId": "pbc_3072146508",
+        "hidden": false,
+        "id": "relation2551806565",
+        "maxSelect": 1,
+        "minSelect": 0,
+        "name": "player",
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "relation"
+      },
+      {
+        "autogeneratePattern": "",
+        "hidden": false,
+        "id": "text3293145029",
+        "max": 0,
+        "min": 0,
+        "name": "user_agent",
+        "pattern": "",
+        "presentable": false,
+        "primaryKey": false,
+        "required": false,
+        "system": false,
+        "type": "text"
+      },
+      {
+        "hidden": false,
+        "id": "autodate2990389176",
+        "name": "created",
+        "onCreate": true,
+        "onUpdate": false,
+        "presentable": false,
+        "system": false,
+        "type": "autodate"
+      },
+      {
+        "hidden": false,
+        "id": "autodate3332085495",
+        "name": "updated",
+        "onCreate": true,
+        "onUpdate": true,
+        "presentable": false,
+        "system": false,
+        "type": "autodate"
+      }
+    ],
+    "id": "pbc_1262591861",
+    "indexes": [],
+    "listRule": null,
+    "name": "activities",
+    "system": false,
+    "type": "base",
+    "updateRule": null,
+    "viewRule": null
+  });
+
+  return app.save(collection);
+}, (app) => {
+  const collection = app.findCollectionByNameOrId("pbc_1262591861");
+
+  return app.delete(collection);
+})

pb_migrations/1759245857_updated_activities.js

@@ -0,0 +1,27 @@
+/// <reference path="../pb_data/types.d.ts" />
+migrate((app) => {
+  const collection = app.findCollectionByNameOrId("pbc_1262591861")
+
+  // add field
+  collection.fields.addAt(5, new Field({
+    "hidden": false,
+    "id": "number2254405824",
+    "max": null,
+    "min": null,
+    "name": "duration",
+    "onlyInt": false,
+    "presentable": false,
+    "required": false,
+    "system": false,
+    "type": "number"
+  }))
+
+  return app.save(collection)
+}, (app) => {
+  const collection = app.findCollectionByNameOrId("pbc_1262591861")
+
+  // remove field
+  collection.fields.removeById("number2254405824")
+
+  return app.save(collection)
+})

pb_migrations/1759246171_updated_activities.js

@@ -0,0 +1,43 @@
+/// <reference path="../pb_data/types.d.ts" />
+migrate((app) => {
+  const collection = app.findCollectionByNameOrId("pbc_1262591861")
+
+  // add field
+  collection.fields.addAt(6, new Field({
+    "hidden": false,
+    "id": "bool1862328242",
+    "name": "success",
+    "presentable": false,
+    "required": false,
+    "system": false,
+    "type": "bool"
+  }))
+
+  // add field
+  collection.fields.addAt(7, new Field({
+    "autogeneratePattern": "",
+    "hidden": false,
+    "id": "text1574812785",
+    "max": 0,
+    "min": 0,
+    "name": "error",
+    "pattern": "",
+    "presentable": false,
+    "primaryKey": false,
+    "required": false,
+    "system": false,
+    "type": "text"
+  }))
+
+  return app.save(collection)
+}, (app) => {
+  const collection = app.findCollectionByNameOrId("pbc_1262591861")
+
+  // remove field
+  collection.fields.removeById("bool1862328242")
+
+  // remove field
+  collection.fields.removeById("text1574812785")
+
+  return app.save(collection)
+})

pb_migrations/1759273534_deleted_player_badges_view.js

@@ -0,0 +1,187 @@
+/// <reference path="../pb_data/types.d.ts" />
+migrate((app) => {
+  const collection = app.findCollectionByNameOrId("pbc_5062686152");
+
+  return app.delete(collection);
+}, (app) => {
+  const collection = new Collection({
+    "createRule": null,
+    "deleteRule": null,
+    "fields": [
+      {
+        "autogeneratePattern": "",
+        "hidden": false,
+        "id": "text3208210256",
+        "max": 0,
+        "min": 0,
+        "name": "id",
+        "pattern": "^[a-z0-9]+$",
+        "presentable": false,
+        "primaryKey": true,
+        "required": true,
+        "system": true,
+        "type": "text"
+      },
+      {
+        "cascadeDelete": false,
+        "collectionId": "pbc_3072146508",
+        "hidden": false,
+        "id": "relation2582050271",
+        "maxSelect": 1,
+        "minSelect": 0,
+        "name": "player_id",
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "relation"
+      },
+      {
+        "cascadeDelete": false,
+        "collectionId": "pbc_1340419796",
+        "hidden": false,
+        "id": "relation4154639100",
+        "maxSelect": 1,
+        "minSelect": 0,
+        "name": "badge_id",
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "relation"
+      },
+      {
+        "autogeneratePattern": "",
+        "hidden": false,
+        "id": "_clone_bzlv",
+        "max": 0,
+        "min": 0,
+        "name": "badge_name",
+        "pattern": "",
+        "presentable": false,
+        "primaryKey": false,
+        "required": true,
+        "system": false,
+        "type": "text"
+      },
+      {
+        "autogeneratePattern": "",
+        "hidden": false,
+        "id": "_clone_CXA6",
+        "max": 0,
+        "min": 0,
+        "name": "badge_description",
+        "pattern": "",
+        "presentable": false,
+        "primaryKey": false,
+        "required": true,
+        "system": false,
+        "type": "text"
+      },
+      {
+        "hidden": false,
+        "id": "_clone_kZTN",
+        "maxSelect": 1,
+        "name": "badge_type",
+        "presentable": false,
+        "required": true,
+        "system": false,
+        "type": "select",
+        "values": [
+          "tournament_participation",
+          "tournament_placement",
+          "performance",
+          "overtime",
+          "match_milestone"
+        ]
+      },
+      {
+        "autogeneratePattern": "",
+        "hidden": false,
+        "id": "_clone_AgrF",
+        "max": 50,
+        "min": 0,
+        "name": "badge_icon",
+        "pattern": "",
+        "presentable": false,
+        "primaryKey": false,
+        "required": false,
+        "system": false,
+        "type": "text"
+      },
+      {
+        "autogeneratePattern": "",
+        "hidden": false,
+        "id": "_clone_m5vn",
+        "max": 50,
+        "min": 0,
+        "name": "badge_color",
+        "pattern": "",
+        "presentable": false,
+        "primaryKey": false,
+        "required": false,
+        "system": false,
+        "type": "text"
+      },
+      {
+        "hidden": false,
+        "id": "_clone_MAib",
+        "name": "is_progressive",
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "bool"
+      },
+      {
+        "hidden": false,
+        "id": "json3212413036",
+        "maxSize": 1,
+        "name": "current_progress",
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "json"
+      },
+      {
+        "hidden": false,
+        "id": "json4171899439",
+        "maxSize": 1,
+        "name": "target_progress",
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "json"
+      },
+      {
+        "hidden": false,
+        "id": "json3435813110",
+        "maxSize": 1,
+        "name": "is_earned",
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "json"
+      },
+      {
+        "hidden": false,
+        "id": "_clone_g8UU",
+        "max": "",
+        "min": "",
+        "name": "earned_at",
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "date"
+      }
+    ],
+    "id": "pbc_5062686152",
+    "indexes": [],
+    "listRule": null,
+    "name": "player_badges_view",
+    "system": false,
+    "type": "view",
+    "updateRule": null,
+    "viewQuery": "\n      SELECT\n        (p.id || '_' || b.id) as id,\n        p.id as player_id,\n        b.id as badge_id,\n        b.name as badge_name,\n        b.description as badge_description,\n        b.type as badge_type,\n        b.icon as badge_icon,\n        b.color as badge_color,\n        b.is_progressive,\n        COALESCE(pbp.current_progress, 0) as current_progress,\n        COALESCE(pbp.target_progress, b.progress_target, 1) as target_progress,\n        COALESCE(pbp.is_earned, false) as is_earned,\n        pbp.earned_at\n      FROM players p\n      CROSS JOIN badges b\n      LEFT JOIN player_badge_progress pbp ON pbp.player_id = p.id AND pbp.badge_id = b.id\n    ",
+    "viewRule": null
+  });
+
+  return app.save(collection);
+})

pb_migrations/1759273543_deleted_player_badge_progress.js

@@ -0,0 +1,129 @@
+/// <reference path="../pb_data/types.d.ts" />
+migrate((app) => {
+  const collection = app.findCollectionByNameOrId("pbc_4251874343");
+
+  return app.delete(collection);
+}, (app) => {
+  const collection = new Collection({
+    "createRule": null,
+    "deleteRule": null,
+    "fields": [
+      {
+        "autogeneratePattern": "[a-z0-9]{15}",
+        "hidden": false,
+        "id": "text3208210256",
+        "max": 15,
+        "min": 15,
+        "name": "id",
+        "pattern": "^[a-z0-9]+$",
+        "presentable": false,
+        "primaryKey": true,
+        "required": true,
+        "system": true,
+        "type": "text"
+      },
+      {
+        "cascadeDelete": true,
+        "collectionId": "pbc_3072146508",
+        "hidden": false,
+        "id": "relation2847519201",
+        "maxSelect": 1,
+        "minSelect": 1,
+        "name": "player_id",
+        "presentable": false,
+        "required": true,
+        "system": false,
+        "type": "relation"
+      },
+      {
+        "cascadeDelete": true,
+        "collectionId": "pbc_1340419796",
+        "hidden": false,
+        "id": "relation3948571039",
+        "maxSelect": 1,
+        "minSelect": 1,
+        "name": "badge_id",
+        "presentable": false,
+        "required": true,
+        "system": false,
+        "type": "relation"
+      },
+      {
+        "hidden": false,
+        "id": "number1847293057",
+        "max": null,
+        "min": 0,
+        "name": "current_progress",
+        "onlyInt": false,
+        "presentable": false,
+        "required": true,
+        "system": false,
+        "type": "number"
+      },
+      {
+        "hidden": false,
+        "id": "number2948571040",
+        "max": null,
+        "min": 1,
+        "name": "target_progress",
+        "onlyInt": false,
+        "presentable": false,
+        "required": true,
+        "system": false,
+        "type": "number"
+      },
+      {
+        "hidden": false,
+        "id": "bool3049672141",
+        "name": "is_earned",
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "bool"
+      },
+      {
+        "hidden": false,
+        "id": "date1150773242",
+        "max": "",
+        "min": "",
+        "name": "earned_at",
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "date"
+      },
+      {
+        "hidden": false,
+        "id": "autodate2990389176",
+        "name": "created",
+        "onCreate": true,
+        "onUpdate": false,
+        "presentable": false,
+        "system": false,
+        "type": "autodate"
+      },
+      {
+        "hidden": false,
+        "id": "autodate3332085495",
+        "name": "updated",
+        "onCreate": true,
+        "onUpdate": true,
+        "presentable": false,
+        "system": false,
+        "type": "autodate"
+      }
+    ],
+    "id": "pbc_4251874343",
+    "indexes": [
+      "CREATE UNIQUE INDEX `idx_unique_player_badge` ON `player_badge_progress` (`player_id`, `badge_id`)"
+    ],
+    "listRule": null,
+    "name": "player_badge_progress",
+    "system": false,
+    "type": "base",
+    "updateRule": null,
+    "viewRule": null
+  });
+
+  return app.save(collection);
+})

pb_migrations/1759285520_deleted_player_badge_progress.js

@@ -0,0 +1,106 @@
+/// <reference path="../pb_data/types.d.ts" />
+migrate((app) => {
+  const collection = app.findCollectionByNameOrId("pbc_badge_progress");
+
+  return app.delete(collection);
+}, (app) => {
+  const collection = new Collection({
+    "createRule": null,
+    "deleteRule": null,
+    "fields": [
+      {
+        "autogeneratePattern": "[a-z0-9]{15}",
+        "hidden": false,
+        "id": "text3208210256",
+        "max": 15,
+        "min": 15,
+        "name": "id",
+        "pattern": "^[a-z0-9]+$",
+        "presentable": false,
+        "primaryKey": true,
+        "required": true,
+        "system": true,
+        "type": "text"
+      },
+      {
+        "cascadeDelete": true,
+        "collectionId": "pbc_3072146508",
+        "hidden": false,
+        "id": "relation_player",
+        "maxSelect": 1,
+        "minSelect": 1,
+        "name": "player_id",
+        "presentable": false,
+        "required": true,
+        "system": false,
+        "type": "relation"
+      },
+      {
+        "cascadeDelete": true,
+        "collectionId": "pbc_1340419796",
+        "hidden": false,
+        "id": "relation_badge",
+        "maxSelect": 1,
+        "minSelect": 1,
+        "name": "badge_id",
+        "presentable": false,
+        "required": true,
+        "system": false,
+        "type": "relation"
+      },
+      {
+        "hidden": false,
+        "id": "number_current",
+        "max": null,
+        "min": 0,
+        "name": "current_progress",
+        "onlyInt": false,
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "number"
+      },
+      {
+        "hidden": false,
+        "id": "bool_earned",
+        "name": "is_earned",
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "bool"
+      },
+      {
+        "hidden": false,
+        "id": "autodate2990389176",
+        "name": "created",
+        "onCreate": true,
+        "onUpdate": false,
+        "presentable": false,
+        "system": false,
+        "type": "autodate"
+      },
+      {
+        "hidden": false,
+        "id": "autodate3332085495",
+        "name": "updated",
+        "onCreate": true,
+        "onUpdate": true,
+        "presentable": false,
+        "system": false,
+        "type": "autodate"
+      }
+    ],
+    "id": "pbc_badge_progress",
+    "indexes": [
+      "CREATE UNIQUE INDEX `idx_player_badge` ON `player_badge_progress` (`player_id`, `badge_id`)"
+    ],
+    "listRule": null,
+    "name": "player_badge_progress",
+    "system": false,
+    "type": "base",
+    "updateRule": null,
+    "viewRule": null
+  });
+
+  return app.save(collection);
+})

pb_migrations/1759285544_updated_players.js

@@ -0,0 +1,28 @@
+/// <reference path="../pb_data/types.d.ts" />
+migrate((app) => {
+  const collection = app.findCollectionByNameOrId("pbc_3072146508")
+
+  // remove field
+  collection.fields.removeById("relation2029409178")
+
+  return app.save(collection)
+}, (app) => {
+  const collection = app.findCollectionByNameOrId("pbc_3072146508")
+
+  // add field
+  collection.fields.addAt(5, new Field({
+    "cascadeDelete": false,
+    "collectionId": "pbc_1340419796",
+    "hidden": false,
+    "id": "relation2029409178",
+    "maxSelect": 999,
+    "minSelect": 0,
+    "name": "badges",
+    "presentable": false,
+    "required": false,
+    "system": false,
+    "type": "relation"
+  }))
+
+  return app.save(collection)
+})

pb_migrations/1759285564_updated_players.js

@@ -0,0 +1,28 @@
+/// <reference path="../pb_data/types.d.ts" />
+migrate((app) => {
+  const collection = app.findCollectionByNameOrId("pbc_3072146508")
+
+  // remove field
+  collection.fields.removeById("relation2813965191")
+
+  return app.save(collection)
+}, (app) => {
+  const collection = app.findCollectionByNameOrId("pbc_3072146508")
+
+  // add field
+  collection.fields.addAt(5, new Field({
+    "cascadeDelete": false,
+    "collectionId": "pbc_1340419796",
+    "hidden": false,
+    "id": "relation2813965191",
+    "maxSelect": 1,
+    "minSelect": 0,
+    "name": "featured_badge",
+    "presentable": false,
+    "required": false,
+    "system": false,
+    "type": "relation"
+  }))
+
+  return app.save(collection)
+})

pb_migrations/1759285574_deleted_badges.js

@@ -0,0 +1,159 @@
+/// <reference path="../pb_data/types.d.ts" />
+migrate((app) => {
+  const collection = app.findCollectionByNameOrId("pbc_1340419796");
+
+  return app.delete(collection);
+}, (app) => {
+  const collection = new Collection({
+    "createRule": null,
+    "deleteRule": null,
+    "fields": [
+      {
+        "autogeneratePattern": "[a-z0-9]{15}",
+        "hidden": false,
+        "id": "text3208210256",
+        "max": 15,
+        "min": 15,
+        "name": "id",
+        "pattern": "^[a-z0-9]+$",
+        "presentable": false,
+        "primaryKey": true,
+        "required": true,
+        "system": true,
+        "type": "text"
+      },
+      {
+        "autogeneratePattern": "",
+        "hidden": false,
+        "id": "text1579384326",
+        "max": 0,
+        "min": 0,
+        "name": "name",
+        "pattern": "",
+        "presentable": false,
+        "primaryKey": false,
+        "required": true,
+        "system": false,
+        "type": "text"
+      },
+      {
+        "autogeneratePattern": "",
+        "hidden": false,
+        "id": "text1843675174",
+        "max": 0,
+        "min": 0,
+        "name": "description",
+        "pattern": "",
+        "presentable": false,
+        "primaryKey": false,
+        "required": true,
+        "system": false,
+        "type": "text"
+      },
+      {
+        "hidden": false,
+        "id": "select4029814376",
+        "maxSelect": 1,
+        "name": "type",
+        "presentable": false,
+        "required": true,
+        "system": false,
+        "type": "select",
+        "values": [
+          "tournament_participation",
+          "tournament_placement",
+          "performance",
+          "overtime",
+          "match_milestone"
+        ]
+      },
+      {
+        "autogeneratePattern": "",
+        "hidden": false,
+        "id": "text_icon_key",
+        "max": 100,
+        "min": 0,
+        "name": "icon_key",
+        "pattern": "",
+        "presentable": false,
+        "primaryKey": false,
+        "required": false,
+        "system": false,
+        "type": "text"
+      },
+      {
+        "hidden": false,
+        "id": "json1578432567",
+        "maxSize": 2000000,
+        "name": "criteria",
+        "presentable": false,
+        "required": true,
+        "system": false,
+        "type": "json"
+      },
+      {
+        "hidden": false,
+        "id": "number_sort",
+        "max": null,
+        "min": 0,
+        "name": "sort_order",
+        "onlyInt": true,
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "number"
+      },
+      {
+        "hidden": false,
+        "id": "bool2847519203",
+        "name": "is_progressive",
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "bool"
+      },
+      {
+        "hidden": false,
+        "id": "number2948571038",
+        "max": null,
+        "min": null,
+        "name": "progress_target",
+        "onlyInt": false,
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "number"
+      },
+      {
+        "hidden": false,
+        "id": "autodate2990389176",
+        "name": "created",
+        "onCreate": true,
+        "onUpdate": false,
+        "presentable": false,
+        "system": false,
+        "type": "autodate"
+      },
+      {
+        "hidden": false,
+        "id": "autodate3332085495",
+        "name": "updated",
+        "onCreate": true,
+        "onUpdate": true,
+        "presentable": false,
+        "system": false,
+        "type": "autodate"
+      }
+    ],
+    "id": "pbc_1340419796",
+    "indexes": [],
+    "listRule": null,
+    "name": "badges",
+    "system": false,
+    "type": "base",
+    "updateRule": null,
+    "viewRule": null
+  });
+
+  return app.save(collection);
+})

pb_migrations/1759285803_created_badges.js

@@ -0,0 +1,133 @@
+/// <reference path="../pb_data/types.d.ts" />
+migrate((app) => {
+  const collection = new Collection({
+    "createRule": null,
+    "deleteRule": null,
+    "fields": [
+      {
+        "autogeneratePattern": "[a-z0-9]{15}",
+        "hidden": false,
+        "id": "text3208210256",
+        "max": 15,
+        "min": 15,
+        "name": "id",
+        "pattern": "^[a-z0-9]+$",
+        "presentable": false,
+        "primaryKey": true,
+        "required": true,
+        "system": true,
+        "type": "text"
+      },
+      {
+        "autogeneratePattern": "",
+        "hidden": false,
+        "id": "text1579384326",
+        "max": 0,
+        "min": 0,
+        "name": "name",
+        "pattern": "",
+        "presentable": false,
+        "primaryKey": false,
+        "required": false,
+        "system": false,
+        "type": "text"
+      },
+      {
+        "autogeneratePattern": "",
+        "hidden": false,
+        "id": "text2324736937",
+        "max": 0,
+        "min": 0,
+        "name": "key",
+        "pattern": "",
+        "presentable": false,
+        "primaryKey": false,
+        "required": false,
+        "system": false,
+        "type": "text"
+      },
+      {
+        "autogeneratePattern": "",
+        "hidden": false,
+        "id": "text1843675174",
+        "max": 0,
+        "min": 0,
+        "name": "description",
+        "pattern": "",
+        "presentable": false,
+        "primaryKey": false,
+        "required": false,
+        "system": false,
+        "type": "text"
+      },
+      {
+        "hidden": false,
+        "id": "json3055524737",
+        "maxSize": 0,
+        "name": "criteria",
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "json"
+      },
+      {
+        "hidden": false,
+        "id": "select2363381545",
+        "maxSelect": 1,
+        "name": "type",
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "select",
+        "values": [
+          "manual",
+          "match",
+          "tournament"
+        ]
+      },
+      {
+        "hidden": false,
+        "id": "bool3646955747",
+        "name": "progressive",
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "bool"
+      },
+      {
+        "hidden": false,
+        "id": "autodate2990389176",
+        "name": "created",
+        "onCreate": true,
+        "onUpdate": false,
+        "presentable": false,
+        "system": false,
+        "type": "autodate"
+      },
+      {
+        "hidden": false,
+        "id": "autodate3332085495",
+        "name": "updated",
+        "onCreate": true,
+        "onUpdate": true,
+        "presentable": false,
+        "system": false,
+        "type": "autodate"
+      }
+    ],
+    "id": "pbc_1340419796",
+    "indexes": [],
+    "listRule": null,
+    "name": "badges",
+    "system": false,
+    "type": "base",
+    "updateRule": null,
+    "viewRule": null
+  });
+
+  return app.save(collection);
+}, (app) => {
+  const collection = app.findCollectionByNameOrId("pbc_1340419796");
+
+  return app.delete(collection);
+})

pb_migrations/1759285923_created_badge_progress.js

@@ -0,0 +1,104 @@
+/// <reference path="../pb_data/types.d.ts" />
+migrate((app) => {
+  const collection = new Collection({
+    "createRule": null,
+    "deleteRule": null,
+    "fields": [
+      {
+        "autogeneratePattern": "[a-z0-9]{15}",
+        "hidden": false,
+        "id": "text3208210256",
+        "max": 15,
+        "min": 15,
+        "name": "id",
+        "pattern": "^[a-z0-9]+$",
+        "presentable": false,
+        "primaryKey": true,
+        "required": true,
+        "system": true,
+        "type": "text"
+      },
+      {
+        "cascadeDelete": false,
+        "collectionId": "pbc_1340419796",
+        "hidden": false,
+        "id": "relation4277159965",
+        "maxSelect": 1,
+        "minSelect": 0,
+        "name": "badge",
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "relation"
+      },
+      {
+        "cascadeDelete": false,
+        "collectionId": "pbc_3072146508",
+        "hidden": false,
+        "id": "relation2551806565",
+        "maxSelect": 1,
+        "minSelect": 0,
+        "name": "player",
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "relation"
+      },
+      {
+        "hidden": false,
+        "id": "number570552902",
+        "max": null,
+        "min": null,
+        "name": "progress",
+        "onlyInt": false,
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "number"
+      },
+      {
+        "hidden": false,
+        "id": "bool2625885481",
+        "name": "earned",
+        "presentable": false,
+        "required": false,
+        "system": false,
+        "type": "bool"
+      },
+      {
+        "hidden": false,
+        "id": "autodate2990389176",
+        "name": "created",
+        "onCreate": true,
+        "onUpdate": false,
+        "presentable": false,
+        "system": false,
+        "type": "autodate"
+      },
+      {
+        "hidden": false,
+        "id": "autodate3332085495",
+        "name": "updated",
+        "onCreate": true,
+        "onUpdate": true,
+        "presentable": false,
+        "system": false,
+        "type": "autodate"
+      }
+    ],
+    "id": "pbc_3342597247",
+    "indexes": [],
+    "listRule": null,
+    "name": "badge_progress",
+    "system": false,
+    "type": "base",
+    "updateRule": null,
+    "viewRule": null
+  });
+
+  return app.save(collection);
+}, (app) => {
+  const collection = app.findCollectionByNameOrId("pbc_3342597247");
+
+  return app.delete(collection);
+})

pb_migrations/1759340868_updated_badges.js

@@ -0,0 +1,27 @@
+/// <reference path="../pb_data/types.d.ts" />
+migrate((app) => {
+  const collection = app.findCollectionByNameOrId("pbc_1340419796")
+
+  // add field
+  collection.fields.addAt(7, new Field({
+    "hidden": false,
+    "id": "number4113142680",
+    "max": null,
+    "min": null,
+    "name": "order",
+    "onlyInt": false,
+    "presentable": false,
+    "required": false,
+    "system": false,
+    "type": "number"
+  }))
+
+  return app.save(collection)
+}, (app) => {
+  const collection = app.findCollectionByNameOrId("pbc_1340419796")
+
+  // remove field
+  collection.fields.removeById("number4113142680")
+
+  return app.save(collection)
+})

server.ts

@@ -330,6 +330,8 @@ async function startServer() {
   const server = Bun.serve({
     port: PORT,
 
+    idleTimeout: 255,
+
     routes: {
       // Serve static assets (preloaded or on-demand)
       ...routes,

src/app/routeTree.gen.ts

@@ -33,6 +33,7 @@ import { Route as AuthedTournamentsTournamentIdRouteImport } from './routes/_aut
 import { Route as AuthedTeamsTeamIdRouteImport } from './routes/_authed/teams.$teamId'
 import { Route as AuthedProfilePlayerIdRouteImport } from './routes/_authed/profile.$playerId'
 import { Route as AuthedAdminPreviewRouteImport } from './routes/_authed/admin/preview'
+import { Route as AuthedAdminBadgesRouteImport } from './routes/_authed/admin/badges'
 import { Route as AuthedAdminTournamentsIndexRouteImport } from './routes/_authed/admin/tournaments/index'
 import { Route as AuthedTournamentsIdBracketRouteImport } from './routes/_authed/tournaments/$id.bracket'
 import { Route as AuthedAdminTournamentsIdIndexRouteImport } from './routes/_authed/admin/tournaments/$id/index'
@@ -161,6 +162,11 @@ const AuthedAdminPreviewRoute = AuthedAdminPreviewRouteImport.update({
   path: '/preview',
   getParentRoute: () => AuthedAdminRoute,
 } as any)
+const AuthedAdminBadgesRoute = AuthedAdminBadgesRouteImport.update({
+  id: '/badges',
+  path: '/badges',
+  getParentRoute: () => AuthedAdminRoute,
+} as any)
 const AuthedAdminTournamentsIndexRoute =
   AuthedAdminTournamentsIndexRouteImport.update({
     id: '/tournaments/',
@@ -206,6 +212,7 @@ export interface FileRoutesByFullPath {
   '/settings': typeof AuthedSettingsRoute
   '/stats': typeof AuthedStatsRoute
   '/': typeof AuthedIndexRoute
+  '/admin/badges': typeof AuthedAdminBadgesRoute
   '/admin/preview': typeof AuthedAdminPreviewRoute
   '/profile/$playerId': typeof AuthedProfilePlayerIdRoute
   '/teams/$teamId': typeof AuthedTeamsTeamIdRoute
@@ -236,6 +243,7 @@ export interface FileRoutesByTo {
   '/settings': typeof AuthedSettingsRoute
   '/stats': typeof AuthedStatsRoute
   '/': typeof AuthedIndexRoute
+  '/admin/badges': typeof AuthedAdminBadgesRoute
   '/admin/preview': typeof AuthedAdminPreviewRoute
   '/profile/$playerId': typeof AuthedProfilePlayerIdRoute
   '/teams/$teamId': typeof AuthedTeamsTeamIdRoute
@@ -269,6 +277,7 @@ export interface FileRoutesById {
   '/_authed/settings': typeof AuthedSettingsRoute
   '/_authed/stats': typeof AuthedStatsRoute
   '/_authed/': typeof AuthedIndexRoute
+  '/_authed/admin/badges': typeof AuthedAdminBadgesRoute
   '/_authed/admin/preview': typeof AuthedAdminPreviewRoute
   '/_authed/profile/$playerId': typeof AuthedProfilePlayerIdRoute
   '/_authed/teams/$teamId': typeof AuthedTeamsTeamIdRoute
@@ -302,6 +311,7 @@ export interface FileRouteTypes {
     | '/settings'
     | '/stats'
     | '/'
+    | '/admin/badges'
     | '/admin/preview'
     | '/profile/$playerId'
     | '/teams/$teamId'
@@ -332,6 +342,7 @@ export interface FileRouteTypes {
     | '/settings'
     | '/stats'
     | '/'
+    | '/admin/badges'
     | '/admin/preview'
     | '/profile/$playerId'
     | '/teams/$teamId'
@@ -364,6 +375,7 @@ export interface FileRouteTypes {
     | '/_authed/settings'
     | '/_authed/stats'
     | '/_authed/'
+    | '/_authed/admin/badges'
     | '/_authed/admin/preview'
     | '/_authed/profile/$playerId'
     | '/_authed/teams/$teamId'
@@ -576,6 +588,13 @@ declare module '@tanstack/react-router' {
       preLoaderRoute: typeof AuthedAdminPreviewRouteImport
       parentRoute: typeof AuthedAdminRoute
     }
+    '/_authed/admin/badges': {
+      id: '/_authed/admin/badges'
+      path: '/badges'
+      fullPath: '/admin/badges'
+      preLoaderRoute: typeof AuthedAdminBadgesRouteImport
+      parentRoute: typeof AuthedAdminRoute
+    }
     '/_authed/admin/tournaments/': {
       id: '/_authed/admin/tournaments/'
       path: '/tournaments'
@@ -622,6 +641,7 @@ declare module '@tanstack/react-router' {
 }
 
 interface AuthedAdminRouteChildren {
+  AuthedAdminBadgesRoute: typeof AuthedAdminBadgesRoute
   AuthedAdminPreviewRoute: typeof AuthedAdminPreviewRoute
   AuthedAdminIndexRoute: typeof AuthedAdminIndexRoute
   AuthedAdminTournamentsIndexRoute: typeof AuthedAdminTournamentsIndexRoute
@@ -631,6 +651,7 @@ interface AuthedAdminRouteChildren {
 }
 
 const AuthedAdminRouteChildren: AuthedAdminRouteChildren = {
+  AuthedAdminBadgesRoute: AuthedAdminBadgesRoute,
   AuthedAdminPreviewRoute: AuthedAdminPreviewRoute,
   AuthedAdminIndexRoute: AuthedAdminIndexRoute,
   AuthedAdminTournamentsIndexRoute: AuthedAdminTournamentsIndexRoute,

src/app/routes/__root.tsx

@@ -37,7 +37,7 @@ export const Route = createRootRouteWithContext<{
       {
         name: "viewport",
         content:
-          "width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1, interactive-widget=overlays-content",
+          "width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1, interactive-widget=resizes-content",
       },
     ],
     links: [
@@ -122,8 +122,7 @@ function RootDocument({ children }: { children: React.ReactNode }) {
       {...mantineHtmlProps}
       style={{
         overflowX: "hidden",
-        overflowY: "hidden",
-        position: "fixed",
+        height: "100%",
         width: "100%",
       }}
     >
@@ -135,9 +134,10 @@ function RootDocument({ children }: { children: React.ReactNode }) {
       <body
         style={{
           overflowX: "hidden",
-          overflowY: "hidden",
-          position: "fixed",
+          height: "100%",
           width: "100%",
+          margin: 0,
+          padding: 0,
         }}
       >
         <div className="app">{children}</div>

src/app/routes/_authed/admin/badges.tsx

@@ -0,0 +1,10 @@
+import { createFileRoute } from "@tanstack/react-router";
+import AwardBadges from "@/features/admin/components/award-badges";
+
+export const Route = createFileRoute("/_authed/admin/badges")({
+  component: RouteComponent,
+});
+
+function RouteComponent() {
+  return <AwardBadges />;
+}

src/app/routes/api/events.$.ts

@@ -3,11 +3,16 @@ import { serverEvents, type ServerEvent } from "@/lib/events/emitter";
 import { logger } from "@/lib/logger";
 import { superTokensRequestMiddleware } from "@/utils/supertokens";
 
+let activeConnections = 0;
+
 export const Route = createFileRoute("/api/events/$")({
   server: {
     middleware: [superTokensRequestMiddleware],
     handlers: {
-      GET: ({ request, context }) => {
+      GET: ({ request }) => {
+        activeConnections++;
+        const connectionId = `conn_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+        logger.info(`ServerEvents | New connection ${connectionId}. Active: ${activeConnections}`);
         const stream = new ReadableStream({
           start(controller) {
             const connectMessage = `data: ${JSON.stringify({ type: "connected" })}\n\n`;
@@ -17,6 +22,10 @@ export const Route = createFileRoute("/api/events/$")({
               logger.info("ServerEvents | Event received", event);
               const message = `data: ${JSON.stringify(event)}\n\n`;
               try {
+                if (!controller.desiredSize || controller.desiredSize <= 0) {
+                  logger.warn("ServerEvents | Stream closed, skipping event");
+                  return;
+                }
                 controller.enqueue(new TextEncoder().encode(message));
               } catch (error) {
                 logger.error("ServerEvents | Error sending SSE message", error);
@@ -29,16 +38,34 @@ export const Route = createFileRoute("/api/events/$")({
 
             const pingInterval = setInterval(() => {
               try {
-                const pingMessage = `data: ${JSON.stringify({ type: "ping" })}\n\n`;
+                if (!controller.desiredSize || controller.desiredSize <= 0) {
+                  clearInterval(pingInterval);
+                  return;
+                }
+                const pingMessage = `data: ${JSON.stringify({ type: "ping", timestamp: Date.now() })}\n\n`;
                 controller.enqueue(new TextEncoder().encode(pingMessage));
               } catch (e) {
+                logger.error("ServerEvents | Ping interval error", e);
                 clearInterval(pingInterval);
               }
-            }, 30000);
+            }, 15000);
+
+            setTimeout(() => {
+              try {
+                const heartbeatMessage = `data: ${JSON.stringify({ type: "heartbeat", timestamp: Date.now() })}\n\n`;
+                controller.enqueue(new TextEncoder().encode(heartbeatMessage));
+              } catch (e) {
+                logger.error("ServerEvents | Heartbeat error", e);
+              }
+            }, 1000);
 
             const cleanup = () => {
+              activeConnections--;
               serverEvents.off("test", handleEvent);
+              serverEvents.off("match", handleEvent);
+              serverEvents.off("reaction", handleEvent);
               clearInterval(pingInterval);
+              logger.info(`ServerEvents | Connection ${connectionId} cleanup completed. Active: ${activeConnections}`);
             };
 
             request.signal?.addEventListener("abort", cleanup);
@@ -49,10 +76,14 @@ export const Route = createFileRoute("/api/events/$")({
         return new Response(stream, {
           headers: {
             "Content-Type": "text/event-stream",
-            "Cache-Control": "no-cache",
-            Connection: "keep-alive",
+            "Cache-Control": "no-cache, no-store, must-revalidate",
+            "Connection": "keep-alive",
             "Access-Control-Allow-Origin": "*",
             "Access-Control-Allow-Headers": "Cache-Control",
+            "X-Accel-Buffering": "no",
+            "X-Proxy-Buffering": "no",
+            "Proxy-Buffering": "off",
+            "Transfer-Encoding": "chunked",
           },
         });
       },

src/components/list-button.tsx

@@ -1,22 +1,33 @@
-import { Divider, Group, Text, UnstyledButton } from "@mantine/core";
+import { Divider, Group, Loader, Text, UnstyledButton } from "@mantine/core";
 import { CaretRightIcon, Icon } from "@phosphor-icons/react";
 
 interface ListButtonProps {
   label: string;
   Icon: Icon;
   onClick: () => void;
+  loading?: boolean;
 }
 
-const ListButton = ({ label, onClick, Icon }: ListButtonProps) => {
+const ListButton = ({ label, onClick, Icon, loading }: ListButtonProps) => {
   return (
     <>
-      <UnstyledButton w="100%" p="md" component={"button"} onClick={onClick}>
+      <UnstyledButton
+        w="100%"
+        p="md"
+        component={"button"}
+        onClick={onClick}
+        disabled={loading}
+      >
         <Group>
           <Icon weight="bold" size={20} />
           <Text fw={500} size="md">
             {label}
           </Text>
-          <CaretRightIcon style={{ marginLeft: "auto" }} size={20} />
+          {loading ? (
+            <Loader size="sm" style={{ marginLeft: "auto" }} />
+          ) : (
+            <CaretRightIcon style={{ marginLeft: "auto" }} size={20} />
+          )}
         </Group>
       </UnstyledButton>
       <Divider />

src/features/admin/components/admin-page.tsx

@@ -4,10 +4,24 @@ import {
   DatabaseIcon,
   TreeStructureIcon,
   TrophyIcon,
+  MedalIcon,
+  CrownIcon,
 } from "@phosphor-icons/react";
 import ListButton from "@/components/list-button";
+import { migrateBadgeProgress } from "@/features/badges/server";
+import { useState } from "react";
 
 const AdminPage = () => {
+  const [isMigrating, setIsMigrating] = useState(false);
+
+  const handleMigrateBadges = async () => {
+    if (isMigrating) return;
+
+    setIsMigrating(true);
+    await migrateBadgeProgress();
+    setIsMigrating(false);
+  };
+
   return (
     <List p="0">
       <ListLink
@@ -15,6 +29,17 @@ const AdminPage = () => {
         Icon={TrophyIcon}
         to="/admin/tournaments"
       />
+      <ListLink
+        label="Award Badges"
+        Icon={CrownIcon}
+        to="/admin/badges"
+      />
+      <ListButton
+        label="Migrate Badge Progress"
+        Icon={MedalIcon}
+        onClick={handleMigrateBadges}
+        loading={isMigrating}
+      />
       <ListButton
         label="Open Pocketbase"
         Icon={DatabaseIcon}

src/features/admin/components/award-badges.tsx

@@ -0,0 +1,99 @@
+import { useState } from "react";
+import { Box, Card, Text, Select, Button, Group, Stack } from "@mantine/core";
+import { awardManualBadge } from "@/features/badges/server";
+import { useAllBadges } from "@/features/badges/queries";
+import toast from "@/lib/sonner";
+import { usePlayers } from "@/features/players/queries";
+
+const AwardBadges = () => {
+  const { data: players } = usePlayers();
+  const { data: allBadges } = useAllBadges();
+
+  const [selectedPlayerId, setSelectedPlayerId] = useState<string | null>(null);
+  const [selectedBadgeId, setSelectedBadgeId] = useState<string | null>(null);
+  const [isAwarding, setIsAwarding] = useState(false);
+
+  const manualBadges = allBadges.filter((badge) => badge.type === "manual");
+
+  const handleAwardBadge = async () => {
+    if (!selectedPlayerId || !selectedBadgeId) return;
+
+    setIsAwarding(true);
+    try {
+      await awardManualBadge({
+        data: {
+          playerId: selectedPlayerId,
+          badgeId: selectedBadgeId,
+        },
+      });
+
+      toast.success("Badge awarded successfully");
+
+      setSelectedPlayerId(null);
+      setSelectedBadgeId(null);
+    } catch (error) {
+      toast.error("Failed to award badge");
+    } finally {
+      setIsAwarding(false);
+    }
+  };
+
+  const playerOptions = players.map((player) => ({
+    value: player.id,
+    label: `${player.first_name} ${player.last_name}`,
+  }));
+
+  const badgeOptions = manualBadges.map((badge) => ({
+    value: badge.id,
+    label: badge.name,
+  }));
+
+  return (
+    <Box p="md">
+      <Card withBorder radius="md" p="md">
+        <Stack gap="md">
+          <Box>
+            <Text size="lg" fw={600} mb="xs">
+              Award Manual Badge
+            </Text>
+            <Text size="sm" c="dimmed">
+              Select a player and a manual badge to award
+            </Text>
+          </Box>
+
+          <Select
+            label="Player"
+            placeholder="Select a player"
+            data={playerOptions}
+            value={selectedPlayerId}
+            onChange={setSelectedPlayerId}
+            searchable
+            clearable
+          />
+
+          <Select
+            label="Badge"
+            placeholder="Select a badge"
+            data={badgeOptions}
+            value={selectedBadgeId}
+            onChange={setSelectedBadgeId}
+            searchable
+            clearable
+          />
+
+          <Group justify="flex-end">
+            <Button
+              onClick={handleAwardBadge}
+              disabled={!selectedPlayerId || !selectedBadgeId}
+              loading={isAwarding}
+            >
+              Award Badge
+            </Button>
+          </Group>
+        </Stack>
+      </Card>
+    </Box>
+  );
+};
+
+export default AwardBadges;

src/features/badges/components/badge-showcase-skeleton.tsx

@@ -0,0 +1,47 @@
+import { Box, Card, Skeleton, Text } from "@mantine/core";
+
+const BadgeShowcaseSkeleton = () => {
+  return (
+    <Box mb="lg">
+      <Card
+        withBorder
+        radius="md"
+        p={0}
+        style={{
+          overflow: 'hidden',
+        }}
+      >
+        <Box
+          p="md"
+          style={{
+            background: 'light-dark(var(--mantine-color-gray-1), var(--mantine-color-dark-6))',
+            borderBottom: '1px solid light-dark(var(--mantine-color-gray-3), var(--mantine-color-dark-4))',
+          }}
+        >
+          <Text size="sm" fw={600} tt="uppercase" c="dimmed" style={{ letterSpacing: '0.5px' }}>
+            Badges
+          </Text>
+        </Box>
+
+        <Box
+          p="md"
+          style={{
+            display: 'grid',
+            gridTemplateColumns: 'repeat(auto-fill, minmax(110px, 1fr))',
+            gap: 'var(--mantine-spacing-sm)',
+          }}
+        >
+          {[1, 2, 3, 4, 5, 6].map((i) => (
+            <Skeleton
+              key={i}
+              height={70}
+              radius="md"
+            />
+          ))}
+        </Box>
+      </Card>
+    </Box>
+  );
+};
+
+export default BadgeShowcaseSkeleton;

src/features/badges/components/badge-showcase.tsx

@@ -0,0 +1,189 @@
+import { Box, Text, Tooltip, Card } from "@mantine/core";
+import { usePlayerBadges, useAllBadges } from "../queries";
+import { useAuth } from "@/contexts/auth-context";
+import { Badge, BadgeProgress } from "../types";
+import { useMemo } from "react";
+
+interface BadgeShowcaseProps {
+  playerId: string;
+}
+
+interface BadgeDisplay {
+  badge: Badge;
+  progress?: BadgeProgress;
+  earned: boolean;
+  progressText: string;
+}
+
+const BadgeShowcase = ({ playerId }: BadgeShowcaseProps) => {
+  const { user } = useAuth();
+  const { data: badgeProgress } = usePlayerBadges(playerId);
+  const { data: allBadges } = useAllBadges();
+
+  const isCurrentUser = user?.id === playerId;
+
+  const badgesToDisplay = useMemo(() => {
+    const displays: BadgeDisplay[] = [];
+
+    if (isCurrentUser) {
+      for (const badge of allBadges) {
+        const progress = badgeProgress.find(bp => bp.badge.id === badge.id);
+        const earned = progress?.earned || false;
+
+        if (badge.type === 'manual' && !earned) {
+          continue;
+        }
+
+        let progressText = "";
+        if (progress) {
+          const target = getTargetProgress(badge);
+          progressText = `${progress.progress} / ${target}`;
+        } else {
+          const target = getTargetProgress(badge);
+          progressText = `0 / ${target}`;
+        }
+
+        displays.push({
+          badge,
+          progress,
+          earned,
+          progressText,
+        });
+      }
+
+      displays.sort((a, b) => {
+        if (a.earned && !b.earned) return -1;
+        if (!a.earned && b.earned) return 1;
+        return a.badge.order - b.badge.order;
+      });
+    } else {
+      const earnedProgress = badgeProgress.filter(bp => bp.earned);
+      for (const progress of earnedProgress) {
+        const badge: Badge = {
+          ...progress.badge,
+          criteria: {},
+          created: progress.created,
+          updated: progress.updated,
+        };
+
+        const target = getTargetProgress(badge);
+        displays.push({
+          badge,
+          progress,
+          earned: true,
+          progressText: `${progress.progress} / ${target}`,
+        });
+      }
+
+      displays.sort((a, b) => a.badge.order - b.badge.order);
+    }
+
+    return displays;
+  }, [allBadges, badgeProgress, isCurrentUser]);
+
+  if (badgesToDisplay.length === 0) {
+    return null;
+  }
+
+  return (
+    <Box px="md" mb="lg">
+      <Card
+        withBorder
+        radius="md"
+        p={0}
+      >
+        <Box
+          p="md"
+          style={{
+            background: 'light-dark(var(--mantine-color-gray-1), var(--mantine-color-dark-6))',
+            borderBottom: '1px solid light-dark(var(--mantine-color-gray-3), var(--mantine-color-dark-4))'
+          }}
+        >
+          <Text size="sm" fw={600} tt="uppercase" c="dimmed" style={{ letterSpacing: '0.5px' }}>
+            Badges
+          </Text>
+        </Box>
+
+        <Box
+          p="md"
+          mah={120}
+          style={{
+            display: 'grid',
+            gridTemplateColumns: 'repeat(auto-fill, minmax(110px, 1fr))',
+            gap: 'var(--mantine-spacing-sm)',
+            overflow: 'scroll',
+          }}
+        >
+          {badgesToDisplay.map((display) => (
+            <Tooltip
+              key={display.badge.id}
+              label={
+                <Box>
+                  <Text size="xs" fw={600} mb={4}>
+                    {display.badge.name}
+                  </Text>
+                  <Text size="xs" mb={4}>
+                    {display.badge.description}
+                  </Text>
+                  {isCurrentUser && (
+                    <Text size="xs" c="dimmed">
+                      Progress: {display.progressText}
+                    </Text>
+                  )}
+                </Box>
+              }
+              multiline
+              w={220}
+            >
+              <Card
+                withBorder
+                padding="sm"
+                radius="md"
+                shadow={display.earned ? "xs" : undefined}
+                style={(theme) => ({
+                  opacity: display.earned ? 1 : 0.35,
+                  cursor: "pointer",
+                  transition: 'all 0.2s ease',
+                  minHeight: 70,
+                  display: 'flex',
+                  alignItems: 'center',
+                  justifyContent: 'center',
+                  borderStyle: display.earned ? 'solid' : 'dashed',
+                  ':hover': {
+                    transform: display.earned ? 'translateY(-2px)' : 'none',
+                    boxShadow: display.earned ? theme.shadows.sm : undefined,
+                  },
+                })}
+              >
+                <Text
+                  size="xs"
+                  ta="center"
+                  fw={display.earned ? 600 : 500}
+                  c={display.earned ? undefined : "dimmed"}
+                  style={{ lineHeight: 1.3 }}
+                >
+                  {display.badge.name}
+                </Text>
+              </Card>
+            </Tooltip>
+          ))}
+        </Box>
+      </Card>
+    </Box>
+  );
+};
+
+function getTargetProgress(badge: Badge): number {
+  const criteria = badge.criteria;
+  return (
+    criteria.matches_played ||
+    criteria.tournament_wins ||
+    criteria.tournaments_attended ||
+    criteria.overtime_matches ||
+    criteria.overtime_wins ||
+    criteria.consecutive_wins ||
+    1
+  );
+}
+
+export default BadgeShowcase;

src/features/badges/queries.ts

@@ -0,0 +1,24 @@
+import { useServerSuspenseQuery } from "@/lib/tanstack-query/hooks";
+import { getPlayerBadges, getAllBadges } from "./server";
+
+export const badgeKeys = {
+  playerBadges: (playerId: string) => ['badges', 'player', playerId],
+  allBadges: () => ['badges', 'all'],
+};
+
+export const badgeQueries = {
+  playerBadges: (playerId: string) => ({
+    queryKey: badgeKeys.playerBadges(playerId),
+    queryFn: async () => await getPlayerBadges({ data: playerId })
+  }),
+  allBadges: () => ({
+    queryKey: badgeKeys.allBadges(),
+    queryFn: async () => await getAllBadges()
+  }),
+};
+
+export const usePlayerBadges = (playerId: string) =>
+  useServerSuspenseQuery(badgeQueries.playerBadges(playerId));
+
+export const useAllBadges = () =>
+  useServerSuspenseQuery(badgeQueries.allBadges());

src/features/badges/server.ts

@@ -1,4 +1,34 @@
 import { toServerResult } from "@/lib/tanstack-query/utils/to-server-result";
-import { superTokensAdminFunctionMiddleware } from "@/utils/supertokens";
+import { superTokensAdminFunctionMiddleware, superTokensFunctionMiddleware } from "@/utils/supertokens";
 import { createServerFn } from "@tanstack/react-start";
+import { pbAdmin } from "@/lib/pocketbase/client";
+import { z } from "zod";
 
+export const getPlayerBadges = createServerFn()
+  .inputValidator(z.string())
+  .middleware([superTokensFunctionMiddleware])
+  .handler(async ({ data: playerId }) =>
+    toServerResult(() => pbAdmin.getPlayerBadgeProgress(playerId))
+  );
+
+export const migrateBadgeProgress = createServerFn()
+  .middleware([superTokensAdminFunctionMiddleware])
+  .handler(async () =>
+    toServerResult(() => pbAdmin.migrateBadgeProgress())
+  );
+
+export const getAllBadges = createServerFn()
+  .middleware([superTokensFunctionMiddleware])
+  .handler(async () =>
+    toServerResult(() => pbAdmin.listBadges())
+  );
+
+export const awardManualBadge = createServerFn()
+  .inputValidator(z.object({
+    playerId: z.string(),
+    badgeId: z.string(),
+  }))
+  .middleware([superTokensAdminFunctionMiddleware])
+  .handler(async ({ data }) =>
+    toServerResult(() => pbAdmin.awardManualBadge(data.playerId, data.badgeId))
+  );

src/features/badges/types.ts

@@ -0,0 +1,25 @@
+export interface BadgeInfo {
+  id: string;
+  name: string;
+  key: string;
+  description: string;
+  type: "manual" | "match" | "tournament";
+  progressive: boolean;
+  order: number;
+}
+
+export interface Badge extends BadgeInfo {
+  criteria: Record<string, any>;
+  created: string;
+  updated: string;
+}
+
+export interface BadgeProgress {
+  id: string;
+  badge: BadgeInfo;
+  player: string;
+  progress: number;
+  earned: boolean;
+  created: string;
+  updated: string;
+}

src/features/core/components/layout.tsx

@@ -31,7 +31,11 @@ const Layout: React.FC<PropsWithChildren> = ({ children }) => {
       pos='relative'
       h='100dvh'
       mah='100dvh'
-      // style={{ top: viewport.top }} //, transition: 'top 0.1s ease-in-out' }}
+      style={{
+        height: `${viewport.height}px`,
+        minHeight: '100dvh',
+        // top: viewport.top
+      }}
     >
       <Header {...header} />
       <AppShell.Main

src/features/core/components/navbar.tsx

@@ -19,7 +19,7 @@ const Navbar = () => {
   //  boxShadow: `5px 5px ${boxShadowColor}`, borderColor
 
   if (isMobile) return (
-    <Paper component='nav' role='navigation' withBorder shadow="sm" radius='lg' h='4rem' w='calc(100% - 1.5rem)' pos='fixed' m='0.75rem' bottom='0' style={{ zIndex: 10 }}>
+    <Paper component='nav' role='navigation' withBorder shadow="sm" radius='lg' h='4rem' w='calc(100% - 1rem)' pos='fixed' m='0.5rem' bottom='0' style={{ zIndex: 10 }}>
       <Group gap='xs' justify='space-around' h='100%' w='100%' px={{ base: 12, sm: 0 }}>
         {links.map((link) => (
           <NavLink key={link.href} {...link} />

src/features/core/hooks/use-visual-viewport-size.ts

@@ -19,11 +19,17 @@ const useVisualViewportSize = () => {
 
   useEffect(() => {
     if (!windowExists) return;
+
+    setSize();
+
     window.visualViewport?.addEventListener('resize', setSize, eventListerOptions);
+    window.visualViewport?.addEventListener('scroll', setSize, eventListerOptions);
+
     return () => {
       window.visualViewport?.removeEventListener('resize', setSize);
+      window.visualViewport?.removeEventListener('scroll', setSize);
     }
-  }, []);
+  }, [setSize]);
 
   return windowSize;
 }

src/features/matches/server.ts

@@ -9,6 +9,7 @@ import { MatchInput } from "@/features/matches/types";
 import { serverEvents } from "@/lib/events/emitter";
 import { superTokensFunctionMiddleware } from "@/utils/supertokens";
 import { PlayerInfo } from "../players/types";
+import { serverFnLoggingMiddleware } from "@/utils/activities";
 
 const orderedTeamsSchema = z.object({
   tournamentId: z.string(),
@@ -17,7 +18,7 @@ const orderedTeamsSchema = z.object({
 
 export const generateTournamentBracket = createServerFn()
   .inputValidator(orderedTeamsSchema)
-  .middleware([superTokensAdminFunctionMiddleware])
+  .middleware([superTokensAdminFunctionMiddleware, serverFnLoggingMiddleware])
   .handler(async ({ data: { tournamentId, orderedTeamIds } }) =>
     toServerResult(async () => {
       logger.info("Generating tournament bracket", {
@@ -138,7 +139,7 @@ export const generateTournamentBracket = createServerFn()
 
 export const startMatch = createServerFn()
   .inputValidator(z.string())
-  .middleware([superTokensAdminFunctionMiddleware])
+  .middleware([superTokensAdminFunctionMiddleware, serverFnLoggingMiddleware])
   .handler(async ({ data }) =>
     toServerResult(async () => {
       logger.info("Starting match", data);
@@ -171,7 +172,7 @@ const endMatchSchema = z.object({
 });
 export const endMatch = createServerFn()
   .inputValidator(endMatchSchema)
-  .middleware([superTokensAdminFunctionMiddleware])
+  .middleware([superTokensAdminFunctionMiddleware, serverFnLoggingMiddleware])
   .handler(async ({ data: { matchId, home_cups, away_cups, ot_count } }) =>
     toServerResult(async () => {
       logger.info("Ending match", matchId);

src/features/players/components/profile/index.tsx

@@ -1,10 +1,13 @@
 import { Box } from "@mantine/core";
+import { Suspense } from "react";
 import Header from "./header";
 import SwipeableTabs from "@/components/swipeable-tabs";
 import { usePlayer, usePlayerMatches, usePlayerStats } from "../../queries";
 import TeamList from "@/features/teams/components/team-list";
 import StatsOverview from "@/components/stats-overview";
 import MatchList from "@/features/matches/components/match-list";
+import BadgeShowcase from "@/features/badges/components/badge-showcase";
+import BadgeShowcaseSkeleton from "@/features/badges/components/badge-showcase-skeleton";
 
 interface ProfileProps {
   id: string;
@@ -18,7 +21,14 @@ const Profile = ({ id }: ProfileProps) => {
   const tabs = [
     {
       label: "Overview",
-      content: <StatsOverview statsData={stats} isLoading={statsLoading} />,
+      content: (
+        <>
+          <Suspense fallback={<BadgeShowcaseSkeleton />}>
+            <BadgeShowcase playerId={id} />
+          </Suspense>
+          <StatsOverview statsData={stats} isLoading={statsLoading} />
+        </>
+      ),
     },
     {
       label: "Matches",

src/features/players/server.ts

@@ -7,6 +7,7 @@ import { z } from "zod";
 import { logger } from ".";
 import { getRequest } from "@tanstack/react-start/server";
 import { toServerResult } from "@/lib/tanstack-query/utils/to-server-result";
+import { serverFnLoggingMiddleware } from "@/utils/activities";
 
 export const fetchMe = createServerFn()
   .handler(async () => 
@@ -46,7 +47,7 @@ export const getPlayer = createServerFn()
 
 export const updatePlayer = createServerFn()
   .inputValidator(playerUpdateSchema)
-  .middleware([superTokensFunctionMiddleware])
+  .middleware([superTokensFunctionMiddleware, serverFnLoggingMiddleware])
   .handler(async ({ context, data }) => 
     toServerResult(async () => {
       const userAuthId = context.userAuthId;
@@ -98,7 +99,7 @@ export const createPlayer = createServerFn()
 
 export const associatePlayer = createServerFn()
   .inputValidator(z.string())
-  .middleware([superTokensFunctionMiddleware])
+  .middleware([superTokensFunctionMiddleware, serverFnLoggingMiddleware])
   .handler(async ({ context, data }) => 
     toServerResult(async () => {
       const userAuthId = context.userAuthId;

src/features/teams/server.ts

@@ -6,6 +6,7 @@ import { toServerResult } from "@/lib/tanstack-query/utils/to-server-result";
 import { teamInputSchema, teamUpdateSchema } from "./types";
 import { logger } from "@/lib/logger";
 import { Match } from "../matches/types";
+import { serverFnLoggingMiddleware } from "@/utils/activities";
 
 
 export const listTeamInfos = createServerFn()
@@ -30,7 +31,7 @@ export const getTeamInfo = createServerFn()
 
 export const createTeam = createServerFn()
   .inputValidator(teamInputSchema)
-  .middleware([superTokensFunctionMiddleware])
+  .middleware([superTokensFunctionMiddleware, serverFnLoggingMiddleware])
   .handler(async ({ data, context }) => 
     toServerResult(async () => {
       const userId = context.userAuthId;
@@ -50,7 +51,7 @@ export const updateTeam = createServerFn()
     id: z.string(),
     updates: teamUpdateSchema
   }))
-  .middleware([superTokensFunctionMiddleware])
+  .middleware([superTokensFunctionMiddleware, serverFnLoggingMiddleware])
   .handler(async ({ data: { id, updates }, context }) =>
     toServerResult(async () => {
       const userId = context.userAuthId;
@@ -61,10 +62,10 @@ export const updateTeam = createServerFn()
         throw new Error("Team not found");
       }
 
-      const isPlayerOnTeam = team.players.some(player => player.id === userId);
-      if (!isAdmin && !isPlayerOnTeam) {
-        throw new Error("You can only update teams that you are a member of");
-      }
+      //const isPlayerOnTeam = team.players.some(player => player.id === userId);
+      //if (!isAdmin && !isPlayerOnTeam) {
+      //  throw new Error("You can only update teams that you are a member of");
+      // }
 
       logger.info("Updating team", { teamId: id, userId, isAdmin });
       return pbAdmin.updateTeam(id, updates);

src/features/tournaments/server.ts

@@ -5,6 +5,7 @@ import { tournamentInputSchema } from "@/features/tournaments/types";
 import { logger } from ".";
 import { z } from "zod";
 import { toServerResult } from "@/lib/tanstack-query/utils/to-server-result";
+import { serverFnLoggingMiddleware } from "@/utils/activities";
 
 export const listTournaments = createServerFn()
   .middleware([superTokensFunctionMiddleware])
@@ -14,7 +15,7 @@ export const listTournaments = createServerFn()
 
 export const createTournament = createServerFn()
   .inputValidator(tournamentInputSchema)
-  .middleware([superTokensAdminFunctionMiddleware])
+  .middleware([superTokensAdminFunctionMiddleware, serverFnLoggingMiddleware])
   .handler(async ({ data }) => 
     toServerResult(() => pbAdmin.createTournament(data))
   );
@@ -24,7 +25,7 @@ export const updateTournament = createServerFn()
     id: z.string(),
     updates: tournamentInputSchema.partial()
   }))
-  .middleware([superTokensAdminFunctionMiddleware])
+  .middleware([superTokensAdminFunctionMiddleware, serverFnLoggingMiddleware])
   .handler(async ({ data }) => 
     toServerResult(() => pbAdmin.updateTournament(data.id, data.updates))
   );
@@ -48,7 +49,7 @@ export const enrollTeam = createServerFn()
     tournamentId: z.string(),
     teamId: z.string()
   }))
-  .middleware([superTokensFunctionMiddleware])
+  .middleware([superTokensFunctionMiddleware, serverFnLoggingMiddleware])
   .handler(async ({ data: { tournamentId, teamId }, context }) => 
     toServerResult(async () => {
       const userId = context.userAuthId;
@@ -57,11 +58,11 @@ export const enrollTeam = createServerFn()
       const team = await pbAdmin.getTeam(teamId);
       if (!team) { throw new Error('Team not found'); }
 
-      const isPlayerOnTeam = team.players?.some(player => player.id === userId);
+      //const isPlayerOnTeam = team.players?.some(player => player.id === userId);
 
-      if (!isPlayerOnTeam && !isAdmin) {
-        throw new Error('You do not have permission to enroll this team');
-      }
+      //if (!isPlayerOnTeam && !isAdmin) {
+      //  throw new Error('You do not have permission to enroll this team');
+      //}
 
       logger.info('Enrolling team in tournament', { tournamentId, teamId, userId });
       const tournament = await pbAdmin.enrollTeam(tournamentId, teamId);
@@ -74,7 +75,7 @@ export const unenrollTeam = createServerFn()
     tournamentId: z.string(),
     teamId: z.string()
   }))
-  .middleware([superTokensAdminFunctionMiddleware])
+  .middleware([superTokensFunctionMiddleware, serverFnLoggingMiddleware])
   .handler(async ({ data: { tournamentId, teamId }, context }) => 
     toServerResult(() => pbAdmin.unenrollTeam(tournamentId, teamId))
   );
@@ -95,7 +96,7 @@ export const getFreeAgents = createServerFn()
 
 export const enrollFreeAgent = createServerFn()
   .inputValidator(z.object({ phone: z.string(), tournamentId: z.string() }))
-  .middleware([superTokensFunctionMiddleware])
+  .middleware([superTokensFunctionMiddleware, serverFnLoggingMiddleware])
   .handler(async ({ context, data }) =>
     toServerResult(async () => {
       const userAuthId = context.userAuthId;
@@ -109,7 +110,7 @@ export const enrollFreeAgent = createServerFn()
 
 export const unenrollFreeAgent = createServerFn()
   .inputValidator(z.object({ tournamentId: z.string() }))
-  .middleware([superTokensFunctionMiddleware])
+  .middleware([superTokensFunctionMiddleware, serverFnLoggingMiddleware])
   .handler(async ({ context, data }) =>
     toServerResult(async () => {
       const userAuthId = context.userAuthId;

src/hooks/use-server-events.ts

@@ -19,6 +19,7 @@ const eventHandlers: Record<string, EventHandler> = {
     logger.info("New Connection");
   },
   "ping": () => {},
+  "heartbeat": () => {},
   "match": (event, queryClient) => {
     queryClient.invalidateQueries(tournamentQueries.details(event.tournamentId))
     queryClient.invalidateQueries(tournamentQueries.current())
@@ -73,15 +74,15 @@ export function useServerEvents() {
         logger.error("SSE connection error", error);
         eventSource.close();
 
-        if (shouldConnectRef.current && retryCountRef.current < 5) {
+        if (shouldConnectRef.current && retryCountRef.current < 10) {
           retryCountRef.current += 1;
           const delay = Math.min(
-            1000 * Math.pow(2, retryCountRef.current - 1),
-            30000
+            1000 * Math.pow(1.5, retryCountRef.current - 1),
+            15000
           );
 
           logger.info(
-            `SSE reconnection attempt ${retryCountRef.current}/5 in ${delay}ms`
+            `SSE reconnection attempt ${retryCountRef.current}/10 in ${delay}ms`
           );
 
           timeoutRef.current = setTimeout(() => {
@@ -89,7 +90,7 @@ export function useServerEvents() {
               connectEventSource();
             }
           }, delay);
-        } else if (retryCountRef.current >= 5) {
+        } else if (retryCountRef.current >= 10) {
           logger.error("SSE max reconnection attempts reached");
         }
       };

src/lib/events/emitter.ts

@@ -2,6 +2,23 @@ import { EventEmitter } from "events";
 
 export const serverEvents = new EventEmitter();
 
+serverEvents.setMaxListeners(50);
+
+// Debug logging for listener count
+if (process.env.NODE_ENV === 'development') {
+  setInterval(() => {
+    const listenerCounts = {
+      test: serverEvents.listenerCount('test'),
+      match: serverEvents.listenerCount('match'),
+      reaction: serverEvents.listenerCount('reaction'),
+    };
+
+    if (listenerCounts.test > 0 || listenerCounts.match > 0 || listenerCounts.reaction > 0) {
+      console.log('ServerEvents listener count:', listenerCounts);
+    }
+  }, 30000); // Log every 30 seconds in development
+}
+
 export type TestEvent = {
   type: "test";
   playerId: string;

src/lib/pocketbase/client.ts

@@ -4,6 +4,8 @@ import { createTournamentsService } from "./services/tournaments";
 import { createTeamsService } from "./services/teams";
 import { createMatchesService } from "./services/matches";
 import { createReactionsService } from "./services/reactions";
+import { createActivitiesService } from "./services/activities";
+import { createBadgesService } from "./services/badges";
 import dotenv from 'dotenv';
 dotenv.config();
 
@@ -35,6 +37,8 @@ class PocketBaseAdminClient {
       Object.assign(this, createTournamentsService(this.pb));
       Object.assign(this, createMatchesService(this.pb));
       Object.assign(this, createReactionsService(this.pb));
+      Object.assign(this, createActivitiesService(this.pb));
+      Object.assign(this, createBadgesService(this.pb));
     });
   }
 
@@ -54,7 +58,9 @@ interface AdminClient
     ReturnType<typeof createTeamsService>,
     ReturnType<typeof createTournamentsService>,
     ReturnType<typeof createMatchesService>,
-    ReturnType<typeof createReactionsService> {
+    ReturnType<typeof createReactionsService>,
+    ReturnType<typeof createActivitiesService>,
+    ReturnType<typeof createBadgesService> {
   authPromise: Promise<void>;
 }
 

src/lib/pocketbase/services/activities.ts

@@ -0,0 +1,56 @@
+import PocketBase from "pocketbase";
+
+export interface Activity {
+  id: string;
+  name: string;
+  player?: string;
+  duration: number;
+  success: boolean;
+  error?: string;
+  arguments?: any;
+  user_agent?: string;
+  created: string;
+  updated: string;
+}
+
+export interface ActivityInput {
+  name: string;
+  player?: string;
+  duration: number;
+  success: boolean;
+  error?: string;
+  arguments?: any;
+  user_agent?: string;
+}
+
+export function createActivitiesService(pb: PocketBase) {
+  return {
+    async createActivity(data: ActivityInput): Promise<Activity> {
+      const result = await pb.collection("activities").create<Activity>(data);
+      return result;
+    },
+
+    async getRecentActivities(limit: number = 100): Promise<Activity[]> {
+      const result = await pb.collection("activities").getList<Activity>(1, limit, {
+        sort: "-created",
+      });
+      return result.items;
+    },
+
+    async getActivitiesByUser(userId: string, limit: number = 50): Promise<Activity[]> {
+      const result = await pb.collection("activities").getList<Activity>(1, limit, {
+        filter: `user_id = "${userId}"`,
+        sort: "-created",
+      });
+      return result.items;
+    },
+
+    async getActivitiesByFunction(functionName: string, limit: number = 50): Promise<Activity[]> {
+      const result = await pb.collection("activities").getList<Activity>(1, limit, {
+        filter: `function_name = "${functionName}"`,
+        sort: "-created",
+      });
+      return result.items;
+    },
+  };
+}

src/lib/pocketbase/services/badges.ts

@@ -0,0 +1,433 @@
+import PocketBase from "pocketbase";
+import { Badge, BadgeProgress } from "@/features/badges/types";
+import { transformBadge, transformBadgeProgress } from "@/lib/pocketbase/util/transform-types";
+
+export interface PlayerStats {
+  player_id: string;
+  matches: number;
+  wins: number;
+  losses: number;
+  total_cups_made: number;
+  total_cups_against: number;
+  margin_of_victory: number;
+}
+
+export function createBadgesService(pb: PocketBase) {
+  return {
+    async getBadge(id: string): Promise<Badge> {
+      const result = await pb.collection("badges").getOne(id);
+      return transformBadge(result);
+    },
+
+    async listBadges(): Promise<Badge[]> {
+      const results = await pb.collection("badges").getFullList({
+        sort: 'name',
+      });
+      return results.map(transformBadge);
+    },
+
+    async getBadgeProgress(id: string): Promise<BadgeProgress> {
+      const result = await pb.collection("badge_progress").getOne(id, {
+        expand: 'badge,player',
+      });
+      return transformBadgeProgress(result);
+    },
+
+    async getPlayerBadgeProgress(playerId: string): Promise<BadgeProgress[]> {
+      const results = await pb.collection("badge_progress").getFullList({
+        filter: `player = "${playerId}"`,
+        expand: 'badge',
+      });
+      return results.map(transformBadgeProgress);
+    },
+
+    async createBadgeProgress(data: {
+      badge: string;
+      player: string;
+      progress: number;
+      earned: boolean;
+    }): Promise<BadgeProgress> {
+      return await pb.collection("badge_progress").create<BadgeProgress>(data);
+    },
+
+    async updateBadgeProgress(id: string, data: {
+      progress?: number;
+      earned?: boolean;
+    }): Promise<BadgeProgress> {
+      return await pb.collection("badge_progress").update<BadgeProgress>(id, data);
+    },
+
+    async deleteBadgeProgress(id: string): Promise<boolean> {
+      await pb.collection("badge_progress").delete(id);
+      return true;
+    },
+
+    async clearAllBadgeProgress(): Promise<number> {
+      const existingProgress = await pb.collection("badge_progress").getFullList();
+      for (const progress of existingProgress) {
+        await pb.collection("badge_progress").delete(progress.id);
+      }
+      return existingProgress.length;
+    },
+
+    async calculateBadgeProgress(playerId: string, badge: Badge): Promise<number> {
+      if (badge.type === "manual") {
+        return 0;
+      }
+
+      if (badge.type === "match") {
+        return await this.calculateMatchBadgeProgress(playerId, badge);
+      }
+
+      if (badge.type === "tournament") {
+        return await this.calculateTournamentBadgeProgress(playerId, badge);
+      }
+
+      return 0;
+    },
+
+    async calculateMatchBadgeProgress(playerId: string, badge: Badge): Promise<number> {
+      const criteria = badge.criteria;
+
+      const stats = await pb.collection("player_stats").getFirstListItem<PlayerStats>(
+        `player_id = "${playerId}"`
+      ).catch(() => null);
+
+      if (!stats) return 0;
+
+      if (criteria.matches_played !== undefined) {
+        return stats.matches;
+      }
+
+      if (criteria.overtime_matches !== undefined || criteria.overtime_wins !== undefined) {
+        const matches = await pb.collection("matches").getFullList({
+          filter: `(home.players.id ?~ "${playerId}" || away.players.id ?~ "${playerId}") && status = "ended" && ot_count > 0`,
+          expand: 'home,away,home.players,away.players',
+        });
+
+        if (criteria.overtime_matches !== undefined) {
+          return matches.length;
+        }
+
+        if (criteria.overtime_wins !== undefined) {
+          const overtimeWins = matches.filter(m => {
+            const isHome = m.expand?.home?.expand?.players?.some((p: any) => p.id === playerId) ||
+                           m.expand?.home?.players?.includes(playerId);
+            const isAway = m.expand?.away?.expand?.players?.some((p: any) => p.id === playerId) ||
+                           m.expand?.away?.players?.includes(playerId);
+
+            if (isHome) {
+              return m.home_cups > m.away_cups;
+            } else if (isAway) {
+              return m.away_cups > m.home_cups;
+            }
+            return false;
+          });
+          return overtimeWins.length;
+        }
+      }
+
+      if (criteria.margin_of_victory !== undefined) {
+        const matches = await pb.collection("matches").getFullList({
+          filter: `(home.players.id ?~ "${playerId}" || away.players.id ?~ "${playerId}") && status = "ended"`,
+          expand: 'home,away,home.players,away.players',
+        });
+
+        const bigWins = matches.filter(m => {
+          const isHome = m.expand?.home?.expand?.players?.some((p: any) => p.id === playerId) ||
+                         m.expand?.home?.players?.includes(playerId);
+          const isAway = m.expand?.away?.expand?.players?.some((p: any) => p.id === playerId) ||
+                         m.expand?.away?.players?.includes(playerId);
+
+          if (isHome && m.home_cups > m.away_cups) {
+            return (m.home_cups - m.away_cups) >= criteria.margin_of_victory;
+          } else if (isAway && m.away_cups > m.home_cups) {
+            return (m.away_cups - m.home_cups) >= criteria.margin_of_victory;
+          }
+          return false;
+        });
+
+        return bigWins.length > 0 ? 1 : 0;
+      }
+
+      return 0;
+    },
+
+    async calculateTournamentBadgeProgress(playerId: string, badge: Badge): Promise<number> {
+      const criteria = badge.criteria;
+
+      const matches = await pb.collection("matches").getFullList({
+        filter: `(home.players.id ?~ "${playerId}" || away.players.id ?~ "${playerId}") && status = "ended"`,
+        expand: 'tournament,home,away,home.players,away.players',
+      });
+
+      const tournamentIds = new Set(matches.map(m => m.tournament));
+      const tournamentsAttended = tournamentIds.size;
+
+      if (criteria.tournaments_attended !== undefined) {
+        return tournamentsAttended;
+      }
+
+      if (criteria.tournament_wins !== undefined) {
+        if (tournamentIds.size === 0) return 0;
+
+        let tournamentWins = 0;
+
+        for (const tournamentId of tournamentIds) {
+          const tournamentMatches = await pb.collection("matches").getFullList({
+            filter: `tournament = "${tournamentId}" && status = "ended"`,
+            expand: 'home,away,home.players,away.players',
+          });
+
+          const winnersMatches = tournamentMatches.filter(m => !m.is_losers_bracket);
+          const finalsMatch = winnersMatches.reduce((highest: any, current: any) =>
+            (!highest || current.lid > highest.lid) ? current : highest, null);
+
+          if (finalsMatch && finalsMatch.status === 'ended') {
+            const finalsWinnerId = (finalsMatch.home_cups > finalsMatch.away_cups) ? finalsMatch.home : finalsMatch.away;
+
+            const winningTeam = finalsMatch.expand?.[finalsWinnerId === finalsMatch.home ? 'home' : 'away'];
+            const winningPlayers = winningTeam?.expand?.players || winningTeam?.players || [];
+
+            const playerWon = winningPlayers.some((p: any) =>
+              (typeof p === 'string' ? p : p.id) === playerId
+            );
+
+            if (playerWon) {
+              tournamentWins++;
+            }
+          }
+        }
+
+        return tournamentWins;
+      }
+
+      if (criteria.placement !== undefined && typeof criteria.placement === 'number') {
+        let placementCount = 0;
+
+        for (const tournamentId of tournamentIds) {
+          const tournamentMatches = await pb.collection("matches").getFullList({
+            filter: `tournament = "${tournamentId}" && status = "ended"`,
+            expand: 'home,away,home.players,away.players',
+          });
+
+          if (criteria.placement === 2) {
+            const winnersMatches = tournamentMatches.filter(m => !m.is_losers_bracket);
+            const finalsMatch = winnersMatches.reduce((highest: any, current: any) =>
+              (!highest || current.lid > highest.lid) ? current : highest, null);
+
+            if (finalsMatch && finalsMatch.status === 'ended') {
+              const finalsLoserId = (finalsMatch.home_cups > finalsMatch.away_cups) ? finalsMatch.away : finalsMatch.home;
+
+              const losingTeam = finalsMatch.expand?.[finalsLoserId === finalsMatch.home ? 'home' : 'away'];
+              const losingPlayers = losingTeam?.expand?.players || losingTeam?.players || [];
+
+              const playerLost = losingPlayers.some((p: any) =>
+                (typeof p === 'string' ? p : p.id) === playerId
+              );
+
+              if (playerLost) {
+                placementCount++;
+              }
+            }
+          }
+
+          if (criteria.placement === 3) {
+            const losersMatches = tournamentMatches.filter(m => m.is_losers_bracket);
+            const losersFinale = losersMatches.reduce((highest: any, current: any) =>
+              (!highest || current.lid > highest.lid) ? current : highest, null);
+
+            if (losersFinale && losersFinale.status === 'ended') {
+              const losersFinaleLoserId = (losersFinale.home_cups > losersFinale.away_cups) ? losersFinale.away : losersFinale.home;
+
+              const losingTeam = losersFinale.expand?.[losersFinaleLoserId === losersFinale.home ? 'home' : 'away'];
+              const losingPlayers = losingTeam?.expand?.players || losingTeam?.players || [];
+
+              const playerLost = losingPlayers.some((p: any) =>
+                (typeof p === 'string' ? p : p.id) === playerId
+              );
+
+              if (playerLost) {
+                placementCount++;
+              }
+            }
+          }
+        }
+
+        return placementCount;
+      }
+
+      if (criteria.tournament_record !== undefined) {
+        const tournaments = await pb.collection("tournaments").getFullList({
+          sort: 'start_time',
+        });
+
+        let timesWent02 = 0;
+
+        for (const tournamentId of tournamentIds) {
+          const tournament = tournaments.find(t => t.id === tournamentId);
+          if (!tournament) continue;
+
+          const tournamentMatches = matches.filter(m => m.tournament === tournamentId);
+
+          let wins = 0;
+          let losses = 0;
+
+          for (const match of tournamentMatches) {
+            const isHome = match.expand?.home?.expand?.players?.some((p: any) => p.id === playerId) ||
+                           match.expand?.home?.players?.includes(playerId);
+            const isAway = match.expand?.away?.expand?.players?.some((p: any) => p.id === playerId) ||
+                           match.expand?.away?.players?.includes(playerId);
+
+            if (isHome && match.home_cups > match.away_cups) {
+              wins++;
+            } else if (isAway && match.away_cups > match.home_cups) {
+              wins++;
+            } else {
+              losses++;
+            }
+          }
+
+          const record = `${wins}-${losses}`;
+
+          if (record === criteria.tournament_record) {
+            if (criteria.won_previous !== undefined && criteria.won_previous === true) {
+              const currentIndex = tournaments.findIndex(t => t.id === tournamentId);
+              if (currentIndex > 0) {
+                const previousTournament = tournaments[currentIndex - 1];
+                if (previousTournament.winner_id === playerId) {
+                  timesWent02++;
+                }
+              }
+            } else {
+              timesWent02++;
+            }
+          }
+        }
+
+        return timesWent02 > 0 ? 1 : 0;
+      }
+
+      if (criteria.consecutive_wins !== undefined) {
+        const tournaments = await pb.collection("tournaments").getFullList({
+          sort: 'start_time',
+        });
+
+        let consecutiveWins = 0;
+        let maxConsecutiveWins = 0;
+
+        for (const tournament of tournaments) {
+          if (!tournamentIds.has(tournament.id)) continue;
+
+          if (tournament.winner_id === playerId) {
+            consecutiveWins++;
+            maxConsecutiveWins = Math.max(maxConsecutiveWins, consecutiveWins);
+          } else {
+            consecutiveWins = 0;
+          }
+        }
+
+        return maxConsecutiveWins >= criteria.consecutive_wins ? 1 : 0;
+      }
+
+      return 0;
+    },
+
+    getTargetProgress(badge: Badge): number {
+      if (badge.type === "manual") {
+        return 1;
+      }
+
+      const criteria = badge.criteria;
+
+      return (
+        criteria.matches_played ||
+        criteria.tournament_wins ||
+        criteria.tournaments_attended ||
+        criteria.overtime_matches ||
+        criteria.overtime_wins ||
+        criteria.consecutive_wins ||
+        1
+      );
+    },
+
+    async awardManualBadge(playerId: string, badgeId: string): Promise<BadgeProgress> {
+      // Get or create badge progress record
+      const existingProgress = await pb.collection("badge_progress").getFirstListItem(
+        `player = "${playerId}" && badge = "${badgeId}"`,
+        { expand: 'badge' }
+      ).catch(() => null);
+
+      if (existingProgress) {
+        // Update existing progress to mark as earned
+        const updated = await pb.collection("badge_progress").update(existingProgress.id, {
+          progress: 1,
+          earned: true,
+        }, { expand: 'badge' });
+        return transformBadgeProgress(updated);
+      }
+
+      // Create new progress record
+      const created = await pb.collection("badge_progress").create({
+        badge: badgeId,
+        player: playerId,
+        progress: 1,
+        earned: true,
+      }, { expand: 'badge' });
+      return transformBadgeProgress(created);
+    },
+
+    async migrateBadgeProgress(): Promise<{
+      success: boolean;
+      playersProcessed: number;
+      progressRecordsCreated: number;
+      totalBadgesEarned: number;
+      averageBadgesPerPlayer: string;
+    }> {
+      await this.clearAllBadgeProgress();
+
+      const badges = await this.listBadges();
+
+      const playerStats = await pb.collection("player_stats").getFullList<PlayerStats>();
+      const uniquePlayers = new Set(playerStats.map(s => s.player_id));
+
+      let totalProgressRecords = 0;
+      let totalBadgesEarned = 0;
+
+      for (const playerId of uniquePlayers) {
+        for (const badge of badges) {
+          try {
+            const progress = await this.calculateBadgeProgress(playerId, badge);
+            const target = this.getTargetProgress(badge);
+            const earned = progress >= target;
+
+            if (progress > 0 || earned) {
+              await this.createBadgeProgress({
+                badge: badge.id,
+                player: playerId,
+                progress: progress,
+                earned: earned,
+              });
+
+              totalProgressRecords++;
+
+              if (earned) {
+                totalBadgesEarned++;
+              }
+            }
+          } catch (error: any) {
+            console.error(`Error processing badge "${badge.name}" for player ${playerId}:`, error.message);
+          }
+        }
+      }
+
+      return {
+        success: true,
+        playersProcessed: uniquePlayers.size,
+        progressRecordsCreated: totalProgressRecords,
+        totalBadgesEarned: totalBadgesEarned,
+        averageBadgesPerPlayer: (totalBadgesEarned / uniquePlayers.size).toFixed(2),
+      };
+    },
+  };
+}

src/lib/pocketbase/util/transform-types.ts

@@ -3,6 +3,7 @@ import { Match } from "@/features/matches/types";
 import { Player, PlayerInfo } from "@/features/players/types";
 import { Team, TeamInfo } from "@/features/teams/types";
 import { Tournament, TournamentInfo } from "@/features/tournaments/types";
+import { Badge, BadgeInfo, BadgeProgress } from "@/features/badges/types";
 
 // pocketbase does this weird thing with relations where it puts them under a seperate "expand" field
 // this file transforms raw pocketbase results to our types
@@ -278,3 +279,36 @@ export function transformReaction(record: any) {
     match: record.match
   };
 }
+
+export function transformBadgeInfo(record: any): BadgeInfo {
+  return {
+    id: record.id,
+    name: record.name,
+    key: record.key,
+    description: record.description,
+    type: record.type,
+    progressive: record.progressive,
+    order: record.order ?? 999,
+  };
+}
+
+export function transformBadge(record: any): Badge {
+  return {
+    ...transformBadgeInfo(record),
+    criteria: record.criteria,
+    created: record.created,
+    updated: record.updated,
+  };
+}
+
+export function transformBadgeProgress(record: any): BadgeProgress {
+  return {
+    id: record.id,
+    badge: record.expand?.badge ? transformBadgeInfo(record.expand.badge) : record.badge,
+    player: record.player,
+    progress: record.progress,
+    earned: record.earned,
+    created: record.created,
+    updated: record.updated,
+  };
+}

src/lib/supertokens/server.ts

@@ -6,7 +6,7 @@ import UserRoles from "supertokens-node/recipe/userroles";
 import { appInfo } from "./config";
 import PasswordlessDevelopmentMode from "./recipes/passwordless-development-mode";
 import { logger } from "./";
-import passwordlessTwilioVerify from "./recipes/passwordless-twilio-verify";
+import PasswordlessTwilioVerify from "./recipes/passwordless-twilio-verify";
 
 export const backendConfig = (): TypeInput => {
   return {
@@ -17,7 +17,8 @@ export const backendConfig = (): TypeInput => {
     },
     appInfo,
     recipeList: [
-      passwordlessTwilioVerify.init(),
+      //PasswordlessTwilioVerify.init(),
+      PasswordlessDevelopmentMode.init(),
       Session.init({
         cookieSameSite: "lax",
         cookieSecure: import.meta.env.NODE_ENV === "production",

src/lib/twilio/index.ts

@@ -1,19 +1,31 @@
 import twilio, { type Twilio } from "twilio";
 
-const accountSid = process.env.TWILIO_ACCOUNT_SID!;
-const authToken = process.env.TWILIO_AUTH_TOKEN!;
-const serviceSid = process.env.TWILIO_SERVICE_SID!;
-
 let client: Twilio;
 
+function getEnvVars() {
+  const accountSid = process.env.TWILIO_ACCOUNT_SID;
+  const authToken = process.env.TWILIO_AUTH_TOKEN;
+  const serviceSid = process.env.TWILIO_SERVICE_SID;
+
+  if (!accountSid || !authToken || !serviceSid) {
+    throw new Error(`Missing env vars. accountSid: ${!!accountSid}, authToken: ${!!authToken}, serviceSid: ${!!serviceSid}`);
+  }
+
+  return { accountSid, authToken, serviceSid };
+}
+
 function getTwilioClient() {
   if (!client) {
+    const { accountSid, authToken } = getEnvVars();
     client = twilio(accountSid, authToken);
   }
   return client;
 }
 
+
 export async function sendVerifyCode(phoneNumber: string, code: string) {
+  const { serviceSid } = getEnvVars();
+
   const twilioClient = getTwilioClient();
 
   const verification = await twilioClient!.verify.v2
@@ -32,6 +44,7 @@ export async function sendVerifyCode(phoneNumber: string, code: string) {
 }
 
 export async function updateVerify(sid: string) {
+  const { serviceSid } = getEnvVars();
   const twilioClient = getTwilioClient();
 
   const verification = await twilioClient!.verify.v2

src/utils/activities.ts

@@ -0,0 +1,54 @@
+import { pbAdmin } from "@/lib/pocketbase/client";
+import { createMiddleware } from "@tanstack/react-start";
+import { getRequest } from "@tanstack/react-start/server";
+
+export const serverFnLoggingMiddleware = createMiddleware({
+  type: "function",
+}).server(async ({ next, data, functionId, context }) => {
+  const request = getRequest();
+
+  const serverFnName = functionId.split('--')[1]?.split('_')[0] || 'unknown';
+  const userId = (context as any)?.metadata?.player_id || 'unknown';
+
+  const startTime = Date.now();
+
+  try {
+    const result = await next();
+    const duration = Date.now() - startTime;
+
+
+    try {
+      await pbAdmin.authPromise;
+      await pbAdmin.createActivity({
+        name: serverFnName,
+        player: userId !== 'unknown' ? userId : undefined,
+        duration,
+        success: true,
+        arguments: data,
+        user_agent: request.headers.get('user-agent') || undefined,
+      });
+    } catch (activityError) {
+    }
+
+    return result;
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    const errorMessage = error instanceof Error ? error.message : String(error);
+
+    try {
+      await pbAdmin.authPromise;
+      await pbAdmin.createActivity({
+        name: serverFnName,
+        player: userId !== 'unknown' ? userId : undefined,
+        duration,
+        success: false,
+        error: errorMessage,
+        arguments: data,
+        user_agent: request.headers.get('user-agent') || undefined,
+      });
+    } catch (activityError) {
+    }
+
+    throw error;
+  }
+});