@v12-engine/create 0.1.0 → 0.4.0

package/layers/desktop/electron/dev.mjs

@@ -0,0 +1,63 @@
+// `npm run app`: the game in its shell while it is developed: the dev server started (Vite, on port 3100) and the
+// shell on it, so a change to the page shows as it does in a browser. `npm run app:editor` (`--attach`) starts no
+// server: it opens the shell on the one already running, which is the map editor's Run panel's way, beside the dev
+// server the editor is open on. Closing the app stops what this started.
+// `--port <n>` puts the server on another port, or attaches to one there; `--page <address>` attaches to a page
+// served elsewhere (`--attach` is then implied): `node electron/dev.mjs --page http://localhost:3000/`
+import { spawn } from 'node:child_process'
+import { buildNative, electronBinary, project } from './tools.mjs'
+
+const PORT = 3100
+
+/** The value given after a flag, as `--port 3200` or `--port=3200` */
+const option = (name) => {
+	const at = process.argv.findIndex((argument) => argument === name || argument.startsWith(`${name}=`))
+	if (at < 0) return undefined
+	const argument = process.argv[at]
+	return argument.includes('=') ? argument.slice(argument.indexOf('=') + 1) : process.argv[at + 1]
+}
+
+const askedPort = option('--port')
+const port = askedPort === undefined ? PORT : Number(askedPort)
+if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+	console.error(`--port takes a port, not "${askedPort}"`)
+	process.exit(1)
+}
+const page = option('--page')
+const attach = process.argv.includes('--attach') || page !== undefined
+let address = `http://localhost:${port}/`
+if (page !== undefined) {
+	try {
+		address = new URL(page).href
+	} catch {
+		console.error(`--page takes an address, as http://localhost:3000/, not "${page}"`)
+		process.exit(1)
+	}
+}
+
+buildNative()
+const binary = electronBinary()
+let server
+if (attach) {
+	const answered = await fetch(address).then(
+		(response) => response.ok,
+		() => false
+	)
+	if (!answered) {
+		console.error(`No dev server at ${address}: start it first (npm run dev), or run npm run app, which starts one`)
+		process.exit(1)
+	}
+} else {
+	const { createServer } = await import('vite')
+	server = await createServer({ root: project, server: { port, strictPort: true } })
+	await server.listen()
+	server.printUrls()
+}
+
+const shell = spawn(binary, [project], { stdio: 'inherit', env: { ...process.env, V12_PAGE: address } })
+const stop = async (code) => {
+	await server?.close()
+	process.exit(code ?? 0)
+}
+shell.on('exit', (code) => void stop(code))
+for (const signal of ['SIGINT', 'SIGTERM']) process.on(signal, () => shell.kill(signal))

package/layers/desktop/electron/files.mjs

