gambling-bot-shared 1.0.4 → 1.0.6

package/dist/casino/index.d.ts

@@ -2,6 +2,7 @@ export * from './constants';
 export * from './types/casinoSettings';
 export * from './types/blackjackGame';
 export * from './utils/calculateRTP';
+export * from './utils/calculateRouletteWin';
 export * from './utils/validateBetAmount';
 export * from './utils/normalizeCasinoSettings';
 export * from './utils/winAnnouncements';

package/dist/casino/index.js

@@ -18,6 +18,7 @@ __exportStar(require("./constants"), exports);
 __exportStar(require("./types/casinoSettings"), exports);
 __exportStar(require("./types/blackjackGame"), exports);
 __exportStar(require("./utils/calculateRTP"), exports);
+__exportStar(require("./utils/calculateRouletteWin"), exports);
 __exportStar(require("./utils/validateBetAmount"), exports);
 __exportStar(require("./utils/normalizeCasinoSettings"), exports);
 __exportStar(require("./utils/winAnnouncements"), exports);

package/dist/casino/utils/calculateRouletteWin.d.ts

@@ -0,0 +1,9 @@
+import type { TCasinoSettings } from '../types/casinoSettings';
+export type RouletteBetType = keyof TCasinoSettings['roulette']['winMultipliers'];
+export type RouletteBet = {
+    type: RouletteBetType;
+    value: string;
+    amount: number;
+};
+export type RouletteWinMultipliers = TCasinoSettings['roulette']['winMultipliers'];
+export declare function calculateRouletteWin(bet: RouletteBet, result: string, payouts: RouletteWinMultipliers): number;

package/dist/casino/utils/calculateRouletteWin.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateRouletteWin = calculateRouletteWin;
+const rouletteConfig_1 = require("../constants/rouletteConfig");
+function calculateRouletteWin(bet, result, payouts) {
+    const amount = bet.amount;
+    const numResult = Number(result);
+    switch (bet.type) {
+        case 'number':
+            return bet.value === result ? amount * payouts.number : 0;
+        case 'color':
+            if (result === '0')
+                return 0;
+            return rouletteConfig_1.MINI_NUMBERS[result] === bet.value.toLowerCase()
+                ? amount * payouts.color
+                : 0;
+        case 'parity':
+            if (result === '0')
+                return 0;
+            return bet.value.toLowerCase() === (numResult % 2 === 0 ? 'even' : 'odd')
+                ? amount * payouts.parity
+                : 0;
+        case 'range':
+            if (result === '0')
+                return 0;
+            return bet.value.toLowerCase() ===
+                (numResult >= 1 && numResult <= 9 ? 'low' : 'high')
+                ? amount * payouts.range
+                : 0;
+        case 'dozen':
+            if (result === '0')
+                return 0;
+            return Number(bet.value) === Math.ceil(numResult / 6)
+                ? amount * payouts.dozen
+                : 0;
+        case 'column':
+            if (result === '0')
+                return 0;
+            return Number(bet.value) === ((numResult - 1) % 3) + 1
+                ? amount * payouts.column
+                : 0;
+        default:
+            return 0;
+    }
+}

package/dist/dev/bonusStressTest.d.ts

@@ -0,0 +1,18 @@
+import type { BonusSettings } from '../bonus/types/bonus';
+import type { PreviewDay } from '../bonus/utils/generateBonusPreview';
+export type BonusStressSummary = {
+    days: number;
+    totalReward: number;
+    avgReward: number;
+    maxReward: number;
+    maxDay: number;
+    resetCount: number;
+    weeklyBonuses: number;
+    monthlyBonuses: number;
+    cycleLength: number;
+    elapsedMs: number;
+};
+export type BonusStressResult = BonusStressSummary & {
+    preview: PreviewDay[];
+};
+export declare function runBonusStressTest(settings: BonusSettings, days: number, onProgress?: (completed: number, total: number) => void, chunkSize?: number): Promise<BonusStressResult>;

