@datamoc/mw_games 0.40.0 → 0.41.0

package/tools/benchmark-browser.mjs

@@ -136,6 +136,12 @@ export async function measurePage({
  * `benchmark-results/<page>.json`, named by the page so two pages keep separate histories.
  */
 async function main(argv) {
+	if (argv.includes('--help') || argv.includes('-h')) {
+		console.log(
+			'usage: mwg-bench <page.html | dist folder> [--frames=180] [--min-fps=45] [--max-p95=40] [--history=<file>]',
+		);
+		return;
+	}
 	const value = (name, env, fallback) =>
 		argv.find((a) => a.startsWith(`--${name}=`))?.split('=')[1] ?? process.env[env] ?? fallback;
 	const target = argv.find((arg) => !arg.startsWith('--')) ?? 'examples/dungeon/dist/index.html';

package/tools/bundle-size.mjs

@@ -99,6 +99,10 @@ function measureFramework(root) {
 }
 
 function main(argv) {
+	if (argv.includes('--help') || argv.includes('-h')) {
+		console.log('usage: mwg-size <dist folder> [--baseline=<file>] [--tolerance=0.02] [--update]');
+		return;
+	}
 	const tolerance = Number(
 		argv.find((a) => a.startsWith('--tolerance='))?.slice(12) ?? process.env.MWG_SIZE_TOLERANCE ?? 0.02,
 	);

package/tools/compile-resources.mjs

@@ -41,9 +41,10 @@ export const DEFAULT_MIME = {
 	'.mid': 'audio/midi',
 	'.midi': 'audio/midi',
 	'.sf2': 'application/octet-stream',
+	'.sf3': 'application/octet-stream',
 };
 
-const isSoundFontKey = (key) => key.toLowerCase().endsWith('.sf2');
+const isSoundFontKey = (key) => /\.sf[23]$/i.test(key);
 const isMidiKey = (key) => /\.(mid|midi)$/i.test(key);
 
 /**
@@ -120,7 +121,7 @@ export async function* walk(dir) {
  *   pixel-art tileset's exact colours survive; set false only with `webpQuality` to opt into
  *   lossy re-encoding for photographic source art)
  * @param options.webpQuality 0-100, used only when `webpLossless` is false (default 90)
- * @param options.soundFont subset an embedded `.sf2` to the programs the embedded
+ * @param options.soundFont subset an embedded `.sf2` or `.sf3` to the programs the embedded
  *   `.mid`/`.midi` files use (default true); `false` embeds every SoundFont whole
  * @param options.soundFontUsage explicit `{ bank, program }` list to subset to, for a
  *   game that voices notes no shipped MIDI file requests; overrides the MIDI-derived list

package/tools/init.mjs

@@ -130,7 +130,9 @@ export function initProject(folder) {
 //no top-level await: this module is also imported, and the real path covers an npm bin symlink
 if (process.argv[1] && realpathSync(process.argv[1]) === fileURLToPath(import.meta.url)) {
 	const folder = process.argv[2];
-	if (!folder) {
+	if (folder === '--help' || folder === '-h') {
+		console.log('usage: mwg-init <new folder>');
+	} else if (!folder) {
 		console.error('usage: mwg-init <new folder>');
 		process.exitCode = 2;
 	} else {

package/tools/make-example-assets.mjs

@@ -717,6 +717,10 @@ if (process.argv[1] && realpathSync(process.argv[1]) === fileURLToPath(import.me
 	const args = process.argv.slice(2);
 	const folder = args.find((arg) => !arg.startsWith('--'));
 	const inRepository = existsSync(join(here, '..', 'examples'));
+	if (args.includes('--help') || args.includes('-h')) {
+		console.log('usage: mwg-placeholder-assets <folder> [--force]');
+		process.exit(0);
+	}
 	if (!folder && !inRepository) {
 		console.error('usage: mwg-placeholder-assets <folder> [--force]');
 		process.exit(1);

package/tools/multiplayer-server.mjs

@@ -187,6 +187,10 @@ export function createLockstepServer(options = {}) {
 //realpath, since an npm `bin` shim reaches this file through a symlink
 if (process.argv[1] && realpathSync(process.argv[1]) === fileURLToPath(import.meta.url)) {
 	const args = process.argv.slice(2);
+	if (args.includes('--help') || args.includes('-h')) {
+		console.log('usage: mwg-lockstep-server [port] [--host=<address>]');
+		process.exit(0);
+	}
 	const port = Number(args.find((arg) => !arg.startsWith('--')) ?? 8787);
 	const host = args.find((arg) => arg.startsWith('--host='))?.slice(7) ?? '127.0.0.1';
 	const server = createLockstepServer({ port, host });

package/tools/mwl.mjs

@@ -65,6 +65,13 @@ const assetRoot = assetRootFlag === -1 ? undefined : args[assetRootFlag + 1];
 const targetFlag = args.indexOf('--to');
 const target = targetFlag === -1 ? undefined : args[targetFlag + 1];
 
+if (args.includes('--help') || args.includes('-h')) {
+	console.log(
+		'usage: mwg-mwl <validate|compile|format|migrate|extract-i18n|assets|report|diagnostics|ci|hooks|build> input.mwl [-o output] [--to 1.0] [--manifest hooks.json] [--asset-root directory]',
+	);
+	process.exit(0);
+}
+
 if (!command || !input || !commands.includes(command)) {
 	console.error(
 		'Usage: mwl <validate|compile|format|migrate|extract-i18n|assets|report|diagnostics|ci|hooks|build> input.mwl [-o output] [--to 1.0] [--manifest hooks.json] [--asset-root directory]',

package/tools/play-uci.mjs

@@ -171,6 +171,10 @@ const isMain = process.argv[1] && realpathSync(process.argv[1]) === fileURLToPat
 
 if (isMain) {
 	const args = process.argv.slice(2);
+	if (args.includes('--help') || args.includes('-h')) {
+		console.log('usage: mwg-uci [--book <book.json>] [--tables <dir>] [--depth N]');
+		process.exit(0);
+	}
 	const flag = (name) => {
 		const at = args.indexOf(name);
 		return at === -1 ? undefined : args[at + 1];

package/tools/sbom.mjs

@@ -301,6 +301,10 @@ async function readJson(path) {
  * `application`, anything else as a `library`. `--check` compares instead of writing, for CI.
  */
 async function main(argv) {
+	if (argv.includes('--help') || argv.includes('-h')) {
+		console.log('usage: mwg-sbom [project folder] [--out=<file>] [--check]');
+		return;
+	}
 	const root = resolve(argv.find((arg) => !arg.startsWith('--')) ?? '.');
 	const out = resolve(root, argv.find((arg) => arg.startsWith('--out='))?.slice(6) ?? OUTPUT);
 	const packageJson = await readJson(join(root, 'package.json'));

package/tools/soundfonts.d.mts

@@ -0,0 +1,79 @@
+/** 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;

package/tools/soundfonts.mjs

@@ -0,0 +1,301 @@
+#!/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;
+	});
+}

package/tools/verify-scenarios.mjs

@@ -105,9 +105,13 @@ export async function verifyScenarios({ file, turns = 3, timeoutMs = 120000, onl
 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: mwg-scenarios <built index.html> [--turns N] [--timeout-ms N] [--only prefix]');
+		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]}`);

package/tools/vite.mjs

@@ -14,7 +14,7 @@ import { buildArtifactSbom, serialize, shippedFiles } from './sbom.mjs';
  * build. `assetFiles: ['characters/hero.svg', 'music/theme.ogg']` embeds only those paths;
  * omit it for all assets, or pass [] for none. An unknown entry fails by name. Filtering
  * affects the build only, so the dev server still serves the asset folder normally.
- * An embedded `.sf2` is subset at build time to the programs the embedded `.mid` files
+ * An embedded `.sf2` or `.sf3` is subset at build time to the programs the embedded `.mid` files
  * use (`soundFont: false` embeds it whole, `soundFontUsage` names the programs instead).
  * At the end of the build it runs `emitPage` over the output folder with the same
  * options. A setting the game's own config gives explicitly still wins, since vite merges a