@v12-engine/create 0.1.1 → 0.4.0

package/layers/desktop/src/desktop.ts

@@ -0,0 +1,175 @@
+/**
+ * What the desktop app adds to the game, in a file of its own: the rest of `src/` is the game's, and hands its view and
+ * its app to this file where a project is made with `--desktop` (`desktopView` where the view is given to the game,
+ * `desktop()` in `main.ts`). It asks the shell only through `shell.ts`, so the same page runs in a browser's tab while it
+ * is developed (`npm run dev`), where each of these is nothing
+ */
+import type { GameClient, GameView, SavedGame, SettingsRecord, SettingsStore } from '@v12-engine/client'
+import type { AppShell, StartAppOptions, StartedApp } from '@v12-engine/client/app'
+import {
+	autosave,
+	autosaveOnClose,
+	canQuit,
+	checkForUpdate,
+	createErrorLog,
+	type ErrorLog,
+	fileStore,
+	gameFullscreen,
+	inShell,
+	logFiles,
+	logPageErrors,
+	openFolder,
+	quit,
+	setWindowed,
+	watchWindowed
+} from './shell'
+
+/**
+ * The pause menu's lines of the app's own: in the shell, the folders of the saves and of the error log, and Quit; a page
+ * in a browser can close nothing and open no folder, so it has none of them
+ */
+export function menuEntries(): { id: string; label: string; run: () => void }[] {
+	return [
+		...(inShell()
+			? [
+					{ id: 'savesFolder', label: 'Open the saves folder', run: () => void openFolder('saves') },
+					{ id: 'logFolder', label: 'Open the error log folder', run: () => void openFolder('logs') }
+				]
+			: []),
+		...(canQuit() ? [{ id: 'quit', label: 'Quit', run: () => void quit() }] : [])
+	]
+}
+
+/**
+ * The game's view with what a desktop game has that a page does not, said with what every game has: a setting of its
+ * own (Windowed, kept with the client's), lines of its own on the pause menu, and the HUD's own full
+ * screen button left out (the window's is the one: a second would disagree). The rest of the view is the game's, as
+ * it was
+ */
+export function desktopView<V extends GameView<any, any, any>>(view: V): V {
+	const hud = view.hud ?? {}
+	const entries = hud.menu?.entries
+	return {
+		...view,
+		hud: {
+			...hud,
+			hide: [...(hud.hide ?? []), 'fullscreen'],
+			menu: {
+				...hud.menu,
+				entries:
+					typeof entries === 'function'
+						? (client: Parameters<typeof entries>[0]) => [...entries(client), ...menuEntries()]
+						: [...(entries ?? []), ...menuEntries()]
+			},
+			settings: {
+				...hud.settings,
+				add: [
+					...(hud.settings?.add ?? []),
+					{
+						id: 'windowed',
+						label: 'Windowed',
+						hint: 'The game in a window with its frame, and not over the whole screen',
+						section: 'view',
+						kind: 'toggle',
+						// an app starts as a game does, over the whole screen; a page in a tab as a page
+						default: !inShell(),
+						apply: (_client: unknown, on: boolean) => void setWindowed(on)
+					}
+				],
+				// the app's window is the game, full screen or not (the shell's full screen is not the page's, which the client's
+				// "in full screen" looks at): the pointer stays in it, as in any game of the system's own
+				change: { ...hud.settings?.change, keepPointer: { default: inShell() ? 'always' : 'fullscreen' } }
+			}
+		}
+	}
+}
+
+/** What `desktop()` gives `main.ts`: the options `startApp` is given, what is done once the app is started, and what the start menu's Exit asks (`exitButton`) */
+export interface Desktop extends AppShell {
+	options: Pick<StartAppOptions, 'stores' | 'onGame' | 'fullscreenButton' | 'fullscreenHost' | 'keepPointer'>
+	started(app: StartedApp): void
+}
+
+/**
+ * The app in its shell. What the player saves and sets is files in the app's own folder of the system (`fileStore`),
+ * there the next time it is opened; what goes wrong is a line of `errors.log`; closing the window saves the game
+ * being played first; the window's full screen is the Windowed setting's, both ways; the start menu has an Exit; and a
+ * new version, where the shell finds one, is offered in a toast. In a browser: nothing, the browser keeps what it keeps
+ */
+export function desktop(): Desktop {
+	if (!inShell()) return { options: {}, canQuit, quit, started: () => {} }
+	const errors = createErrorLog(logFiles)
+	logPageErrors(errors)
+	const settings: SettingsStore = fileStore<SettingsRecord>('settings')
+	/** The game played now: the one the window's closing saves */
+	let playing: GameClient | undefined
+	void autosaveOnClose(() => playing, { log: (error) => void errors.write('autosave', error) }).catch((error) => errors.write('window', error))
+	// the window as the player left it the last time: over the screen, or a window (whose size and place the shell keeps)
+	void startWindow(settings, errors)
+	return {
+		canQuit,
+		quit,
+		options: {
+			// the window's full screen is the shell's, which the Windowed setting has: a button for the page's would disagree; and the
+			// pointer stays in the window on the app's own screens too, as in its game
+			fullscreenButton: false,
+			// and what a game of its own asks (`app.fullscreen()`, a corner button of its HUD) is that one too
+			fullscreenHost: gameFullscreen,
+			keepPointer: 'always',
+			stores: { saves: fileStore<SavedGame>('saves'), settings },
+			onGame(client) {
+				playing = client
+				let unwatch: (() => void) | undefined
+				let ended = false
+				void watchWindowed(client).then(
+					(off) => (ended ? off() : (unwatch = off)),
+					(error) => errors.write('window', error)
+				)
+				return () => {
+					ended = true
+					unwatch?.()
+					if (playing === client) playing = undefined
+				}
+			}
+		},
+		started(app) {
+			void offerUpdate(app, () => playing, errors)
+		}
+	}
+}
+
+/** The window as the setting says as the app starts: over the whole screen where it was never set */
+async function startWindow(settings: SettingsStore, errors: ErrorLog): Promise<void> {
+	try {
+		await setWindowed((await settings.read('settings'))?.values.windowed === true)
+	} catch (error) {
+		await errors.write('window', error)
+	}
+}
+
+/**
+ * A new version offered, where the shell finds one: a toast says which, and its button saves the game being played,
+ * installs it and starts the app again. Only in a release built to have one (`VITE_DESKTOP_UPDATES=on`): an app built
+ * here has no address to ask (`UPDATES` in `electron/config.mjs` is a placeholder until the docs' Updates are done). What fails (no network, a signature that does not hold) is
+ * a line of the error log, not the player's business
+ */
+export async function offerUpdate(app: Pick<StartedApp, 'overlays'>, playing: () => GameClient | undefined, errors: ErrorLog): Promise<void> {
+	if (import.meta.env.VITE_DESKTOP_UPDATES !== 'on') return
+	try {
+		const update = await checkForUpdate()
+		if (!update) return
+		app.overlays.toast(`Version ${update.version} is ready`, {
+			seconds: 30,
+			action: {
+				label: 'Install and restart',
+				run: () =>
+					void autosave(playing())
+						.catch((error) => errors.write('autosave', error))
+						.then(() => update.install())
+						.catch((error) => errors.write('update', error))
+			}
+		})
+	} catch (error) {
+		await errors.write('update', error)
+	}
+}

