incanto 0.1.0

package/dist/test.d.ts

@@ -0,0 +1,158 @@
+import { c as JsonValue, i as SceneJson } from "./schema-CcoWb32N.js";
+import { O as LogEntry, T as Node, n as BehaviorCtor, v as Engine, w as Scene } from "./behavior-BAQq7HGM.js";
+import { t as LoadSceneOptions } from "./loader-Mo0KghCv.js";
+import { t as IncantoError } from "./errors-BMFaY68Q.js";
+
+//#region src/test/index.d.ts
+/**
+* Register every built-in node set (core + 2d + 3d + net) AND the built-in
+* gameplay behaviors — so headless verification (validateScene/runScript) of a
+* game built on `incanto/gameplay` works without re-passing them. Idempotent;
+* a user behavior passed via `behaviors` (registered after) still wins.
+*/
+declare function registerAllNodes(): void;
+interface NodeCapture {
+  /** Absolute path ('/Root/Player') — stable, grep-able. */
+  path: string;
+  type: string;
+  uid?: string;
+  groups?: string[];
+  tags?: Record<string, JsonValue>;
+  /** The attached behavior's name, if any. */
+  script?: string;
+  /** CURRENT value of every schema prop (not delta — captures runtime state). */
+  props: Record<string, JsonValue>;
+}
+interface SceneCapture {
+  name: string;
+  dimension?: "2d" | "3d";
+  nodes: NodeCapture[];
+}
+/** Snapshot the live tree: every node, every schema prop's current value. */
+declare function captureScene(scene: Scene): SceneCapture;
+/**
+* Render a capture as one grep-able line per node, showing only NON-DEFAULT
+* props — the same delta discipline as scene JSON, so the interesting state
+* stands out.
+*/
+declare function describeCapture(capture: SceneCapture): string;
+interface ValidateSceneOptions {
+  /** Real behavior classes to register (hot-replacing) before loading. */
+  behaviors?: Record<string, BehaviorCtor>;
+  /** Hard-fail on unregistered behaviors instead of stubbing them. */
+  strictBehaviors?: boolean;
+  resolveScene?: LoadSceneOptions["resolveScene"];
+}
+interface ValidationResult {
+  ok: boolean;
+  /** The hard load error, when ok is false — `details` is machine-readable. */
+  error?: IncantoError;
+}
+/**
+* Run every hard load-time check headlessly. Unregistered behaviors are
+* stubbed by default (structure-only validation, no TypeScript needed) —
+* pass the real classes via `behaviors` to validate script props too.
+*/
+declare function validateScene(json: unknown, opts?: ValidateSceneOptions): ValidationResult;
+interface RunContext {
+  engine: Engine;
+  scene: Scene;
+  /** Simulated time of the current step, in ms. */
+  timeMs: number;
+  /** Resolve a node path relative to the scene root. */
+  getNode(path: string): Node;
+  /** Snapshot the scene right now. */
+  capture(): SceneCapture;
+}
+interface ScriptStep {
+  /** Simulated time at which this step applies (before that frame's tick). */
+  atMs: number;
+  /** Press a button action (held until `release`). */
+  press?: string;
+  /** Release a previously pressed button action. */
+  release?: string;
+  /** Set a vector2 action: [action, x, y]. (0,0) clears. */
+  vector?: [string, number, number];
+  /** Raw key-code fallback: [code, isDown]. */
+  key?: [string, boolean];
+  /** Arbitrary imperative hook. */
+  do?: (ctx: RunContext) => void;
+  /** Inline check: return false or throw to record a failure (run continues). */
+  assert?: (ctx: RunContext) => boolean | undefined;
+  /** Names this step in failure reports. */
+  label?: string;
+}
+interface RunFailure {
+  atMs: number;
+  label?: string;
+  message: string;
+}
+interface RunScriptOptions {
+  /** Total simulated duration in ms. */
+  durationMs: number;
+  steps?: ScriptStep[];
+  /** Real behavior classes (hot-replacing). Unregistered ones still hard-fail. */
+  behaviors?: Record<string, BehaviorCtor>;
+  /** Fixed-update rate (default 60). */
+  fixedHz?: number;
+  /** Seed for engine.rng — same seed, same run. */
+  seed?: number;
+  /** Physics: 'auto' (default — by scene dimension), '2d', '3d', or false. */
+  physics?: "2d" | "3d" | "auto" | false;
+  /** Collect a snapshot every N simulated ms. */
+  snapshotEveryMs?: number;
+  resolveScene?: LoadSceneOptions["resolveScene"];
+}
+interface RunResult {
+  /** True when no step assertion failed. */
+  ok: boolean;
+  failures: RunFailure[];
+  snapshots: Array<{
+    atMs: number;
+    capture: SceneCapture;
+  }>;
+  /** Everything the game logged via engine.log / this.log. */
+  logs: readonly LogEntry[];
+  finalCapture: SceneCapture;
+  /** Human/agent-readable run report. */
+  describe(): string;
+}
+/**
+* Load a scene and play it headlessly at a fixed timestep, driving input by
+* ACTION intent. This is the e2e loop without a browser: script → simulate →
+* snapshot → assert.
+*/
+declare function runScript(json: unknown, opts: RunScriptOptions): Promise<RunResult>;
+interface PlaySessionOptions {
+  behaviors?: Record<string, BehaviorCtor>;
+  /** Stub unregistered behaviors (structure-only play — the CLI default without --behaviors). */
+  stubMissingBehaviors?: boolean;
+  seed?: number;
+  fixedHz?: number;
+  physics?: "2d" | "3d" | "auto" | false;
+  resolveScene?: LoadSceneOptions["resolveScene"];
+}
+interface PlaySession {
+  engine: Engine;
+  scene: Scene;
+  /** Simulated time so far, ms. */
+  readonly timeMs: number;
+  /** Advance the simulation by ~ms (whole fixed steps). */
+  step(ms: number): void;
+  /** The CURRENT runtime state in scene-JSON format — loadable, diffable. */
+  capture(): SceneJson;
+  /** Grep-able one-line-per-node text view of the current state. */
+  describe(): string;
+  /** Engine log entries since the last drain. */
+  drainLogs(): LogEntry[];
+  dispose(): void;
+}
+/**
+* The headless play loop behind `incanto-play`: load → feed inputs by intent
+* (`session.engine.input.pressAction(...)`) → `step(ms)` → `capture()` the
+* state AS A SCENE FILE. What a screenshot is to humans, the capture is to
+* agents: complete, structured, and in the exact format they already read.
+*/
+declare function createPlaySession(json: unknown, opts?: PlaySessionOptions): Promise<PlaySession>;
+//#endregion
+export { NodeCapture, PlaySession, PlaySessionOptions, RunContext, RunFailure, RunResult, RunScriptOptions, SceneCapture, ScriptStep, ValidateSceneOptions, ValidationResult, captureScene, createPlaySession, describeCapture, registerAllNodes, runScript, validateScene };

