@datamoc/mw_games 0.19.0 → 0.22.0

package/tools/compress-dist.d.mts

@@ -6,6 +6,8 @@ export interface CompressOptions {
 	brotli?: boolean;
 	/** Also write `.xz` siblings where smaller (default false, needs the system `xz`). */
 	xz?: boolean;
+	/** Files to compress at once (default `compressJobs()`). */
+	jobs?: number;
 }
 
 /**
@@ -25,6 +27,12 @@ export interface CompressRow {
 /** True when the system `xz` binary (LZMA2) is available for the opt-in archive pass. */
 export function hasXz(): boolean;
 
+/**
+ * How many files `compressDist` works on at once: `MWG_COMPRESS_JOBS` when it names
+ * a positive integer, else the machine's own thread count, else 4.
+ */
+export function compressJobs(): number;
+
 /**
  * Writes compressed siblings for the large files in `dir`, *into that same folder*: the
  * originals are left untouched, and each `<file>` gains `<file>.gz`, `<file>.br` and, when

package/tools/compress-dist.mjs

@@ -1,6 +1,8 @@
 import { readFile, writeFile } from 'node:fs/promises';
 import { relative, extname, basename } from 'node:path';
-import { gzipSync, brotliCompressSync, constants } from 'node:zlib';
+import { gzip, brotliCompress, constants } from 'node:zlib';
+import { promisify } from 'node:util';
+import { availableParallelism } from 'node:os';
 import { spawnSync } from 'node:child_process';
 import { walk } from './compile-resources.mjs';
 
@@ -21,6 +23,11 @@ import { walk } from './compile-resources.mjs';
  * a server can negotiate: `gz` stays the fallback.
  *
  * usage: node tools/compress-dist.mjs <dist folder> [--xz] [--no-gzip] [--no-brotli]
+ *
+ * Files compress in parallel over async `zlib` (the libuv threadpool, not worker
+ * threads): one chain per job over a shared queue, defaulting to MWG_COMPRESS_JOBS
+ * when it names a positive integer, else the machine's thread count, else 4. Rows
+ * land by index, so the report keeps walk order no matter who finishes first.
  */
 
 const TEXT_EXTENSIONS = new Set(['.js', '.html', '.css', '.svg', '.json', '.txt', '.map']);
@@ -41,6 +48,26 @@ const ALREADY_COMPRESSED = new Set([
 ]);
 const MIN_BYTES = 1024;
 
