@datamoc/mw_games 0.44.2 → 0.46.0

package/tools/compile-resources.mjs

@@ -1,406 +1 @@
-import { realpathSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { readdir, readFile, mkdir, writeFile, rm } from 'node:fs/promises';
-import { join, extname, relative, sep, dirname } from 'node:path';
-import { WEBP_CONVERTIBLE_EXTENSIONS } from './webp-convert.mjs';
-
-/**
- * Turns a folder of assets into scripts a `file://` page can load.
- *
- * Opening a page from disk removes three things a normal web game relies on:
- *
- *   - `fetch()` and XHR are blocked, so nothing can be loaded on demand and no directory
- *     can be listed;
- *   - ES modules are blocked by CORS, so the page cannot use a module loader;
- *   - an `<img>` read from a sibling file counts as cross-origin in Chrome, so uploading
- *     it into a WebGL texture throws a SecurityError.
- *
- * The last one is the awkward one: even shipping plain .png files next to the page does
- * not work. What does work is a `<script src>`, which is exempt from those rules. So each
- * asset becomes a `data:` URI inside a generated script, grouped by folder so no single
- * file is enormous and a rebuild only rewrites what changed.
- *
- * The result is a global `__MWG_ASSETS__` mapping asset path to `data:` URI, which
- * `mwg/assets` reads.
- */
-
-export const DEFAULT_MIME = {
-	'.png': 'image/png',
-	'.jpg': 'image/jpeg',
-	'.jpeg': 'image/jpeg',
-	'.webp': 'image/webp',
-	'.gif': 'image/gif',
-	'.svg': 'image/svg+xml',
-	'.wav': 'audio/wav',
-	'.ogg': 'audio/ogg',
-	'.mp3': 'audio/mpeg',
-	'.ttf': 'font/ttf',
-	'.woff2': 'font/woff2',
-	'.json': 'application/json',
-	'.txt': 'text/plain',
-	'.mid': 'audio/midi',
-	'.midi': 'audio/midi',
-	'.sf2': 'application/octet-stream',
-	'.sf3': 'application/octet-stream',
-};
-
-const isSoundFontKey = (key) => /\.sf[23]$/i.test(key);
-const isMidiKey = (key) => /\.(mid|midi)$/i.test(key);
-
-/**
- * The SoundFont/MIDI implementation lives in the library, not in this tool: in this
- * repository it is the TypeScript source, in an installed package it is the built
- * `dist/` the source compiles to. Only called when a build actually embeds a
- * SoundFont it can subset, so a game without one never pays for the import.
- */
-async function loadSoundFontTools() {
-	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');
-	}
-}
-
-function checkedSoundFontUsage(soundFontUsage) {
-	if (soundFontUsage === undefined) return undefined;
-	if (!Array.isArray(soundFontUsage)) throw new Error('soundFontUsage must be an array of { bank, program }');
-	return soundFontUsage.map((entry, index) => {
-		const { bank, program } = entry ?? {};
-		if (!Number.isInteger(bank) || bank < 0 || !Number.isInteger(program) || program < 0 || program > 127) {
-			throw new Error(`soundFontUsage[${index}] needs an integer bank >= 0 and a program between 0 and 127`);
-		}
-		return { bank, program };
-	});
-}
-
-/** parses a `--soundfont-usage=bank:program,...` CLI value; undefined when the flag is absent */
-export function soundFontUsageFromFlag(value) {
-	if (value === undefined) return undefined;
-	return value
-		.split(',')
-		.filter(Boolean)
-		.map((pair) => {
-			const [bank, program] = pair.split(':').map(Number);
-			return { bank, program };
-		});
-}
-
-export async function* walk(dir) {
-	let entries;
-	try {
-		entries = await readdir(dir, { withFileTypes: true });
-	} catch {
-		return;
-	}
-	for (const entry of entries) {
-		const full = join(dir, entry.name);
-		if (entry.isDirectory()) yield* walk(full);
-		else yield full;
-	}
-}
-
-/**
- * @param options.from folder holding the assets
- * @param options.to folder to write the generated scripts into
- * @param options.mime extension to MIME type, merged over the defaults
- * @param options.assetFiles exact paths relative to `from` to embed; omit for all, [] for none.
- *   Unknown paths and explicitly selected unsupported formats fail before replacing output.
- *   credits.json is converted to CREDITS.txt only when selected (or when no list is given).
- * @param options.groupBy how to name the script an asset lands in; defaults to its top folder
- * @param options.toWebp convert `.png`/`.jpg`/`.jpeg` assets to WebP before embedding
- *   (default false - see `tools/webp-convert.mjs`). The asset's *key* never changes (a game
- *   still calls `load('tiles.png')` in both dev and built modes; dev mode serves the literal
- *   file from disk, unconverted), only the embedded `data:` URI's bytes and MIME type do, and
- *   only when the WebP result is actually smaller - a conversion that would not save
- *   anything is silently skipped rather than embedded anyway.
- * @param options.webpLossless use WebP's lossless mode when converting (default true - a
- *   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.svgo minify embedded `.svg` assets through the optional `svgo` package (default
- *   false - see `tools/svg-optimise.mjs`). The key never changes, only the embedded bytes, and
- *   only when the optimised file is actually smaller. A file svgo cannot parse fails the build by
- *   name rather than shipping unoptimised in silence.
- * @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
- * @returns the group names, in the order the page should load them
- *
- * An `assets/credits.json` (an array, or `{ "credits": [...] }`, of `{ name, license, author?, url? }`)
- * is not embedded as an asset: it is turned into `CREDITS.txt` beside the compiled scripts, for
- * the attribution that free art packs require. An entry without a `name` and a `license` is an
- * error, since a credits file that silently omits a pack defeats its purpose.
- */
-export async function compileResources({
-	from,
-	to,
-	mime = {},
-	groupBy,
-	assetFiles,
-	toWebp: convertToWebp = false,
-	webpLossless = true,
-	webpQuality = 90,
-	svgo: optimiseSvgFiles = false,
-	soundFont = true,
-	soundFontUsage,
-} = {}) {
-	if (!from || !to) throw new Error('compileResources needs both `from` and `to`');
-
-	const types = { ...DEFAULT_MIME, ...mime };
-	const group = groupBy ?? ((key) => (key.includes('/') ? key.slice(0, key.indexOf('/')) : 'assets'));
-
-	const files = [];
-	for await (const file of walk(from)) files.push(file);
-	const keyOf = (file) => relative(from, file).split(sep).join('/');
-	const selected =
-		assetFiles === undefined
-			? undefined
-			: new Set(assetFiles.map((key) => key.replaceAll('\\', '/').replace(/^\.\//, '')));
-	if (selected) {
-		const known = new Set(files.map(keyOf));
-		for (const key of selected) {
-			if (!known.has(key)) throw new Error(`unknown asset file ${key}`);
-			if (key !== 'credits.json' && !types[extname(key).toLowerCase()])
-				throw new Error(`unsupported asset file ${key}`);
-		}
-	}
-
-	// A shipped SoundFont carries only the programs the game's shipped MIDI files
-	// request: the full bank - even a small one - is mostly
-	// instruments no track plays. Usage is resolved before any output is replaced,
-	// so an unreadable MIDI or SoundFont fails the build with the old output intact.
-	// With no shipped MIDI and no explicit `soundFontUsage` the usage is unknowable
-	// (a game may voice notes it generates), so the font embeds whole.
-	const isSelected = (file) => !selected || selected.has(keyOf(file));
-	const explicitUsage = checkedSoundFontUsage(soundFontUsage);
-	const embedsSoundFont =
-		soundFont !== false && files.some((file) => isSelected(file) && isSoundFontKey(keyOf(file)));
-	let soundFontTools = null;
-	let usage = explicitUsage;
-	if (embedsSoundFont && usage === undefined) {
-		const midiFiles = files.filter((file) => isSelected(file) && isMidiKey(keyOf(file)));
-		if (midiFiles.length > 0) {
-			soundFontTools = await loadSoundFontTools();
-			const parsed = [];
-			for (const file of midiFiles) {
-				try {
-					parsed.push(soundFontTools.parseMidi(await readFile(file)));
-				} catch (error) {
-					throw new Error(
-						`cannot read MIDI asset ${keyOf(file)} to subset a SoundFont: ${error.message ?? error}`,
-					);
-				}
-			}
-			usage = soundFontTools.collectSoundFontUsage(parsed);
-		}
-	}
-	if (embedsSoundFont && usage !== undefined && !soundFontTools) soundFontTools = await loadSoundFontTools();
-	const soundFonts = [];
-
-	await rm(to, { recursive: true, force: true });
-	await mkdir(to, { recursive: true });
-
-	const groups = new Map();
-	let skipped = 0;
-	let rawBytes = 0;
-	let embeddedBytes = 0;
-	let webpConverted = 0;
-	let svgOptimised = 0;
-
-	// only paid when toWebp is actually used, so a build that never asks for it never imports
-	// (or requires installing) sharp
-	const toWebp = convertToWebp ? (await import('./webp-convert.mjs')).toWebp : null;
-	const optimiseSvg = optimiseSvgFiles ? (await import('./svg-optimise.mjs')).optimiseSvg : null;
-
-	const creditsFile = join(from, 'credits.json');
-	let credits = null;
-	const keys = [];
-
-	for (const file of files) {
-		if (selected && !selected.has(keyOf(file))) continue;
-		if (file === creditsFile) {
-			credits = creditsText(JSON.parse(await readFile(file, 'utf8')));
-			continue;
-		}
-		const ext = extname(file).toLowerCase();
-		const type = types[ext];
-		if (!type) {
-			skipped++;
-			continue;
-		}
-
-		const key = keyOf(file);
-		const data = await readFile(file);
-
-		let mimeType = type;
-		let bytes = data;
-		if (toWebp && WEBP_CONVERTIBLE_EXTENSIONS.has(ext)) {
-			const webp = await toWebp(data, { lossless: webpLossless, quality: webpQuality });
-			if (webp.length < data.length) {
-				mimeType = 'image/webp';
-				bytes = webp;
-				webpConverted++;
-			}
-		}
-
-		if (optimiseSvg && ext === '.svg') {
-			let optimised;
-			try {
-				optimised = await optimiseSvg(data);
-			} catch (error) {
-				throw new Error(`cannot optimise SVG asset ${key}: ${error.message ?? error}`);
-			}
-			if (optimised.length < data.length) {
-				bytes = optimised;
-				svgOptimised++;
-			}
-		}
-
-		if (isSoundFontKey(key)) {
-			if (usage !== undefined && soundFontTools) {
-				try {
-					bytes = Buffer.from(soundFontTools.subsetSoundFont(data, usage));
-				} catch (error) {
-					throw new Error(`cannot subset SoundFont asset ${key}: ${error.message ?? error}`);
-				}
-				soundFonts.push({
-					key,
-					programs: usage.length,
-					rawBytes: data.length,
-					embeddedBytes: bytes.length,
-					//the programs the MIDI files ask for that this font does not carry
-					missing: soundFontTools.missingSoundFontPrograms(data, usage),
-				});
-			} else {
-				soundFonts.push({ key, programs: null, rawBytes: data.length, embeddedBytes: data.length });
-			}
-		}
-
-		const name = group(key);
-		if (!groups.has(name)) groups.set(name, {});
-		groups.get(name)[key] = `data:${mimeType};base64,${bytes.toString('base64')}`;
-		keys.push(key);
-		rawBytes += data.length;
-		embeddedBytes += bytes.length;
-	}
-
-	const written = [];
-	for (const [name, assets] of groups) {
-		const js =
-			'//generated by mwg/tools/compile-resources, do not edit\n' +
-			'(function(){var a=window.__MWG_ASSETS__||(window.__MWG_ASSETS__={});' +
-			`var g=${JSON.stringify(assets)};for(var k in g)a[k]=g[k];})();\n`;
-
-		await writeFile(join(to, `${name}.js`), js, 'utf8');
-		written.push({ name, count: Object.keys(assets).length, size: js.length });
-	}
-
-	if (credits) await writeFile(join(to, 'CREDITS.txt'), credits, 'utf8');
-
-	return {
-		groups: written,
-		keys,
-		rawBytes,
-		embeddedBytes,
-		webpConverted,
-		svgOptimised,
-		skipped,
-		credits,
-		soundFonts,
-	};
-}
-
-/** the plain-text credits for a manifest, one block per entry; throws on an entry that cannot be attributed */
-export function creditsText(manifest) {
-	const entries = Array.isArray(manifest) ? manifest : manifest?.credits;
-	if (!Array.isArray(entries)) throw new Error('credits.json must be an array or { "credits": [...] }');
-	const blocks = entries.map((entry, index) => {
-		if (typeof entry?.name !== 'string' || typeof entry?.license !== 'string') {
-			throw new Error(`credits.json entry ${index} needs a "name" and a "license"`);
-		}
-		const lines = [entry.name + (entry.author ? ` by ${entry.author}` : ''), `License: ${entry.license}`];
-		if (entry.url) lines.push(entry.url);
-		return lines.join('\n');
-	});
-	return blocks.join('\n\n') + '\n';
-}
-
-// ---------------------------------------------------------------- CLI
-
-//the real path, since an npm `bin` shim reaches this file through a symlink; a suffix test on the
-//name is not enough (`compress-dist.mjs` ends with `t.mjs`)
-const isMain = process.argv[1] && realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
-
-async function runCli() {
-	const args = process.argv.slice(2);
-	const [from, to] = args.filter((a) => !a.startsWith('--'));
-	if (!from || !to) {
-		console.error(
-			'usage: node compile-resources.mjs <asset folder> <output folder> [--to-webp] [--webp-lossy[=quality]] [--svgo] [--no-soundfont-subset] [--soundfont-usage=bank:program,...]',
-		);
-		process.exit(1);
-	}
-	const toWebp = args.includes('--to-webp');
-	const lossyFlag = args.find((a) => a === '--webp-lossy' || a.startsWith('--webp-lossy='));
-	const webpLossless = !lossyFlag;
-	const webpQuality = lossyFlag && lossyFlag.includes('=') ? Number(lossyFlag.split('=')[1]) : 90;
-
-	const soundFontUsage = soundFontUsageFromFlag(
-		args.find((a) => a.startsWith('--soundfont-usage='))?.slice('--soundfont-usage='.length),
-	);
-
-	const { groups, rawBytes, embeddedBytes, webpConverted, svgOptimised, skipped, soundFonts } =
-		await compileResources({
-			from,
-			to,
-			//a flat folder has no subdirectories to group by, so everything lands in one file
-			groupBy: (key) => (key.includes('/') ? key.slice(0, key.indexOf('/')) : 'assets'),
-			toWebp,
-			webpLossless,
-			webpQuality,
-			svgo: args.includes('--svgo'),
-			soundFont: !args.includes('--no-soundfont-subset'),
-			soundFontUsage,
-		});
-
-	const kb = (n) => (n / 1024).toFixed(1).padStart(8) + ' KB';
-	for (const { name, count, size } of groups) {
-		console.log(`  ${join(relative(process.cwd(), to), name + '.js').padEnd(40)}${kb(size)}  (${count} files)`);
-	}
-	console.log(`  ${groups.length} script(s), ${kb(rawBytes)} of assets` + (skipped ? `, ${skipped} skipped` : ''));
-	for (const font of soundFonts) {
-		console.log(
-			font.programs === null
-				? `  ${font.key}: SoundFont embedded whole (${kb(font.rawBytes)}), no shipped MIDI to subset against`
-				: `  ${font.key}: SoundFont subset to ${font.programs} program(s), ${kb(font.rawBytes)} -> ${kb(font.embeddedBytes)}`,
-		);
-		if (font.missing?.length > 0) {
-			console.log(
-				`  warning: ${font.key} does not carry ${font.missing.map(({ bank, program }) => `${bank}:${program}`).join(', ')}: ` +
-					"they play the font's piano, or the built-in synthesizer with `missingProgram: 'synth'`",
-			);
-		}
-	}
-	if (args.includes('--svgo')) console.log(`  ${svgOptimised} SVG(s) optimised`);
-	if (toWebp) {
-		console.log(
-			`  ${webpConverted} image(s) converted to WebP (${webpLossless ? 'lossless' : `lossy, quality ${webpQuality}`}), ` +
-				`${kb(rawBytes)} -> ${kb(embeddedBytes)} embedded`,
-		);
-	}
-}
-
-//no top-level await: a vite config loaded as CommonJS has to be able to require() this module
-if (isMain) {
-	runCli().catch((error) => {
-		console.error(error);
-		process.exitCode = 1;
-	});
-}
-
-export { dirname };
+export * from '@datamoc/mwg/tools/compile-resources';

package/tools/compress-dist.d.mts

@@ -1,42 +1 @@
-/** Options for {@link compressDist}. */
-export interface CompressOptions {
-	/** Write `.gz` siblings (default true). */
-	gzip?: boolean;
-	/** Write `.br` siblings (default true). */
-	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;
-}
-
-/**
- * One considered file, with the sizes of the siblings actually written for it: `file` is
- * relative to `dir`, and a size is 0 when that sibling was not asked for, was not smaller
- * than the original, or (for `.xz`) needs a system binary that is not there. Files under the
- * size floor, and extensions that are already compressed or not text, never produce a row.
- */
-export interface CompressRow {
-	file: string;
-	raw: number;
-	gzip: number;
-	brotli: number;
-	xz: number;
-}
-
-/** 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
- * opted into, `<file>.xz`, beside it. There is no separate output directory, so pass a
- * directory you own or a copy of the build output, not one you are about to publish.
- */
-export function compressDist(dir: string, options?: CompressOptions): Promise<CompressRow[]>;
+export * from '@datamoc/mwg/tools/compress-dist';

package/tools/compress-dist.mjs

@@ -1,193 +1 @@
-import { realpathSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { readFile, writeFile } from 'node:fs/promises';
-import { relative, extname } from 'node:path';
-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';
-
-/**
- * Writes precompressed siblings (`.gz`, `.br`, optionally `.xz`) next to a build's
- * text files, for servers that can serve them with a `Content-Encoding` header.
- *
- * The originals stay exactly where they are, so a page opened from `file://` keeps
- * working with no server: the compressed files are only ever picked up when a server
- * negotiates them (nginx `gzip_static`, Apache `mod_rewrite`, a CDN, Capacitor live
- * reload, and so on). Nothing in the page references them.
- *
- * Only Node built-ins are used, so this adds no dependency. Gzip (level 9) is the
- * universal fallback every server understands; brotli (quality 11) is smaller and served
- * by preference where the client offers `br`. LZMA2 (`.xz`, via the system `xz` binary
- * when present, opt-in with `--xz`) compresses a little further, but browsers do not
- * decode `xz` as a `Content-Encoding`, so it is an offline archive format, not something
- * 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']);
-const ALREADY_COMPRESSED = new Set([
-	'.gz',
-	'.br',
-	'.xz',
-	'.png',
-	'.jpg',
-	'.jpeg',
-	'.webp',
-	'.gif',
-	'.wav',
-	'.ogg',
-	'.mp3',
-	'.ttf',
-	'.woff2',
-]);
-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 {
-		const found = spawnSync('xz', ['--version'], { stdio: 'ignore' });
-		return found.status === 0;
-	} catch {
-		return false;
-	}
-}
-
-function compressXz(data) {
-	const out = spawnSync('xz', ['-c', '-9'], { input: data });
-	if (out.status !== 0 || !out.stdout) return undefined;
-	return out.stdout;
-}
-
-/**
- * Writes sibling files *into the folder it is given*: each `<file>.gz`/`.br`/`.xz` appears
- * beside its original inside `dir`, which is rewritten in place, with no separate output
- * directory. The originals themselves are never modified, so a caller whose `dist` is also
- * what it publishes should still hand this a copy.
- *
- * @param dir folder to compress, normally an example's `dist`
- * @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`)
- * @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, 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;
-		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 = 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) {
-		//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;
-		}
-	}
-	return row;
-}
-
-//the real path, since an npm `bin` shim reaches this file through a symlink; a suffix test on the
-//name is not enough (`compress-dist.mjs` ends with `t.mjs`)
-const isMain = process.argv[1] && realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
-
-async function runCli() {
-	const [dir, ...flags] = process.argv.slice(2);
-	if (!dir) {
-		console.error('usage: node tools/compress-dist.mjs <dist folder> [--xz] [--no-gzip] [--no-brotli]');
-		process.exit(1);
-	}
-	const rows = await compressDist(dir, {
-		gzip: !flags.includes('--no-gzip'),
-		brotli: !flags.includes('--no-brotli'),
-		xz: flags.includes('--xz'),
-	});
-	const kb = (n) => (n / 1024).toFixed(1).padStart(8) + ' KB';
-	for (const row of rows) {
-		const parts = [`${row.file.padEnd(36)}${kb(row.raw)}`];
-		if (row.gzip) parts.push(`gz:${kb(row.gzip)}`);
-		if (row.brotli) parts.push(`br:${kb(row.brotli)}`);
-		if (row.xz) parts.push(`xz:${kb(row.xz)}`);
-		console.log('  ' + parts.join('  '));
-	}
-	if (flags.includes('--xz') && !hasXz()) {
-		console.log('  (xz requested but no `xz` binary found - skipping LZMA2, gz stays the fallback)');
-	}
-	console.log(`  ${rows.length} file(s) considered in ${relative(process.cwd(), dir)}`);
-}
-
-//no top-level await: a vite config loaded as CommonJS has to be able to require() this module
-if (isMain) {
-	runCli().catch((error) => {
-		console.error(error);
-		process.exitCode = 1;
-	});
-}
+export * from '@datamoc/mwg/tools/compress-dist';

package/tools/csp.d.mts

@@ -1,7 +1 @@
-import type { CspOptions } from './emit-page.mjs';
-
-/** the policy `emitPage` writes, for a page's HTML; `scripts` are extra script texts allowed by hash */
-export function contentSecurityPolicy(html: string, options?: CspOptions & { scripts?: string[] }): string;
-
-/** `html` with that policy as the first element of `<head>`, replacing an earlier one */
-export function withContentSecurityPolicy(html: string, options?: CspOptions & { scripts?: string[] }): string;
+export * from '@datamoc/mwg/tools/csp';