@remit/web-client 0.0.324 → 0.0.326

package/spellcheck/empty-build.test.ts

@@ -1,160 +0,0 @@
-/**
- * The self-hoster's opt-out, proven by building it.
- *
- * `REMIT_SPELLCHECK_LANGUAGES=` is the documented way to build an image with no
- * spellchecker — a small box, or an operator who does not want to carry
- * somebody else's licence obligations. What it has to produce is a *clean*
- * build: a web client that works, with no `spellcheck/` tree to serve, and none
- * of the worker's code shipped to browsers that can never start it. Nothing
- * short of a real build can tell those apart from a broken one, so this runs
- * vite twice and reads the output.
- *
- * The second build is the control. Asserting only that an empty list emits no
- * worker chunk would pass just as well if the chunk were renamed, if the
- * composer stopped reaching the worker at all, or if the build quietly produced
- * nothing — so the same assertions are made against a build that must carry it.
- */
-
-import assert from "node:assert/strict";
-import { spawnSync } from "node:child_process";
-import { mkdtempSync, readdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, relative, resolve, sep } from "node:path";
-import { after, before, describe, it } from "node:test";
-
-const packageRoot = resolve(import.meta.dirname, "..");
-
-const BUILD_TIMEOUT_MS = 600_000;
-
-const outputs: string[] = [];
-
-// A child process, because the language set is read out of the environment when
-// the plugin configures itself and two builds in one process would share it.
-const build = (languages: string): readonly string[] => {
-	const outDir = mkdtempSync(join(tmpdir(), "spellcheck-build-"));
-	outputs.push(outDir);
-	const result = spawnSync(
-		process.execPath,
-		[
-			"--input-type=module",
-			"-e",
-			`import { build } from "vite";
-			 await build({
-				 logLevel: "warn",
-				 build: { outDir: ${JSON.stringify(outDir)}, emptyOutDir: true },
-			 });`,
-		],
-		{
-			cwd: packageRoot,
-			encoding: "utf8",
-			env: { ...process.env, REMIT_SPELLCHECK_LANGUAGES: languages },
-		},
-	);
-	assert.equal(
-		result.status,
-		0,
-		`vite build with REMIT_SPELLCHECK_LANGUAGES="${languages}" failed:\n${result.stdout}\n${result.stderr}`,
-	);
-	return emitted(outDir);
-};
-
-const emitted = (root: string): readonly string[] => {
-	const found: string[] = [];
-	const walk = (current: string): void => {
-		for (const entry of readdirSync(current, { withFileTypes: true })) {
-			const full = join(current, entry.name);
-			if (entry.isDirectory()) {
-				walk(full);
-				continue;
-			}
-			found.push(relative(root, full).split(sep).join("/"));
-		}
-	};
-	walk(root);
-	return found.sort();
-};
-
-/**
- * The worker, the port it speaks over, and the bundle vite emits for the `new
- * Worker(new URL(...))` that reaches it. Vite emits that bundle while
- * transforming the module rather than while writing the output, so it survives
- * tree-shaking: its absence means the specifier never resolved there at all.
- */
-const workerChunks = (files: readonly string[]): readonly string[] =>
-	files.filter((file) => /rich-text-spellcheck-/.test(file));
-
-const spellcheckAssets = (files: readonly string[]): readonly string[] =>
-	files.filter((file) => file.startsWith("spellcheck/"));
-
-describe("a build that carries no dictionaries", () => {
-	let files: readonly string[] = [];
-
-	before(
-		() => {
-			files = build("");
-		},
-		{ timeout: BUILD_TIMEOUT_MS },
-	);
-
-	after(() => {
-		for (const outDir of outputs)
-			rmSync(outDir, { recursive: true, force: true });
-	});
-
-	it("is still a web client", () => {
-		assert.ok(files.includes("index.html"), "the build emitted no index.html");
-		assert.ok(
-			files.some((file) => file.startsWith("assets/") && file.endsWith(".js")),
-			"the build emitted no JavaScript",
-		);
-	});
-
-	it("serves no spellcheck tree", () => {
-		assert.deepEqual(spellcheckAssets(files), []);
-	});
-
-	it("ships no worker to browsers that could never start it", () => {
-		assert.deepEqual(workerChunks(files), []);
-	});
-});
-
-describe("a build that carries one", () => {
-	let files: readonly string[] = [];
-
-	before(
-		() => {
-			files = build("nl");
-		},
-		{ timeout: BUILD_TIMEOUT_MS },
-	);
-
-	it("stages the engine, the dictionary and the notice", () => {
-		// The staged directory is named after a digest of its own contents, so
-		// what is asserted is the tree under it rather than the whole path.
-		const staged = spellcheckAssets(files).map((file) =>
-			file.replace(/^spellcheck\/[0-9a-f]+\//, ""),
-		);
-		// English rides along whether or not it was asked for: it is the language
-		// every account is guaranteed to offer.
-		assert.deepEqual(staged.sort(), [
-			"LICENSE",
-			"NOTICE.txt",
-			"dictionaries/en/LICENSE",
-			"dictionaries/en/index.aff",
-			"dictionaries/en/index.dic",
-			"dictionaries/nl/LICENSE",
-			"dictionaries/nl/index.aff",
-			"dictionaries/nl/index.dic",
-			"hunspell.mjs",
-			"hunspell.wasm",
-			"license.hunspell",
-			"manifest.json",
-		]);
-	});
-
-	// The control for the two assertions above: both names are real, and a build
-	// that should carry them does.
-	it("ships the worker the empty build must not", () => {
-		assert.notDeepEqual(workerChunks(files), []);
-	});
-});

package/spellcheck/languages.test.ts

@@ -1,80 +0,0 @@
-/**
- * The switch, at the point where a self-hoster's `REMIT_SPELLCHECK_LANGUAGES`
- * becomes the set the image carries. Everything downstream — the staged files,
- * the manifest, NOTICE.txt, and what the composer believes it can check — is
- * that set and nothing else, so a wrong answer here is wrong everywhere at once.
- */
-
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import {
-	DEFAULT_SPELLCHECK_LANGUAGES,
-	DICTIONARY_SOURCES,
-	resolveLanguages,
-} from "./languages.ts";
-
-const tagsOf = (requested: string | undefined): readonly string[] =>
-	resolveLanguages(requested).map((source) => source.tag);
-
-describe("the language set an image is built with", () => {
-	it("carries the published default when nothing is asked for", () => {
-		assert.deepEqual(
-			tagsOf(undefined),
-			DEFAULT_SPELLCHECK_LANGUAGES.split(","),
-		);
-	});
-
-	// `defaultComposeLanguages` appends `en` to every account, so an image
-	// without it would leave the one language every account offers as the one
-	// language it cannot check.
-	it("carries English whether or not it was asked for", () => {
-		assert.deepEqual(tagsOf("nl"), ["en", "nl"]);
-		assert.equal(tagsOf("en,nl")[0], "en");
-	});
-
-	it("reads a tag the same however it was typed, and carries it once", () => {
-		assert.deepEqual(tagsOf(" nl , EN-gb ,nl, en "), ["en", "nl", "en-GB"]);
-	});
-
-	// The self-hoster's opt-out. An empty list is a legitimate answer and not a
-	// typo to be corrected into the default, so it does not acquire English.
-	it("carries nothing at all when the list is empty", () => {
-		assert.deepEqual(tagsOf(""), []);
-		assert.deepEqual(tagsOf("  "), []);
-		assert.deepEqual(tagsOf(",, ,"), []);
-	});
-
-	it("hands back the whole row, not just the tag", () => {
-		const [english] = resolveLanguages("en");
-		assert.equal(english.package, "dictionary-en");
-		assert.ok(english.licence.length > 0);
-		assert.ok(english.source.startsWith("https://"));
-	});
-
-	// A tag nobody can ship must stop the build rather than quietly produce an
-	// image whose NOTICE.txt is a list of what the operator asked for.
-	it("stops on a tag no dictionary covers, and says which one", () => {
-		assert.throws(
-			() => resolveLanguages("en,nl,fi"),
-			(failed: Error) => {
-				assert.match(failed.message, /"fi"/);
-				assert.match(
-					failed.message,
-					/packages\/web-client\/spellcheck\/languages/,
-				);
-				// The remedy is picking a known tag, so the message lists them.
-				for (const source of DICTIONARY_SOURCES) {
-					assert.ok(
-						failed.message.includes(source.tag),
-						`the failure does not offer ${source.tag}`,
-					);
-				}
-				return true;
-			},
-		);
-	});
-
-	it("stops on an unknown tag even when every other tag is known", () => {
-		assert.throws(() => resolveLanguages("nl,de"), /"de"/);
-	});
-});

package/spellcheck/languages.ts

@@ -1,86 +0,0 @@
-/**
- * Every dictionary this repo knows how to ship, and everything the image owes
- * for carrying one. Adding a language is a row here, its `dictionary-*` package
- * in `devDependencies`, and its tag in `REMIT_SPELLCHECK_LANGUAGES` — no code.
- *
- * A `.aff` and a `.dic` are data an engine reads at runtime, so carrying one is
- * aggregation and reader's own licence is untouched. What each licence does
- * oblige is that its text travels with the file and that the served bytes are
- * the upstream source; both are build outputs, generated from this table.
- */
-
-export interface DictionarySource {
-	/** BCP 47, and the directory name the browser fetches under. */
-	readonly tag: string;
-	readonly package: string;
-	readonly project: string;
-	readonly authors: string;
-	readonly source: string;
-	/** SPDX, with the option taken where upstream offers a choice. */
-	readonly licence: string;
-}
-
-export const DICTIONARY_SOURCES: readonly DictionarySource[] = [
-	{
-		tag: "en",
-		package: "dictionary-en",
-		project: "SCOWL",
-		authors: "Kevin Atkinson and contributors",
-		source: "https://github.com/wooorm/dictionaries/tree/main/dictionaries/en",
-		licence: "MIT AND BSD-3-Clause",
-	},
-	{
-		tag: "en-GB",
-		package: "dictionary-en-gb",
-		project: "SCOWL",
-		authors: "Kevin Atkinson and contributors",
-		source:
-			"https://github.com/wooorm/dictionaries/tree/main/dictionaries/en-GB",
-		licence: "MIT AND BSD-3-Clause",
-	},
-	{
-		tag: "nl",
-		package: "dictionary-nl",
-		project: "OpenTaal",
-		authors: "Stichting OpenTaal",
-		source: "https://github.com/wooorm/dictionaries/tree/main/dictionaries/nl",
-		licence: "CC-BY-3.0",
-	},
-];
-
-/**
- * What the published image carries. Everything else in the table above is a
- * language this repo can build and does not; the list is the switch.
- */
-export const DEFAULT_SPELLCHECK_LANGUAGES = "en,en-GB,nl";
-
-/**
- * `defaultComposeLanguages` appends `en` to every account's candidate set, so a
- * build without it would leave the one language every account is guaranteed to
- * offer as the one with no dictionary. The switch normalises rather than
- * validates.
- */
-export const resolveLanguages = (
-	requested: string | undefined,
-): readonly DictionarySource[] => {
-	const asked = (requested ?? DEFAULT_SPELLCHECK_LANGUAGES)
-		.split(",")
-		.map((tag) => tag.trim())
-		.filter((tag) => tag !== "");
-	if (asked.length === 0) return [];
-
-	const known = new Map(
-		DICTIONARY_SOURCES.map((source) => [source.tag.toLowerCase(), source]),
-	);
-	const wanted: DictionarySource[] = [];
-	for (const tag of ["en", ...asked]) {
-		const source = known.get(tag.toLowerCase());
-		if (!source) {
-			throw new Error(
-				`REMIT_SPELLCHECK_LANGUAGES names "${tag}", which no dictionary in packages/web-client/spellcheck/languages.ts covers. Known tags: ${DICTIONARY_SOURCES.map((entry) => entry.tag).join(", ")}.`,
-			);
-		}
-		if (!wanted.includes(source)) wanted.push(source);
-	}
-	return wanted;
-};

package/spellcheck/vite-plugin-licence.test.ts

@@ -1,140 +0,0 @@
-/**
- * A dictionary whose licence text cannot travel with it must stop the build.
- *
- * Every licence in the table obliges the text to ship alongside the files, and
- * the build generates NOTICE.txt from the same rows — so a package that lost its
- * licence file (an upstream repackage, a pruned install) would otherwise produce
- * an image whose notice points at a `LICENSE` nobody staged. That is the one
- * failure mode a reader cannot see and a distributor is answerable for.
- *
- * The dictionary is shadowed inside this test's own temporary tree rather than
- * anywhere on the shared resolution path: the plugin sources are copied in
- * beside a private `node_modules`, so `require.resolve` from that copy answers
- * for the shadow and nowhere else. Planting into `spellcheck/node_modules`
- * instead would be visible to every other test file — node's runner isolates
- * the module cache per process, never the filesystem, and runs files
- * concurrently.
- */
-
-import assert from "node:assert/strict";
-import {
-	copyFileSync,
-	mkdirSync,
-	mkdtempSync,
-	readdirSync,
-	rmSync,
-	writeFileSync,
-} from "node:fs";
-import { createRequire } from "node:module";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { after, describe, it } from "node:test";
-import { pathToFileURL } from "node:url";
-
-const here = import.meta.dirname;
-const tmpRoot = mkdtempSync(join(tmpdir(), "spellcheck-licence-"));
-after(() => {
-	rmSync(tmpRoot, { recursive: true, force: true });
-});
-
-// The plugin under test, imported from inside the temporary tree so its
-// package resolution starts at the tree's own `node_modules`.
-const src = join(tmpRoot, "spellcheck");
-const engineDir = join(tmpRoot, "engine");
-mkdirSync(src, { recursive: true });
-// Every local import of vite-plugin.ts must be listed here.
-for (const name of ["vite-plugin.ts", "languages.ts"]) {
-	copyFileSync(join(here, name), join(src, name));
-}
-
-// A licence-less shadow of `dictionary-en-gb`, plus the real `dictionary-en`
-// copied across for the case that does stage a licence.
-const modules = join(tmpRoot, "node_modules");
-const real = (name: string) =>
-	dirname(createRequire(import.meta.url).resolve(name));
-const shadow = join(modules, "dictionary-en-gb");
-mkdirSync(shadow, { recursive: true });
-writeFileSync(
-	join(shadow, "package.json"),
-	JSON.stringify({ name: "dictionary-en-gb", version: "0.0.0-shadow" }),
-);
-writeFileSync(join(shadow, "index.js"), "");
-writeFileSync(join(shadow, "index.aff"), "SET UTF-8\n");
-writeFileSync(join(shadow, "index.dic"), "1\nword\n");
-const realEn = real("dictionary-en");
-const stagedEn = join(modules, "dictionary-en");
-mkdirSync(stagedEn, { recursive: true });
-for (const entry of [
-	"package.json",
-	"index.js",
-	"index.aff",
-	"index.dic",
-] as const) {
-	copyFileSync(join(realEn, entry), join(stagedEn, entry));
-}
-// The licence text under whatever name upstream ships it.
-const licenceFile = readdirSync(realEn).find((entry) =>
-	/^licen[cs]e/i.test(entry),
-);
-assert.ok(licenceFile);
-copyFileSync(join(realEn, licenceFile), join(stagedEn, licenceFile));
-
-// Pins read from beside the engine; the stub carries its own.
-mkdirSync(engineDir, { recursive: true });
-for (const name of [
-	"hunspell.wasm",
-	"hunspell.mjs",
-	"LICENSE",
-	"license.hunspell",
-]) {
-	writeFileSync(join(engineDir, name), "stub");
-}
-writeFileSync(
-	join(engineDir, "pin.env"),
-	["HUNSPELL_VERSION=0.0.0-test", "HUNSPELL_SHA256=test"].join("\n"),
-);
-process.env.REMIT_SPELLCHECK_ENGINE_DIR = engineDir;
-
-const { stageSpellcheck }: typeof import("./vite-plugin.ts") = await import(
-	pathToFileURL(join(src, "vite-plugin.ts")).href
-);
-
-describe("a dictionary that ships no licence text", () => {
-	it("stops the build rather than staging it", () => {
-		assert.throws(() => stageSpellcheck("en-GB", "/"));
-	});
-
-	// The remedy is the whole message: which directory, and why a missing
-	// licence file is fatal rather than something the notice can paper over.
-	it("names the directory and what is wrong with it", () => {
-		assert.throws(
-			() => stageSpellcheck("en-GB", "/"),
-			(failed: Error) => {
-				assert.ok(
-					failed.message.includes(shadow),
-					`the failure does not name the dictionary directory: ${failed.message}`,
-				);
-				assert.match(failed.message, /licence/i);
-				assert.match(failed.message, /NOTICE\.txt/);
-				return true;
-			},
-		);
-	});
-
-	// The languages before the broken one must not reach the output either: a
-	// half-staged tree with a complete-looking notice is worse than no build.
-	it("takes the whole build with it, not just that language", () => {
-		assert.throws(() => stageSpellcheck("en,en-GB", "/"));
-	});
-});
-
-describe("a dictionary that does ship one", () => {
-	it("stages the licence text beside the files it covers", () => {
-		const build = stageSpellcheck("en", "/");
-		const licence = build.files.find(
-			(file) => file.path === "dictionaries/en/LICENSE",
-		);
-		assert.ok(licence);
-		assert.ok(licence.source.byteLength > 0);
-	});
-});

package/spellcheck/vite-plugin.test.ts

@@ -1,230 +0,0 @@
-/**
- * What the build stages, and whether NOTICE.txt describes it.
- *
- * The licence obligation this repo took on is that the notice matches the image
- * exactly and that the served dictionary is the upstream file — which is the
- * whole reason the language set is fixed at build time rather than chosen at
- * run time. A notice that names a dictionary the image does not carry, or omits
- * one it does, is a licence failure and not a cosmetic one, so the chain from
- * the resolved set through the manifest to the notice is asserted end to end
- * rather than at either end.
- *
- * This runs in the checkout, against the dictionary packages actually
- * installed, which is what makes the byte-for-byte and licence-text assertions
- * mean anything. `npm-scripts/lib/spellcheck-staging.test.mjs` is the other
- * half: the same function against a synthetic tree shaped like the published
- * package, where the question is which file gets read and what a distributor is
- * told when one is missing. Base, `servePath` and the digest belong to that
- * one.
- *
- * The engine is stubbed: what it weighs is gated where it is built
- * (npm-scripts/build-hunspell.mjs), and staging it here would make every one of
- * these tests wait on a WebAssembly toolchain.
- */
-
-import assert from "node:assert/strict";
-import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { describe, it } from "node:test";
-
-const require = createRequire(import.meta.url);
-
-const ENGINE_FILES = {
-	"hunspell.wasm": "\0asm stub",
-	"hunspell.mjs": "export default () => {};",
-	LICENSE: "Mozilla Public Licence 1.1, stub",
-	"license.hunspell": "Hunspell licence, stub",
-};
-
-const engineDir = mkdtempSync(join(tmpdir(), "spellcheck-engine-"));
-for (const [name, body] of Object.entries(ENGINE_FILES)) {
-	writeFileSync(join(engineDir, name), body);
-}
-
-process.env.REMIT_SPELLCHECK_ENGINE_DIR = engineDir;
-const { stageSpellcheck } = await import("./vite-plugin.ts");
-
-const staged = (requested: string) => stageSpellcheck(requested, "/");
-
-const fileNamed = (
-	build: ReturnType<typeof staged>,
-	path: string,
-): Buffer | undefined => build.files.find((file) => file.path === path)?.source;
-
-const textOf = (build: ReturnType<typeof staged>, path: string): string => {
-	const found = fileNamed(build, path);
-	if (!found) throw new Error(`${path} was not staged`);
-	return found.toString("utf8");
-};
-
-/** The tags NOTICE.txt claims this image carries, read back off the notice. */
-const tagsNoticed = (notice: string): readonly string[] => {
-	const dictionaries = notice.split("\nDictionaries\n")[1];
-	if (dictionaries === undefined) {
-		throw new Error("NOTICE.txt has no Dictionaries section");
-	}
-	return dictionaries
-		.split("\n")
-		.map((line) => /^(\S+) — /.exec(line)?.[1])
-		.filter((tag): tag is string => tag !== undefined);
-};
-
-/** The tags the image actually carries a dictionary for. */
-const tagsStaged = (build: ReturnType<typeof staged>): readonly string[] => [
-	...new Set(
-		build.files
-			.map((file) => /^dictionaries\/([^/]+)\//.exec(file.path)?.[1])
-			.filter((tag): tag is string => tag !== undefined),
-	),
-];
-
-describe("what a build stages", () => {
-	it("stages the engine, both dictionary files and a licence per language", () => {
-		const build = staged("en,nl");
-		const paths = build.files.map((file) => file.path).sort();
-		assert.deepEqual(paths, [
-			"LICENSE",
-			"NOTICE.txt",
-			"dictionaries/en/LICENSE",
-			"dictionaries/en/index.aff",
-			"dictionaries/en/index.dic",
-			"dictionaries/nl/LICENSE",
-			"dictionaries/nl/index.aff",
-			"dictionaries/nl/index.dic",
-			"hunspell.mjs",
-			"hunspell.wasm",
-			"license.hunspell",
-			"manifest.json",
-		]);
-	});
-
-	// GPL and MPL correspondence is discharged by the served file being the
-	// upstream one. Anything that rewrote a dictionary on the way through —
-	// a normaliser, a re-encode, a line-ending fix — would break that quietly.
-	it("serves the upstream dictionary byte for byte", () => {
-		const build = staged("nl");
-		const upstream = dirname(require.resolve("dictionary-nl"));
-		for (const name of ["index.aff", "index.dic"]) {
-			assert.deepEqual(
-				fileNamed(build, `dictionaries/nl/${name}`),
-				readFileSync(join(upstream, name)),
-				`dictionaries/nl/${name} is not the upstream file`,
-			);
-		}
-	});
-});
-
-describe("NOTICE.txt", () => {
-	it("names every language the image carries", () => {
-		const build = staged("en,en-GB,nl");
-		const noticed = tagsNoticed(textOf(build, "NOTICE.txt"));
-		assert.deepEqual([...noticed].sort(), ["en", "en-GB", "nl"]);
-	});
-
-	// Over-claiming is the failure that matters: a notice listing a dictionary
-	// the image does not carry offers a licence text nobody can find, and one
-	// missing a dictionary it does carry ships that dictionary with no licence
-	// at all. Both are the same defect from opposite sides, so the three lists
-	// the build produces are compared to each other rather than to a fixture.
-	it("names only the languages the image carries", () => {
-		for (const requested of ["en", "nl", "en,en-GB,nl"]) {
-			const build = staged(requested);
-			const notice = textOf(build, "NOTICE.txt");
-			const carried = tagsStaged(build);
-			const manifest = JSON.parse(textOf(build, "manifest.json"));
-
-			assert.deepEqual(
-				[...tagsNoticed(notice)].sort(),
-				[...carried].sort(),
-				`NOTICE.txt and the staged dictionaries disagree for "${requested}"`,
-			);
-			assert.deepEqual(
-				manifest.languages.map((language: { tag: string }) => language.tag),
-				build.languages.map((language) => language.tag),
-			);
-			assert.deepEqual(
-				[...carried].sort(),
-				build.languages.map((language) => language.tag).sort(),
-			);
-		}
-	});
-
-	it("points every language at a licence text the image ships", () => {
-		const build = staged("en,en-GB,nl");
-		const notice = textOf(build, "NOTICE.txt");
-		const referenced = [...notice.matchAll(/Licence text: (\S+?),/g)]
-			.map((match) => match[1])
-			.sort();
-		assert.deepEqual(referenced, [
-			"LICENSE",
-			"dictionaries/en-GB/LICENSE",
-			"dictionaries/en/LICENSE",
-			"dictionaries/nl/LICENSE",
-		]);
-		for (const path of referenced) {
-			const licence = fileNamed(build, path);
-			assert.ok(licence, `NOTICE.txt names ${path}, which is not staged`);
-			assert.ok(licence.byteLength > 0, `${path} is empty`);
-		}
-	});
-
-	it("states each licence, its author and the version that was staged", () => {
-		const build = staged("nl");
-		const notice = textOf(build, "NOTICE.txt");
-		const [dutch] = build.languages.filter((language) => language.tag === "nl");
-		assert.match(notice, /nl — OpenTaal/);
-		assert.ok(notice.includes(`Licence: ${dutch.licence}`));
-		assert.ok(notice.includes(`Authors: ${dutch.authors}`));
-		assert.ok(notice.includes(`dictionary-nl@${dutch.version}`));
-		assert.match(dutch.version, /^\d+\.\d+\.\d+/);
-	});
-
-	it("says the served files are the source where a licence requires it", () => {
-		const gpl = textOf(staged("nl,en"), "NOTICE.txt");
-		// Neither English nor Dutch is under a correspondence licence here, so
-		// the sentence must not appear; German would bring it.
-		assert.ok(!gpl.includes("unmodified upstream source"));
-	});
-
-	it("carries the engine's own provenance, checksum included", () => {
-		const notice = textOf(staged("en"), "NOTICE.txt");
-		const pins = readFileSync(
-			join(
-				import.meta.dirname,
-				"..",
-				"..",
-				"..",
-				"docker",
-				"hunspell",
-				"pin.env",
-			),
-			"utf8",
-		);
-		const version = /HUNSPELL_VERSION=(\S+)/.exec(pins)?.[1];
-		const sha = /HUNSPELL_SHA256=(\S+)/.exec(pins)?.[1];
-		assert.ok(version && sha);
-		assert.ok(notice.includes(`Hunspell ${version}`));
-		assert.ok(notice.includes(sha));
-	});
-});
-
-describe("the manifest the app reads", () => {
-	it("describes the engine and every language it staged", () => {
-		const build = staged("en,nl");
-		const manifest = JSON.parse(textOf(build, "manifest.json"));
-		assert.equal(manifest.engine.project, "Hunspell");
-		assert.equal(manifest.engine.licence, "MPL-1.1");
-		assert.deepEqual(
-			manifest.languages.map(
-				(language: { licenceFile: string }) => language.licenceFile,
-			),
-			["dictionaries/en/LICENSE", "dictionaries/nl/LICENSE"],
-		);
-		for (const language of manifest.languages) {
-			assert.ok(fileNamed(build, language.licenceFile));
-			assert.match(language.package, /@\d+\.\d+\.\d+/);
-		}
-	});
-});