package/dist/dev/bonusStressTest.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBonusStressTest = runBonusStressTest;
+const calculateBonusReward_1 = require("../bonus/utils/calculateBonusReward");
+const yieldToEventLoop_1 = require("./yieldToEventLoop");
+const summarizePreview = (preview, settings, elapsedMs) => {
+    let totalReward = 0;
+    let maxReward = 0;
+    let maxDay = 1;
+    let resetCount = 0;
+    let weeklyBonuses = 0;
+    let monthlyBonuses = 0;
+    for (const day of preview) {
+        totalReward += day.reward;
+        if (day.reward > maxReward) {
+            maxReward = day.reward;
+            maxDay = day.day;
+        }
+        if (day.isReset)
+            resetCount++;
+        if (day.weekly > 0)
+            weeklyBonuses++;
+        if (day.monthly > 0)
+            monthlyBonuses++;
+    }
+    const cycleLength = (0, calculateBonusReward_1.getBonusCycleLength)(settings.rewardMode, settings.baseReward, settings.maxReward, settings.streakIncrement ?? 0, settings.streakMultiplier ?? 1);
+    return {
+        days: preview.length,
+        totalReward: Number(totalReward.toFixed(2)),
+        avgReward: preview.length
+            ? Number((totalReward / preview.length).toFixed(2))
+            : 0,
+        maxReward,
+        maxDay,
+        resetCount,
+        weeklyBonuses,
+        monthlyBonuses,
+        cycleLength,
+        elapsedMs,
+        preview
+    };
+};
+async function runBonusStressTest(settings, days, onProgress, chunkSize = 5000) {
+    const started = performance.now();
+    const preview = [];
+    let completed = 0;
+    while (completed < days) {
+        const batch = Math.min(chunkSize, days - completed);
+        for (let i = 0; i < batch; i++) {
+            const day = completed + i + 1;
+            const reward = (0, calculateBonusReward_1.calculateBonusReward)({ streak: day, settings });
+            preview.push({
+                day,
+                reward: reward.reward,
+                base: reward.base,
+                weekly: reward.weekly,
+                monthly: reward.monthly,
+                isReset: reward.isReset
+            });
+        }
+        completed += batch;
+        onProgress?.(completed, days);
+        await (0, yieldToEventLoop_1.yieldToEventLoop)();
+    }
+    return summarizePreview(preview, settings, Math.round(performance.now() - started));
+}

package/dist/dev/casinoMonteCarlo.d.ts

@@ -0,0 +1,16 @@
+import type { TCasinoSettings } from '../casino/types/casinoSettings';
+import { type RouletteBetType } from '../casino/utils/calculateRouletteWin';
+export type MonteCarloTarget = 'dice' | 'coinflip' | 'slots' | 'lottery' | 'plinko' | 'goldenJackpot' | `roulette:${RouletteBetType}`;
+export declare const MONTE_CARLO_TARGETS: MonteCarloTarget[];
+export type MonteCarloResult = {
+    target: MonteCarloTarget;
+    label: string;
+    iterations: number;
+    theoreticalRtp: number | null;
+    empiricalRtp: number;
+    delta: number | null;
+    elapsedMs: number;
+    distribution?: Record<string, number>;
+};
+export declare function runMonteCarloSimulation(target: MonteCarloTarget, settings: TCasinoSettings, iterations: number, onProgress?: (completed: number, total: number) => void, chunkSize?: number): Promise<MonteCarloResult>;
+export declare function runAllMonteCarloSimulations(settings: TCasinoSettings, iterations: number, onProgress?: (completed: number, total: number) => void): Promise<MonteCarloResult[]>;