+const gzipAsync = promisify(gzip);
+const brotliAsync = promisify(brotliCompress);
+
+/**
+ * How many files `compressDist` works on at once: `MWG_COMPRESS_JOBS` when it names
+ * a positive integer, else the machine's own thread count, else 4. An env knob rather
+ * than a constant so a loaded CI host can turn one build down without editing anything.
+ */
+export function compressJobs() {
+	const raw = Number(process.env.MWG_COMPRESS_JOBS);
+	if (Number.isInteger(raw) && raw > 0) return raw;
+	try {
+		const parallel = availableParallelism();
+		if (Number.isInteger(parallel) && parallel > 0) return parallel;
+	} catch {
+		//a build tool must never fail for lack of a hint about its own host
+	}
+	return 4;
+}
+
 /** true when the system `xz` binary (LZMA2) is available for the opt-in archive pass */
 export function hasXz() {
 	try {
@@ -67,44 +94,63 @@ function compressXz(data) {
  * @param options.gzip write `.gz` siblings (default true)
  * @param options.brotli write `.br` siblings (default true)
  * @param options.xz also write `.xz` siblings where smaller (default false, needs `xz`)
- * @returns one row per file considered, with the sizes actually written
+ * @param options.jobs files to compress at once (default `compressJobs()`)
+ * @returns one row per file considered, with the sizes actually written, in walk order
  */
-export async function compressDist(dir, { gzip = true, brotli = true, xz = false } = {}) {
-	const rows = [];
-	const wantXz = xz && hasXz();
+export async function compressDist(dir, { gzip = true, brotli = true, xz = false, jobs = compressJobs() } = {}) {
+	const candidates = [];
 	for await (const file of walk(dir)) {
 		const ext = extname(file).toLowerCase();
 		if (!TEXT_EXTENSIONS.has(ext) || ALREADY_COMPRESSED.has(ext)) continue;
-		const data = await readFile(file);
-		if (data.length < MIN_BYTES) continue;
-		const name = relative(dir, file);
-		const row = { file: name, raw: data.length, gzip: 0, brotli: 0, xz: 0 };
-		if (gzip) {
-			const zipped = gzipSync(data, { level: 9 });
-			if (zipped.length < data.length) {
-				await writeFile(file + '.gz', zipped);
-				row.gzip = zipped.length;
+		candidates.push(file);
+	}
+	const wantXz = xz && hasXz();
+	const lanes = Math.max(1, Math.min(Math.floor(jobs) || 1, Math.max(candidates.length, 1)));
+	const rows = new Array(candidates.length);
+	let next = 0;
+	await Promise.all(
+		Array.from({ length: lanes }, async () => {
+			for (;;) {
+				const index = next++;
+				if (index >= candidates.length) return;
+				rows[index] = await compressOne(dir, candidates[index], { gzip, brotli, wantXz });
 			}
+		}),
+	);
+	return rows.filter((row) => row !== undefined);
+}
+
+/** gzip and brotli of one file, or undefined when it is too small to bother with */
+async function compressOne(dir, file, { gzip, brotli, wantXz }) {
+	const data = await readFile(file);
+	if (data.length < MIN_BYTES) return undefined;
+	const row = { file: relative(dir, file), raw: data.length, gzip: 0, brotli: 0, xz: 0 };
+	if (gzip) {
+		const zipped = await gzipAsync(data, { level: 9 });
+		if (zipped.length < data.length) {
+			await writeFile(file + '.gz', zipped);
+			row.gzip = zipped.length;
 		}
-		if (brotli) {
-			const squeezed = brotliCompressSync(data, {
-				params: { [constants.BROTLI_PARAM_QUALITY]: 11 },
-			});
-			if (squeezed.length < data.length) {
-				await writeFile(file + '.br', squeezed);
-				row.brotli = squeezed.length;
-			}
+	}
+	if (brotli) {
+		const squeezed = await brotliAsync(data, {
+			params: { [constants.BROTLI_PARAM_QUALITY]: 11 },
+		});
+		if (squeezed.length < data.length) {
+			await writeFile(file + '.br', squeezed);
+			row.brotli = squeezed.length;
 		}
-		if (wantXz) {
-			const archived = compressXz(data);
-			if (archived && archived.length < data.length) {
-				await writeFile(file + '.xz', archived);
-				row.xz = archived.length;
-			}
+	}
+	if (wantXz) {
+		//the opt-in archive pass stays synchronous: xz is a child process either way, and
+		//it sits outside the measured gzip/brotli path this parallelizes
+		const archived = compressXz(data);
+		if (archived && archived.length < data.length) {
+			await writeFile(file + '.xz', archived);
+			row.xz = archived.length;
 		}
-		rows.push(row);
 	}
-	return rows;
+	return row;
 }
 
 const isMain = process.argv[1] && import.meta.url.endsWith(basename(process.argv[1]));

package/tools/play-uci.d.mts

@@ -0,0 +1,26 @@
+import type { ChessMove } from '../src/board/chess.ts';
+import type { OpeningBook } from '../src/board/openings.ts';
+import type { LoadedEnding } from '../src/board/tablebase.ts';
+
+export interface UciSessionOptions {
+	/** plies when `go` names no depth */
+	depth?: number;
+	/** compiled opening book, probed before anything thinks */
+	book?: OpeningBook | null;
+	/** loaded tablebase endings, probed before the search */
+	tables?: Record<string, LoadedEnding>;
+}
+
+export interface UciSession {
+	/** one input line in, zero or more output lines out; never throws */
+	input(line: string): string[];
+}
+
+/** a move in UCI coordinates (`e2e4`, `e7e8q`). */
+export function uciString(move: ChessMove): string;
+
+/**
+ * One stateful UCI conversation over the tournament engine: book, then
+ * tablebase, then `searchTourney`. Feed it input lines, read back output lines.
+ */
+export function createUciSession(options?: UciSessionOptions): UciSession;

package/tools/play-uci.mjs

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+import { readFileSync, readdirSync } from 'node:fs';
+import { join, basename, extname } from 'node:path';
+import { createInterface } from 'node:readline';
+import { applyMove, cloneChess, legalMoves, parseFen, squareName, startingChess } from '../src/board/chess.ts';
+import { parseUciMove, probeBook } from '../src/board/openings.ts';
+import { searchTourney } from '../src/board/tourney.ts';
+import { loadTablebaseEnding, probeTablebase } from '../src/board/tablebase.ts';
+
+/**
+ * A UCI adapter over the tournament engine: `position`/`go` on stdin, `bestmove`
+ * on stdout, the way a GUI expects. Move choice runs book first, then tablebase,
+ * then `searchTourney`, so each layer only pays when the earlier ones miss.
+ *
+ * This is a Node tool, never part of the browser bundle: it reads files and
+ * stdio, which a `file://` page cannot do. `info score` is centipawns from the
+ * side to move's view (documented because GUIs vary); `bestmove 0000` answers
+ * a position with no legal moves, per the UCI convention.
+ *
+ * usage: node tools/play-uci.mjs [--book <book.json>] [--tables <dir>] [--depth N]
+ */
+
+const PROMOTION_LETTER = { queen: 'q', rook: 'r', bishop: 'b', knight: 'n' };
+
+export function uciString(move) {
+	return squareName(move.from) + squareName(move.to) + (move.promotion ? PROMOTION_LETTER[move.promotion] : '');
+}
+
+/**
+ * One stateful conversation: feed it input lines, read back output lines. Pure
+ * except for the injected search, book and tables, so tests drive transcripts
+ * without spawning anything.
+ */
+export function createUciSession(options = {}) {
+	const book = options.book ?? null;
+	const tables = options.tables ?? {};
+	const fallbackDepth = options.depth ?? 4;
+	let state = startingChess();
+	let halfmove = 0;
+
+	const findMove = (token) => {
+		let parsed;
+		try {
+			parsed = parseUciMove(token);
+		} catch {
+			return null;
+		}
+		return (
+			legalMoves(state).find(
+				(move) =>
+					move.from === parsed.from &&
+					move.to === parsed.to &&
+					(parsed.promotion === undefined
+						? move.promotion === undefined
+						: move.promotion === parsed.promotion),
+			) ?? null
+		);
+	};
+
+	const play = (move) => {
+		const target = move.to === state.enPassant && state.board[move.from]?.kind === 'pawn';
+		const capture = target || state.board[move.to] !== null;
+		const pawn = state.board[move.from]?.kind === 'pawn';
+		applyMove(state, move);
+		halfmove = pawn || capture ? 0 : halfmove + 1;
+	};
+
+	const tablebest = () => {
+		const ids = Object.keys(tables);
+		if (!ids.length) return null;
+		let best = null;
+		let complete = true;
+		for (const move of legalMoves(state)) {
+			const next = cloneChess(state);
+			applyMove(next, move);
+			const probe = probeTablebase(tables, next, halfmove);
+			if (!probe) {
+				complete = false;
+				continue;
+			}
+			const score =
+				probe.outcome === 'loss' ? 100000 - probe.dtm : probe.outcome === 'draw' ? 0 : -(100000 - probe.dtm);
+			if (best === null || score > best.score) best = { move, score };
+		}
+		//a forced mate beats any unprobed capture line; otherwise every successor
+		//must probe, or the search (which sees captures) takes the move instead
+		if (best !== null && (best.score > 90000 || complete)) return best;
+		return null;
+	};
+
+	const go = (args) => {
+		let depth = fallbackDepth;
+		let maxNodes;
+		let timeMs;
+		for (let i = 0; i < args.length; i++) {
+			if (args[i] === 'depth' && args[i + 1] !== undefined) depth = Math.max(1, Math.floor(Number(args[i + 1])));
+			if (args[i] === 'nodes' && args[i + 1] !== undefined)
+				maxNodes = Math.max(1, Math.floor(Number(args[i + 1])));
+			if (args[i] === 'movetime' && args[i + 1] !== undefined)
+				timeMs = Math.max(1, Math.floor(Number(args[i + 1])));
+		}
+		if (!Number.isInteger(depth)) depth = fallbackDepth;
+		const moves = legalMoves(state);
+		if (!moves.length) return ['bestmove 0000'];
+		const entry = book ? probeBook(book, state) : null;
+		if (entry?.moves.length) return ['info string book', `bestmove ${entry.moves[0]}`];
+		const tabled = tablebest();
+		if (tabled) return ['info string tablebase', `bestmove ${uciString(tabled.move)}`];
+		const result = searchTourney(state, { depth, maxNodes, timeMs });
+		if (!result.move) return ['bestmove 0000'];
+		return [
+			`info depth ${result.depth} score cp ${result.score} nodes ${result.nodes}`,
+			`bestmove ${uciString(result.move)}`,
+		];
+	};
+
+	const position = (args) => {
+		const movesAt = args.indexOf('moves');
+		const head = movesAt === -1 ? args : args.slice(0, movesAt);
+		const tail = movesAt === -1 ? [] : args.slice(movesAt + 1);
+		if (head[0] === 'startpos') {
+			state = startingChess();
+			halfmove = 0;
+		} else if (head[0] === 'fen') {
+			try {
+				const fen = head.slice(1).join(' ');
+				state = parseFen(fen);
+				const parts = fen.split(' ');
+				halfmove = parts[4] !== undefined && /^\d+$/.test(parts[4]) ? Number(parts[4]) : 0;
+			} catch {
+				return [`info string bad fen: ${head.slice(1).join(' ')}`];
+			}
+		} else {
+			return [`info string unknown position: ${head[0] ?? ''}`];
+		}
+		for (const token of tail) {
+			const move = findMove(token);
+			if (!move) return [`info string illegal move: ${token}`];
+			play(move);
+		}
+		return [];
+	};
+
+	return {
+		input(line) {
+			const parts = line
+				.trim()
+				.split(/\s+/)
+				.filter((part) => part.length);
+			if (!parts.length) return [];
+			const [command, ...args] = parts;
+			if (command === 'uci') return ['id name mwg tourney', 'uciok'];
+			if (command === 'isready') return ['readyok'];
+			if (command === 'ucinewgame') {
+				state = startingChess();
+				halfmove = 0;
+				return [];
+			}
+			if (command === 'position') return position(args);
+			if (command === 'go') return go(args);
+			if (command === 'quit') return [];
+			return [`info string unknown command: ${command}`];
+		},
+	};
+}
+
+const isMain = process.argv[1] && import.meta.url.endsWith(basename(process.argv[1]));
+
+if (isMain) {
+	const args = process.argv.slice(2);
+	const flag = (name) => {
+		const at = args.indexOf(name);
+		return at === -1 ? undefined : args[at + 1];
+	};
+	const bookPath = flag('--book');
+	const tablesDir = flag('--tables');
+	const depth = flag('--depth') === undefined ? 4 : Math.max(1, Math.floor(Number(flag('--depth'))));
+	const book = bookPath ? JSON.parse(readFileSync(bookPath, 'utf8')) : null;
+	if (book && book.version !== 1) throw new Error(`${bookPath}: unknown opening-book version`);
+	const tables = {};
+	if (tablesDir) {
+		for (const file of readdirSync(tablesDir)) {
+			if (extname(file) !== '.json') continue;
+			const ending = loadTablebaseEnding(JSON.parse(readFileSync(join(tablesDir, file), 'utf8')));
+			tables[ending.id] = ending;
+		}
+	}
+	const session = createUciSession({ book, tables, depth });
+	const lines = createInterface({ input: process.stdin, output: process.stdout, terminal: false });
+	for await (const line of lines) {
+		if (line.trim() === 'quit') break;
+		for (const out of session.input(line)) console.log(out);
+	}
+}