bot freezing solved and difficulty levels reduced to the original three
This commit is contained in:
@@ -5,7 +5,7 @@ Built from `templates/game-bundle` (the Tic-Tac-Toe sample) and adapted to this
|
||||
monorepo: deterministic TypeScript game server on the `@3miz/game-server-sdk`
|
||||
(contract 40) plus a sandboxed iframe client (contract 43).
|
||||
|
||||
- `game_id`: `chess`, version `1.0.0`
|
||||
- `game_id`: `chess`, version `1.1.0`
|
||||
- Lafayette orientation: the board is shown from your own side (white sees `a8`
|
||||
top-left, black sees `h1` top-left); `a1` is always dark.
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "chess-client",
|
||||
"version": "1.0.0",
|
||||
"version": "1.3.0",
|
||||
"private": true,
|
||||
"type": "module",
|
||||
"scripts": {
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
"bundle_format": 1,
|
||||
"kind": "source",
|
||||
"game_id": "chess",
|
||||
"version": "1.0.0",
|
||||
"version": "1.3.0",
|
||||
"server": { "entry": "server/main.ts" },
|
||||
"client": { "entry": "index.html" },
|
||||
"catalog": {
|
||||
|
||||
+3
-3
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"manifest_version": 1,
|
||||
"game_id": "chess",
|
||||
"version": "1.0.0",
|
||||
"version": "1.3.0",
|
||||
"protocol": "socketio",
|
||||
"protocol_version": 1,
|
||||
"title": {
|
||||
@@ -81,14 +81,14 @@
|
||||
],
|
||||
"achievements": [],
|
||||
"client": {
|
||||
"entry": "https://g.3miz.ir/chess/1.0.0/index.html",
|
||||
"entry": "https://g.3miz.ir/chess/1.3.0/index.html",
|
||||
"integrity": "sha384-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
|
||||
"aspect": "1:1",
|
||||
"min_width_px": 320,
|
||||
"supports_portrait": true
|
||||
},
|
||||
"server": {
|
||||
"image": "registry.3miz.ir/games/chess:1.0.0",
|
||||
"image": "registry.3miz.ir/games/chess:1.3.0",
|
||||
"max_tables_per_instance": 500,
|
||||
"checkpoint_every_inputs": 20,
|
||||
"snapshot_every_messages": 50,
|
||||
|
||||
+123
-115
@@ -1,11 +1,12 @@
|
||||
/**
|
||||
* Advanced Chess AI Engine — deterministic minimax with alpha-beta pruning,
|
||||
* Chess AI Engine — deterministic negamax with alpha-beta pruning,
|
||||
* piece-square tables (PST), MVV-LVA move ordering, and quiescence search.
|
||||
* Differentiated depth and strategic profiles for Easy, Basic, and Hard.
|
||||
*/
|
||||
|
||||
import type { Rng } from "@3miz/game-server-sdk";
|
||||
import {
|
||||
isValidMove,
|
||||
isMoveLegalFor,
|
||||
isKingInCheck,
|
||||
isCheckmate,
|
||||
type State,
|
||||
@@ -104,8 +105,8 @@ function getPstScore(type: PieceType, color: "w" | "b", sq: number): number {
|
||||
}
|
||||
|
||||
/**
|
||||
* Static position evaluation from the perspective of white.
|
||||
* Returns a score in centipawns: positive favors White, negative favors Black.
|
||||
* Static position evaluation from White's perspective.
|
||||
* Positive favors White, negative favors Black.
|
||||
*/
|
||||
function evaluateStatic(s: State): number {
|
||||
let material = 0;
|
||||
@@ -115,17 +116,15 @@ function evaluateStatic(s: State): number {
|
||||
const p = s.board[sq];
|
||||
if (!p) continue;
|
||||
const val = PIECE_VALUES[p.type] ?? 0;
|
||||
const pst = getPstScore(p.type, p.color, sq);
|
||||
if (p.color === "w") {
|
||||
material += val;
|
||||
positional += pst;
|
||||
positional += getPstScore(p.type, p.color, sq);
|
||||
} else {
|
||||
material -= val;
|
||||
positional -= pst;
|
||||
positional -= getPstScore(p.type, p.color, sq);
|
||||
}
|
||||
}
|
||||
|
||||
// King check penalties / bonuses
|
||||
if (isKingInCheck(s, "w")) positional -= 40;
|
||||
if (isKingInCheck(s, "b")) positional += 40;
|
||||
|
||||
@@ -232,10 +231,10 @@ function unmakeMove(s: State, undo: UndoRecord) {
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate all legal moves for a given seat, ordered using MVV-LVA heuristics
|
||||
* Generate all legal moves for a given color, ordered using MVV-LVA heuristics.
|
||||
* Uses isMoveLegalFor so it is independent of whose turn it currently is in the root state.
|
||||
*/
|
||||
function generateOrderedMoves(s: State, seat: number): MoveCandidate[] {
|
||||
const color = s.players[seat].color;
|
||||
function generateOrderedMoves(s: State, color: "w" | "b", prioritizeCaptures = true): MoveCandidate[] {
|
||||
const moves: MoveCandidate[] = [];
|
||||
|
||||
for (let from = 0; from < 64; from++) {
|
||||
@@ -243,50 +242,52 @@ function generateOrderedMoves(s: State, seat: number): MoveCandidate[] {
|
||||
if (!p || p.color !== color) continue;
|
||||
|
||||
for (let to = 0; to < 64; to++) {
|
||||
if (isValidMove(s, from, to, seat)) {
|
||||
if (isMoveLegalFor(s, from, to, color)) {
|
||||
const target = s.board[to];
|
||||
let moveScore = 0;
|
||||
|
||||
// MVV-LVA: Most Valuable Victim - Least Valuable Attacker
|
||||
if (target) {
|
||||
moveScore = 1000 + (PIECE_VALUES[target.type] ?? 0) * 10 - (PIECE_VALUES[p.type] ?? 0);
|
||||
} else if (to === s.ep && p.type === "p") {
|
||||
// En passant capture
|
||||
moveScore = 1000 + 100 * 10 - 100;
|
||||
if (prioritizeCaptures) {
|
||||
// MVV-LVA: Most Valuable Victim - Least Valuable Attacker
|
||||
if (target) {
|
||||
moveScore = 1000 + (PIECE_VALUES[target.type] ?? 0) * 10 - (PIECE_VALUES[p.type] ?? 0);
|
||||
} else if (to === s.ep && p.type === "p") {
|
||||
moveScore = 1000 + 100 * 10 - 100;
|
||||
}
|
||||
|
||||
// Promotion bonus
|
||||
const lastRank = color === "w" ? 7 : 0;
|
||||
const isPromo = p.type === "p" && Math.floor(to / 8) === lastRank;
|
||||
if (isPromo) {
|
||||
moveScore += 900;
|
||||
}
|
||||
|
||||
// Positional gain
|
||||
const pstGain = getPstScore(p.type, color, to) - getPstScore(p.type, color, from);
|
||||
moveScore += pstGain;
|
||||
}
|
||||
|
||||
// Promotion bonus
|
||||
const lastRank = color === "w" ? 7 : 0;
|
||||
const isPromo = p.type === "p" && Math.floor(to / 8) === lastRank;
|
||||
if (isPromo) {
|
||||
moveScore += 900;
|
||||
}
|
||||
|
||||
// Positional gain
|
||||
const pstGain = getPstScore(p.type, color, to) - getPstScore(p.type, color, from);
|
||||
moveScore += pstGain;
|
||||
|
||||
const isPawnPromo = p.type === "p" && Math.floor(to / 8) === (color === "w" ? 7 : 0);
|
||||
moves.push({
|
||||
from,
|
||||
to,
|
||||
promotion: isPromo ? "q" : undefined,
|
||||
promotion: isPawnPromo ? "q" : undefined,
|
||||
score: moveScore,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Sort moves in descending order of predicted potential
|
||||
moves.sort((a, b) => b.score - a.score);
|
||||
if (prioritizeCaptures) {
|
||||
moves.sort((a, b) => b.score - a.score);
|
||||
}
|
||||
return moves;
|
||||
}
|
||||
|
||||
/**
|
||||
* Quiescence search to avoid horizon effect on loud capture positions
|
||||
* Quiescence search for loud capture sequences
|
||||
*/
|
||||
function quiescence(
|
||||
s: State,
|
||||
seat: number,
|
||||
alpha: number,
|
||||
beta: number,
|
||||
color: "w" | "b",
|
||||
@@ -297,12 +298,14 @@ function quiescence(
|
||||
if (standPat > alpha) alpha = standPat;
|
||||
if (depthLimit <= 0) return alpha;
|
||||
|
||||
const moves = generateOrderedMoves(s, seat).filter((m) => s.board[m.to] !== null || m.to === s.ep);
|
||||
const oppSeat = 1 - seat;
|
||||
const oppColor = color === "w" ? "b" : "w";
|
||||
const moves = generateOrderedMoves(s, color, true).filter(
|
||||
(m) => s.board[m.to] !== null || m.to === s.ep
|
||||
);
|
||||
|
||||
for (const move of moves) {
|
||||
const undo = makeMove(s, move.from, move.to, move.promotion);
|
||||
const score = -quiescence(s, oppSeat, -beta, -alpha, color === "w" ? "b" : "w", depthLimit - 1);
|
||||
const score = -quiescence(s, -beta, -alpha, oppColor, depthLimit - 1);
|
||||
unmakeMove(s, undo);
|
||||
|
||||
if (score >= beta) return beta;
|
||||
@@ -312,66 +315,50 @@ function quiescence(
|
||||
}
|
||||
|
||||
/**
|
||||
* Minimax with Alpha-Beta Pruning
|
||||
* Negamax with Alpha-Beta Pruning
|
||||
*/
|
||||
function alphaBeta(
|
||||
function negamax(
|
||||
s: State,
|
||||
depth: number,
|
||||
alpha: number,
|
||||
beta: number,
|
||||
seat: number,
|
||||
botColor: "w" | "b",
|
||||
ply: number
|
||||
color: "w" | "b",
|
||||
ply: number,
|
||||
quiesceDepth: number
|
||||
): number {
|
||||
const currentColor = s.players[seat].color;
|
||||
const isBotTurn = currentColor === botColor;
|
||||
const oppColor = color === "w" ? "b" : "w";
|
||||
|
||||
if (isCheckmate(s, currentColor)) {
|
||||
// Checkmate penalty/reward scaled by ply to prefer faster mates
|
||||
return isBotTurn ? -100000 + ply : 100000 - ply;
|
||||
if (isCheckmate(s, color)) {
|
||||
// Current side to move is mated -> large penalty scaled by distance to root
|
||||
return -100000 + ply;
|
||||
}
|
||||
|
||||
if (depth <= 0) {
|
||||
return quiescence(s, seat, alpha, beta, currentColor, 2);
|
||||
if (quiesceDepth > 0) {
|
||||
return quiescence(s, alpha, beta, color, quiesceDepth);
|
||||
}
|
||||
return (color === "w" ? 1 : -1) * evaluateStatic(s);
|
||||
}
|
||||
|
||||
const moves = generateOrderedMoves(s, seat);
|
||||
const moves = generateOrderedMoves(s, color, true);
|
||||
if (moves.length === 0) {
|
||||
// Stalemate is a draw (0)
|
||||
return 0;
|
||||
}
|
||||
|
||||
const oppSeat = 1 - seat;
|
||||
for (const move of moves) {
|
||||
const undo = makeMove(s, move.from, move.to, move.promotion);
|
||||
const score = -negamax(s, depth - 1, -beta, -alpha, oppColor, ply + 1, quiesceDepth);
|
||||
unmakeMove(s, undo);
|
||||
|
||||
if (isBotTurn) {
|
||||
let maxEval = -Infinity;
|
||||
for (const move of moves) {
|
||||
const undo = makeMove(s, move.from, move.to, move.promotion);
|
||||
const evalScore = alphaBeta(s, depth - 1, alpha, beta, oppSeat, botColor, ply + 1);
|
||||
unmakeMove(s, undo);
|
||||
|
||||
maxEval = Math.max(maxEval, evalScore);
|
||||
alpha = Math.max(alpha, evalScore);
|
||||
if (beta <= alpha) break; // Beta cutoff
|
||||
}
|
||||
return maxEval;
|
||||
} else {
|
||||
let minEval = Infinity;
|
||||
for (const move of moves) {
|
||||
const undo = makeMove(s, move.from, move.to, move.promotion);
|
||||
const evalScore = alphaBeta(s, depth - 1, alpha, beta, oppSeat, botColor, ply + 1);
|
||||
unmakeMove(s, undo);
|
||||
|
||||
minEval = Math.min(minEval, evalScore);
|
||||
beta = Math.min(beta, evalScore);
|
||||
if (beta <= alpha) break; // Alpha cutoff
|
||||
}
|
||||
return minEval;
|
||||
if (score >= beta) return beta;
|
||||
if (score > alpha) alpha = score;
|
||||
}
|
||||
return alpha;
|
||||
}
|
||||
|
||||
/**
|
||||
* Standard book openings for classic initial turns
|
||||
* Standard opening book moves
|
||||
*/
|
||||
const OPENING_BOOK_WHITE = [
|
||||
{ from: 12, to: 28 }, // e2 -> e4
|
||||
@@ -390,12 +377,12 @@ const OPENING_BOOK_BLACK: Record<string, { from: number; to: number }[]> = {
|
||||
// Against d2-d4:
|
||||
"27": [
|
||||
{ from: 51, to: 35 }, // d7 -> d5
|
||||
{ from: 62, to: 45 }, // g8 -> f6 (Indian Defense)
|
||||
{ from: 62, to: 45 }, // g8 -> f6 (Indian)
|
||||
],
|
||||
};
|
||||
|
||||
/**
|
||||
* Main bot entry point called by the game server
|
||||
* Main bot decision engine
|
||||
*/
|
||||
export function decideBot(
|
||||
s: State,
|
||||
@@ -406,8 +393,8 @@ export function decideBot(
|
||||
if (!player) return null;
|
||||
|
||||
const color = player.color;
|
||||
const level = player.level || "basic";
|
||||
const legalMoves = generateOrderedMoves(s, seat);
|
||||
const rawLevel = (player.level || "").toLowerCase().trim();
|
||||
const legalMoves = generateOrderedMoves(s, color, true);
|
||||
|
||||
if (legalMoves.length === 0) return null;
|
||||
if (legalMoves.length === 1) {
|
||||
@@ -418,52 +405,74 @@ export function decideBot(
|
||||
};
|
||||
}
|
||||
|
||||
// 1. Opening book selection on the first 2 moves of the game
|
||||
if (s.moves_played === 0 && color === "w") {
|
||||
const bookPick = OPENING_BOOK_WHITE[rng.int(OPENING_BOOK_WHITE.length)];
|
||||
if (isValidMove(s, bookPick.from, bookPick.to, seat)) {
|
||||
return { fromIdx: bookPick.from, toIdx: bookPick.to };
|
||||
}
|
||||
} else if (s.moves_played === 1 && color === "b") {
|
||||
// Find what white played
|
||||
const whitePawnOnE4 = s.board[28]?.type === "p" && s.board[28]?.color === "w";
|
||||
const whitePawnOnD4 = s.board[27]?.type === "p" && s.board[27]?.color === "w";
|
||||
const candidates = whitePawnOnE4
|
||||
? OPENING_BOOK_BLACK["28"]
|
||||
: (whitePawnOnD4 ? OPENING_BOOK_BLACK["27"] : null);
|
||||
// Difficulty profiles: easy (آسون), basic (معمولی), hard (سخت)
|
||||
let searchDepth = 2;
|
||||
let quiesceDepth = 1;
|
||||
let noiseRange = 0;
|
||||
let useOpeningBook = true;
|
||||
let blunderChancePercent = 0;
|
||||
|
||||
if (candidates) {
|
||||
const bookPick = candidates[rng.int(candidates.length)];
|
||||
if (isValidMove(s, bookPick.from, bookPick.to, seat)) {
|
||||
return { fromIdx: bookPick.from, toIdx: bookPick.to };
|
||||
if (rawLevel === "hard" || rawLevel === "expert" || rawLevel === "master") {
|
||||
// Hard (سخت): Depth 3 + 2 plies quiescence. Sharp, tactical, 0 blunders (~160ms).
|
||||
searchDepth = 3;
|
||||
quiesceDepth = 2;
|
||||
noiseRange = 0;
|
||||
useOpeningBook = true;
|
||||
blunderChancePercent = 0;
|
||||
} else if (rawLevel === "basic" || rawLevel === "normal") {
|
||||
// Basic / Normal (معمولی): Depth 2 + 1 ply quiescence. Solid play, small noise (~2ms).
|
||||
searchDepth = 2;
|
||||
quiesceDepth = 1;
|
||||
noiseRange = 10;
|
||||
useOpeningBook = true;
|
||||
blunderChancePercent = 5;
|
||||
} else {
|
||||
// Easy (آسون): Depth 1, no quiescence, higher noise & 25% casual blunders (~1ms).
|
||||
searchDepth = 1;
|
||||
quiesceDepth = 0;
|
||||
noiseRange = 50;
|
||||
useOpeningBook = false;
|
||||
blunderChancePercent = 25;
|
||||
}
|
||||
|
||||
// 1. Opening book selection on the first 2 moves of the game (if enabled)
|
||||
if (useOpeningBook) {
|
||||
if (s.moves_played === 0 && color === "w") {
|
||||
const pick = OPENING_BOOK_WHITE[rng.int(OPENING_BOOK_WHITE.length)];
|
||||
if (isMoveLegalFor(s, pick.from, pick.to, color)) {
|
||||
return { fromIdx: pick.from, toIdx: pick.to };
|
||||
}
|
||||
} else if (s.moves_played === 1 && color === "b") {
|
||||
const cand = s.board[28]?.type === "p" && s.board[28]?.color === "w"
|
||||
? OPENING_BOOK_BLACK["28"]
|
||||
: (s.board[27]?.type === "p" && s.board[27]?.color === "w" ? OPENING_BOOK_BLACK["27"] : null);
|
||||
|
||||
if (cand) {
|
||||
const pick = cand[rng.int(cand.length)];
|
||||
if (isMoveLegalFor(s, pick.from, pick.to, color)) {
|
||||
return { fromIdx: pick.from, toIdx: pick.to };
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 2. Search depth based on configured difficulty level
|
||||
let searchDepth = 2;
|
||||
let noiseRange = 0;
|
||||
|
||||
if (level === "hard") {
|
||||
searchDepth = 3;
|
||||
noiseRange = 0;
|
||||
} else if (level === "easy") {
|
||||
searchDepth = 1;
|
||||
noiseRange = 35; // Casual noise to allow human-like minor inaccuracies
|
||||
} else {
|
||||
// "basic"
|
||||
searchDepth = 2;
|
||||
noiseRange = 8;
|
||||
// 2. Beginner blunder mechanism: integer-based check using rng.int(100) (never rng.float)
|
||||
if (blunderChancePercent > 0 && rng.int(100) < blunderChancePercent) {
|
||||
const nonCaptures = legalMoves.filter((m) => s.board[m.to] === null);
|
||||
if (nonCaptures.length > 0) {
|
||||
const pick = nonCaptures[rng.int(nonCaptures.length)];
|
||||
return { fromIdx: pick.from, toIdx: pick.to, promotion: pick.promotion };
|
||||
}
|
||||
}
|
||||
|
||||
// 3. Minimax evaluation over all candidate root moves
|
||||
const oppSeat = 1 - seat;
|
||||
// 3. Negamax evaluation over all candidate root moves
|
||||
const oppColor = color === "w" ? "b" : "w";
|
||||
let bestScore = -Infinity;
|
||||
let bestMoves: MoveCandidate[] = [];
|
||||
|
||||
for (const move of legalMoves) {
|
||||
const undo = makeMove(s, move.from, move.to, move.promotion);
|
||||
let evalScore = alphaBeta(s, searchDepth - 1, -Infinity, Infinity, oppSeat, color, 1);
|
||||
let evalScore = -negamax(s, searchDepth - 1, -Infinity, Infinity, oppColor, 1, quiesceDepth);
|
||||
unmakeMove(s, undo);
|
||||
|
||||
// Apply difficulty noise
|
||||
@@ -480,8 +489,7 @@ export function decideBot(
|
||||
}
|
||||
}
|
||||
|
||||
// Tie-breaker using deterministic rng
|
||||
const selected = bestMoves[rng.int(bestMoves.length)] || legalMoves[0];
|
||||
const selected = bestMoves.length > 0 ? bestMoves[rng.int(bestMoves.length)] : legalMoves[0];
|
||||
|
||||
return {
|
||||
fromIdx: selected.from,
|
||||
|
||||
+18
-4
@@ -27,6 +27,7 @@ export interface State {
|
||||
timer_id: string | null;
|
||||
deadline: number | null;
|
||||
bot_timer: string | null;
|
||||
bot_n: number;
|
||||
moves_played: number;
|
||||
captures: number;
|
||||
// Castling rights decay as kings/rooks move or corner rooks are captured.
|
||||
@@ -234,7 +235,7 @@ export function isValidMove(state: State, from: number, to: number, seat: number
|
||||
}
|
||||
|
||||
// Geometry + king safety, without any turn/phase/seat checks.
|
||||
function isMoveLegalFor(s: State, from: number, to: number, moverColor: Color): boolean {
|
||||
export function isMoveLegalFor(s: State, from: number, to: number, moverColor: Color): boolean {
|
||||
if (!pieceCanMove(s, from, to, moverColor)) return false;
|
||||
return !wouldLeaveInCheck(s, from, to, moverColor);
|
||||
}
|
||||
@@ -297,10 +298,19 @@ function setDeadline(s: State, t: { now: number; setTimer(id: string, due: numbe
|
||||
t.setTimer(s.timer_id, s.deadline);
|
||||
}
|
||||
|
||||
const pendingBot = (s: State) => s.phase === "play" && !!s.players[s.turn]?.bot && !s.players[s.turn].left;
|
||||
|
||||
function scheduleBot(s: State, t: { now: number; setTimer(id: string, due: number): void; clearTimer?(id: string): void }) {
|
||||
const p = s.players[s.turn];
|
||||
if (s.phase !== "play" || !p.bot || s.bot_timer) return;
|
||||
s.bot_timer = `bot-${s.timer_n}`;
|
||||
if (!pendingBot(s)) {
|
||||
if (s.bot_timer) {
|
||||
t.clearTimer?.(s.bot_timer);
|
||||
s.bot_timer = null;
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (s.bot_timer) return;
|
||||
s.bot_n += 1;
|
||||
s.bot_timer = `bot-${s.bot_n}`;
|
||||
t.setTimer(s.bot_timer, t.now + 600);
|
||||
}
|
||||
|
||||
@@ -365,6 +375,8 @@ function finish(s: State, ctx: Ctx, winner: number | null, reason: string = "com
|
||||
s.deadline = null;
|
||||
if (s.timer_id) ctx.clearTimer(s.timer_id);
|
||||
s.timer_id = null;
|
||||
if (s.bot_timer) ctx.clearTimer(s.bot_timer);
|
||||
s.bot_timer = null;
|
||||
ctx.finish({
|
||||
reason: reason === "abandoned" ? "abandoned" : "completed",
|
||||
standings: s.players.map((p) => ({
|
||||
@@ -410,6 +422,7 @@ export const chess: GameDef<State> = {
|
||||
timer_id: null,
|
||||
deadline: null,
|
||||
bot_timer: null,
|
||||
bot_n: 0,
|
||||
moves_played: 0,
|
||||
captures: 0,
|
||||
rights: { wk: true, wq: true, bk: true, bq: true },
|
||||
@@ -439,6 +452,7 @@ export const chess: GameDef<State> = {
|
||||
p.user_id = String(input.payload.bot_user_id);
|
||||
p.name = String(input.payload.display?.name ?? "🤖");
|
||||
p.bot = true;
|
||||
if (input.payload.bot_level) p.level = String(input.payload.bot_level);
|
||||
scheduleBot(s, ctx);
|
||||
}
|
||||
return;
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@3miz/chess-server",
|
||||
"version": "1.0.0",
|
||||
"version": "1.3.0",
|
||||
"private": true,
|
||||
"type": "module",
|
||||
"scripts": { "start": "tsx main.ts", "test": "node --test --import tsx ../tests/*.test.ts" },
|
||||
|
||||
Reference in New Issue
Block a user