package/layers/desktop/src/shell.ts

@@ -0,0 +1,279 @@
+/**
+ * What the page asks of the desktop shell, each with what it does in a browser, where the same page runs while it is
+ * developed (`npm run dev`): the page never names Electron outside this file, and asks the main process
+ * (`electron/app.mjs`) only through what `electron/preload.cjs` puts on the window
+ */
+import type { GameClient, Store } from '@v12-engine/client'
+
+/** What the preload script puts on the window */
+export interface ShellBridge {
+	fullscreen(on?: boolean): Promise<boolean>
+	close(): Promise<void>
+	destroy(): Promise<void>
+	onResized(listener: () => void): () => void
+	onCloseRequested(listener: () => void): () => void
+	openFolder(folder: string): Promise<void>
+	records: {
+		list(folder: string): Promise<string[]>
+		read(folder: string, id: string): Promise<string | undefined>
+		write(folder: string, id: string, text: string): Promise<void>
+		remove(folder: string, id: string): Promise<void>
+	}
+	log: {
+		append(file: string, text: string): Promise<void>
+		size(file: string): Promise<number>
+		rename(from: string, to: string): Promise<void>
+	}
+	updates: {
+		check(): Promise<{ version: string; notes?: string } | undefined>
+		install(): Promise<void>
+	}
+}
+
+/** The bridge, in the shell */
+const bridge = (): ShellBridge => (window as unknown as { v12Shell: ShellBridge }).v12Shell
+
+/** Whether the page is in the shell (the preload script says so on the window), not in a browser's tab */
+export const inShell = (): boolean => 'v12Shell' in window
+
+/** How long the window takes over going over the screen or back: what it says meanwhile is not what the player asked */
+const SETTLES_IN = 2000
+/** Until when the window is being changed by `setWindowed`, and `watchWindowed` listens to none of it */
+let settlingUntil = 0
+
+/**
+ * The game over the whole screen with no frame, or a window with one, by the shell (`electron/app.mjs`: on macOS no Dock
+ * or menu bar at the edges, and Esc is the game's), or told which it is when `on` is left out. This is `startApp`'s
+ * `fullscreenHost`, so that nothing of the page asks for the page's own full screen. False in a browser
+ */
+export async function gameFullscreen(on?: boolean): Promise<boolean> {
+	if (!inShell()) return false
+	return bridge().fullscreen(on)
+}
+
+/**
+ * A window with its frame, or the game over the whole screen with none (as the shell starts it): the shell's own
+ * window, where a browser has only the page's
+ */
+export async function setWindowed(on: boolean): Promise<void> {
+	if (inShell()) {
+		settlingUntil = Date.now() + SETTLES_IN
+		await gameFullscreen(!on)
+		settlingUntil = Date.now() + SETTLES_IN
+		return
+	}
+	// a browser gives it to a click only: as a setting is applied when the game starts, it may say no
+	if (!on) await document.documentElement.requestFullscreen().catch(() => undefined)
+	else if (document.fullscreenElement) await document.exitFullscreen()
+}
+
+/**
+ * Whether the game can be quit from its menu: in the shell only. A page cannot close its own tab (`window.close` does
+ * nothing for a tab the page did not open), so a browser's menu has no Quit
+ */
+export const canQuit = (): boolean => inShell()
+
+/** Out of the game: the window closed (which saves the game first, `autosaveOnClose`), and the app with its last one. Nothing in a browser */
+export async function quit(): Promise<void> {
+	if (inShell()) return bridge().close()
+}
+
+/** What `watchWindowed` needs of a client: the settings, in which the window's state is kept */
+type WithSettings = Pick<GameClient, 'settings'>
+
+/** What `watchWindowed` needs of a window */
+interface Resizable {
+	onResized(handler: () => void): Promise<() => void>
+}
+
+/**
+ * Keeps the "Windowed" setting, the one control of it (the HUD's own button is left out, `GameView.hud.hide`), true to
+ * the window: a window that was put in or out of full screen by anything else (`StartedApp.fullscreen`) sets it, so that
+ * the toggle shows what the window is. What the window says while the setting itself moves it is passed over: it is not
+ * there yet, and would put the setting back
+ */
+export async function watchWindowed(
+	client: WithSettings,
+	window: Resizable = { onResized: async (handler) => bridge().onResized(handler) },
+	isOn: () => Promise<boolean> = gameFullscreen
+): Promise<() => void> {
+	return window.onResized(async () => {
+		if (Date.now() < settlingUntil) return
+		const windowed = !(await isOn())
+		if (Date.now() < settlingUntil) return
+		if (client.settings.get('windowed') !== windowed) client.settings.set('windowed', windowed)
+	})
+}
+
+/** The game's name for the save made as the window closes: the one before it is replaced, so there is one */
+export const AUTOSAVE = 'Autosave'
+
+/** What an autosave needs of a client: its saves (not there when the game is launched with none) */
+type WithSaves = { readonly saves?: Pick<NonNullable<GameClient['saves']>, 'canSave' | 'list' | 'refresh' | 'save' | 'remove'> }
+
+/** The game saved as "Autosave", the one made before taken away. Nothing when there is no game to save; whether it was saved */
+export async function autosave(client: WithSaves | undefined): Promise<boolean> {
+	const saves = client?.saves
+	if (!saves || !saves.canSave()) return false
+	await saves.refresh()
+	const before = saves.list().filter((saved) => saved.name === AUTOSAVE)
+	const saved = await saves.save(AUTOSAVE)
+	if (!saved) return false
+	// only once the new one is kept are the old ones given up
+	for (const old of before) await saves.remove(old.id)
+	return true
+}
+
+/** What `autosaveOnClose` needs of a window */
+interface Closable {
+	onCloseRequested(handler: () => void | Promise<void>): Promise<() => void>
+	destroy(): Promise<void>
+}
+
+/**
+ * The window's closing (its X, Cmd+Q, the menu's Quit) saves the game first: the shell holds the close until the page
+ * destroys the window, which it does once the save is done, but no more than `limit` ms (a save that hangs does not
+ * keep the app open; the shell's own limit is longer), and a save that fails is logged, not the end of the player's wish
+ * to leave
+ */
+export async function autosaveOnClose(
+	getClient: () => WithSaves | undefined,
+	options: { window?: Closable; limit?: number; log?: (error: unknown) => void } = {}
+): Promise<() => void> {
+	const {
+		window = { onCloseRequested: async (handler) => bridge().onCloseRequested(handler), destroy: () => bridge().destroy() },
+		limit = 4000,
+		log
+	} = options
+	return window.onCloseRequested(async () => {
+		try {
+			await Promise.race([autosave(getClient()), new Promise((resolve) => setTimeout(resolve, limit))])
+		} catch (error) {
+			log?.(error)
+		}
+		await window.destroy()
+	})
+}
+
+/** The folders the app keeps things in: the saves under its own folder of the system, the logs in the system's place for them */
+export const FOLDERS = { saves: 'saves', logs: 'logs' } as const
+
+/** Opens one of the app's folders in the system's file manager (made first, so that there is something to open) */
+export async function openFolder(folder: keyof typeof FOLDERS): Promise<void> {
+	if (inShell()) await bridge().openFolder(folder)
+}
+
+/** What the error log asks of the files: append to one, its size, and a move (the shell's are `logFiles`) */
+export interface LogFiles {
+	append(file: string, text: string): Promise<void>
+	size(file: string): Promise<number>
+	rename(from: string, to: string): Promise<void>
+}
+
+/** The files of the app's log folder, the system's own (`~/Library/Logs/<name>`, `%APPDATA%\<identifier>\logs`): `errors.log` and `errors.old.log` only */
+export const logFiles: LogFiles = {
+	append: (file, text) => bridge().log.append(file, text),
+	size: (file) => bridge().log.size(file),
+	rename: (from, to) => bridge().log.rename(from, to)
+}
+
+/** What an error log is: a line for each, written to `errors.log`; when that is over `maxBytes` it becomes `errors.old.log` (one generation kept) */
+export interface ErrorLog {
+	write(where: string, error: unknown): Promise<void>
+}
+
+/** The text of whatever was thrown: an Error with its stack, a string, anything else as JSON */
+export function describeError(error: unknown): string {
+	if (error instanceof Error) return error.stack ?? `${error.name}: ${error.message}`
+	if (typeof error === 'string') return error
+	try {
+		return JSON.stringify(error) ?? String(error)
+	} catch {
+		return String(error)
+	}
+}
+
+/**
+ * The error log: what went wrong in the page, as lines of a file the player can send. A failing log never throws (an
+ * error while logging one is lost, not the game), and writes are in order
+ */
+export function createErrorLog(files: LogFiles, options: { maxBytes?: number; now?: () => Date } = {}): ErrorLog {
+	const { maxBytes = 512 * 1024, now = () => new Date() } = options
+	let chain: Promise<void> = Promise.resolve()
+	return {
+		write(where, error) {
+			chain = chain.then(async () => {
+				try {
+					if ((await files.size('errors.log')) > maxBytes) await files.rename('errors.log', 'errors.old.log')
+					const text = describeError(error).replace(/\r?\n/g, '\n    ')
+					await files.append('errors.log', `${now().toISOString()} [${where}] ${text}\n`)
+				} catch {
+					// nothing more can be done about it
+				}
+			})
+			return chain
+		}
+	}
+}
+
+/** The page's uncaught errors and rejected promises go to the log. Gives back what takes them off again */
+export function logPageErrors(log: ErrorLog, target: Pick<Window, 'addEventListener' | 'removeEventListener'> = window): () => void {
+	const onError = (event: Event) => void log.write('error', (event as ErrorEvent).error ?? (event as ErrorEvent).message)
+	const onRejection = (event: Event) => void log.write('unhandledrejection', (event as PromiseRejectionEvent).reason)
+	target.addEventListener('error', onError)
+	target.addEventListener('unhandledrejection', onRejection)
+	return () => {
+		target.removeEventListener('error', onError)
+		target.removeEventListener('unhandledrejection', onRejection)
+	}
+}
+
+/**
+ * A store of records as files: one JSON file for each, `<folder>/<id>.json`, in the app's own data folder of the system
+ * (under its identifier, `electron/config.mjs`), written by the main process (`electron/files.mjs`, which checks every
+ * name, and writes a record whole or not at all). What a player saves and sets is there the next time the app is
+ * opened, and can be found, copied or backed up with the rest of the app's folder. A file that does not read as a
+ * record (cut short, edited by hand) is left out. A browser has none of these and keeps them in its own storage
+ */
+export function fileStore<R extends { id: string }>(folder: string): Store<R> {
+	const parsed = (text: string | undefined): R | undefined => {
+		if (text === undefined) return undefined
+		try {
+			return JSON.parse(text) as R
+		} catch {
+			return undefined
+		}
+	}
+	return {
+		async list() {
+			const texts = await bridge().records.list(folder)
+			return texts.flatMap((text) => parsed(text) ?? [])
+		},
+		read: async (id) => parsed(await bridge().records.read(folder, id)),
+		write: (record) => bridge().records.write(folder, record.id, JSON.stringify(record)),
+		remove: (id) => bridge().records.remove(folder, id)
+	}
+}
+
+/** A new version of the app, found at the address of `electron/config.mjs` (`UPDATES`) and downloaded */
+export interface AppUpdate {
+	/** The version it is, as its feed names it */
+	version: string
+	/** Its notes, as its feed says: none where it says none */
+	notes?: string
+	/** The app quit, the new version put in its place and started (the game is the caller's to save first) */
+	install(): Promise<void>
+}
+
+/**
+ * A newer version of the app, where there is one, by Electron's `autoUpdater` (`electron/updates.mjs`): downloaded before
+ * it is offered. None in a browser, none in an app run from the project or whose address is the placeholder, none when the
+ * app is the newest. A feed that cannot be had, or an update that does not hold (Squirrel.Mac checks the new app's
+ * signature against this one's), throws: the caller logs it
+ */
+export async function checkForUpdate(): Promise<AppUpdate | undefined> {
+	if (!inShell()) return undefined
+	const found = await bridge().updates.check()
+	if (!found) return undefined
+	return { version: found.version, ...(found.notes && { notes: found.notes }), install: () => bridge().updates.install() }
+}