package/dist/dev/casinoMonteCarlo.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MONTE_CARLO_TARGETS = void 0;
+exports.runMonteCarloSimulation = runMonteCarloSimulation;
+exports.runAllMonteCarloSimulations = runAllMonteCarloSimulations;
+const lotteryConfig_1 = require("../casino/constants/lotteryConfig");
+const plinkoConfig_1 = require("../casino/constants/plinkoConfig");
+const plinkoConfig_2 = require("../casino/constants/plinkoConfig");
+const rouletteConfig_1 = require("../casino/constants/rouletteConfig");
+const calculateRTP_1 = require("../casino/utils/calculateRTP");
+const calculateRouletteWin_1 = require("../casino/utils/calculateRouletteWin");
+const yieldToEventLoop_1 = require("./yieldToEventLoop");
+const toNumber = (val) => {
+    if (typeof val === 'string')
+        return parseFloat(val) || 0;
+    if (typeof val === 'number')
+        return val;
+    return 0;
+};
+const ROULETTE_NUMBERS = Object.keys(rouletteConfig_1.MINI_NUMBERS);
+const ROULETTE_BET_TYPES = [
+    'number',
+    'color',
+    'parity',
+    'range',
+    'dozen',
+    'column'
+];
+const ROULETTE_REP_BETS = {
+    number: { type: 'number', value: '1', amount: 1 },
+    color: { type: 'color', value: 'red', amount: 1 },
+    parity: { type: 'parity', value: 'even', amount: 1 },
+    range: { type: 'range', value: 'low', amount: 1 },
+    dozen: { type: 'dozen', value: '1', amount: 1 },
+    column: { type: 'column', value: '2', amount: 1 }
+};
+exports.MONTE_CARLO_TARGETS = [
+    'dice',
+    'coinflip',
+    'slots',
+    'lottery',
+    'plinko',
+    'goldenJackpot',
+    ...ROULETTE_BET_TYPES.map((type) => `roulette:${type}`)
+];
+const drawUnique = (count, max) => {
+    const pool = Array.from({ length: max }, (_, index) => index + 1);
+    const picks = [];
+    for (let i = 0; i < count; i++) {
+        const index = Math.floor(Math.random() * pool.length);
+        picks.push(pool[index]);
+        pool.splice(index, 1);
+    }
+    return picks;
+};
+const pickWeightedSymbol = (weights) => {
+    const entries = Object.entries(weights);
+    const total = entries.reduce((sum, [, weight]) => sum + toNumber(weight), 0);
+    let roll = Math.random() * total;
+    let selected = entries[entries.length - 1]?.[0] ?? '';
+    for (const [symbol, weight] of entries) {
+        roll -= toNumber(weight);
+        if (roll <= 0) {
+            selected = symbol;
+            break;
+        }
+    }
+    return selected;
+};
+const spinSlots = (settings) => {
+    const combo = Array.from({ length: 3 }, () => pickWeightedSymbol(settings.symbolWeights)).join('');
+    return toNumber(settings.winMultipliers[combo] ?? 0);
+};
+const spinRoulette = () => ROULETTE_NUMBERS[Math.floor(Math.random() * ROULETTE_NUMBERS.length)];
+const simulateRound = (target, settings) => {
+    switch (target) {
+        case 'dice': {
+            const rolled = Math.floor(Math.random() * 6) + 1;
+            const guessed = Math.floor(Math.random() * 6) + 1;
+            return {
+                multiplier: rolled === guessed ? toNumber(settings.dice.winMultiplier) : 0
+            };
+        }
+        case 'coinflip': {
+            const flipped = Math.random() < 0.5 ? 'heads' : 'tails';
+            const picked = Math.random() < 0.5 ? 'heads' : 'tails';
+            return {
+                multiplier: flipped === picked ? toNumber(settings.coinflip.winMultiplier) : 0
+            };
+        }
+        case 'slots':
+            return { multiplier: spinSlots(settings.slots) };
+        case 'lottery': {
+            const picks = drawUnique(lotteryConfig_1.LOTTERY_NUM_TO_DRAW, lotteryConfig_1.LOTTERY_TOTAL_NUMBERS);
+            const drawn = drawUnique(lotteryConfig_1.LOTTERY_NUM_TO_DRAW, lotteryConfig_1.LOTTERY_TOTAL_NUMBERS);
+            const matched = picks.filter((pick) => drawn.includes(pick)).length;
+            return {
+                multiplier: toNumber(settings.lottery.winMultipliers[matched] ?? 0),
+                bucket: String(matched)
+            };
+        }
+        case 'plinko': {
+            let rights = 0;
+            for (let row = 0; row < plinkoConfig_1.PLINKO_ROW_COUNT; row++) {
+                if (Math.random() < 0.5)
+                    rights++;
+            }
+            const multipliers = (0, plinkoConfig_2.normalizePlinkoBinMultipliers)(settings.plinko.binMultipliers);
+            return {
+                multiplier: (0, plinkoConfig_2.getPlinkoMultiplierAtPathIndex)(multipliers, rights),
+                bucket: String(rights)
+            };
+        }
+        case 'goldenJackpot': {
+            const chance = Math.max(1, toNumber(settings.goldenJackpot.oneInChance));
+            const won = Math.floor(Math.random() * chance) === 0;
+            return {
+                multiplier: won ? toNumber(settings.goldenJackpot.winMultiplier) : 0
+            };
+        }
+        default: {
+            const betType = target.replace('roulette:', '');
+            const result = spinRoulette();
+            return {
+                multiplier: (0, calculateRouletteWin_1.calculateRouletteWin)(ROULETTE_REP_BETS[betType], result, settings.roulette.winMultipliers)
+            };
+        }
+    }
+};
+const getTheoreticalRtp = (target, settings) => {
+    if (target.startsWith('roulette:')) {
+        const betType = target.replace('roulette:', '');
+        const rtp = (0, calculateRTP_1.calculateRTP)('roulette', settings.roulette);
+        if (typeof rtp !== 'object')
+            return null;
+        return rtp[betType] ?? null;
+    }
+    const game = target;
+    const rtp = (0, calculateRTP_1.calculateRTP)(game, settings[game]);
+    return typeof rtp === 'number' ? rtp : null;
+};
+const targetLabel = (target) => {
+    if (target.startsWith('roulette:')) {
+        return `Roulette · ${target.replace('roulette:', '')}`;
+    }
+    const labels = {
+        dice: 'Dice',
+        coinflip: 'Coin flip',
+        slots: 'Slots',
+        lottery: 'Lottery',
+        plinko: 'Plinko',
+        goldenJackpot: 'Golden jackpot'
+    };
+    return labels[target];
+};
+async function runMonteCarloSimulation(target, settings, iterations, onProgress, chunkSize = 25000) {
+    const started = performance.now();
+    let totalMultiplier = 0;
+    const distribution = {};
+    let completed = 0;
+    while (completed < iterations) {
+        const batch = Math.min(chunkSize, iterations - completed);
+        for (let i = 0; i < batch; i++) {
+            const round = simulateRound(target, settings);
+            totalMultiplier += round.multiplier;
+            if (round.bucket) {
+                distribution[round.bucket] = (distribution[round.bucket] ?? 0) + 1;
+            }
+        }
+        completed += batch;
+        onProgress?.(completed, iterations);
+        await (0, yieldToEventLoop_1.yieldToEventLoop)();
+    }
+    const empiricalRtp = (totalMultiplier / iterations) * 100;
+    const theoreticalRtp = getTheoreticalRtp(target, settings);
+    const delta = theoreticalRtp == null ? null : empiricalRtp - theoreticalRtp;
+    return {
+        target,
+        label: targetLabel(target),
+        iterations,
+        theoreticalRtp,
+        empiricalRtp,
+        delta,
+        elapsedMs: Math.round(performance.now() - started),
+        distribution: Object.keys(distribution).length > 0 ? distribution : undefined
+    };
+}
+async function runAllMonteCarloSimulations(settings, iterations, onProgress) {
+    const results = [];
+    const total = exports.MONTE_CARLO_TARGETS.length;
+    for (let index = 0; index < exports.MONTE_CARLO_TARGETS.length; index++) {
+        const target = exports.MONTE_CARLO_TARGETS[index];
+        const result = await runMonteCarloSimulation(target, settings, iterations, (completed, targetIterations) => {
+            onProgress?.(index + completed / targetIterations, total);
+        });
+        results.push(result);
+    }
+    onProgress?.(total, total);
+    return results;
+}

