incanto 0.69.0 → 0.71.0

package/dist/test.js

@@ -1,3 +1,3 @@
-import { i as instancedScenes, r as auditScene } from "./replay-BEHLDcQV.js";
-import { C as describeFraming, S as playtestText, _ as facingReport, a as registerAllNodes, b as findPlayer, c as ladderText, d as multiplayText, f as playMultiplayer, g as agreementProblems, h as takeAgreementSnapshots, i as findFloatingProps, l as ladderVerdict, m as feelText, n as createPlaySession, o as runScript, p as feelReport, r as describeCapture, s as validateScene, t as captureScene, u as multiplayProblems, v as facingText, w as framingText, x as playtest, y as failingReplays } from "./test-D6ISmuFE.js";
-export { agreementProblems, auditScene, captureScene, createPlaySession, describeCapture, describeFraming, facingReport, facingText, failingReplays, feelReport, feelText, findFloatingProps, findPlayer, framingText, instancedScenes, ladderText, ladderVerdict, multiplayProblems, multiplayText, playMultiplayer, playtest, playtestText, registerAllNodes, runScript, takeAgreementSnapshots, validateScene };
+import { i as instancedScenes, r as auditScene } from "./replay-DEvp3kyV.js";
+import { A as geometricPicker, C as facingReport, D as playtest, E as findPlayer, F as sceneAssetUrls, M as pointAtNode, N as describeFraming, O as playtestFailed, P as framingText, S as collectionProblems, T as failingReplays, _ as feelReport, a as registerAllNodes, b as takeCollectionSnapshots, c as feelsRung, d as ladderVerdict, f as saysRung, g as playMultiplayer, h as multiplayText, i as findFloatingProps, j as geometricView, k as playtestText, l as firstLine, m as multiplayProblems, n as createPlaySession, o as runScript, p as unmeasuredPlays, r as describeCapture, s as validateScene, t as captureScene, u as ladderText, v as feelText, w as facingText, x as agreementProblems, y as takeAgreementSnapshots } from "./test-CmN54kWv.js";
+export { agreementProblems, auditScene, captureScene, collectionProblems, createPlaySession, describeCapture, describeFraming, facingReport, facingText, failingReplays, feelReport, feelText, feelsRung, findFloatingProps, findPlayer, firstLine, framingText, geometricPicker, geometricView, instancedScenes, ladderText, ladderVerdict, multiplayProblems, multiplayText, playMultiplayer, playtest, playtestFailed, playtestText, pointAtNode, registerAllNodes, runScript, saysRung, sceneAssetUrls, takeAgreementSnapshots, takeCollectionSnapshots, unmeasuredPlays, validateScene };

package/dist/touch-BnCyPA0G.js