@@ -0,0 +1,86 @@
+// What the page may ask of the disk, on the main process's side: records in the folders named here, and the two log
+// files, nothing else. The page's words are not trusted as a path. No Electron here, so that the tests run it in Node.
+import { mkdir, readdir, readFile, rename, rm, stat, writeFile, appendFile } from 'node:fs/promises'
+import { createHash } from 'node:crypto'
+import { join } from 'node:path'
+
+/** The folders of records a page may name */
+export const RECORD_FOLDERS = ['saves', 'settings']
+/** The files of the log a page may name */
+export const LOG_FILES = ['errors.log', 'errors.old.log']
+
+function folderIn(base, folder) {
+	if (!RECORD_FOLDERS.includes(folder)) throw new Error(`"${folder}" is not a folder of the app's`)
+	return join(base, folder)
+}
+
+/**
+ * The name of a record's file, from its id: the id itself where it is a plain name (letters, digits, `_`, `-` and dots,
+ * not first), and otherwise the id written in letters and digits (base64url) after a `~`, which no plain name has: a
+ * checkpoint's id has colons and braces in it. Nothing that moves out of the folder either way. A very long id is
+ * named by its hash
+ */
+export function fileNameOf(id) {
+	if (typeof id !== 'string' || !id) throw new Error(`"${id}" is not the id of a record`)
+	if (/^[\w-][\w.-]{0,119}$/.test(id)) return id
+	const written = Buffer.from(id).toString('base64url')
+	return written.length <= 160 ? `~${written}` : `~h${createHash('sha256').update(id).digest('base64url')}`
+}
+
+function recordIn(base, folder, id) {
+	return join(folderIn(base, folder), `${fileNameOf(id)}.json`)
+}
+
+function logIn(base, file) {
+	if (!LOG_FILES.includes(file)) throw new Error(`"${file}" is not a file of the log`)
+	return join(base, file)
+}
+
+/** The records under the app's data folder, as text, each whole on the disk or not at all */
+export function recordFiles(base) {
+	return {
+		async list(folder) {
+			const path = folderIn(base, folder)
+			let names
+			try {
+				names = await readdir(path)
+			} catch {
+				return []
+			}
+			const texts = await Promise.all(
+				names.filter((name) => name.endsWith('.json')).map((name) => readFile(join(path, name), 'utf8').catch(() => undefined))
+			)
+			return texts.filter((text) => text !== undefined)
+		},
+		read: (folder, id) => readFile(recordIn(base, folder, id), 'utf8').catch(() => undefined),
+		async write(folder, id, text) {
+			const file = recordIn(base, folder, id)
+			await mkdir(folderIn(base, folder), { recursive: true })
+			const partial = `${file}.tmp`
+			try {
+				await writeFile(partial, text)
+				await rename(partial, file)
+			} catch (error) {
+				await rm(partial, { force: true })
+				throw error
+			}
+		},
+		remove: (folder, id) => rm(recordIn(base, folder, id), { force: true })
+	}
+}
+
+/** The two files of the error log, in the system's folder of the app's logs */
+export function logFiles(base) {
+	return {
+		async append(file, text) {
+			await mkdir(base, { recursive: true })
+			await appendFile(logIn(base, file), text)
+		},
+		size: (file) =>
+			stat(logIn(base, file)).then(
+				(found) => found.size,
+				() => 0
+			),
+		rename: async (from, to) => rename(logIn(base, from), logIn(base, to))
+	}
+}

package/layers/desktop/electron/main.mjs

@@ -0,0 +1,12 @@
+// The app's main process (`main` in `package.json`): the shell, on the built page, or on the dev server where
+// `npm run app` says one (`dev.mjs`). `V12_USER_DATA` puts the app's folder elsewhere, for a check that is not to touch
+// the player's saves
+import { app } from 'electron'
+import { startShell } from './app.mjs'
+
+const { V12_PAGE: page, V12_USER_DATA: userData } = process.env
+// (no `await` at the top of the file: Electron's start waits for this file, and the app's being ready waits for that)
+startShell({ ...(page && !app.isPackaged && { page }), ...(userData && { userData }) }).catch((error) => {
+	console.error(error)
+	app.exit(1)
+})

package/layers/desktop/electron/package.mjs