package/dist/dev/devAccess.d.ts

@@ -0,0 +1,5 @@
+/** Discord guild IDs where dev tooling is enabled for all guild members. */
+export declare const DEV_GUILDS: string[];
+/** Discord user IDs allowed to use dev tooling outside dev guilds. */
+export declare const DEV_USERS: string[];
+export declare function hasDevAccess(userId: string, guildId: string | null | undefined): boolean;

package/dist/dev/devAccess.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEV_USERS = exports.DEV_GUILDS = void 0;
+exports.hasDevAccess = hasDevAccess;
+/** Discord guild IDs where dev tooling is enabled for all guild members. */
+exports.DEV_GUILDS = ['1298805664654561340'];
+/** Discord user IDs allowed to use dev tooling outside dev guilds. */
+exports.DEV_USERS = [];
+function hasDevAccess(userId, guildId) {
+    if (guildId && exports.DEV_GUILDS.includes(guildId)) {
+        return true;
+    }
+    return exports.DEV_USERS.includes(userId);
+}

package/dist/dev/index.d.ts

@@ -0,0 +1,4 @@
+export * from './devAccess';
+export * from './bonusStressTest';
+export * from './casinoMonteCarlo';
+export * from './yieldToEventLoop';

package/dist/dev/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./devAccess"), exports);
+__exportStar(require("./bonusStressTest"), exports);
+__exportStar(require("./casinoMonteCarlo"), exports);
+__exportStar(require("./yieldToEventLoop"), exports);