@@ -0,0 +1,519 @@
+import { r as jsonKind, t as jsonClone } from "./json-CfTjpvW8.js";
+import { t as IncantoError } from "./errors-BpWbnbb_.js";
+//#region src/core/nearest.ts
+/**
+* The one name you probably meant, out of the list the error already prints.
+*
+* Every `UNKNOWN_*` error in this engine lists what WOULD have worked, which is
+* the right instinct and, past a couple of dozen options, not an answer. Two
+* measured cases, from one session of building a game out of the skills:
+*
+* ```
+* Unknown node type 'Label2D'. Registered types: [Node, Timer, Respawn,
+* AudioPlayer, HudLayer, UiText, … 64 of them …].
+*
+* Unknown prop 'size' on 'Label'. Valid props: [position, rotation, static,
+* scale, renderOrder, orderGroup, visible, text, fontSize, color, font, align,
+* opacity].
+* ```
+*
+* Both answers are in those lists — `Label`, and `fontSize`. Nothing points at
+* them, and the wall of names reads as "none of these is what you want". The
+* scene loader has had `nearestKey` for its own key check since the round that
+* closed that dictionary; the same three lines belong on every one of them.
+*
+* Two rules, because typos come in two shapes:
+*
+*   a small EDIT distance   `Label2D` → `Label`, `Sprite2D` → `Sprite3D`,
+*                           `colorrect2d` → `ColorRect2D` (case only, d = 0)
+*   a CONTAINED word        `size` → `fontSize`, `speed` → `fallSpeed` — far
+*                           apart by edit distance, and obviously the same word
+*/
+/** Case-insensitive Levenshtein distance. */
+function editDistance(a, b) {
+	const x = a.toLowerCase();
+	const y = b.toLowerCase();
+	const rows = Array.from({ length: x.length + 1 }, () => Array(y.length + 1).fill(0));
+	for (let i = 0; i <= x.length; i++) rows[i][0] = i;
+	for (let j = 0; j <= y.length; j++) rows[0][j] = j;
+	for (let i = 1; i <= x.length; i++) for (let j = 1; j <= y.length; j++) {
+		const cost = x[i - 1] === y[j - 1] ? 0 : 1;
+		rows[i][j] = Math.min(rows[i - 1][j] + 1, rows[i][j - 1] + 1, rows[i - 1][j - 1] + cost);
+	}
+	return rows[x.length][y.length];
+}
+/**
+* The closest candidate, or null when nothing is close enough to name.
+*
+* Null matters as much as a hit: a suggestion that is not the answer sends its
+* reader somewhere wrong, so a name that resembles nothing gets the list alone,
+* exactly as before.
+*/
+function nearestName(name, known) {
+	let best = null;
+	let bestScore = Number.POSITIVE_INFINITY;
+	const lower = name.toLowerCase();
+	for (const candidate of known) {
+		if (candidate === name) continue;
+		const d = editDistance(name, candidate);
+		const low = candidate.toLowerCase();
+		const contained = lower.length >= 3 && (low.includes(lower) || lower.includes(low)) && Math.abs(low.length - lower.length) <= 8;
+		const score = d <= 2 ? d : contained ? 2.5 : Number.POSITIVE_INFINITY;
+		if (score < bestScore) {
+			bestScore = score;
+			best = candidate;
+		}
+	}
+	return best;
+}
+/** ` Did you mean "X"?`, or nothing at all. */
+function didYouMean(name, known) {
+	const guess = nearestName(name, known);
+	return guess ? ` Did you mean "${guess}"?` : "";
+}
+//#endregion
+//#region src/core/prop-range.ts
+function describe(range) {
+	const { min, max, exclusiveMin, exclusiveMax, allow } = range;
+	let body;
+	if (min !== void 0 && max !== void 0) body = `${exclusiveMin ? "above " : ""}${min}..${max}${exclusiveMax ? " exclusive" : ""}`;
+	else if (min !== void 0) body = exclusiveMin ? `greater than ${min}` : `at least ${min}`;
+	else if (max !== void 0) body = exclusiveMax ? `less than ${max}` : `at most ${max}`;
+	else body = "a finite number";
+	return allow && allow.length > 0 ? `${body} (or ${allow.join(", ")})` : body;
+}
+/**
+* Throws `PROP_TYPE_MISMATCH` when a number falls outside its documented range.
+*
+* A non-number is ignored: the kind check has already run and reporting the
+* same value twice, under two codes, tells its reader nothing new.
+*
+* @param value the authored value
+* @param label `Type.prop`, for the message
+* @param range what the prop documents
+*/
+function validatePropRange(value, label, range) {
+	if (typeof value !== "number") return;
+	if (range.allow?.includes(value)) return;
+	if (!Number.isFinite(value)) throw new IncantoError("PROP_TYPE_MISMATCH", `Prop '${label}' must be a finite number, got ${value}.`, { prop: label });
+	const belowMin = range.min !== void 0 && (range.exclusiveMin ? value <= range.min : value < range.min);
+	const aboveMax = range.max !== void 0 && (range.exclusiveMax ? value >= range.max : value > range.max);
+	if (!belowMin && !aboveMax) return;
+	throw new IncantoError("PROP_TYPE_MISMATCH", `Prop '${label}' must be ${describe(range)}, got ${value}.`, { prop: label });
+}
+//#endregion
+//#region src/core/registry.ts
+/**
+* Validate a prop value against its schema default:
+* - JSON kind must match (unless the default is null = "any")
+* - numbers must be finite (NaN/Infinity corrupt JSON files)
+* - non-empty default arrays are FIXED templates: same length, element-wise match
+*   (empty default arrays are unconstrained — variable-length lists)
+*/
+function validatePropValue(value, def, at, options, kinds) {
+	if (options && typeof value === "string" && !options.includes(value)) throw new IncantoError("PROP_TYPE_MISMATCH", `Prop '${at}' is ${JSON.stringify(value)}, which is not one of: ${options.map((o) => JSON.stringify(o)).join(", ")}.`, {
+		prop: at,
+		validOptions: [...options]
+	});
+	const expected = jsonKind(def);
+	if (expected === "null") return;
+	const actual = jsonKind(value);
+	const accepted = kinds ?? [expected];
+	if (!accepted.includes(actual)) throw new IncantoError("PROP_TYPE_MISMATCH", `Prop '${at}' expects ${listKinds(accepted)} (default ${JSON.stringify(def)}), got ${actual} (${JSON.stringify(value)}).`, { prop: at });
+	if (actual !== expected) return;
+	if (typeof value === "number" && !Number.isFinite(value)) throw new IncantoError("PROP_TYPE_MISMATCH", `Prop '${at}' is ${value} — props must be finite numbers.`, { prop: at });
+	if (Array.isArray(def) && Array.isArray(value) && def.length > 0) {
+		if (value.length !== def.length) throw new IncantoError("PROP_TYPE_MISMATCH", `Prop '${at}' expects an array of length ${def.length} (default ${JSON.stringify(def)}), got length ${value.length}.`, { prop: at });
+		for (let i = 0; i < def.length; i++) validatePropValue(value[i], def[i], `${at}[${i}]`);
+	}
+}
+/** `['string', 'number']` -> `"string or number"`. */
+function listKinds(kinds) {
+	if (kinds.length <= 1) return kinds[0] ?? "nothing";
+	return `${kinds.slice(0, -1).join(", ")} or ${kinds[kinds.length - 1]}`;
+}
+/**
+* Global node-type registry (Godot's ClassDB role).
+*
+* Registration is EXPLICIT — never an import-time side effect, so
+* `sideEffects: false` tree-shaking can never silently drop node types.
+*/
+const types = /* @__PURE__ */ new Map();
+function registerNode(ctor, opts) {
+	const existing = types.get(ctor.typeName);
+	if (existing && existing !== ctor && !opts?.replace) throw new IncantoError("DUPLICATE_NODE_TYPE", `Node type '${ctor.typeName}' is already registered by a different class. Replacing an implementation (e.g. under hot reload) needs registerNode(ctor, { replace: true }).`, { nodeType: ctor.typeName });
+	for (const [key, def] of Object.entries(ctor.props ?? {})) if (def.kinds && !def.kinds.includes(jsonKind(def.default))) throw new IncantoError("PROP_TYPE_MISMATCH", `Prop '${ctor.typeName}.${key}' declares kinds [${def.kinds.join(", ")}], which do not include its own default's kind (${jsonKind(def.default)}). The default has to be writable in a scene.`, {
+		prop: key,
+		nodeType: ctor.typeName
+	});
+	types.set(ctor.typeName, ctor);
+}
+function getNodeType(typeName) {
+	const ctor = types.get(typeName);
+	if (!ctor) {
+		const registered = [...types.keys()];
+		throw new IncantoError("UNKNOWN_NODE_TYPE", `Unknown node type '${typeName}'.${didYouMean(typeName, registered)} Registered types: [${registered.join(", ")}].` + missingRegistrarHint(typeName), {
+			nodeType: typeName,
+			validOptions: registered
+		});
+	}
+	return ctor;
+}
+/**
+* "Unknown node type 'Node2D'" next to a list with no 2D types in it is the
+* most confusing error this engine can produce: the type is not misspelled and
+* not missing — a REGISTRAR was never called. Say which one.
+*
+* The case that produced this: the multiplayer boot registers `registerNodesNet()`
+* and loads a 2D scene, which dies on its own root node.
+*/
+function missingRegistrarHint(typeName) {
+	const suffix = typeName.endsWith("2D") ? "2D" : typeName.endsWith("3D") ? "3D" : "";
+	if (!suffix || types.has(`Node${suffix}`)) return "";
+	const dim = suffix.toLowerCase();
+	return ` '${typeName}' is a ${dim} node and no ${dim} type is registered: call registerNodes${suffix}() (from 'incanto/${dim}') before loading the scene — createGame${suffix}() does it for you. Registrars compose: a multiplayer game calls registerNodes${suffix}() AND registerNodesNet().`;
+}
+function registeredTypes() {
+	return [...types.keys()];
+}
+/** Test isolation helper. */
+function clearRegistry() {
+	types.clear();
+}
+/**
+* Effective prop schema for a type: own static `props` merged over every
+* ancestor's (subclass keys win).
+*/
+function getNodeSchema(typeName) {
+	return mergeStaticProps(getNodeType(typeName));
+}
+/** Walk a constructor's prototype chain collecting static `signals` (deduped). */
+function mergeStaticSignals(ctor) {
+	const out = [];
+	let current = ctor;
+	while (current) {
+		if (Object.hasOwn(current, "signals") && current.signals) out.unshift(...current.signals);
+		const parent = Object.getPrototypeOf(current);
+		current = typeof parent === "function" ? parent : null;
+	}
+	return [...new Set(out)];
+}
+/** Every signal a registered type declares (its own + inherited). */
+function getNodeSignals(typeName) {
+	return mergeStaticSignals(getNodeType(typeName));
+}
+/** Walk a constructor's prototype chain merging static `props` (subclass wins). */
+function mergeStaticProps(ctor) {
+	const chain = [];
+	let current = ctor;
+	while (current) {
+		if (Object.hasOwn(current, "props") && current.props) chain.unshift(current.props);
+		const parent = Object.getPrototypeOf(current);
+		current = typeof parent === "function" ? parent : null;
+	}
+	return Object.assign({}, ...chain);
+}
+/** Walk a constructor's prototype chain merging static `propAliases` (legacy
+* prop key → its current canonical key; subclass wins). Lets a renamed prop keep
+* loading old scenes (e.g. 2D `zIndex` → `renderOrder`) without a format bump. */
+function mergeStaticAliases(ctor) {
+	const chain = [];
+	let current = ctor;
+	while (current) {
+		if (Object.hasOwn(current, "propAliases") && current.propAliases) chain.unshift(current.propAliases);
+		const parent = Object.getPrototypeOf(current);
+		current = typeof parent === "function" ? parent : null;
+	}
+	return Object.assign({}, ...chain);
+}
+/**
+* Assign schema defaults (cloned) then the given props onto a target,
+* hard-validating every key and JSON kind. Shared by nodes and behaviors.
+* `aliases` maps legacy keys onto current ones (back-compat for renamed props).
+*/
+function applySchemaProps(target, schema, props, label, aliases = {}, extraOptions = {}) {
+	for (const [key, def] of Object.entries(schema)) target[key] = jsonClone(def.default);
+	if (props) applyGivenProps(target, schema, props, label, aliases, extraOptions);
+	requireNonEmpty(target, schema, label);
+}
+function applyGivenProps(target, schema, props, label, aliases, extraOptions) {
+	for (const [rawKey, value] of Object.entries(props)) {
+		const key = schema[rawKey] ? rawKey : aliases[rawKey] ?? rawKey;
+		const def = schema[key];
+		if (!def) {
+			const valid = Object.keys(schema);
+			throw new IncantoError("UNKNOWN_PROP", `Unknown prop '${rawKey}' on '${label}'.${didYouMean(rawKey, valid)} Valid props: [${valid.join(", ")}].`, {
+				prop: rawKey,
+				nodeType: label,
+				validOptions: valid
+			});
+		}
+		const extra = extraOptions[key];
+		const options = def.options && extra && extra.length > 0 ? [...def.options, ...extra] : def.options;
+		validatePropValue(value, def.default, `${label}.${key}`, options, def.kinds);
+		if (def.range && jsonKind(value) === jsonKind(def.default)) validatePropRange(value, `${label}.${key}`, def.range);
+		target[key] = jsonClone(value);
+	}
+}
+function requireNonEmpty(target, schema, label) {
+	for (const [key, def] of Object.entries(schema)) {
+		if (!def.required) continue;
+		if (!isEmptyValue(target[key])) continue;
+		throw new IncantoError("PROP_TYPE_MISMATCH", `'${label}' needs a "${key}" — it is empty.`, {
+			prop: key,
+			nodeType: label
+		});
+	}
+}
+/**
+* "Not a configuration" — what `required` refuses.
+*
+* The first cut only knew about `''`, which is what the two props that
+* introduced the flag hold. Three of the ones declared since default to an
+* ARRAY — `MoveTo.to`, `Patrol.points`, `WaveSpawner.waves` — and for those the
+* flag was inert: a `MoveTo` with no `to` loaded clean and moved nowhere, which
+* is exactly the failure the flag was added to stop. Found by running the
+* shipped package as a consumer instead of trusting the declaration.
+*/
+function isEmptyValue(value) {
+	if (value === "" || value === void 0 || value === null) return true;
+	if (Array.isArray(value)) return value.length === 0;
+	if (typeof value === "object") return Object.keys(value).length === 0;
+	return false;
+}
+/**
+* Instantiate a registered type, assign schema defaults (cloned), then the
+* given props — validating every key and its JSON kind against the default.
+*/
+function createNode(typeName, props, extraOptions) {
+	const ctor = getNodeType(typeName);
+	const node = new ctor();
+	applySchemaProps(node, getNodeSchema(typeName), props, typeName, mergeStaticAliases(ctor), extraOptions);
+	return node;
+}
+//#endregion
+//#region src/core/touch.ts
+/** Drags inside this fraction of the radius read as neutral. */
+const DEADZONE = .08;
+/**
+* Pure joystick math: drag offset (px) → normalized direction, deadzoned at
+* the center and clamped to unit length at the rim.
+*/
+function joystickVector(dx, dy, radius) {
+	let x = dx / radius;
+	let y = dy / radius;
+	const len = Math.hypot(x, y);
+	if (len < DEADZONE) return {
+		x: 0,
+		y: 0
+	};
+	if (len > 1) {
+		x /= len;
+		y /= len;
+	}
+	return {
+		x,
+		y
+	};
+}
+/**
+* On-screen touch controls driven by the scene's own input map: every action
+* declared with `"touch": "joystick"` gets a left-side virtual stick feeding
+* `setActionVector`, every `"touch": "button"` a right-side button feeding
+* `pressAction`/`releaseAction`. The game never knows the difference between
+* touch and keyboard — both arrive as actions.
+*
+* `attachTouchControls(engine, container)` shows them automatically on
+* coarse-pointer devices ('auto' in createGame); `force` shows them anywhere.
+* The container should be `position: relative/absolute` over the canvas.
+*/
+function attachTouchControls(engine, container, opts = {}) {
+	const controls = engine.input.touchControls();
+	if (controls.length === 0) return null;
+	if (!opts.force && !isCoarsePointer()) return null;
+	const doc = opts.doc ?? (typeof document !== "undefined" ? document : null);
+	if (!doc) return null;
+	if (typeof container.appendChild !== "function") return null;
+	return new TouchControls(engine, container, controls, doc);
+}
+function isCoarsePointer() {
+	return typeof matchMedia !== "undefined" && matchMedia("(pointer: coarse)").matches;
+}
+/**
+* Retarget moves and ups back to this element — and never at the cost of the press.
+*
+* `setPointerCapture` THROWS `NotFoundError` for a pointerId that is not
+* currently active, and `?.` guards a missing method rather than a throwing
+* one. It ran BEFORE `feed()` — the try/catch that would have absorbed it was
+* the very next line — so a synthetic `pointerdown` lost its press entirely.
+*
+* Real fingers are unaffected: a real touch is an active pointer. What it broke
+* was every `dispatchEvent`-based driver, which is how a touch game is tested
+* at all. And the instrument agreed with the bug: happy-dom's
+* `setPointerCapture` throws nothing, so a harness printed `ALL CHECKS PASSED`
+* while Chrome lost the same game. Controlled A/B, one page, one autopilot, one
+* variable:
+*
+*   capture throws   gameover @6.48s, 7/9 shards, 19 uncaught errors
+*   capture guarded  WON      @6.30s, 9/9 shards,  0 errors
+*
+* Worse than losing the press: `activePointer` is assigned first, so the
+* matching `pointerup` still fired `releaseAction` — a release the state
+* machine never earned.
+*/
+function capturePointer(el, pointerId) {
+	try {
+		el.setPointerCapture?.(pointerId);
+	} catch {}
+}
+var TouchControls = class {
+	elements = [];
+	detachers = [];
+	constructor(engine, container, controls, doc) {
+		let buttonIndex = 0;
+		let joystickIndex = 0;
+		for (const control of controls) if (control.kind === "joystick") {
+			this.buildJoystick(engine, container, control.action, joystickIndex, doc);
+			joystickIndex += 1;
+		} else {
+			this.buildButton(engine, container, control.action, buttonIndex, doc);
+			buttonIndex += 1;
+		}
+	}
+	dispose() {
+		for (const detach of this.detachers) detach();
+		for (const el of this.elements) el.remove();
+		this.elements.length = 0;
+		this.detachers.length = 0;
+	}
+	buildJoystick(engine, container, action, index, doc) {
+		const base = doc.createElement("div");
+		style(base, {
+			position: "absolute",
+			left: `calc(${24 + index * 140}px + env(safe-area-inset-left))`,
+			bottom: "calc(24px + env(safe-area-inset-bottom))",
+			width: "120px",
+			height: "120px",
+			borderRadius: "50%",
+			background: "rgba(255,255,255,0.10)",
+			border: "2px solid rgba(255,255,255,0.25)",
+			touchAction: "none",
+			pointerEvents: "auto",
+			zIndex: "20"
+		});
+		const knob = doc.createElement("div");
+		style(knob, {
+			position: "absolute",
+			left: "50%",
+			top: "50%",
+			width: "48px",
+			height: "48px",
+			marginLeft: "-24px",
+			marginTop: "-24px",
+			borderRadius: "50%",
+			background: "rgba(255,255,255,0.35)",
+			pointerEvents: "none"
+		});
+		base.appendChild(knob);
+		container.appendChild(base);
+		this.elements.push(base);
+		let activePointer = null;
+		let cx = 0;
+		let cy = 0;
+		let radius = 60;
+		const apply = (clientX, clientY) => {
+			const v = joystickVector(clientX - cx, clientY - cy, radius);
+			feed(() => engine.input.setActionVector(action, v.x, v.y));
+			knob.style.transform = `translate(${v.x * radius * .6}px, ${v.y * radius * .6}px)`;
+		};
+		const onDown = (e) => {
+			activePointer = e.pointerId;
+			const rect = base.getBoundingClientRect();
+			cx = rect.left + rect.width / 2;
+			cy = rect.top + rect.height / 2;
+			radius = rect.width / 2;
+			capturePointer(base, e.pointerId);
+			apply(e.clientX, e.clientY);
+		};
+		const onMove = (e) => {
+			if (e.pointerId === activePointer) apply(e.clientX, e.clientY);
+		};
+		const release = (e) => {
+			if (e.pointerId !== activePointer) return;
+			activePointer = null;
+			knob.style.transform = "";
+			feed(() => engine.input.setActionVector(action, 0, 0));
+		};
+		base.addEventListener("pointerdown", onDown);
+		base.addEventListener("pointermove", onMove);
+		base.addEventListener("pointerup", release);
+		base.addEventListener("pointercancel", release);
+		this.detachers.push(() => {
+			base.removeEventListener("pointerdown", onDown);
+			base.removeEventListener("pointermove", onMove);
+			base.removeEventListener("pointerup", release);
+			base.removeEventListener("pointercancel", release);
+		});
+	}
+	buildButton(engine, container, action, index, doc) {
+		const button = doc.createElement("div");
+		button.textContent = action;
+		style(button, {
+			position: "absolute",
+			right: "calc(24px + env(safe-area-inset-right))",
+			bottom: `calc(${24 + index * 80}px + env(safe-area-inset-bottom))`,
+			width: "64px",
+			height: "64px",
+			borderRadius: "50%",
+			background: "rgba(255,255,255,0.12)",
+			border: "2px solid rgba(255,255,255,0.3)",
+			color: "rgba(255,255,255,0.85)",
+			font: "600 12px system-ui, sans-serif",
+			display: "flex",
+			alignItems: "center",
+			justifyContent: "center",
+			userSelect: "none",
+			touchAction: "none",
+			pointerEvents: "auto",
+			zIndex: "20"
+		});
+		container.appendChild(button);
+		this.elements.push(button);
+		let activePointer = null;
+		const onDown = (e) => {
+			activePointer = e.pointerId;
+			feed(() => engine.input.pressAction(action));
+			capturePointer(button, e.pointerId);
+			button.style.background = "rgba(255,255,255,0.3)";
+		};
+		const release = (e) => {
+			if (e.pointerId !== activePointer) return;
+			activePointer = null;
+			feed(() => engine.input.releaseAction(action));
+			button.style.background = "rgba(255,255,255,0.12)";
+		};
+		button.addEventListener("pointerdown", onDown);
+		button.addEventListener("pointerup", release);
+		button.addEventListener("pointercancel", release);
+		this.detachers.push(() => {
+			button.removeEventListener("pointerdown", onDown);
+			button.removeEventListener("pointerup", release);
+			button.removeEventListener("pointercancel", release);
+		});
+	}
+};
+/**
+* A gesture can outlive its action by one frame (scene swap redeclares the
+* input map while a finger is down; createGame rebuilds the overlay right
+* after) — swallow only that race, never normal errors.
+*/
+function feed(fn) {
+	try {
+		fn();
+	} catch {}
+}
+function style(el, rules) {
+	for (const [key, value] of Object.entries(rules)) el.style[key] = value;
+}
+//#endregion
+export { applySchemaProps as a, getNodeSchema as c, mergeStaticProps as d, mergeStaticSignals as f, nearestName as g, didYouMean as h, joystickVector as i, getNodeSignals as l, registeredTypes as m, attachTouchControls as n, clearRegistry as o, registerNode as p, capturePointer as r, createNode as s, TouchControls as t, getNodeType as u };