@@ -0,0 +1,75 @@
+// `npm run package`: the app to hand out, by Electron's own "manual packaging" (its Application Packaging guide), which
+// adds no package to the project: the page built (`vite build`), then Electron's own app copied with the main process and
+// the built page under `resources/app`, named and given its version and icon. Into `out/`: on macOS `out/<name>.app`,
+// signed ad hoc so that it opens on this Mac (a zip of it beside, for the updater's feed, with `--zip`); on Windows and
+// Linux a folder `out/<name>-<system>-<processor>` with the app's executable in it. It is made for the system it runs on.
+// Signing for other Macs (Apple's notarization), Windows' certificate and installers are Electron Forge's
+// (`docs/scenes/desktop.md`, Before the app is handed out).
+import { execFileSync } from 'node:child_process'
+import { cpSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { IDENTIFIER, NAME } from './config.mjs'
+import { buildNative, electronDist, electronVersion, project } from './tools.mjs'
+
+/** The main process's files: what the app runs, and none of what makes it (this file, the addon's source, the dev server's) */
+const RUNS = ['main.mjs', 'app.mjs', 'config.mjs', 'files.mjs', 'serve.mjs', 'updates.mjs', 'preload.cjs', 'presentation.node', 'icons/icon.png']
+
+const manifest = JSON.parse(readFileSync(join(project, 'package.json'), 'utf8'))
+const version = manifest.version ?? '0.0.0'
+const zip = process.argv.includes('--zip')
+
+buildNative()
+const dist = electronDist()
+const { build } = await import('vite')
+await build({ root: project, logLevel: 'warn' })
+if (!existsSync(join(project, 'dist/index.html'))) throw new Error('The page was not built: no dist/index.html')
+
+const out = join(project, 'out')
+mkdirSync(out, { recursive: true })
+let made
+if (process.platform === 'darwin') {
+	made = join(out, `${NAME}.app`)
+	rmSync(made, { recursive: true, force: true })
+	// (`cp -R` keeps the bundle's links and modes, which a copy by Node may not)
+	execFileSync('cp', ['-R', join(dist, 'Electron.app'), made])
+	const resources = join(made, 'Contents/Resources')
+	putApp(resources)
+	cpSync(join(project, 'electron/icons/icon.icns'), join(resources, 'electron.icns'))
+	const plist = join(made, 'Contents/Info.plist')
+	for (const [key, value] of [
+		['CFBundleDisplayName', NAME],
+		['CFBundleName', NAME],
+		['CFBundleIdentifier', IDENTIFIER],
+		['CFBundleShortVersionString', version],
+		['CFBundleVersion', version]
+	])
+		execFileSync('plutil', ['-replace', key, '-string', value, plist])
+	// ad hoc: this Mac opens it; another refuses it until it is signed with a certificate and notarized
+	execFileSync('codesign', ['--force', '--deep', '--sign', '-', made], { stdio: 'inherit' })
+	if (zip) execFileSync('ditto', ['-c', '-k', '--sequesterRsrc', '--keepParent', made, join(out, `${NAME}-${version}-darwin-${process.arch}.zip`)])
+} else {
+	made = join(out, `${NAME}-${process.platform}-${process.arch}`)
+	rmSync(made, { recursive: true, force: true })
+	cpSync(dist, made, { recursive: true, verbatimSymlinks: true })
+	putApp(join(made, 'resources'))
+	const executable = process.platform === 'win32' ? 'electron.exe' : 'electron'
+	renameSync(join(made, executable), join(made, process.platform === 'win32' ? `${NAME}.exe` : NAME))
+}
+console.log(`${made} (Electron ${electronVersion()}, version ${version})`)
+
+/** The app's own files under Electron's resources, in the place of its default app */
+function putApp(resources) {
+	rmSync(join(resources, 'default_app.asar'), { force: true })
+	const inside = join(resources, 'app')
+	rmSync(inside, { recursive: true, force: true })
+	for (const file of RUNS) {
+		const from = join(project, 'electron', file)
+		// (the addon is there on macOS only)
+		if (existsSync(from)) cpSync(from, join(inside, 'electron', file))
+	}
+	cpSync(join(project, 'dist'), join(inside, 'dist'), { recursive: true })
+	writeFileSync(
+		join(inside, 'package.json'),
+		`${JSON.stringify({ name: manifest.name, productName: NAME, version, type: 'module', main: 'electron/main.mjs' }, null, '\t')}\n`
+	)
+}

package/layers/desktop/electron/preload.cjs

@@ -0,0 +1,41 @@
+// All that the page may ask of the main process (`app.mjs`), and nothing of Electron's own: `src/shell.ts` is the one
+// file that reads it
+const { contextBridge, ipcRenderer } = require('electron')
+
+/** A message of the main process's, to a function of the page's; gives back what stops it */
+const listen = (channel, listener) => {
+	const heard = () => listener()
+	ipcRenderer.on(channel, heard)
+	return () => ipcRenderer.removeListener(channel, heard)
+}
+
+contextBridge.exposeInMainWorld('v12Shell', {
+	fullscreen: (on) => ipcRenderer.invoke('v12:fullscreen', on),
+	close: () => ipcRenderer.invoke('v12:close'),
+	destroy: () => ipcRenderer.invoke('v12:destroy'),
+	onResized: (listener) => listen('v12:resized', listener),
+	onCloseRequested: (listener) => {
+		ipcRenderer.send('v12:close-is-heard', true)
+		const off = listen('v12:close-requested', listener)
+		return () => {
+			ipcRenderer.send('v12:close-is-heard', false)
+			off()
+		}
+	},
+	openFolder: (folder) => ipcRenderer.invoke('v12:open-folder', folder),
+	records: {
+		list: (folder) => ipcRenderer.invoke('v12:records', 'list', folder),
+		read: (folder, id) => ipcRenderer.invoke('v12:records', 'read', folder, id),
+		write: (folder, id, text) => ipcRenderer.invoke('v12:records', 'write', folder, id, text),
+		remove: (folder, id) => ipcRenderer.invoke('v12:records', 'remove', folder, id)
+	},
+	log: {
+		append: (file, text) => ipcRenderer.invoke('v12:log', 'append', file, text),
+		size: (file) => ipcRenderer.invoke('v12:log', 'size', file),
+		rename: (from, to) => ipcRenderer.invoke('v12:log', 'rename', from, to)
+	},
+	updates: {
+		check: () => ipcRenderer.invoke('v12:update-check'),
+		install: () => ipcRenderer.invoke('v12:update-install')
+	}
+})

package/layers/desktop/electron/presentation.m

@@ -0,0 +1,87 @@
+// What Electron's API does not have: the app's presentation options (`NSApp.presentationOptions`), said and read. Without
+// it `setSimpleFullScreen` leaves AutoHideDock|AutoHideMenuBar, whose Dock and menu bar come back at the screen's edges.
+// A Node-API addon, whose functions are stable across Electron's versions, with the few it asks for declared here so that
+// no headers are needed: `tools.mjs` compiles it with the system's clang (Xcode's command line tools) and nothing else,
+// as `npm run app` and `npm run package` start. Electron gives the symbols as the addon is loaded (`-undefined dynamic_lookup`).
+#import <AppKit/AppKit.h>
+#include <stddef.h>
+#include <stdint.h>
+
+typedef struct napi_env__ *napi_env;
+typedef struct napi_value__ *napi_value;
+typedef struct napi_callback_info__ *napi_callback_info;
+typedef int napi_status;
+typedef napi_value (*napi_callback)(napi_env, napi_callback_info);
+extern napi_status napi_get_cb_info(napi_env, napi_callback_info, size_t *, napi_value *, napi_value *, void **);
+extern napi_status napi_get_value_uint32(napi_env, napi_value, uint32_t *);
+extern napi_status napi_create_uint32(napi_env, uint32_t, napi_value *);
+extern napi_status napi_create_function(napi_env, const char *, size_t, napi_callback, void *, napi_value *);
+extern napi_status napi_set_named_property(napi_env, napi_value, const char *, napi_value);
+
+static uint32_t first_argument(napi_env env, napi_callback_info info) {
+	size_t count = 1;
+	napi_value argument = NULL;
+	uint32_t value = 0;
+	napi_get_cb_info(env, info, &count, &argument, NULL, NULL);
+	if (count > 0) napi_get_value_uint32(env, argument, &value);
+	return value;
+}
+
+static napi_value number(napi_env env, uint32_t value) {
+	napi_value out = NULL;
+	napi_create_uint32(env, value, &out);
+	return out;
+}
+
+/** The app's options said; what they read as after */
+static napi_value set_options(napi_env env, napi_callback_info info) {
+	NSApp.presentationOptions = (NSApplicationPresentationOptions)first_argument(env, info);
+	return number(env, (uint32_t)NSApp.presentationOptions);
+}
+
+/** The options of this app, whether or not it is the active one */
+static napi_value own_options(napi_env env, napi_callback_info info) {
+	return number(env, (uint32_t)NSApp.presentationOptions);
+}
+
+/** The options the system holds now: the active app's */
+static napi_value system_options(napi_env env, napi_callback_info info) {
+	return number(env, (uint32_t)NSApp.currentSystemPresentationOptions);
+}
+
+/**
+ * A key pressed and let go, as an AppKit event posted inside the app, by its key code: for the probes alone, as macOS
+ * refuses an agent real keys. It comes in by the app's event queue, where the system's own have already been through
+ * what the system takes (Cmd+Tab never gets this far)
+ */
+static napi_value post_key(napi_env env, napi_callback_info info) {
+	uint32_t code = first_argument(env, info);
+	for (int down = 1; down >= 0; down--) {
+		NSEvent *event = [NSEvent keyEventWithType:down ? NSEventTypeKeyDown : NSEventTypeKeyUp
+		                                  location:NSZeroPoint
+		                             modifierFlags:0
+		                                 timestamp:NSProcessInfo.processInfo.systemUptime
+		                              windowNumber:NSApp.keyWindow.windowNumber
+		                                   context:nil
+		                                characters:code == 53 ? @"\x1b" : @""
+		               charactersIgnoringModifiers:code == 53 ? @"\x1b" : @""
+		                                 isARepeat:NO
+		                                   keyCode:(unsigned short)code];
+		[NSApp postEvent:event atStart:NO];
+	}
+	return number(env, code);
+}
+
+static void put(napi_env env, napi_value exports, const char *name, napi_callback callback) {
+	napi_value function = NULL;
+	napi_create_function(env, name, (size_t)-1, callback, NULL, &function);
+	napi_set_named_property(env, exports, name, function);
+}
+
+napi_value napi_register_module_v1(napi_env env, napi_value exports) {
+	put(env, exports, "setOptions", set_options);
+	put(env, exports, "ownOptions", own_options);
+	put(env, exports, "systemOptions", system_options);
+	put(env, exports, "postKey", post_key);
+	return exports;
+}

package/layers/desktop/electron/serve.mjs

@@ -0,0 +1,76 @@
+// The built page, answered from a scheme of the app's own: modules, WebAssembly and what the browser keeps all want an
+// origin, which a `file:` page has not. Parts of a file where a part is asked (music). No Electron here: the tests run it in Node.
+import { readFile } from 'node:fs/promises'
+import { extname, join, normalize, sep } from 'node:path'
+
+const TYPES = {
+	'.html': 'text/html; charset=utf-8',
+	'.js': 'text/javascript',
+	'.mjs': 'text/javascript',
+	'.css': 'text/css',
+	'.json': 'application/json',
+	'.wasm': 'application/wasm',
+	'.png': 'image/png',
+	'.jpg': 'image/jpeg',
+	'.jpeg': 'image/jpeg',
+	'.webp': 'image/webp',
+	'.ktx2': 'image/ktx2',
+	'.svg': 'image/svg+xml',
+	'.woff2': 'font/woff2',
+	'.woff': 'font/woff',
+	'.mp3': 'audio/mpeg',
+	'.ogg': 'audio/ogg',
+	'.wav': 'audio/wav',
+	'.glb': 'model/gltf-binary',
+	'.gltf': 'model/gltf+json'
+}
+
+/**
+ * The page's content security policy: its own origin and nothing else, with `blob:` and `data:` for what Babylon makes in
+ * the page (textures, sounds, workers), `'wasm-unsafe-eval'` for WebAssembly (the navigation, the physics) and inline
+ * styles (the HUD's). `connect`: addresses besides the app's own, such as a game's server
+ */
+export const contentPolicy = (connect = []) =>
+	[
+		"default-src 'self'",
+		"script-src 'self' 'wasm-unsafe-eval'",
+		"style-src 'self' 'unsafe-inline'",
+		"img-src 'self' data: blob:",
+		"font-src 'self' data:",
+		"media-src 'self' data: blob:",
+		"worker-src 'self' blob:",
+		`connect-src 'self' blob: data:${connect.map((address) => ` ${address}`).join('')}`,
+		"object-src 'none'",
+		"base-uri 'none'",
+		"frame-src 'none'"
+	].join('; ')
+
+/** The answer to a request for a file of the built page in `root`; never a file outside it */
+export async function answer(root, request, policy) {
+	const { pathname } = new URL(request.url)
+	const asked = pathname === '/' ? 'index.html' : decodeURIComponent(pathname).slice(1)
+	const path = normalize(join(root, asked))
+	if (!path.startsWith(root.endsWith(sep) ? root : root + sep)) return new Response('Not found', { status: 404 })
+	let bytes
+	try {
+		bytes = await readFile(path)
+	} catch {
+		return new Response('Not found', { status: 404 })
+	}
+	const headers = {
+		'Content-Type': TYPES[extname(path).toLowerCase()] ?? 'application/octet-stream',
+		'Accept-Ranges': 'bytes',
+		'Content-Security-Policy': policy
+	}
+	const range = /^bytes=(\d*)-(\d*)$/.exec(request.headers.get('range') ?? '')
+	if (range && (range[1] || range[2])) {
+		const start = range[1] ? Number(range[1]) : Math.max(0, bytes.length - Number(range[2]))
+		const end = range[1] && range[2] ? Math.min(Number(range[2]), bytes.length - 1) : bytes.length - 1
+		if (start > end) return new Response(null, { status: 416, headers: { 'Content-Range': `bytes */${bytes.length}` } })
+		return new Response(bytes.subarray(start, end + 1), {
+			status: 206,
+			headers: { ...headers, 'Content-Range': `bytes ${start}-${end}/${bytes.length}` }
+		})
+	}
+	return new Response(bytes, { status: 200, headers })
+}

package/layers/desktop/electron/tools.mjs

@@ -0,0 +1,63 @@
+// What `dev.mjs` and `package.mjs` share: Electron itself, fetched the first time it is asked for and not by the
+// install (its package has no install step: some 100 to 260 MB, which a project's other work does not pay for), and the
+// presentation addon compiled on macOS.
+import { execFileSync } from 'node:child_process'
+import { existsSync, statSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+/** The project's folder */
+export const project = fileURLToPath(new URL('..', import.meta.url))
+const require = createRequire(join(project, 'package.json'))
+
+/** Electron's executable, fetched where it is not there yet (into Electron's cache, then its package's folder) */
+export const electronBinary = () => require('electron')
+
+/** Electron's own folder of the app (`Electron.app` on macOS, the folder of `electron.exe` or `electron` elsewhere), fetched as above */
+export function electronDist() {
+	electronBinary()
+	return join(dirname(require.resolve('electron/package.json')), 'dist')
+}
+
+/** Electron's version, which a packaged app says it was made with */
+export const electronVersion = () => require('electron/package.json').version
+
+/**
+ * `presentation.m` compiled into `electron/presentation.node`, on macOS where it is not there or is older than its
+ * source. Nothing elsewhere, which has no such options. Without Xcode's command line tools (`xcode-select --install`)
+ * it says so and the shell runs without it, the Dock and the menu bar auto-hiding at the edges
+ */
+export function buildNative() {
+	if (process.platform !== 'darwin') return false
+	const source = join(project, 'electron/presentation.m')
+	const built = join(project, 'electron/presentation.node')
+	if (existsSync(built) && statSync(built).mtimeMs >= statSync(source).mtimeMs) return true
+	try {
+		execFileSync(
+			'clang',
+			[
+				'-bundle',
+				'-undefined',
+				'dynamic_lookup',
+				'-fobjc-arc',
+				'-O2',
+				'-mmacosx-version-min=12.0',
+				'-arch',
+				process.arch === 'arm64' ? 'arm64' : 'x86_64',
+				'-framework',
+				'AppKit',
+				source,
+				'-o',
+				built
+			],
+			{ stdio: 'inherit' }
+		)
+		return true
+	} catch (error) {
+		console.warn(
+			`The presentation addon was not compiled (${error.message}): the Dock and the menu bar will auto-hide in full screen. xcode-select --install gives clang`
+		)
+		return false
+	}
+}

package/layers/desktop/electron/updates.mjs

@@ -0,0 +1,71 @@
+// The app's updates, by Electron's own `autoUpdater` (Squirrel) from a folder of static files, the way of Electron's
+// docs' "Updating Applications" that needs no server and no package: on macOS a `RELEASES.json` beside the zipped app,
+// on Windows Squirrel.Windows' `RELEASES` beside its installer's packages. Squirrel.Mac installs only into an app signed
+// with a real certificate, and Squirrel.Windows only into an app its installer put there (Electron Forge's
+// `maker-squirrel`): the ad hoc signed app of `npm run package` finds nothing, and asks nothing while the address is a
+// placeholder (`config.mjs`). No Electron here: it is handed in, so that the tests run it in Node.
+
+/**
+ * The feed for this system and processor (`setFeedURL`'s options), or nothing where there is none: a placeholder's
+ * address (a host under `.invalid`), or a system Squirrel does not update (Linux)
+ */
+export function feedOf(address, platform = process.platform, arch = process.arch) {
+	let host
+	try {
+		host = new URL(address).hostname
+	} catch {
+		return undefined
+	}
+	if (host.endsWith('.invalid') || (platform !== 'darwin' && platform !== 'win32')) return undefined
+	const folder = `${address.replace(/\/+$/, '')}/${platform}/${arch}`
+	return platform === 'darwin' ? { url: `${folder}/RELEASES.json`, serverType: 'json' } : { url: folder }
+}
+
+/**
+ * What the page asks of updates: `check()`, a newer version downloaded and ready (its name and notes), or nothing; and
+ * `install()`, which quits and starts the new one. `updater` is Electron's `autoUpdater`, `feed` what `feedOf` gave,
+ * `packaged` whether this is a packaged app (`app.isPackaged`: one run from the project has nothing to update)
+ */
+export function updatesOf(updater, feed, packaged) {
+	let fed = false
+	let asking
+	return {
+		check() {
+			if (!feed || !packaged) return Promise.resolve(undefined)
+			if (asking) return asking
+			if (!fed) {
+				updater.setFeedURL(feed)
+				fed = true
+			}
+			asking = new Promise((resolve, reject) => {
+				const done = () => {
+					updater.off('update-downloaded', downloaded)
+					updater.off('update-not-available', none)
+					updater.off('error', failed)
+					asking = undefined
+				}
+				// (Squirrel downloads what it finds before it says so: "downloaded" is the one to wait for)
+				const downloaded = (_event, notes, name) => {
+					done()
+					resolve({ version: name || 'new', ...(notes && { notes: String(notes) }) })
+				}
+				const none = () => {
+					done()
+					resolve(undefined)
+				}
+				const failed = (error) => {
+					done()
+					reject(error)
+				}
+				updater.on('update-downloaded', downloaded)
+				updater.on('update-not-available', none)
+				updater.on('error', failed)
+				updater.checkForUpdates()
+			})
+			return asking
+		},
+		install() {
+			updater.quitAndInstall()
+		}
+	}
+}

package/layers/desktop/package.json

@@ -0,0 +1,13 @@
+{
+	"main": "electron/main.mjs",
+	"scripts": {
+		"dev": "vite --port 3100 --strictPort",
+		"app": "node electron/dev.mjs",
+		"app:editor": "node electron/dev.mjs --attach",
+		"package": "node electron/package.mjs"
+	},
+	"devDependencies": {
+		"electron": "45.2.1",
+		"happy-dom": "^21.0.3"
+	}
+}