incanto 0.7.0 → 0.8.0

package/dist/{behavior-e3kAmPGC.d.ts → behavior-Bod1AyJS.d.ts}

@@ -1,5 +1,68 @@
 import { a as Rng, c as JsonValue, i as SceneJson, s as JsonObject } from "./schema-CcoWb32N.js";
 
+//#region src/core/scene-tree.d.ts
+/**
+* Owns a node tree and drives its lifecycle:
+*
+* - `setRoot` → onEnterTree parent-first, then onReady children-first (once per instance)
+* - `update`/`fixedUpdate` → parent-first traversal, then flush of queued frees
+* - group queries across attached nodes
+*
+* Headless by design — tests step it manually; the render loop (M2) calls it.
+*/
+declare class SceneTree {
+  private _root;
+  private _engine;
+  private readonly freeQueue;
+  /**
+  * name → attached nodes with that name. Maintained by Node enter/exit/rename
+  * so `%name` targeting and root-level getNodesByName are O(1) — behaviors
+  * resolve targets every frame and a full-tree walk per chaser melted horde
+  * scenes (N chasers × whole tree, 60×/s).
+  */
+  private readonly _nameIndex;
+  /**
+  * Bumped whenever ANY node attaches or detaches — cheap "did the tree
+  * change shape?" check for per-step body gathers and similar caches.
+  */
+  _structureVersion: number;
+  private _frameId;
+  /**
+  * Monotonic update-frame counter — bumped once per `update()`. Per-frame
+  * caches (e.g. the 3d grass-bender body gather) key off this so they rebuild
+  * at most once a frame regardless of node visitation order.
+  */
+  get frameId(): number;
+  /** @internal Node attach hook. */
+  _indexName(node: Node): void;
+  /** @internal Node detach/rename hook (`name` = the entry to remove). */
+  _unindexName(node: Node, name?: string): void;
+  /** @internal Every ATTACHED node named `name` (undefined = none). */
+  _nodesNamed(name: string): ReadonlySet<Node> | undefined;
+  /**
+  * @internal Opaque per-frame scratch the 3d layer parks its shared moving-body
+  * snapshot on (kept here so it is per-tree-instance, never a module global —
+  * core stays three-free, the 3d resolver owns the shape).
+  */
+  _frameScratch: unknown;
+  get root(): Node | null;
+  /** The engine driving this tree (set by Engine.setScene), or null. */
+  get engine(): Engine | null;
+  /** @internal */
+  _setEngine(engine: Engine | null): void;
+  setRoot(node: Node): void;
+  update(dt: number): void;
+  fixedUpdate(dt: number): void;
+  getNodesInGroup(group: string): Node[];
+  /** Call `method(...args)` on every group member that implements it. */
+  callGroup(group: string, method: string, ...args: unknown[]): void;
+  /** @internal */
+  _queueFree(node: Node): void;
+  /** @internal Called by Node.free(): a freed root must not be re-drivable. */
+  _detachRoot(node: Node): void;
+  private flushFreeQueue;
+}
+//#endregion
 //#region src/core/signal.d.ts
 /**
 * Minimal typed observer used for every engine event (Godot signal semantics).
@@ -20,6 +83,116 @@ declare class Signal<Args extends unknown[] = unknown[]> {
   get connectionCount(): number;
 }
 //#endregion
+//#region src/core/node.d.ts
+/** Lifecycle hooks a SceneTree drives. Wired in scene-tree.ts. */
+interface NodeLifecycle {
+  onEnterTree(): void;
+  onReady(): void;
+  onExitTree(): void;
+  update(dt: number): void;
+  fixedUpdate(dt: number): void;
+}
+/**
+* Base class of everything in an Incanto scene (Godot's Node model).
+*
+* Pure data + tree structure: no rendering, no DOM, no three.js — renderer
+* adapters subscribe from the outside.
+*/
+declare class Node implements NodeLifecycle {
+  static readonly typeName: string;
+  /**
+  * Signals this node type can emit, declared statically (merged up the class
+  * hierarchy). A behavior's `static signals` are declared onto its node at
+  * load. Emitting or subscribing an UNDECLARED signal is a hard error —
+  * a typo'd signal name must fail loudly, never silently never-fire.
+  */
+  static readonly signals?: readonly string[];
+  private _name;
+  private _parent;
+  private readonly _children;
+  private readonly _groups;
+  private readonly _signals;
+  private _declared;
+  private _tree;
+  private _ready;
+  /**
+  * Optional STABLE identifier (scene JSON `uid`) — unlike names (unique only
+  * among siblings) a uid is unique across the whole scene, so scripts and
+  * tools can address a node no matter where it moves.
+  */
+  uid: string | null;
+  /** Free-form JSON identity for game logic (e.g. `{kind: 'ITEM', value: 10}`). */
+  tags: Record<string, unknown>;
+  /** Behavior attachment blob from scene JSON (resolved by the loader). */
+  script: JsonObject | null;
+  /** The resolved behavior instance (set by the loader from `script`). */
+  behavior: Behavior | null;
+  /** Replication config blob from scene JSON (interpreted in M6; preserved until then). */
+  network: JsonObject | null;
+  constructor(name?: string);
+  get name(): string;
+  set name(value: string);
+  get parent(): Node | null;
+  get children(): readonly Node[];
+  get groups(): ReadonlySet<string>;
+  /** The SceneTree this node is attached to, or null while detached. */
+  get tree(): SceneTree | null;
+  /** Whether onReady has run (it runs at most once per instance). */
+  get isReady(): boolean;
+  addChild<T extends Node>(child: T): T;
+  removeChild(child: Node): void;
+  reparent(newParent: Node): void;
+  findChild(name: string, recursive?: boolean): Node | null;
+  /** Topmost ancestor (the node itself when detached). */
+  getRoot(): Node;
+  /** Depth-first search of THIS subtree for the node carrying `uid`. */
+  getNodeByUid(uid: string): Node | null;
+  /** Every node in THIS subtree named `name` — names repeat, so a list. */
+  getNodesByName(name: string): Node[];
+  getPath(): string;
+  getNode(path: string): Node;
+  getNodeOrNull(path: string): Node | null;
+  private resolve;
+  addToGroup(group: string): void;
+  removeFromGroup(group: string): void;
+  isInGroup(group: string): boolean;
+  private declaredSignals;
+  /** Declare an ad-hoc signal on THIS instance (static `signals` covers types). */
+  declareSignal(name: string): void;
+  /** Every signal this instance may emit (static + behavior + ad-hoc). */
+  declaredSignalNames(): string[];
+  private assertDeclared;
+  /** Get the named DECLARED signal (creating its Signal object on demand). */
+  signal(name: string): Signal<unknown[]>;
+  on(signal: string, fn: SignalListener<unknown[]>, opts?: {
+    once?: boolean;
+  }): () => void;
+  off(signal: string, fn: SignalListener<unknown[]>): void;
+  emit(signal: string, ...args: unknown[]): void;
+  /**
+  * Defer destruction to the end of the current update pass (flushed by the
+  * SceneTree). Frees immediately when detached from any tree.
+  */
+  queueFree(): void;
+  /** Immediately detach and tear down this node and its children. */
+  free(): void;
+  /** @internal */
+  _propagateEnterTree(tree: SceneTree): void;
+  /** @internal */
+  _propagateReady(): void;
+  /** @internal */
+  _propagateExitTree(): void;
+  /** @internal */
+  _propagateUpdate(dt: number): void;
+  /** @internal */
+  _propagateFixedUpdate(dt: number): void;
+  onEnterTree(): void;
+  onReady(): void;
+  onExitTree(): void;
+  update(_dt: number): void;
+  fixedUpdate(_dt: number): void;
+}
+//#endregion
 //#region src/core/audio/buses.d.ts
 /** The two volume buses every sound routes through (plus the global `master`). */
 type BusName = "sfx" | "music";