package/dist/vite.d.ts

@@ -76,6 +76,24 @@ interface FrameEndpointOptions {
 }
 declare function serveFrameEndpoints(host: FrameHost, version: string, opts?: FrameEndpointOptions): void;
 //#endregion
+//#region src/vite/options.d.ts
+/**
+* A plugin option the plugin does not know is a hard error, like every other
+* key this engine reads.
+*
+* Scene props have had `UNKNOWN_PROP` — "Valid props: […]" — since the first
+* milestone. A vite plugin's options had nothing: `incantoScenes({
+* strictBehavior: true })` type-checked green, built green and did NOTHING,
+* because the scaffolded `tsconfig.json` never pointed the compiler at
+* `vite.config.ts` in the first place.
+*
+* That `include` is fixed too, but it cannot be the whole answer. TypeScript's
+* excess-property check only fires on a FRESH object literal — hoist the
+* options into a `const` and it passes again — and a `vite.config.js` is never
+* type-checked at all. This is the half that holds either way.
+*/
+declare function onlyKnownOptions(plugin: string, opts: object, known: readonly string[]): void;
+//#endregion
 //#region src/vite/static-inspect.d.ts
 interface StaticInspectHost extends FrameHost {
   /** Handle `/__incanto/pull` and `/__incanto/push`; returns false if not ours. */
@@ -92,41 +110,6 @@ interface StaticInspectHost extends FrameHost {
 declare function createStaticInspectHost(root: string): StaticInspectHost;
 //#endregion
 //#region src/vite/trim.d.ts
-/**
-* Leave out of the BUILD what this game can never run.
-*
-* A 2D game's `dist/` contains the 3D adapter and rapier3d. Measured on the
-* shipped `platformer-2d` flagship:
-*
-* ```
-* 2236503  assets/rapier-*.js    # rapier3d
-* 1692150  assets/rapier-*.js    # rapier2d — the one it uses
-*  471186  assets/3d-*.js        # the 3D adapter
-* ─────────
-* 5942650  total  →  45.6% of it can never execute
-* ```
-*
-* Nothing is wrong at RUNTIME: the chunks are lazy and never requested. This is
-* deploy weight — a CDN, a jam upload, an agent8 zip — and the only path that
-* drags them in is the live game⇄editor switch: `createGame*` imports
-* `incanto/editor`, and the editor imports `incanto/3d` so it can offer 3D node
-* types.
-*
-* `editor: false` on `createGame*` is a RUNTIME option and cannot remove bytes
-* from a bundle; it changed the artifact by 10 bytes while the docs said it
-* "opts out". A build-time decision needs a build-time lever, which is this.
-*
-* ```ts
-* import { incantoScenes, incantoTrim } from 'incanto/vite';
-* export default defineConfig({
-*   plugins: [incantoScenes(), incantoTrim({ editor: false })],
-* });
-* ```
-*
-* Build only — the dev server keeps the editor, so `☰ debug ▸ ✎ edit this
-* scene` works while you are building the game and is simply absent from what
-* you ship.
-*/
 interface IncantoTrimOptions {
   /**
   * Keep the in-game scene editor in the build. Default `false` when this
@@ -267,7 +250,7 @@ interface LibraryReq {
 interface LibraryRes {
   statusCode: number;
   setHeader(name: string, value: string): void;
-  end(body?: string): void;
+  end(body?: string | Uint8Array): void;
 }
 interface IncantoLibraryOptions {
   /**
@@ -327,4 +310,4 @@ declare function serveDeviceAuth(req: LibraryReq, res: LibraryRes, opts?: Incant
 /** @internal Exported for tests — the whole request/response behaviour. */
 declare function serveLibrary(req: LibraryReq, res: LibraryRes, opts?: IncantoLibraryOptions, doFetch?: typeof fetch): Promise<void>;
 //#endregion
-export { type FrameHost, type FrameReq, type FrameRes, IncantoLibraryOptions, IncantoScenesOptions, type IncantoTrimOptions, ProjectFileEntry, type StaticInspectHost, createStaticInspectHost, discoverScenes, incantoLibrary, incantoScenes, incantoTrim, listeningPorts, maskToken, parseProcNetTcp, resolveSceneFile, sceneFacts, serveDeviceAuth, serveFrameEndpoints, serveLibrary, serveSceneFile, serveSceneList, serveTokenStatus };
+export { type FrameHost, type FrameReq, type FrameRes, IncantoLibraryOptions, IncantoScenesOptions, type IncantoTrimOptions, ProjectFileEntry, type StaticInspectHost, createStaticInspectHost, discoverScenes, incantoLibrary, incantoScenes, incantoTrim, listeningPorts, maskToken, onlyKnownOptions, parseProcNetTcp, resolveSceneFile, sceneFacts, serveDeviceAuth, serveFrameEndpoints, serveLibrary, serveSceneFile, serveSceneList, serveTokenStatus };