incanto 0.65.0 → 0.67.0

package/dist/{register-CgeR4ckF.js → register-Cs53CY7s.js}

@@ -1,8 +1,9 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { C as ORDER_GROUP_BASE, E as InputMap, O as Node, S as createSaveStore, T as resolveOrderGroups, V as Signal, b as restoreBehaviors, k as diagnose, y as captureBehaviors } from "./loader-lQDCwNag.js";
+import { C as ORDER_GROUP_BASE, E as InputMap, O as Node, S as createSaveStore, T as resolveOrderGroups, V as Signal, b as restoreBehaviors, k as diagnose, y as captureBehaviors } from "./loader-KZESOZmE.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as Rng } from "./rng-DP-SR7eg.js";
 import { l as registerNode } from "./registry-CF70EArN.js";
+import { r as capturePointer } from "./touch-DEAmqGdf.js";
 //#region src/core/audio/buses.ts
 const AUDIO_LOG_LIMIT = 200;
 var AudioBuses = class {
@@ -1339,11 +1340,29 @@ var HudLayer = class extends Node {
 			}
 		}
 	}
-	/** Focusable widgets under this layer, in tree order. */
+	/**
+	* Focusable widgets under this layer, in tree order — **on screen only**.
+	*
+	* This filtered on each widget's OWN `visible` and recursed into hidden
+	* containers anyway, so arrow-keys walked into closed panels and Enter really
+	* pressed what it found. Measured on a title screen: 23 focus stops, 21 of
+	* them under an ancestor with `visible = false`, and
+	*
+	*   gold before = 150 -> Enter on the hidden Shop/Row0/Buy -> gold 120,
+	*   screen still 'title'
+	*
+	* The layer's own visibility was not a gate either. It is now: a HUD nobody
+	* can see has no ring, and a subtree nobody can see is not walked.
+	*
+	* PUBLIC, because a game that wants to know what its ring contains could not
+	* ask — and "why is focus on that" is exactly the question this answers.
+	*/
 	focusables() {
 		const out = [];
+		if (!this.visible) return out;
 		const walk = (node) => {
-			if (node instanceof HudWidgetBase && node.focusable && node.visible) out.push(node);
+			if (node instanceof HudWidgetBase && !node.visible) return;
+			if (node instanceof HudWidgetBase && node.focusable) out.push(node);
 			for (const child of node.children) walk(child);
 		};
 		walk(this);
@@ -1513,7 +1532,7 @@ var HudWidgetBase = class extends Node {
 			el.addEventListener("pointerdown", (event) => {
 				if (!this.draggable) return;
 				event.preventDefault();
-				el.setPointerCapture?.(event.pointerId);
+				capturePointer(el, event.pointerId);
 				dragging = this;
 				draggingFrom = dropTargetFromElement(el.parentElement);
 				el.style.opacity = "0.6";
@@ -1553,10 +1572,16 @@ var HudWidgetBase = class extends Node {
 			this._mountWidget();
 			if (!this._element) return;
 		}
-		this._element.style.display = this.visible ? "" : "none";
 		this._followAnchor();
 		this._sync();
+		if (this._element.style.display !== "none") this._shownDisplay = this._element.style.display;
+		this._element.style.display = this.visible ? this._shownDisplay : "none";
 	}
+	/**
+	* The display this widget's own css asks for while shown — `grid` for a grid
+	* panel, `flex` for a row, `''` for a widget that never says.
+	*/
+	_shownDisplay = "";
 	/** Which anchor slot this widget was mounted into. */
 	mountedAnchor = null;
 	/**
@@ -2280,14 +2305,9 @@ function qualityEnvironment(tier) {
 	};
 	if (tier === "medium") return {
 		shadows: { static: true },
-		bloom: {},
 		post: null
 	};
-	return {
-		shadows: true,
-		bloom: {},
-		post: {}
-	};
+	return { shadows: true };
 }
 const QUALITY_CAPS = Object.freeze({
 	low: Object.freeze({
@@ -2393,6 +2413,33 @@ var Engine = class {
 	* and cleared on dispose; null when nothing renders (headless).
 	*/
 	picker = null;
+	/** Frames the engine has stepped — monotonic, and the pick cache's key. */
+	frameNumber = 0;
+	/** @internal frame number + answer, so N Clickables cost ONE raycast. */
+	pickCacheFrame = -1;
+	pickCacheKey = "";
+	pickCacheHit = null;
+	/**
+	* The node under (x, y), answered at most ONCE per frame per cursor position.
+	*
+	* `Clickable` asks every frame, and a board game has one per cell: 42 pads
+	* measured **420 picker calls over ten frames** — one GPU raycast per pad per
+	* frame, all answering the same question about the same pixel. At 60 fps that
+	* is ~2500 raycasts a second to find out what the cursor is on, and a 200-tile
+	* board was unusable.
+	*
+	* Cached on (frame, x, y), so a game that picks at two different points in one
+	* frame still gets two real answers.
+	*/
+	pickAt(x, y) {
+		if (!this.picker) return null;
+		const key = `${x},${y}`;
+		if (this.pickCacheFrame === this.frameNumber && this.pickCacheKey === key) return this.pickCacheHit;
+		this.pickCacheFrame = this.frameNumber;
+		this.pickCacheKey = key;
+		this.pickCacheHit = this.picker(x, y);
+		return this.pickCacheHit;
+	}
 	/** Global volume buses — `master` × `sfx`/`music` gain + `muted`. AudioPlayer
 	*  routes its volume through this; games set it for global volume/mute. */
 	audio = new AudioBuses();
@@ -2409,7 +2456,7 @@ var Engine = class {
 	* reset on reload. Reading it here costs nothing (localStorage, once) and
 	* `bindAudio` makes the volumes write themselves.
 	*/
-	settings = new Settings();
+	settings;
 	/**
 	* Translations, and the locale in force. English is the base and the default;
 	* anything a locale does not declare falls back to it silently.
@@ -2483,6 +2530,7 @@ var Engine = class {
 		this.scheduler = opts.scheduler ?? rafScheduler;
 		this.rng = new Rng(opts.seed ?? Math.random() * 4294967295 >>> 0);
 		this.maxFps = opts.maxFps ?? 0;
+		this.settings = opts.settings instanceof Settings ? opts.settings : new Settings(opts.settings?.namespace ?? "settings");
 		this.sfx._setBuses(this.audio);
 		this.music.onTrackError = (src, reason) => {
 			diagnose(this, "error", `[incanto] music '${src}' will not play — ${reason}.`);
@@ -2609,8 +2657,9 @@ var Engine = class {
 	captureState() {
 		const root = this.scene?.root;
 		if (!root) return {};
-		const { state, unaddressable } = captureBehaviors(root, this.scene?.source);
+		const { state, unaddressable, unrecordable } = captureBehaviors(root, this.scene?.source);
 		for (const path of unaddressable) diagnose(this, "warn", `save: ${path} has state to save and no uid to key it under.`);
+		if (unrecordable.length > 0) diagnose(this, "error", `[incanto] save: ${unrecordable.length} authored node(s) this run consumed have no uid, so nothing records that they are gone and LOADING THIS SAVE BRINGS THEM BACK: ${unrecordable.slice(0, 8).join(", ")}${unrecordable.length > 8 ? `, +${unrecordable.length - 8} more` : ""}. Give each one a "uid" from newUid().`);
 		return state;
 	}
 	/** Give it back, after the scene is loaded and onReady has run. */
@@ -2728,6 +2777,7 @@ var Engine = class {
 		scene.tree.fixedUpdate(dt);
 		this.fixedUpdated.emit(dt);
 		const startedUpdate = performance.now();
+		this.frameNumber += 1;
 		scene.tree.update(dt);
 		this.music.tick(dt);
 		this.updated.emit(dt);
@@ -2762,6 +2812,7 @@ var Engine = class {
 		}
 		if (this.accumulator >= this.fixedStep) this.accumulator %= this.fixedStep;
 		const startedUpdate = performance.now();
+		this.frameNumber += 1;
 		scene.tree.update(dt);
 		this.music.tick(dt);
 		this.updated.emit(dt);
@@ -3158,6 +3209,7 @@ var UiDialogue = class extends HudWidgetBase {
 	];
 	static props = {
 		...HudWidgetBase.props,
+		focusable: { default: true },
 		anchor: {
 			default: "bottom",
 			options: [
@@ -3207,6 +3259,49 @@ var UiDialogue = class extends HudWidgetBase {
 		});
 	}
 	/**
+	* A dialogue takes focus while it is up.
+	*
+	* It paints a focus ring and the generated reference advertises the prop, and
+	* it was inert: choices are raw DOM buttons inside the widget, so
+	* `HudLayer.focusables()` can never see them, and this class — unlike
+	* `UiButton` a hundred lines above it — never overrode `_activate`. Eleven
+	* keys and eight pad codes did nothing to a waiting choice while the same
+	* Enter pressed a sibling button. Native Tab worked, and is closed by any
+	* game that binds Tab; a pad has no Tab at all.
+	*/
+	focusable = true;
+	/** Which choice the keyboard/pad is on. Reset by every new line. */
+	cursor = 0;
+	/**
+	* Enter / A, and left / right between the options.
+	*
+	* `dir` is 0 for "activate" and ±1 for a nudge, the same shape `UiSelect`
+	* uses — so one key layout drives a menu, a slider and a conversation.
+	*/
+	_activate(dir) {
+		if (!this.active || !this.current) return;
+		const choices = this.current.choices;
+		if (!choices || choices.length === 0) {
+			this.advance();
+			return;
+		}
+		if (dir !== 0) {
+			this.cursor = (this.cursor + dir + choices.length) % choices.length;
+			this.paintCursor();
+			return;
+		}
+		this.choose(this.cursor);
+	}
+	/** Show which option the keyboard is on — a ring nobody can see is not one. */
+	paintCursor() {
+		const buttons = this.choicesEl?.children;
+		if (!buttons) return;
+		for (let i = 0; i < buttons.length; i++) {
+			const el = buttons[i];
+			if (el) el.style.outline = i === this.cursor ? "2px solid #fff" : "none";
+		}
+	}
+	/**
 	* Player pressed "next": mid-typing reveals the whole line; a fully-typed
 	* line without choices advances (choice lines wait for `choose`).
 	*/
@@ -3289,12 +3384,11 @@ var UiDialogue = class extends HudWidgetBase {
 			this.revealed = Math.round(progress * this.current.text.length);
 			if (this.speakerEl) this.speakerEl.textContent = this.current.speaker;
 		}
-		const wasTyping = this.revealed < this.current.text.length;
-		if (wasTyping) this.revealed = Math.min(this.current.text.length, this.revealed + this.charsPerSecond * dt);
+		if (this.revealed < this.current.text.length) this.revealed = Math.min(this.current.text.length, this.revealed + this.charsPerSecond * dt);
 		const doneTyping = this.revealed >= this.current.text.length;
 		if (this.textEl) this.textEl.textContent = this.showing;
 		if (this.hintEl) this.hintEl.style.visibility = doneTyping && !this.current.choices ? "visible" : "hidden";
-		if (doneTyping && wasTyping && this.current.choices && this.choicesEl) this.current.choices.forEach((label, i) => {
+		if (doneTyping && this.current.choices && this.choicesEl && this.choicesEl.children.length === 0) this.current.choices.forEach((label, i) => {
 			const b = document.createElement("button");
 			b.type = "button";
 			b.textContent = label;

package/dist/{register-DO5_Qp0Q.js → register-vIxU3Xbv.js}

@@ -1,10 +1,10 @@
-import { O as Node, k as diagnose, w as effectiveOrder } from "./loader-lQDCwNag.js";
-import { L as translateOn, t as registerCoreNodes } from "./register-CgeR4ckF.js";
+import { O as Node, k as diagnose, w as effectiveOrder } from "./loader-KZESOZmE.js";
+import { L as translateOn, t as registerCoreNodes } from "./register-Cs53CY7s.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as Rng } from "./rng-DP-SR7eg.js";
 import { i as getNodeSchema, l as registerNode } from "./registry-CF70EArN.js";
 import { i as ParticleSim, n as resolveFrames, o as PARTICLE_PRESET_NAMES, r as validateAnimationAliases, s as applyParticlePreset, t as resolveAnimation } from "./sprite-animation-CY-mrr1L.js";
-import { N as localFromWorld, P as worldPosition } from "./gameplay-D-H986A4.js";
+import { F as localFromWorld, I as worldPosition } from "./gameplay-CGSv-9XR.js";
 import { t as checkSheetGrid } from "./sheet-grid-BT6N_Bjs.js";
 import { AdditiveBlending, BufferAttribute, BufferGeometry, CanvasTexture, Color, DynamicDrawUsage, Group, InstancedMesh, MathUtils, Matrix4, Mesh, MeshBasicMaterial, NearestFilter, NormalBlending, Object3D, PlaneGeometry, SRGBColorSpace } from "three";
 //#region src/2d/physics/collider-validate.ts
@@ -223,6 +223,14 @@ var StaticBody2D = class extends PhysicsBody2D {
 */
 var Area2D = class extends PhysicsBody2D {
 	static typeName = "Area2D";
+	/**
+	* Who is inside RIGHT NOW — the standing answer behind the enter/exit pair.
+	* See `Area3D.overlapping`. Empty in a scene with no physics world.
+	*/
+	overlapping(group) {
+		const all = this._physics?.overlapping(this) ?? [];
+		return group === void 0 ? all : all.filter((n) => n.isInGroup(group));
+	}
 };
 /** Dynamic simulated body. */
 var RigidBody2D = class extends PhysicsBody2D {
@@ -334,7 +342,8 @@ var Joint2D = class extends Node2D {
 		targetAnchor: { default: [0, 0] },
 		length: { default: 0 },
 		stiffness: { default: 50 },
-		damping: { default: 5 }
+		damping: { default: 5 },
+		collide: { default: null }
 	};
 	type = "revolute";
 	target = "";
@@ -344,6 +353,31 @@ var Joint2D = class extends Node2D {
 	length = 0;
 	stiffness = 50;
 	damping = 5;
+	/**
+	* Do the two linked bodies still collide with EACH OTHER?
+	*
+	* `null` (default) decides from the joint type, because the two families want
+	* opposite answers:
+	*
+	* - **pivots** (`fixed`, `spherical`, `revolute`) → **off**. A hinge's bodies
+	*   overlap at the pivot by construction, so the contact solver fights the
+	*   joint and flings them. A puzzle builder's first hinge produced a bar that
+	*   spun chaotically forever and threw a 40 kg box thirty metres, and they
+	*   nearly filed "spherical joints inject energy":
+	*
+	*   ```
+	*   t=   0  Plank r=[0,0,0]      Box [ 0.00, 5.50,  2.40]
+	*   t=3000  Plank r=[-66,24,64]  Box [-29.70, 0.40, -4.91]
+	*   ```
+	*
+	* - **tethers** (`rope`, `spring`) → **on**. These anchor a thing to the world,
+	*   and the thing has to rest on what it is tethered to. Defaulting these off
+	*   drops a barrel roped to the floor straight through it — measured, in this
+	*   repo's own conformance room.
+	*
+	* Set `true`/`false` to say it outright.
+	*/
+	collide = null;
 	onEnterTree() {
 		if (!(this.parent instanceof PhysicsBody2D)) throw new IncantoError("TREE_VIOLATION", `Joint2D '${this.name}' must be a child of a physics body (its body A); parent is '${this.parent?.name ?? "none"}'.`);
 		if (this.target === "") throw new IncantoError("BAD_FORMAT", `Joint2D '${this.name}' needs a "target" node path to the body it links to.`);

package/dist/rendering-options-ByAdi8PF.js

@@ -0,0 +1,184 @@
+//#region src/core/drive-script.ts
+const num = (raw) => {
+	if (raw === void 0) return null;
+	const n = Number(raw);
+	return Number.isFinite(n) ? n : null;
+};
+/**
+* `vector move 0 1; step 2000` → steps, or an error naming the bad command.
+*
+* Semicolons and newlines both separate, so a whole plan fits in one shell
+* argument and a longer one fits in a file. `#` starts a comment.
+*
+* A command it does not know REFUSES THE WHOLE SCRIPT. Skipping it would leave
+* an agent looking at a frame that never moved, believing it had walked
+* somewhere — the failure mode this exists to prevent.
+*/
+function parseDrive(text) {
+	const steps = [];
+	let totalMs = 0;
+	const lines = text.split(/[;\n]/).map((l) => l.replace(/#.*$/, "").trim()).filter(Boolean);
+	for (const line of lines) {
+		const [word, ...rest] = line.split(/\s+/);
+		const bad = (why) => ({
+			steps: [],
+			error: `${why}: "${line}"`,
+			totalMs: 0
+		});
+		switch (word) {
+			case "press":
+			case "release": {
+				const action = rest[0];
+				if (!action) return bad(`${word} needs an action name`);
+				steps.push(word === "press" ? {
+					kind: "press",
+					action
+				} : {
+					kind: "release",
+					action
+				});
+				break;
+			}
+			case "vector": {
+				const action = rest[0];
+				const x = num(rest[1]);
+				const y = num(rest[2]);
+				if (!action || x === null || y === null) return bad("vector needs an action and two numbers");
+				steps.push({
+					kind: "vector",
+					action,
+					x,
+					y
+				});
+				break;
+			}
+			case "key": {
+				const code = rest[0];
+				const dir = rest[1];
+				if (!code || dir !== "down" && dir !== "up") return bad("key needs a code and down|up");
+				steps.push({
+					kind: "key",
+					code,
+					down: dir === "down"
+				});
+				break;
+			}
+			case "pointer": {
+				const dx = num(rest[0]);
+				const dy = num(rest[1]);
+				if (dx === null || dy === null) return bad("pointer needs two numbers");
+				steps.push({
+					kind: "pointer",
+					dx,
+					dy
+				});
+				break;
+			}
+			case "step": {
+				const ms = num(rest[0]);
+				if (ms === null || ms < 0) return bad("step needs a duration in ms");
+				steps.push({
+					kind: "step",
+					ms
+				});
+				totalMs += ms;
+				break;
+			}
+			default: return bad("not a command");
+		}
+	}
+	return {
+		steps,
+		error: null,
+		totalMs
+	};
+}
+//#endregion
+//#region src/core/log-report.ts
+const RANK = {
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3
+};
+/** Under this, with the loop running, is a frame rate somebody can feel. */
+const SLOW_FPS = 50;
+/** How many distinct messages to carry. Beyond this it is a log file, not a report. */
+const MAX_GROUPS = 20;
+/** The engine logs values, not strings — format them the way a console would. */
+function format(parts) {
+	return parts.map((p) => {
+		if (typeof p === "string") return p;
+		if (p instanceof Error) return p.message;
+		try {
+			return JSON.stringify(p);
+		} catch {
+			return String(p);
+		}
+	}).join(" ");
+}
+function logReport(input) {
+	const counts = {
+		debug: 0,
+		info: 0,
+		warn: 0,
+		error: 0
+	};
+	const byMessage = /* @__PURE__ */ new Map();
+	for (const e of input.entries) {
+		counts[e.level] += 1;
+		const message = format(e.parts);
+		const key = `${e.level}\0${message}`;
+		const seen = byMessage.get(key);
+		if (seen) {
+			seen.count += 1;
+			seen.lastMs = Math.max(seen.lastMs, e.timeMs);
+		} else byMessage.set(key, {
+			level: e.level,
+			message,
+			count: 1,
+			lastMs: e.timeMs
+		});
+	}
+	const grouped = [...byMessage.values()].sort((a, b) => RANK[b.level] - RANK[a.level] || b.lastMs - a.lastMs).slice(0, MAX_GROUPS);
+	const hidden = input.hidden === true;
+	const slow = !hidden && input.stats.running && input.stats.fps > 0 && input.stats.fps < SLOW_FPS;
+	return {
+		hidden,
+		ok: counts.error === 0 && input.stats.errors === 0 && input.assetErrors.length === 0,
+		slow,
+		counts,
+		grouped,
+		worst: grouped.find((g) => g.level === "error") ?? grouped[0] ?? null,
+		stats: input.stats,
+		assetErrors: input.assetErrors
+	};
+}
+/** The report as a person or an agent reads it: what is wrong, then the numbers. */
+function logText(r) {
+	const lines = [];
+	if (r.stats.errors > 0) lines.push(`${r.stats.errors} error${r.stats.errors === 1 ? "" : "s"} were swallowed to keep the game alive — it is running, and something in it is broken`);
+	for (const a of r.assetErrors) lines.push(`asset ${a.ref} never loaded: ${a.error} (${a.url})`);
+	for (const g of r.grouped) {
+		if (g.level === "debug") continue;
+		lines.push(`[${g.level}] ${g.message}${g.count > 1 ? ` ×${g.count}` : ""}`);
+	}
+	if (lines.length === 0) lines.push("nothing wrong — no warnings, no errors, no failed assets");
+	if (!r.stats.running) lines.push(`not running — the loop is stopped (${r.stats.nodes} nodes in the scene)`);
+	else if (r.hidden) lines.push(`${r.stats.nodes} nodes · frame rate not measurable — the page is hidden (a window covered by another counts), and the browser throttles it. Bring it to the front`);
+	else lines.push(`${Math.round(r.stats.fps)} fps · ${r.stats.frameMs.toFixed(1)}ms per frame · ${r.stats.nodes} nodes${r.slow ? " — slow enough to feel" : ""}`);
+	return lines.join("\n");
+}
+//#endregion
+//#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,
+		preserveDrawingBuffer: explicit?.preserveDrawingBuffer ?? rendering.preserveDrawingBuffer ?? fallback.preserveDrawingBuffer
+	};
+}
+//#endregion
+export { parseDrive as i, logReport as n, logText as r, resolveRendering as t };

package/dist/{replay-CEw2xAhG.js → replay-BkpDV51O.js}

@@ -1,5 +1,5 @@
-import { D as handlerShadowWarnings, j as nodeRefWarnings } from "./loader-lQDCwNag.js";
-import { R as translationKey, k as HudWidgetBase } from "./register-CgeR4ckF.js";
+import { D as handlerShadowWarnings, j as nodeRefWarnings } from "./loader-KZESOZmE.js";
+import { R as translationKey, k as HudWidgetBase } from "./register-Cs53CY7s.js";
 import { o as getNodeType } from "./registry-CF70EArN.js";
 //#region src/core/audit.ts
 const ANIMATED_TYPES = new Set([
@@ -166,7 +166,8 @@ function auditScene(scene, opts = {}) {
 	if (cameraDrivers.length > 0 && followedCameras.length > 0) warnings.push(`${followedCameras.join(", ")}: a FollowCamera writes this camera's position every frame, and so does the CharacterController3D at ${cameraDrivers.join(", ")} — the controller owns the camera in every view it has. Drop one of them: use the controller's own \`view\`/\`camDistance\`, or take the controller off the camera duty.`);
 	if (cameras > 0 && currentCameras === 0) warnings.push("no camera has \"current\": true — the screen renders from a default view, probably not what you framed.");
 	if (currentCameras > 1) warnings.push(`${currentCameras} cameras claim "current": true — only the first found wins.`);
-	if (scene.dimension === "3d" && lights === 0 && !isLit(scene.environment)) warnings.push("nothing lights this 3D scene — no light node, no environment sky/hdri, and no ambient intensity. It will render black. Add a DirectionalLight3D, or an \"environment\": { \"sky\": { \"type\": \"atmosphere\" } } / { \"preset\": \"...\" }.");
+	const isFragment = cameras === 0;
+	if (scene.dimension === "3d" && !isFragment && lights === 0 && !isLit(scene.environment)) warnings.push("nothing lights this 3D scene — no light node, no environment sky/hdri, and no ambient intensity. It will render black. Add a DirectionalLight3D, or an \"environment\": { \"sky\": { \"type\": \"atmosphere\" } } / { \"preset\": \"...\" }.");
 	if (damageGroups.length > 0) {
 		const hurtable = hurtableGroups(root);
 		for (const { path, group } of damageGroups) {

package/dist/{replay-CThvwkcQ.d.ts → replay-D0GcEHYU.d.ts}

@@ -1,4 +1,4 @@
-import { b as Engine } from "./behavior-CmMuQ6CL.js";
+import { b as Engine } from "./behavior-ZnfzKDo3.js";
 import { s as JsonObject } from "./schema-CFeioQRE.js";
 
 //#region src/core/audit.d.ts

package/dist/{split-screen-DxZzC1nm.d.ts → split-screen-DD5eYIgW.d.ts}

@@ -1,6 +1,6 @@
-import { Lt as Signal, b as Engine, jt as Node } from "./behavior-CmMuQ6CL.js";
+import { Lt as Signal, b as Engine, jt as Node } from "./behavior-ZnfzKDo3.js";
 import { c as JsonValue, i as SceneJson, s as JsonObject } from "./schema-CFeioQRE.js";
-import { t as LoadSceneOptions } from "./loader-CTB441z4.js";
+import { t as LoadSceneOptions } from "./loader-DyT30ArB.js";
 
 //#region src/net/types.d.ts
 type Unsubscribe = () => void;

package/dist/{split-screen-gb0c3xdb.js → split-screen-DS8RaUV_.js}

@@ -1,5 +1,5 @@
-import { O as Node, V as Signal, k as diagnose, n as loadScene, t as buildNodeJson } from "./loader-lQDCwNag.js";
-import { t as registerCoreNodes, v as Engine } from "./register-CgeR4ckF.js";
+import { O as Node, V as Signal, k as diagnose, n as loadScene, t as buildNodeJson } from "./loader-KZESOZmE.js";
+import { t as registerCoreNodes, v as Engine } from "./register-Cs53CY7s.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { n as jsonEquals, t as jsonClone } from "./json-CwwhxQgb.js";
 import { l as registerNode } from "./registry-CF70EArN.js";

package/dist/{src-DYffzHbd.js → src-BLlsGJW9.js}

@@ -214,6 +214,6 @@ function newUid() {
 //#endregion
 //#region src/index.ts
 /** Engine version. Kept in sync with package.json by the release pipeline. */
-const VERSION = "0.65.0";
+const VERSION = "0.67.0";
 //#endregion
 export { preloadUrls as a, preloadSceneAssets as i, newUid as n, findPath as o, assetUrls as r, gridFromRows as s, VERSION as t };

package/dist/{teardown-BordHL9o.js → teardown-LB9cTnXJ.js}

@@ -1,5 +1,5 @@
-import { _ as AudioPlayer } from "./register-CgeR4ckF.js";
-import { a as logReport, s as parseDrive } from "./touch-DESwnpOc.js";
+import { _ as AudioPlayer } from "./register-Cs53CY7s.js";
+import { i as parseDrive, n as logReport } from "./rendering-options-ByAdi8PF.js";
 import { a as frameSignature, i as frameImage, o as frameStats } from "./frame-report-BSMny7oe.js";
 //#region src/core/audio-errors.ts
 /** Every AudioPlayer under `root` whose source could not be played. */