@remit/web-client 0.0.324 → 0.0.326

package/dist/harness/index.html

@@ -0,0 +1,50 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover" />
+    <title>Remit</title>
+    <!--
+      Installability. The preset serves this page for every host. The two theme colours are the light and dark --canvas tokens from
+      packages/ui/src/tokens.css.
+    -->
+    <link rel="manifest" href="/manifest.webmanifest" />
+    <link rel="apple-touch-icon" href="/apple-touch-icon.png" />
+    <link rel="icon" href="/favicon.ico" sizes="16x16 32x32" />
+    <link rel="icon" href="/icons/icon-192.png" type="image/png" sizes="192x192" />
+    <meta name="apple-mobile-web-app-capable" content="yes" />
+    <meta name="apple-mobile-web-app-title" content="Remit" />
+    <meta name="apple-mobile-web-app-status-bar-style" content="default" />
+    <meta name="theme-color" media="(prefers-color-scheme: light)" content="#f6f2e7" />
+    <meta name="theme-color" media="(prefers-color-scheme: dark)" content="#0c1d23" />
+    <!--
+      Pre-paint theme to avoid a flash-of-wrong-theme on reload. Mirrors
+      theme-preference.ts: a stored "remit.theme" of "light"/"dark" wins;
+      "system" (or no key) follows prefers-color-scheme.
+    -->
+    <script>
+      (function () {
+        try {
+          var pref = localStorage.getItem("remit.theme");
+          var isDark =
+            pref === "dark" ||
+            (pref !== "light" &&
+              window.matchMedia &&
+              window.matchMedia("(prefers-color-scheme: dark)").matches);
+          document.documentElement.classList.toggle("dark", isDark);
+        } catch (_) {}
+      })();
+    </script>
+  </head>
+  <body>
+    <div id="root"></div>
+    <!--
+      Runtime deployment config. A classic (non-module) script so it runs before
+      the deferred module bundle: it sets window.__REMIT_CONFIG__, read by the
+      runtime-config primitive. Served from the distributor's public dir and
+      replaced per deployment; never bundled.
+    -->
+    <script src="/config.js"></script>
+    <script type="module" src="/@remit-web-client/entry"></script>
+  </body>
+</html>

package/dist/harness/vite-preset.d.ts

@@ -0,0 +1,10 @@
+import type { UserConfig } from "vite";
+export interface WebClientPresetOptions {
+    /** The module that calls `mountApp`, relative to the vite root. */
+    entry: string;
+    /** Written to `config.js` in the build; the package default otherwise. */
+    runtimeConfig?: Record<string, unknown>;
+    /** The commit the bundle names; GITHUB_SHA or `git rev-parse HEAD` otherwise. */
+    commit?: string;
+}
+export declare const webClientPreset: ({ entry, runtimeConfig, commit, }: WebClientPresetOptions) => UserConfig;

package/dist/harness/vite-preset.js

