@sonatel-os/strapi-plugin-tcg 0.0.0-stage → 0.2.0

package/dist/server/index.mjs

@@ -0,0 +1,4484 @@
+import { createHash, timingSafeEqual, createHmac, randomBytes, randomInt } from "node:crypto";
+const PLUGIN_ID = "tcg";
+const PLUGIN_DISPLAY_NAME = "TCG";
+const LOG_PREFIX = "[tcg]";
+const UID = Object.freeze({
+  SEASON: "plugin::tcg.season",
+  PACK: "plugin::tcg.pack",
+  CARD: "plugin::tcg.card",
+  PACK_CARD: "plugin::tcg.pack-card",
+  PLAYER: "plugin::tcg.player",
+  PLAYER_CARD: "plugin::tcg.player-card",
+  PULL: "plugin::tcg.pull",
+  TRADE_OFFER: "plugin::tcg.trade-offer",
+  TRADE: "plugin::tcg.trade",
+  REDEMPTION: "plugin::tcg.redemption",
+  NONCE: "plugin::tcg.nonce",
+  DROP: "plugin::tcg.drop",
+  DROP_CARD: "plugin::tcg.drop-card",
+  BOOST: "plugin::tcg.boost",
+  REWARD: "plugin::tcg.reward",
+  CARD_SET: "plugin::tcg.card-set",
+  BADGE: "plugin::tcg.badge",
+  PLAYER_BADGE: "plugin::tcg.player-badge"
+});
+const RBAC = Object.freeze({
+  ACCESS: "access",
+  DASHBOARD_READ: "dashboard.read",
+  SEASONS_READ: "seasons.read",
+  SEASONS_WRITE: "seasons.write",
+  CARDS_READ: "cards.read",
+  CARDS_WRITE: "cards.write",
+  PACKS_READ: "packs.read",
+  PACKS_WRITE: "packs.write",
+  PACKS_QR: "packs.qr",
+  PLAYERS_READ: "players.read",
+  PLAYERS_WRITE: "players.write",
+  REDEMPTIONS_READ: "redemptions.read",
+  REDEMPTIONS_FULFILL: "redemptions.fulfill",
+  AUDIT_READ: "audit.read",
+  REWARDS_READ: "rewards.read",
+  REWARDS_WRITE: "rewards.write",
+  LIVE_READ: "live.read",
+  LIVE_WRITE: "live.write",
+  SETTINGS_READ: "settings.read",
+  SETTINGS_WRITE: "settings.write"
+});
+const SEASON_STATUS = Object.freeze({ DRAFT: "draft", ACTIVE: "active", ARCHIVED: "archived" });
+const PACK_KIND = Object.freeze({ LOCATION: "location", BOOSTER: "booster", EVENT: "event" });
+const ACQUISITION = Object.freeze({ PULL: "pull", TRADE: "trade", GRANT: "grant" });
+const TRADE_STATUS = Object.freeze({
+  PENDING: "pending",
+  ACCEPTED: "accepted",
+  REJECTED: "rejected",
+  EXPIRED: "expired",
+  CANCELLED: "cancelled"
+});
+const REDEMPTION_STATUS = Object.freeze({ PENDING: "pending", FULFILLED: "fulfilled", CANCELLED: "cancelled" });
+const NONCE_KIND = Object.freeze({ PACK: "pack", TRADE: "trade", DROP: "drop" });
+const DROP_MODE = Object.freeze({ STATIC: "static", ROTATING: "rotating" });
+const POOL_MODE = Object.freeze({ INHERIT: "inherit", EXTEND: "extend", OVERRIDE: "override" });
+const DEFAULT_DROP_NAME = "Entrée";
+const MAX_PULL_RETRIES = 3;
+const COST_RULE = Object.freeze({
+  CARDS: "cards",
+  // { type:'cards', count, rarity?, minRarity? }
+  CARD: "card",
+  // { type:'card', card:<documentId>, count? }
+  SET: "set"
+  // { type:'set', set:<slug>, consume? }  consume=false → owning the set is enough, no card handed in
+});
+const BADGE_RULE = Object.freeze({
+  PULLS: "pulls",
+  // { type:'pulls', count }
+  RARITY_PULLS: "rarity_pulls",
+  // { type:'rarity_pulls', rarity, count }
+  UNIQUE_CARDS: "unique_cards",
+  // { type:'unique_cards', count }
+  PACKS_VISITED: "packs_visited",
+  // { type:'packs_visited', count | 'all' }
+  DROPS_VISITED: "drops_visited",
+  // { type:'drops_visited', count }
+  TRADES: "trades",
+  // { type:'trades', count }
+  REDEMPTIONS: "redemptions",
+  // { type:'redemptions', count }
+  SET_COMPLETE: "set_complete",
+  // { type:'set_complete', set:<slug> | 'any' | 'all' }
+  STREAK_DAYS: "streak_days",
+  // { type:'streak_days', count }
+  COMPLETION: "completion",
+  // { type:'completion', percent }
+  MINT: "mint",
+  // { type:'mint', max }  own a copy with mintNumber <= max
+  SCAN_DROP: "scan_drop"
+  // { type:'scan_drop', drop:<slug> }
+});
+const DEFAULT_RARITIES = Object.freeze([
+  { key: "common", label: "Common", probability: 0.5, color: "#7A7A86", scoreMin: 10, scoreMax: 30 },
+  { key: "rare", label: "Rare", probability: 0.3, color: "#00BFFF", scoreMin: 35, scoreMax: 55 },
+  { key: "epic", label: "Epic", probability: 0.15, color: "#A020F0", scoreMin: 60, scoreMax: 80 },
+  { key: "legendary", label: "Legendary", probability: 0.05, color: "#FFD700", scoreMin: 85, scoreMax: 100 }
+]);
+const DEFAULT_EDITIONS = Object.freeze([
+  { key: "standard", label: "Standard" },
+  { key: "limited", label: "Limited" },
+  { key: "holographic", label: "Holographic" }
+]);
+const DEFAULT_LIMITS = Object.freeze({
+  pullCooldownMs: 5 * 60 * 1e3,
+  maxDailyPullsPerPack: 3,
+  maxDailyPullsTotal: 15,
+  maxCollectionSize: 100,
+  tradeOfferExpiryMs: 10 * 60 * 1e3,
+  maxActiveTradeOffers: 5,
+  maxCardsPerTrade: 3,
+  minCardsForRedemption: 1,
+  qrTokenTtlMs: 5 * 60 * 1e3,
+  staticScanCooldownMs: 24 * 60 * 60 * 1e3,
+  pityRareAfter: 0,
+  pityLegendaryAfter: 0
+});
+const DEFAULT_RANK_TIERS = Object.freeze([
+  { key: "legend", label: "Legend", minPercent: 100 },
+  { key: "champion", label: "Champion", minPercent: 80 },
+  { key: "elite", label: "Elite", minPercent: 60 },
+  { key: "expert", label: "Expert", minPercent: 40 },
+  { key: "explorer", label: "Explorer", minPercent: 20 },
+  { key: "collector", label: "Collector", minPercent: 1 },
+  { key: "debutant", label: "Debutant", minPercent: 0 }
+]);
+const CODE_CHARSET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+const PLAYER_CODE_LENGTH = 4;
+const REDEMPTION_CODE_LENGTH = 6;
+const QR_NONCE_BYTES = 16;
+const MAX_CODE_ATTEMPTS = 10;
+const NONCE_SWEEP_INTERVAL_MS = 60 * 1e3;
+const TRADE_SWEEP_INTERVAL_MS = 60 * 1e3;
+const DEFAULT_PAGE_SIZE = 20;
+const MAX_PAGE_SIZE = 100;
+const ERROR_CODES = Object.freeze({
+  AUTH_REQUIRED: "AUTH_REQUIRED",
+  AUTH_INVALID: "AUTH_INVALID",
+  PLAYER_REQUIRED: "PLAYER_REQUIRED",
+  PLAYER_NOT_FOUND: "PLAYER_NOT_FOUND",
+  PLAYER_INACTIVE: "PLAYER_INACTIVE",
+  SEASON_NOT_FOUND: "SEASON_NOT_FOUND",
+  SEASON_INACTIVE: "SEASON_INACTIVE",
+  PACK_NOT_FOUND: "PACK_NOT_FOUND",
+  PACK_INACTIVE: "PACK_INACTIVE",
+  PACK_EMPTY: "PACK_EMPTY",
+  QR_INVALID: "QR_INVALID",
+  QR_EXPIRED: "QR_EXPIRED",
+  QR_REUSED: "QR_REUSED",
+  COOLDOWN_ACTIVE: "COOLDOWN_ACTIVE",
+  DAILY_LIMIT_PACK: "DAILY_LIMIT_PACK",
+  DAILY_LIMIT_TOTAL: "DAILY_LIMIT_TOTAL",
+  COLLECTION_FULL: "COLLECTION_FULL",
+  CARD_NOT_FOUND: "CARD_NOT_FOUND",
+  CARD_NOT_OWNED: "CARD_NOT_OWNED",
+  TRADE_NOT_FOUND: "TRADE_NOT_FOUND",
+  TRADE_SELF: "TRADE_SELF",
+  TRADE_LIMIT: "TRADE_LIMIT",
+  TRADE_TOO_MANY_CARDS: "TRADE_TOO_MANY_CARDS",
+  TRADE_INVALID_STATUS: "TRADE_INVALID_STATUS",
+  TRADE_EXPIRED: "TRADE_EXPIRED",
+  TRADE_FORBIDDEN: "TRADE_FORBIDDEN",
+  REDEMPTION_NOT_FOUND: "REDEMPTION_NOT_FOUND",
+  REDEMPTION_TOO_FEW_CARDS: "REDEMPTION_TOO_FEW_CARDS",
+  REDEMPTION_INVALID_STATUS: "REDEMPTION_INVALID_STATUS",
+  DROP_NOT_FOUND: "DROP_NOT_FOUND",
+  DROP_CLOSED: "DROP_CLOSED",
+  DROP_SOLD_OUT: "DROP_SOLD_OUT",
+  DROP_PLAYER_LIMIT: "DROP_PLAYER_LIMIT",
+  REWARD_NOT_FOUND: "REWARD_NOT_FOUND",
+  REWARD_UNAVAILABLE: "REWARD_UNAVAILABLE",
+  REWARD_SOLD_OUT: "REWARD_SOLD_OUT",
+  REWARD_PLAYER_LIMIT: "REWARD_PLAYER_LIMIT",
+  REWARD_COST_UNMET: "REWARD_COST_UNMET",
+  VALIDATION: "VALIDATION"
+});
+const CATEGORY = PLUGIN_DISPLAY_NAME;
+const ACTIONS = [
+  { section: "plugins", uid: RBAC.ACCESS, displayName: `Access the ${PLUGIN_DISPLAY_NAME} module` },
+  { section: "plugins", uid: RBAC.DASHBOARD_READ, displayName: "Read the dashboard" },
+  { section: "plugins", uid: RBAC.SEASONS_READ, displayName: "Read seasons" },
+  { section: "plugins", uid: RBAC.SEASONS_WRITE, displayName: "Create, edit and delete seasons" },
+  { section: "plugins", uid: RBAC.CARDS_READ, displayName: "Read cards" },
+  { section: "plugins", uid: RBAC.CARDS_WRITE, displayName: "Create, edit and delete cards" },
+  { section: "plugins", uid: RBAC.PACKS_READ, displayName: "Read packs" },
+  { section: "plugins", uid: RBAC.PACKS_WRITE, displayName: "Create, edit and delete packs" },
+  { section: "plugins", uid: RBAC.PACKS_QR, displayName: "Generate pack QR codes (booth)" },
+  { section: "plugins", uid: RBAC.PLAYERS_READ, displayName: "Read players" },
+  { section: "plugins", uid: RBAC.PLAYERS_WRITE, displayName: "Deactivate players, grant cards" },
+  { section: "plugins", uid: RBAC.REDEMPTIONS_READ, displayName: "Read redemptions" },
+  { section: "plugins", uid: RBAC.REDEMPTIONS_FULFILL, displayName: "Fulfill or cancel redemptions (booth)" },
+  { section: "plugins", uid: RBAC.AUDIT_READ, displayName: "Read the pull audit log" },
+  { section: "plugins", uid: RBAC.REWARDS_READ, displayName: "Read the reward catalog" },
+  { section: "plugins", uid: RBAC.REWARDS_WRITE, displayName: "Edit the reward catalog" },
+  { section: "plugins", uid: RBAC.LIVE_READ, displayName: "Read live boosts" },
+  { section: "plugins", uid: RBAC.LIVE_WRITE, displayName: "Create and edit live boosts" },
+  { section: "settings", category: CATEGORY, uid: RBAC.SETTINGS_READ, displayName: "Read settings" },
+  { section: "settings", category: CATEGORY, uid: RBAC.SETTINGS_WRITE, displayName: "Edit settings" }
+].map((a) => ({ ...a, pluginName: PLUGIN_ID }));
+const timers = [];
+const UNIQUE_COLUMNS = [
+  ["plugin::tcg.nonce", "nonce"],
+  ["plugin::tcg.player", "code"],
+  ["plugin::tcg.redemption", "code"]
+];
+const ensureUniqueIndexes = async (strapi) => {
+  for (const [uid, column] of UNIQUE_COLUMNS) {
+    const table = strapi.db.metadata.get(uid)?.tableName;
+    if (!table) continue;
+    const name = `${table}_${column}_tcg_uq`;
+    try {
+      await strapi.db.connection.schema.alterTable(table, (t) => t.unique([column], { indexName: name }));
+    } catch (err) {
+      if (!/exist|duplicate/i.test(err.message)) strapi.log.warn(`${LOG_PREFIX} unique index ${name}: ${err.message}`);
+    }
+  }
+};
+const bootstrap = async ({ strapi }) => {
+  await strapi.service("admin::permission").actionProvider.registerMany(ACTIONS);
+  await ensureUniqueIndexes(strapi);
+  const plugin = strapi.plugin(PLUGIN_ID);
+  if (plugin.service("settings").sweepsEnabled()) {
+    const safe = (label, fn) => async () => {
+      try {
+        const n = await fn();
+        if (n > 0) strapi.log.debug(`${LOG_PREFIX} swept ${n} ${label}`);
+      } catch (err) {
+        strapi.log.warn(`${LOG_PREFIX} sweep ${label} failed: ${err.message}`);
+      }
+    };
+    const nonceTimer = setInterval(safe("nonces", () => plugin.service("qr").sweep()), NONCE_SWEEP_INTERVAL_MS);
+    const tradeTimer = setInterval(safe("expired offers", () => plugin.service("trade").sweep()), TRADE_SWEEP_INTERVAL_MS);
+    nonceTimer.unref();
+    tradeTimer.unref();
+    timers.push(nonceTimer, tradeTimer);
+  }
+  strapi.log.info(`${LOG_PREFIX} ready — ${ACTIONS.length} RBAC actions, content API at /api/${PLUGIN_ID}`);
+};
+const stopTimers = () => {
+  while (timers.length) clearInterval(timers.pop());
+};
+const destroy = () => {
+  stopTimers();
+};
+const register = ({ strapi }) => {
+  strapi.log.info(`${LOG_PREFIX} registered`);
+};
+const fail = (message) => {
+  throw new Error(`${LOG_PREFIX} ${message}`);
+};
+const HEADER_NAME = /^[a-z0-9-]{2,64}$/i;
+const config = {
+  default: {
+    playerCodePrefix: "TCG",
+    qr: { globalSecret: "" },
+    players: {
+      idHeader: "x-player-id",
+      nameHeader: "x-player-name",
+      avatarHeader: "x-player-avatar",
+      autoProvision: true
+    },
+    sweeps: { enabled: true }
+  },
+  /**
+   * @param {Object} config - resolved plugin config
+   */
+  validator(config2) {
+    if (config2.playerCodePrefix && !/^[A-Z0-9]{2,6}$/.test(config2.playerCodePrefix)) {
+      fail("playerCodePrefix must be 2 to 6 uppercase letters or digits.");
+    }
+    const players = config2.players ?? {};
+    for (const key of ["idHeader", "nameHeader", "avatarHeader"]) {
+      if (players[key] != null && !HEADER_NAME.test(String(players[key]))) {
+        fail(`players.${key} must be a valid header name.`);
+      }
+    }
+  }
+};
+const kind$h = "collectionType";
+const collectionName$h = "tcg_seasons";
+const info$h = {
+  singularName: "season",
+  pluralName: "seasons",
+  displayName: "TCG Season",
+  description: "A self-contained game: its card pool, packs, rarity table, limits and rank ladder."
+};
+const options$h = {
+  draftAndPublish: false
+};
+const pluginOptions$h = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes$h = {
+  name: {
+    type: "string",
+    required: true,
+    maxLength: 120
+  },
+  slug: {
+    type: "uid",
+    targetField: "name",
+    required: true
+  },
+  description: {
+    type: "text"
+  },
+  eventName: {
+    type: "string",
+    maxLength: 160
+  },
+  status: {
+    type: "enumeration",
+    "enum": [
+      "draft",
+      "active",
+      "archived"
+    ],
+    "default": "draft",
+    required: true
+  },
+  startsAt: {
+    type: "datetime"
+  },
+  endsAt: {
+    type: "datetime"
+  },
+  cover: {
+    type: "media",
+    multiple: false,
+    allowedTypes: [
+      "images"
+    ]
+  },
+  rarities: {
+    type: "json",
+    required: true
+  },
+  editions: {
+    type: "json"
+  },
+  limits: {
+    type: "json",
+    required: true
+  },
+  rankTiers: {
+    type: "json",
+    required: true
+  },
+  theme: {
+    type: "json"
+  },
+  cards: {
+    type: "relation",
+    relation: "oneToMany",
+    target: "plugin::tcg.card",
+    mappedBy: "season"
+  },
+  packs: {
+    type: "relation",
+    relation: "oneToMany",
+    target: "plugin::tcg.pack",
+    mappedBy: "season"
+  }
+};
+const schema$h = {
+  kind: kind$h,
+  collectionName: collectionName$h,
+  info: info$h,
+  options: options$h,
+  pluginOptions: pluginOptions$h,
+  attributes: attributes$h
+};
+const season$1 = { schema: schema$h };
+const kind$g = "collectionType";
+const collectionName$g = "tcg_packs";
+const info$g = {
+  singularName: "pack",
+  pluralName: "packs",
+  displayName: "TCG Pack",
+  description: "Something a player opens by scanning a QR: a physical location, a booster, an event booth."
+};
+const options$g = {
+  draftAndPublish: false
+};
+const pluginOptions$g = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes$g = {
+  season: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.season",
+    inversedBy: "packs"
+  },
+  name: {
+    type: "string",
+    required: true,
+    maxLength: 160
+  },
+  slug: {
+    type: "string",
+    required: true,
+    maxLength: 120
+  },
+  kind: {
+    type: "enumeration",
+    "enum": [
+      "location",
+      "booster",
+      "event"
+    ],
+    "default": "location",
+    required: true
+  },
+  description: {
+    type: "text"
+  },
+  location: {
+    type: "string",
+    maxLength: 300
+  },
+  image: {
+    type: "media",
+    multiple: false,
+    allowedTypes: [
+      "images"
+    ]
+  },
+  isActive: {
+    type: "boolean",
+    "default": true,
+    required: true
+  },
+  sortOrder: {
+    type: "integer",
+    "default": 0
+  },
+  meta: {
+    type: "json"
+  },
+  packCards: {
+    type: "relation",
+    relation: "oneToMany",
+    target: "plugin::tcg.pack-card",
+    mappedBy: "pack"
+  },
+  drops: {
+    type: "relation",
+    relation: "oneToMany",
+    target: "plugin::tcg.drop",
+    mappedBy: "pack"
+  }
+};
+const schema$g = {
+  kind: kind$g,
+  collectionName: collectionName$g,
+  info: info$g,
+  options: options$g,
+  pluginOptions: pluginOptions$g,
+  attributes: attributes$g
+};
+const pack$1 = { schema: schema$g };
+const kind$f = "collectionType";
+const collectionName$f = "tcg_drops";
+const info$f = {
+  singularName: "drop",
+  pluralName: "drops",
+  displayName: "TCG Drop",
+  description: "A scannable point inside a pack: one QR code, its own window, caps and optional card pool."
+};
+const options$f = {
+  draftAndPublish: false
+};
+const pluginOptions$f = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes$f = {
+  pack: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.pack",
+    inversedBy: "drops"
+  },
+  name: {
+    type: "string",
+    required: true,
+    maxLength: 160
+  },
+  slug: {
+    type: "string",
+    required: true,
+    maxLength: 120
+  },
+  description: {
+    type: "text"
+  },
+  mode: {
+    type: "enumeration",
+    "enum": [
+      "static",
+      "rotating"
+    ],
+    "default": "static",
+    required: true
+  },
+  secret: {
+    type: "string",
+    "private": true,
+    maxLength: 255
+  },
+  isDefault: {
+    type: "boolean",
+    "default": false,
+    required: true
+  },
+  isActive: {
+    type: "boolean",
+    "default": true,
+    required: true
+  },
+  isSecret: {
+    type: "boolean",
+    "default": false,
+    required: true
+  },
+  startsAt: {
+    type: "datetime"
+  },
+  endsAt: {
+    type: "datetime"
+  },
+  poolMode: {
+    type: "enumeration",
+    "enum": [
+      "inherit",
+      "extend",
+      "override"
+    ],
+    "default": "inherit",
+    required: true
+  },
+  maxScansTotal: {
+    type: "integer"
+  },
+  maxScansPerPlayer: {
+    type: "integer"
+  },
+  cooldownMs: {
+    type: "integer"
+  },
+  scanCount: {
+    type: "integer",
+    "default": 0,
+    required: true
+  },
+  geo: {
+    type: "json"
+  },
+  sortOrder: {
+    type: "integer",
+    "default": 0
+  },
+  dropCards: {
+    type: "relation",
+    relation: "oneToMany",
+    target: "plugin::tcg.drop-card",
+    mappedBy: "drop"
+  }
+};
+const schema$f = {
+  kind: kind$f,
+  collectionName: collectionName$f,
+  info: info$f,
+  options: options$f,
+  pluginOptions: pluginOptions$f,
+  attributes: attributes$f
+};
+const drop$1 = { schema: schema$f };
+const kind$e = "collectionType";
+const collectionName$e = "tcg_cards";
+const info$e = {
+  singularName: "card",
+  pluralName: "cards",
+  displayName: "TCG Card",
+  description: "A collectible card belonging to one season."
+};
+const options$e = {
+  draftAndPublish: false
+};
+const pluginOptions$e = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes$e = {
+  season: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.season",
+    inversedBy: "cards"
+  },
+  name: {
+    type: "string",
+    required: true,
+    maxLength: 200
+  },
+  number: {
+    type: "string",
+    maxLength: 10
+  },
+  description: {
+    type: "text"
+  },
+  rarity: {
+    type: "string",
+    required: true,
+    maxLength: 40
+  },
+  edition: {
+    type: "string",
+    "default": "standard",
+    maxLength: 50
+  },
+  score: {
+    type: "integer",
+    "default": 0
+  },
+  image: {
+    type: "media",
+    multiple: false,
+    allowedTypes: [
+      "images"
+    ]
+  },
+  attributes: {
+    type: "json"
+  },
+  isActive: {
+    type: "boolean",
+    "default": true,
+    required: true
+  },
+  packCards: {
+    type: "relation",
+    relation: "oneToMany",
+    target: "plugin::tcg.pack-card",
+    mappedBy: "card"
+  },
+  supplyCap: {
+    type: "integer"
+  },
+  minted: {
+    type: "integer",
+    "default": 0,
+    required: true
+  },
+  lore: {
+    type: "text"
+  },
+  artist: {
+    type: "string",
+    maxLength: 160
+  },
+  sets: {
+    type: "relation",
+    relation: "manyToMany",
+    target: "plugin::tcg.card-set",
+    mappedBy: "cards"
+  }
+};
+const schema$e = {
+  kind: kind$e,
+  collectionName: collectionName$e,
+  info: info$e,
+  options: options$e,
+  pluginOptions: pluginOptions$e,
+  attributes: attributes$e
+};
+const card$1 = { schema: schema$e };
+const kind$d = "collectionType";
+const collectionName$d = "tcg_pack_cards";
+const info$d = {
+  singularName: "pack-card",
+  pluralName: "pack-cards",
+  displayName: "TCG Pack Card",
+  description: "Which cards a pack can drop, with per-card weight."
+};
+const options$d = {
+  draftAndPublish: false
+};
+const pluginOptions$d = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes$d = {
+  pack: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.pack",
+    inversedBy: "packCards"
+  },
+  card: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.card",
+    inversedBy: "packCards"
+  },
+  weight: {
+    type: "integer",
+    "default": 100,
+    required: true
+  },
+  isExclusive: {
+    type: "boolean",
+    "default": false
+  },
+  isActive: {
+    type: "boolean",
+    "default": true,
+    required: true
+  }
+};
+const schema$d = {
+  kind: kind$d,
+  collectionName: collectionName$d,
+  info: info$d,
+  options: options$d,
+  pluginOptions: pluginOptions$d,
+  attributes: attributes$d
+};
+const packCard = { schema: schema$d };
+const kind$c = "collectionType";
+const collectionName$c = "tcg_drop_cards";
+const info$c = {
+  singularName: "drop-card",
+  pluralName: "drop-cards",
+  displayName: "TCG Drop Card",
+  description: "Cards a drop adds to (or replaces) its pack pool, with weight and exclusivity."
+};
+const options$c = {
+  draftAndPublish: false
+};
+const pluginOptions$c = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes$c = {
+  drop: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.drop",
+    inversedBy: "dropCards"
+  },
+  card: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.card"
+  },
+  weight: {
+    type: "integer",
+    "default": 100,
+    required: true
+  },
+  isExclusive: {
+    type: "boolean",
+    "default": false
+  },
+  isActive: {
+    type: "boolean",
+    "default": true,
+    required: true
+  }
+};
+const schema$c = {
+  kind: kind$c,
+  collectionName: collectionName$c,
+  info: info$c,
+  options: options$c,
+  pluginOptions: pluginOptions$c,
+  attributes: attributes$c
+};
+const dropCard = { schema: schema$c };
+const kind$b = "collectionType";
+const collectionName$b = "tcg_card_sets";
+const info$b = {
+  singularName: "card-set",
+  pluralName: "card-sets",
+  displayName: "TCG Card Set",
+  description: "A named group of cards; completing it is a goal, a badge trigger and a reward cost."
+};
+const options$b = {
+  draftAndPublish: false
+};
+const pluginOptions$b = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes$b = {
+  season: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.season"
+  },
+  name: {
+    type: "string",
+    required: true,
+    maxLength: 160
+  },
+  slug: {
+    type: "string",
+    required: true,
+    maxLength: 120
+  },
+  description: {
+    type: "text"
+  },
+  image: {
+    type: "media",
+    multiple: false,
+    allowedTypes: [
+      "images"
+    ]
+  },
+  cards: {
+    type: "relation",
+    relation: "manyToMany",
+    target: "plugin::tcg.card",
+    inversedBy: "sets"
+  },
+  sortOrder: {
+    type: "integer",
+    "default": 0
+  },
+  isActive: {
+    type: "boolean",
+    "default": true,
+    required: true
+  }
+};
+const schema$b = {
+  kind: kind$b,
+  collectionName: collectionName$b,
+  info: info$b,
+  options: options$b,
+  pluginOptions: pluginOptions$b,
+  attributes: attributes$b
+};
+const cardSet = { schema: schema$b };
+const kind$a = "collectionType";
+const collectionName$a = "tcg_boosts";
+const info$a = {
+  singularName: "boost",
+  pluralName: "boosts",
+  displayName: "TCG Boost",
+  description: "A time window where rarity odds are multiplied, season-wide or on one pack / drop."
+};
+const options$a = {
+  draftAndPublish: false
+};
+const pluginOptions$a = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes$a = {
+  season: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.season"
+  },
+  pack: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.pack"
+  },
+  drop: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.drop"
+  },
+  name: {
+    type: "string",
+    required: true,
+    maxLength: 160
+  },
+  description: {
+    type: "text"
+  },
+  multipliers: {
+    type: "json",
+    required: true
+  },
+  startsAt: {
+    type: "datetime"
+  },
+  endsAt: {
+    type: "datetime"
+  },
+  isActive: {
+    type: "boolean",
+    "default": true,
+    required: true
+  },
+  announce: {
+    type: "boolean",
+    "default": true,
+    required: true
+  }
+};
+const schema$a = {
+  kind: kind$a,
+  collectionName: collectionName$a,
+  info: info$a,
+  options: options$a,
+  pluginOptions: pluginOptions$a,
+  attributes: attributes$a
+};
+const boost$1 = { schema: schema$a };
+const kind$9 = "collectionType";
+const collectionName$9 = "tcg_rewards";
+const info$9 = {
+  singularName: "reward",
+  pluralName: "rewards",
+  displayName: "TCG Reward",
+  description: "Something physical a player can claim at a booth by handing cards in."
+};
+const options$9 = {
+  draftAndPublish: false
+};
+const pluginOptions$9 = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes$9 = {
+  season: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.season"
+  },
+  name: {
+    type: "string",
+    required: true,
+    maxLength: 160
+  },
+  slug: {
+    type: "string",
+    required: true,
+    maxLength: 120
+  },
+  description: {
+    type: "text"
+  },
+  image: {
+    type: "media",
+    multiple: false,
+    allowedTypes: [
+      "images"
+    ]
+  },
+  cost: {
+    type: "json",
+    required: true
+  },
+  stock: {
+    type: "integer"
+  },
+  claimed: {
+    type: "integer",
+    "default": 0,
+    required: true
+  },
+  perPlayerLimit: {
+    type: "integer"
+  },
+  booth: {
+    type: "string",
+    maxLength: 200
+  },
+  isActive: {
+    type: "boolean",
+    "default": true,
+    required: true
+  },
+  startsAt: {
+    type: "datetime"
+  },
+  endsAt: {
+    type: "datetime"
+  },
+  sortOrder: {
+    type: "integer",
+    "default": 0
+  },
+  tier: {
+    type: "enumeration",
+    "enum": [
+      "bronze",
+      "silver",
+      "gold",
+      "legend"
+    ],
+    "default": "bronze"
+  }
+};
+const schema$9 = {
+  kind: kind$9,
+  collectionName: collectionName$9,
+  info: info$9,
+  options: options$9,
+  pluginOptions: pluginOptions$9,
+  attributes: attributes$9
+};
+const reward$1 = { schema: schema$9 };
+const kind$8 = "collectionType";
+const collectionName$8 = "tcg_badges";
+const info$8 = {
+  singularName: "badge",
+  pluralName: "badges",
+  displayName: "TCG Badge",
+  description: "An achievement with a rule; awarded automatically after pulls, trades and redemptions."
+};
+const options$8 = {
+  draftAndPublish: false
+};
+const pluginOptions$8 = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes$8 = {
+  season: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.season"
+  },
+  key: {
+    type: "string",
+    required: true,
+    maxLength: 60
+  },
+  name: {
+    type: "string",
+    required: true,
+    maxLength: 160
+  },
+  description: {
+    type: "text"
+  },
+  icon: {
+    type: "string",
+    maxLength: 16
+  },
+  image: {
+    type: "media",
+    multiple: false,
+    allowedTypes: [
+      "images"
+    ]
+  },
+  rule: {
+    type: "json",
+    required: true
+  },
+  tier: {
+    type: "enumeration",
+    "enum": [
+      "bronze",
+      "silver",
+      "gold",
+      "legend"
+    ],
+    "default": "bronze"
+  },
+  isSecret: {
+    type: "boolean",
+    "default": false,
+    required: true
+  },
+  isActive: {
+    type: "boolean",
+    "default": true,
+    required: true
+  },
+  sortOrder: {
+    type: "integer",
+    "default": 0
+  }
+};
+const schema$8 = {
+  kind: kind$8,
+  collectionName: collectionName$8,
+  info: info$8,
+  options: options$8,
+  pluginOptions: pluginOptions$8,
+  attributes: attributes$8
+};
+const badge$1 = { schema: schema$8 };
+const kind$7 = "collectionType";
+const collectionName$7 = "tcg_players";
+const info$7 = {
+  singularName: "player",
+  pluralName: "players",
+  displayName: "TCG Player",
+  description: "A person playing, identified by the external id the host sends in the player header."
+};
+const options$7 = {
+  draftAndPublish: false
+};
+const pluginOptions$7 = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes$7 = {
+  externalId: {
+    type: "string",
+    unique: true,
+    maxLength: 190
+  },
+  msisdn: {
+    type: "string",
+    "private": true,
+    maxLength: 20
+  },
+  code: {
+    type: "string",
+    required: true,
+    unique: true,
+    maxLength: 16
+  },
+  displayName: {
+    type: "string",
+    maxLength: 100
+  },
+  avatarUrl: {
+    type: "string",
+    maxLength: 500
+  },
+  provider: {
+    type: "string",
+    "default": "api",
+    maxLength: 40
+  },
+  isGuest: {
+    type: "boolean",
+    "default": false,
+    required: true
+  },
+  isActive: {
+    type: "boolean",
+    "default": true,
+    required: true
+  },
+  totalCards: {
+    type: "integer",
+    "default": 0,
+    required: true
+  },
+  totalTrades: {
+    type: "integer",
+    "default": 0,
+    required: true
+  },
+  totalRedemptions: {
+    type: "integer",
+    "default": 0,
+    required: true
+  },
+  lastActiveAt: {
+    type: "datetime"
+  },
+  meta: {
+    type: "json"
+  }
+};
+const schema$7 = {
+  kind: kind$7,
+  collectionName: collectionName$7,
+  info: info$7,
+  options: options$7,
+  pluginOptions: pluginOptions$7,
+  attributes: attributes$7
+};
+const player$2 = { schema: schema$7 };
+const kind$6 = "collectionType";
+const collectionName$6 = "tcg_player_cards";
+const info$6 = {
+  singularName: "player-card",
+  pluralName: "player-cards",
+  displayName: "TCG Player Card",
+  description: "One owned copy of a card."
+};
+const options$6 = {
+  draftAndPublish: false
+};
+const pluginOptions$6 = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes$6 = {
+  player: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.player"
+  },
+  card: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.card"
+  },
+  pack: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.pack"
+  },
+  acquiredFrom: {
+    type: "enumeration",
+    "enum": [
+      "pull",
+      "trade",
+      "grant"
+    ],
+    "default": "pull",
+    required: true
+  },
+  acquiredAt: {
+    type: "datetime",
+    required: true
+  },
+  sourceTrade: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.trade"
+  },
+  mintNumber: {
+    type: "integer"
+  }
+};
+const schema$6 = {
+  kind: kind$6,
+  collectionName: collectionName$6,
+  info: info$6,
+  options: options$6,
+  pluginOptions: pluginOptions$6,
+  attributes: attributes$6
+};
+const playerCard = { schema: schema$6 };
+const kind$5 = "collectionType";
+const collectionName$5 = "tcg_player_badges";
+const info$5 = {
+  singularName: "player-badge",
+  pluralName: "player-badges",
+  displayName: "TCG Player Badge",
+  description: "A badge earned by a player."
+};
+const options$5 = {
+  draftAndPublish: false
+};
+const pluginOptions$5 = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes$5 = {
+  player: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.player"
+  },
+  badge: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.badge"
+  },
+  earnedAt: {
+    type: "datetime",
+    required: true
+  },
+  context: {
+    type: "json"
+  }
+};
+const schema$5 = {
+  kind: kind$5,
+  collectionName: collectionName$5,
+  info: info$5,
+  options: options$5,
+  pluginOptions: pluginOptions$5,
+  attributes: attributes$5
+};
+const playerBadge = { schema: schema$5 };
+const kind$4 = "collectionType";
+const collectionName$4 = "tcg_pulls";
+const info$4 = {
+  singularName: "pull",
+  pluralName: "pulls",
+  displayName: "TCG Pull",
+  description: "Audit trail of every scan that produced a card."
+};
+const options$4 = {
+  draftAndPublish: false
+};
+const pluginOptions$4 = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes$4 = {
+  player: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.player"
+  },
+  pack: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.pack"
+  },
+  card: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.card"
+  },
+  season: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.season"
+  },
+  seed: {
+    type: "string",
+    required: true,
+    maxLength: 100
+  },
+  roll: {
+    type: "decimal",
+    required: true
+  },
+  rarity: {
+    type: "string",
+    required: true,
+    maxLength: 40
+  },
+  verificationHash: {
+    type: "string",
+    maxLength: 32
+  },
+  qrToken: {
+    type: "string",
+    maxLength: 500
+  },
+  pulledAt: {
+    type: "datetime",
+    required: true
+  },
+  drop: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.drop"
+  },
+  odds: {
+    type: "json"
+  },
+  pity: {
+    type: "boolean",
+    "default": false
+  },
+  mintNumber: {
+    type: "integer"
+  }
+};
+const schema$4 = {
+  kind: kind$4,
+  collectionName: collectionName$4,
+  info: info$4,
+  options: options$4,
+  pluginOptions: pluginOptions$4,
+  attributes: attributes$4
+};
+const pull$2 = { schema: schema$4 };
+const kind$3 = "collectionType";
+const collectionName$3 = "tcg_trade_offers";
+const info$3 = {
+  singularName: "trade-offer",
+  pluralName: "trade-offers",
+  displayName: "TCG Trade Offer",
+  description: "A pending P2P proposal carried by a QR code."
+};
+const options$3 = {
+  draftAndPublish: false
+};
+const pluginOptions$3 = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes$3 = {
+  initiator: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.player"
+  },
+  season: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.season"
+  },
+  status: {
+    type: "enumeration",
+    "enum": [
+      "pending",
+      "accepted",
+      "rejected",
+      "expired",
+      "cancelled"
+    ],
+    "default": "pending",
+    required: true
+  },
+  offeredCardIds: {
+    type: "json",
+    required: true
+  },
+  qrToken: {
+    type: "string",
+    maxLength: 500
+  },
+  expiresAt: {
+    type: "datetime",
+    required: true
+  }
+};
+const schema$3 = {
+  kind: kind$3,
+  collectionName: collectionName$3,
+  info: info$3,
+  options: options$3,
+  pluginOptions: pluginOptions$3,
+  attributes: attributes$3
+};
+const tradeOffer = { schema: schema$3 };
+const kind$2 = "collectionType";
+const collectionName$2 = "tcg_trades";
+const info$2 = {
+  singularName: "trade",
+  pluralName: "trades",
+  displayName: "TCG Trade",
+  description: "A completed swap between two players."
+};
+const options$2 = {
+  draftAndPublish: false
+};
+const pluginOptions$2 = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes$2 = {
+  offer: {
+    type: "relation",
+    relation: "oneToOne",
+    target: "plugin::tcg.trade-offer"
+  },
+  initiator: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.player"
+  },
+  receiver: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.player"
+  },
+  season: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.season"
+  },
+  initiatorCardIds: {
+    type: "json",
+    required: true
+  },
+  receiverCardIds: {
+    type: "json",
+    required: true
+  },
+  completedAt: {
+    type: "datetime",
+    required: true
+  }
+};
+const schema$2 = {
+  kind: kind$2,
+  collectionName: collectionName$2,
+  info: info$2,
+  options: options$2,
+  pluginOptions: pluginOptions$2,
+  attributes: attributes$2
+};
+const trade$1 = { schema: schema$2 };
+const kind$1 = "collectionType";
+const collectionName$1 = "tcg_redemptions";
+const info$1 = {
+  singularName: "redemption",
+  pluralName: "redemptions",
+  displayName: "TCG Redemption",
+  description: "Cards handed in for a physical reward, validated at a booth."
+};
+const options$1 = {
+  draftAndPublish: false
+};
+const pluginOptions$1 = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes$1 = {
+  player: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.player"
+  },
+  season: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.season"
+  },
+  code: {
+    type: "string",
+    required: true,
+    unique: true,
+    maxLength: 16
+  },
+  cards: {
+    type: "json",
+    required: true
+  },
+  rewardType: {
+    type: "string",
+    maxLength: 100
+  },
+  rewardDescription: {
+    type: "string",
+    maxLength: 500
+  },
+  status: {
+    type: "enumeration",
+    "enum": [
+      "pending",
+      "fulfilled",
+      "cancelled"
+    ],
+    "default": "pending",
+    required: true
+  },
+  redeemedAt: {
+    type: "datetime",
+    required: true
+  },
+  fulfilledAt: {
+    type: "datetime"
+  },
+  fulfilledBy: {
+    type: "string",
+    maxLength: 255
+  },
+  note: {
+    type: "text"
+  },
+  reward: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::tcg.reward"
+  },
+  rewardName: {
+    type: "string",
+    maxLength: 160
+  }
+};
+const schema$1 = {
+  kind: kind$1,
+  collectionName: collectionName$1,
+  info: info$1,
+  options: options$1,
+  pluginOptions: pluginOptions$1,
+  attributes: attributes$1
+};
+const redemption$1 = { schema: schema$1 };
+const kind = "collectionType";
+const collectionName = "tcg_nonces";
+const info = {
+  singularName: "nonce",
+  pluralName: "nonces",
+  displayName: "TCG QR Nonce",
+  description: "Anti-replay ledger for consumed QR tokens."
+};
+const options = {
+  draftAndPublish: false
+};
+const pluginOptions = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes = {
+  nonce: {
+    type: "string",
+    required: true,
+    unique: true,
+    maxLength: 100
+  },
+  kind: {
+    type: "string",
+    maxLength: 20
+  },
+  expiresAt: {
+    type: "datetime",
+    required: true
+  }
+};
+const schema = {
+  kind,
+  collectionName,
+  info,
+  options,
+  pluginOptions,
+  attributes
+};
+const nonce = { schema };
+const contentTypes = {
+  season: season$1,
+  pack: pack$1,
+  drop: drop$1,
+  card: card$1,
+  "pack-card": packCard,
+  "drop-card": dropCard,
+  "card-set": cardSet,
+  boost: boost$1,
+  reward: reward$1,
+  badge: badge$1,
+  player: player$2,
+  "player-card": playerCard,
+  "player-badge": playerBadge,
+  pull: pull$2,
+  "trade-offer": tradeOffer,
+  trade: trade$1,
+  redemption: redemption$1,
+  nonce
+};
+class TcgError extends Error {
+  /**
+   * @param {number} status HTTP status
+   * @param {string} code stable machine code (see constants.ERROR_CODES)
+   * @param {string} message human message (French is fine; the client branches on `code`)
+   * @param {Object} [details]
+   */
+  constructor(status, code, message, details) {
+    super(message);
+    this.name = "TcgError";
+    this.status = status;
+    this.code = code;
+    this.details = details;
+  }
+}
+const badRequest = (code, message, details) => new TcgError(400, code, message, details);
+const forbidden = (code, message, details) => new TcgError(403, code, message, details);
+const notFound = (code, message, details) => new TcgError(404, code, message, details);
+const conflict = (code, message, details) => new TcgError(409, code, message, details);
+const unprocessable = (code, message, details) => new TcgError(422, code, message, details);
+const sendError = (ctx, err, strapi) => {
+  if (err instanceof TcgError) {
+    ctx.status = err.status;
+    ctx.body = { error: { status: err.status, code: err.code, message: err.message, details: err.details } };
+    return;
+  }
+  strapi?.log?.error(`[tcg] unexpected: ${err?.stack || err}`);
+  ctx.status = 500;
+  ctx.body = { error: { status: 500, code: "INTERNAL", message: "Une erreur interne est survenue." } };
+};
+const parsePagination = (query = {}) => {
+  const page = Math.max(1, parseInt(query.page, 10) || 1);
+  const pageSize = Math.min(MAX_PAGE_SIZE, Math.max(1, parseInt(query.pageSize ?? query.limit, 10) || DEFAULT_PAGE_SIZE));
+  return { page, pageSize, offset: (page - 1) * pageSize, limit: pageSize };
+};
+const paged = (items, total, { page, pageSize }) => ({
+  data: items,
+  meta: { pagination: { page, pageSize, total, pageCount: Math.max(1, Math.ceil(total / pageSize)) } }
+});
+const handle = (strapi, fn) => async (ctx) => {
+  try {
+    await fn(ctx);
+  } catch (err) {
+    sendError(ctx, err, strapi);
+  }
+};
+const body = (ctx) => ctx.request.body && typeof ctx.request.body === "object" ? ctx.request.body.data ?? ctx.request.body : {};
+const ok = (ctx, data, meta) => {
+  ctx.body = { data };
+};
+const created = (ctx, data) => {
+  ctx.status = 201;
+  ctx.body = { data };
+};
+const game = ({ strapi }) => {
+  const svc = (name) => strapi.plugin("tcg").service(name);
+  const seasonOf = (ctx) => svc("season").resolve(ctx.query.season);
+  return {
+    // ── Player ───────────────────────────────────────────────────────────
+    me: handle(strapi, async (ctx) => {
+      ok(ctx, { ...svc("format").player(ctx.state.tcgPlayer), isNew: Boolean(ctx.state.tcgPlayerIsNew) });
+    }),
+    updateMe: handle(strapi, async (ctx) => {
+      const { displayName, avatarUrl } = body(ctx);
+      const data = {};
+      if (typeof displayName === "string") data.displayName = displayName.slice(0, 100);
+      if (typeof avatarUrl === "string") data.avatarUrl = avatarUrl.slice(0, 500);
+      const player2 = await strapi.db.query("plugin::tcg.player").update({ where: { id: ctx.state.tcgPlayer.id }, data });
+      ok(ctx, svc("format").player(player2));
+    }),
+    // ── Season / catalog ─────────────────────────────────────────────────
+    currentSeason: handle(strapi, async (ctx) => {
+      const season2 = await seasonOf(ctx);
+      ok(ctx, svc("format").season(season2));
+    }),
+    packs: handle(strapi, async (ctx) => {
+      const season2 = await seasonOf(ctx);
+      const packs = await svc("pack").list(season2);
+      ok(ctx, packs.map((p) => svc("format").pack(p)));
+    }),
+    pack: handle(strapi, async (ctx) => {
+      const season2 = await seasonOf(ctx);
+      const pack2 = await svc("pack").findOne(season2, ctx.params.slug);
+      const [pool, drops, exclusiveIds] = await Promise.all([svc("pack").pool(pack2), svc("drop").list(pack2, { includeInactive: false }), svc("drop").exclusiveCardIds(season2)]);
+      ok(ctx, {
+        ...svc("format").pack(pack2),
+        cards: pool.filter((c) => !exclusiveIds.has(c.id) || c.isExclusive).map((c) => ({ ...svc("format").card(c, season2), isExclusive: c.isExclusive })),
+        drops: await Promise.all(drops.map((d) => svc("drop").publicView(d, pack2, season2)))
+      });
+    }),
+    /** Everything live right now: boosts, open limited drops, low-stock rewards. For the app's home screen. */
+    live: handle(strapi, async (ctx) => {
+      const season2 = await seasonOf(ctx);
+      const packs = await svc("pack").list(season2);
+      const windows = [];
+      for (const pack2 of packs) {
+        const drops = await svc("drop").list(pack2, { includeInactive: false });
+        for (const d of drops) {
+          if (d.isDefault && !d.startsAt && !d.endsAt && d.maxScansTotal == null) continue;
+          const v = await svc("drop").publicView(d, pack2, season2);
+          windows.push({ ...v, pack: { id: pack2.documentId, name: pack2.name, slug: pack2.slug } });
+        }
+      }
+      ok(ctx, { boosts: await svc("boost").liveNow(season2), drops: windows, serverTime: /* @__PURE__ */ new Date() });
+    }),
+    sets: handle(strapi, async (ctx) => {
+      const season2 = await seasonOf(ctx);
+      const sets = await svc("set").list(season2, { includeInactive: false });
+      const owned = ctx.state.tcgPlayer ? new Set(await svc("collection").ownedCardIds(ctx.state.tcgPlayer, season2)) : /* @__PURE__ */ new Set();
+      ok(ctx, svc("set").progress(sets, owned, season2));
+    }),
+    badges: handle(strapi, async (ctx) => {
+      const season2 = await seasonOf(ctx);
+      ok(ctx, await svc("badge").forPlayer(ctx.state.tcgPlayer, season2));
+    }),
+    rewards: handle(strapi, async (ctx) => {
+      const season2 = await seasonOf(ctx);
+      const rewards = await svc("reward").list(season2, { includeInactive: false });
+      const sets = Object.fromEntries((await svc("set").list(season2)).map((x) => [x.slug, { name: x.name }]));
+      ok(ctx, rewards.map((r) => svc("reward").format(r, season2, sets)));
+    }),
+    rewardEligibility: handle(strapi, async (ctx) => {
+      const season2 = await seasonOf(ctx);
+      ok(ctx, await svc("reward").eligibility(ctx.state.tcgPlayer, season2));
+    }),
+    cards: handle(strapi, async (ctx) => {
+      const season2 = await seasonOf(ctx);
+      const page = parsePagination(ctx.query);
+      const { items, total } = await svc("card").list(season2, { rarity: ctx.query.rarity, edition: ctx.query.edition, isActive: true }, page);
+      ctx.body = paged(items.map((c) => svc("format").card(c, season2)), total, page);
+    }),
+    card: handle(strapi, async (ctx) => {
+      const card2 = await svc("card").findOne(ctx.params.id);
+      const season2 = await svc("season").resolve(card2.season?.documentId);
+      ok(ctx, svc("format").card(card2, season2));
+    }),
+    // ── Collection ───────────────────────────────────────────────────────
+    collection: handle(strapi, async (ctx) => {
+      const season2 = await seasonOf(ctx);
+      const page = parsePagination(ctx.query);
+      const { items, total } = await svc("collection").list(ctx.state.tcgPlayer, season2, { rarity: ctx.query.rarity }, page);
+      ctx.body = paged(items, total, page);
+    }),
+    collectionStats: handle(strapi, async (ctx) => {
+      const season2 = await seasonOf(ctx);
+      ok(ctx, await svc("collection").stats(ctx.state.tcgPlayer, season2));
+    }),
+    // ── Pulls ────────────────────────────────────────────────────────────
+    scan: handle(strapi, async (ctx) => {
+      const { qrToken } = body(ctx);
+      created(ctx, await svc("pull").scan(ctx.state.tcgPlayer, String(qrToken ?? "")));
+    }),
+    pullHistory: handle(strapi, async (ctx) => {
+      const season2 = await seasonOf(ctx);
+      const page = parsePagination(ctx.query);
+      const { items, total } = await svc("pull").history(ctx.state.tcgPlayer, season2, page);
+      ctx.body = paged(items, total, page);
+    }),
+    cooldowns: handle(strapi, async (ctx) => {
+      const season2 = await seasonOf(ctx);
+      ok(ctx, await svc("pull").cooldowns(ctx.state.tcgPlayer, season2));
+    }),
+    // ── Trades ───────────────────────────────────────────────────────────
+    createOffer: handle(strapi, async (ctx) => {
+      const season2 = await seasonOf(ctx);
+      created(ctx, await svc("trade").createOffer(ctx.state.tcgPlayer, season2, { cardIds: body(ctx).cardIds }));
+    }),
+    scanOffer: handle(strapi, async (ctx) => {
+      ok(ctx, await svc("trade").scan(ctx.state.tcgPlayer, String(body(ctx).qrToken ?? "")));
+    }),
+    getOffer: handle(strapi, async (ctx) => {
+      const offer = await svc("trade").findOffer(ctx.params.id);
+      ok(ctx, await svc("trade").describe(offer, offer.season));
+    }),
+    acceptOffer: handle(strapi, async (ctx) => {
+      ok(ctx, await svc("trade").accept(ctx.state.tcgPlayer, ctx.params.id, { cardIds: body(ctx).cardIds }));
+    }),
+    rejectOffer: handle(strapi, async (ctx) => {
+      ok(ctx, await svc("trade").reject(ctx.state.tcgPlayer, ctx.params.id));
+    }),
+    cancelOffer: handle(strapi, async (ctx) => {
+      ok(ctx, await svc("trade").cancel(ctx.state.tcgPlayer, ctx.params.id));
+    }),
+    activeOffers: handle(strapi, async (ctx) => {
+      const season2 = await seasonOf(ctx);
+      ok(ctx, await svc("trade").activeOffers(ctx.state.tcgPlayer, season2));
+    }),
+    tradeHistory: handle(strapi, async (ctx) => {
+      const season2 = await seasonOf(ctx);
+      const page = parsePagination(ctx.query);
+      const { items, total } = await svc("trade").history(ctx.state.tcgPlayer, season2, page);
+      ctx.body = paged(items, total, page);
+    }),
+    // ── Redemptions ──────────────────────────────────────────────────────
+    createRedemption: handle(strapi, async (ctx) => {
+      const season2 = await seasonOf(ctx);
+      const { cardIds, rewardId } = body(ctx);
+      created(ctx, await svc("redemption").create(ctx.state.tcgPlayer, season2, { cardIds, rewardId }));
+    }),
+    getRedemption: handle(strapi, async (ctx) => {
+      const rec = await svc("redemption").findOne(ctx.params.id, { forPlayer: ctx.state.tcgPlayer });
+      ok(ctx, svc("format").redemption(rec));
+    }),
+    redemptionHistory: handle(strapi, async (ctx) => {
+      const season2 = await seasonOf(ctx);
+      const page = parsePagination(ctx.query);
+      const { items, total } = await svc("redemption").history(ctx.state.tcgPlayer, season2, page);
+      ctx.body = paged(items, total, page);
+    })
+  };
+};
+const createSeededRNG = (seed) => {
+  let state = seed | 0;
+  return () => {
+    state = state + 1831565813 | 0;
+    let t = Math.imul(state ^ state >>> 15, 1 | state);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+};
+const generateSeed = (playerId, dropId, pullNumber, timestamp) => {
+  const hash = createHash("sha256").update(`${playerId}:${dropId}:${pullNumber}:${timestamp}`).digest("hex");
+  return parseInt(hash.substring(0, 8), 16);
+};
+const effectiveRarities = (rarities, multipliers = {}) => {
+  const weighted = rarities.map((r) => ({ ...r, probability: (Number(r.probability) || 0) * Math.max(0, Number(multipliers[r.key] ?? 1)) }));
+  const sum = weighted.reduce((s, r) => s + r.probability, 0);
+  if (sum <= 0) return rarities.map((r) => ({ ...r }));
+  return weighted.map((r) => ({ ...r, probability: r.probability / sum }));
+};
+const rarityFromRoll = (roll, rarities, minRarity) => {
+  let cumulative = 0;
+  let picked = rarities[0]?.key;
+  for (const tier of rarities) {
+    cumulative += Number(tier.probability) || 0;
+    if (roll < cumulative) {
+      picked = tier.key;
+      break;
+    }
+  }
+  if (minRarity) {
+    const keys = rarities.map((r) => r.key);
+    if (keys.indexOf(picked) < keys.indexOf(minRarity)) return minRarity;
+  }
+  return picked;
+};
+const selectCard = (pool, rarity, rng, rarities = []) => {
+  const keys = rarities.map((r) => r.key);
+  const start = Math.max(0, keys.indexOf(rarity));
+  const order = keys.length ? [...keys.slice(0, start + 1).reverse(), ...keys.slice(start + 1)] : [rarity];
+  let list = [];
+  for (const k of order) {
+    list = pool.filter((c) => c.rarity === k);
+    if (list.length) break;
+  }
+  if (!list.length) list = pool;
+  if (list.length === 0) return null;
+  const totalWeight = list.reduce((sum, c) => sum + (Number(c.weight) || 100), 0);
+  let roll = rng() * totalWeight;
+  for (const card2 of list) {
+    roll -= Number(card2.weight) || 100;
+    if (roll <= 0) return card2;
+  }
+  return list[list.length - 1];
+};
+const prunePool = (pool, exclusiveCardIds = /* @__PURE__ */ new Set()) => pool.filter((c) => {
+  if (exclusiveCardIds.has(c.id) && !c.isExclusive) return false;
+  if (c.supplyCap != null && Number(c.minted ?? 0) >= Number(c.supplyCap)) return false;
+  return true;
+});
+const pull$1 = ({ playerId, dropId, pullNumber, pool, rarities, multipliers, minRarity, timestamp }) => {
+  const ts = timestamp ?? Date.now();
+  const seed = generateSeed(playerId, dropId, pullNumber, ts);
+  const rng = createSeededRNG(seed);
+  const odds = effectiveRarities(rarities, multipliers ?? {});
+  const roll = rng();
+  const rolled = rarityFromRoll(roll, odds);
+  const rarity = rarityFromRoll(roll, odds, minRarity);
+  const card2 = selectCard(pool, rarity, rng, odds);
+  const verificationHash = createHash("sha256").update(`${seed}:${roll}:${rarity}:${card2?.id}`).digest("hex").substring(0, 16);
+  return {
+    seed,
+    roll,
+    rarity: card2?.rarity ?? rarity,
+    requestedRarity: rarity,
+    rolledRarity: rolled,
+    pity: rolled !== rarity,
+    odds: Object.fromEntries(odds.map((r) => [r.key, Math.round(r.probability * 1e4) / 1e4])),
+    card: card2,
+    timestamp: ts,
+    verificationHash
+  };
+};
+const distribution = (pulls, rarities) => {
+  const total = pulls.length;
+  const byRarity = {};
+  for (const tier of rarities) {
+    const actual = pulls.filter((p) => p.rarity === tier.key).length;
+    const expected = Math.round(total * (Number(tier.probability) || 0));
+    byRarity[tier.key] = { actual, expected, percentage: total ? Math.round(actual / total * 100) : 0, deviation: actual - expected };
+  }
+  return { total, byRarity };
+};
+const pityFloor = (recent, rarities, limits) => {
+  const keys = rarities.map((r) => r.key);
+  if (keys.length < 2) return void 0;
+  const top = keys[keys.length - 1];
+  const second = keys[1];
+  const legendaryAfter = Number(limits.pityLegendaryAfter) || 0;
+  if (legendaryAfter > 0 && recent.length >= legendaryAfter && recent.slice(0, legendaryAfter).every((p) => p.rarity !== top)) return top;
+  const rareAfter = Number(limits.pityRareAfter) || 0;
+  if (rareAfter > 0 && recent.length >= rareAfter && recent.slice(0, rareAfter).every((p) => p.rarity === keys[0])) return second;
+  return void 0;
+};
+const validateRarities = (rarities) => {
+  const problems = [];
+  if (!Array.isArray(rarities) || rarities.length === 0) return ["rarities must be a non-empty array"];
+  const keys = /* @__PURE__ */ new Set();
+  let sum = 0;
+  rarities.forEach((r, i) => {
+    if (!r?.key || !/^[a-z0-9_-]{2,30}$/.test(r.key)) problems.push(`rarities[${i}].key is invalid`);
+    if (keys.has(r?.key)) problems.push(`rarities[${i}].key "${r.key}" is duplicated`);
+    keys.add(r?.key);
+    const p = Number(r?.probability);
+    if (!(p >= 0 && p <= 1)) problems.push(`rarities[${i}].probability must be between 0 and 1`);
+    sum += p || 0;
+  });
+  if (Math.abs(sum - 1) > 1e-4) problems.push(`rarity probabilities sum to ${sum.toFixed(4)}, expected 1`);
+  return problems;
+};
+const admin$1 = ({ strapi }) => {
+  const svc = (name) => strapi.plugin("tcg").service(name);
+  const seasonParam = (ctx) => svc("season").resolve(ctx.params.season ?? ctx.query.season);
+  const operator = (ctx) => ctx.state.user?.email ?? ctx.state.user?.username ?? "admin";
+  return {
+    // ── Dashboard ────────────────────────────────────────────────────────
+    dashboard: handle(strapi, async (ctx) => {
+      const season2 = ctx.query.season ? await svc("season").resolve(ctx.query.season) : await svc("season").current();
+      ok(ctx, await svc("stats").dashboard(season2));
+    }),
+    leaderboard: handle(strapi, async (ctx) => {
+      const season2 = await seasonParam(ctx);
+      ok(ctx, await svc("stats").leaderboard(season2, Math.min(50, parseInt(ctx.query.limit, 10) || 10)));
+    }),
+    pulls: handle(strapi, async (ctx) => {
+      const season2 = await seasonParam(ctx);
+      const page = parsePagination(ctx.query);
+      const { items, total } = await svc("stats").pulls(season2, { playerCode: ctx.query.player, rarity: ctx.query.rarity }, page);
+      ctx.body = paged(items, total, page);
+    }),
+    // ── Seasons ──────────────────────────────────────────────────────────
+    seasons: handle(strapi, async (ctx) => ok(ctx, await svc("season").list())),
+    seasonDefaults: handle(strapi, async (ctx) => ok(ctx, svc("season").defaults())),
+    season: handle(strapi, async (ctx) => {
+      const season2 = await seasonParam(ctx);
+      const [cards, packs] = await Promise.all([svc("card").countByRarity(season2), svc("pack").list(season2, { includeInactive: true })]);
+      ok(ctx, { ...season2, counts: { cardsByRarity: cards, packs: packs.length } });
+    }),
+    createSeason: handle(strapi, async (ctx) => created(ctx, await svc("season").create(body(ctx)))),
+    updateSeason: handle(strapi, async (ctx) => ok(ctx, await svc("season").update(ctx.params.season, body(ctx)))),
+    deleteSeason: handle(strapi, async (ctx) => ok(ctx, await svc("season").remove(ctx.params.season))),
+    // ── Cards ────────────────────────────────────────────────────────────
+    cards: handle(strapi, async (ctx) => {
+      const season2 = await seasonParam(ctx);
+      const page = parsePagination({ ...ctx.query, pageSize: ctx.query.pageSize ?? 100 });
+      const { items, total } = await svc("card").list(season2, { rarity: ctx.query.rarity, edition: ctx.query.edition, q: ctx.query.q }, page);
+      ctx.body = paged(await svc("card").withExclusivity(items), total, page);
+    }),
+    card: handle(strapi, async (ctx) => ok(ctx, await svc("card").findOne(ctx.params.id))),
+    createCard: handle(strapi, async (ctx) => created(ctx, await svc("card").create(await seasonParam(ctx), body(ctx)))),
+    updateCard: handle(strapi, async (ctx) => ok(ctx, await svc("card").update(await seasonParam(ctx), ctx.params.id, body(ctx)))),
+    deleteCard: handle(strapi, async (ctx) => ok(ctx, await svc("card").remove(ctx.params.id))),
+    // ── Packs ────────────────────────────────────────────────────────────
+    packs: handle(strapi, async (ctx) => {
+      const season2 = await seasonParam(ctx);
+      const packs = await svc("pack").list(season2, { includeInactive: true });
+      const withCounts = await Promise.all(packs.map(async (p) => ({ ...p, cardCount: (await svc("pack").pool(p)).length })));
+      ok(ctx, withCounts);
+    }),
+    pack: handle(strapi, async (ctx) => {
+      const season2 = await seasonParam(ctx);
+      const pack2 = await svc("pack").findOne(season2, ctx.params.id);
+      const drops = await svc("drop").list(pack2);
+      ok(ctx, { ...pack2, cards: await svc("pack").cards(season2, pack2.documentId), drops: await Promise.all(drops.map(async (d) => ({ ...d, cardCount: (await svc("drop").cards(pack2, d.documentId)).length, isOpen: svc("drop").isOpen(d) }))) });
+    }),
+    // ── Drops ────────────────────────────────────────────────────────────
+    drops: handle(strapi, async (ctx) => {
+      const season2 = await seasonParam(ctx);
+      const pack2 = await svc("pack").findOne(season2, ctx.params.id);
+      const drops = await svc("drop").list(pack2);
+      ok(ctx, drops.map((d) => ({ ...d, isOpen: svc("drop").isOpen(d) })));
+    }),
+    drop: handle(strapi, async (ctx) => {
+      const season2 = await seasonParam(ctx);
+      const pack2 = await svc("pack").findOne(season2, ctx.params.id);
+      const drop2 = await svc("drop").findOne(pack2, ctx.params.dropId);
+      const raw = await svc("drop").rawPool(drop2, { ...pack2, season: season2 });
+      const exclusiveIds = await svc("drop").exclusiveCardIds(season2);
+      ok(ctx, {
+        ...drop2,
+        isOpen: svc("drop").isOpen(drop2),
+        cards: await svc("drop").cards(pack2, drop2.documentId),
+        effectivePool: raw.map((c) => ({ id: c.documentId, name: c.name, number: c.number, rarity: c.rarity, weight: c.weight, isExclusive: Boolean(c.isExclusive), source: c.source, prunedByExclusivity: exclusiveIds.has(c.id) && !c.isExclusive, soldOut: c.supplyCap != null && (c.minted ?? 0) >= c.supplyCap }))
+      });
+    }),
+    createDrop: handle(strapi, async (ctx) => {
+      const season2 = await seasonParam(ctx);
+      const pack2 = await svc("pack").findOne(season2, ctx.params.id);
+      created(ctx, await svc("drop").create({ ...pack2, season: season2 }, body(ctx)));
+    }),
+    updateDrop: handle(strapi, async (ctx) => {
+      const season2 = await seasonParam(ctx);
+      const pack2 = await svc("pack").findOne(season2, ctx.params.id);
+      ok(ctx, await svc("drop").update({ ...pack2, season: season2 }, ctx.params.dropId, body(ctx)));
+    }),
+    deleteDrop: handle(strapi, async (ctx) => {
+      const season2 = await seasonParam(ctx);
+      const pack2 = await svc("pack").findOne(season2, ctx.params.id);
+      ok(ctx, await svc("drop").remove(pack2, ctx.params.dropId));
+    }),
+    setDropCards: handle(strapi, async (ctx) => {
+      const season2 = await seasonParam(ctx);
+      const pack2 = await svc("pack").findOne(season2, ctx.params.id);
+      ok(ctx, await svc("drop").setCards({ ...pack2, season: season2 }, ctx.params.dropId, body(ctx).cards ?? []));
+    }),
+    dropQR: handle(strapi, async (ctx) => {
+      const season2 = await seasonParam(ctx);
+      const pack2 = await svc("pack").findOne(season2, ctx.params.id);
+      const { token, expiresAt, mode, drop: drop2 } = await svc("drop").generateQR({ ...pack2, season: season2 }, ctx.params.dropId);
+      ok(ctx, { token, expiresAt, mode, drop: { id: drop2.documentId, name: drop2.name, slug: drop2.slug }, pack: svc("format").pack(pack2) });
+    }),
+    rotateDropSecret: handle(strapi, async (ctx) => {
+      const season2 = await seasonParam(ctx);
+      const pack2 = await svc("pack").findOne(season2, ctx.params.id);
+      ok(ctx, await svc("drop").rotateSecret(pack2, ctx.params.dropId));
+    }),
+    // ── Boosts (Live) ────────────────────────────────────────────────────
+    boosts: handle(strapi, async (ctx) => ok(ctx, await svc("boost").list(await seasonParam(ctx)))),
+    createBoost: handle(strapi, async (ctx) => created(ctx, await svc("boost").create(await seasonParam(ctx), body(ctx)))),
+    updateBoost: handle(strapi, async (ctx) => ok(ctx, await svc("boost").update(await seasonParam(ctx), ctx.params.id, body(ctx)))),
+    deleteBoost: handle(strapi, async (ctx) => ok(ctx, await svc("boost").remove(await seasonParam(ctx), ctx.params.id))),
+    // ── Rewards ──────────────────────────────────────────────────────────
+    rewards: handle(strapi, async (ctx) => {
+      const season2 = await seasonParam(ctx);
+      const sets = Object.fromEntries((await svc("set").list(season2)).map((x) => [x.slug, { name: x.name }]));
+      ok(ctx, (await svc("reward").list(season2)).map((r) => ({ ...svc("reward").format(r, season2, sets), documentId: r.documentId })));
+    }),
+    createReward: handle(strapi, async (ctx) => created(ctx, await svc("reward").create(await seasonParam(ctx), body(ctx)))),
+    updateReward: handle(strapi, async (ctx) => ok(ctx, await svc("reward").update(await seasonParam(ctx), ctx.params.id, body(ctx)))),
+    deleteReward: handle(strapi, async (ctx) => ok(ctx, await svc("reward").remove(await seasonParam(ctx), ctx.params.id))),
+    // ── Sets ─────────────────────────────────────────────────────────────
+    sets: handle(strapi, async (ctx) => ok(ctx, await svc("set").list(await seasonParam(ctx)))),
+    createSet: handle(strapi, async (ctx) => created(ctx, await svc("set").create(await seasonParam(ctx), body(ctx)))),
+    updateSet: handle(strapi, async (ctx) => ok(ctx, await svc("set").update(await seasonParam(ctx), ctx.params.id, body(ctx)))),
+    deleteSet: handle(strapi, async (ctx) => ok(ctx, await svc("set").remove(await seasonParam(ctx), ctx.params.id))),
+    // ── Badges ───────────────────────────────────────────────────────────
+    badges: handle(strapi, async (ctx) => ok(ctx, await svc("badge").list(await seasonParam(ctx)))),
+    createBadge: handle(strapi, async (ctx) => created(ctx, await svc("badge").create(await seasonParam(ctx), body(ctx)))),
+    updateBadge: handle(strapi, async (ctx) => ok(ctx, await svc("badge").update(await seasonParam(ctx), ctx.params.id, body(ctx)))),
+    deleteBadge: handle(strapi, async (ctx) => ok(ctx, await svc("badge").remove(await seasonParam(ctx), ctx.params.id))),
+    seedBadges: handle(strapi, async (ctx) => ok(ctx, { created: await svc("badge").seedStarters(await seasonParam(ctx)) })),
+    createPack: handle(strapi, async (ctx) => created(ctx, await svc("pack").create(await seasonParam(ctx), body(ctx)))),
+    updatePack: handle(strapi, async (ctx) => ok(ctx, await svc("pack").update(await seasonParam(ctx), ctx.params.id, body(ctx)))),
+    deletePack: handle(strapi, async (ctx) => ok(ctx, await svc("pack").remove(await seasonParam(ctx), ctx.params.id))),
+    setPackCards: handle(strapi, async (ctx) => ok(ctx, await svc("pack").setCards(await seasonParam(ctx), ctx.params.id, body(ctx).cards ?? []))),
+    packQR: handle(strapi, async (ctx) => {
+      const { token, expiresAt, mode, drop: drop2, pack: pack2 } = await svc("pack").generateQR(await seasonParam(ctx), ctx.params.id);
+      ok(ctx, { token, expiresAt, mode, drop: { id: drop2.documentId, name: drop2.name, slug: drop2.slug }, pack: svc("format").pack(pack2) });
+    }),
+    rotatePackSecret: handle(strapi, async (ctx) => {
+      const season2 = await seasonParam(ctx);
+      const pack2 = await svc("pack").findOne(season2, ctx.params.id);
+      const drop2 = await svc("drop").ensureDefault({ ...pack2, season: season2 });
+      ok(ctx, await svc("drop").rotateSecret(pack2, drop2.documentId));
+    }),
+    /** Dry-run N pulls against a pack to eyeball the distribution. Nothing is written. */
+    simulate: handle(strapi, async (ctx) => {
+      const season2 = await seasonParam(ctx);
+      const pack2 = await svc("pack").findOne(season2, ctx.params.id);
+      const drop2 = ctx.query.drop ? await svc("drop").findOne(pack2, ctx.query.drop) : await svc("drop").ensureDefault({ ...pack2, season: season2 });
+      const raw = await svc("drop").rawPool(drop2, pack2);
+      const pool = prunePool(raw, await svc("drop").exclusiveCardIds(season2)).map((c) => ({ ...c, supplyCap: null }));
+      const multipliers = svc("boost").combine(await svc("boost").activeFor(season2, pack2, drop2));
+      const n = Math.min(1e4, Math.max(1, parseInt(ctx.query.n, 10) || 1e3));
+      const results = [];
+      for (let i = 0; i < n; i += 1) {
+        results.push(pull$1({ playerId: "sim", dropId: drop2.documentId, pullNumber: i, pool, rarities: season2.rarities ?? [], multipliers, timestamp: i }));
+      }
+      const byCard = {};
+      for (const r of results) {
+        if (!r.card) continue;
+        byCard[r.card.documentId] = byCard[r.card.documentId] ?? { name: r.card.name, rarity: r.card.rarity, count: 0 };
+        byCard[r.card.documentId].count += 1;
+      }
+      ok(ctx, { n, drop: { id: drop2.documentId, name: drop2.name }, multipliers, poolSize: pool.length, distribution: distribution(results, effectiveRarities(season2.rarities ?? [], multipliers)), byCard: Object.values(byCard).sort((a, b) => b.count - a.count) });
+    }),
+    // ── Players ──────────────────────────────────────────────────────────
+    players: handle(strapi, async (ctx) => {
+      const page = parsePagination(ctx.query);
+      const isActive = ctx.query.isActive === void 0 ? void 0 : ctx.query.isActive === "true";
+      const { items, total } = await svc("player").search({ q: ctx.query.q, provider: ctx.query.provider, isActive }, page);
+      ctx.body = paged(items.map((p) => svc("format").playerAdmin(p)), total, page);
+    }),
+    player: handle(strapi, async (ctx) => {
+      const player2 = await svc("player").byDocumentId(ctx.params.id);
+      const season2 = ctx.query.season ? await svc("season").resolve(ctx.query.season) : await svc("season").current();
+      const stats2 = season2 ? await svc("collection").stats(player2, season2) : null;
+      const page = parsePagination({ pageSize: 200 });
+      const collection2 = season2 ? await svc("collection").list(player2, season2, {}, page) : { items: [] };
+      ok(ctx, { player: svc("format").playerAdmin(player2), stats: stats2, collection: collection2.items });
+    }),
+    setPlayerActive: handle(strapi, async (ctx) => {
+      const player2 = await svc("player").setActive(ctx.params.id, body(ctx).isActive);
+      ok(ctx, svc("format").playerAdmin(player2));
+    }),
+    grantCard: handle(strapi, async (ctx) => {
+      const player2 = await svc("player").byDocumentId(ctx.params.id);
+      const card2 = await svc("card").findOne(body(ctx).cardId);
+      await svc("collection").grant(player2, card2);
+      strapi.log.info(`[tcg] grant ${card2.name} → ${player2.code} by ${operator(ctx)}`);
+      ok(ctx, svc("format").playerAdmin(await svc("player").recount(player2.id)));
+    }),
+    // ── Redemptions (booth) ──────────────────────────────────────────────
+    redemptions: handle(strapi, async (ctx) => {
+      const season2 = ctx.query.season ? await svc("season").resolve(ctx.query.season) : null;
+      const page = parsePagination(ctx.query);
+      const { items, total } = await svc("redemption").search({ season: season2, status: ctx.query.status, q: ctx.query.q, reward: ctx.query.reward }, page);
+      ctx.body = paged(items, total, page);
+    }),
+    redemption: handle(strapi, async (ctx) => ok(ctx, svc("format").redemption(await svc("redemption").findOne(ctx.params.code)))),
+    fulfillRedemption: handle(strapi, async (ctx) => ok(ctx, await svc("redemption").fulfill(ctx.params.code, { operator: operator(ctx), note: body(ctx).note }))),
+    cancelRedemption: handle(strapi, async (ctx) => ok(ctx, await svc("redemption").cancel(ctx.params.code, { operator: operator(ctx), note: body(ctx).note }))),
+    // ── Settings (read-only view of the resolved config, secrets masked) ─
+    settings: handle(strapi, async (ctx) => {
+      const all = svc("settings").all();
+      const mask = (v) => v ? "••••••" : "";
+      ok(ctx, {
+        playerCodePrefix: svc("settings").playerCodePrefix(),
+        qr: { globalSecret: mask(all.qr?.globalSecret) },
+        players: svc("settings").players(),
+        sweeps: all.sweeps ?? { enabled: true }
+      });
+    })
+  };
+};
+const controllers = { game, admin: admin$1 };
+const header = (ctx, name) => {
+  const value = ctx.request.header[String(name).toLowerCase()];
+  return typeof value === "string" ? value.trim() : "";
+};
+const player$1 = (_config, { strapi }) => async (ctx, next) => {
+  try {
+    const cfg = strapi.plugin("tcg").service("settings").players();
+    const externalId = header(ctx, cfg.idHeader).slice(0, 190);
+    if (!externalId) {
+      throw badRequest(ERROR_CODES.PLAYER_REQUIRED, `En-tête ${cfg.idHeader} requis : l'identifiant du joueur.`);
+    }
+    const found = await strapi.plugin("tcg").service("player").resolve({
+      externalId,
+      displayName: header(ctx, cfg.nameHeader) || null,
+      avatarUrl: header(ctx, cfg.avatarHeader) || null,
+      autoProvision: cfg.autoProvision !== false
+    });
+    if (!found.isActive) throw forbidden(ERROR_CODES.PLAYER_INACTIVE, "Ce compte est désactivé.");
+    ctx.state.tcgPlayer = found;
+    ctx.state.tcgPlayerIsNew = Boolean(found.__created);
+    ctx.set("Cache-Control", "private, no-store");
+  } catch (err) {
+    sendError(ctx, err, strapi);
+    return;
+  }
+  await next();
+};
+const middlewares = { player: player$1 };
+const policies = {};
+const PLAYER = { middlewares: ["plugin::tcg.player"] };
+const CATALOG = {};
+const contentApi = [
+  // player
+  { method: "GET", path: "/me", handler: "game.me", config: PLAYER },
+  { method: "PATCH", path: "/me", handler: "game.updateMe", config: PLAYER },
+  // catalog
+  { method: "GET", path: "/season", handler: "game.currentSeason", config: CATALOG },
+  { method: "GET", path: "/packs", handler: "game.packs", config: CATALOG },
+  { method: "GET", path: "/packs/:slug", handler: "game.pack", config: CATALOG },
+  { method: "GET", path: "/cards", handler: "game.cards", config: CATALOG },
+  { method: "GET", path: "/cards/:id", handler: "game.card", config: CATALOG },
+  { method: "GET", path: "/live", handler: "game.live", config: CATALOG },
+  { method: "GET", path: "/rewards", handler: "game.rewards", config: CATALOG },
+  { method: "GET", path: "/rewards/eligibility", handler: "game.rewardEligibility", config: PLAYER },
+  { method: "GET", path: "/sets", handler: "game.sets", config: PLAYER },
+  { method: "GET", path: "/badges", handler: "game.badges", config: PLAYER },
+  // collection
+  { method: "GET", path: "/collection", handler: "game.collection", config: PLAYER },
+  { method: "GET", path: "/collection/stats", handler: "game.collectionStats", config: PLAYER },
+  // pulls
+  { method: "POST", path: "/pulls/scan", handler: "game.scan", config: PLAYER },
+  { method: "GET", path: "/pulls/history", handler: "game.pullHistory", config: PLAYER },
+  { method: "GET", path: "/pulls/cooldowns", handler: "game.cooldowns", config: PLAYER },
+  // trades
+  { method: "POST", path: "/trades/offer", handler: "game.createOffer", config: PLAYER },
+  { method: "POST", path: "/trades/scan", handler: "game.scanOffer", config: PLAYER },
+  { method: "GET", path: "/trades/active", handler: "game.activeOffers", config: PLAYER },
+  { method: "GET", path: "/trades/history", handler: "game.tradeHistory", config: PLAYER },
+  { method: "GET", path: "/trades/offer/:id", handler: "game.getOffer", config: PLAYER },
+  { method: "POST", path: "/trades/offer/:id/accept", handler: "game.acceptOffer", config: PLAYER },
+  { method: "POST", path: "/trades/offer/:id/reject", handler: "game.rejectOffer", config: PLAYER },
+  { method: "POST", path: "/trades/offer/:id/cancel", handler: "game.cancelOffer", config: PLAYER },
+  // redemptions
+  { method: "POST", path: "/redemptions", handler: "game.createRedemption", config: PLAYER },
+  { method: "GET", path: "/redemptions/history", handler: "game.redemptionHistory", config: PLAYER },
+  { method: "GET", path: "/redemptions/:id", handler: "game.getRedemption", config: PLAYER }
+];
+const can = (...actions) => ({
+  policies: [{ name: "admin::hasPermissions", config: { actions: actions.map((a) => `plugin::tcg.${a}`) } }]
+});
+const admin = [
+  // dashboard & audit
+  { method: "GET", path: "/dashboard", handler: "admin.dashboard", config: can(RBAC.DASHBOARD_READ) },
+  { method: "GET", path: "/seasons/:season/leaderboard", handler: "admin.leaderboard", config: can(RBAC.DASHBOARD_READ) },
+  { method: "GET", path: "/seasons/:season/pulls", handler: "admin.pulls", config: can(RBAC.AUDIT_READ) },
+  // seasons
+  { method: "GET", path: "/seasons", handler: "admin.seasons", config: can(RBAC.SEASONS_READ) },
+  { method: "GET", path: "/seasons/defaults", handler: "admin.seasonDefaults", config: can(RBAC.SEASONS_READ) },
+  { method: "POST", path: "/seasons", handler: "admin.createSeason", config: can(RBAC.SEASONS_WRITE) },
+  { method: "GET", path: "/seasons/:season", handler: "admin.season", config: can(RBAC.SEASONS_READ) },
+  { method: "PUT", path: "/seasons/:season", handler: "admin.updateSeason", config: can(RBAC.SEASONS_WRITE) },
+  { method: "DELETE", path: "/seasons/:season", handler: "admin.deleteSeason", config: can(RBAC.SEASONS_WRITE) },
+  // cards
+  { method: "GET", path: "/seasons/:season/cards", handler: "admin.cards", config: can(RBAC.CARDS_READ) },
+  { method: "POST", path: "/seasons/:season/cards", handler: "admin.createCard", config: can(RBAC.CARDS_WRITE) },
+  { method: "GET", path: "/seasons/:season/cards/:id", handler: "admin.card", config: can(RBAC.CARDS_READ) },
+  { method: "PUT", path: "/seasons/:season/cards/:id", handler: "admin.updateCard", config: can(RBAC.CARDS_WRITE) },
+  { method: "DELETE", path: "/seasons/:season/cards/:id", handler: "admin.deleteCard", config: can(RBAC.CARDS_WRITE) },
+  // packs
+  { method: "GET", path: "/seasons/:season/packs", handler: "admin.packs", config: can(RBAC.PACKS_READ) },
+  { method: "POST", path: "/seasons/:season/packs", handler: "admin.createPack", config: can(RBAC.PACKS_WRITE) },
+  { method: "GET", path: "/seasons/:season/packs/:id", handler: "admin.pack", config: can(RBAC.PACKS_READ) },
+  { method: "PUT", path: "/seasons/:season/packs/:id", handler: "admin.updatePack", config: can(RBAC.PACKS_WRITE) },
+  { method: "DELETE", path: "/seasons/:season/packs/:id", handler: "admin.deletePack", config: can(RBAC.PACKS_WRITE) },
+  { method: "PUT", path: "/seasons/:season/packs/:id/cards", handler: "admin.setPackCards", config: can(RBAC.PACKS_WRITE) },
+  { method: "POST", path: "/seasons/:season/packs/:id/qr", handler: "admin.packQR", config: can(RBAC.PACKS_QR) },
+  { method: "POST", path: "/seasons/:season/packs/:id/rotate-secret", handler: "admin.rotatePackSecret", config: can(RBAC.PACKS_WRITE) },
+  { method: "GET", path: "/seasons/:season/packs/:id/simulate", handler: "admin.simulate", config: can(RBAC.PACKS_READ) },
+  // drops
+  { method: "GET", path: "/seasons/:season/packs/:id/drops", handler: "admin.drops", config: can(RBAC.PACKS_READ) },
+  { method: "POST", path: "/seasons/:season/packs/:id/drops", handler: "admin.createDrop", config: can(RBAC.PACKS_WRITE) },
+  { method: "GET", path: "/seasons/:season/packs/:id/drops/:dropId", handler: "admin.drop", config: can(RBAC.PACKS_READ) },
+  { method: "PUT", path: "/seasons/:season/packs/:id/drops/:dropId", handler: "admin.updateDrop", config: can(RBAC.PACKS_WRITE) },
+  { method: "DELETE", path: "/seasons/:season/packs/:id/drops/:dropId", handler: "admin.deleteDrop", config: can(RBAC.PACKS_WRITE) },
+  { method: "PUT", path: "/seasons/:season/packs/:id/drops/:dropId/cards", handler: "admin.setDropCards", config: can(RBAC.PACKS_WRITE) },
+  { method: "POST", path: "/seasons/:season/packs/:id/drops/:dropId/qr", handler: "admin.dropQR", config: can(RBAC.PACKS_QR) },
+  { method: "POST", path: "/seasons/:season/packs/:id/drops/:dropId/rotate-secret", handler: "admin.rotateDropSecret", config: can(RBAC.PACKS_WRITE) },
+  // live boosts
+  { method: "GET", path: "/seasons/:season/boosts", handler: "admin.boosts", config: can(RBAC.LIVE_READ) },
+  { method: "POST", path: "/seasons/:season/boosts", handler: "admin.createBoost", config: can(RBAC.LIVE_WRITE) },
+  { method: "PUT", path: "/seasons/:season/boosts/:id", handler: "admin.updateBoost", config: can(RBAC.LIVE_WRITE) },
+  { method: "DELETE", path: "/seasons/:season/boosts/:id", handler: "admin.deleteBoost", config: can(RBAC.LIVE_WRITE) },
+  // rewards
+  { method: "GET", path: "/seasons/:season/rewards", handler: "admin.rewards", config: can(RBAC.REWARDS_READ) },
+  { method: "POST", path: "/seasons/:season/rewards", handler: "admin.createReward", config: can(RBAC.REWARDS_WRITE) },
+  { method: "PUT", path: "/seasons/:season/rewards/:id", handler: "admin.updateReward", config: can(RBAC.REWARDS_WRITE) },
+  { method: "DELETE", path: "/seasons/:season/rewards/:id", handler: "admin.deleteReward", config: can(RBAC.REWARDS_WRITE) },
+  // sets & badges
+  { method: "GET", path: "/seasons/:season/sets", handler: "admin.sets", config: can(RBAC.CARDS_READ) },
+  { method: "POST", path: "/seasons/:season/sets", handler: "admin.createSet", config: can(RBAC.CARDS_WRITE) },
+  { method: "PUT", path: "/seasons/:season/sets/:id", handler: "admin.updateSet", config: can(RBAC.CARDS_WRITE) },
+  { method: "DELETE", path: "/seasons/:season/sets/:id", handler: "admin.deleteSet", config: can(RBAC.CARDS_WRITE) },
+  { method: "GET", path: "/seasons/:season/badges", handler: "admin.badges", config: can(RBAC.CARDS_READ) },
+  { method: "POST", path: "/seasons/:season/badges", handler: "admin.createBadge", config: can(RBAC.CARDS_WRITE) },
+  { method: "POST", path: "/seasons/:season/badges/seed", handler: "admin.seedBadges", config: can(RBAC.CARDS_WRITE) },
+  { method: "PUT", path: "/seasons/:season/badges/:id", handler: "admin.updateBadge", config: can(RBAC.CARDS_WRITE) },
+  { method: "DELETE", path: "/seasons/:season/badges/:id", handler: "admin.deleteBadge", config: can(RBAC.CARDS_WRITE) },
+  // players
+  { method: "GET", path: "/players", handler: "admin.players", config: can(RBAC.PLAYERS_READ) },
+  { method: "GET", path: "/players/:id", handler: "admin.player", config: can(RBAC.PLAYERS_READ) },
+  { method: "PUT", path: "/players/:id/active", handler: "admin.setPlayerActive", config: can(RBAC.PLAYERS_WRITE) },
+  { method: "POST", path: "/players/:id/grant", handler: "admin.grantCard", config: can(RBAC.PLAYERS_WRITE) },
+  // redemptions
+  { method: "GET", path: "/redemptions", handler: "admin.redemptions", config: can(RBAC.REDEMPTIONS_READ) },
+  { method: "GET", path: "/redemptions/:code", handler: "admin.redemption", config: can(RBAC.REDEMPTIONS_READ) },
+  { method: "POST", path: "/redemptions/:code/fulfill", handler: "admin.fulfillRedemption", config: can(RBAC.REDEMPTIONS_FULFILL) },
+  { method: "POST", path: "/redemptions/:code/cancel", handler: "admin.cancelRedemption", config: can(RBAC.REDEMPTIONS_FULFILL) },
+  // settings
+  { method: "GET", path: "/settings", handler: "admin.settings", config: can(RBAC.SETTINGS_READ) }
+];
+const routes = {
+  "content-api": { type: "content-api", routes: contentApi },
+  admin: { type: "admin", routes: admin }
+};
+let warnedQr = false;
+const DEFAULT_PLAYERS = Object.freeze({
+  autoProvision: true,
+  idHeader: "x-player-id",
+  nameHeader: "x-player-name",
+  avatarHeader: "x-player-avatar"
+});
+const settings = ({ strapi }) => ({
+  /** @returns {Object} the full plugin config */
+  all() {
+    return strapi.config.get(`plugin::${PLUGIN_ID}`) ?? {};
+  },
+  /** Secret used for trade QR tokens and packs without their own secret. Falls back to the app keys. */
+  qrGlobalSecret() {
+    const configured = this.all().qr?.globalSecret;
+    if (configured) return configured;
+    const appKeys = strapi.config.get("server.app.keys") ?? [];
+    if (!warnedQr) {
+      strapi.log.warn(`${LOG_PREFIX} qr.globalSecret not set, deriving one from the app keys. Set TCG_QR_SECRET before going live.`);
+      warnedQr = true;
+    }
+    return `${appKeys[0] ?? "tcg-dev"}:tcg-qr`;
+  },
+  playerCodePrefix() {
+    return this.all().playerCodePrefix ?? "TCG";
+  },
+  /** How the caller names the player: header names and whether unknown ids create a player. */
+  players() {
+    const p = this.all().players ?? {};
+    return {
+      autoProvision: p.autoProvision !== false,
+      idHeader: String(p.idHeader || DEFAULT_PLAYERS.idHeader).toLowerCase(),
+      nameHeader: String(p.nameHeader || DEFAULT_PLAYERS.nameHeader).toLowerCase(),
+      avatarHeader: String(p.avatarHeader || DEFAULT_PLAYERS.avatarHeader).toLowerCase()
+    };
+  },
+  sweepsEnabled() {
+    return this.all().sweeps?.enabled !== false;
+  }
+});
+const sign = (payload, secret) => createHmac("sha256", secret).update(payload).digest("hex");
+const safeEqual = (a, b) => {
+  const ba = Buffer.from(String(a));
+  const bb = Buffer.from(String(b));
+  return ba.length === bb.length && timingSafeEqual(ba, bb);
+};
+const newNonce = () => randomBytes(QR_NONCE_BYTES).toString("hex");
+const signDropToken = (dropId, secret, ttlMs, now = Date.now()) => {
+  const nonce2 = newNonce();
+  const expiresAt = now + ttlMs;
+  const payload = `d.${dropId}.${nonce2}.${expiresAt}`;
+  return { token: `${payload}.${sign(payload, secret)}`, nonce: nonce2, expiresAt };
+};
+const signStaticToken = (dropId, secret) => {
+  const payload = `s.${dropId}`;
+  return { token: `${payload}.${sign(payload, secret)}` };
+};
+const signTradeToken = (offerId, playerId, secret, ttlMs, now = Date.now()) => {
+  const nonce2 = newNonce();
+  const expiresAt = now + ttlMs;
+  const payload = `t.${offerId}.${playerId}.${nonce2}.${expiresAt}`;
+  return { token: `${payload}.${sign(payload, secret)}`, nonce: nonce2, expiresAt };
+};
+const peekToken = (token) => {
+  const parts = String(token ?? "").split(".");
+  if (parts[0] === "d" && parts.length === 5) return { kind: "drop", mode: "rotating", dropId: parts[1] };
+  if (parts[0] === "s" && parts.length === 3) return { kind: "drop", mode: "static", dropId: parts[1] };
+  if (parts[0] === "t" && parts.length === 6) return { kind: "trade", offerId: parts[1], playerId: parts[2] };
+  return null;
+};
+const verifyToken = (token, secret, now = Date.now()) => {
+  const peek = peekToken(token);
+  if (!peek) return { valid: false, reason: "format" };
+  const parts = String(token).split(".");
+  const signature = parts[parts.length - 1];
+  const payload = parts.slice(0, -1).join(".");
+  if (!safeEqual(sign(payload, secret), signature)) return { valid: false, reason: "signature" };
+  if (peek.kind === "drop" && peek.mode === "static") return { valid: true, ...peek };
+  const expiresAt = Number(parts[parts.length - 2]);
+  if (!Number.isFinite(expiresAt) || now > expiresAt) return { valid: false, reason: "expired" };
+  const nonce2 = parts[parts.length - 3];
+  return { valid: true, ...peek, nonce: nonce2, expiresAt };
+};
+const qr = ({ strapi }) => ({
+  secretOf(drop2) {
+    return drop2.secret || strapi.plugin("tcg").service("settings").qrGlobalSecret();
+  },
+  /** @param {Object} drop @param {number} ttlMs */
+  forDrop(drop2, ttlMs) {
+    if (drop2.mode === DROP_MODE.STATIC) return { ...signStaticToken(drop2.documentId, this.secretOf(drop2)), mode: DROP_MODE.STATIC, expiresAt: null };
+    return { ...signDropToken(drop2.documentId, this.secretOf(drop2), ttlMs), mode: DROP_MODE.ROTATING };
+  },
+  forTrade(offer, player2, ttlMs) {
+    return signTradeToken(offer.documentId, player2.documentId, strapi.plugin("tcg").service("settings").qrGlobalSecret(), ttlMs);
+  },
+  /**
+   * Verifies signature + expiry; burns the nonce for rotating/trade tokens. Throws TcgError.
+   * @param {string} token
+   * @param {string} secret
+   * @param {'drop'|'trade'} kind
+   */
+  async consume(token, secret, kind2) {
+    const result = verifyToken(token, secret);
+    if (!result.valid) {
+      if (result.reason === "expired") throw badRequest(ERROR_CODES.QR_EXPIRED, "Ce QR code a expiré.");
+      throw badRequest(ERROR_CODES.QR_INVALID, "QR code invalide.");
+    }
+    if (result.kind !== kind2) throw badRequest(ERROR_CODES.QR_INVALID, "QR code invalide.");
+    if (!result.nonce) return result;
+    const seen = await strapi.db.query(UID.NONCE).findOne({ where: { nonce: result.nonce }, select: ["id"] });
+    if (seen) throw badRequest(ERROR_CODES.QR_REUSED, "Ce QR code a déjà été utilisé.");
+    try {
+      await strapi.db.query(UID.NONCE).create({
+        data: { nonce: result.nonce, kind: kind2 === "drop" ? NONCE_KIND.DROP : NONCE_KIND.TRADE, expiresAt: new Date(result.expiresAt) }
+      });
+    } catch (err) {
+      throw badRequest(ERROR_CODES.QR_REUSED, "Ce QR code a déjà été utilisé.");
+    }
+    return result;
+  },
+  async sweep() {
+    const { count } = await strapi.db.query(UID.NONCE).deleteMany({ where: { expiresAt: { $lt: /* @__PURE__ */ new Date() } } });
+    return count ?? 0;
+  }
+});
+const mediaUrl = (media) => media && typeof media === "object" ? media.url ?? null : null;
+const format = () => ({
+  rarityMeta(season2, key) {
+    return (season2?.rarities ?? []).find((r) => r.key === key) ?? { key, label: key, color: "#000000" };
+  },
+  card(card2, season2) {
+    if (!card2) return null;
+    const rarity = this.rarityMeta(season2, card2.rarity);
+    return {
+      id: card2.documentId,
+      name: card2.name,
+      number: card2.number ?? null,
+      description: card2.description ?? null,
+      rarity: card2.rarity,
+      rarityLabel: rarity.label,
+      rarityColor: rarity.color,
+      edition: card2.edition ?? "standard",
+      score: card2.score ?? 0,
+      imageUrl: mediaUrl(card2.image),
+      attributes: card2.attributes ?? {},
+      lore: card2.lore ?? null,
+      artist: card2.artist ?? null,
+      supplyCap: card2.supplyCap ?? null,
+      minted: card2.minted ?? 0,
+      isSoldOut: card2.supplyCap != null && (card2.minted ?? 0) >= card2.supplyCap
+    };
+  },
+  pack(pack2) {
+    if (!pack2) return null;
+    return {
+      id: pack2.documentId,
+      name: pack2.name,
+      slug: pack2.slug,
+      kind: pack2.kind,
+      description: pack2.description ?? null,
+      location: pack2.location ?? null,
+      imageUrl: mediaUrl(pack2.image),
+      isActive: pack2.isActive,
+      sortOrder: pack2.sortOrder ?? 0,
+      meta: pack2.meta ?? {}
+    };
+  },
+  season(season2) {
+    if (!season2) return null;
+    return {
+      id: season2.documentId,
+      name: season2.name,
+      slug: season2.slug,
+      eventName: season2.eventName ?? null,
+      description: season2.description ?? null,
+      status: season2.status,
+      startsAt: season2.startsAt ?? null,
+      endsAt: season2.endsAt ?? null,
+      coverUrl: mediaUrl(season2.cover),
+      rarities: season2.rarities ?? [],
+      editions: season2.editions ?? [],
+      limits: season2.limits ?? {},
+      rankTiers: season2.rankTiers ?? [],
+      theme: season2.theme ?? {}
+    };
+  },
+  player(player2) {
+    if (!player2) return null;
+    return {
+      id: player2.documentId,
+      code: player2.code,
+      displayName: player2.displayName ?? null,
+      avatarUrl: player2.avatarUrl ?? null,
+      provider: player2.provider,
+      isGuest: player2.isGuest,
+      totalCards: player2.totalCards ?? 0,
+      totalTrades: player2.totalTrades ?? 0,
+      totalRedemptions: player2.totalRedemptions ?? 0,
+      createdAt: player2.createdAt,
+      lastActiveAt: player2.lastActiveAt ?? null
+    };
+  },
+  /** Admin-only view: includes msisdn. */
+  playerAdmin(player2) {
+    return player2 ? { ...this.player(player2), externalId: player2.externalId ?? null, msisdn: player2.msisdn ?? null, isActive: player2.isActive, meta: player2.meta ?? {} } : null;
+  },
+  playerCard(pc, season2) {
+    if (!pc) return null;
+    return {
+      id: pc.documentId,
+      card: this.card(pc.card, season2),
+      pack: pc.pack ? { id: pc.pack.documentId, name: pc.pack.name, slug: pc.pack.slug } : null,
+      acquiredFrom: pc.acquiredFrom,
+      acquiredAt: pc.acquiredAt,
+      mintNumber: pc.mintNumber ?? null
+    };
+  },
+  redemption(r) {
+    if (!r) return null;
+    return {
+      id: r.documentId,
+      code: r.code,
+      status: r.status,
+      cards: r.cards ?? [],
+      rewardType: r.rewardType ?? null,
+      rewardDescription: r.rewardDescription ?? null,
+      redeemedAt: r.redeemedAt,
+      fulfilledAt: r.fulfilledAt ?? null,
+      fulfilledBy: r.fulfilledBy ?? null,
+      note: r.note ?? null,
+      player: r.player ? this.player(r.player) : void 0,
+      season: r.season ? { id: r.season.documentId, name: r.season.name, slug: r.season.slug } : void 0,
+      reward: r.reward ? { id: r.reward.documentId, name: r.reward.name, slug: r.reward.slug, tier: r.reward.tier ?? null, booth: r.reward.booth ?? null, imageUrl: mediaUrl(r.reward.image), stock: r.reward.stock ?? null, claimed: r.reward.claimed ?? 0 } : r.rewardName ? { name: r.rewardName } : null
+    };
+  }
+});
+const randomCode = (length) => {
+  let out = "";
+  for (let i = 0; i < length; i += 1) out += CODE_CHARSET[randomInt(CODE_CHARSET.length)];
+  return out;
+};
+const player = ({ strapi }) => ({
+  async generateCode() {
+    const prefix = strapi.plugin("tcg").service("settings").playerCodePrefix();
+    for (let i = 0; i < MAX_CODE_ATTEMPTS; i += 1) {
+      const code = `${prefix}-${randomCode(PLAYER_CODE_LENGTH)}`;
+      const exists = await strapi.db.query(UID.PLAYER).findOne({ where: { code }, select: ["id"] });
+      if (!exists) return code;
+    }
+    throw conflict(ERROR_CODES.VALIDATION, "Impossible de générer un code joueur unique.");
+  },
+  /**
+   * The player behind an external id (whatever the host uses: phone, user id, username), created on
+   * first sight when `autoProvision` is on. Name and avatar are hints that refresh the record.
+   * @param {{ externalId: string, displayName?: string|null, avatarUrl?: string|null, autoProvision?: boolean }} p
+   * @returns {Promise<Object>} the player row (`__created` is true when it was just provisioned)
+   */
+  async resolve({ externalId, displayName = null, avatarUrl = null, autoProvision = true }) {
+    const now = /* @__PURE__ */ new Date();
+    const id = String(externalId).trim();
+    const existing = await strapi.db.query(UID.PLAYER).findOne({ where: { externalId: id } });
+    if (existing) {
+      const patch = { lastActiveAt: now };
+      if (displayName && displayName !== existing.displayName) patch.displayName = displayName.slice(0, 100);
+      if (avatarUrl && avatarUrl !== existing.avatarUrl) patch.avatarUrl = avatarUrl.slice(0, 500);
+      return strapi.db.query(UID.PLAYER).update({ where: { id: existing.id }, data: patch });
+    }
+    if (!autoProvision) throw notFound(ERROR_CODES.PLAYER_NOT_FOUND, "Joueur inconnu.");
+    const player2 = await strapi.db.query(UID.PLAYER).create({
+      data: {
+        externalId: id,
+        msisdn: /^\+?\d{8,15}$/.test(id) ? id : null,
+        code: await this.generateCode(),
+        displayName: displayName ? displayName.slice(0, 100) : null,
+        avatarUrl: avatarUrl ? avatarUrl.slice(0, 500) : null,
+        provider: "api",
+        isGuest: false,
+        isActive: true,
+        lastActiveAt: now
+      }
+    });
+    return { ...player2, __created: true };
+  },
+  /** @param {number} id internal id */
+  async byId(id) {
+    const player2 = await strapi.db.query(UID.PLAYER).findOne({ where: { id } });
+    if (!player2) throw notFound(ERROR_CODES.PLAYER_NOT_FOUND, "Joueur introuvable.");
+    return player2;
+  },
+  async byDocumentId(documentId) {
+    const player2 = await strapi.db.query(UID.PLAYER).findOne({ where: { documentId } });
+    if (!player2) throw notFound(ERROR_CODES.PLAYER_NOT_FOUND, "Joueur introuvable.");
+    return player2;
+  },
+  async byCode(code) {
+    return strapi.db.query(UID.PLAYER).findOne({ where: { code: String(code).toUpperCase().trim() } });
+  },
+  async touch(id) {
+    await strapi.db.query(UID.PLAYER).update({ where: { id }, data: { lastActiveAt: /* @__PURE__ */ new Date() } });
+  },
+  /**
+   * Admin search by code, msisdn fragment or display name.
+   * @param {{ q?: string, provider?: string, isActive?: boolean }} filters
+   * @param {{ offset: number, limit: number }} page
+   */
+  async search(filters, page) {
+    const where = {};
+    if (filters.q) {
+      const q = String(filters.q).trim();
+      where.$or = [{ code: { $containsi: q } }, { externalId: { $containsi: q } }, { msisdn: { $contains: q.replace(/[^\d]/g, "") || q } }, { displayName: { $containsi: q } }];
+    }
+    if (filters.provider) where.provider = filters.provider;
+    if (typeof filters.isActive === "boolean") where.isActive = filters.isActive;
+    const [items, total] = await Promise.all([
+      strapi.db.query(UID.PLAYER).findMany({ where, orderBy: { lastActiveAt: "desc" }, offset: page.offset, limit: page.limit }),
+      strapi.db.query(UID.PLAYER).count({ where })
+    ]);
+    return { items, total };
+  },
+  async setActive(documentId, isActive) {
+    const player2 = await this.byDocumentId(documentId);
+    return strapi.db.query(UID.PLAYER).update({ where: { id: player2.id }, data: { isActive: Boolean(isActive) } });
+  },
+  /** Recomputes the denormalised counters from the ledger tables. */
+  async recount(id) {
+    const [totalCards, totalRedemptions, asInitiator, asReceiver] = await Promise.all([
+      strapi.db.query(UID.PLAYER_CARD).count({ where: { player: id } }),
+      strapi.db.query(UID.REDEMPTION).count({ where: { player: id } }),
+      strapi.db.query(UID.TRADE).count({ where: { initiator: id } }),
+      strapi.db.query(UID.TRADE).count({ where: { receiver: id } })
+    ]);
+    return strapi.db.query(UID.PLAYER).update({
+      where: { id },
+      data: { totalCards, totalRedemptions, totalTrades: asInitiator + asReceiver }
+    });
+  }
+});
+const slugify = (value) => String(value ?? "").normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "item";
+const uniqueSlug = async (strapi, uid, base, extraWhere = {}) => {
+  const root = slugify(base);
+  let candidate = root;
+  for (let i = 2; i < 1e3; i += 1) {
+    const exists = await strapi.db.query(uid).findOne({ where: { slug: candidate, ...extraWhere }, select: ["id"] });
+    if (!exists) return candidate;
+    candidate = `${root}-${i}`;
+  }
+  return `${root}-${Date.now()}`;
+};
+const POPULATE$8 = { cover: true };
+const season = ({ strapi }) => ({
+  defaults() {
+    return {
+      rarities: DEFAULT_RARITIES.map((r) => ({ ...r })),
+      editions: DEFAULT_EDITIONS.map((e) => ({ ...e })),
+      limits: { ...DEFAULT_LIMITS },
+      rankTiers: DEFAULT_RANK_TIERS.map((t) => ({ ...t }))
+    };
+  },
+  /** Merges season limits over the defaults so a missing key never breaks the engine. */
+  limitsOf(season2) {
+    return { ...DEFAULT_LIMITS, ...season2?.limits ?? {} };
+  },
+  rankTiersOf(season2) {
+    const tiers = Array.isArray(season2?.rankTiers) && season2.rankTiers.length ? season2.rankTiers : DEFAULT_RANK_TIERS;
+    return [...tiers].sort((a, b) => b.minPercent - a.minPercent);
+  },
+  /** @returns {Promise<Object|null>} */
+  async current() {
+    const now = /* @__PURE__ */ new Date();
+    const active = await strapi.db.query(UID.SEASON).findMany({
+      where: { status: SEASON_STATUS.ACTIVE },
+      populate: POPULATE$8,
+      orderBy: [{ startsAt: "desc" }, { createdAt: "desc" }]
+    });
+    if (active.length === 0) return null;
+    const inWindow = active.find(
+      (s) => (!s.startsAt || new Date(s.startsAt) <= now) && (!s.endsAt || new Date(s.endsAt) >= now)
+    );
+    return inWindow ?? active[0];
+  },
+  async requireCurrent() {
+    const season2 = await this.current();
+    if (!season2) throw notFound(ERROR_CODES.SEASON_NOT_FOUND, "Aucune saison en cours.");
+    return season2;
+  },
+  /** Resolves `?season=` (slug or documentId) or falls back to the current season. */
+  async resolve(ref) {
+    if (!ref) return this.requireCurrent();
+    const season2 = await strapi.db.query(UID.SEASON).findOne({
+      where: { $or: [{ slug: ref }, { documentId: ref }] },
+      populate: POPULATE$8
+    });
+    if (!season2) throw notFound(ERROR_CODES.SEASON_NOT_FOUND, "Saison introuvable.");
+    return season2;
+  },
+  async list() {
+    return strapi.db.query(UID.SEASON).findMany({ populate: POPULATE$8, orderBy: [{ status: "asc" }, { startsAt: "desc" }] });
+  },
+  async findOne(ref) {
+    return this.resolve(ref);
+  },
+  validate(data) {
+    if (data.rarities !== void 0) {
+      const problems = validateRarities(data.rarities);
+      if (problems.length) throw badRequest(ERROR_CODES.VALIDATION, "Table de raretés invalide.", { problems });
+    }
+    if (data.limits !== void 0) {
+      for (const [k, v] of Object.entries(data.limits)) {
+        if (!(k in DEFAULT_LIMITS)) throw badRequest(ERROR_CODES.VALIDATION, `Limite inconnue "${k}".`);
+        if (!(Number.isFinite(Number(v)) && Number(v) >= 0)) throw badRequest(ERROR_CODES.VALIDATION, `Limite "${k}" invalide.`);
+      }
+    }
+    if (data.rankTiers !== void 0) {
+      if (!Array.isArray(data.rankTiers) || data.rankTiers.some((t) => !t?.key || !Number.isFinite(Number(t.minPercent)))) {
+        throw badRequest(ERROR_CODES.VALIDATION, "Paliers de rang invalides.");
+      }
+    }
+    if (data.status !== void 0 && !Object.values(SEASON_STATUS).includes(data.status)) {
+      throw badRequest(ERROR_CODES.VALIDATION, "Statut invalide.");
+    }
+  },
+  async create(data) {
+    const payload = { ...this.defaults(), status: SEASON_STATUS.DRAFT, ...data };
+    if (!payload.name) throw badRequest(ERROR_CODES.VALIDATION, "Le nom est requis.");
+    this.validate(payload);
+    payload.slug = await uniqueSlug(strapi, UID.SEASON, payload.slug || payload.name);
+    const { seedBadges = true, ...clean } = payload;
+    const season2 = await strapi.documents(UID.SEASON).create({ data: clean, populate: POPULATE$8 });
+    if (seedBadges) await strapi.plugin("tcg").service("badge").seedStarters(season2);
+    return season2;
+  },
+  async update(ref, data) {
+    const season2 = await this.resolve(ref);
+    this.validate(data);
+    if (data.slug && data.slug !== season2.slug) data.slug = await uniqueSlug(strapi, UID.SEASON, data.slug);
+    return strapi.documents(UID.SEASON).update({ documentId: season2.documentId, data, populate: POPULATE$8 });
+  },
+  async remove(ref) {
+    const season2 = await this.resolve(ref);
+    const [cards, pulls] = await Promise.all([
+      strapi.db.query(UID.CARD).count({ where: { season: season2.id } }),
+      strapi.db.query(UID.PULL).count({ where: { season: season2.id } })
+    ]);
+    if (pulls > 0) throw badRequest(ERROR_CODES.VALIDATION, "Cette saison a déjà des tirages : archivez-la au lieu de la supprimer.");
+    if (cards > 0) throw badRequest(ERROR_CODES.VALIDATION, "Supprimez ou déplacez les cartes de la saison avant.");
+    await strapi.documents(UID.SEASON).delete({ documentId: season2.documentId });
+    return { ok: true };
+  },
+  /** Rank tier for a completion percentage. */
+  tierFor(season2, percent) {
+    const tiers = this.rankTiersOf(season2);
+    return tiers.find((t) => percent >= Number(t.minPercent)) ?? tiers[tiers.length - 1];
+  }
+});
+const POPULATE$7 = { image: true, season: true };
+const card = ({ strapi }) => ({
+  /**
+   * @param {Object} season
+   * @param {{ rarity?: string, edition?: string, q?: string, isActive?: boolean }} filters
+   * @param {{ offset: number, limit: number }} [page]
+   */
+  async list(season2, filters = {}, page) {
+    const where = { season: season2.id };
+    if (filters.rarity) where.rarity = filters.rarity;
+    if (filters.edition) where.edition = filters.edition;
+    if (typeof filters.isActive === "boolean") where.isActive = filters.isActive;
+    if (filters.q) where.name = { $containsi: String(filters.q) };
+    const q = { where, populate: POPULATE$7, orderBy: [{ number: "asc" }, { name: "asc" }] };
+    if (page) Object.assign(q, { offset: page.offset, limit: page.limit });
+    const [items, total] = await Promise.all([strapi.db.query(UID.CARD).findMany(q), strapi.db.query(UID.CARD).count({ where })]);
+    return { items, total };
+  },
+  async findOne(documentId) {
+    const card2 = await strapi.db.query(UID.CARD).findOne({ where: { documentId }, populate: POPULATE$7 });
+    if (!card2) throw notFound(ERROR_CODES.CARD_NOT_FOUND, "Carte introuvable.");
+    return card2;
+  },
+  validate(season2, data) {
+    if (data.rarity !== void 0) {
+      const keys = (season2.rarities ?? []).map((r) => r.key);
+      if (!keys.includes(data.rarity)) throw badRequest(ERROR_CODES.VALIDATION, `Rareté "${data.rarity}" inconnue pour cette saison.`, { allowed: keys });
+    }
+    if (data.supplyCap !== void 0 && data.supplyCap !== null && data.supplyCap !== "" && !(Number(data.supplyCap) >= 1)) {
+      throw badRequest(ERROR_CODES.VALIDATION, "supplyCap doit être ≥ 1 (ou vide pour illimité).");
+    }
+    if (data.edition !== void 0 && Array.isArray(season2.editions) && season2.editions.length) {
+      const keys = season2.editions.map((e) => e.key);
+      if (!keys.includes(data.edition)) throw badRequest(ERROR_CODES.VALIDATION, `Édition "${data.edition}" inconnue.`, { allowed: keys });
+    }
+  },
+  async create(season2, data) {
+    if (!data.name) throw badRequest(ERROR_CODES.VALIDATION, "Le nom est requis.");
+    if (!data.rarity) throw badRequest(ERROR_CODES.VALIDATION, "La rareté est requise.");
+    this.validate(season2, data);
+    return strapi.documents(UID.CARD).create({ data: { ...data, season: season2.id }, populate: POPULATE$7 });
+  },
+  async update(season2, documentId, data) {
+    await this.findOne(documentId);
+    this.validate(season2, data);
+    const { season: _ignored, minted: _m, sets: _sets, ...rest } = data;
+    if (rest.supplyCap === "") rest.supplyCap = null;
+    return strapi.documents(UID.CARD).update({ documentId, data: rest, populate: POPULATE$7 });
+  },
+  async remove(documentId) {
+    const card2 = await this.findOne(documentId);
+    const owned = await strapi.db.query(UID.PLAYER_CARD).count({ where: { card: card2.id } });
+    if (owned > 0) throw badRequest(ERROR_CODES.VALIDATION, "Des joueurs possèdent cette carte : désactivez-la au lieu de la supprimer.");
+    await strapi.documents(UID.CARD).delete({ documentId });
+    return { ok: true };
+  },
+  /** Admin list enrichment: where each card is exclusive. */
+  async withExclusivity(cards) {
+    const drop2 = strapi.plugin("tcg").service("drop");
+    return Promise.all(cards.map(async (c) => ({ ...c, exclusiveTo: await drop2.exclusivityOf(c.id) })));
+  },
+  /** Count of cards per rarity for a season (admin). */
+  async countByRarity(season2) {
+    const rows = await strapi.db.query(UID.CARD).findMany({ where: { season: season2.id, isActive: true }, select: ["rarity"] });
+    return rows.reduce((acc, r) => ({ ...acc, [r.rarity]: (acc[r.rarity] ?? 0) + 1 }), {});
+  }
+});
+const POPULATE$6 = { image: true, season: true };
+const pack = ({ strapi }) => ({
+  async list(season2, { includeInactive = false } = {}) {
+    const where = { season: season2.id };
+    if (!includeInactive) where.isActive = true;
+    return strapi.db.query(UID.PACK).findMany({ where, populate: POPULATE$6, orderBy: [{ sortOrder: "asc" }, { name: "asc" }] });
+  },
+  async findOne(season2, ref) {
+    const pack2 = await strapi.db.query(UID.PACK).findOne({ where: { season: season2.id, $or: [{ slug: ref }, { documentId: ref }] }, populate: POPULATE$6 });
+    if (!pack2) throw notFound(ERROR_CODES.PACK_NOT_FOUND, "Pack introuvable.");
+    return pack2;
+  },
+  /** Base pool: active pack cards with weights. */
+  async pool(pack2) {
+    const rows = await strapi.db.query(UID.PACK_CARD).findMany({
+      where: { pack: pack2.id, isActive: true, card: { isActive: true } },
+      populate: { card: { populate: { image: true } } }
+    });
+    return rows.filter((r) => r.card).map((r) => ({ ...r.card, weight: r.weight, isExclusive: r.isExclusive, packCardId: r.id }));
+  },
+  async create(season2, data) {
+    if (!data.name) throw badRequest(ERROR_CODES.VALIDATION, "Le nom est requis.");
+    if (data.kind && !Object.values(PACK_KIND).includes(data.kind)) throw badRequest(ERROR_CODES.VALIDATION, "Type de pack invalide.");
+    const { cards, drops: _d, ...rest } = data;
+    const slug = await uniqueSlug(strapi, UID.PACK, rest.slug || rest.name, { season: season2.id });
+    const pack2 = await strapi.documents(UID.PACK).create({ data: { ...rest, slug, season: season2.id }, populate: POPULATE$6 });
+    const full = { ...pack2, season: season2 };
+    if (Array.isArray(cards)) await this.setCards(season2, pack2.documentId, cards);
+    await strapi.plugin("tcg").service("drop").ensureDefault(full);
+    return pack2;
+  },
+  async update(season2, ref, data) {
+    const pack2 = await this.findOne(season2, ref);
+    if (data.kind && !Object.values(PACK_KIND).includes(data.kind)) throw badRequest(ERROR_CODES.VALIDATION, "Type de pack invalide.");
+    const { cards, season: _s, drops: _d, ...rest } = data;
+    if (rest.slug && rest.slug !== pack2.slug) rest.slug = await uniqueSlug(strapi, UID.PACK, rest.slug, { season: season2.id });
+    const updated = await strapi.documents(UID.PACK).update({ documentId: pack2.documentId, data: rest, populate: POPULATE$6 });
+    if (Array.isArray(cards)) await this.setCards(season2, pack2.documentId, cards);
+    return updated;
+  },
+  async remove(season2, ref) {
+    const pack2 = await this.findOne(season2, ref);
+    const pulls = await strapi.db.query(UID.PULL).count({ where: { pack: pack2.id } });
+    if (pulls > 0) throw badRequest(ERROR_CODES.VALIDATION, "Ce pack a des tirages : désactivez-le au lieu de le supprimer.");
+    const drops = await strapi.db.query(UID.DROP).findMany({ where: { pack: pack2.id }, select: ["id", "documentId"] });
+    for (const d of drops) {
+      await strapi.db.query(UID.DROP_CARD).deleteMany({ where: { drop: d.id } });
+      await strapi.documents(UID.DROP).delete({ documentId: d.documentId });
+    }
+    await strapi.db.query(UID.PACK_CARD).deleteMany({ where: { pack: pack2.id } });
+    await strapi.documents(UID.PACK).delete({ documentId: pack2.documentId });
+    return { ok: true };
+  },
+  async setCards(season2, packDocumentId, entries) {
+    const pack2 = await this.findOne(season2, packDocumentId);
+    const docIds = [...new Set(entries.map((e) => typeof e === "string" ? e : e.card))];
+    const cards = docIds.length ? await strapi.db.query(UID.CARD).findMany({ where: { documentId: { $in: docIds }, season: season2.id }, select: ["id", "documentId"] }) : [];
+    if (cards.length !== docIds.length) throw badRequest(ERROR_CODES.VALIDATION, "Certaines cartes ne font pas partie de cette saison.");
+    const idByDoc = Object.fromEntries(cards.map((c) => [c.documentId, c.id]));
+    await strapi.db.transaction(async () => {
+      await strapi.db.query(UID.PACK_CARD).deleteMany({ where: { pack: pack2.id } });
+      for (const e of entries) {
+        const entry = typeof e === "string" ? { card: e } : e;
+        await strapi.db.query(UID.PACK_CARD).create({
+          data: { pack: pack2.id, card: idByDoc[entry.card], weight: Number.isFinite(Number(entry.weight)) ? Number(entry.weight) : 100, isExclusive: Boolean(entry.isExclusive), isActive: entry.isActive !== false }
+        });
+      }
+    });
+    return this.cards(season2, packDocumentId);
+  },
+  async cards(season2, ref) {
+    const pack2 = await this.findOne(season2, ref);
+    const rows = await strapi.db.query(UID.PACK_CARD).findMany({ where: { pack: pack2.id }, populate: { card: { populate: { image: true } } }, orderBy: { id: "asc" } });
+    return rows.filter((r) => r.card).map((r) => ({ id: r.documentId, weight: r.weight, isExclusive: r.isExclusive, isActive: r.isActive, card: r.card }));
+  },
+  /** Pack-level QR = the default drop's QR. */
+  async generateQR(season2, ref) {
+    const pack2 = await this.findOne(season2, ref);
+    const drop2 = await strapi.plugin("tcg").service("drop").ensureDefault({ ...pack2, season: season2 });
+    const out = await strapi.plugin("tcg").service("drop").generateQR({ ...pack2, season: season2 }, drop2.documentId);
+    return { ...out, pack: pack2 };
+  }
+});
+const startOfToday$1 = () => {
+  const d = /* @__PURE__ */ new Date();
+  d.setHours(0, 0, 0, 0);
+  return d;
+};
+const pull = ({ strapi }) => ({
+  /**
+   * Conditional increment on a capped counter. Returns the new value, or null when the cap is reached.
+   * Pass `trx` when called inside `strapi.db.transaction(async ({ trx }) => …)`: sqlite has a single connection
+   * and a second one would wait forever.
+   */
+  async claimSlot(uid, id, counter, capColumn, trx = null) {
+    const md = strapi.db.metadata.get(uid);
+    const table = md.tableName;
+    const col = md.attributes[counter].columnName ?? counter;
+    const cap = capColumn ? md.attributes[capColumn].columnName ?? capColumn : null;
+    const knex = trx ?? strapi.db.connection;
+    let q = knex(table).where({ id });
+    if (cap) q = q.andWhere((b) => b.whereNull(cap).orWhereRaw(`${col} < ${cap}`));
+    const affected = await q.increment(col, 1);
+    if (!affected) return null;
+    const row = await knex(table).where({ id }).first(col);
+    return Number(row[col]);
+  },
+  /**
+   * @param {Object} player db row
+   * @param {string} qrToken
+   */
+  async scan(player2, qrToken) {
+    const plugin = strapi.plugin("tcg");
+    const peek = peekToken(qrToken);
+    if (!peek || peek.kind !== "drop") throw badRequest(ERROR_CODES.QR_INVALID, "QR code invalide.");
+    const drop2 = await plugin.service("drop").byDocumentId(peek.dropId);
+    const pack2 = drop2.pack;
+    const season2 = pack2?.season;
+    if (!pack2 || !pack2.isActive) throw unprocessable(ERROR_CODES.PACK_INACTIVE, "Ce pack n'est plus disponible.");
+    if (!season2 || season2.status !== "active") throw unprocessable(ERROR_CODES.SEASON_INACTIVE, "Cette saison n'est pas en cours.");
+    if (peek.mode !== drop2.mode) throw badRequest(ERROR_CODES.QR_INVALID, "QR code invalide.");
+    if (!plugin.service("drop").isOpen(drop2)) throw unprocessable(ERROR_CODES.DROP_CLOSED, "Ce point n'est pas ouvert en ce moment.", { startsAt: drop2.startsAt, endsAt: drop2.endsAt });
+    if (drop2.maxScansTotal != null && drop2.scanCount >= drop2.maxScansTotal) throw unprocessable(ERROR_CODES.DROP_SOLD_OUT, "Toutes les cartes de ce point ont été distribuées.");
+    const limits = plugin.service("season").limitsOf(season2);
+    await plugin.service("qr").consume(qrToken, plugin.service("qr").secretOf(drop2), "drop");
+    const now = /* @__PURE__ */ new Date();
+    const owned = await strapi.db.query(UID.PLAYER_CARD).count({ where: { player: player2.id, card: { season: season2.id } } });
+    if (owned >= limits.maxCollectionSize) throw unprocessable(ERROR_CODES.COLLECTION_FULL, `Collection pleine (${limits.maxCollectionSize} cartes max).`);
+    const cooldownMs = drop2.cooldownMs ?? (drop2.mode === DROP_MODE.STATIC ? Math.max(limits.pullCooldownMs, limits.staticScanCooldownMs) : limits.pullCooldownMs);
+    const lastHere = await strapi.db.query(UID.PULL).findOne({ where: { player: player2.id, drop: drop2.id }, orderBy: { pulledAt: "desc" }, select: ["pulledAt"] });
+    if (lastHere) {
+      const elapsed = now.getTime() - new Date(lastHere.pulledAt).getTime();
+      if (elapsed < cooldownMs) {
+        const remainingSeconds = Math.ceil((cooldownMs - elapsed) / 1e3);
+        throw unprocessable(ERROR_CODES.COOLDOWN_ACTIVE, remainingSeconds > 3600 ? `Revenez dans ${Math.ceil(remainingSeconds / 3600)} h.` : `Patientez encore ${remainingSeconds} s.`, { remainingSeconds });
+      }
+    }
+    if (drop2.maxScansPerPlayer != null) {
+      const mine = await strapi.db.query(UID.PULL).count({ where: { player: player2.id, drop: drop2.id } });
+      if (mine >= drop2.maxScansPerPlayer) throw unprocessable(ERROR_CODES.DROP_PLAYER_LIMIT, `Vous avez déjà obtenu vos ${drop2.maxScansPerPlayer} carte(s) ici.`);
+    }
+    const since = startOfToday$1();
+    const [packToday, totalToday] = await Promise.all([
+      strapi.db.query(UID.PULL).count({ where: { player: player2.id, pack: pack2.id, pulledAt: { $gte: since } } }),
+      strapi.db.query(UID.PULL).count({ where: { player: player2.id, season: season2.id, pulledAt: { $gte: since } } })
+    ]);
+    if (packToday >= limits.maxDailyPullsPerPack) throw unprocessable(ERROR_CODES.DAILY_LIMIT_PACK, `Limite atteinte pour ce pack aujourd'hui (${limits.maxDailyPullsPerPack}).`);
+    if (totalToday >= limits.maxDailyPullsTotal) throw unprocessable(ERROR_CODES.DAILY_LIMIT_TOTAL, `Limite quotidienne atteinte (${limits.maxDailyPullsTotal}).`);
+    const raw = await plugin.service("drop").rawPool(drop2, pack2);
+    const exclusiveIds = await plugin.service("drop").exclusiveCardIds(season2);
+    let pool = prunePool(raw, exclusiveIds);
+    if (pool.length === 0) throw unprocessable(ERROR_CODES.PACK_EMPTY, "Aucune carte disponible ici pour le moment.");
+    const boosts = await plugin.service("boost").activeFor(season2, pack2, drop2);
+    const multipliers = plugin.service("boost").combine(boosts);
+    const recent = await strapi.db.query(UID.PULL).findMany({
+      where: { player: player2.id, season: season2.id },
+      orderBy: { pulledAt: "desc" },
+      limit: Math.max(Number(limits.pityRareAfter) || 0, Number(limits.pityLegendaryAfter) || 0, 1),
+      select: ["rarity"]
+    });
+    const minRarity = pityFloor(recent, season2.rarities ?? [], limits);
+    let result = null;
+    let mintNumber = null;
+    for (let attempt = 0; attempt < MAX_PULL_RETRIES && pool.length; attempt += 1) {
+      result = pull$1({ playerId: player2.documentId, dropId: drop2.documentId, pullNumber: totalToday + 1 + attempt, pool, rarities: season2.rarities ?? [], multipliers, minRarity });
+      if (!result.card) break;
+      mintNumber = await this.claimSlot(UID.CARD, result.card.id, "minted", "supplyCap");
+      if (mintNumber != null) break;
+      pool = pool.filter((c) => c.id !== result.card.id);
+      result = null;
+    }
+    if (!result?.card || mintNumber == null) throw unprocessable(ERROR_CODES.PACK_EMPTY, "Plus de cartes disponibles ici.");
+    if (drop2.maxScansTotal != null) {
+      const slot = await this.claimSlot(UID.DROP, drop2.id, "scanCount", "maxScansTotal");
+      if (slot == null) throw unprocessable(ERROR_CODES.DROP_SOLD_OUT, "Toutes les cartes de ce point ont été distribuées.");
+    } else {
+      await this.claimSlot(UID.DROP, drop2.id, "scanCount", null);
+    }
+    const alreadyOwned = await strapi.db.query(UID.PLAYER_CARD).count({ where: { player: player2.id, card: result.card.id } });
+    const playerCard2 = await strapi.db.transaction(async () => {
+      const pc = await strapi.db.query(UID.PLAYER_CARD).create({
+        data: { player: player2.id, card: result.card.id, pack: pack2.id, acquiredFrom: ACQUISITION.PULL, acquiredAt: now, mintNumber }
+      });
+      await strapi.db.query(UID.PULL).create({
+        data: {
+          player: player2.id,
+          pack: pack2.id,
+          drop: drop2.id,
+          card: result.card.id,
+          season: season2.id,
+          seed: String(result.seed),
+          roll: result.roll,
+          rarity: result.rarity,
+          verificationHash: result.verificationHash,
+          qrToken: peek.mode === DROP_MODE.STATIC ? null : qrToken,
+          pulledAt: now,
+          odds: result.odds,
+          pity: result.pity,
+          mintNumber
+        }
+      });
+      await strapi.db.query(UID.PLAYER).update({ where: { id: player2.id }, data: { totalCards: (player2.totalCards ?? 0) + 1, lastActiveAt: now } });
+      return pc;
+    });
+    strapi.log.info(`[tcg] pull ${player2.code} ← ${result.card.name} #${mintNumber} (${result.rarity}${result.pity ? ", pity" : ""}) @ ${pack2.slug}/${drop2.slug}${boosts.length ? ` boosts=${boosts.map((b) => b.name).join("+")}` : ""}`);
+    const format2 = plugin.service("format");
+    const unlocked = await plugin.service("badge").evaluate(player2, season2, { event: "pull", card: result.card.documentId });
+    return {
+      playerCardId: playerCard2.documentId,
+      card: { ...format2.card(result.card, season2), mintNumber },
+      pull: {
+        rarity: result.rarity,
+        isNew: alreadyOwned === 0,
+        pity: result.pity,
+        odds: result.odds,
+        boosts: boosts.map((b) => ({ name: b.name, multipliers: b.multipliers })),
+        isExclusive: Boolean(result.card.isExclusive),
+        pack: { id: pack2.documentId, name: pack2.name, slug: pack2.slug },
+        drop: { id: drop2.documentId, name: drop2.name, slug: drop2.slug },
+        verificationHash: result.verificationHash,
+        pulledAt: now
+      },
+      unlocked
+    };
+  },
+  async history(player2, season2, page) {
+    const where = { player: player2.id, season: season2.id };
+    const [items, total] = await Promise.all([
+      strapi.db.query(UID.PULL).findMany({ where, populate: { card: { populate: { image: true } }, pack: true, drop: true }, orderBy: { pulledAt: "desc" }, offset: page.offset, limit: page.limit }),
+      strapi.db.query(UID.PULL).count({ where })
+    ]);
+    const format2 = strapi.plugin("tcg").service("format");
+    return {
+      items: items.map((p) => ({
+        id: p.documentId,
+        rarity: p.rarity,
+        pulledAt: p.pulledAt,
+        pity: Boolean(p.pity),
+        mintNumber: p.mintNumber ?? null,
+        verificationHash: p.verificationHash,
+        card: format2.card(p.card, season2),
+        pack: p.pack ? { id: p.pack.documentId, name: p.pack.name, slug: p.pack.slug } : null,
+        drop: p.drop ? { id: p.drop.documentId, name: p.drop.name, slug: p.drop.slug } : null
+      })),
+      total
+    };
+  },
+  /** Per-pack and per-drop cooldown state for the player. */
+  async cooldowns(player2, season2) {
+    const plugin = strapi.plugin("tcg");
+    const limits = plugin.service("season").limitsOf(season2);
+    const packs = await plugin.service("pack").list(season2);
+    const since = startOfToday$1();
+    const todays = await strapi.db.query(UID.PULL).findMany({ where: { player: player2.id, season: season2.id, pulledAt: { $gte: since } }, populate: { pack: { select: ["id"] } }, select: ["pulledAt"] });
+    const countByPack = {};
+    for (const p of todays) countByPack[p.pack?.id] = (countByPack[p.pack?.id] ?? 0) + 1;
+    const totalToday = todays.length;
+    const now = Date.now();
+    const result = [];
+    for (const pack2 of packs) {
+      const drops = await plugin.service("drop").list(pack2, { includeInactive: false });
+      const dropStates = [];
+      for (const drop2 of drops) {
+        const last = await strapi.db.query(UID.PULL).findOne({ where: { player: player2.id, drop: drop2.id }, orderBy: { pulledAt: "desc" }, select: ["pulledAt"] });
+        const cooldownMs = drop2.cooldownMs ?? (drop2.mode === DROP_MODE.STATIC ? Math.max(limits.pullCooldownMs, limits.staticScanCooldownMs) : limits.pullCooldownMs);
+        const remaining = last ? Math.max(0, cooldownMs - (now - new Date(last.pulledAt).getTime())) : 0;
+        dropStates.push({ drop: { id: drop2.documentId, name: drop2.name, slug: drop2.slug }, isOpen: plugin.service("drop").isOpen(drop2), cooldownRemainingMs: remaining, cooldownRemainingSeconds: Math.ceil(remaining / 1e3) });
+      }
+      const pullsToday = countByPack[pack2.id] ?? 0;
+      const anyReady = dropStates.some((d) => d.isOpen && d.cooldownRemainingMs === 0);
+      result.push({
+        pack: { id: pack2.documentId, name: pack2.name, slug: pack2.slug },
+        pullsToday,
+        maxPullsPerDay: limits.maxDailyPullsPerPack,
+        canPull: anyReady && pullsToday < limits.maxDailyPullsPerPack && totalToday < limits.maxDailyPullsTotal,
+        drops: dropStates
+      });
+    }
+    return { totalPullsToday: totalToday, maxDailyPulls: limits.maxDailyPullsTotal, packs: result };
+  }
+});
+const collection = ({ strapi }) => ({
+  async list(player2, season2, { rarity } = {}, page) {
+    const where = { player: player2.id, card: { season: season2.id } };
+    if (rarity) where.card.rarity = rarity;
+    const [items, total] = await Promise.all([
+      strapi.db.query(UID.PLAYER_CARD).findMany({
+        where,
+        populate: { card: { populate: { image: true } }, pack: true },
+        orderBy: { acquiredAt: "desc" },
+        offset: page.offset,
+        limit: page.limit
+      }),
+      strapi.db.query(UID.PLAYER_CARD).count({ where })
+    ]);
+    const format2 = strapi.plugin("tcg").service("format");
+    return { items: items.map((pc) => format2.playerCard(pc, season2)), total };
+  },
+  /** Distinct card ids owned by a player in a season. */
+  async ownedCardIds(player2, season2) {
+    const rows = await strapi.db.query(UID.PLAYER_CARD).findMany({
+      where: { player: player2.id, card: { season: season2.id } },
+      populate: { card: { select: ["id"] } }
+    });
+    return [...new Set(rows.map((r) => r.card?.id).filter(Boolean))];
+  },
+  /**
+   * Global rank = 1 + number of players owning more distinct season cards. Uses the link tables
+   * Strapi 5 creates for relations, resolved from metadata so table names never get hardcoded.
+   */
+  async rank(player2, season2, myUnique) {
+    if (myUnique === 0) return null;
+    const knex = strapi.db.connection;
+    const md = strapi.db.metadata.get(UID.PLAYER_CARD);
+    const pcTable = md.tableName;
+    const playerLnk = md.attributes.player.joinTable;
+    const cardLnk = md.attributes.card.joinTable;
+    const cardMd = strapi.db.metadata.get(UID.CARD);
+    const seasonLnk = cardMd.attributes.season.joinTable;
+    const seasonId = season2.id;
+    const sub = knex(`${pcTable} as pc`).join(`${playerLnk.name} as pl`, "pl." + playerLnk.joinColumn.name, "pc.id").join(`${cardLnk.name} as cl`, "cl." + cardLnk.joinColumn.name, "pc.id").join(`${seasonLnk.name} as sl`, "sl." + seasonLnk.joinColumn.name, "cl." + cardLnk.inverseJoinColumn.name).where("sl." + seasonLnk.inverseJoinColumn.name, seasonId).groupBy("pl." + playerLnk.inverseJoinColumn.name).select("pl." + playerLnk.inverseJoinColumn.name + " as player_id").countDistinct("cl." + cardLnk.inverseJoinColumn.name + " as unique_cards");
+    const row = await knex.from(sub.as("ranked")).where("ranked.unique_cards", ">", myUnique).count("* as better").first();
+    return Number(row?.better ?? 0) + 1;
+  },
+  async stats(player2, season2) {
+    const plugin = strapi.plugin("tcg");
+    const format2 = plugin.service("format");
+    const [owned, catalog, packs, latest] = await Promise.all([
+      strapi.db.query(UID.PLAYER_CARD).findMany({
+        where: { player: player2.id, card: { season: season2.id } },
+        populate: { card: { select: ["id", "rarity"] } }
+      }),
+      strapi.db.query(UID.CARD).findMany({ where: { season: season2.id, isActive: true }, select: ["id", "rarity"] }),
+      plugin.service("pack").list(season2),
+      strapi.db.query(UID.PLAYER_CARD).findOne({
+        where: { player: player2.id, card: { season: season2.id } },
+        populate: { card: { populate: { image: true } }, pack: true },
+        orderBy: { acquiredAt: "desc" }
+      })
+    ]);
+    const ownedIds = new Set(owned.map((o) => o.card?.id).filter(Boolean));
+    const catalogTotal = catalog.length;
+    const completion = catalogTotal ? Math.round(ownedIds.size / catalogTotal * 100) : 0;
+    const byRarity = {};
+    for (const r of season2.rarities ?? []) {
+      byRarity[r.key] = {
+        label: r.label,
+        color: r.color,
+        owned: owned.filter((o) => o.card?.rarity === r.key).length,
+        unique: catalog.filter((c) => c.rarity === r.key && ownedIds.has(c.id)).length,
+        total: catalog.filter((c) => c.rarity === r.key).length
+      };
+    }
+    const packRows = await strapi.db.query(UID.PACK_CARD).findMany({
+      where: { pack: { id: { $in: packs.map((p) => p.id) } }, isActive: true },
+      populate: { pack: { select: ["id"] }, card: { select: ["id"] } }
+    });
+    const byPack = packs.map((p) => {
+      const cardIds = [...new Set(packRows.filter((r) => r.pack?.id === p.id).map((r) => r.card?.id).filter(Boolean))];
+      const collected = cardIds.filter((id) => ownedIds.has(id)).length;
+      return { pack: format2.pack(p), collected, total: cardIds.length, isComplete: cardIds.length > 0 && collected === cardIds.length };
+    });
+    const tier = plugin.service("season").tierFor(season2, completion);
+    const [sets, badges, metrics, live] = await Promise.all([
+      plugin.service("set").list(season2, { includeInactive: false }),
+      plugin.service("badge").forPlayer(player2, season2),
+      plugin.service("badge").metrics(player2, season2),
+      plugin.service("boost").liveNow(season2)
+    ]);
+    return {
+      sets: plugin.service("set").progress(sets, ownedIds, season2),
+      badges,
+      streakDays: metrics.streakDays,
+      liveBoosts: live,
+      totalCards: owned.length,
+      uniqueCards: ownedIds.size,
+      catalogTotal,
+      completionPercentage: completion,
+      globalRank: await this.rank(player2, season2, ownedIds.size),
+      rankTier: { key: tier.key, label: tier.label },
+      season: format2.season(season2),
+      byRarity,
+      byPack,
+      latestAcquisition: latest ? format2.playerCard(latest, season2) : null
+    };
+  },
+  /** Admin: give a card to a player (events, support). Mints a copy; ignores the supply cap on purpose. */
+  async grant(player2, card2, pack2 = null) {
+    const now = /* @__PURE__ */ new Date();
+    const mintNumber = await strapi.plugin("tcg").service("pull").claimSlot(UID.CARD, card2.id, "minted", null);
+    const pc = await strapi.db.transaction(async () => {
+      const row = await strapi.db.query(UID.PLAYER_CARD).create({
+        data: { player: player2.id, card: card2.id, pack: pack2?.id ?? null, acquiredFrom: "grant", acquiredAt: now, mintNumber }
+      });
+      await strapi.db.query(UID.PLAYER).update({ where: { id: player2.id }, data: { totalCards: (player2.totalCards ?? 0) + 1 } });
+      return row;
+    });
+    return pc;
+  }
+});
+const trade = ({ strapi }) => ({
+  /** Player-card rows owned by `player` among `documentIds`; throws if any is missing. */
+  async ownedRows(player2, documentIds, season2) {
+    const ids = [...new Set((documentIds ?? []).map(String))];
+    if (ids.length === 0) throw badRequest(ERROR_CODES.VALIDATION, "Sélectionnez au moins une carte.");
+    const rows = await strapi.db.query(UID.PLAYER_CARD).findMany({
+      where: { player: player2.id, documentId: { $in: ids }, ...season2 ? { card: { season: season2.id } } : {} },
+      populate: { card: { populate: { image: true } } }
+    });
+    if (rows.length !== ids.length) throw badRequest(ERROR_CODES.CARD_NOT_OWNED, "Vous ne possédez pas toutes ces cartes.");
+    return rows;
+  },
+  async createOffer(player2, season2, { cardIds }) {
+    const plugin = strapi.plugin("tcg");
+    const limits = plugin.service("season").limitsOf(season2);
+    if ((cardIds ?? []).length > limits.maxCardsPerTrade) {
+      throw unprocessable(ERROR_CODES.TRADE_TOO_MANY_CARDS, `Maximum ${limits.maxCardsPerTrade} cartes par échange.`);
+    }
+    const active = await strapi.db.query(UID.TRADE_OFFER).count({ where: { initiator: player2.id, status: TRADE_STATUS.PENDING } });
+    if (active >= limits.maxActiveTradeOffers) {
+      throw unprocessable(ERROR_CODES.TRADE_LIMIT, `Maximum ${limits.maxActiveTradeOffers} offres actives.`);
+    }
+    const rows = await this.ownedRows(player2, cardIds, season2);
+    const expiresAt = new Date(Date.now() + limits.tradeOfferExpiryMs);
+    const offer = await strapi.db.query(UID.TRADE_OFFER).create({
+      data: { initiator: player2.id, season: season2.id, status: TRADE_STATUS.PENDING, offeredCardIds: rows.map((r) => r.documentId), expiresAt }
+    });
+    const { token } = plugin.service("qr").forTrade(offer, player2, limits.tradeOfferExpiryMs);
+    await strapi.db.query(UID.TRADE_OFFER).update({ where: { id: offer.id }, data: { qrToken: token } });
+    const format2 = plugin.service("format");
+    return {
+      id: offer.documentId,
+      status: TRADE_STATUS.PENDING,
+      qrToken: token,
+      expiresAt,
+      offeredCards: rows.map((r) => format2.playerCard(r, season2))
+    };
+  },
+  async findOffer(documentId) {
+    const offer = await strapi.db.query(UID.TRADE_OFFER).findOne({
+      where: { documentId },
+      populate: { initiator: true, season: true }
+    });
+    if (!offer) throw notFound(ERROR_CODES.TRADE_NOT_FOUND, "Offre introuvable.");
+    return offer;
+  },
+  assertOpen(offer) {
+    if (offer.status !== TRADE_STATUS.PENDING) throw unprocessable(ERROR_CODES.TRADE_INVALID_STATUS, `Cette offre est ${offer.status}.`);
+    if (/* @__PURE__ */ new Date() > new Date(offer.expiresAt)) throw unprocessable(ERROR_CODES.TRADE_EXPIRED, "Cette offre a expiré.");
+  },
+  async describe(offer, season2) {
+    const format2 = strapi.plugin("tcg").service("format");
+    const rows = await strapi.db.query(UID.PLAYER_CARD).findMany({
+      where: { documentId: { $in: offer.offeredCardIds ?? [] } },
+      populate: { card: { populate: { image: true } } }
+    });
+    return {
+      id: offer.documentId,
+      status: offer.status,
+      expiresAt: offer.expiresAt,
+      initiator: offer.initiator ? { code: offer.initiator.code, displayName: offer.initiator.displayName } : null,
+      offeredCards: rows.map((r) => format2.playerCard(r, season2))
+    };
+  },
+  /** The receiver scans the initiator's QR. The token is NOT burned here; acceptance burns it. */
+  async scan(player2, qrToken) {
+    const peek = peekToken(qrToken);
+    if (!peek || peek.kind !== "trade") throw badRequest(ERROR_CODES.QR_INVALID, "QR code invalide.");
+    if (peek.playerId === player2.documentId) throw badRequest(ERROR_CODES.TRADE_SELF, "Vous ne pouvez pas scanner votre propre offre.");
+    const offer = await this.findOffer(peek.offerId);
+    if (offer.qrToken !== qrToken) throw badRequest(ERROR_CODES.QR_INVALID, "QR code invalide.");
+    this.assertOpen(offer);
+    return this.describe(offer, offer.season);
+  },
+  /**
+   * Atomic swap. `cardIds` are the receiver's player-card documentIds.
+   */
+  async accept(receiver, offerDocumentId, { cardIds }) {
+    const plugin = strapi.plugin("tcg");
+    const offer = await this.findOffer(offerDocumentId);
+    this.assertOpen(offer);
+    if (offer.initiator?.id === receiver.id) throw badRequest(ERROR_CODES.TRADE_SELF, "Vous ne pouvez pas accepter votre propre offre.");
+    const season2 = offer.season;
+    const limits = plugin.service("season").limitsOf(season2);
+    if ((cardIds ?? []).length > limits.maxCardsPerTrade) {
+      throw unprocessable(ERROR_CODES.TRADE_TOO_MANY_CARDS, `Maximum ${limits.maxCardsPerTrade} cartes par échange.`);
+    }
+    const receiverRows = await this.ownedRows(receiver, cardIds, season2);
+    const initiatorRows = await strapi.db.query(UID.PLAYER_CARD).findMany({
+      where: { player: offer.initiator.id, documentId: { $in: offer.offeredCardIds ?? [] } }
+    });
+    if (initiatorRows.length !== (offer.offeredCardIds ?? []).length) {
+      throw unprocessable(ERROR_CODES.CARD_NOT_OWNED, "L'autre joueur ne possède plus ces cartes.");
+    }
+    const now = /* @__PURE__ */ new Date();
+    const trade2 = await strapi.db.transaction(async () => {
+      const fresh = await strapi.db.query(UID.TRADE_OFFER).findOne({ where: { id: offer.id }, select: ["status"] });
+      if (fresh.status !== TRADE_STATUS.PENDING) throw unprocessable(ERROR_CODES.TRADE_INVALID_STATUS, "Offre déjà traitée.");
+      await strapi.db.query(UID.TRADE_OFFER).update({ where: { id: offer.id }, data: { status: TRADE_STATUS.ACCEPTED } });
+      const t = await strapi.db.query(UID.TRADE).create({
+        data: {
+          offer: offer.id,
+          initiator: offer.initiator.id,
+          receiver: receiver.id,
+          season: season2.id,
+          initiatorCardIds: initiatorRows.map((r) => r.documentId),
+          receiverCardIds: receiverRows.map((r) => r.documentId),
+          completedAt: now
+        }
+      });
+      for (const row of initiatorRows) {
+        await strapi.db.query(UID.PLAYER_CARD).update({ where: { id: row.id }, data: { player: receiver.id, acquiredFrom: ACQUISITION.TRADE, acquiredAt: now, sourceTrade: t.id } });
+      }
+      for (const row of receiverRows) {
+        await strapi.db.query(UID.PLAYER_CARD).update({ where: { id: row.id }, data: { player: offer.initiator.id, acquiredFrom: ACQUISITION.TRADE, acquiredAt: now, sourceTrade: t.id } });
+      }
+      const delta = receiverRows.length - initiatorRows.length;
+      await strapi.db.query(UID.PLAYER).update({
+        where: { id: offer.initiator.id },
+        data: { totalTrades: (offer.initiator.totalTrades ?? 0) + 1, totalCards: Math.max(0, (offer.initiator.totalCards ?? 0) + delta), lastActiveAt: now }
+      });
+      await strapi.db.query(UID.PLAYER).update({
+        where: { id: receiver.id },
+        data: { totalTrades: (receiver.totalTrades ?? 0) + 1, totalCards: Math.max(0, (receiver.totalCards ?? 0) - delta), lastActiveAt: now }
+      });
+      return t;
+    });
+    strapi.log.info(`[tcg] trade ${offer.initiator.code} ⇄ ${receiver.code} (${initiatorRows.length}:${receiverRows.length})`);
+    const badge2 = plugin.service("badge");
+    const [unlocked] = await Promise.all([badge2.evaluate(receiver, season2, { event: "trade" }), badge2.evaluate(offer.initiator, season2, { event: "trade" })]);
+    return { id: trade2.documentId, offerId: offer.documentId, completedAt: now, received: initiatorRows.length, given: receiverRows.length, unlocked };
+  },
+  async reject(player2, offerDocumentId) {
+    const offer = await this.findOffer(offerDocumentId);
+    this.assertOpen(offer);
+    if (offer.initiator?.id === player2.id) throw badRequest(ERROR_CODES.TRADE_SELF, "Utilisez « annuler » pour votre propre offre.");
+    await strapi.db.query(UID.TRADE_OFFER).update({ where: { id: offer.id }, data: { status: TRADE_STATUS.REJECTED } });
+    return { ok: true };
+  },
+  async cancel(player2, offerDocumentId) {
+    const offer = await this.findOffer(offerDocumentId);
+    if (offer.initiator?.id !== player2.id) throw forbidden(ERROR_CODES.TRADE_FORBIDDEN, "Vous ne pouvez annuler que vos offres.");
+    if (offer.status !== TRADE_STATUS.PENDING) throw unprocessable(ERROR_CODES.TRADE_INVALID_STATUS, `Cette offre est déjà ${offer.status}.`);
+    await strapi.db.query(UID.TRADE_OFFER).update({ where: { id: offer.id }, data: { status: TRADE_STATUS.CANCELLED } });
+    return { ok: true };
+  },
+  async activeOffers(player2, season2) {
+    const offers = await strapi.db.query(UID.TRADE_OFFER).findMany({
+      where: { initiator: player2.id, season: season2.id, status: TRADE_STATUS.PENDING, expiresAt: { $gt: /* @__PURE__ */ new Date() } },
+      populate: { initiator: true },
+      orderBy: { createdAt: "desc" }
+    });
+    return Promise.all(offers.map((o) => this.describe(o, season2).then((d) => ({ ...d, qrToken: o.qrToken }))));
+  },
+  async history(player2, season2, page) {
+    const where = { season: season2.id, $or: [{ initiator: player2.id }, { receiver: player2.id }] };
+    const [items, total] = await Promise.all([
+      strapi.db.query(UID.TRADE).findMany({ where, populate: { initiator: true, receiver: true }, orderBy: { completedAt: "desc" }, offset: page.offset, limit: page.limit }),
+      strapi.db.query(UID.TRADE).count({ where })
+    ]);
+    return {
+      items: items.map((t) => ({
+        id: t.documentId,
+        completedAt: t.completedAt,
+        role: t.initiator?.id === player2.id ? "initiator" : "receiver",
+        counterpart: (t.initiator?.id === player2.id ? t.receiver : t.initiator) ? { code: (t.initiator?.id === player2.id ? t.receiver : t.initiator).code, displayName: (t.initiator?.id === player2.id ? t.receiver : t.initiator).displayName } : null,
+        given: (t.initiator?.id === player2.id ? t.initiatorCardIds : t.receiverCardIds) ?? [],
+        received: (t.initiator?.id === player2.id ? t.receiverCardIds : t.initiatorCardIds) ?? []
+      })),
+      total
+    };
+  },
+  /** Marks pending offers past their expiry. */
+  async sweep() {
+    const { count } = await strapi.db.query(UID.TRADE_OFFER).updateMany({
+      where: { status: TRADE_STATUS.PENDING, expiresAt: { $lt: /* @__PURE__ */ new Date() } },
+      data: { status: TRADE_STATUS.EXPIRED }
+    });
+    return count ?? 0;
+  }
+});
+const POPULATE$5 = { player: true, season: true, reward: { populate: { image: true } } };
+const redemption = ({ strapi }) => ({
+  async generateCode() {
+    for (let i = 0; i < MAX_CODE_ATTEMPTS; i += 1) {
+      const code = randomCode(REDEMPTION_CODE_LENGTH);
+      const exists = await strapi.db.query(UID.REDEMPTION).findOne({ where: { code }, select: ["id"] });
+      if (!exists) return code;
+    }
+    throw conflict(ERROR_CODES.VALIDATION, "Impossible de générer un code.");
+  },
+  async create(player2, season2, { rewardId, cardIds }) {
+    const plugin = strapi.plugin("tcg");
+    if (!rewardId) throw unprocessable(ERROR_CODES.VALIDATION, "Choisissez une récompense.");
+    const reward2 = await plugin.service("reward").findOne(season2, rewardId);
+    const rows = (cardIds ?? []).length ? await plugin.service("trade").ownedRows(player2, cardIds, season2) : [];
+    await plugin.service("reward").check(player2, season2, reward2, rows);
+    const format2 = plugin.service("format");
+    const snapshot = rows.map((r) => ({ playerCardId: r.documentId, mintNumber: r.mintNumber ?? null, ...format2.card(r.card, season2) }));
+    const now = /* @__PURE__ */ new Date();
+    const record = await strapi.db.transaction(async ({ trx }) => {
+      if (reward2.stock != null) {
+        const slot = await plugin.service("pull").claimSlot(UID.REWARD, reward2.id, "claimed", "stock", trx);
+        if (slot == null) throw unprocessable(ERROR_CODES.REWARD_SOLD_OUT, "Stock épuisé.");
+      } else {
+        await plugin.service("pull").claimSlot(UID.REWARD, reward2.id, "claimed", null, trx);
+      }
+      const rec = await strapi.db.query(UID.REDEMPTION).create({
+        data: {
+          player: player2.id,
+          season: season2.id,
+          reward: reward2.id,
+          rewardName: reward2.name,
+          code: await this.generateCode(),
+          cards: snapshot,
+          rewardType: reward2.tier ?? null,
+          rewardDescription: reward2.name,
+          status: REDEMPTION_STATUS.PENDING,
+          redeemedAt: now
+        }
+      });
+      if (rows.length) await strapi.db.query(UID.PLAYER_CARD).deleteMany({ where: { id: { $in: rows.map((r) => r.id) } } });
+      await strapi.db.query(UID.PLAYER).update({
+        where: { id: player2.id },
+        data: { totalCards: Math.max(0, (player2.totalCards ?? 0) - rows.length), totalRedemptions: (player2.totalRedemptions ?? 0) + 1, lastActiveAt: now }
+      });
+      return rec;
+    });
+    strapi.log.info(`[tcg] redemption ${record.code} by ${player2.code}: ${reward2.name} (${rows.length} cards)`);
+    const unlocked = await plugin.service("badge").evaluate(player2, season2, { event: "redemption", reward: reward2.documentId });
+    const full = await this.findOne(record.code);
+    return { ...format2.redemption(full), unlocked };
+  },
+  async findOne(ref, { forPlayer } = {}) {
+    const where = { $or: [{ documentId: ref }, { code: String(ref).toUpperCase().trim() }] };
+    if (forPlayer) where.player = forPlayer.id;
+    const rec = await strapi.db.query(UID.REDEMPTION).findOne({ where, populate: POPULATE$5 });
+    if (!rec) throw notFound(ERROR_CODES.REDEMPTION_NOT_FOUND, "Demande introuvable.");
+    return rec;
+  },
+  async history(player2, season2, page) {
+    const where = { player: player2.id, season: season2.id };
+    const [items, total] = await Promise.all([
+      strapi.db.query(UID.REDEMPTION).findMany({ where, populate: { reward: { populate: { image: true } } }, orderBy: { redeemedAt: "desc" }, offset: page.offset, limit: page.limit }),
+      strapi.db.query(UID.REDEMPTION).count({ where })
+    ]);
+    const format2 = strapi.plugin("tcg").service("format");
+    return { items: items.map((r) => format2.redemption(r)), total };
+  },
+  async fulfill(ref, { operator, note }) {
+    const rec = await this.findOne(ref);
+    if (rec.status === REDEMPTION_STATUS.FULFILLED) throw unprocessable(ERROR_CODES.REDEMPTION_INVALID_STATUS, "Déjà remise.");
+    if (rec.status === REDEMPTION_STATUS.CANCELLED) throw unprocessable(ERROR_CODES.REDEMPTION_INVALID_STATUS, "Demande annulée.");
+    const updated = await strapi.db.query(UID.REDEMPTION).update({
+      where: { id: rec.id },
+      data: { status: REDEMPTION_STATUS.FULFILLED, fulfilledAt: /* @__PURE__ */ new Date(), fulfilledBy: operator ?? null, note: note ?? rec.note },
+      populate: POPULATE$5
+    });
+    return strapi.plugin("tcg").service("format").redemption(updated);
+  },
+  /** Booth cancel: cards go back (same mint numbers), stock is released. */
+  async cancel(ref, { operator, note }) {
+    const rec = await this.findOne(ref);
+    if (rec.status !== REDEMPTION_STATUS.PENDING) throw unprocessable(ERROR_CODES.REDEMPTION_INVALID_STATUS, `Demande déjà ${rec.status}.`);
+    const now = /* @__PURE__ */ new Date();
+    const updated = await strapi.db.transaction(async ({ trx }) => {
+      for (const snap of rec.cards ?? []) {
+        const card2 = await strapi.db.query(UID.CARD).findOne({ where: { documentId: snap.id }, select: ["id"] });
+        if (card2) await strapi.db.query(UID.PLAYER_CARD).create({ data: { player: rec.player.id, card: card2.id, acquiredFrom: "grant", acquiredAt: now, mintNumber: snap.mintNumber ?? null } });
+      }
+      if (rec.reward) {
+        const md = strapi.db.metadata.get(UID.REWARD);
+        await trx(md.tableName).where({ id: rec.reward.id }).andWhere("claimed", ">", 0).decrement("claimed", 1);
+      }
+      await strapi.db.query(UID.PLAYER).update({
+        where: { id: rec.player.id },
+        data: { totalCards: (rec.player.totalCards ?? 0) + (rec.cards?.length ?? 0), totalRedemptions: Math.max(0, (rec.player.totalRedemptions ?? 0) - 1) }
+      });
+      return strapi.db.query(UID.REDEMPTION).update({ where: { id: rec.id }, data: { status: REDEMPTION_STATUS.CANCELLED, fulfilledBy: operator ?? null, note: note ?? rec.note }, populate: POPULATE$5 });
+    });
+    return strapi.plugin("tcg").service("format").redemption(updated);
+  },
+  async search({ season: season2, status, q, reward: reward2 }, page) {
+    const where = {};
+    if (season2) where.season = season2.id;
+    if (status) where.status = status;
+    if (reward2) where.reward = { documentId: reward2 };
+    if (q) where.$or = [{ code: { $containsi: q } }, { player: { code: { $containsi: q } } }, { player: { displayName: { $containsi: q } } }, { rewardName: { $containsi: q } }];
+    const [items, total] = await Promise.all([
+      strapi.db.query(UID.REDEMPTION).findMany({ where, populate: POPULATE$5, orderBy: { redeemedAt: "desc" }, offset: page.offset, limit: page.limit }),
+      strapi.db.query(UID.REDEMPTION).count({ where })
+    ]);
+    const format2 = strapi.plugin("tcg").service("format");
+    return { items: items.map((r) => format2.redemption(r)), total };
+  }
+});
+const startOfToday = () => {
+  const d = /* @__PURE__ */ new Date();
+  d.setHours(0, 0, 0, 0);
+  return d;
+};
+const daysAgo = (n) => {
+  const d = startOfToday();
+  d.setDate(d.getDate() - n);
+  return d;
+};
+const stats = ({ strapi }) => ({
+  async dashboard(season2) {
+    const since = startOfToday();
+    const week = daysAgo(6);
+    const seasonWhere = season2 ? { season: season2.id } : {};
+    const [
+      players,
+      playersToday,
+      pullsToday,
+      pullsTotal,
+      tradesToday,
+      pendingOffers,
+      pendingRedemptions,
+      fulfilledToday,
+      cards,
+      packs,
+      weekPulls,
+      recentPulls
+    ] = await Promise.all([
+      strapi.db.query(UID.PLAYER).count({}),
+      strapi.db.query(UID.PLAYER).count({ where: { createdAt: { $gte: since } } }),
+      strapi.db.query(UID.PULL).count({ where: { ...seasonWhere, pulledAt: { $gte: since } } }),
+      strapi.db.query(UID.PULL).count({ where: seasonWhere }),
+      strapi.db.query(UID.TRADE).count({ where: { ...seasonWhere, completedAt: { $gte: since } } }),
+      strapi.db.query(UID.TRADE_OFFER).count({ where: { ...seasonWhere, status: TRADE_STATUS.PENDING, expiresAt: { $gt: /* @__PURE__ */ new Date() } } }),
+      strapi.db.query(UID.REDEMPTION).count({ where: { ...seasonWhere, status: REDEMPTION_STATUS.PENDING } }),
+      strapi.db.query(UID.REDEMPTION).count({ where: { ...seasonWhere, status: REDEMPTION_STATUS.FULFILLED, fulfilledAt: { $gte: since } } }),
+      season2 ? strapi.db.query(UID.CARD).count({ where: { season: season2.id, isActive: true } }) : Promise.resolve(0),
+      season2 ? strapi.db.query(UID.PACK).count({ where: { season: season2.id, isActive: true } }) : Promise.resolve(0),
+      strapi.db.query(UID.PULL).findMany({ where: { ...seasonWhere, pulledAt: { $gte: week } }, select: ["pulledAt", "rarity"] }),
+      strapi.db.query(UID.PULL).findMany({
+        where: seasonWhere,
+        populate: { player: { select: ["code", "displayName"] }, card: { select: ["name", "rarity"] }, pack: { select: ["name"] }, drop: { select: ["name"] } },
+        orderBy: { pulledAt: "desc" },
+        limit: 8
+      })
+    ]);
+    const sparkline = Array.from({ length: 7 }, (_, i) => {
+      const day = daysAgo(6 - i);
+      const next = new Date(day);
+      next.setDate(day.getDate() + 1);
+      return { day: day.toISOString().slice(0, 10), pulls: weekPulls.filter((p) => new Date(p.pulledAt) >= day && new Date(p.pulledAt) < next).length };
+    });
+    const rarities = season2?.rarities ?? [];
+    const plugin = strapi.plugin("tcg");
+    const [liveBoosts, rewards, drops] = season2 ? await Promise.all([
+      plugin.service("boost").liveNow(season2),
+      plugin.service("reward").list(season2, { includeInactive: false }),
+      strapi.db.query(UID.DROP).findMany({ where: { pack: { season: season2.id }, isActive: true }, populate: { pack: { select: ["name"] } } })
+    ]) : [[], [], []];
+    const lowStock = rewards.filter((r) => r.stock != null).map((r) => ({ id: r.documentId, name: r.name, remaining: Math.max(0, r.stock - (r.claimed ?? 0)), stock: r.stock })).filter((r) => r.remaining <= Math.max(3, Math.ceil(r.stock * 0.1))).sort((a, b) => a.remaining - b.remaining);
+    const dropStates = drops.map((d) => ({ id: d.documentId, name: `${d.pack?.name ?? ""} · ${d.name}`, mode: d.mode, scans: d.scanCount ?? 0, cap: d.maxScansTotal ?? null, isOpen: plugin.service("drop").isOpen(d) }));
+    return {
+      liveBoosts,
+      lowStock,
+      drops: dropStates,
+      season: season2 ? { id: season2.documentId, name: season2.name, slug: season2.slug, status: season2.status } : null,
+      players: { total: players, today: playersToday },
+      pulls: { today: pullsToday, total: pullsTotal, sparkline, distribution: distribution(weekPulls, rarities) },
+      trades: { today: tradesToday, pendingOffers },
+      redemptions: { pending: pendingRedemptions, fulfilledToday },
+      catalog: { cards, packs },
+      recentPulls: recentPulls.map((p) => ({
+        id: p.documentId,
+        pulledAt: p.pulledAt,
+        rarity: p.rarity,
+        player: p.player ? { code: p.player.code, displayName: p.player.displayName } : null,
+        card: p.card ? { name: p.card.name } : null,
+        pack: p.pack ? { name: p.pack.name } : null,
+        drop: p.drop ? { name: p.drop.name } : null,
+        mintNumber: p.mintNumber ?? null,
+        pity: Boolean(p.pity)
+      }))
+    };
+  },
+  /** Top collectors by distinct cards owned in a season (admin leaderboard). */
+  async leaderboard(season2, limit = 10) {
+    const rows = await strapi.db.query(UID.PLAYER_CARD).findMany({
+      where: { card: { season: season2.id } },
+      populate: { player: { select: ["id", "documentId", "code", "displayName"] }, card: { select: ["id"] } }
+    });
+    const byPlayer = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      if (!r.player || !r.card) continue;
+      const entry = byPlayer.get(r.player.id) ?? { player: r.player, unique: /* @__PURE__ */ new Set(), total: 0 };
+      entry.unique.add(r.card.id);
+      entry.total += 1;
+      byPlayer.set(r.player.id, entry);
+    }
+    return [...byPlayer.values()].map((e) => ({ player: { id: e.player.documentId, code: e.player.code, displayName: e.player.displayName }, uniqueCards: e.unique.size, totalCards: e.total })).sort((a, b) => b.uniqueCards - a.uniqueCards || b.totalCards - a.totalCards).slice(0, limit).map((e, i) => ({ rank: i + 1, ...e }));
+  },
+  /** Recent pulls for the audit screen. */
+  async pulls(season2, { playerCode, rarity }, page) {
+    const where = { season: season2.id };
+    if (rarity) where.rarity = rarity;
+    if (playerCode) where.player = { code: { $containsi: playerCode } };
+    const [items, total] = await Promise.all([
+      strapi.db.query(UID.PULL).findMany({
+        where,
+        populate: { player: { select: ["code", "displayName"] }, card: { select: ["name", "rarity", "number"] }, pack: { select: ["name", "slug"] }, drop: { select: ["name", "slug"] } },
+        orderBy: { pulledAt: "desc" },
+        offset: page.offset,
+        limit: page.limit
+      }),
+      strapi.db.query(UID.PULL).count({ where })
+    ]);
+    return {
+      items: items.map((p) => ({
+        id: p.documentId,
+        pulledAt: p.pulledAt,
+        rarity: p.rarity,
+        seed: p.seed,
+        roll: p.roll,
+        verificationHash: p.verificationHash,
+        odds: p.odds ?? null,
+        pity: Boolean(p.pity),
+        mintNumber: p.mintNumber ?? null,
+        drop: p.drop ? { name: p.drop.name, slug: p.drop.slug } : null,
+        player: p.player ? { code: p.player.code, displayName: p.player.displayName } : null,
+        card: p.card ? { name: p.card.name, number: p.card.number, rarity: p.card.rarity } : null,
+        pack: p.pack ? { name: p.pack.name, slug: p.pack.slug } : null
+      })),
+      total
+    };
+  }
+});
+const POPULATE$4 = { pack: { populate: { season: { populate: { cover: true } }, image: true } } };
+const drop = ({ strapi }) => ({
+  isOpen(drop2, now = /* @__PURE__ */ new Date()) {
+    if (!drop2.isActive) return false;
+    if (drop2.startsAt && new Date(drop2.startsAt) > now) return false;
+    if (drop2.endsAt && new Date(drop2.endsAt) < now) return false;
+    return true;
+  },
+  async list(pack2, { includeInactive = true } = {}) {
+    const where = { pack: pack2.id };
+    if (!includeInactive) where.isActive = true;
+    return strapi.db.query(UID.DROP).findMany({ where, orderBy: [{ isDefault: "desc" }, { sortOrder: "asc" }, { name: "asc" }] });
+  },
+  async findOne(pack2, ref) {
+    const drop2 = await strapi.db.query(UID.DROP).findOne({ where: { pack: pack2.id, $or: [{ slug: ref }, { documentId: ref }] } });
+    if (!drop2) throw notFound(ERROR_CODES.DROP_NOT_FOUND, "Point de scan introuvable.");
+    return drop2;
+  },
+  /** Scan path: by documentId, with pack → season populated. */
+  async byDocumentId(documentId) {
+    const drop2 = await strapi.db.query(UID.DROP).findOne({ where: { documentId }, populate: POPULATE$4 });
+    if (!drop2) throw notFound(ERROR_CODES.DROP_NOT_FOUND, "Point de scan introuvable.");
+    return drop2;
+  },
+  validate(data) {
+    if (data.mode && !Object.values(DROP_MODE).includes(data.mode)) throw badRequest(ERROR_CODES.VALIDATION, "Mode invalide.");
+    if (data.poolMode && !Object.values(POOL_MODE).includes(data.poolMode)) throw badRequest(ERROR_CODES.VALIDATION, "Mode de pool invalide.");
+    for (const k of ["maxScansTotal", "maxScansPerPlayer", "cooldownMs"]) {
+      if (data[k] != null && data[k] !== "" && !(Number(data[k]) >= 0)) throw badRequest(ERROR_CODES.VALIDATION, `${k} invalide.`);
+    }
+  },
+  async create(pack2, data) {
+    if (!data.name) throw badRequest(ERROR_CODES.VALIDATION, "Le nom est requis.");
+    this.validate(data);
+    const { cards, ...rest } = data;
+    const drop2 = await strapi.documents(UID.DROP).create({
+      data: {
+        ...rest,
+        slug: await uniqueSlug(strapi, UID.DROP, rest.slug || rest.name, { pack: pack2.id }),
+        pack: pack2.id,
+        secret: randomBytes(24).toString("hex"),
+        isDefault: Boolean(rest.isDefault)
+      }
+    });
+    if (Array.isArray(cards)) await this.setCards(pack2, drop2.documentId, cards);
+    return drop2;
+  },
+  /** Every pack gets one default drop so a pack is scannable the moment it exists. */
+  async ensureDefault(pack2) {
+    const existing = await strapi.db.query(UID.DROP).findOne({ where: { pack: pack2.id, isDefault: true } });
+    if (existing) return existing;
+    return this.create(pack2, { name: DEFAULT_DROP_NAME, mode: DROP_MODE.STATIC, isDefault: true, poolMode: POOL_MODE.INHERIT });
+  },
+  async update(pack2, ref, data) {
+    const drop2 = await this.findOne(pack2, ref);
+    this.validate(data);
+    const { cards, pack: _p, secret: _s, scanCount: _c, isDefault: _d, ...rest } = data;
+    if (rest.slug && rest.slug !== drop2.slug) rest.slug = await uniqueSlug(strapi, UID.DROP, rest.slug, { pack: pack2.id });
+    const updated = await strapi.documents(UID.DROP).update({ documentId: drop2.documentId, data: rest });
+    if (Array.isArray(cards)) await this.setCards(pack2, drop2.documentId, cards);
+    return updated;
+  },
+  async rotateSecret(pack2, ref) {
+    const drop2 = await this.findOne(pack2, ref);
+    await strapi.db.query(UID.DROP).update({ where: { id: drop2.id }, data: { secret: randomBytes(24).toString("hex") } });
+    return { ok: true };
+  },
+  async remove(pack2, ref) {
+    const drop2 = await this.findOne(pack2, ref);
+    if (drop2.isDefault) throw badRequest(ERROR_CODES.VALIDATION, "Le point de scan par défaut ne peut pas être supprimé : désactivez-le.");
+    const pulls = await strapi.db.query(UID.PULL).count({ where: { drop: drop2.id } });
+    if (pulls > 0) throw badRequest(ERROR_CODES.VALIDATION, "Ce point a des tirages : désactivez-le au lieu de le supprimer.");
+    await strapi.db.query(UID.DROP_CARD).deleteMany({ where: { drop: drop2.id } });
+    await strapi.documents(UID.DROP).delete({ documentId: drop2.documentId });
+    return { ok: true };
+  },
+  async setCards(pack2, dropRef, entries) {
+    const drop2 = await this.findOne(pack2, dropRef);
+    const season2 = pack2.season?.id ? pack2.season : await strapi.db.query(UID.PACK).findOne({ where: { id: pack2.id }, populate: { season: true } }).then((p) => p.season);
+    const docIds = [...new Set(entries.map((e) => typeof e === "string" ? e : e.card))];
+    const cards = docIds.length ? await strapi.db.query(UID.CARD).findMany({ where: { documentId: { $in: docIds }, season: season2.id }, select: ["id", "documentId"] }) : [];
+    if (cards.length !== docIds.length) throw badRequest(ERROR_CODES.VALIDATION, "Certaines cartes ne font pas partie de cette saison.");
+    const idByDoc = Object.fromEntries(cards.map((c) => [c.documentId, c.id]));
+    await strapi.db.transaction(async () => {
+      await strapi.db.query(UID.DROP_CARD).deleteMany({ where: { drop: drop2.id } });
+      for (const e of entries) {
+        const entry = typeof e === "string" ? { card: e } : e;
+        await strapi.db.query(UID.DROP_CARD).create({
+          data: { drop: drop2.id, card: idByDoc[entry.card], weight: Number.isFinite(Number(entry.weight)) ? Number(entry.weight) : 100, isExclusive: Boolean(entry.isExclusive), isActive: entry.isActive !== false }
+        });
+      }
+    });
+    return this.cards(pack2, drop2.documentId);
+  },
+  async cards(pack2, ref) {
+    const drop2 = await this.findOne(pack2, ref);
+    const rows = await strapi.db.query(UID.DROP_CARD).findMany({ where: { drop: drop2.id }, populate: { card: { populate: { image: true } } }, orderBy: { id: "asc" } });
+    return rows.filter((r) => r.card).map((r) => ({ id: r.documentId, weight: r.weight, isExclusive: r.isExclusive, isActive: r.isActive, card: r.card }));
+  },
+  /**
+   * Effective raw pool for a drop (before exclusivity/supply pruning): pack pool, drop pool, or both.
+   * Entries carry card fields + weight + isExclusive + source.
+   */
+  async rawPool(drop2, pack2) {
+    const packPool = drop2.poolMode === POOL_MODE.OVERRIDE ? [] : await strapi.plugin("tcg").service("pack").pool(pack2);
+    const own = drop2.poolMode === POOL_MODE.INHERIT ? [] : await strapi.db.query(UID.DROP_CARD).findMany({
+      where: { drop: drop2.id, isActive: true, card: { isActive: true } },
+      populate: { card: { populate: { image: true } } }
+    });
+    const ownEntries = own.filter((r) => r.card).map((r) => ({ ...r.card, weight: r.weight, isExclusive: r.isExclusive, source: "drop" }));
+    const seen = new Set(ownEntries.map((c) => c.id));
+    return [...ownEntries, ...packPool.filter((c) => !seen.has(c.id)).map((c) => ({ ...c, source: "pack" }))];
+  },
+  /** Card ids flagged exclusive on any pack-card or drop-card of a season. */
+  async exclusiveCardIds(season2) {
+    const [pc, dc] = await Promise.all([
+      strapi.db.query(UID.PACK_CARD).findMany({ where: { isExclusive: true, isActive: true, pack: { season: season2.id } }, populate: { card: { select: ["id"] } } }),
+      strapi.db.query(UID.DROP_CARD).findMany({ where: { isExclusive: true, isActive: true, drop: { pack: { season: season2.id } } }, populate: { card: { select: ["id"] } } })
+    ]);
+    return new Set([...pc, ...dc].map((r) => r.card?.id).filter(Boolean));
+  },
+  /** Where a card is exclusive, for the admin: [{ kind:'pack'|'drop', name, slug }]. */
+  async exclusivityOf(cardId) {
+    const [pc, dc] = await Promise.all([
+      strapi.db.query(UID.PACK_CARD).findMany({ where: { card: cardId, isExclusive: true }, populate: { pack: { select: ["name", "slug"] } } }),
+      strapi.db.query(UID.DROP_CARD).findMany({ where: { card: cardId, isExclusive: true }, populate: { drop: { select: ["name", "slug"], populate: { pack: { select: ["name"] } } } } })
+    ]);
+    return [
+      ...pc.filter((r) => r.pack).map((r) => ({ kind: "pack", name: r.pack.name, slug: r.pack.slug })),
+      ...dc.filter((r) => r.drop).map((r) => ({ kind: "drop", name: `${r.drop.pack?.name ?? ""} · ${r.drop.name}`, slug: r.drop.slug }))
+    ];
+  },
+  /** Booth / poster token. */
+  async generateQR(pack2, ref) {
+    const drop2 = await this.findOne(pack2, ref);
+    const season2 = pack2.season ?? (await strapi.db.query(UID.PACK).findOne({ where: { id: pack2.id }, populate: { season: true } })).season;
+    const limits = strapi.plugin("tcg").service("season").limitsOf(season2);
+    return { ...strapi.plugin("tcg").service("qr").forDrop(drop2, limits.qrTokenTtlMs), drop: drop2 };
+  },
+  /** Public shape, exclusives revealed as count (+ names unless the drop is secret). */
+  async publicView(drop2, pack2, season2) {
+    const format2 = strapi.plugin("tcg").service("format");
+    const own = drop2.poolMode === POOL_MODE.INHERIT ? [] : await strapi.db.query(UID.DROP_CARD).findMany({ where: { drop: drop2.id, isActive: true, isExclusive: true }, populate: { card: true } });
+    return {
+      id: drop2.documentId,
+      name: drop2.name,
+      slug: drop2.slug,
+      description: drop2.description ?? null,
+      mode: drop2.mode,
+      isDefault: drop2.isDefault,
+      isOpen: this.isOpen(drop2),
+      startsAt: drop2.startsAt ?? null,
+      endsAt: drop2.endsAt ?? null,
+      soldOut: drop2.maxScansTotal != null && drop2.scanCount >= drop2.maxScansTotal,
+      remaining: drop2.maxScansTotal != null ? Math.max(0, drop2.maxScansTotal - drop2.scanCount) : null,
+      exclusiveCount: own.length,
+      exclusiveCards: drop2.isSecret ? [] : own.filter((r) => r.card).map((r) => ({ id: r.card.documentId, name: r.card.name, rarity: r.card.rarity, rarityColor: format2.rarityMeta(season2, r.card.rarity).color })),
+      geo: drop2.geo ?? null
+    };
+  }
+});
+const POPULATE$3 = { pack: true, drop: true, season: true };
+const boost = ({ strapi }) => ({
+  isLive(b, now = /* @__PURE__ */ new Date()) {
+    if (!b.isActive) return false;
+    if (b.startsAt && new Date(b.startsAt) > now) return false;
+    if (b.endsAt && new Date(b.endsAt) < now) return false;
+    return true;
+  },
+  async list(season2) {
+    const rows = await strapi.db.query(UID.BOOST).findMany({ where: { season: season2.id }, populate: POPULATE$3, orderBy: [{ startsAt: "desc" }] });
+    return rows.map((b) => ({ ...b, isLive: this.isLive(b) }));
+  },
+  /** Boosts live right now that apply to this drop (season-wide, its pack, or itself). */
+  async activeFor(season2, pack2, drop2) {
+    const rows = await strapi.db.query(UID.BOOST).findMany({ where: { season: season2.id, isActive: true }, populate: { pack: { select: ["id"] }, drop: { select: ["id"] } } });
+    return rows.filter((b) => this.isLive(b) && (!b.pack || b.pack.id === pack2.id) && (!b.drop || b.drop.id === drop2.id));
+  },
+  /** Season-wide view for the mini-program: everything live now, with scope. */
+  async liveNow(season2) {
+    const rows = await strapi.db.query(UID.BOOST).findMany({ where: { season: season2.id, isActive: true, announce: true }, populate: { pack: true, drop: true } });
+    return rows.filter((b) => this.isLive(b)).map((b) => this.format(b));
+  },
+  combine(boosts) {
+    const m = {};
+    for (const b of boosts) for (const [k, v] of Object.entries(b.multipliers ?? {})) m[k] = (m[k] ?? 1) * (Number(v) || 1);
+    return m;
+  },
+  validate(season2, data) {
+    if (data.multipliers !== void 0) {
+      if (!data.multipliers || typeof data.multipliers !== "object") throw badRequest(ERROR_CODES.VALIDATION, "multipliers doit être un objet.");
+      const keys = (season2.rarities ?? []).map((r) => r.key);
+      for (const [k, v] of Object.entries(data.multipliers)) {
+        if (!keys.includes(k)) throw badRequest(ERROR_CODES.VALIDATION, `Rareté inconnue "${k}".`);
+        if (!(Number(v) >= 0)) throw badRequest(ERROR_CODES.VALIDATION, `Multiplicateur invalide pour "${k}".`);
+      }
+    }
+  },
+  async resolveScope(season2, data) {
+    const out = {};
+    if (data.pack !== void 0) {
+      out.pack = data.pack ? (await strapi.plugin("tcg").service("pack").findOne(season2, data.pack)).id : null;
+    }
+    if (data.drop !== void 0) {
+      if (!data.drop) out.drop = null;
+      else {
+        const drop2 = await strapi.db.query(UID.DROP).findOne({ where: { documentId: data.drop }, populate: { pack: { select: ["id"] } } });
+        if (!drop2) throw notFound(ERROR_CODES.DROP_NOT_FOUND, "Point de scan introuvable.");
+        out.drop = drop2.id;
+        out.pack = drop2.pack?.id ?? out.pack;
+      }
+    }
+    return out;
+  },
+  async create(season2, data) {
+    if (!data.name) throw badRequest(ERROR_CODES.VALIDATION, "Le nom est requis.");
+    if (!data.multipliers) throw badRequest(ERROR_CODES.VALIDATION, "multipliers est requis.");
+    this.validate(season2, data);
+    const scope = await this.resolveScope(season2, data);
+    const row = await strapi.documents(UID.BOOST).create({ data: { ...data, ...scope, season: season2.id }, populate: POPULATE$3 });
+    return { ...row, isLive: this.isLive(row) };
+  },
+  async update(season2, documentId, data) {
+    const existing = await strapi.db.query(UID.BOOST).findOne({ where: { documentId, season: season2.id } });
+    if (!existing) throw notFound(ERROR_CODES.VALIDATION, "Boost introuvable.");
+    this.validate(season2, data);
+    const scope = await this.resolveScope(season2, data);
+    const { season: _s, ...rest } = data;
+    const row = await strapi.documents(UID.BOOST).update({ documentId, data: { ...rest, ...scope }, populate: POPULATE$3 });
+    return { ...row, isLive: this.isLive(row) };
+  },
+  async remove(season2, documentId) {
+    const existing = await strapi.db.query(UID.BOOST).findOne({ where: { documentId, season: season2.id } });
+    if (!existing) throw notFound(ERROR_CODES.VALIDATION, "Boost introuvable.");
+    await strapi.documents(UID.BOOST).delete({ documentId });
+    return { ok: true };
+  },
+  format(b) {
+    return {
+      id: b.documentId,
+      name: b.name,
+      description: b.description ?? null,
+      multipliers: b.multipliers ?? {},
+      startsAt: b.startsAt ?? null,
+      endsAt: b.endsAt ?? null,
+      scope: b.drop ? { kind: "drop", name: b.drop.name, slug: b.drop.slug } : b.pack ? { kind: "pack", name: b.pack.name, slug: b.pack.slug } : { kind: "season" }
+    };
+  }
+});
+const matchCost = (rules, handed, ctx) => {
+  const rarities = ctx.rarities ?? [];
+  const idx = (k) => rarities.indexOf(k);
+  const pool = handed.map((c) => ({ ...c, rarityIndex: idx(c.rarity) }));
+  const missing = [];
+  const consumed = [];
+  const ordered = [...rules ?? []].sort((a, b) => rank(a) - rank(b));
+  for (const rule of ordered) {
+    if (rule.type === COST_RULE.CARD) {
+      const need = Number(rule.count) || 1;
+      let got = 0;
+      for (let i = pool.length - 1; i >= 0 && got < need; i -= 1) {
+        if (pool[i].cardId === rule.card) {
+          consumed.push(pool.splice(i, 1)[0]);
+          got += 1;
+        }
+      }
+      if (got < need) missing.push(`${need - got} × ${ctx.cardNames?.[rule.card] ?? `carte ${rule.card}`}`);
+    } else if (rule.type === COST_RULE.SET) {
+      const cards = ctx.sets?.[rule.set] ?? [];
+      if (cards.length === 0) {
+        missing.push(`set inconnu ${rule.set}`);
+        continue;
+      }
+      if (rule.consume) {
+        for (const cardId of cards) {
+          const i = pool.findIndex((c) => c.cardId === cardId);
+          if (i === -1) missing.push(`${ctx.cardNames?.[cardId] ?? cardId} (set ${ctx.setNames?.[rule.set] ?? rule.set})`);
+          else consumed.push(pool.splice(i, 1)[0]);
+        }
+      } else if (!cards.every((cardId) => ctx.owned?.has(cardId))) {
+        missing.push(`set ${rule.set} incomplet`);
+      }
+    } else if (rule.type === COST_RULE.CARDS) {
+      const need = Number(rule.count) || 1;
+      const minIdx = rule.minRarity ? idx(rule.minRarity) : -1;
+      const candidates = pool.map((c, i) => ({ c, i })).filter(({ c }) => (rule.rarity ? c.rarity === rule.rarity : true) && c.rarityIndex >= minIdx).sort((a, b) => a.c.rarityIndex - b.c.rarityIndex);
+      const take = candidates.slice(0, need);
+      for (const { c } of take) {
+        const i = pool.indexOf(c);
+        consumed.push(pool.splice(i, 1)[0]);
+      }
+      if (take.length < need) {
+        const label = rule.rarity ?? (rule.minRarity ? `≥ ${rule.minRarity}` : "carte(s)");
+        missing.push(`${need - take.length} × ${label}`);
+      }
+    } else {
+      missing.push(`règle inconnue ${rule.type}`);
+    }
+  }
+  return { ok: missing.length === 0 && pool.length === 0, missing, leftover: pool.length, consumed };
+};
+const rank = (rule) => rule.type === COST_RULE.CARD ? 0 : rule.type === COST_RULE.SET ? 1 : 2;
+const describeCost = (rules, rarities = [], sets = {}) => (rules ?? []).map((r) => {
+  const label = (k) => rarities.find((x) => x.key === k)?.label ?? k;
+  if (r.type === COST_RULE.CARDS) return `${r.count} ${r.rarity ? label(r.rarity) : r.minRarity ? `≥ ${label(r.minRarity)}` : "carte(s)"}`;
+  if (r.type === COST_RULE.CARD) return `${r.count ?? 1} × ${r.cardName ?? r.card}`;
+  if (r.type === COST_RULE.SET) return `${r.consume ? "Remettre" : "Posséder"} le set ${sets[r.set]?.name ?? r.set}`;
+  return "?";
+});
+const validateCost = (rules) => {
+  const problems = [];
+  if (!Array.isArray(rules) || rules.length === 0) return ["cost must be a non-empty array of rules"];
+  rules.forEach((r, i) => {
+    if (!Object.values(COST_RULE).includes(r?.type)) problems.push(`cost[${i}].type is invalid`);
+    if (r?.type === COST_RULE.CARDS && !(Number(r.count) >= 1)) problems.push(`cost[${i}].count must be ≥ 1`);
+    if (r?.type === COST_RULE.CARD && !r.card) problems.push(`cost[${i}].card is required`);
+    if (r?.type === COST_RULE.SET && !r.set) problems.push(`cost[${i}].set is required`);
+  });
+  return problems;
+};
+const POPULATE$2 = { image: true };
+const reward = ({ strapi }) => ({
+  isOpen(r, now = /* @__PURE__ */ new Date()) {
+    if (!r.isActive) return false;
+    if (r.startsAt && new Date(r.startsAt) > now) return false;
+    if (r.endsAt && new Date(r.endsAt) < now) return false;
+    return true;
+  },
+  async list(season2, { includeInactive = true } = {}) {
+    const where = { season: season2.id };
+    if (!includeInactive) where.isActive = true;
+    return strapi.db.query(UID.REWARD).findMany({ where, populate: POPULATE$2, orderBy: [{ sortOrder: "asc" }, { name: "asc" }] });
+  },
+  async findOne(season2, ref) {
+    const r = await strapi.db.query(UID.REWARD).findOne({ where: { season: season2.id, $or: [{ slug: ref }, { documentId: ref }] }, populate: POPULATE$2 });
+    if (!r) throw notFound(ERROR_CODES.REWARD_NOT_FOUND, "Récompense introuvable.");
+    return r;
+  },
+  validate(data) {
+    if (data.cost !== void 0) {
+      const problems = validateCost(data.cost);
+      if (problems.length) throw badRequest(ERROR_CODES.VALIDATION, "Coût invalide.", { problems });
+    }
+    for (const k of ["stock", "perPlayerLimit"]) {
+      if (data[k] != null && data[k] !== "" && !(Number(data[k]) >= 0)) throw badRequest(ERROR_CODES.VALIDATION, `${k} invalide.`);
+    }
+  },
+  async create(season2, data) {
+    if (!data.name) throw badRequest(ERROR_CODES.VALIDATION, "Le nom est requis.");
+    if (!data.cost) throw badRequest(ERROR_CODES.VALIDATION, "Le coût est requis.");
+    this.validate(data);
+    return strapi.documents(UID.REWARD).create({
+      data: { ...data, slug: await uniqueSlug(strapi, UID.REWARD, data.slug || data.name, { season: season2.id }), season: season2.id },
+      populate: POPULATE$2
+    });
+  },
+  async update(season2, ref, data) {
+    const r = await this.findOne(season2, ref);
+    this.validate(data);
+    const { season: _s, claimed: _c, ...rest } = data;
+    if (rest.slug && rest.slug !== r.slug) rest.slug = await uniqueSlug(strapi, UID.REWARD, rest.slug, { season: season2.id });
+    return strapi.documents(UID.REWARD).update({ documentId: r.documentId, data: rest, populate: POPULATE$2 });
+  },
+  async remove(season2, ref) {
+    const r = await this.findOne(season2, ref);
+    const used = await strapi.db.query(UID.REDEMPTION).count({ where: { reward: r.id } });
+    if (used > 0) throw badRequest(ERROR_CODES.VALIDATION, "Des retraits référencent cette récompense : désactivez-la.");
+    await strapi.documents(UID.REWARD).delete({ documentId: r.documentId });
+    return { ok: true };
+  },
+  /**
+   * Checks a player's handed cards against a reward. Returns the matched consumption or throws.
+   * @param {Object} player
+   * @param {Object} season
+   * @param {Object} reward
+   * @param {Array} handedRows player-card rows (populate card)
+   */
+  async check(player2, season2, reward2, handedRows) {
+    const plugin = strapi.plugin("tcg");
+    if (!this.isOpen(reward2)) throw unprocessable(ERROR_CODES.REWARD_UNAVAILABLE, "Cette récompense n'est pas disponible.");
+    if (reward2.stock != null && reward2.claimed >= reward2.stock) throw unprocessable(ERROR_CODES.REWARD_SOLD_OUT, "Stock épuisé.");
+    if (reward2.perPlayerLimit != null) {
+      const mine = await strapi.db.query(UID.REDEMPTION).count({ where: { player: player2.id, reward: reward2.id, status: { $ne: "cancelled" } } });
+      if (mine >= reward2.perPlayerLimit) throw unprocessable(ERROR_CODES.REWARD_PLAYER_LIMIT, `Limite de ${reward2.perPlayerLimit} par joueur atteinte.`);
+    }
+    const rarities = (season2.rarities ?? []).map((r) => r.key);
+    const [sets, names] = await Promise.all([plugin.service("set").slugMap(season2), this.names(season2)]);
+    const ownedRows = await strapi.db.query(UID.PLAYER_CARD).findMany({ where: { player: player2.id, card: { season: season2.id } }, populate: { card: { select: ["documentId"] } } });
+    const owned = new Set(ownedRows.map((r) => r.card?.documentId).filter(Boolean));
+    const handed = handedRows.map((r) => ({ playerCardId: r.documentId, cardId: r.card?.documentId, rarity: r.card?.rarity }));
+    const result = matchCost(reward2.cost ?? [], handed, { rarities, sets, owned, ...names });
+    if (!result.ok) {
+      const why = result.missing.length ? result.missing : [`${result.leftover} carte(s) en trop`];
+      throw unprocessable(ERROR_CODES.REWARD_COST_UNMET, `Conditions non remplies : ${why.join(", ")}.`, { missing: result.missing, leftover: result.leftover });
+    }
+    return result;
+  },
+  /** Eligibility hints for the mini-program: can this player afford each reward with what they own? */
+  async eligibility(player2, season2) {
+    const plugin = strapi.plugin("tcg");
+    const [rewards, ownedRows, sets, names] = await Promise.all([
+      this.list(season2, { includeInactive: false }),
+      strapi.db.query(UID.PLAYER_CARD).findMany({ where: { player: player2.id, card: { season: season2.id } }, populate: { card: { select: ["documentId", "rarity"] } } }),
+      plugin.service("set").slugMap(season2),
+      this.names(season2)
+    ]);
+    const rarities = (season2.rarities ?? []).map((r) => r.key);
+    const owned = new Set(ownedRows.map((r) => r.card?.documentId).filter(Boolean));
+    const all = ownedRows.map((r) => ({ playerCardId: r.documentId, cardId: r.card?.documentId, rarity: r.card?.rarity }));
+    return rewards.map((r) => {
+      const res = matchCost(r.cost ?? [], all, { rarities, sets, owned, ...names });
+      const open = this.isOpen(r);
+      const soldOut = r.stock != null && r.claimed >= r.stock;
+      return { ...this.format(r, season2), eligible: open && !soldOut && res.missing.length === 0, missing: res.missing, suggestedCards: res.consumed.map((c) => c.playerCardId) };
+    });
+  },
+  /** Human names for cost messages. */
+  async names(season2) {
+    const [cards, sets] = await Promise.all([
+      strapi.db.query(UID.CARD).findMany({ where: { season: season2.id }, select: ["documentId", "name"] }),
+      strapi.plugin("tcg").service("set").list(season2)
+    ]);
+    return { cardNames: Object.fromEntries(cards.map((c) => [c.documentId, c.name])), setNames: Object.fromEntries(sets.map((s) => [s.slug, s.name])) };
+  },
+  format(r, season2, setsByName = {}) {
+    return {
+      id: r.documentId,
+      name: r.name,
+      slug: r.slug,
+      description: r.description ?? null,
+      imageUrl: r.image?.url ?? null,
+      tier: r.tier ?? "bronze",
+      booth: r.booth ?? null,
+      cost: r.cost ?? [],
+      costLabel: describeCost(r.cost ?? [], season2?.rarities ?? [], setsByName),
+      stock: r.stock ?? null,
+      remaining: r.stock != null ? Math.max(0, r.stock - (r.claimed ?? 0)) : null,
+      claimed: r.claimed ?? 0,
+      perPlayerLimit: r.perPlayerLimit ?? null,
+      isActive: r.isActive,
+      isOpen: this.isOpen(r),
+      startsAt: r.startsAt ?? null,
+      endsAt: r.endsAt ?? null,
+      sortOrder: r.sortOrder ?? 0
+    };
+  }
+});
+const POPULATE$1 = { image: true, cards: { populate: { image: true } } };
+const set = ({ strapi }) => ({
+  async list(season2, { includeInactive = true } = {}) {
+    const where = { season: season2.id };
+    if (!includeInactive) where.isActive = true;
+    return strapi.db.query(UID.CARD_SET).findMany({ where, populate: POPULATE$1, orderBy: [{ sortOrder: "asc" }, { name: "asc" }] });
+  },
+  async findOne(season2, ref) {
+    const set2 = await strapi.db.query(UID.CARD_SET).findOne({ where: { season: season2.id, $or: [{ slug: ref }, { documentId: ref }] }, populate: POPULATE$1 });
+    if (!set2) throw notFound(ERROR_CODES.VALIDATION, "Set introuvable.");
+    return set2;
+  },
+  async resolveCards(season2, docIds = []) {
+    const ids = [...new Set(docIds)];
+    const cards = ids.length ? await strapi.db.query(UID.CARD).findMany({ where: { documentId: { $in: ids }, season: season2.id }, select: ["id"] }) : [];
+    if (cards.length !== ids.length) throw badRequest(ERROR_CODES.VALIDATION, "Certaines cartes ne font pas partie de cette saison.");
+    return cards.map((c) => c.id);
+  },
+  async create(season2, data) {
+    if (!data.name) throw badRequest(ERROR_CODES.VALIDATION, "Le nom est requis.");
+    const { cards, ...rest } = data;
+    return strapi.documents(UID.CARD_SET).create({
+      data: { ...rest, slug: await uniqueSlug(strapi, UID.CARD_SET, rest.slug || rest.name, { season: season2.id }), season: season2.id, cards: await this.resolveCards(season2, cards ?? []) },
+      populate: POPULATE$1
+    });
+  },
+  async update(season2, ref, data) {
+    const set2 = await this.findOne(season2, ref);
+    const { cards, season: _s, ...rest } = data;
+    if (rest.slug && rest.slug !== set2.slug) rest.slug = await uniqueSlug(strapi, UID.CARD_SET, rest.slug, { season: season2.id });
+    const payload = { ...rest };
+    if (Array.isArray(cards)) payload.cards = await this.resolveCards(season2, cards);
+    return strapi.documents(UID.CARD_SET).update({ documentId: set2.documentId, data: payload, populate: POPULATE$1 });
+  },
+  async remove(season2, ref) {
+    const set2 = await this.findOne(season2, ref);
+    await strapi.documents(UID.CARD_SET).delete({ documentId: set2.documentId });
+    return { ok: true };
+  },
+  /** { [slug]: cardDocumentIds[] } for the cost matcher. */
+  async slugMap(season2) {
+    const sets = await this.list(season2, { includeInactive: false });
+    return Object.fromEntries(sets.map((s) => [s.slug, (s.cards ?? []).map((c) => c.documentId)]));
+  },
+  /** Progress for a player given the set of owned card ids (internal ids). */
+  progress(sets, ownedIds, season2) {
+    const format2 = strapi.plugin("tcg").service("format");
+    return sets.map((s) => {
+      const cards = s.cards ?? [];
+      const collected = cards.filter((c) => ownedIds.has(c.id)).length;
+      return {
+        id: s.documentId,
+        name: s.name,
+        slug: s.slug,
+        description: s.description ?? null,
+        imageUrl: s.image?.url ?? null,
+        total: cards.length,
+        collected,
+        isComplete: cards.length > 0 && collected === cards.length,
+        cards: cards.map((c) => ({ ...format2.card(c, season2), owned: ownedIds.has(c.id) }))
+      };
+    });
+  }
+});
+const ruleMet = (rule, m) => {
+  if (!rule || !m) return false;
+  const n = Number(rule.count ?? 0);
+  switch (rule.type) {
+    case BADGE_RULE.PULLS:
+      return m.pulls >= n;
+    case BADGE_RULE.RARITY_PULLS:
+      return (m.pullsByRarity?.[rule.rarity] ?? 0) >= n;
+    case BADGE_RULE.UNIQUE_CARDS:
+      return m.uniqueCards >= n;
+    case BADGE_RULE.PACKS_VISITED:
+      return rule.count === "all" ? m.packsTotal > 0 && m.packsVisited >= m.packsTotal : m.packsVisited >= n;
+    case BADGE_RULE.DROPS_VISITED:
+      return m.dropsVisited >= n;
+    case BADGE_RULE.TRADES:
+      return m.trades >= n;
+    case BADGE_RULE.REDEMPTIONS:
+      return m.redemptions >= n;
+    case BADGE_RULE.SET_COMPLETE:
+      if (rule.set === "any") return (m.setsComplete?.length ?? 0) > 0;
+      if (rule.set === "all") return m.setsTotal > 0 && (m.setsComplete?.length ?? 0) >= m.setsTotal;
+      return (m.setsComplete ?? []).includes(rule.set);
+    case BADGE_RULE.STREAK_DAYS:
+      return m.streakDays >= n;
+    case BADGE_RULE.COMPLETION:
+      return m.completionPercent >= Number(rule.percent ?? 100);
+    case BADGE_RULE.MINT:
+      return m.bestMint != null && m.bestMint <= Number(rule.max ?? 1);
+    case BADGE_RULE.SCAN_DROP:
+      return (m.dropsScanned ?? []).includes(rule.drop);
+    default:
+      return false;
+  }
+};
+const streakDays = (pullDates, now = /* @__PURE__ */ new Date()) => {
+  const days = new Set(pullDates.map((d) => new Date(d).toISOString().slice(0, 10)));
+  if (days.size === 0) return 0;
+  const cursor = new Date(now);
+  cursor.setUTCHours(0, 0, 0, 0);
+  const today = cursor.toISOString().slice(0, 10);
+  if (!days.has(today)) cursor.setUTCDate(cursor.getUTCDate() - 1);
+  let streak = 0;
+  while (days.has(cursor.toISOString().slice(0, 10))) {
+    streak += 1;
+    cursor.setUTCDate(cursor.getUTCDate() - 1);
+  }
+  return streak;
+};
+const validateBadgeRule = (rule) => {
+  if (!rule || !Object.values(BADGE_RULE).includes(rule.type)) return [`rule.type is invalid`];
+  const needsCount = [BADGE_RULE.PULLS, BADGE_RULE.RARITY_PULLS, BADGE_RULE.UNIQUE_CARDS, BADGE_RULE.DROPS_VISITED, BADGE_RULE.TRADES, BADGE_RULE.REDEMPTIONS, BADGE_RULE.STREAK_DAYS];
+  const problems = [];
+  if (needsCount.includes(rule.type) && !(Number(rule.count) >= 1)) problems.push("rule.count must be ≥ 1");
+  if (rule.type === BADGE_RULE.PACKS_VISITED && rule.count !== "all" && !(Number(rule.count) >= 1)) problems.push("rule.count must be ≥ 1 or 'all'");
+  if (rule.type === BADGE_RULE.RARITY_PULLS && !rule.rarity) problems.push("rule.rarity is required");
+  if (rule.type === BADGE_RULE.SET_COMPLETE && !rule.set) problems.push("rule.set is required");
+  if (rule.type === BADGE_RULE.SCAN_DROP && !rule.drop) problems.push("rule.drop is required");
+  return problems;
+};
+const STARTER_BADGES = [
+  { key: "first-pull", name: "Première carte", icon: "🎴", tier: "bronze", rule: { type: BADGE_RULE.PULLS, count: 1 } },
+  { key: "ten-pulls", name: "Collectionneur", icon: "📚", tier: "bronze", rule: { type: BADGE_RULE.PULLS, count: 10 } },
+  { key: "explorer", name: "Explorateur", icon: "🧭", tier: "silver", rule: { type: BADGE_RULE.PACKS_VISITED, count: "all" } },
+  { key: "first-trade", name: "Négociant", icon: "🤝", tier: "bronze", rule: { type: BADGE_RULE.TRADES, count: 1 } },
+  { key: "streak-3", name: "Fidèle", icon: "🔥", tier: "silver", rule: { type: BADGE_RULE.STREAK_DAYS, count: 3 } },
+  { key: "first-set", name: "Set complet", icon: "🧩", tier: "gold", rule: { type: BADGE_RULE.SET_COMPLETE, set: "any" } },
+  { key: "half-way", name: "À mi-chemin", icon: "⛰️", tier: "silver", rule: { type: BADGE_RULE.COMPLETION, percent: 50 } },
+  { key: "legend", name: "Légende", icon: "👑", tier: "legend", rule: { type: BADGE_RULE.COMPLETION, percent: 100 } },
+  { key: "early-mint", name: "Pionnier", icon: "🥇", tier: "gold", rule: { type: BADGE_RULE.MINT, max: 10 }, isSecret: true }
+];
+const POPULATE = { image: true };
+const badge = ({ strapi }) => ({
+  async list(season2, { includeInactive = true } = {}) {
+    const where = { $or: [{ season: season2.id }, { season: null }] };
+    if (!includeInactive) where.isActive = true;
+    return strapi.db.query(UID.BADGE).findMany({ where, populate: POPULATE, orderBy: [{ sortOrder: "asc" }, { tier: "asc" }, { name: "asc" }] });
+  },
+  async findOne(season2, ref) {
+    const b = await strapi.db.query(UID.BADGE).findOne({ where: { $or: [{ documentId: ref }, { key: ref }], season: season2.id }, populate: POPULATE });
+    if (!b) throw notFound(ERROR_CODES.VALIDATION, "Badge introuvable.");
+    return b;
+  },
+  validate(data) {
+    if (data.rule !== void 0) {
+      const problems = validateBadgeRule(data.rule);
+      if (problems.length) throw badRequest(ERROR_CODES.VALIDATION, "Règle invalide.", { problems });
+    }
+    if (data.key !== void 0 && !/^[a-z0-9-]{2,60}$/.test(data.key)) throw badRequest(ERROR_CODES.VALIDATION, "Clé invalide (a-z, 0-9, -).");
+  },
+  async create(season2, data) {
+    if (!data.name || !data.key || !data.rule) throw badRequest(ERROR_CODES.VALIDATION, "name, key et rule sont requis.");
+    this.validate(data);
+    const dup = await strapi.db.query(UID.BADGE).findOne({ where: { key: data.key, season: season2.id }, select: ["id"] });
+    if (dup) throw badRequest(ERROR_CODES.VALIDATION, `La clé "${data.key}" existe déjà dans cette saison.`);
+    return strapi.documents(UID.BADGE).create({ data: { ...data, season: season2.id }, populate: POPULATE });
+  },
+  async update(season2, ref, data) {
+    const b = await this.findOne(season2, ref);
+    this.validate(data);
+    const { season: _s, ...rest } = data;
+    return strapi.documents(UID.BADGE).update({ documentId: b.documentId, data: rest, populate: POPULATE });
+  },
+  async remove(season2, ref) {
+    const b = await this.findOne(season2, ref);
+    await strapi.db.query(UID.PLAYER_BADGE).deleteMany({ where: { badge: b.id } });
+    await strapi.documents(UID.BADGE).delete({ documentId: b.documentId });
+    return { ok: true };
+  },
+  /** Seeds the starter set into a season (skips keys that exist). */
+  async seedStarters(season2) {
+    let created2 = 0;
+    for (const b of STARTER_BADGES) {
+      const exists = await strapi.db.query(UID.BADGE).findOne({ where: { key: b.key, season: season2.id }, select: ["id"] });
+      if (exists) continue;
+      await strapi.documents(UID.BADGE).create({ data: { ...b, description: b.description ?? null, isSecret: Boolean(b.isSecret), season: season2.id, sortOrder: created2 } });
+      created2 += 1;
+    }
+    return created2;
+  },
+  /** One pass over the player's season activity. */
+  async metrics(player2, season2) {
+    const plugin = strapi.plugin("tcg");
+    const [pulls, owned, packs, drops, trades, redemptions, sets, catalogTotal] = await Promise.all([
+      strapi.db.query(UID.PULL).findMany({ where: { player: player2.id, season: season2.id }, select: ["rarity", "pulledAt", "mintNumber"], populate: { pack: { select: ["id"] }, drop: { select: ["id", "slug"] } } }),
+      strapi.db.query(UID.PLAYER_CARD).findMany({ where: { player: player2.id, card: { season: season2.id } }, select: ["mintNumber"], populate: { card: { select: ["id"] } } }),
+      strapi.db.query(UID.PACK).count({ where: { season: season2.id, isActive: true } }),
+      strapi.db.query(UID.DROP).count({ where: { pack: { season: season2.id }, isActive: true } }),
+      strapi.db.query(UID.TRADE).count({ where: { season: season2.id, $or: [{ initiator: player2.id }, { receiver: player2.id }] } }),
+      strapi.db.query(UID.REDEMPTION).count({ where: { player: player2.id, season: season2.id, status: { $ne: "cancelled" } } }),
+      plugin.service("set").list(season2, { includeInactive: false }),
+      strapi.db.query(UID.CARD).count({ where: { season: season2.id, isActive: true } })
+    ]);
+    const ownedIds = new Set(owned.map((o) => o.card?.id).filter(Boolean));
+    const pullsByRarity = {};
+    for (const p of pulls) pullsByRarity[p.rarity] = (pullsByRarity[p.rarity] ?? 0) + 1;
+    const mints = owned.map((o) => o.mintNumber).filter((n) => n != null);
+    const setsComplete = sets.filter((s) => (s.cards ?? []).length > 0 && s.cards.every((c) => ownedIds.has(c.id))).map((s) => s.slug);
+    return {
+      pulls: pulls.length,
+      pullsByRarity,
+      uniqueCards: ownedIds.size,
+      packsVisited: new Set(pulls.map((p) => p.pack?.id).filter(Boolean)).size,
+      packsTotal: packs,
+      dropsVisited: new Set(pulls.map((p) => p.drop?.id).filter(Boolean)).size,
+      dropsTotal: drops,
+      dropsScanned: [...new Set(pulls.map((p) => p.drop?.slug).filter(Boolean))],
+      trades,
+      redemptions,
+      setsComplete,
+      setsTotal: sets.length,
+      streakDays: streakDays(pulls.map((p) => p.pulledAt)),
+      completionPercent: catalogTotal ? Math.round(ownedIds.size / catalogTotal * 100) : 0,
+      bestMint: mints.length ? Math.min(...mints) : null
+    };
+  },
+  /**
+   * Awards newly met badges. Never throws into the game flow.
+   * @returns {Promise<Array>} newly earned badges (formatted)
+   */
+  async evaluate(player2, season2, context = {}) {
+    try {
+      const [badges, earned] = await Promise.all([
+        this.list(season2, { includeInactive: false }),
+        strapi.db.query(UID.PLAYER_BADGE).findMany({ where: { player: player2.id }, populate: { badge: { select: ["id"] } } })
+      ]);
+      const have = new Set(earned.map((e) => e.badge?.id).filter(Boolean));
+      const candidates = badges.filter((b) => !have.has(b.id));
+      if (candidates.length === 0) return [];
+      const m = await this.metrics(player2, season2);
+      const now = /* @__PURE__ */ new Date();
+      const fresh = [];
+      for (const b of candidates) {
+        if (!ruleMet(b.rule, m)) continue;
+        await strapi.db.query(UID.PLAYER_BADGE).create({ data: { player: player2.id, badge: b.id, earnedAt: now, context } });
+        fresh.push(this.format(b, { earnedAt: now }));
+      }
+      if (fresh.length) strapi.log.info(`[tcg] badges ${player2.code}: ${fresh.map((b) => b.key).join(", ")}`);
+      return fresh;
+    } catch (err) {
+      strapi.log.warn(`[tcg] badge evaluation failed for ${player2.code}: ${err.message}`);
+      return [];
+    }
+  },
+  /** Season badges with the player's earned state; secret ones hidden until earned. */
+  async forPlayer(player2, season2) {
+    const [badges, earned] = await Promise.all([
+      this.list(season2, { includeInactive: false }),
+      strapi.db.query(UID.PLAYER_BADGE).findMany({ where: { player: player2.id }, populate: { badge: { select: ["id"] } } })
+    ]);
+    const earnedAt = Object.fromEntries(earned.map((e) => [e.badge?.id, e.earnedAt]));
+    return badges.filter((b) => !b.isSecret || earnedAt[b.id]).map((b) => this.format(b, { earnedAt: earnedAt[b.id] ?? null }));
+  },
+  format(b, { earnedAt } = {}) {
+    return {
+      id: b.documentId,
+      key: b.key,
+      name: b.name,
+      description: b.description ?? null,
+      icon: b.icon ?? null,
+      imageUrl: b.image?.url ?? null,
+      tier: b.tier ?? "bronze",
+      isSecret: Boolean(b.isSecret),
+      rule: b.rule,
+      earnedAt: earnedAt ?? null,
+      earned: Boolean(earnedAt)
+    };
+  }
+});
+const services = { settings, qr, format, player, season, card, pack, drop, boost, reward, set, badge, pull, collection, trade, redemption, stats };
+const index = { register, bootstrap, destroy, config, controllers, contentTypes, middlewares, policies, routes, services };
+export {
+  index as default
+};