@@ -264,6 +437,30 @@ declare function spatialGain(distance: number, params: SpatialParams): number;
 */
 declare function spatialPan(sourcePos: Vec3, listener: Listener): number;
 //#endregion
+//#region src/core/audio/voice.d.ts
+/**
+* Continuous parametric voices — the engine hum, wind rush and thruster
+* roar that one-shot SFX can't do (racing-3d hand-built exactly this graph).
+* A voice is a small WebAudio patch you retune every frame:
+*
+*   const voice = engine.sfx.startVoice('engine');
+*   voice.set({ pitch: rpm / 4000, volume: throttle * 0.6 });
+*   voice.stop();                       // fades out and frees the graph
+*
+* Headless (no AudioContext) the handle is inert — same call sites, no ifs.
+*/
+type VoicePreset = "engine" | "wind" | "hum" | "noise";
+interface Voice {
+  /** Retune live. pitch 1 = the preset's base; volume 0..1. */
+  set(params: {
+    pitch?: number;
+    volume?: number;
+  }): void;
+  /** Fade out over `seconds` (default 0.15) and free the nodes. */
+  stop(seconds?: number): void;
+  readonly stopped: boolean;
+}
+//#endregion
 //#region src/core/audio/webaudio-sfx.d.ts
 /** A spatial emitter: where the sound is + where the listener is. */
 interface SpatialPlay {
@@ -296,6 +493,12 @@ declare class SfxEngine {
   /** True once a backend is present (lazily created on first use). */
   get available(): boolean;
   private ensure;
+  /**
+  * Start a continuous parametric voice (engine hum, wind, thrusters) —
+  * retune it per frame with `voice.set({ pitch, volume })`, `stop()` when
+  * done. Headless returns an inert handle (same call sites, no ifs).
+  */
+  startVoice(preset: VoicePreset, gain?: number): Voice;
   /** Resume a gesture-suspended context (wired to the first user gesture). */
   unlock(): void;
   /**
@@ -477,179 +680,6 @@ declare class LogManager {
   private push;
 }
 //#endregion
-//#region src/core/scene-tree.d.ts
-/**
-* Owns a node tree and drives its lifecycle:
-*
-* - `setRoot` → onEnterTree parent-first, then onReady children-first (once per instance)
-* - `update`/`fixedUpdate` → parent-first traversal, then flush of queued frees
-* - group queries across attached nodes
-*
-* Headless by design — tests step it manually; the render loop (M2) calls it.
-*/
-declare class SceneTree {
-  private _root;
-  private _engine;
-  private readonly freeQueue;
-  /**
-  * name → attached nodes with that name. Maintained by Node enter/exit/rename
-  * so `%name` targeting and root-level getNodesByName are O(1) — behaviors
-  * resolve targets every frame and a full-tree walk per chaser melted horde
-  * scenes (N chasers × whole tree, 60×/s).
-  */
-  private readonly _nameIndex;
-  /**
-  * Bumped whenever ANY node attaches or detaches — cheap "did the tree
-  * change shape?" check for per-step body gathers and similar caches.
-  */
-  _structureVersion: number;
-  private _frameId;
-  /**
-  * Monotonic update-frame counter — bumped once per `update()`. Per-frame
-  * caches (e.g. the 3d grass-bender body gather) key off this so they rebuild
-  * at most once a frame regardless of node visitation order.
-  */
-  get frameId(): number;
-  /** @internal Node attach hook. */
-  _indexName(node: Node): void;
-  /** @internal Node detach/rename hook (`name` = the entry to remove). */
-  _unindexName(node: Node, name?: string): void;
-  /** @internal Every ATTACHED node named `name` (undefined = none). */
-  _nodesNamed(name: string): ReadonlySet<Node> | undefined;
-  /**
-  * @internal Opaque per-frame scratch the 3d layer parks its shared moving-body
-  * snapshot on (kept here so it is per-tree-instance, never a module global —
-  * core stays three-free, the 3d resolver owns the shape).
-  */
-  _frameScratch: unknown;
-  get root(): Node | null;
-  /** The engine driving this tree (set by Engine.setScene), or null. */
-  get engine(): Engine | null;
-  /** @internal */
-  _setEngine(engine: Engine | null): void;
-  setRoot(node: Node): void;
-  update(dt: number): void;
-  fixedUpdate(dt: number): void;
-  getNodesInGroup(group: string): Node[];
-  /** Call `method(...args)` on every group member that implements it. */
-  callGroup(group: string, method: string, ...args: unknown[]): void;
-  /** @internal */
-  _queueFree(node: Node): void;
-  /** @internal Called by Node.free(): a freed root must not be re-drivable. */
-  _detachRoot(node: Node): void;
-  private flushFreeQueue;
-}
-//#endregion
-//#region src/core/node.d.ts
-/** Lifecycle hooks a SceneTree drives. Wired in scene-tree.ts. */
-interface NodeLifecycle {
-  onEnterTree(): void;
-  onReady(): void;
-  onExitTree(): void;
-  update(dt: number): void;
-  fixedUpdate(dt: number): void;
-}
-/**
-* Base class of everything in an Incanto scene (Godot's Node model).
-*
-* Pure data + tree structure: no rendering, no DOM, no three.js — renderer
-* adapters subscribe from the outside.
-*/
-declare class Node implements NodeLifecycle {
-  static readonly typeName: string;
-  /**
-  * Signals this node type can emit, declared statically (merged up the class
-  * hierarchy). A behavior's `static signals` are declared onto its node at
-  * load. Emitting or subscribing an UNDECLARED signal is a hard error —
-  * a typo'd signal name must fail loudly, never silently never-fire.
-  */
-  static readonly signals?: readonly string[];
-  private _name;
-  private _parent;
-  private readonly _children;
-  private readonly _groups;
-  private readonly _signals;
-  private _declared;
-  private _tree;
-  private _ready;
-  /**
-  * Optional STABLE identifier (scene JSON `uid`) — unlike names (unique only
-  * among siblings) a uid is unique across the whole scene, so scripts and
-  * tools can address a node no matter where it moves.
-  */
-  uid: string | null;
-  /** Free-form JSON identity for game logic (e.g. `{kind: 'ITEM', value: 10}`). */
-  tags: Record<string, unknown>;
-  /** Behavior attachment blob from scene JSON (resolved by the loader). */
-  script: JsonObject | null;
-  /** The resolved behavior instance (set by the loader from `script`). */
-  behavior: Behavior | null;
-  /** Replication config blob from scene JSON (interpreted in M6; preserved until then). */
-  network: JsonObject | null;
-  constructor(name?: string);
-  get name(): string;
-  set name(value: string);
-  get parent(): Node | null;
-  get children(): readonly Node[];
-  get groups(): ReadonlySet<string>;
-  /** The SceneTree this node is attached to, or null while detached. */
-  get tree(): SceneTree | null;
-  /** Whether onReady has run (it runs at most once per instance). */
-  get isReady(): boolean;
-  addChild<T extends Node>(child: T): T;
-  removeChild(child: Node): void;
-  reparent(newParent: Node): void;
-  findChild(name: string, recursive?: boolean): Node | null;
-  /** Topmost ancestor (the node itself when detached). */
-  getRoot(): Node;
-  /** Depth-first search of THIS subtree for the node carrying `uid`. */
-  getNodeByUid(uid: string): Node | null;
-  /** Every node in THIS subtree named `name` — names repeat, so a list. */
-  getNodesByName(name: string): Node[];
-  getPath(): string;
-  getNode(path: string): Node;
-  getNodeOrNull(path: string): Node | null;
-  private resolve;
-  addToGroup(group: string): void;
-  removeFromGroup(group: string): void;
-  isInGroup(group: string): boolean;
-  private declaredSignals;
-  /** Declare an ad-hoc signal on THIS instance (static `signals` covers types). */
-  declareSignal(name: string): void;
-  /** Every signal this instance may emit (static + behavior + ad-hoc). */
-  declaredSignalNames(): string[];
-  private assertDeclared;
-  /** Get the named DECLARED signal (creating its Signal object on demand). */
-  signal(name: string): Signal<unknown[]>;
-  on(signal: string, fn: SignalListener<unknown[]>, opts?: {
-    once?: boolean;
-  }): () => void;
-  off(signal: string, fn: SignalListener<unknown[]>): void;
-  emit(signal: string, ...args: unknown[]): void;
-  /**
-  * Defer destruction to the end of the current update pass (flushed by the
-  * SceneTree). Frees immediately when detached from any tree.
-  */
-  queueFree(): void;
-  /** Immediately detach and tear down this node and its children. */
-  free(): void;
-  /** @internal */
-  _propagateEnterTree(tree: SceneTree): void;
-  /** @internal */
-  _propagateReady(): void;
-  /** @internal */
-  _propagateExitTree(): void;
-  /** @internal */
-  _propagateUpdate(dt: number): void;
-  /** @internal */
-  _propagateFixedUpdate(dt: number): void;
-  onEnterTree(): void;
-  onReady(): void;
-  onExitTree(): void;
-  update(_dt: number): void;
-  fixedUpdate(_dt: number): void;
-}
-//#endregion
 //#region src/core/scene/scene.d.ts
 /**
 * A loaded, live scene: the node tree plus everything needed to round-trip
@@ -773,6 +803,13 @@ declare class Engine {
   * timers, behaviors all breathe together. See `gameplay` `hitStop()`.
   */
   timeScale: number;
+  /**
+  * The node the dev overlay has selected (renderers draw its bounding box
+  * as an orange outline in the game view so you can SEE what you picked).
+  * Null when nothing is selected; cleared automatically when it leaves the
+  * tree. Set by the debug overlay — games normally never touch this.
+  */
+  debugSelection: Node | null;
   private _time;
   private _unscaledTime;
   /**
@@ -913,4 +950,4 @@ declare function registeredBehaviors(): string[];
 /** Test isolation helper. */
 declare function clearBehaviors(): void;
 //#endregion
-export { BusName as $, LogManager as A, spatialGain as B, RendererStats as C, SceneTree as D, NodeLifecycle as E, Listener as F, SfxWave as G, SFX_PRESETS as H, ROLLOFF_MODELS as I, MusicBackend as J, SynthOptions as K, RolloffModel as L, SfxEngine as M, SfxPlayOptions as N, LogEntry as O, isAudioContextAvailable as P, AudioBuses as Q, SpatialParams as R, GameStats as S, Node as T, SFX_PRESET_NAMES as U, spatialPan as V, SfxParams as W, MusicTrack as X, MusicManager as Y, PlayMusicOptions as Z, registeredTypes as _, registerBehavior as a, Scheduler as b, PropDef as c, createNode as d, Signal as et, getNodeSchema as f, registerNode as g, mergeStaticSignals as h, getBehavior as i, InputMap as j, LogLevel as k, PropSchema as l, getNodeType as m, BehaviorCtor as n, registeredBehaviors as o, getNodeSignals as p, synthSfx as q, clearBehaviors as r, NodeCtor as s, Behavior as t, SignalListener as tt, clearRegistry as u, Engine as v, Scene as w, EngineStats as x, EngineOptions as y, Vec3 as z };
+export { Node as $, SfxPlayOptions as A, spatialPan as B, RendererStats as C, LogManager as D, LogLevel as E, ROLLOFF_MODELS as F, SynthOptions as G, SFX_PRESET_NAMES as H, RolloffModel as I, MusicManager as J, synthSfx as K, SpatialParams as L, Voice as M, VoicePreset as N, InputMap as O, Listener as P, BusName as Q, Vec3 as R, GameStats as S, LogEntry as T, SfxParams as U, SFX_PRESETS as V, SfxWave as W, PlayMusicOptions as X, MusicTrack as Y, AudioBuses as Z, registeredTypes as _, registerBehavior as a, Scheduler as b, PropDef as c, createNode as d, NodeLifecycle as et, getNodeSchema as f, registerNode as g, mergeStaticSignals as h, getBehavior as i, isAudioContextAvailable as j, SfxEngine as k, PropSchema as l, getNodeType as m, BehaviorCtor as n, SignalListener as nt, registeredBehaviors as o, getNodeSignals as p, MusicBackend as q, clearBehaviors as r, SceneTree as rt, NodeCtor as s, Behavior as t, Signal as tt, clearRegistry as u, Engine as v, Scene as w, EngineStats as x, EngineOptions as y, spatialGain as z };

package/dist/{create-game-CEFoFN8d.js → create-game-66c4iYJE.js}

@@ -1,14 +1,13 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { _ as registerBehavior, n as loadScene } from "./loader-B4OEXDZ8.js";
-import { s as Engine } from "./particle-sim-CrTE7c02.js";
+import { l as AudioPlayer, u as Engine } from "./register-DRPIjrKG.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { s as AudioPlayer } from "./register-Dl_ixIJe.js";
 import { i as resolveRendering, n as attachTouchControls } from "./touch-031PxtCR.js";
-import { n as registerGameplayBehaviors } from "./gameplay-CDFgSG6z.js";
+import { n as registerGameplayBehaviors } from "./gameplay-DPMgZk9W.js";
 import { t as debugSources } from "./debug-draw-CZmOYjL2.js";
-import { O as PhysicsBody3D, c as ModelInstance3D, d as DirectionalLight3D, j as Node3D, t as registerNodes3D, y as Camera3D } from "./register-CscQqB7V.js";
-import { n as enablePhysics3D } from "./physics-3d-CDjuhtt_.js";
-import { ACESFilmicToneMapping, AmbientLight, BufferAttribute, BufferGeometry, Color, DepthTexture, EquirectangularReflectionMapping, FloatType, Fog, HalfFloatType, LineBasicMaterial, LineSegments, Matrix4, Mesh, PCFShadowMap, PMREMGenerator, PerspectiveCamera, PlaneGeometry, Quaternion, Raycaster, Scene, ShaderMaterial, Vector2, Vector3, WebGLRenderTarget, WebGLRenderer } from "three";
+import { M as Node3D, b as Camera3D, f as DirectionalLight3D, k as PhysicsBody3D, l as ModelInstance3D, t as registerNodes3D } from "./register-Cbs7QxoV.js";
+import { n as enablePhysics3D } from "./physics-3d-CvHr31d4.js";
+import { ACESFilmicToneMapping, AmbientLight, Box3, BufferAttribute, BufferGeometry, Color, DepthTexture, EquirectangularReflectionMapping, FloatType, Fog, HalfFloatType, LineBasicMaterial, LineSegments, Matrix4, Mesh, PCFShadowMap, PMREMGenerator, PerspectiveCamera, PlaneGeometry, Quaternion, Raycaster, Scene, ShaderMaterial, Vector2, Vector3, WebGLRenderTarget, WebGLRenderer } from "three";
 import { VRMLoaderPlugin, VRMUtils } from "@pixiv/three-vrm";
 import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
 import { RGBELoader } from "three/examples/jsm/loaders/RGBELoader.js";
@@ -1073,6 +1072,54 @@ function parseIblIntensity(value) {
 	return value;
 }
 //#endregion
+//#region src/3d/selection-outline.ts
+/**
+* Where IS the node the dev-overlay selected? — world-space outline segments
+* for the renderer's highlight pass. A renderable node gets its actual
+* bounding box (children included); a node with no visual extent gets a
+* small marker cube at its world position so it is still findable.
+*/
+const box = new Box3();
+const size = new Vector3();
+const MARKER_HALF = .4;
+/** 12 box edges = 24 points × xyz. */
+const OUT = new Float32Array(72);
+function selectionOutline3D(node) {
+	if (!(node instanceof Node3D)) return null;
+	const obj = node._ensureObject3D();
+	obj.updateWorldMatrix(true, true);
+	box.setFromObject(obj);
+	box.getSize(size);
+	if (!Number.isFinite(size.x) || size.x === 0 && size.y === 0 && size.z === 0) {
+		const p = new Vector3().setFromMatrixPosition(obj.matrixWorld);
+		box.min.set(p.x - MARKER_HALF, p.y - MARKER_HALF, p.z - MARKER_HALF);
+		box.max.set(p.x + MARKER_HALF, p.y + MARKER_HALF, p.z + MARKER_HALF);
+	} else box.expandByScalar(.02);
+	const { min, max } = box;
+	let i = 0;
+	const seg = (x1, y1, z1, x2, y2, z2) => {
+		OUT[i++] = x1;
+		OUT[i++] = y1;
+		OUT[i++] = z1;
+		OUT[i++] = x2;
+		OUT[i++] = y2;
+		OUT[i++] = z2;
+	};
+	seg(min.x, min.y, min.z, max.x, min.y, min.z);
+	seg(max.x, min.y, min.z, max.x, min.y, max.z);
+	seg(max.x, min.y, max.z, min.x, min.y, max.z);
+	seg(min.x, min.y, max.z, min.x, min.y, min.z);
+	seg(min.x, max.y, min.z, max.x, max.y, min.z);
+	seg(max.x, max.y, min.z, max.x, max.y, max.z);
+	seg(max.x, max.y, max.z, min.x, max.y, max.z);
+	seg(min.x, max.y, max.z, min.x, max.y, min.z);
+	seg(min.x, min.y, min.z, min.x, max.y, min.z);
+	seg(max.x, min.y, min.z, max.x, max.y, min.z);
+	seg(max.x, min.y, max.z, max.x, max.y, max.z);
+	seg(min.x, min.y, max.z, min.x, max.y, max.z);
+	return OUT;
+}
+//#endregion
 //#region src/3d/sync.ts
 function isSpatialConsumer(node) {
 	return node.spatial === true && typeof node._setSpatialPose === "function";
@@ -1449,9 +1496,31 @@ var Renderer3D = class {
 		this.debugLines.renderOrder = 9999;
 		this.debugLines.visible = false;
 		this.threeScene.add(this.debugLines);
+		this.selectionLines = new LineSegments(new BufferGeometry(), new LineBasicMaterial({
+			color: "#ffb020",
+			transparent: true,
+			depthTest: false
+		}));
+		this.selectionLines.frustumCulled = false;
+		this.selectionLines.renderOrder = 1e4;
+		this.selectionLines.visible = false;
+		this.threeScene.add(this.selectionLines);
 		this.disconnect = this.engine.updated.connect(() => this.render());
 	}
 	debugLines;
+	selectionLines;
+	syncSelectionOutline() {
+		const node = this.engine.debugSelection;
+		if (node && node.tree !== this.engine.scene?.tree) this.engine.debugSelection = null;
+		const current = this.engine.debugSelection;
+		const vertices = current ? selectionOutline3D(current) : null;
+		this.selectionLines.visible = vertices !== null;
+		if (vertices) {
+			this.selectionLines.geometry.setAttribute("position", new BufferAttribute(vertices, 3));
+			const attr = this.selectionLines.geometry.getAttribute("position");
+			attr.needsUpdate = true;
+		}
+	}
 	syncDebugLines() {
 		let vertices = null;
 		for (const source of debugSources("3d")) {
@@ -1465,6 +1534,7 @@ var Renderer3D = class {
 		const scene = this.engine.scene;
 		if (!scene) return;
 		this.syncDebugLines();
+		this.syncSelectionOutline();
 		if (scene.assets && !this.loadedAssetScenes.has(scene)) {
 			this.assets.load(scene.assets);
 			this.loadedAssetScenes.add(scene);

package/dist/{create-game-X5iRu6pf.js → create-game-BNDSbhy-.js}

@@ -1,13 +1,12 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { _ as registerBehavior, n as loadScene, o as computeViewport, s as resolveViewport } from "./loader-B4OEXDZ8.js";
-import { s as Engine } from "./particle-sim-CrTE7c02.js";
+import { l as AudioPlayer, u as Engine } from "./register-DRPIjrKG.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { s as AudioPlayer } from "./register-Dl_ixIJe.js";
 import { i as resolveRendering, n as attachTouchControls } from "./touch-031PxtCR.js";
-import { n as registerGameplayBehaviors } from "./gameplay-CDFgSG6z.js";
-import { g as Node2D, n as UILayer, p as PhysicsBody2D, s as Camera2D, t as registerNodes2D } from "./register-ClKnoILk.js";
+import { n as registerGameplayBehaviors } from "./gameplay-DPMgZk9W.js";
+import { g as PhysicsBody2D, n as UILayer, t as registerNodes2D, u as Camera2D, y as Node2D } from "./register-Cqjxrfq0.js";
 import { t as debugSources } from "./debug-draw-CZmOYjL2.js";
-import { n as enablePhysics2D } from "./physics-2d-DmQ540uR.js";
+import { n as enablePhysics2D } from "./physics-2d-q2N362ph.js";
 import { Box3, BufferAttribute, BufferGeometry, Color, LineBasicMaterial, LineSegments, LinearFilter, NearestFilter, OrthographicCamera, Raycaster, SRGBColorSpace, Scene, TextureLoader, Vector2, Vector3, WebGLRenderer } from "three";
 //#region src/2d/assets.ts
 /**
@@ -101,6 +100,58 @@ function worldFromScreen(view, sx, sy) {
 	};
 }
 //#endregion
+//#region src/2d/selection-outline.ts
+/** 2D twin of the 3D selection outline: a world-space (px, y-down) rectangle
+*  around the selected node's rendered extent, or a marker square. */
+const box = new Box3();
+const size = new Vector3();
+const MARKER_HALF = 12;
+/** 4 rect edges = 8 points × xy. */
+const OUT = new Float32Array(16);
+function selectionOutline2D(node) {
+	if (!(node instanceof Node2D)) return null;
+	const obj = node._ensureObject2D();
+	obj.updateWorldMatrix(true, true);
+	box.setFromObject(obj);
+	box.getSize(size);
+	let minX;
+	let minY;
+	let maxX;
+	let maxY;
+	if (!Number.isFinite(size.x) || size.x === 0 && size.y === 0) {
+		const p = new Vector3().setFromMatrixPosition(obj.matrixWorld);
+		minX = p.x - MARKER_HALF;
+		maxX = p.x + MARKER_HALF;
+		minY = p.y - MARKER_HALF;
+		maxY = p.y + MARKER_HALF;
+	} else {
+		minX = box.min.x - 2;
+		maxX = box.max.x + 2;
+		minY = box.min.y - 2;
+		maxY = box.max.y + 2;
+	}
+	const pts = [
+		minX,
+		minY,
+		maxX,
+		minY,
+		maxX,
+		minY,
+		maxX,
+		maxY,
+		maxX,
+		maxY,
+		minX,
+		maxY,
+		minX,
+		maxY,
+		minX,
+		minY
+	];
+	OUT.set(pts);
+	return OUT;
+}
+//#endregion
 //#region src/2d/sync.ts
 function createSync2DScratch() {
 	return {
@@ -217,14 +268,44 @@ var Renderer2D = class {
 		});
 		this.webgl.setPixelRatio(rendering.pixelRatio);
 		this.webgl.info.autoReset = false;
-		this.debugLines = new LineSegments(new BufferGeometry(), new LineBasicMaterial({ color: "#00ff6e" }));
+		this.debugLines = new LineSegments(new BufferGeometry(), new LineBasicMaterial({
+			color: "#00ff6e",
+			transparent: true,
+			depthTest: false
+		}));
 		this.debugLines.frustumCulled = false;
 		this.debugLines.renderOrder = 9999;
 		this.debugLines.visible = false;
 		this.worldScene.add(this.debugLines);
+		this.selectionLines = new LineSegments(new BufferGeometry(), new LineBasicMaterial({
+			color: "#ffb020",
+			transparent: true,
+			depthTest: false
+		}));
+		this.selectionLines.frustumCulled = false;
+		this.selectionLines.renderOrder = 1e4;
+		this.selectionLines.visible = false;
+		this.worldScene.add(this.selectionLines);
 		this.disconnect = this.engine.updated.connect(() => this.render());
 	}
 	debugLines;
+	selectionLines;
+	syncSelectionOutline() {
+		const node = this.engine.debugSelection;
+		if (node && node.tree !== this.engine.scene?.tree) this.engine.debugSelection = null;
+		const current = this.engine.debugSelection;
+		const vertices = current ? selectionOutline2D(current) : null;
+		this.selectionLines.visible = vertices !== null;
+		if (!vertices) return;
+		const xyz = new Float32Array(vertices.length / 2 * 3);
+		for (let i = 0, j = 0; i < vertices.length; i += 2, j += 3) {
+			xyz[j] = vertices[i];
+			xyz[j + 1] = vertices[i + 1];
+			xyz[j + 2] = 0;
+		}
+		this.selectionLines.geometry.setAttribute("position", new BufferAttribute(xyz, 3));
+		this.selectionLines.geometry.getAttribute("position").needsUpdate = true;
+	}
 	syncDebugLines() {
 		let vertices = null;
 		for (const source of debugSources("2d")) {
@@ -246,6 +327,7 @@ var Renderer2D = class {
 		if (!scene) return;
 		this.webgl.info.reset();
 		this.syncDebugLines();
+		this.syncSelectionOutline();
 		if (scene.assets && !this.loadedAssetScenes.has(scene)) {
 			this.assets.load(scene.assets);
 			this.loadedAssetScenes.add(scene);

package/dist/debug.d.ts

@@ -1,4 +1,4 @@
-import { C as RendererStats, k as LogLevel, v as Engine } from "./behavior-e3kAmPGC.js";
+import { C as RendererStats, E as LogLevel, v as Engine } from "./behavior-Bod1AyJS.js";
 
 //#region src/debug/panel.d.ts
 /** Minimal document surface the overlay needs (injectable for tests). */