package/dist/test.js

@@ -0,0 +1,275 @@
+import { _ as registerBehavior, n as loadScene } from "./loader-CGs_G-r0.js";
+import { a as Engine } from "./particle-sim-DYuSUxvK.js";
+import { t as IncantoError } from "./errors-BpWbnbb_.js";
+import { n as jsonEquals, t as jsonClone } from "./json-BLk7H2Qa.js";
+import { i as getNodeSchema, s as mergeStaticProps } from "./registry-BVJ2HbCn.js";
+import { n as registerGameplayBehaviors } from "./gameplay-Ccruc3Wd.js";
+import { t as registerNodes2D } from "./register-DPEV9_9t.js";
+import { t as registerNodes3D } from "./register-CNlYAS1_.js";
+import { t as registerNodesNet } from "./register-Dasmnurl.js";
+//#region src/test/index.ts
+/**
+* incanto/test — the browserless verification harness.
+*
+* The agent loop is "author → VERIFY → fix", and production environments
+* (e.g. the agent8 VM) have no browser. This module makes the scene state
+* itself the screenshot:
+*
+* - `validateScene(json)`  — every hard load error, without a browser
+* - `runScript(json, ...)` — scripted play by ACTION intent at a fixed
+*   timestep, with inline assertions and periodic snapshots
+* - `captureScene(scene)` / `describeCapture(capture)` — a structural,
+*   grep-able "text screenshot" of the live tree
+*
+* Deterministic by construction: fixed timestep, seeded `engine.rng`,
+* no requestAnimationFrame.
+*/
+/**
+* Register every built-in node set (core + 2d + 3d + net) AND the built-in
+* gameplay behaviors — so headless verification (validateScene/runScript) of a
+* game built on `incanto/gameplay` works without re-passing them. Idempotent;
+* a user behavior passed via `behaviors` (registered after) still wins.
+*/
+function registerAllNodes() {
+	registerNodes2D();
+	registerNodes3D();
+	registerNodesNet();
+	registerGameplayBehaviors();
+}
+/** Snapshot the live tree: every node, every schema prop's current value. */
+function captureScene(scene) {
+	const nodes = [];
+	const walk = (node) => {
+		const ctor = node.constructor;
+		const schema = mergeStaticProps(ctor);
+		const props = {};
+		for (const key of Object.keys(schema)) props[key] = jsonClone(node[key]);
+		const capture = {
+			path: node.getPath(),
+			type: ctor.typeName,
+			props
+		};
+		if (node.uid) capture.uid = node.uid;
+		if (node.groups.size > 0) capture.groups = [...node.groups];
+		if (Object.keys(node.tags).length > 0) capture.tags = jsonClone(node.tags);
+		if (typeof node.script?.name === "string") capture.script = node.script.name;
+		nodes.push(capture);
+		for (const child of node.children) walk(child);
+	};
+	walk(scene.root);
+	const out = {
+		name: scene.name,
+		nodes
+	};
+	if (scene.dimension) out.dimension = scene.dimension;
+	return out;
+}
+/**
+* Render a capture as one grep-able line per node, showing only NON-DEFAULT
+* props — the same delta discipline as scene JSON, so the interesting state
+* stands out.
+*/
+function describeCapture(capture) {
+	const lines = [`scene ${capture.name}${capture.dimension ? ` (${capture.dimension})` : ""}`];
+	for (const node of capture.nodes) {
+		const schema = defaultsFor(node.type);
+		const deltas = Object.entries(node.props).filter(([key, value]) => !schema || !jsonEquals(value, schema[key]?.default ?? null)).map(([key, value]) => `${key}=${JSON.stringify(value)}`);
+		const extras = [
+			node.script ? `script=${node.script}` : "",
+			node.groups ? `groups=${node.groups.join(",")}` : "",
+			...deltas
+		].filter(Boolean);
+		lines.push(`${node.path} ${node.type}${extras.length ? ` ${extras.join(" ")}` : ""}`);
+	}
+	return lines.join("\n");
+}
+function defaultsFor(typeName) {
+	try {
+		return getNodeSchema(typeName);
+	} catch {
+		return null;
+	}
+}
+/**
+* Run every hard load-time check headlessly. Unregistered behaviors are
+* stubbed by default (structure-only validation, no TypeScript needed) —
+* pass the real classes via `behaviors` to validate script props too.
+*/
+function validateScene(json, opts = {}) {
+	registerAllNodes();
+	for (const [name, ctor] of Object.entries(opts.behaviors ?? {})) registerBehavior(name, ctor, { replace: true });
+	try {
+		loadScene(json, {
+			resolveScene: opts.resolveScene,
+			stubMissingBehaviors: !opts.strictBehaviors
+		}).root.free();
+		return { ok: true };
+	} catch (e) {
+		if (e instanceof IncantoError) return {
+			ok: false,
+			error: e
+		};
+		throw e;
+	}
+}
+/**
+* Load a scene and play it headlessly at a fixed timestep, driving input by
+* ACTION intent. This is the e2e loop without a browser: script → simulate →
+* snapshot → assert.
+*/
+async function runScript(json, opts) {
+	registerAllNodes();
+	for (const [name, ctor] of Object.entries(opts.behaviors ?? {})) registerBehavior(name, ctor, { replace: true });
+	const engine = new Engine({
+		seed: opts.seed,
+		fixedHz: opts.fixedHz,
+		scheduler: () => () => {}
+	});
+	const scene = loadScene(structuredClone(json), { resolveScene: opts.resolveScene });
+	engine.setScene(scene);
+	const physics = opts.physics ?? "auto";
+	if (physics === "2d" || physics === "auto" && scene.dimension === "2d") {
+		const { enablePhysics2D } = await import("./physics-2d-KuMWPTf6.js").then((n) => n.r);
+		await enablePhysics2D(engine);
+	} else if (physics === "3d" || physics === "auto" && scene.dimension === "3d") {
+		const { enablePhysics3D } = await import("./physics-3d-Dl67vOLT.js").then((n) => n.r);
+		await enablePhysics3D(engine);
+	}
+	const failures = [];
+	const snapshots = [];
+	const ctx = {
+		engine,
+		scene,
+		timeMs: 0,
+		getNode: (path) => scene.root.getNode(path),
+		capture: () => captureScene(scene)
+	};
+	const applyStep = (step) => {
+		if (step.press) engine.input.pressAction(step.press);
+		if (step.release) engine.input.releaseAction(step.release);
+		if (step.vector) engine.input.setActionVector(...step.vector);
+		if (step.key) engine.input.handleKey(step.key[0], step.key[1]);
+		step.do?.(ctx);
+		if (step.assert) try {
+			if (step.assert(ctx) === false) failures.push({
+				atMs: step.atMs,
+				label: step.label,
+				message: "assert returned false"
+			});
+		} catch (e) {
+			failures.push({
+				atMs: step.atMs,
+				label: step.label,
+				message: e instanceof Error ? e.message : String(e)
+			});
+		}
+	};
+	const stepMs = 1e3 / (opts.fixedHz ?? 60);
+	const totalTicks = Math.round(opts.durationMs / stepMs);
+	const steps = [...opts.steps ?? []].sort((a, b) => a.atMs - b.atMs);
+	let stepIndex = 0;
+	let nextSnapshot = opts.snapshotEveryMs ?? Number.POSITIVE_INFINITY;
+	for (let i = 1; i <= totalTicks; i++) {
+		const t = i * stepMs;
+		ctx.timeMs = t;
+		while (stepIndex < steps.length && steps[stepIndex].atMs <= t) {
+			applyStep(steps[stepIndex]);
+			stepIndex += 1;
+		}
+		engine.step();
+		if (t >= nextSnapshot - 1e-6) {
+			snapshots.push({
+				atMs: Math.round(t),
+				capture: captureScene(scene)
+			});
+			nextSnapshot += opts.snapshotEveryMs;
+		}
+	}
+	for (; stepIndex < steps.length; stepIndex++) {
+		const missed = steps[stepIndex];
+		failures.push({
+			atMs: missed.atMs,
+			label: missed.label,
+			message: `step never executed — atMs ${missed.atMs} is beyond the ${opts.durationMs}ms run`
+		});
+	}
+	const finalCapture = captureScene(scene);
+	const logs = [...engine.log.entries()];
+	engine.dispose();
+	const ok = failures.length === 0;
+	return {
+		ok,
+		failures,
+		snapshots,
+		logs,
+		finalCapture,
+		describe: () => {
+			return [
+				`run ${ok ? "OK" : "FAILED"} — ${opts.durationMs}ms simulated, ${failures.length} failure(s), ${logs.length} log(s)`,
+				...failures.map((f) => `  ✗ at ${f.atMs}ms${f.label ? ` [${f.label}]` : ""}: ${f.message}`),
+				describeCapture(finalCapture)
+			].join("\n");
+		}
+	};
+}
+/**
+* The headless play loop behind `incanto-play`: load → feed inputs by intent
+* (`session.engine.input.pressAction(...)`) → `step(ms)` → `capture()` the
+* state AS A SCENE FILE. What a screenshot is to humans, the capture is to
+* agents: complete, structured, and in the exact format they already read.
+*/
+async function createPlaySession(json, opts = {}) {
+	registerAllNodes();
+	for (const [name, ctor] of Object.entries(opts.behaviors ?? {})) registerBehavior(name, ctor, { replace: true });
+	const engine = new Engine({
+		seed: opts.seed,
+		fixedHz: opts.fixedHz,
+		scheduler: () => () => {}
+	});
+	const scene = loadScene(structuredClone(json), {
+		resolveScene: opts.resolveScene,
+		stubMissingBehaviors: opts.stubMissingBehaviors,
+		engine
+	});
+	engine.setScene(scene);
+	const physics = opts.physics ?? "auto";
+	if (physics === "2d" || physics === "auto" && scene.dimension === "2d") {
+		const { enablePhysics2D } = await import("./physics-2d-KuMWPTf6.js").then((n) => n.r);
+		await enablePhysics2D(engine);
+	} else if (physics === "3d" || physics === "auto" && scene.dimension === "3d") {
+		const { enablePhysics3D } = await import("./physics-3d-Dl67vOLT.js").then((n) => n.r);
+		await enablePhysics3D(engine);
+	}
+	const stepMs = 1e3 / (opts.fixedHz ?? 60);
+	let timeMs = 0;
+	let logCursor = 0;
+	return {
+		engine,
+		scene,
+		get timeMs() {
+			return timeMs;
+		},
+		step(ms) {
+			const ticks = Math.max(1, Math.round(ms / stepMs));
+			for (let i = 0; i < ticks; i++) engine.step();
+			timeMs += ticks * stepMs;
+		},
+		capture() {
+			return scene.toJSON();
+		},
+		describe() {
+			return describeCapture(captureScene(scene));
+		},
+		drainLogs() {
+			const all = engine.log.entries();
+			const fresh = all.filter((e) => e.seq > logCursor);
+			if (all.length > 0) logCursor = all[all.length - 1].seq;
+			return [...fresh];
+		},
+		dispose() {
+			engine.dispose();
+		}
+	};
+}
+//#endregion
+export { captureScene, createPlaySession, describeCapture, registerAllNodes, runScript, validateScene };