package/dist/dev/yieldToEventLoop.d.ts

@@ -0,0 +1 @@
+export declare const yieldToEventLoop: () => Promise<void>;

package/dist/dev/yieldToEventLoop.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yieldToEventLoop = void 0;
+const yieldToEventLoop = () => new Promise((resolve) => {
+    setTimeout(resolve, 0);
+});
+exports.yieldToEventLoop = yieldToEventLoop;

package/dist/guild/guildConfiguration.mongoose.d.ts

@@ -81,6 +81,15 @@ export declare const GuildConfigurationSchema: Schema<TGuildConfiguration, impor
     }, "id"> & {
         id: string;
     }> | undefined;
+    bannedRoleId?: import("mongoose").SchemaDefinitionProperty<string, TGuildConfiguration, import("mongoose").Document<unknown, {}, TGuildConfiguration, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TGuildConfiguration & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
     casinoSettings?: import("mongoose").SchemaDefinitionProperty<{
         dice: {
             winMultiplier: number;

package/dist/guild/guildConfiguration.mongoose.js

@@ -53,6 +53,10 @@ exports.GuildConfigurationSchema = new mongoose_1.Schema({
         type: String,
         default: ''
     },
+    bannedRoleId: {
+        type: String,
+        default: ''
+    },
     casinoSettings: {
         type: mongoose_1.Schema.Types.Mixed,
         default: defaultConfig_1.defaultCasinoSettings

package/dist/guild/schemas/guild.forms.d.ts

@@ -19,6 +19,7 @@ export declare const channelsFormSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const managerRoleFormSchema: z.ZodObject<{
     managerRoleId: z.ZodString;
+    bannedRoleId: z.ZodString;
 }, z.core.$strip>;
 export declare const globalSettingsFormSchema: z.ZodObject<{
     disableRegistrations: z.ZodBoolean;

package/dist/guild/schemas/guild.forms.js

@@ -17,7 +17,8 @@ exports.channelsFormSchema = zod_1.default.object({
     raffle: raffle_forms_1.raffleChannelsFormSchema
 });
 exports.managerRoleFormSchema = zod_1.default.object({
-    managerRoleId: zod_1.default.string()
+    managerRoleId: zod_1.default.string(),
+    bannedRoleId: zod_1.default.string()
 });
 exports.globalSettingsFormSchema = zod_1.default.object({
     disableRegistrations: zod_1.default.boolean(),

package/dist/guild/types/guildConfiguration.d.ts

@@ -19,6 +19,7 @@ export type TGuildConfiguration = {
         logs: string;
     };
     managerRoleId: string;
+    bannedRoleId: string;
     casinoSettings: typeof defaultCasinoSettings;
     vipSettings: {
         roleOwnerId: string;

package/dist/transactions/constants/staffAudit.d.ts

@@ -8,7 +8,10 @@ export declare const STAFF_ADMIN_ACTIONS: {
     readonly PREDICTION_PAYOUT: "prediction-payout";
     readonly PREDICTION_CANCEL: "prediction-cancel";
     readonly ATM_REJECT: "atm-reject";
+    readonly USER_BAN: "user-ban";
+    readonly USER_UNBAN: "user-unban";
+    readonly USER_NOTE: "user-note";
 };
 export type StaffAdminAction = (typeof STAFF_ADMIN_ACTIONS)[keyof typeof STAFF_ADMIN_ACTIONS];
-export declare const STAFF_ACTION_CATEGORIES: readonly ["balance", "atm", "vip", "raffle", "prediction"];
+export declare const STAFF_ACTION_CATEGORIES: readonly ["balance", "atm", "vip", "raffle", "prediction", "user"];
 export type StaffActionCategory = (typeof STAFF_ACTION_CATEGORIES)[number];

package/dist/transactions/constants/staffAudit.js

@@ -10,12 +10,16 @@ exports.STAFF_ADMIN_ACTIONS = {
     PREDICTION_END: 'prediction-end',
     PREDICTION_PAYOUT: 'prediction-payout',
     PREDICTION_CANCEL: 'prediction-cancel',
-    ATM_REJECT: 'atm-reject'
+    ATM_REJECT: 'atm-reject',
+    USER_BAN: 'user-ban',
+    USER_UNBAN: 'user-unban',
+    USER_NOTE: 'user-note'
 };
 exports.STAFF_ACTION_CATEGORIES = [
     'balance',
     'atm',
     'vip',
     'raffle',
-    'prediction'
+    'prediction',
+    'user'
 ];

package/dist/user/index.d.ts

@@ -1 +1,2 @@
 export * from './types/user';
+export * from './utils/userModeration';

package/dist/user/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types/user"), exports);
+__exportStar(require("./utils/userModeration"), exports);

package/dist/user/types/user.d.ts

@@ -1,3 +1,15 @@
+export type TUserStaffNote = {
+    text: string;
+    authorId: string;
+    createdAt: Date;
+};
+export type TUserBanHistoryEntry = {
+    bannedAt: Date;
+    bannedBy: string;
+    unbannedAt: Date | null;
+    unbannedBy: string | null;
+    reason?: string;
+};
 export type TUser = {
     userId: string;
     guildId: string;
@@ -6,6 +18,11 @@ export type TUser = {
     lockedBalance: number;
     lastDailyClaim: Date | null;
     dailyStreak: number;
+    banned: boolean;
+    bannedAt: Date | null;
+    bannedBy: string | null;
+    banHistory: TUserBanHistoryEntry[];
+    staffNotes: TUserStaffNote[];
     createdAt: Date;
     updatedAt: Date;
 };

package/dist/user/user.mongoose.d.ts

@@ -72,6 +72,51 @@ export declare const UserSchema: Schema<TUser, import("mongoose").Model<TUser, a
     }, "id"> & {
         id: string;
     }> | undefined;
+    banned?: import("mongoose").SchemaDefinitionProperty<boolean, TUser, import("mongoose").Document<unknown, {}, TUser, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TUser & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    bannedAt?: import("mongoose").SchemaDefinitionProperty<Date | null, TUser, import("mongoose").Document<unknown, {}, TUser, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TUser & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    bannedBy?: import("mongoose").SchemaDefinitionProperty<string | null, TUser, import("mongoose").Document<unknown, {}, TUser, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TUser & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    banHistory?: import("mongoose").SchemaDefinitionProperty<import("./types/user").TUserBanHistoryEntry[], TUser, import("mongoose").Document<unknown, {}, TUser, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TUser & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    staffNotes?: import("mongoose").SchemaDefinitionProperty<import("./types/user").TUserStaffNote[], TUser, import("mongoose").Document<unknown, {}, TUser, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TUser & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
     createdAt?: import("mongoose").SchemaDefinitionProperty<Date, TUser, import("mongoose").Document<unknown, {}, TUser, {
         id: string;
     }, import("mongoose").DefaultSchemaOptions> & Omit<TUser & {

package/dist/user/user.mongoose.js

@@ -2,6 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserSchema = void 0;
 const mongoose_1 = require("mongoose");
+const UserStaffNoteSchema = new mongoose_1.Schema({
+    text: { type: String, required: true },
+    authorId: { type: String, required: true },
+    createdAt: { type: Date, required: true }
+}, { _id: false });
+const UserBanHistoryEntrySchema = new mongoose_1.Schema({
+    bannedAt: { type: Date, required: true },
+    bannedBy: { type: String, required: true },
+    unbannedAt: { type: Date, default: null },
+    unbannedBy: { type: String, default: null },
+    reason: { type: String }
+}, { _id: false });
 exports.UserSchema = new mongoose_1.Schema({
     userId: { type: String, required: true },
     guildId: { type: String, required: true },
@@ -9,6 +21,11 @@ exports.UserSchema = new mongoose_1.Schema({
     bonusBalance: { type: Number, default: 0 }, // BONUS (non-withdrawable)
     lockedBalance: { type: Number, default: 0 }, // ONLY for in-flight bets
     lastDailyClaim: { type: Date, default: null },
-    dailyStreak: { type: Number, default: 0 }
+    dailyStreak: { type: Number, default: 0 },
+    banned: { type: Boolean, default: false },
+    bannedAt: { type: Date, default: null },
+    bannedBy: { type: String, default: null },
+    banHistory: { type: [UserBanHistoryEntrySchema], default: [] },
+    staffNotes: { type: [UserStaffNoteSchema], default: [] }
 }, { timestamps: true });
 exports.UserSchema.index({ userId: 1, guildId: 1 }, { unique: true });

package/dist/user/utils/userModeration.d.ts

@@ -0,0 +1,16 @@
+import type { TUser, TUserBanHistoryEntry, TUserStaffNote } from '../types/user';
+export declare const USER_BANNED_ERROR = "USER_BANNED";
+export declare const USER_BANNED_MESSAGE = "Your account is restricted. Contact server staff.";
+export declare function isUserBanned(user: Pick<TUser, 'banned'>): boolean;
+export declare function normalizeStaffNote(text: string): string | null;
+export declare function appendStaffNote(notes: TUserStaffNote[], entry: TUserStaffNote, maxNotes?: number): TUserStaffNote[];
+export declare function startBanHistoryEntry({ history, bannedBy, reason, maxEntries }: {
+    history: TUserBanHistoryEntry[];
+    bannedBy: string;
+    reason?: string;
+    maxEntries?: number;
+}): TUserBanHistoryEntry[];
+export declare function closeLatestBanHistoryEntry({ history, unbannedBy }: {
+    history: TUserBanHistoryEntry[];
+    unbannedBy: string;
+}): TUserBanHistoryEntry[];

package/dist/user/utils/userModeration.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USER_BANNED_MESSAGE = exports.USER_BANNED_ERROR = void 0;
+exports.isUserBanned = isUserBanned;
+exports.normalizeStaffNote = normalizeStaffNote;
+exports.appendStaffNote = appendStaffNote;
+exports.startBanHistoryEntry = startBanHistoryEntry;
+exports.closeLatestBanHistoryEntry = closeLatestBanHistoryEntry;
+exports.USER_BANNED_ERROR = 'USER_BANNED';
+exports.USER_BANNED_MESSAGE = 'Your account is restricted. Contact server staff.';
+function isUserBanned(user) {
+    return Boolean(user.banned);
+}
+function normalizeStaffNote(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return null;
+    return trimmed.slice(0, 500);
+}
+function appendStaffNote(notes, entry, maxNotes = 50) {
+    return [entry, ...notes].slice(0, maxNotes);
+}
+function startBanHistoryEntry({ history, bannedBy, reason, maxEntries = 50 }) {
+    const entry = {
+        bannedAt: new Date(),
+        bannedBy,
+        unbannedAt: null,
+        unbannedBy: null,
+        ...(reason ? { reason } : {})
+    };
+    return [entry, ...history].slice(0, maxEntries);
+}
+function closeLatestBanHistoryEntry({ history, unbannedBy }) {
+    const openIndex = history.findIndex((entry) => entry.unbannedAt === null);
+    if (openIndex === -1)
+        return history;
+    const updated = [...history];
+    updated[openIndex] = {
+        ...updated[openIndex],
+        unbannedAt: new Date(),
+        unbannedBy
+    };
+    return updated;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gambling-bot-shared",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "license": "MIT",
   "type": "commonjs",
   "repository": {
@@ -58,6 +58,10 @@
     "./mongoose": {
       "types": "./dist/mongoose/index.d.ts",
       "default": "./dist/mongoose/index.js"
+    },
+    "./dev": {
+      "types": "./dist/dev/index.d.ts",
+      "default": "./dist/dev/index.js"
     }
   },
   "scripts": {