@datamoc/mw_games 0.43.0 → 0.45.0

package/tools/soundfonts.d.mts

@@ -1,79 +1 @@
-/** how freely a catalogue font may be shipped inside a game */
-export type SoundFontLicenceClass =
-	'public-domain' | 'permissive' | 'attribution' | 'share-alike' | 'copyleft' | 'check';
-
-export interface SoundFontCatalogEntry {
-	name: string;
-	licence: string;
-	licenceClass: SoundFontLicenceClass;
-	web?: string;
-	/** instrument files the collection carries for this font (programs for a bundled bank) */
-	programs: number;
-	/** megabytes of a full General MIDI bank, SoundFont 3 compressed; absent for the bundled bank */
-	gmMB?: number;
-	/** megabytes of every instrument file, SoundFont 3 compressed (the bundled bank's own size) */
-	fullMB: number;
-	/** the file of a bundled bank, relative to the package root */
-	file?: string;
-	note?: string;
-}
-
-export interface SoundFontCatalog {
-	description: string;
-	/** where the per-instrument files are fetched from by default */
-	source: string;
-	/** the name of the bank the package ships and games use unless they choose another */
-	default: string;
-	bundled: SoundFontCatalogEntry[];
-	fonts: SoundFontCatalogEntry[];
-}
-
-export interface SoundFontProgramRef {
-	bank: number;
-	program: number;
-}
-
-export interface FetchSoundFontOptions {
-	/** a catalogue font name, from `mwg-soundfonts list` */
-	name: string;
-	programs: SoundFontProgramRef[];
-	catalog?: SoundFontCatalog;
-	/** a folder or `http(s)` URL laid out as `<font>/<bank>/<program>.sf3`; the catalogue's source by default */
-	source?: string;
-	/** required for a licence class that is not public-domain, permissive or attribution */
-	acceptLicence?: boolean;
-	/** the decoded font is a SoundFont 2 (`ffmpeg` needed) instead of a SoundFont 3; `sf3` by default */
-	format?: 'sf2' | 'sf3';
-	/** Ogg Vorbis bytes to mono 16-bit frames, for `format: 'sf2'`; `ffmpeg` by default */
-	decode?: (ogg: Uint8Array, rate: number) => Int16Array | Promise<Int16Array>;
-	/** replaces the file reader, mainly for tests */
-	read?: (path: string) => Promise<Uint8Array | null>;
-}
-
-export interface FetchedSoundFont {
-	/** one font holding the found programs, in `format` */
-	bytes: Uint8Array;
-	format: 'sf2' | 'sf3';
-	found: SoundFontProgramRef[];
-	/** requested programs the collection does not carry */
-	missing: SoundFontProgramRef[];
-	font: SoundFontCatalogEntry;
-}
-
-/** the licence-classified catalogue of fetchable fonts */
-export declare const CATALOG_PATH: string;
-export declare function readCatalog(path?: string): SoundFontCatalog;
-export declare function findFont(catalog: SoundFontCatalog, name: string): SoundFontCatalogEntry | undefined;
-/** `"0,24,128:0"`: a bare number is a program of bank 0, `bank:program` names both */
-export declare function parseProgramList(text: string): SoundFontProgramRef[];
-/** mono 16-bit frames from Ogg Vorbis bytes, through `ffmpeg` */
-export declare function ffmpegDecode(ogg: Uint8Array): Int16Array;
-/** a SoundFont 3 decoded into SoundFont 2 bytes (`ffmpeg` unless `decode` is given) */
-export declare function sf3ToSf2(
-	bytes: Uint8Array,
-	decode?: (ogg: Uint8Array, rate: number) => Int16Array | Promise<Int16Array>,
-): Promise<Uint8Array>;
-export declare function readCollectionFile(source: string, path: string): Promise<Uint8Array | null>;
-export declare function fetchSoundFont(options: FetchSoundFontOptions): Promise<FetchedSoundFont>;
-/** the credits note that travels beside a fetched font */
-export declare function creditsFor(font: SoundFontCatalogEntry, programs: SoundFontProgramRef[]): string;
+export * from '@datamoc/mwg/tools/soundfonts';