package/dist/touch-031PxtCR.js

@@ -0,0 +1,208 @@
+//#region src/core/rendering-options.ts
+function resolveRendering(environment, fallback, devicePixelRatio, explicit) {
+	const rendering = environment?.rendering ?? {};
+	const scenePixelRatio = rendering.pixelRatio === "device" ? devicePixelRatio : rendering.pixelRatio;
+	return {
+		antialias: explicit?.antialias ?? rendering.antialias ?? fallback.antialias,
+		pixelRatio: explicit?.pixelRatio ?? scenePixelRatio ?? fallback.pixelRatio
+	};
+}
+//#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;
+}
+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: `${24 + index * 140}px`,
+			bottom: "24px",
+			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;
+			base.setPointerCapture?.(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: "24px",
+			bottom: `${24 + index * 80}px`,
+			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;
+			button.setPointerCapture?.(e.pointerId);
+			feed(() => engine.input.pressAction(action));
+			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 { resolveRendering as i, attachTouchControls as n, joystickVector as r, TouchControls as t };

package/dist/vite.d.ts

@@ -0,0 +1,26 @@
+//#region src/vite/index.d.ts
+interface HotUpdateContext {
+  file: string;
+  read(): Promise<string>;
+  server: {
+    ws: {
+      send(payload: unknown): void;
+    };
+    config?: {
+      logger?: {
+        error(msg: string): void;
+      };
+    };
+  };
+  modules?: unknown[];
+}
+interface IncantoScenesOptions {
+  /** Hard-fail on unregistered behaviors too (default: structure-only). */
+  strictBehaviors?: boolean;
+}
+declare function incantoScenes(opts?: IncantoScenesOptions): {
+  name: string;
+  handleHotUpdate(ctx: HotUpdateContext): Promise<undefined | never[]>;
+};
+//#endregion
+export { IncantoScenesOptions, incantoScenes };