@@ -0,0 +1,151 @@
+import { execSync } from "node:child_process";
+import { readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import tailwindcss from "@tailwindcss/vite";
+import { tanstackRouter } from "@tanstack/router-plugin/vite";
+import react from "@vitejs/plugin-react";
+import { spellcheckPlugin } from "../spellcheck/vite-plugin.js";
+import { spellcheckWorkerStub } from "../spellcheck/worker-stub.js";
+const here = dirname(fileURLToPath(import.meta.url));
+const compiled = !import.meta.url.endsWith(".ts");
+const codeRoot = resolve(here, "..");
+const packageRoot = compiled ? resolve(codeRoot, "..") : codeRoot;
+const ENTRY_ID = "/@remit-web-client/entry";
+const resolveGitSha = () => {
+    if (process.env.GITHUB_SHA)
+        return process.env.GITHUB_SHA;
+    try {
+        return execSync("git rev-parse HEAD", { encoding: "utf8" }).trim();
+    }
+    catch {
+        return "dev";
+    }
+};
+const isPageRequest = (req) => req.method === "GET" &&
+    (req.headers.accept ?? "").includes("text/html") &&
+    !(req.url ?? "").startsWith("/api");
+const indexHtml = (entry) => {
+    const template = () => readFileSync(join(codeRoot, "harness", "index.html"), "utf8");
+    let indexPath = "";
+    let entryPath = "";
+    return {
+        name: "remit-web-client-index-html",
+        config: () => ({ build: { rollupOptions: { input: "index.html" } } }),
+        configResolved(config) {
+            indexPath = resolve(config.root, "index.html");
+            entryPath = resolve(config.root, entry);
+        },
+        resolveId(id) {
+            if (id === ENTRY_ID)
+                return entryPath;
+            if (resolve(dirname(indexPath), id) === indexPath)
+                return indexPath;
+            return null;
+        },
+        load(id) {
+            return id === indexPath ? template() : null;
+        },
+        configureServer(server) {
+            return () => {
+                server.middlewares.use(async (req, res, next) => {
+                    if (!isPageRequest(req))
+                        return next();
+                    const html = await server.transformIndexHtml(req.url ?? "/", template());
+                    res.setHeader("Content-Type", "text/html");
+                    res.end(html);
+                });
+            };
+        },
+    };
+};
+const runtimeConfigFile = (runtimeConfig) => {
+    const served = () => process.env.REMIT_RUNTIME_CONFIG ??
+        (runtimeConfig ? JSON.stringify(runtimeConfig) : undefined);
+    const serve = (req, res, next) => {
+        const body = served();
+        if (req.url !== "/config.js" || body === undefined) {
+            next();
+            return;
+        }
+        res.setHeader("Content-Type", "application/javascript");
+        res.end(`window.__REMIT_CONFIG__ = ${body};\n`);
+    };
+    let outDir = "";
+    return {
+        name: "remit-web-client-runtime-config",
+        configResolved(config) {
+            outDir = resolve(config.root, config.build.outDir);
+        },
+        configureServer(server) {
+            server.middlewares.use(serve);
+        },
+        configurePreviewServer(server) {
+            server.middlewares.use(serve);
+        },
+        closeBundle() {
+            if (!runtimeConfig)
+                return;
+            writeFileSync(join(outDir, "config.js"), `window.__REMIT_CONFIG__ = ${JSON.stringify(runtimeConfig)};\n`);
+        },
+    };
+};
+const routes = () => tanstackRouter({
+    target: "react",
+    autoCodeSplitting: true,
+    routesDirectory: join(codeRoot, "src", "routes"),
+    generatedRouteTree: join(codeRoot, "src", compiled ? "routeTree.gen.js" : "routeTree.gen.ts"),
+    disableTypes: compiled,
+    routeFileIgnorePattern: "\\.d\\.ts$",
+});
+const backendProxy = () => {
+    const target = `http://localhost:${process.env.VITE_PROXY_BACKEND_PORT ?? "5433"}`;
+    return {
+        "/api/auth": { target, changeOrigin: true },
+        "/api": {
+            target,
+            changeOrigin: true,
+            rewrite: (path) => path.replace(/^\/api/, ""),
+        },
+        "/content": { target, changeOrigin: true },
+        "/feeds/calendar": { target, changeOrigin: true },
+        "/outbox-upload": { target, changeOrigin: true },
+    };
+};
+const allowedHosts = () => process.env.VITE_ALLOWED_HOST ? [process.env.VITE_ALLOWED_HOST] : undefined;
+/**
+ * Rollup keeps up to `maxParallelFileOps` module reads in flight, and each one
+ * holds a file descriptor. Its default of 1000 is above the 1024 `RLIMIT_NOFILE`
+ * soft limit that container runtimes hand a build step, and the icon barrels this
+ * app imports (lucide-react re-exports ~1500 single-icon modules) give rollup
+ * enough sibling modules to saturate the ceiling, so the default reliably fails
+ * with EMFILE inside an image build while passing on a developer machine.
+ */
+const MAX_PARALLEL_FILE_OPS = 64;
+export const webClientPreset = ({ entry, runtimeConfig, commit, }) => ({
+    plugins: [
+        indexHtml(entry),
+        runtimeConfigFile(runtimeConfig),
+        routes(),
+        react(),
+        tailwindcss(),
+        spellcheckPlugin(),
+        spellcheckWorkerStub(),
+    ],
+    publicDir: join(packageRoot, "public"),
+    define: {
+        __APP_SHA__: JSON.stringify(commit ?? resolveGitSha()),
+        __APP_BUILD_TIME__: JSON.stringify(new Date().toISOString()),
+    },
+    build: { rollupOptions: { maxParallelFileOps: MAX_PARALLEL_FILE_OPS } },
+    server: {
+        host: "0.0.0.0",
+        allowedHosts: allowedHosts(),
+        proxy: backendProxy(),
+    },
+    preview: {
+        host: "0.0.0.0",
+        allowedHosts: allowedHosts(),
+        proxy: backendProxy(),
+    },
+});

package/dist/spellcheck/languages.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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 declare const DICTIONARY_SOURCES: readonly DictionarySource[];
+/**
+ * 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 declare 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 declare const resolveLanguages: (requested: string | undefined) => readonly DictionarySource[];

package/dist/spellcheck/languages.js

@@ -0,0 +1,66 @@
+/**
+ * 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 const DICTIONARY_SOURCES = [
+    {
+        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) => {
+    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 = [];
+    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/dist/spellcheck/vite-plugin.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Turns `REMIT_SPELLCHECK_LANGUAGES` into what the browser fetches: the engine,
+ * one directory per language holding the upstream `.aff`, `.dic` and licence
+ * text byte for byte, a manifest, and the notice generated from it.
+ *
+ * Nothing here is bundled and nothing is fetched at page load. The build's own
+ * job is that the notice describes the image exactly — which is the reason the
+ * language set is fixed at build time at all — so a tag nobody can ship, or a
+ * dictionary whose licence file is missing, fails the build by name.
+ *
+ * The engine comes from `@remit/spellcheck-engine`, which reader builds from
+ * its Hunspell recipe and publishes. Every failure below names the file it
+ * wanted and both ways past it — `REMIT_SPELLCHECK_ENGINE_DIR` for an engine
+ * built elsewhere, and an empty `REMIT_SPELLCHECK_LANGUAGES` for a build with
+ * no spellchecker at all.
+ */
+import type { Plugin } from "vite";
+import type { DictionarySource } from "./languages.ts";
+interface StagedFile {
+    readonly path: string;
+    readonly source: Buffer;
+}
+interface StagedLanguage extends DictionarySource {
+    readonly version: string;
+    readonly bytes: number;
+    readonly files: readonly StagedFile[];
+}
+export interface SpellcheckBuild {
+    readonly languages: readonly StagedLanguage[];
+    /** Paths relative to `directory`, which is where all of them are emitted. */
+    readonly files: readonly StagedFile[];
+    /** `spellcheck/<digest>/`, relative to the build's output root. */
+    readonly directory: string;
+    /** What the browser resolves against the document to reach `directory`. */
+    readonly base: string;
+    /** Where the dev server answers for `directory`, always document-rooted. */
+    readonly servePath: string;
+    /** Tag → the bytes opening that language downloads, engine included. */
+    readonly bytes: Readonly<Record<string, number>>;
+}
+export declare const stageSpellcheck: (requested: string | undefined, viteBase: string | undefined) => SpellcheckBuild;
+export declare const spellcheckPlugin: () => Plugin;
+export {};

package/dist/spellcheck/vite-plugin.js

@@ -0,0 +1,294 @@
+/**
+ * Turns `REMIT_SPELLCHECK_LANGUAGES` into what the browser fetches: the engine,
+ * one directory per language holding the upstream `.aff`, `.dic` and licence
+ * text byte for byte, a manifest, and the notice generated from it.
+ *
+ * Nothing here is bundled and nothing is fetched at page load. The build's own
+ * job is that the notice describes the image exactly — which is the reason the
+ * language set is fixed at build time at all — so a tag nobody can ship, or a
+ * dictionary whose licence file is missing, fails the build by name.
+ *
+ * The engine comes from `@remit/spellcheck-engine`, which reader builds from
+ * its Hunspell recipe and publishes. Every failure below names the file it
+ * wanted and both ways past it — `REMIT_SPELLCHECK_ENGINE_DIR` for an engine
+ * built elsewhere, and an empty `REMIT_SPELLCHECK_LANGUAGES` for a build with
+ * no spellchecker at all.
+ */
+import { createHash } from "node:crypto";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { resolveLanguages } from "./languages.js";
+const require = createRequire(import.meta.url);
+const engineDir = () => {
+    const configured = process.env.REMIT_SPELLCHECK_ENGINE_DIR;
+    if (configured !== undefined)
+        return configured;
+    const manifest = "@remit/spellcheck-engine/package.json";
+    if (require.resolve
+        .paths(manifest)
+        ?.some((dir) => existsSync(join(dir, manifest)))) {
+        return dirname(require.resolve(manifest));
+    }
+    throw new Error(`@remit/spellcheck-engine is not installed, so this build has no spellchecking engine to serve.\n${WAYS_OUT}`);
+};
+const WAYS_OUT = [
+    "Set REMIT_SPELLCHECK_ENGINE_DIR to a directory holding hunspell.wasm, hunspell.mjs, LICENSE, license.hunspell and pin.env, or install @remit/spellcheck-engine, which holds all five.",
+    "Or set REMIT_SPELLCHECK_LANGUAGES= (empty) to build a web client with no spellchecker at all; the browser's own checker stays on either way.",
+].join("\n");
+const LICENCE_NAMES = ["LICENSE", "license", "LICENCE", "licence"];
+/** The engine's own files, in the order the browser needs them explained. */
+const ENGINE_FILES = [
+    "hunspell.wasm",
+    "hunspell.mjs",
+    "LICENSE",
+    "license.hunspell",
+];
+/**
+ * The pins describe the engine, so they are read from beside it, and the
+ * checksum in NOTICE.txt is the checksum of the bytes being served.
+ */
+const pinFile = () => {
+    const beside = join(engineDir(), "pin.env");
+    if (existsSync(beside))
+        return beside;
+    throw new Error(`The engine at ${engineDir()} carries no pin.env, so nothing here can say which Hunspell release is being served and NOTICE.txt would have to guess.\n${WAYS_OUT}`);
+};
+let pins = null;
+const readPin = (name) => {
+    const path = pinFile();
+    pins ??= Object.fromEntries(readFileSync(path, "utf8")
+        .split("\n")
+        .flatMap((line) => {
+        const match = /^([A-Z0-9_]+)=(.*)$/.exec(line.trim());
+        return match ? [[match[1], match[2]]] : [];
+    }));
+    const found = pins[name];
+    if (found === undefined)
+        throw new Error(`${path} has no ${name}`);
+    return found;
+};
+const licenceIn = (directory) => {
+    const named = LICENCE_NAMES.find((name) => existsSync(join(directory, name)));
+    if (named)
+        return named;
+    const found = readdirSync(directory).find((entry) => /^licen[cs]e/i.test(entry));
+    if (found)
+        return found;
+    throw new Error(`${directory} ships no licence file. A dictionary whose licence text cannot travel with it cannot ship, so the build stops here rather than producing a NOTICE.txt that claims one exists.`);
+};
+const stageEngine = () => ENGINE_FILES.map((name) => {
+    const path = join(engineDir(), name);
+    if (!existsSync(path)) {
+        throw new Error(`${path} is missing, so this build has no spellchecking engine to serve.\n${WAYS_OUT}`);
+    }
+    return { path: name, source: readFileSync(path) };
+});
+/**
+ * A `dictionary-*` package is a devDependency of @remit/web-client, which a
+ * consumer of the published tarball never receives — so a missing one is the
+ * ordinary case out here, not a broken install.
+ */
+const dictionaryDir = (source) => {
+    try {
+        // Resolved through the package's own entry point: `dictionary-*` declares an
+        // `exports` map, so its package.json is not a resolvable subpath.
+        return dirname(require.resolve(source.package));
+    }
+    catch {
+        throw new Error(`${source.package} is not installed, so the ${source.tag} dictionary cannot be staged. It is a devDependency of @remit/web-client and a consumer of the published package never gets it.\nInstall ${source.package} alongside @remit/web-client, or drop "${source.tag}" from REMIT_SPELLCHECK_LANGUAGES — set it empty to build with no spellchecker at all.`);
+    }
+};
+const stageLanguage = (source) => {
+    const directory = dictionaryDir(source);
+    const version = JSON.parse(readFileSync(join(directory, "package.json"), "utf8")).version;
+    const licence = licenceIn(directory);
+    const at = (name) => `dictionaries/${source.tag}/${name}`;
+    const aff = readFileSync(join(directory, "index.aff"));
+    const dic = readFileSync(join(directory, "index.dic"));
+    return {
+        ...source,
+        version,
+        bytes: aff.byteLength + dic.byteLength,
+        files: [
+            { path: at("index.aff"), source: aff },
+            { path: at("index.dic"), source: dic },
+            { path: at("LICENSE"), source: readFileSync(join(directory, licence)) },
+        ],
+    };
+};
+/** A licence that says the served form must be the source says it out loud. */
+const correspondence = (licence) => /GPL|MPL/.test(licence.toUpperCase());
+const noticeFor = (engineVersion, languages) => {
+    const blocks = languages.map((language) => [
+        `${language.tag} — ${language.project}`,
+        `  Authors: ${language.authors}`,
+        `  Source: ${language.source}`,
+        `  Package: ${language.package}@${language.version}`,
+        `  Licence: ${language.licence}`,
+        `  Licence text: dictionaries/${language.tag}/LICENSE, beside this file`,
+        ...(correspondence(language.licence)
+            ? [
+                `  The served index.aff and index.dic are the unmodified upstream source.`,
+            ]
+            : []),
+    ].join("\n"));
+    return [
+        "This build of Remit Reader carries the spelling dictionaries listed below.",
+        "Each stays under its own licence; the licence text travels with the files,",
+        "and nothing in this image modifies a dictionary. Reader itself is MIT.",
+        "",
+        "Engine",
+        "",
+        `  Hunspell ${engineVersion}`,
+        "  Source: https://github.com/hunspell/hunspell",
+        `  Tarball: https://github.com/hunspell/hunspell/releases/download/v${engineVersion}/hunspell-${engineVersion}.tar.gz`,
+        `  sha256: ${readPin("HUNSPELL_SHA256")}`,
+        "  Licence: MPL-1.1 (the option taken from Hunspell's MPL-1.1/GPL-2.0/LGPL-2.1 triple)",
+        "  Licence text: LICENSE, beside this file",
+        "  Build recipe: https://github.com/remit-mail/reader/blob/main/docker/hunspell/build.sh",
+        "",
+        "Dictionaries",
+        "",
+        ...blocks.map((block) => `${block}\n`),
+    ].join("\n");
+};
+const EMPTY_BUILD = {
+    languages: [],
+    files: [],
+    directory: "",
+    base: "",
+    servePath: "",
+    bytes: {},
+};
+/**
+ * One digest over everything served, folded into the directory name. Nothing
+ * the browser fetches is versioned otherwise — `hunspell.wasm` and `index.dic`
+ * are the same two paths in every build — and an unversioned path cannot be
+ * cached, which is what left every composer open re-downloading its dictionary.
+ */
+const digestOf = (files) => {
+    const hash = createHash("sha256");
+    for (const file of [...files].sort((left, right) => left.path.localeCompare(right.path))) {
+        hash.update(file.path);
+        hash.update("\0");
+        hash.update(file.source);
+    }
+    return hash.digest("hex").slice(0, 16);
+};
+const documentRooted = (viteBase) => viteBase === undefined || viteBase.startsWith("/");
+/**
+ * An absolute base names where the app is mounted, and the staged directory
+ * hangs off it. A relative one — Storybook's, always `./` — belongs to a build
+ * published under a path it cannot know here (`/reader-ui/pr/<n>/<sha>/`), so it
+ * gets the directory alone and the document resolves it at run time. An unset
+ * base is vite's own default of `/`, not a relative one.
+ */
+const browserBase = (viteBase, directory) => documentRooted(viteBase)
+    ? `${(viteBase ?? "/").replace(/\/$/, "")}/${directory}`
+    : directory;
+export const stageSpellcheck = (requested, viteBase) => {
+    const wanted = resolveLanguages(requested);
+    if (wanted.length === 0)
+        return EMPTY_BUILD;
+    // The engine first: it is the file a build outside this repo is most likely
+    // to be missing, and its error is the one that names both ways out.
+    const engine = stageEngine();
+    const engineVersion = readPin("HUNSPELL_VERSION");
+    const languages = wanted.map(stageLanguage);
+    const wasmBytes = engine.find((file) => file.path === "hunspell.wasm")?.source.byteLength ??
+        0;
+    const payload = [
+        ...engine,
+        ...languages.flatMap((language) => language.files),
+    ];
+    const directory = `spellcheck/${digestOf(payload)}/`;
+    const manifest = {
+        engine: {
+            project: "Hunspell",
+            version: engineVersion,
+            licence: "MPL-1.1",
+            source: "https://github.com/hunspell/hunspell",
+            recipe: "https://github.com/remit-mail/reader/blob/main/docker/hunspell/build.sh",
+            bytes: wasmBytes,
+        },
+        languages: languages.map((language) => ({
+            tag: language.tag,
+            project: language.project,
+            authors: language.authors,
+            source: language.source,
+            package: `${language.package}@${language.version}`,
+            licence: language.licence,
+            licenceFile: `dictionaries/${language.tag}/LICENSE`,
+            bytes: language.bytes,
+        })),
+    };
+    return {
+        languages,
+        directory,
+        base: browserBase(viteBase, directory),
+        servePath: `${(documentRooted(viteBase) ? (viteBase ?? "/") : "/").replace(/\/$/, "")}/${directory}`,
+        bytes: Object.fromEntries(languages.map((language) => [language.tag, wasmBytes + language.bytes])),
+        files: [
+            ...payload,
+            {
+                path: "manifest.json",
+                source: Buffer.from(`${JSON.stringify(manifest, null, "\t")}\n`),
+            },
+            {
+                path: "NOTICE.txt",
+                source: Buffer.from(noticeFor(engineVersion, languages)),
+            },
+        ],
+    };
+};
+export const spellcheckPlugin = () => {
+    let staged = null;
+    return {
+        name: "remit-spellcheck",
+        enforce: "pre",
+        config(userConfig) {
+            staged = stageSpellcheck(process.env.REMIT_SPELLCHECK_LANGUAGES, userConfig.base);
+            return {
+                define: {
+                    __REMIT_SPELLCHECK_LANGUAGES__: JSON.stringify(staged.languages.map((language) => language.tag)),
+                    __REMIT_SPELLCHECK_BASE__: JSON.stringify(staged.base),
+                    __REMIT_SPELLCHECK_BYTES__: JSON.stringify(staged.bytes),
+                },
+            };
+        },
+        configureServer(server) {
+            server.middlewares.use((request, response, next) => {
+                const held = staged;
+                const url = (request.url ?? "").split("?")[0];
+                if (!held || held.servePath === "" || !url.startsWith(held.servePath))
+                    return next();
+                const wanted = decodeURIComponent(url.slice(held.servePath.length));
+                const file = held.files.find((entry) => entry.path === wanted);
+                if (!file)
+                    return next();
+                response.setHeader("Content-Length", file.source.byteLength);
+                response.setHeader("Content-Type", wanted.endsWith(".mjs")
+                    ? "text/javascript; charset=utf-8"
+                    : wanted.endsWith(".wasm")
+                        ? "application/wasm"
+                        : wanted.endsWith(".json")
+                            ? "application/json; charset=utf-8"
+                            : "text/plain; charset=utf-8");
+                response.end(file.source);
+            });
+        },
+        generateBundle() {
+            const held = staged;
+            if (!held)
+                return;
+            for (const file of held.files) {
+                this.emitFile({
+                    type: "asset",
+                    fileName: `${held.directory}${file.path}`,
+                    source: file.source,
+                });
+            }
+        },
+    };
+};

package/dist/spellcheck/worker-stub.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Keeps the spellchecking worker out of a build that staged no dictionaries.
+ *
+ * Vite emits a worker bundle for whatever module graph reaches a `new
+ * Worker(new URL(...))`, and it emits it while transforming that module —
+ * before tree-shaking, and whether or not anything in the output still imports
+ * it. So a dead branch around the dynamic import is not enough on its own: the
+ * bundle is already a file by the time the branch is dropped. The only way the
+ * worker never becomes an asset is for the specifier never to resolve to it.
+ *
+ * The decision is `resolveLanguages`, the same function the staging plugin
+ * asks, so there is no second answer to what this build carries.
+ */
+import type { Plugin } from "vite";
+export declare const spellcheckWorkerStub: () => Plugin;