package/layers/desktop/tests/main.test.ts

@@ -0,0 +1,189 @@
+// @if tests
+/** What the main process does with the page's words: the disk's, the scheme's and the updater's parts, which need no Electron to run */
+import { mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterAll, describe, expect, it } from 'vitest'
+// @ts-expect-error plain JavaScript for the main process, with no types of its own
+import { fileNameOf, logFiles, recordFiles } from '../electron/files.mjs'
+// @ts-expect-error plain JavaScript for the main process, with no types of its own
+import { answer, contentPolicy } from '../electron/serve.mjs'
+// @ts-expect-error plain JavaScript for the main process, with no types of its own
+import { feedOf, updatesOf } from '../electron/updates.mjs'
+// @ts-expect-error plain JavaScript for the main process, with no types of its own
+import { UPDATES } from '../electron/config.mjs'
+import { EventEmitter } from 'node:events'
+
+/** A folder of the system's for one test, inside one for the file, which goes when the file's tests are done */
+const under = mkdtempSync(join(tmpdir(), 'v12-electron-test-'))
+const folder = () => mkdtempSync(join(under, 'case-'))
+afterAll(() => rmSync(under, { recursive: true, force: true }))
+
+describe('records', () => {
+	it('keeps a record whole and leaves no partial file', async () => {
+		const base = folder()
+		const records = recordFiles(base)
+		await records.write('saves', 'one', '{"id":"one"}')
+		expect(await records.read('saves', 'one')).toBe('{"id":"one"}')
+		expect(await records.list('saves')).toEqual(['{"id":"one"}'])
+		expect(readdirSync(join(base, 'saves'))).toEqual(['one.json'])
+		await records.remove('saves', 'one')
+		expect(await records.read('saves', 'one')).toBeUndefined()
+	})
+
+	it('says nothing of a folder not made yet', async () => {
+		expect(await recordFiles(folder()).list('saves')).toEqual([])
+	})
+
+	it("keeps a record of any id inside its folder, and refuses a folder that is not the app's", async () => {
+		const base = folder()
+		const records = recordFiles(base)
+		// a checkpoint's id, and ids that would leave the folder were they a path
+		const ids = ['checkpoint:desktop:campaign-mission:{"mission":"homecoming"}', '../../x', 'a/b', '..', '.hidden', 'x'.repeat(400)]
+		for (const id of ids) await records.write('saves', id, JSON.stringify({ id }))
+		for (const id of ids) expect(await records.read('saves', id)).toBe(JSON.stringify({ id }))
+		const names = readdirSync(join(base, 'saves'))
+		expect(names).toHaveLength(ids.length)
+		for (const name of names) expect(name).toMatch(/^~[\w-]+\.json$/)
+		expect(readdirSync(base)).toEqual(['saves'])
+		expect(fileNameOf('a-save.1')).toBe('a-save.1')
+		await expect(records.write('saves', '', '{}')).rejects.toThrow('not the id')
+		await expect(records.write('../..', 'x', '{}')).rejects.toThrow('not a folder')
+		await expect(records.list('anything')).rejects.toThrow('not a folder')
+	})
+})
+
+describe('the log', () => {
+	it('appends to its two files and to no other', async () => {
+		const base = folder()
+		const log = logFiles(base)
+		expect(await log.size('errors.log')).toBe(0)
+		await log.append('errors.log', 'a line\n')
+		expect(await log.size('errors.log')).toBe(7)
+		await log.rename('errors.log', 'errors.old.log')
+		expect(readFileSync(join(base, 'errors.old.log'), 'utf8')).toBe('a line\n')
+		await expect(log.append('../x', 'y')).rejects.toThrow('not a file of the log')
+		await expect(log.rename('errors.log', '../x')).rejects.toThrow('not a file of the log')
+	})
+})
+
+describe("the page's files", () => {
+	const root = () => {
+		const base = folder()
+		mkdirSync(join(base, 'assets'))
+		writeFileSync(join(base, 'index.html'), '<html>')
+		writeFileSync(join(base, 'assets/a.wasm'), 'abcdefghij')
+		return base
+	}
+	const get = (path: string, headers = {}) => new Request(`http://game${path}`, { headers })
+
+	it('answers the page with its policy, and WebAssembly as what it is', async () => {
+		const base = root()
+		const index = await answer(base, get('/'), 'the policy')
+		expect(await index.text()).toBe('<html>')
+		expect(index.headers.get('content-security-policy')).toBe('the policy')
+		expect((await answer(base, get('/assets/a.wasm'), '')).headers.get('content-type')).toBe('application/wasm')
+	})
+
+	it('gives a part of a file where a part is asked', async () => {
+		const part = await answer(root(), get('/assets/a.wasm', { range: 'bytes=2-4' }), '')
+		expect(part.status).toBe(206)
+		expect(await part.text()).toBe('cde')
+		expect(part.headers.get('content-range')).toBe('bytes 2-4/10')
+		const last = await answer(root(), get('/assets/a.wasm', { range: 'bytes=-3' }), '')
+		expect(await last.text()).toBe('hij')
+		expect((await answer(root(), get('/assets/a.wasm', { range: 'bytes=50-' }), '')).status).toBe(416)
+	})
+
+	it('answers nothing outside its folder, however it is written', async () => {
+		const base = root()
+		writeFileSync(join(base, '..', 'v12-outside.txt'), 'secret')
+		// (a URL's own dots are gone by the time it is read: `%2e%2e` and an encoded slash are what could still get out)
+		for (const path of ['/../v12-outside.txt', '/%2e%2e/v12-outside.txt', '/assets/..%2f..%2fv12-outside.txt', '/nothing.js'])
+			expect((await answer(base, get(path), '')).status).toBe(404)
+	})
+
+	it('says a policy of its own origin, WebAssembly and nothing else, with the addresses it is given', () => {
+		const directives: Record<string, string[]> = Object.fromEntries(
+			(contentPolicy() as string).split(';').map((part) => {
+				const [name, ...sources] = part.trim().split(/\s+/)
+				return [name, sources]
+			})
+		)
+		expect(directives['default-src']).toEqual(["'self'"])
+		// the ground's worker and Babylon's textures and sounds made in the page
+		for (const name of ['worker-src', 'img-src', 'media-src']) expect(directives[name], name).toEqual(expect.arrayContaining(["'self'", 'blob:']))
+		// WebAssembly: the navigation, Havok's physics
+		expect(directives['script-src']).toEqual(["'self'", "'wasm-unsafe-eval'"])
+		// and no other site, but those it is given
+		for (const sources of Object.values(directives)) for (const source of sources) expect(source).not.toMatch(/^https?:/)
+		expect(contentPolicy(['http://127.0.0.1:1'])).toContain("connect-src 'self' blob: data: http://127.0.0.1:1")
+	})
+})
+
+describe('updates', () => {
+	it('asks nothing while the address is the placeholder, and nothing on a system Squirrel does not update', () => {
+		expect(new URL(UPDATES).hostname.endsWith('.invalid')).toBe(true)
+		expect(feedOf(UPDATES, 'darwin', 'arm64')).toBeUndefined()
+		expect(feedOf('not an address', 'darwin', 'arm64')).toBeUndefined()
+		expect(feedOf('https://example.com/game', 'linux', 'x64')).toBeUndefined()
+	})
+
+	it("reads the static files laid out by system and processor, as Electron's docs lay them", () => {
+		expect(feedOf('https://example.com/game/', 'darwin', 'arm64')).toEqual({
+			url: 'https://example.com/game/darwin/arm64/RELEASES.json',
+			serverType: 'json'
+		})
+		expect(feedOf('https://example.com/game', 'win32', 'x64')).toEqual({ url: 'https://example.com/game/win32/x64' })
+	})
+
+	/** Electron's `autoUpdater`, pretended: what it is asked, and what it says when told to */
+	const pretendUpdater = (says: (updater: EventEmitter) => void) => {
+		const updater = Object.assign(new EventEmitter(), {
+			asked: [] as unknown[],
+			setFeedURL(feed: unknown) {
+				updater.asked.push(['feed', feed])
+			},
+			checkForUpdates() {
+				updater.asked.push(['check'])
+				setTimeout(() => says(updater))
+			},
+			quitAndInstall() {
+				updater.asked.push(['install'])
+			}
+		})
+		return updater
+	}
+	const feed = { url: 'https://example.com/game/darwin/arm64/RELEASES.json', serverType: 'json' }
+
+	it('gives a version once it is downloaded, nothing when there is none, and throws what fails', async () => {
+		const found = pretendUpdater((updater) => updater.emit('update-downloaded', {}, 'What is new', '1.2.0'))
+		const updates = updatesOf(found, feed, true)
+		expect(await updates.check()).toEqual({ version: '1.2.0', notes: 'What is new' })
+		updates.install()
+		expect(found.asked).toEqual([['feed', feed], ['check'], ['install']])
+		expect(found.listenerCount('error')).toBe(0)
+		expect(
+			await updatesOf(
+				pretendUpdater((updater) => updater.emit('update-not-available')),
+				feed,
+				true
+			).check()
+		).toBeUndefined()
+		await expect(
+			updatesOf(
+				pretendUpdater((updater) => updater.emit('error', new Error('no network'))),
+				feed,
+				true
+			).check()
+		).rejects.toThrow('no network')
+	})
+
+	it('asks nothing of an app run from the project, or with no feed', async () => {
+		const updater = pretendUpdater(() => undefined)
+		expect(await updatesOf(updater, feed, false).check()).toBeUndefined()
+		expect(await updatesOf(updater, undefined, true).check()).toBeUndefined()
+		expect(updater.asked).toEqual([])
+	})
+})
+// @end