package/tools/soundfonts.mjs

@@ -1,301 +1 @@
-#!/usr/bin/env node
-import { spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-/**
- * `mwg-soundfonts`: the developer-side half of choosing a SoundFont. The package ships one
- * small bank (`data/microgm-opt.sf2`); a game that wants another picks it from the catalogue
- * (`data/soundfont-catalog.json`, a licence-classified snapshot of the marmooo free-soundfonts
- * collection), and this tool fetches only the instruments the game's MIDI files use and merges
- * them into one font for the asset folder, where the build subsets it again like any other.
- *
- * The merged font stays a SoundFont 3 (Ogg Vorbis samples, a fraction of the size) by default:
- * nothing is decoded here, and the game decodes it where it runs with `loadSoundFont`.
- * `--sf2` decodes it into a plain SoundFont 2 instead, which is `ffmpeg`'s job: needed on a
- * developer machine only, never by the player, and named when missing. Nothing here runs in a
- * browser.
- */
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-export const CATALOG_PATH = join(HERE, '..', 'data', 'soundfont-catalog.json');
-
-/** licence classes a font may be fetched under without saying so */
-const FREE_TO_SHIP = new Set(['public-domain', 'permissive', 'attribution']);
-
-/**
- * The SoundFont implementation lives in the library, not in this tool: in this repository it is
- * the TypeScript source, in an installed package the built `dist/` it compiles to (the same
- * lookup `compile-resources` makes).
- */
-async function loadLibrary() {
-	try {
-		const [soundFont, midi] = await Promise.all([
-			import('../src/audio/SoundFont.ts'),
-			import('../src/audio/Midi.ts'),
-		]);
-		return { ...soundFont, ...midi };
-	} catch {
-		return import('../dist/audio/index.js');
-	}
-}
-
-/** the catalogue as parsed JSON: `{ source, default, bundled, fonts }` */
-export function readCatalog(path = CATALOG_PATH) {
-	return JSON.parse(readFileSync(path, 'utf8'));
-}
-
-/** a catalogue entry (bundled bank included) by name, or undefined */
-export function findFont(catalog, name) {
-	return [...catalog.bundled, ...catalog.fonts].find((font) => font.name === name);
-}
-
-/** `"0,24,128:0"` as `[{ bank, program }]`: a bare number is a program of bank 0, `bank:program` names both */
-export function parseProgramList(text) {
-	return text
-		.split(',')
-		.map((item) => item.trim())
-		.filter(Boolean)
-		.map((item) => {
-			const [first, second] = item.split(':');
-			const bank = second === undefined ? 0 : Number(first);
-			const program = Number(second === undefined ? first : second);
-			if (
-				!Number.isInteger(bank) ||
-				!Number.isInteger(program) ||
-				bank < 0 ||
-				bank > 128 ||
-				program < 0 ||
-				program > 127
-			) {
-				throw new Error(`invalid program "${item}": expected a program 0-127 or bank:program`);
-			}
-			return { bank, program };
-		});
-}
-
-/**
- * mono 16-bit PCM from Ogg Vorbis bytes, through `ffmpeg`, at the rate the stream carries (the
- * `rate` a font states for the sample is the same one). The bytes come from a font file that may
- * have been downloaded, so they are not trusted: anything that does not start with the Ogg magic
- * is refused before a process is spawned, the demuxer is forced to Ogg rather than probed (a
- * probed "sample" could be read as a playlist naming local files), and only the `pipe` protocol
- * is allowed.
- */
-export function ffmpegDecode(ogg) {
-	if (Buffer.from(ogg.subarray(0, 4)).toString('latin1') !== 'OggS') {
-		throw new Error('a compressed sample is not Ogg Vorbis data: the font is damaged or not a SoundFont 3');
-	}
-	const run = spawnSync(
-		'ffmpeg',
-		[
-			'-v',
-			'error',
-			'-protocol_whitelist',
-			'pipe',
-			'-f',
-			'ogg',
-			'-i',
-			'pipe:0',
-			'-f',
-			's16le',
-			'-ac',
-			'1',
-			'pipe:1',
-		],
-		{ input: ogg, maxBuffer: 256 * 1024 * 1024 },
-	);
-	if (run.error?.code === 'ENOENT') {
-		throw new Error('ffmpeg was not found on PATH: install it to decode SoundFont 3 (developer machines only)');
-	}
-	if (run.status !== 0) throw new Error(`ffmpeg could not decode a sample: ${run.stderr}`);
-	const out = run.stdout;
-	return new Int16Array(out.buffer.slice(out.byteOffset, out.byteOffset + out.length - (out.length & 1)));
-}
-
-/** a SoundFont 3 decoded into SoundFont 2 bytes (`decode` is `ffmpeg` unless given) */
-export async function sf3ToSf2(bytes, decode = ffmpegDecode) {
-	const { decodeSoundFont } = await loadLibrary();
-	return new Uint8Array(await decodeSoundFont(bytes, decode));
-}
-
-const pad = (value, width) => String(value).padStart(width, '0');
-
-/** reads one file of a collection laid out as `<source>/<font>/<bank>/<program>.sf3`, from a folder or a URL; null when absent */
-export async function readCollectionFile(source, path) {
-	if (/^https?:\/\//.test(source)) {
-		const response = await fetch(
-			`${source.replace(/\/$/, '')}/${path.split('/').map(encodeURIComponent).join('/')}`,
-		);
-		if (response.status === 404) return null;
-		if (!response.ok) throw new Error(`${path}: HTTP ${response.status}`);
-		return new Uint8Array(await response.arrayBuffer());
-	}
-	const file = resolve(source, path);
-	return existsSync(file) ? new Uint8Array(readFileSync(file)) : null;
-}
-
-/**
- * Fetches `programs` (`[{ bank, program }]`) of the catalogue font `name` and merges them into
- * one font: a SoundFont 3 with the compressed samples untouched, or with `format: 'sf2'` a
- * SoundFont 2 decoded through `decode` (`ffmpeg` by default). Returns
- * `{ bytes, format, found, missing, font }`: `missing` lists the programs the collection does
- * not carry (the renderer falls back for them as it does for any font). A font whose licence
- * class is not free to ship is refused unless `acceptLicence` is set, and a font that is not in
- * the catalogue is refused outright.
- */
-export async function fetchSoundFont({
-	name,
-	programs,
-	catalog = readCatalog(),
-	source,
-	acceptLicence = false,
-	format = 'sf3',
-	decode,
-	read,
-}) {
-	const font = catalog.fonts.find((entry) => entry.name === name);
-	if (!font) {
-		const bundled = catalog.bundled.find((entry) => entry.name === name);
-		throw new Error(
-			bundled
-				? `${name} ships in the package as ${bundled.file}: copy that file instead of fetching it`
-				: `${name} is not in the catalogue: run "mwg-soundfonts list"`,
-		);
-	}
-	if (!FREE_TO_SHIP.has(font.licenceClass) && !acceptLicence) {
-		throw new Error(
-			`${name} is ${font.licence} (${font.licenceClass})${font.note ? `: ${font.note}` : ''}. ` +
-				'Pass --accept-licence once you have read its terms and are sure the game may ship it.',
-		);
-	}
-	if (format !== 'sf3' && format !== 'sf2') throw new Error(`unknown format "${format}": expected sf3 or sf2`);
-	if (programs.length === 0) throw new Error('no programs requested: pass --midi <files> or --programs <list>');
-	const origin = source ?? catalog.source;
-	const reader = read ?? ((path) => readCollectionFile(origin, path));
-	const { mergeSoundFonts, decodeSoundFont } = await loadLibrary();
-
-	const found = [];
-	const missing = [];
-	const files = [];
-	const seen = new Set();
-	for (const { bank, program } of programs) {
-		const key = `${bank}:${program}`;
-		if (seen.has(key)) continue;
-		seen.add(key);
-		const bytes = await reader(`${name}/${pad(bank, 3)}/${pad(program, 3)}.sf3`);
-		if (!bytes) {
-			missing.push({ bank, program });
-			continue;
-		}
-		files.push(bytes);
-		found.push({ bank, program });
-	}
-	if (files.length === 0) throw new Error(`${name} carries none of the requested programs`);
-	const merged = mergeSoundFonts(files);
-	const bytes = new Uint8Array(format === 'sf2' ? await decodeSoundFont(merged, decode ?? ffmpegDecode) : merged);
-	return { bytes, format, found, missing, font };
-}
-
-/** the credits note that travels beside a fetched font, so the licence is not lost */
-export function creditsFor(font, programs) {
-	return [
-		`${font.name}`,
-		`Licence: ${font.licence} (${font.licenceClass})`,
-		...(font.web ? [`Source: ${font.web}`] : []),
-		`Programs: ${programs.map(({ bank, program }) => `${bank}:${program}`).join(', ')}`,
-		...(font.licenceClass === 'attribution' ? ['Credit the author of this font in your game.'] : []),
-		...(font.licenceClass === 'share-alike' || font.licenceClass === 'copyleft'
-			? ['This licence carries sharing obligations: read it before shipping a game that embeds this font.']
-			: []),
-		'',
-	].join('\n');
-}
-
-const USAGE = `usage: mwg-soundfonts <command>
-  list                                          the bundled bank and every catalogue font, with licence and size
-  fetch <font> (--midi <file>... | --programs <list>) [--out <file>] [--source <url|folder>] [--accept-licence] [--sf2]
-                                                one font holding just those instruments (programs: 0,24,128:0),
-                                                a SoundFont 3 the game decodes with loadSoundFont, or with --sf2
-                                                a decoded SoundFont 2 (needs ffmpeg on PATH)
-  convert <in.sf3> <out.sf2>                    SoundFont 3 to SoundFont 2 (needs ffmpeg on PATH)`;
-
-function formatList(catalog) {
-	const rows = [
-		...catalog.bundled.map((font) => ({ ...font, shipped: 'bundled in the package: ' + font.file })),
-		...catalog.fonts.map((font) => ({
-			...font,
-			shipped: `${font.gmMB} MB for a full GM bank, ${font.fullMB} MB in all (sf3)`,
-		})),
-	];
-	return rows
-		.map((font) => {
-			const free = FREE_TO_SHIP.has(font.licenceClass) ? '' : '  [read the licence first]';
-			return `${font.name}${font.name === catalog.default ? '  (default)' : ''}\n  ${font.licence} (${font.licenceClass})${free}\n  ${font.shipped}`;
-		})
-		.join('\n');
-}
-
-async function main(argv) {
-	const [command, ...rest] = argv;
-	if (!command || command === '--help' || command === '-h') {
-		console.log(USAGE);
-		return;
-	}
-	const flag = (name) => {
-		const at = rest.indexOf(name);
-		return at === -1 ? undefined : rest[at + 1];
-	};
-	const valuesAfter = (name) => {
-		const at = rest.indexOf(name);
-		if (at === -1) return [];
-		const out = [];
-		for (let index = at + 1; index < rest.length && !rest[index].startsWith('--'); index++) out.push(rest[index]);
-		return out;
-	};
-	if (command === 'list') {
-		console.log(formatList(readCatalog()));
-	} else if (command === 'convert') {
-		const [input, output] = rest;
-		if (!input || !output) throw new Error('usage: mwg-soundfonts convert <in.sf3> <out.sf2>');
-		writeFileSync(output, await sf3ToSf2(readFileSync(input)));
-		console.log(`wrote ${output}`);
-	} else if (command === 'fetch') {
-		const name = rest.find((arg) => !arg.startsWith('--'));
-		if (!name) throw new Error('usage: mwg-soundfonts fetch <font> (--midi <file>... | --programs <list>)');
-		const programs = flag('--programs') ? parseProgramList(flag('--programs')) : [];
-		const midiFiles = valuesAfter('--midi');
-		if (midiFiles.length > 0) {
-			const { collectSoundFontUsage, parseMidi } = await loadLibrary();
-			programs.push(...collectSoundFontUsage(midiFiles.map((file) => parseMidi(readFileSync(file)))));
-		}
-		const result = await fetchSoundFont({
-			name,
-			programs,
-			source: flag('--source'),
-			acceptLicence: rest.includes('--accept-licence'),
-			format: rest.includes('--sf2') ? 'sf2' : 'sf3',
-		});
-		const out = resolve(flag('--out') ?? `${name}.${result.format}`);
-		mkdirSync(dirname(out), { recursive: true });
-		writeFileSync(out, result.bytes);
-		writeFileSync(out.replace(/\.sf[23]$/, '') + '.credits.txt', creditsFor(result.font, result.found));
-		console.log(`wrote ${out}: ${result.found.length} programs, ${(result.bytes.length / 1024).toFixed(0)} KB`);
-		if (result.missing.length > 0) {
-			console.log(
-				`not in ${name}: ${result.missing.map(({ bank, program }) => `${bank}:${program}`).join(', ')}`,
-			);
-		}
-	} else {
-		throw new Error(`unknown command "${command}"\n${USAGE}`);
-	}
-}
-
-//realpath, since an npm `bin` shim reaches this file through a symlink
-if (process.argv[1] && realpathSync(process.argv[1]) === fileURLToPath(import.meta.url)) {
-	main(process.argv.slice(2)).catch((error) => {
-		console.error(error instanceof Error ? error.message : error);
-		process.exitCode = 1;
-	});
-}
+export * from '@datamoc/mwg/tools/soundfonts';

package/tools/svg-optimise.d.mts

@@ -1,8 +1 @@
-/** the svgo configuration `optimiseSvg` runs */
-export declare const SVGO_CONFIG: {
-	multipass: boolean;
-	plugins: { name: string; params: { overrides: Record<string, boolean> } }[];
-};
-
-/** the SVG bytes minified; needs the optional `svgo` package, and throws for a file that is not valid SVG */
-export declare function optimiseSvg(buffer: Buffer): Promise<Buffer>;
+export * from '@datamoc/mwg/tools/svg-optimise';

package/tools/svg-optimise.mjs

@@ -1,45 +1 @@
-/**
- * Minifies an SVG for embedding, the SVG half of what `webp-convert` is for raster images, kept as
- * its own module so `tools/compile-resources.mjs` never has to import an optimiser itself: it
- * dynamically imports `svgo`, which a game that opts in installs in its own project the way it does
- * `sharp` for WebP (`npm install --save-dev svgo`). A game that never passes `svgo: true` carries
- * no new dependency at all.
- *
- * Optimising must not change what the game can see or name. Ids are left alone (`cleanupIds` is off:
- * a `<use href="#id">`, a gradient reference or a style selector inside the file, or an id the game
- * looks up, would break if minified), and the `viewBox` stays because svgo 4's default preset no
- * longer removes it (a game scales a texture by it), which is why this needs svgo 4 or newer.
- * Everything else in the default preset applies: comments, metadata, editor data, default
- * attributes, redundant groups, path precision.
- */
-
-/** the svgo configuration `optimiseSvg` runs, exposed so a game can see exactly what it opts into */
-export const SVGO_CONFIG = {
-	multipass: true,
-	plugins: [{ name: 'preset-default', params: { overrides: { cleanupIds: false } } }],
-};
-
-let svgoModule;
-async function loadSvgo() {
-	if (svgoModule) return svgoModule;
-	try {
-		svgoModule = await import('svgo');
-	} catch (err) {
-		throw new Error(
-			'SVG optimisation needs the optional `svgo` package, which is not installed. ' +
-				'Run `npm install --save-dev svgo` in your project to use `svgo: true`, or leave ' +
-				'it off (the default) to embed SVG files as they are.',
-			{ cause: err },
-		);
-	}
-	return svgoModule;
-}
-
-/**
- * @param {Buffer} buffer the SVG file's bytes (UTF-8)
- * @returns {Promise<Buffer>} the optimised SVG; svgo throws for a file that is not valid SVG
- */
-export async function optimiseSvg(buffer) {
-	const { optimize } = await loadSvgo();
-	return Buffer.from(optimize(buffer.toString('utf8'), SVGO_CONFIG).data, 'utf8');
-}
+export * from '@datamoc/mwg/tools/svg-optimise';

package/tools/verify-scenarios.d.mts

@@ -1,15 +1 @@
-export interface ScenarioPlanEntry {
-	id: string;
-	enter: string;
-	/** Steps that play all sides and advance dialogue for one game-owned turn. */
-	turn: string[];
-	/** A step that throws when game-owned map, units, outcome or campaign checks fail. */
-	verify: string;
-	leave?: string;
-}
-export function validateScenarioPlan(plan: unknown): ScenarioPlanEntry[];
-export function verifyScenarios(options: { file: string; turns?: number; timeoutMs?: number; only?: string }): Promise<{
-	ok: boolean;
-	scenarios: { id: string; turns: number; ok: boolean }[];
-	failures: string[];
-}>;
+export * from '@datamoc/mwg/tools/verify-scenarios';

package/tools/verify-scenarios.mjs

@@ -1,133 +1 @@
-#!/usr/bin/env node
-import { realpathSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { launchChrome } from './find-chrome.mjs';
-
-/** Validate the serialisable, game-owned plan before running any scene steps. */
-export function validateScenarioPlan(plan) {
-	if (!Array.isArray(plan) || plan.length === 0) throw new Error('scenario plan must be a nonempty array');
-	const ids = new Set();
-	for (const scenario of plan) {
-		if (!scenario || typeof scenario.id !== 'string' || !scenario.id || ids.has(scenario.id))
-			throw new Error('scenario IDs must be nonempty and unique');
-		ids.add(scenario.id);
-		for (const field of ['enter', 'verify'])
-			if (typeof scenario[field] !== 'string' || !scenario[field])
-				throw new Error(`${scenario.id}: ${field} needs a scene control name`);
-		if (
-			!Array.isArray(scenario.turn) ||
-			scenario.turn.length === 0 ||
-			scenario.turn.some((step) => typeof step !== 'string' || !step)
-		)
-			throw new Error(`${scenario.id}: turn needs a nonempty list of scene control names`);
-		if (scenario.leave !== undefined && (typeof scenario.leave !== 'string' || !scenario.leave))
-			throw new Error(`${scenario.id}: leave needs a scene control name`);
-	}
-	return plan;
-}
-
-/** Opens one local page and drives every scenario through its registered SceneControls. */
-export async function verifyScenarios({ file, turns = 3, timeoutMs = 120000, only = '' }) {
-	if (!Number.isSafeInteger(turns) || turns < 1) throw new Error('turns must be a positive integer');
-	if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1) throw new Error('timeoutMs must be a positive integer');
-	const browser = await launchChrome({ argsEnv: 'MWG_VISUAL_CHROME_ARGS' });
-	const failures = [];
-	const scenarios = [];
-	let expired = false;
-	const bounded = async (operation) => {
-		let timer;
-		try {
-			return await Promise.race([
-				operation,
-				new Promise((_, reject) => {
-					timer = setTimeout(() => {
-						expired = true;
-						reject(new Error(`scene step exceeded ${timeoutMs} ms`));
-					}, timeoutMs);
-				}),
-			]);
-		} finally {
-			clearTimeout(timer);
-		}
-	};
-	try {
-		const page = await browser.newPage({ viewport: { width: 1280, height: 720 } });
-		let current = 'startup';
-		page.on('pageerror', (error) => failures.push(`${current}: ${error.message}`));
-		page.on('console', (message) => {
-			if (message.type() === 'error') failures.push(`${current}: ${message.text()}`);
-		});
-		await page.goto(pathToFileURL(resolve(file)).href, { waitUntil: 'load', timeout: timeoutMs });
-		await page.waitForFunction(() => Boolean(window.__MWG_SCENARIOS__), undefined, { timeout: timeoutMs });
-		const plan = validateScenarioPlan(await page.evaluate(() => window.__MWG_SCENARIOS__.scenarios));
-		const selected = plan.filter((scenario) => scenario.id.startsWith(only));
-		if (!selected.length) throw new Error(`no scenarios match ${JSON.stringify(only)}`);
-		// Refuse a missing step before entering the first scenario.
-		await page.evaluate((plan) => {
-			const controls = window.__MWG_SCENARIOS__.controls;
-			for (const scenario of plan)
-				for (const step of [scenario.enter, ...scenario.turn, scenario.verify, scenario.leave].filter(Boolean))
-					if (!controls.has(step)) throw new Error(`scene control step is not registered: ${step}`);
-		}, selected);
-		for (const scenario of selected) {
-			current = scenario.id;
-			const before = failures.length;
-			let played = 0;
-			const run = (step) => bounded(page.evaluate((name) => window.__MWG_SCENARIOS__.controls.run(name), step));
-			try {
-				await run(scenario.enter);
-				for (; played < turns; played++) {
-					for (const step of scenario.turn) await run(step);
-					await run(scenario.verify);
-				}
-			} catch (error) {
-				failures.push(`${current}: ${error.message}`);
-			} finally {
-				if (scenario.leave && !expired) {
-					try {
-						await run(scenario.leave);
-					} catch (error) {
-						failures.push(`${current}: cleanup: ${error.message}`);
-					}
-				}
-			}
-			scenarios.push({ id: scenario.id, turns: played, ok: failures.length === before });
-			// A timed-out promise is still live in the page. Do not overlap another scenario with it.
-			if (expired) break;
-		}
-		return { ok: failures.length === 0, scenarios, failures };
-	} finally {
-		await browser.close();
-	}
-}
-
-if (process.argv[1] && realpathSync(process.argv[1]) === fileURLToPath(import.meta.url)) {
-	const [file, ...args] = process.argv.slice(2);
-	const options = { file };
-	const usage = 'usage: mwg-scenarios <built index.html> [--turns N] [--timeout-ms N] [--only prefix]';
-	if (file === '--help' || file === '-h') {
-		console.log(usage);
-		process.exit(0);
-	}
-	try {
-		if (!file) throw new Error(usage);
-		for (let i = 0; i < args.length; i += 2) {
-			const name = { '--turns': 'turns', '--timeout-ms': 'timeoutMs', '--only': 'only' }[args[i]];
-			if (!name || args[i + 1] === undefined) throw new Error(`invalid option: ${args[i]}`);
-			options[name] = name === 'only' ? args[i + 1] : Number(args[i + 1]);
-		}
-		verifyScenarios(options)
-			.then((report) => {
-				console.log(JSON.stringify(report, null, 2));
-				process.exitCode = report.ok ? 0 : 1;
-			})
-			.catch((error) => {
-				console.error(error.message);
-				process.exitCode = 1;
-			});
-	} catch (error) {
-		console.error(error.message);
-		process.exitCode = 1;
-	}
-}
+export * from '@datamoc/mwg/tools/verify-scenarios';

package/tools/vite.d.mts

@@ -1,17 +1 @@
-import type { EmitPageOptions } from './emit-page.mjs';
-
-export interface MwgPageOptions extends Omit<EmitPageOptions, 'dist' | 'assets'> {
-	/** the asset source folder, relative to the vite root; served in dev and compiled in the build. Default `'assets'`, `false` for none */
-	assets?: string | false;
-	/** write `sbom.cdx.json`, the CycloneDX SBOM of what the build ships; default true */
-	sbom?: boolean;
-}
-
-/** the vite plugin that makes `vite build` alone write a page that opens from `file://` */
-export function mwgPage(options?: MwgPageOptions): {
-	name: string;
-	config(): Record<string, unknown>;
-	configResolved(config: { root: string; command: string; build: { outDir: string } }): void;
-	generateBundle(options: unknown, bundle: Record<string, { type: string; modules?: Record<string, unknown> }>): void;
-	closeBundle(this: { meta?: { watchMode?: boolean } }): Promise<void>;
-};
+export * from '@datamoc/mwg/tools/vite';