@hopple/sdk 0.1.0-rc.3 → 1.0.0-next.4

package/manifest.js

@@ -0,0 +1,896 @@
+/*! @hopple/sdk 1.0.0-next.4 | Copyright (c) 2026 The Hopple authors | MIT License */
+//#region ../manifest/src/manifest.schema.ts
+const GameManifest = {
+	"type": "object",
+	"properties": {
+		"api": { "$ref": "#/definitions/ApiVersion" },
+		"id": {
+			"type": "string",
+			"pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$",
+			"maxLength": 64,
+			"errorMessage": "must be lowercase letters, digits and hyphens"
+		},
+		"owner": {
+			"type": "string",
+			"pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$",
+			"maxLength": 64,
+			"errorMessage": "must be a handle: lowercase letters, digits and hyphens"
+		},
+		"publishable": { "type": "boolean" },
+		"version": {
+			"type": "string",
+			"pattern": "^\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z.-]+)?$",
+			"errorMessage": "must look like 1.0.0"
+		},
+		"title": {
+			"type": "string",
+			"pattern": "\\S",
+			"maxLength": 60,
+			"errorMessage": "must not be blank"
+		},
+		"description": {
+			"type": "string",
+			"pattern": "\\S",
+			"maxLength": 500,
+			"errorMessage": "must not be blank"
+		},
+		"genres": {
+			"type": "array",
+			"items": { "$ref": "#/definitions/GameGenre" },
+			"minItems": 1,
+			"maxItems": 5
+		},
+		"cover": {
+			"type": "string",
+			"pattern": "^(?!/)(?!.*\\.\\.)[A-Za-z0-9._/-]+\\.(?:png|jpe?g|webp)$",
+			"maxLength": 200,
+			"errorMessage": "must be the path of a .png, .jpg or .webp file beside the config, like \"cover.png\""
+		},
+		"orientation": { "$ref": "#/definitions/Orientation" },
+		"layout": { "$ref": "#/definitions/LayoutDeclaration" },
+		"analytics": { "$ref": "#/definitions/AnalyticsDeclaration" },
+		"save": { "$ref": "#/definitions/SaveDeclaration" },
+		"score": { "$ref": "#/definitions/ScoreDeclaration" },
+		"achievements": { "$ref": "#/definitions/AchievementDeclaration" },
+		"input": { "$ref": "#/definitions/InputDeclaration" },
+		"players": { "$ref": "#/definitions/PlayersDeclaration" },
+		"audio": { "anyOf": [{ "$ref": "#/definitions/AudioDeclaration" }, { "type": "null" }] },
+		"previews": { "$ref": "#/definitions/PreviewsDeclaration" }
+	},
+	"required": [
+		"api",
+		"id",
+		"version",
+		"title",
+		"orientation",
+		"audio"
+	],
+	"additionalProperties": false
+};
+const ApiVersion = {
+	"type": "string",
+	"pattern": "^(?:(?:0|[1-9][0-9]*)\\.(?:0|[1-9][0-9]*)|next)$",
+	"errorMessage": "must be the API the game is written against, like \"1.0\", or \"next\""
+};
+const GameGenre = {
+	"type": "string",
+	"enum": [
+		"racing",
+		"shooter",
+		"platformer",
+		"puzzle",
+		"arcade",
+		"physics",
+		"roguelike",
+		"strategy",
+		"building",
+		"idle",
+		"sports",
+		"horror",
+		"stealth",
+		"fighting",
+		"casual",
+		"simulation",
+		"adventure",
+		"rhythm",
+		"rpg",
+		"local-multiplayer",
+		"online-multiplayer"
+	]
+};
+const Orientation = {
+	"type": "string",
+	"enum": [
+		"portrait",
+		"landscape",
+		"any"
+	]
+};
+const LayoutDeclaration = {
+	"type": "object",
+	"properties": { "insets": { "$ref": "#/definitions/InsetMode" } },
+	"required": ["insets"],
+	"additionalProperties": false
+};
+const InsetMode = {
+	"type": "string",
+	"enum": ["draw-under", "reserve"]
+};
+const AnalyticsDeclaration = {
+	"type": "object",
+	"properties": { "events": {
+		"type": "object",
+		"additionalProperties": { "$ref": "#/definitions/AnalyticsShape" },
+		"maxProperties": 64,
+		"propertyNames": {
+			"pattern": "^[a-z0-9]+(?:[._-][a-z0-9]+)*$",
+			"maxLength": 48,
+			"not": { "pattern": "^hopple\\." },
+			"errorMessage": "must be lowercase letters, digits, dots, hyphens and underscores, and must not start with \"hopple.\", which the host uses"
+		}
+	} },
+	"required": ["events"],
+	"additionalProperties": false
+};
+const AnalyticsShape = {
+	"type": "object",
+	"additionalProperties": { "$ref": "#/definitions/AnalyticsType" },
+	"maxProperties": 8,
+	"propertyNames": {
+		"pattern": "^[a-z0-9]+(?:[._-][a-z0-9]+)*$",
+		"maxLength": 24,
+		"errorMessage": "must be a prop name of lowercase letters, digits, dots, hyphens and underscores"
+	}
+};
+const AnalyticsType = {
+	"type": "string",
+	"enum": [
+		"string",
+		"number",
+		"boolean"
+	]
+};
+const SaveDeclaration = {
+	"type": "object",
+	"properties": { "bytes": {
+		"type": "integer",
+		"exclusiveMinimum": 0,
+		"maximum": 1048576
+	} },
+	"required": ["bytes"],
+	"additionalProperties": false
+};
+const ScoreDeclaration = {
+	"type": "object",
+	"properties": { "boards": {
+		"type": "object",
+		"additionalProperties": { "$ref": "#/definitions/ScoreBoard" },
+		"minProperties": 1,
+		"maxProperties": 16,
+		"propertyNames": {
+			"pattern": "^[a-z0-9]+(?:[._-][a-z0-9]+)*$",
+			"maxLength": 48,
+			"errorMessage": "must be lowercase letters, digits, dots, hyphens and underscores"
+		}
+	} },
+	"required": ["boards"],
+	"additionalProperties": false
+};
+const ScoreBoard = {
+	"type": "object",
+	"properties": {
+		"title": {
+			"type": "string",
+			"pattern": "\\S",
+			"maxLength": 40,
+			"errorMessage": "must not be blank"
+		},
+		"direction": { "$ref": "#/definitions/ScoreDirection" },
+		"format": { "$ref": "#/definitions/ScoreFormat" }
+	},
+	"required": ["title", "direction"],
+	"additionalProperties": false
+};
+const ScoreDirection = {
+	"type": "string",
+	"enum": ["asc", "desc"]
+};
+const ScoreFormat = {
+	"type": "string",
+	"enum": [
+		"integer",
+		"decimal",
+		"duration-ms"
+	]
+};
+const AchievementDeclaration = {
+	"type": "object",
+	"properties": { "list": {
+		"type": "object",
+		"additionalProperties": { "$ref": "#/definitions/Achievement" },
+		"minProperties": 1,
+		"maxProperties": 128,
+		"propertyNames": {
+			"pattern": "^[a-z0-9]+(?:[._-][a-z0-9]+)*$",
+			"maxLength": 48,
+			"errorMessage": "must be lowercase letters, digits, dots, hyphens and underscores"
+		}
+	} },
+	"required": ["list"],
+	"additionalProperties": false
+};
+const Achievement = {
+	"type": "object",
+	"properties": {
+		"title": {
+			"type": "string",
+			"pattern": "\\S",
+			"maxLength": 40,
+			"errorMessage": "must not be blank"
+		},
+		"detail": {
+			"type": "string",
+			"pattern": "\\S",
+			"maxLength": 120,
+			"errorMessage": "must not be blank"
+		},
+		"icon": {
+			"type": "string",
+			"pattern": "\\S",
+			"maxLength": 8,
+			"errorMessage": "must not be blank"
+		},
+		"secret": { "type": "boolean" },
+		"progress": { "$ref": "#/definitions/AchievementProgress" }
+	},
+	"required": ["title"],
+	"additionalProperties": false
+};
+const AchievementProgress = {
+	"type": "object",
+	"properties": {
+		"target": {
+			"type": "number",
+			"minimum": -9007199254740991,
+			"maximum": 9007199254740991
+		},
+		"direction": { "$ref": "#/definitions/ScoreDirection" },
+		"format": { "$ref": "#/definitions/ScoreFormat" },
+		"tiers": {
+			"type": "array",
+			"items": { "$ref": "#/definitions/AchievementTier" },
+			"maxItems": 8
+		}
+	},
+	"required": ["target"],
+	"additionalProperties": false
+};
+const AchievementTier = {
+	"type": "object",
+	"properties": {
+		"at": {
+			"type": "number",
+			"minimum": -9007199254740991,
+			"maximum": 9007199254740991
+		},
+		"title": {
+			"type": "string",
+			"pattern": "\\S",
+			"maxLength": 40,
+			"errorMessage": "must not be blank"
+		},
+		"icon": {
+			"type": "string",
+			"pattern": "\\S",
+			"maxLength": 8,
+			"errorMessage": "must not be blank"
+		}
+	},
+	"required": ["at", "title"],
+	"additionalProperties": false
+};
+const InputDeclaration = {
+	"type": "object",
+	"properties": {
+		"supported": {
+			"type": "array",
+			"items": { "$ref": "#/definitions/InputDeviceSet" },
+			"minItems": 1,
+			"maxItems": 8
+		},
+		"actions": {
+			"type": "object",
+			"additionalProperties": { "$ref": "#/definitions/InputAction" },
+			"maxProperties": 64,
+			"propertyNames": {
+				"pattern": "^[a-z0-9]+(?:[._-][a-z0-9]+)*$",
+				"maxLength": 48,
+				"errorMessage": "must be lowercase letters, digits, dots, hyphens and underscores"
+			}
+		},
+		"controls": {
+			"type": "object",
+			"additionalProperties": { "$ref": "#/definitions/ControlLayout" },
+			"maxProperties": 8,
+			"propertyNames": {
+				"pattern": "^[a-z0-9]+(?:[._-][a-z0-9]+)*$",
+				"maxLength": 48,
+				"errorMessage": "must be a layout name of lowercase letters, digits, dots, hyphens and underscores"
+			}
+		},
+		"player": { "$ref": "#/definitions/PlayerInputDeclaration" }
+	},
+	"additionalProperties": false
+};
+const InputDeviceSet = {
+	"type": "array",
+	"items": { "$ref": "#/definitions/InputDevice" },
+	"minItems": 1,
+	"maxItems": 8
+};
+const InputDevice = {
+	"type": "string",
+	"enum": [
+		"keyboard",
+		"mouse",
+		"touch",
+		"gamepad"
+	]
+};
+const InputAction = {
+	"type": "object",
+	"properties": {
+		"bind": { "$ref": "#/definitions/InputBindings" },
+		"title": {
+			"type": "string",
+			"pattern": "\\S",
+			"maxLength": 40,
+			"errorMessage": "must not be blank"
+		},
+		"label": {
+			"type": "string",
+			"pattern": "\\S",
+			"maxLength": 8,
+			"errorMessage": "must not be blank"
+		}
+	},
+	"required": ["bind"],
+	"additionalProperties": false
+};
+const InputBindings = {
+	"type": "array",
+	"items": { "$ref": "#/definitions/InputBinding" },
+	"minItems": 1,
+	"maxItems": 8
+};
+const InputBinding = {
+	"type": "string",
+	"pattern": "^(?:key\\.(?!Escape$)(?=.{1,48}$)[A-Za-z][A-Za-z0-9]*|pointer\\.(?:primary|secondary)|mouse\\.(?:left|middle|right)|touch\\.tap|controls\\.(?=.{1,48}$)[a-z0-9]+(?:[_-][a-z0-9]+)*|pad\\.(?:north|south|east|west|start|select)|pad\\.(?:left|right)\\.(?:north|south|east|west|bumper|trigger))$",
+	"errorMessage": "is not a binding this SDK knows (a thumbstick is read rather than bound, and Escape is the host's key)"
+};
+const ControlLayout = {
+	"type": "object",
+	"properties": {
+		"left": { "$ref": "#/definitions/ControlZoneSlots" },
+		"right": { "$ref": "#/definitions/ControlZoneSlots" },
+		"full": { "$ref": "#/definitions/ControlZoneSlots" }
+	},
+	"additionalProperties": false
+};
+const ControlZoneSlots = {
+	"type": "object",
+	"additionalProperties": { "$ref": "#/definitions/ControlSlot" },
+	"maxProperties": 8,
+	"propertyNames": {
+		"pattern": "^[a-z0-9]+(?:[._-][a-z0-9]+)*$",
+		"maxLength": 48,
+		"errorMessage": "must be a control id of lowercase letters, digits, dots, hyphens and underscores"
+	}
+};
+const ControlSlot = {
+	"type": "object",
+	"properties": {
+		"type": {
+			"type": "string",
+			"enum": ["buttons", "thumbstick"]
+		},
+		"buttons": {
+			"type": "array",
+			"items": { "type": "string" },
+			"minItems": 1,
+			"maxItems": 8
+		},
+		"shape": { "$ref": "#/definitions/ControlShape" },
+		"as": { "anyOf": [{ "$ref": "#/definitions/InputStick" }, {
+			"type": "object",
+			"additionalProperties": { "$ref": "#/definitions/InputBinding" }
+		}] },
+		"axis": { "$ref": "#/definitions/ControlAxis" },
+		"scale": {
+			"type": "number",
+			"minimum": .75,
+			"maximum": 1.5
+		}
+	},
+	"required": ["type"],
+	"additionalProperties": false,
+	"if": {
+		"properties": { "type": { "const": "buttons" } },
+		"required": ["type"]
+	},
+	"then": {
+		"required": ["buttons"],
+		"properties": {
+			"as": {
+				"type": "object",
+				"additionalProperties": { "$ref": "#/definitions/InputBinding" }
+			},
+			"axis": {
+				"not": {},
+				"errorMessage": "is only for a thumbstick"
+			}
+		}
+	},
+	"else": { "properties": { "as": { "$ref": "#/definitions/InputStick" } } }
+};
+const ControlShape = {
+	"type": "string",
+	"enum": [
+		"row",
+		"column",
+		"diamond",
+		"cluster"
+	]
+};
+const InputStick = {
+	"type": "string",
+	"pattern": "^(?:controls\\.(?=.{1,48}$)[a-z0-9]+(?:[_-][a-z0-9]+)*|pad\\.stick|pad\\.(?:left|right)\\.stick)$",
+	"errorMessage": "must name a thumbstick, such as pad.left.stick"
+};
+const definitions = {
+	GameManifest,
+	ApiVersion,
+	GameGenre,
+	Orientation,
+	LayoutDeclaration,
+	InsetMode,
+	AnalyticsDeclaration,
+	AnalyticsShape,
+	AnalyticsType,
+	SaveDeclaration,
+	ScoreDeclaration,
+	ScoreBoard,
+	ScoreDirection,
+	ScoreFormat,
+	AchievementDeclaration,
+	Achievement,
+	AchievementProgress,
+	AchievementTier,
+	InputDeclaration,
+	InputDeviceSet,
+	InputDevice,
+	InputAction,
+	InputBindings,
+	InputBinding,
+	ControlLayout,
+	ControlZoneSlots,
+	ControlSlot,
+	ControlShape,
+	InputStick,
+	ControlAxis: {
+		"type": "string",
+		"enum": ["x", "y"]
+	},
+	PlayerInputDeclaration: {
+		"type": "object",
+		"properties": {
+			"actions": {
+				"type": "object",
+				"additionalProperties": { "$ref": "#/definitions/PlayerInputAction" },
+				"maxProperties": 32,
+				"propertyNames": {
+					"pattern": "^[a-z0-9]+(?:[._-][a-z0-9]+)*$",
+					"maxLength": 48,
+					"errorMessage": "must be lowercase letters, digits, dots, hyphens and underscores"
+				}
+			},
+			"keyboard": {
+				"type": "array",
+				"items": { "$ref": "#/definitions/KeyboardSet" },
+				"minItems": 1,
+				"maxItems": 4
+			}
+		},
+		"required": ["actions"],
+		"additionalProperties": false
+	},
+	PlayerInputAction: {
+		"type": "object",
+		"properties": {
+			"bind": {
+				"type": "array",
+				"items": { "$ref": "#/definitions/PlayerBinding" },
+				"minItems": 1,
+				"maxItems": 8
+			},
+			"title": {
+				"type": "string",
+				"pattern": "\\S",
+				"maxLength": 40,
+				"errorMessage": "must not be blank"
+			},
+			"label": {
+				"type": "string",
+				"pattern": "\\S",
+				"maxLength": 8,
+				"errorMessage": "must not be blank"
+			},
+			"join": { "type": "boolean" }
+		},
+		"additionalProperties": false
+	},
+	PlayerBinding: {
+		"type": "string",
+		"pattern": "^(?:controls\\.(?=.{1,48}$)[a-z0-9]+(?:[_-][a-z0-9]+)*|pad\\.(?:north|south|east|west|start|select)|pad\\.(?:left|right)\\.(?:north|south|east|west|bumper|trigger))$",
+		"errorMessage": "must be a pad button or an on-screen control: a player's keys and mouse buttons go in input.player.keyboard"
+	},
+	KeyboardSet: {
+		"type": "object",
+		"properties": {
+			"title": {
+				"type": "string",
+				"pattern": "\\S",
+				"maxLength": 40,
+				"errorMessage": "must not be blank"
+			},
+			"bind": {
+				"type": "object",
+				"additionalProperties": {
+					"type": "array",
+					"items": { "$ref": "#/definitions/KeyboardBinding" }
+				},
+				"maxProperties": 64,
+				"propertyNames": {
+					"pattern": "^[a-z0-9]+(?:[._-][a-z0-9]+)*$",
+					"maxLength": 48,
+					"errorMessage": "must be a player action id"
+				}
+			}
+		},
+		"required": ["bind"],
+		"additionalProperties": false
+	},
+	KeyboardBinding: {
+		"type": "string",
+		"pattern": "^(?:key\\.(?!Escape$)(?=.{1,48}$)[A-Za-z][A-Za-z0-9]*|mouse\\.(?:left|middle|right))$",
+		"errorMessage": "must be a key or a mouse button (and Escape is the host's key)"
+	},
+	PlayersDeclaration: {
+		"type": "object",
+		"properties": { "local": {
+			"type": "integer",
+			"minimum": 1,
+			"maximum": 8
+		} },
+		"additionalProperties": false
+	},
+	AudioDeclaration: {
+		"type": "object",
+		"properties": { "channels": {
+			"type": "object",
+			"additionalProperties": { "$ref": "#/definitions/AudioChannel" },
+			"maxProperties": 8,
+			"propertyNames": {
+				"pattern": "^[a-z0-9]+(?:[._-][a-z0-9]+)*$",
+				"maxLength": 48,
+				"not": { "const": "master" },
+				"errorMessage": "must be lowercase letters, digits, dots, hyphens and underscores, and must not be \"master\", which every host adds itself"
+			}
+		} },
+		"additionalProperties": false
+	},
+	AudioChannel: {
+		"type": "object",
+		"properties": { "title": {
+			"type": "string",
+			"pattern": "\\S",
+			"maxLength": 40,
+			"errorMessage": "must not be blank"
+		} },
+		"required": ["title"],
+		"additionalProperties": false
+	},
+	PreviewsDeclaration: {
+		"type": "object",
+		"properties": { "network": { "$ref": "#/definitions/PreviewRevision" } },
+		"additionalProperties": false
+	},
+	PreviewRevision: {
+		"type": "integer",
+		"minimum": 1
+	}
+};
+AchievementProgress.properties.target.maximum;
+GameManifest.required;
+GameGenre.enum;
+/**
+* The zones a layout places controls in, in the order they are drawn.
+*
+* @group Input
+*/
+const CONTROL_ZONES = Object.keys(ControlLayout.properties);
+new RegExp(InputBinding.pattern);
+new RegExp(InputStick.pattern);
+/**
+* Check a parsed manifest, without throwing and without changing it.
+*
+* Every problem is reported, not just the first: someone fixing a manifest
+* wants the list, and a validator that reveals one error per run is a validator
+* people stop running. A key the manifest does not know is refused, since a
+* misspelt one would otherwise mean nothing in silence; `lenient` ignores it
+* instead, for reading a manifest that was published, possibly against a newer
+* minor than this one. A key we *do* know, spelled wrongly, is refused either
+* way: `"draw_under"` would otherwise mean `reserve` in silence, and silence
+* here looks exactly like a bug in the host.
+*
+* @group Manifest
+* @category Important
+*/
+function validateManifest(value, options = {}) {
+	const problems = [];
+	const fail = (field, message) => {
+		if (problems.some((p) => p.field === field && p.message === message)) return;
+		problems.push({
+			field,
+			message
+		});
+	};
+	walk(GameManifest, value, "", fail, options.lenient === true);
+	if (problems.length === 0) checkReferences(value, fail);
+	if (problems.length > 0) return {
+		ok: false,
+		problems
+	};
+	return {
+		ok: true,
+		manifest: value
+	};
+}
+/**
+* One line per problem, worded the same wherever a manifest is rejected.
+*
+* Field names are set in backticks, because plenty of them are ordinary words
+* — "entry is required" reads as a sentence about some entry, and
+* "`entry` is required" names a key.
+*
+* @group Manifest
+* @category Useful
+*/
+function describeProblems(problems) {
+	return problems.map((p) => p.field === "" ? `the manifest ${p.message}` : `\`${p.field}\` ${p.message}`).join("; ");
+}
+function resolve(node) {
+	let at = node;
+	while (typeof at.$ref === "string") {
+		const name = at.$ref.slice(14);
+		const found = definitions[name];
+		if (found === void 0) throw new Error(`the manifest schema has no definition ${name}`);
+		at = found;
+	}
+	return at;
+}
+/** Whether a value passes, with nothing reported. */
+function passes(node, value, lenient) {
+	let ok = true;
+	walk(node, value, "", () => {
+		ok = false;
+	}, lenient);
+	return ok;
+}
+function kindOf(value) {
+	if (Array.isArray(value)) return "array";
+	if (value === null) return "null";
+	if (typeof value === "number") return Number.isInteger(value) ? "integer" : "number";
+	return typeof value;
+}
+function isKind(value, type) {
+	const kind = kindOf(value);
+	return kind === type || type === "number" && kind === "integer";
+}
+const KIND_WORDS = {
+	string: "a string",
+	number: "a number",
+	integer: "a whole number",
+	boolean: "true or false",
+	object: "an object",
+	array: "a list",
+	null: "null"
+};
+function child(path, key, max = 48) {
+	const name = [...key].length > max ? `${[...key].slice(0, max).join("")}…` : key;
+	return path === "" ? name : `${path}.${name}`;
+}
+/** One value against one schema node, reporting what is wrong where it is wrong. */
+/** `lenient` ignores keys an object's schema does not name, rather than refusing them. */
+function walk(given, value, path, fail, lenient) {
+	const node = resolve(given);
+	if (Array.isArray(node.anyOf)) {
+		const branches = node.anyOf.map(resolve);
+		if (branches.some((branch) => passes(branch, value, lenient))) return;
+		const shaped = branches.find((branch) => isKind(value, branch.type));
+		if (shaped !== void 0) walk(shaped, value, path, fail, lenient);
+		else fail(path, `must be ${branches.map((branch) => KIND_WORDS[String(branch.type)]).join(" or ")}`);
+		return;
+	}
+	if (node.type !== void 0 && !isKind(value, node.type)) {
+		fail(path, `must be ${KIND_WORDS[String(node.type)] ?? String(node.type)}`);
+		return;
+	}
+	if ("const" in node && value !== node.const) {
+		fail(path, `must be ${JSON.stringify(node.const)}`);
+		return;
+	}
+	if (Array.isArray(node.enum) && !node.enum.includes(value)) {
+		fail(path, `must be one of ${node.enum.join(", ")}`);
+		return;
+	}
+	const message = typeof node.errorMessage === "string" ? node.errorMessage : void 0;
+	if (typeof value === "string") {
+		const length = [...value].length;
+		if (typeof node.pattern === "string" && !new RegExp(node.pattern, "u").test(value)) fail(path, message ?? `must match ${node.pattern}`);
+		else if (typeof node.maxLength === "number" && length > node.maxLength) fail(path, `must be at most ${node.maxLength} characters`);
+		else if (typeof node.minLength === "number" && length < node.minLength) fail(path, `must be at least ${node.minLength} characters`);
+	}
+	if (typeof value === "number") {
+		if (typeof node.minimum === "number" && value < node.minimum) fail(path, `must be at least ${node.minimum}`);
+		else if (typeof node.exclusiveMinimum === "number" && value <= node.exclusiveMinimum) fail(path, `must be above ${node.exclusiveMinimum}`);
+		else if (typeof node.maximum === "number" && value > node.maximum) fail(path, `must be at most ${node.maximum}`);
+		else if (typeof node.exclusiveMaximum === "number" && value >= node.exclusiveMaximum) fail(path, `must be below ${node.exclusiveMaximum}`);
+	}
+	if (node.not !== void 0 && passes(node.not, value, lenient)) fail(path, message ?? "is not allowed");
+	if (Array.isArray(value)) walkArray(node, value, path, fail, lenient);
+	else if (kindOf(value) === "object") walkObject(node, value, path, fail, lenient);
+	if (node.if !== void 0) {
+		const branch = passes(node.if, value, lenient) ? node.then : node.else;
+		if (branch !== void 0) walk(branch, value, path, fail, lenient);
+	}
+	if (Array.isArray(node.allOf)) for (const part of node.allOf) walk(part, value, path, fail, lenient);
+}
+function walkArray(node, value, path, fail, lenient) {
+	if (typeof node.minItems === "number" && value.length < node.minItems) fail(path, node.minItems === 1 ? "must not be empty" : `must hold at least ${node.minItems}`);
+	else if (typeof node.maxItems === "number" && value.length > node.maxItems) fail(path, `must hold at most ${node.maxItems}`);
+	if (node.items === void 0) return;
+	for (const [index, item] of value.entries()) if (typeof item === "object" && item !== null) walk(node.items, item, `${path}[${index}]`, fail, lenient);
+	else walk(node.items, item, path, (field, message) => {
+		fail(field, field === path ? `${JSON.stringify(item)} ${message}` : message);
+	}, lenient);
+}
+function walkObject(node, value, path, fail, lenient) {
+	const keys = Object.keys(value);
+	if (typeof node.minProperties === "number" && keys.length < node.minProperties) fail(path, node.minProperties === 1 ? "must declare at least one" : `must declare at least ${node.minProperties}`);
+	else if (typeof node.maxProperties === "number" && keys.length > node.maxProperties) fail(path, `must declare at most ${node.maxProperties}`);
+	const names = node.propertyNames;
+	const clip = typeof names?.maxLength === "number" ? names.maxLength : void 0;
+	const properties = node.properties ?? {};
+	const required = node.required ?? [];
+	for (const [key, property] of Object.entries(properties)) if (key in value) walk(property, value[key], child(path, key), fail, lenient);
+	else if (required.includes(key)) fail(child(path, key), "is required");
+	for (const key of keys) {
+		if (key in properties) continue;
+		const at = child(path, key, clip);
+		if (names !== void 0) {
+			let first;
+			walk(names, key, "", (_field, message) => {
+				first ??= message;
+			}, lenient);
+			if (first !== void 0) fail(at, first);
+		}
+		if (typeof node.additionalProperties === "object" && node.additionalProperties !== null) walk(node.additionalProperties, value[key], at, fail, lenient);
+		else if (node.additionalProperties === false && !lenient) fail(at, "is not a key the manifest knows");
+	}
+}
+function checkReferences(manifest, fail) {
+	const genres = manifest.genres ?? [];
+	for (const genre of new Set(genres.filter((one, index) => genres.indexOf(one) !== index))) fail("genres", `names "${genre}" twice`);
+	if (genres.filter((genre) => !MULTIPLAYER_GENRES.includes(genre)).length > 3) fail("genres", `must hold at most 3 genres, beside local-multiplayer and online-multiplayer`);
+	const players = manifest.input?.player;
+	const own = new Set(Object.keys(players?.actions ?? {}));
+	const actions = /* @__PURE__ */ new Set([...Object.keys(manifest.input?.actions ?? {}), ...own]);
+	for (const id of own) if (manifest.input?.actions?.[id] !== void 0) fail(`input.player.actions.${id}`, "is an id input.actions declares too");
+	/** Which set each key or mouse button already presses something in, so two players never share one. */
+	const taken = /* @__PURE__ */ new Map();
+	for (const [index, set] of (players?.keyboard ?? []).entries()) for (const [id, bind] of Object.entries(set.bind)) {
+		const at = `input.player.keyboard[${index}].bind.${id}`;
+		if (!own.has(id)) fail(at, `names no player action "${id}"`);
+		for (const binding of bind) {
+			const before = taken.get(binding);
+			if (before !== void 0 && before !== index) fail(at, `binds ${binding}, which keyboard set ${before} binds too: a press would be two players'`);
+			taken.set(binding, index);
+		}
+	}
+	for (const id of own) if (!((players?.actions[id]?.bind?.length ?? 0) > 0 || (players?.keyboard ?? []).some((set) => (set.bind[id]?.length ?? 0) > 0) || Object.values(controlLayouts(manifest)).some((layout) => layoutActions(layout).includes(id)))) fail(`input.player.actions.${id}`, "is pressed by nothing: bind it, give it keys in a keyboard set, or put it on an on-screen control");
+	if ((manifest.players?.local ?? 1) > 1 && players === void 0) fail("players.local", "needs input.player: the actions each of the players has");
+	for (const [name, layout] of Object.entries(controlLayouts(manifest))) for (const zone of CONTROL_ZONES) for (const [id, slot] of Object.entries(layout[zone] ?? {})) {
+		if (slot.type !== "buttons" || slot.buttons === void 0) continue;
+		const at = `input.controls.${name}.${zone}.${id}`;
+		for (const action of slot.buttons) if (!actions.has(action)) fail(`${at}.buttons`, `names no declared action "${action}"`);
+		if (typeof slot.as !== "object") continue;
+		for (const action of Object.keys(slot.as)) if (!slot.buttons.includes(action)) fail(`${at}.as`, `names no button "${action}" in this control`);
+	}
+	for (const [id, achievement] of Object.entries(declaredAchievements(manifest))) {
+		const progress = achievement.progress;
+		if (progress?.tiers === void 0) continue;
+		const way = achievementDirection(achievement);
+		let previous = null;
+		for (const [index, tier] of progress.tiers.entries()) {
+			const at = `achievements.list.${id}.progress.tiers[${index}].at`;
+			if (previous !== null && !beatsScore(way, tier.at, previous)) fail(at, `must be past ${previous}, which is the tier before it`);
+			if (beatsScore(way, tier.at, progress.target)) fail(at, `must be short of the target of ${progress.target}`);
+			previous = tier.at;
+		}
+	}
+}
+/** The genres that say how a game is played together rather than what it is. */
+const MULTIPLAYER_GENRES = ["local-multiplayer", "online-multiplayer"];
+/**
+* Whether `a` beats `b` on a board sorted this way. Ties are not improvements.
+*
+* @group Score
+*/
+function beatsScore(direction, a, b) {
+	return direction === "asc" ? a < b : a > b;
+}
+/**
+* The achievements a game declared, with the default applied.
+*
+* An empty map for a game that declared nothing, which reads as "this game has
+* no achievements" — the only safe reading of silence, and what makes the tab
+* absent rather than empty.
+*
+* @group Achievements
+*/
+function declaredAchievements(manifest) {
+	return manifest.achievements?.list ?? {};
+}
+/**
+* Which way a measured achievement counts, with the default applied.
+*
+* One place that knows, because a host, a client and a server that disagreed
+* would each be right about a different achievement.
+*
+* @group Achievements
+*/
+function achievementDirection(achievement) {
+	return achievement.progress?.direction ?? "desc";
+}
+/**
+* The layouts of on-screen controls a game declared.
+*
+* An empty map for a game that declared none, which reads as "draw nothing over
+* this game" — the only safe reading of silence, and what keeps a pad off a
+* game written before any of this existed.
+*
+* @group Input
+*/
+function controlLayouts(manifest) {
+	return manifest.input?.controls ?? {};
+}
+/**
+* Every action a layout puts on the screen, in the order the zones declare them.
+*
+* @group Input
+*/
+function layoutActions(layout) {
+	const found = [];
+	for (const zone of CONTROL_ZONES) {
+		const slots = layout[zone];
+		if (slots === void 0) continue;
+		for (const slot of Object.values(slots)) {
+			if (slot.type !== "buttons" || !Array.isArray(slot.buttons)) continue;
+			for (const action of slot.buttons) if (!found.includes(action)) found.push(action);
+		}
+	}
+	return found;
+}
+//#endregion
+export { describeProblems, validateManifest };