incanto 0.65.0 → 0.67.0

package/dist/{gameplay-D-H986A4.js → gameplay-CGSv-9XR.js}

@@ -1,7 +1,7 @@
-import { O as Node, P as Behavior, _ as SaveSlots, k as diagnose, n as loadScene, w as effectiveOrder, z as registerBehavior } from "./loader-lQDCwNag.js";
+import { O as Node, P as Behavior, _ as SaveSlots, k as diagnose, n as loadScene, w as effectiveOrder, z as registerBehavior } from "./loader-KZESOZmE.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as jsonClone } from "./json-CwwhxQgb.js";
-import { t as duplicateNode } from "./duplicate-CqSAtdrh.js";
+import { t as duplicateNode } from "./duplicate-B8QnX2-r.js";
 import { Color, CubeCamera, DepthTexture, DoubleSide, Euler, FloatType, Frustum, HalfFloatType, LinearMipmapLinearFilter, MathUtils, Matrix4, Mesh, MeshDepthMaterial, Object3D, PerspectiveCamera, Plane, PlaneGeometry, Quaternion, ShaderMaterial, Sphere, Vector2, Vector3, Vector4, WebGLCubeRenderTarget, WebGLRenderTarget } from "three";
 //#region src/3d/frustum.ts
 const scratchFrustum = new Frustum();
@@ -2534,6 +2534,36 @@ var StaticBody3D = class extends PhysicsBody3D {
 /** Sensor volume emitting `triggerEnter(other)` / `triggerExit(other)`. */
 var Area3D = class extends PhysicsBody3D {
 	static typeName = "Area3D";
+	/**
+	* Who is inside RIGHT NOW — the standing answer behind the enter/exit pair.
+	*
+	* Enter and exit tell you about crossings; a pressure plate, a capture point,
+	* a "how many enemies are in the blast" count and a shop trigger all want
+	* OCCUPANCY. Without this every one of them kept a private `Set` fed by the
+	* two signals, and had to guard it, because a body that is teleported or
+	* freed inside a sensor does not reliably announce its exit. Physics already
+	* knows; now it says.
+	*
+	* ```ts
+	* const load = this.area.overlapping()
+	*   .reduce((kg, b) => kg + ((b as RigidBody3D).mass ?? 0), 0);
+	* door.open = load >= 60;
+	* ```
+	*
+	* It reports everything the solver says is inside, STATIC WORLD INCLUDED — a
+	* plate laid into the floor genuinely contains the floor. Pass a group to ask
+	* the question you usually mean:
+	*
+	* ```ts
+	* area.overlapping('crate')   // only things tagged `crate`
+	* ```
+	*
+	* 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 RigidBody3D = class extends PhysicsBody3D {
@@ -2548,6 +2578,11 @@ var RigidBody3D = class extends PhysicsBody3D {
 			0,
 			0,
 			0
+		] },
+		angularVelocity: { default: [
+			0,
+			0,
+			0
 		] }
 	};
 	mass = 1;
@@ -2561,6 +2596,18 @@ var RigidBody3D = class extends PhysicsBody3D {
 		0,
 		0
 	];
+	/**
+	* rad/s about each world axis. Read back every step; write to spin.
+	*
+	* A puzzle builder could neither launch a spinning body nor read how fast a
+	* lever was swinging — only its angle, differenced by hand — because this had
+	* no counterpart to `linearVelocity`. `fixedRotation` pins it at zero.
+	*/
+	angularVelocity = [
+		0,
+		0,
+		0
+	];
 	/** @internal set by Physics3D */
 	_physics3d = null;
 	/** World-space impulse (kg·m/s) — the floating-capsule controller's verb. */
@@ -4711,7 +4758,7 @@ var Clickable = class extends Behavior {
 			if (this.hovering) this.setHover(false);
 			return;
 		}
-		const hit = picker(pointer.x, pointer.y);
+		const hit = engine.pickAt(pointer.x, pointer.y);
 		const over = hit !== null && this.isSelfOrDescendant(hit) && this.withinRange(hit);
 		if (over !== this.hovering) this.setHover(over);
 		if (engine.input.mouseJustPressed(this.button)) this.pressedHere = over;
@@ -4781,6 +4828,104 @@ group: { default: "player" } };
 	}
 };
 //#endregion
+//#region src/gameplay/currency.ts
+/**
+* Money. Earn it, spend it, and refuse what you cannot afford.
+*
+* `ScoreKeeper` is the closest thing the library had and it is a SCORE: it
+* counts up, it has no spend, no affordability question, and its counter is
+* already wired to the win condition. So a tower defense built on 0.65.0 wrote
+* its own wallet — and so does every shop, every build mode, every upgrade tree
+* and every economy game.
+*
+* `spend` is the whole point: it returns whether it went through, and emits
+* `refused` when it did not, so "you cannot afford that" is a wire rather than
+* a comparison every caller repeats and one caller forgets.
+*/
+var Currency = class extends Behavior {
+	static props = {
+		/** What you start with. */
+		amount: { default: 0 },
+		/** Ceiling (0 = none). */
+		max: { default: 0 }
+	};
+	static signals = [
+		"changed",
+		"earned",
+		"spent",
+		"refused"
+	];
+	amount = 0;
+	max = 0;
+	/** Can this be paid right now? */
+	canAfford(cost) {
+		return cost <= this.amount;
+	}
+	/** Pay `cost` if it is there. Returns whether it went through. */
+	spend(cost) {
+		if (!this.canAfford(cost)) {
+			this.emit("refused", cost);
+			return false;
+		}
+		this.amount -= cost;
+		this.emit("spent", cost);
+		this.emit("changed", this.amount);
+		return true;
+	}
+	/** Take payment in. */
+	earn(gain) {
+		this.amount = this.max > 0 ? Math.min(this.max, this.amount + gain) : this.amount + gain;
+		this.emit("earned", gain);
+		this.emit("changed", this.amount);
+	}
+	/** Set it outright (a shop that grants, a cheat, a restore). */
+	setAmount(next) {
+		this.amount = this.max > 0 ? Math.min(this.max, next) : next;
+		this.emit("changed", this.amount);
+	}
+	serialize() {
+		return { amount: this.amount };
+	}
+	deserialize(data) {
+		const d = data;
+		if (typeof d.amount === "number") this.amount = d.amount;
+	}
+};
+//#endregion
+//#region src/gameplay/free-target.ts
+/**
+* Free the ENTITY a despawning behavior belongs to, not just the node it sits on.
+*
+* `Lifetime` and `DamageOnContact` both remove their own node, which is right
+* when the behavior IS the thing. It is wrong for the composition the docs
+* teach: a node carries ONE script, so a bullet that both hurts and expires must
+* put those on CHILD nodes — and then each child quietly removed itself while
+* the bullet flew on forever, leaking a node per shot.
+*
+* `freeParent: true` is the other half. It is the same escape hatch the movement
+* behaviors call `moveParent`, named the same way for the same reason.
+*/
+function freeOwner(behavior, freeParent, who) {
+	if (!freeParent) {
+		behavior.node.queueFree();
+		return;
+	}
+	const parent = behavior.node.parent;
+	if (!parent) {
+		diagnose(behavior.node.tree?.engine ?? null, "error", `[incanto] ${who} on '${behavior.node.getPath()}': "freeParent" is set and this node has no parent to free — it is the scene root. Nothing was removed. Drop the prop, or move this behavior onto a child of the thing you meant to despawn.`);
+		return;
+	}
+	parent.queueFree();
+}
+/** The shared prop, so both behaviors declare it identically. */
+const FREE_PARENT_PROP = { 
+/**
+* Free this node's PARENT instead of this node — the composition where a
+* bullet carries `Projectile` and its children carry the damage and the
+* timer. Without it each child removes only itself and the bullet leaks.
+*/
+freeParent: { default: false } };
+//#endregion
 //#region src/gameplay/health.ts
 /**
 * Hit points with regeneration and post-hit invulnerability (i-frames) —
@@ -4871,11 +5016,19 @@ var Health = class extends Behavior {
 	* unlosable. Every checker was green on it, and `incanto-playtest` even
 	* reported `lost in 19/20` because a single `died` reads as a loss.
 	*
-	* Wire it where the life is spent:
+	* **Wire `reviveFull`, not this, to `lifeLost`.** `ScoreKeeper.loseLife()`
+	* emits `lifeLost` WITH the remaining life count, and this method's first
+	* parameter is the HP to come back at — so the documented recipe revived at
+	* 2 HP, then 1, then 0, and nothing warned (the wire-arity guard fires only
+	* when a handler is UNDER-fed, and `hp` is optional):
 	*
-	* ```json
-	* { "signal": "lifeLost", "from": "Score", "to": "Player", "handler": "revive" }
 	* ```
+	* death 1: lives=2  hp=2
+	* death 2: lives=1  hp=1
+	* death 3: lives=0  hp=0  dead=false   <- alive at zero HP
+	* ```
+	*
+	* Reach for `revive(hp)` when your game genuinely wants a partial comeback.
 	*
 	* A no-op on the living — reviving someone who never died would silently
 	* refill their health, which is a different feature and not this one.
@@ -4888,6 +5041,21 @@ var Health = class extends Behavior {
 		this.invulnTimer = this.invulnerableFor;
 		this.emit("revived", this.current);
 	}
+	/**
+	* Bring a dead one back at FULL health — the handler a life-lost wire wants.
+	*
+	* It exists because `revive` takes an optional `hp` and `lifeLost` carries the
+	* life count, so wiring the two silently made "you have 2 lives left" mean
+	* "come back at 2 HP". This takes no arguments, so no signal's payload can
+	* ever change what it means.
+	*
+	* ```json
+	* { "signal": "lifeLost", "from": "Score", "to": "Player", "handler": "reviveFull" }
+	* ```
+	*/
+	reviveFull() {
+		this.revive();
+	}
 	/** Drop to 0 and die immediately (ignores i-frames). */
 	kill() {
 		if (this.dead) return;
@@ -4971,7 +5139,9 @@ function onTriggerEnter(behavior, fn) {
 * - `repeatEvery` (seconds, 0 = off) re-damages targets that STAY overlapped —
 *   lava pools, poison clouds, an enemy standing on you. Contact events fire
 *   only on entry/exit; this is the "and it keeps hurting" knob.
-* - `destroySelf` frees the hazard after a hit (single-use projectiles).
+* - `destroySelf` frees the hazard after a hit (single-use projectiles), and
+*   `freeParent` makes that free the PARENT — a bullet whose hitbox is a child,
+*   which is the only shape a node-carries-one-script engine allows.
 *
 * SCORING PATTERN (clone-safe): wire the KILLER's `dealtDamage` →
 * `ScoreKeeper.addScore`. The weapon is usually a non-cloned node (it lives on
@@ -4989,7 +5159,8 @@ var DamageOnContact = class extends Behavior {
 		/** Re-damage targets still overlapping every N seconds (0 = entry only). */
 		repeatEvery: { default: 0 },
 		/** queueFree() this node after the first successful hit. */
-		destroySelf: { default: false }
+		destroySelf: { default: false },
+		...FREE_PARENT_PROP
 	};
 	static signals = ["dealtDamage"];
 	amount = 10;
@@ -4997,6 +5168,7 @@ var DamageOnContact = class extends Behavior {
 	oncePerTarget = true;
 	repeatEvery = 0;
 	destroySelf = false;
+	freeParent = false;
 	hit = /* @__PURE__ */ new WeakSet();
 	/** Targets currently overlapping → seconds until their next repeat tick. */
 	inside = /* @__PURE__ */ new Map();
@@ -5032,7 +5204,7 @@ var DamageOnContact = class extends Behavior {
 		if (this.oncePerTarget) this.hit.add(other);
 		found.health.damage(this.amount);
 		this.emit("dealtDamage", this.amount, found.owner);
-		if (this.destroySelf) this.node.queueFree();
+		if (this.destroySelf) freeOwner(this, this.freeParent, "DamageOnContact");
 	}
 };
 /**
@@ -5146,6 +5318,109 @@ function phaseOf(hour) {
 	return "dusk";
 }
 //#endregion
+//#region src/gameplay/face-target.ts
+/**
+* Turn toward the nearest thing in a group, and say when you are on it.
+*
+* A turret is the shape every tower defense, sentry gun, security camera and
+* idle-NPC-that-watches-you needs, and it could not be composed. `Chase`
+* already finds the nearest target and turns toward it — and then MOVES, which
+* is the one thing a turret must not do; `Patrol`/`Chase`'s `facePath` only
+* turns as a side effect of locomotion, so a stationary node cannot use it.
+* A tower defense built on 0.65.0 hand-wrote acquisition (~20 lines) and
+* turn-and-gate-the-shot (~15) because of that.
+*
+* `aimed` fires when the facing settles onto the target and `lostAim` when it
+* comes off, so "only fire while actually pointed at it" is a wire rather than
+* an angle comparison you write yourself.
+*/
+var FaceTarget = class extends Behavior {
+	static props = {
+		/** Group to acquire from — the nearest live member wins. */
+		targetGroup: {
+			default: "",
+			required: true
+		},
+		/** Only acquire within this distance (0 = anywhere). */
+		range: { default: 0 },
+		/** Node to TURN (usually a skin); empty turns this behavior's own node. */
+		facePath: {
+			default: "",
+			nodePath: true
+		},
+		/** Turn rate rad/s; 100 is an instant snap, as on the controller. */
+		turnSpeed: { default: 6 },
+		/** Degrees of slop that still counts as pointed at it. */
+		aimTolerance: { default: 6 }
+	};
+	static signals = [
+		"acquired",
+		"lostTarget",
+		"aimed",
+		"lostAim"
+	];
+	targetGroup = "";
+	range = 0;
+	facePath = "";
+	turnSpeed = 6;
+	aimTolerance = 6;
+	/** The node currently being tracked, or null. */
+	target = null;
+	/** True while the facing is within `aimTolerance` of the target. */
+	onTarget = false;
+	onReady() {
+		if (this.targetGroup === "") throw new IncantoError("PROP_TYPE_MISMATCH", `FaceTarget on '${this.node.getPath()}': "targetGroup" is required — it is the group this turret acquires from.`, { prop: "targetGroup" });
+	}
+	update(dt) {
+		const self = this.node;
+		if (!hasPosition$1(self)) return;
+		const found = this.nearest();
+		if (found !== this.target) {
+			this.target = found;
+			this.emit(found ? "acquired" : "lostTarget", found);
+			if (!found) this.setAim(false);
+		}
+		if (!found) return;
+		const turret = this.facePath === "" ? self : this.node.getNodeOrNull(this.facePath);
+		if (!turret) return;
+		const dir = found.position.map((v, i) => v - (self.position[i] ?? 0));
+		faceTravel(turret, dir, dt, this.turnSpeed);
+		this.setAim(this.pointedAt(turret, dir));
+	}
+	nearest() {
+		const self = this.node;
+		let best = null;
+		let bestD = Number.POSITIVE_INFINITY;
+		for (const candidate of this.node.tree?.getNodesInGroup(this.targetGroup) ?? []) {
+			if (!hasPosition$1(candidate)) continue;
+			const d = Math.hypot(...candidate.position.map((v, i) => v - (self.position[i] ?? 0)));
+			if (this.range > 0 && d > this.range) continue;
+			if (d < bestD) {
+				bestD = d;
+				best = candidate;
+			}
+		}
+		return best;
+	}
+	/** Is the turret's forward within tolerance of the direction to the target? */
+	pointedAt(turret, dir) {
+		const rot = turret.rotation;
+		const is3d = Array.isArray(rot);
+		const [a, b] = is3d ? [dir[0] ?? 0, dir[2] ?? 0] : [dir[0] ?? 0, dir[1] ?? 0];
+		const len = Math.hypot(a, b);
+		if (len < 1e-6) return true;
+		const yaw = (is3d ? rot[1] ?? 0 : rot ?? 0) * Math.PI / 180;
+		const fx = is3d ? Math.sin(yaw) : Math.cos(yaw);
+		const fy = is3d ? Math.cos(yaw) : Math.sin(yaw);
+		return (fx * a + fy * b) / len >= Math.cos(this.aimTolerance * Math.PI / 180);
+	}
+	setAim(on) {
+		if (on === this.onTarget) return;
+		this.onTarget = on;
+		this.emit(on ? "aimed" : "lostAim", this.target);
+	}
+};
+//#endregion
 //#region src/gameplay/float-away.ts
 /**
 * Rise, fade, and be gone — the second half of a damage number.
@@ -5780,6 +6055,10 @@ const hitStops = /* @__PURE__ */ new Map();
 * pickups that vanish. Accumulates `dt`; on elapse emits `expired` then
 * `queueFree()`s its node.
 *
+* `freeParent: true` frees the node's PARENT instead — the shape a bullet needs,
+* since a node carries ONE script so `Projectile`, the damage and the timer have
+* to live on separate nodes.
+*
 * With `startOnSignal: true` the countdown is armed manually via `startTimer()`
 * (wire a signal → `startTimer`), so the lifetime begins on an event rather
 * than at spawn.
@@ -5789,11 +6068,13 @@ var Lifetime = class extends Behavior {
 		/** Seconds before the node frees itself. */
 		seconds: { default: 1 },
 		/** Defer the countdown until `startTimer()` is called (default: start at ready). */
-		startOnSignal: { default: false }
+		startOnSignal: { default: false },
+		...FREE_PARENT_PROP
 	};
 	static signals = ["expired"];
 	seconds = 1;
 	startOnSignal = false;
+	freeParent = false;
 	elapsed = 0;
 	running = false;
 	fired = false;
@@ -5814,7 +6095,7 @@ var Lifetime = class extends Behavior {
 			this.fired = true;
 			this.running = false;
 			this.emit("expired");
-			this.node.queueFree();
+			freeOwner(this, this.freeParent, "Lifetime");
 		}
 	}
 };
@@ -7102,6 +7383,7 @@ const GAMEPLAY_BEHAVIORS = {
 	Health,
 	Lifetime,
 	ScoreKeeper,
+	Currency,
 	Pickup,
 	Collector,
 	DamageOnContact,
@@ -7111,6 +7393,7 @@ const GAMEPLAY_BEHAVIORS = {
 	FollowCamera,
 	Patrol,
 	Chase,
+	FaceTarget,
 	Wander,
 	ZombieAI,
 	MoveTo,
@@ -7131,4 +7414,4 @@ function registerGameplayBehaviors(opts) {
 	for (const [name, ctor] of Object.entries(GAMEPLAY_BEHAVIORS)) registerBehavior(name, ctor, { replace });
 }
 //#endregion
-export { Health as A, CharacterBody3D as B, restartScene as C, DayNight as D, FloatAway as E, Water3D as F, validateCollider3D as G, RigidBody3D as H, WATER_CUTOUT_MAX as I, colliderFootDrop as J, createCausticsQuad as K, WaterCutout3D as L, Chase as M, localFromWorld as N, phaseOf as O, worldPosition as P, rejectScale as R, goToScene as S, FollowCamera as T, StaticBody3D as U, PhysicsBody3D as V, Node3D as W, Cooldown as _, Wander as a, Interactable as b, SavePoint as c, Patrol as d, PathFollow as f, CameraShake as g, Lifetime as h, WaveSpawner as i, Collector as j, DamageOnContact as k, Projectile as l, MoveTo as m, registerGameplayBehaviors as n, Spawner as o, Oscillate as p, WATER_MAX_RIPPLES as q, ZombieAI as r, ScoreKeeper as s, GAMEPLAY_BEHAVIORS as t, Pickup as u, hitStop as v, tolerateUnknownAction as w, GameFlow as x, screenFlash as y, Area3D as z };
+export { DamageOnContact as A, rejectScale as B, restartScene as C, FaceTarget as D, FloatAway as E, localFromWorld as F, StaticBody3D as G, CharacterBody3D as H, worldPosition as I, createCausticsQuad as J, Node3D as K, Water3D as L, Currency as M, Collector as N, DayNight as O, Chase as P, WATER_CUTOUT_MAX as R, goToScene as S, FollowCamera as T, PhysicsBody3D as U, Area3D as V, RigidBody3D as W, colliderFootDrop as X, WATER_MAX_RIPPLES as Y, Cooldown as _, Wander as a, Interactable as b, SavePoint as c, Patrol as d, PathFollow as f, CameraShake as g, Lifetime as h, WaveSpawner as i, Health as j, phaseOf as k, Projectile as l, MoveTo as m, registerGameplayBehaviors as n, Spawner as o, Oscillate as p, validateCollider3D as q, ZombieAI as r, ScoreKeeper as s, GAMEPLAY_BEHAVIORS as t, Pickup as u, hitStop as v, tolerateUnknownAction as w, GameFlow as x, screenFlash as y, WaterCutout3D as z };

package/dist/gameplay.d.ts

@@ -1,4 +1,4 @@
-import { b as Engine, d as PropSchema, jt as Node, n as BehaviorCtor, t as Behavior } from "./behavior-CmMuQ6CL.js";
+import { b as Engine, d as PropSchema, jt as Node, n as BehaviorCtor, t as Behavior } from "./behavior-ZnfzKDo3.js";
 import { c as JsonValue, s as JsonObject } from "./schema-CFeioQRE.js";
 
 //#region src/gameplay/chase.d.ts
@@ -60,6 +60,37 @@ declare class Collector extends Behavior {
   override deserialize(data: JsonValue): void;
 }
 //#endregion
+//#region src/gameplay/currency.d.ts
+/**
+* Money. Earn it, spend it, and refuse what you cannot afford.
+*
+* `ScoreKeeper` is the closest thing the library had and it is a SCORE: it
+* counts up, it has no spend, no affordability question, and its counter is
+* already wired to the win condition. So a tower defense built on 0.65.0 wrote
+* its own wallet — and so does every shop, every build mode, every upgrade tree
+* and every economy game.
+*
+* `spend` is the whole point: it returns whether it went through, and emits
+* `refused` when it did not, so "you cannot afford that" is a wire rather than
+* a comparison every caller repeats and one caller forgets.
+*/
+declare class Currency extends Behavior {
+  static readonly props: PropSchema;
+  static readonly signals: readonly string[];
+  amount: number;
+  max: number;
+  /** Can this be paid right now? */
+  canAfford(cost: number): boolean;
+  /** Pay `cost` if it is there. Returns whether it went through. */
+  spend(cost: number): boolean;
+  /** Take payment in. */
+  earn(gain: number): void;
+  /** Set it outright (a shop that grants, a cheat, a restore). */
+  setAmount(next: number): void;
+  override serialize(): JsonValue;
+  override deserialize(data: JsonValue): void;
+}
+//#endregion
 //#region src/gameplay/health.d.ts
 /**
 * Hit points with regeneration and post-hit invulnerability (i-frames) —
@@ -112,16 +143,37 @@ declare class Health extends Behavior {
   * unlosable. Every checker was green on it, and `incanto-playtest` even
   * reported `lost in 19/20` because a single `died` reads as a loss.
   *
-  * Wire it where the life is spent:
+  * **Wire `reviveFull`, not this, to `lifeLost`.** `ScoreKeeper.loseLife()`
+  * emits `lifeLost` WITH the remaining life count, and this method's first
+  * parameter is the HP to come back at — so the documented recipe revived at
+  * 2 HP, then 1, then 0, and nothing warned (the wire-arity guard fires only
+  * when a handler is UNDER-fed, and `hp` is optional):
   *
-  * ```json
-  * { "signal": "lifeLost", "from": "Score", "to": "Player", "handler": "revive" }
+  * ```
+  * death 1: lives=2  hp=2
+  * death 2: lives=1  hp=1
+  * death 3: lives=0  hp=0  dead=false   <- alive at zero HP
   * ```
   *
+  * Reach for `revive(hp)` when your game genuinely wants a partial comeback.
+  *
   * A no-op on the living — reviving someone who never died would silently
   * refill their health, which is a different feature and not this one.
   */
   revive(hp?: number): void;
+  /**
+  * Bring a dead one back at FULL health — the handler a life-lost wire wants.
+  *
+  * It exists because `revive` takes an optional `hp` and `lifeLost` carries the
+  * life count, so wiring the two silently made "you have 2 lives left" mean
+  * "come back at 2 HP". This takes no arguments, so no signal's payload can
+  * ever change what it means.
+  *
+  * ```json
+  * { "signal": "lifeLost", "from": "Score", "to": "Player", "handler": "reviveFull" }
+  * ```
+  */
+  reviveFull(): void;
   /** Drop to 0 and die immediately (ignores i-frames). */
   kill(): void;
   /**
@@ -162,7 +214,9 @@ declare class Health extends Behavior {
 * - `repeatEvery` (seconds, 0 = off) re-damages targets that STAY overlapped —
 *   lava pools, poison clouds, an enemy standing on you. Contact events fire
 *   only on entry/exit; this is the "and it keeps hurting" knob.
-* - `destroySelf` frees the hazard after a hit (single-use projectiles).
+* - `destroySelf` frees the hazard after a hit (single-use projectiles), and
+*   `freeParent` makes that free the PARENT — a bullet whose hitbox is a child,
+*   which is the only shape a node-carries-one-script engine allows.
 *
 * SCORING PATTERN (clone-safe): wire the KILLER's `dealtDamage` →
 * `ScoreKeeper.addScore`. The weapon is usually a non-cloned node (it lives on
@@ -177,6 +231,7 @@ declare class DamageOnContact extends Behavior {
   oncePerTarget: boolean;
   repeatEvery: number;
   destroySelf: boolean;
+  freeParent: boolean;
   private readonly hit;
   /** Targets currently overlapping → seconds until their next repeat tick. */
   private readonly inside;
@@ -185,6 +240,42 @@ declare class DamageOnContact extends Behavior {
   private tryDamage;
 }
 //#endregion
+//#region src/gameplay/face-target.d.ts
+/**
+* Turn toward the nearest thing in a group, and say when you are on it.
+*
+* A turret is the shape every tower defense, sentry gun, security camera and
+* idle-NPC-that-watches-you needs, and it could not be composed. `Chase`
+* already finds the nearest target and turns toward it — and then MOVES, which
+* is the one thing a turret must not do; `Patrol`/`Chase`'s `facePath` only
+* turns as a side effect of locomotion, so a stationary node cannot use it.
+* A tower defense built on 0.65.0 hand-wrote acquisition (~20 lines) and
+* turn-and-gate-the-shot (~15) because of that.
+*
+* `aimed` fires when the facing settles onto the target and `lostAim` when it
+* comes off, so "only fire while actually pointed at it" is a wire rather than
+* an angle comparison you write yourself.
+*/
+declare class FaceTarget extends Behavior {
+  static readonly props: PropSchema;
+  static readonly signals: readonly string[];
+  targetGroup: string;
+  range: number;
+  facePath: string;
+  turnSpeed: number;
+  aimTolerance: number;
+  /** The node currently being tracked, or null. */
+  target: Node | null;
+  /** True while the facing is within `aimTolerance` of the target. */
+  onTarget: boolean;
+  override onReady(): void;
+  override update(dt: number): void;
+  private nearest;
+  /** Is the turret's forward within tolerance of the direction to the target? */
+  private pointedAt;
+  private setAim;
+}
+//#endregion
 //#region src/gameplay/follow-camera.d.ts
 /**
 * Make the node it sits on chase a target's position — THE camera-follow
@@ -239,6 +330,10 @@ declare class Interactable extends Behavior {
 * pickups that vanish. Accumulates `dt`; on elapse emits `expired` then
 * `queueFree()`s its node.
 *
+* `freeParent: true` frees the node's PARENT instead — the shape a bullet needs,
+* since a node carries ONE script so `Projectile`, the damage and the timer have
+* to live on separate nodes.
+*
 * With `startOnSignal: true` the countdown is armed manually via `startTimer()`
 * (wire a signal → `startTimer`), so the lifetime begins on an event rather
 * than at spawn.
@@ -248,6 +343,7 @@ declare class Lifetime extends Behavior {
   static readonly signals: readonly string[];
   seconds: number;
   startOnSignal: boolean;
+  freeParent: boolean;
   private elapsed;
   private running;
   private fired;
@@ -987,4 +1083,4 @@ declare function registerGameplayBehaviors(opts?: {
   replace?: boolean;
 }): void;
 //#endregion
-export { CameraShake, Chase, Collector, Cooldown, DamageOnContact, DayNight, type DayPhase, FloatAway, FollowCamera, GAMEPLAY_BEHAVIORS, GameFlow, type GameFlowState, Health, Interactable, Lifetime, MoveTo, Oscillate, PathFollow, Patrol, Pickup, Projectile, SavePoint, ScoreKeeper, Spawner, Wander, WaveSpawner, ZombieAI, goToScene, hitStop, phaseOf, registerGameplayBehaviors, restartScene, screenFlash };
+export { CameraShake, Chase, Collector, Cooldown, Currency, DamageOnContact, DayNight, type DayPhase, FaceTarget, FloatAway, FollowCamera, GAMEPLAY_BEHAVIORS, GameFlow, type GameFlowState, Health, Interactable, Lifetime, MoveTo, Oscillate, PathFollow, Patrol, Pickup, Projectile, SavePoint, ScoreKeeper, Spawner, Wander, WaveSpawner, ZombieAI, goToScene, hitStop, phaseOf, registerGameplayBehaviors, restartScene, screenFlash };

package/dist/gameplay.js

@@ -1,2 +1,2 @@
-import { A as Health, C as restartScene, D as DayNight, E as FloatAway, M as Chase, O as phaseOf, S as goToScene, T as FollowCamera, _ as Cooldown, a as Wander, b as Interactable, c as SavePoint, d as Patrol, f as PathFollow, g as CameraShake, h as Lifetime, i as WaveSpawner, j as Collector, k as DamageOnContact, l as Projectile, m as MoveTo, n as registerGameplayBehaviors, o as Spawner, p as Oscillate, r as ZombieAI, s as ScoreKeeper, t as GAMEPLAY_BEHAVIORS, u as Pickup, v as hitStop, x as GameFlow, y as screenFlash } from "./gameplay-D-H986A4.js";
-export { CameraShake, Chase, Collector, Cooldown, DamageOnContact, DayNight, FloatAway, FollowCamera, GAMEPLAY_BEHAVIORS, GameFlow, Health, Interactable, Lifetime, MoveTo, Oscillate, PathFollow, Patrol, Pickup, Projectile, SavePoint, ScoreKeeper, Spawner, Wander, WaveSpawner, ZombieAI, goToScene, hitStop, phaseOf, registerGameplayBehaviors, restartScene, screenFlash };
+import { A as DamageOnContact, C as restartScene, D as FaceTarget, E as FloatAway, M as Currency, N as Collector, O as DayNight, P as Chase, S as goToScene, T as FollowCamera, _ as Cooldown, a as Wander, b as Interactable, c as SavePoint, d as Patrol, f as PathFollow, g as CameraShake, h as Lifetime, i as WaveSpawner, j as Health, k as phaseOf, l as Projectile, m as MoveTo, n as registerGameplayBehaviors, o as Spawner, p as Oscillate, r as ZombieAI, s as ScoreKeeper, t as GAMEPLAY_BEHAVIORS, u as Pickup, v as hitStop, x as GameFlow, y as screenFlash } from "./gameplay-CGSv-9XR.js";
+export { CameraShake, Chase, Collector, Cooldown, Currency, DamageOnContact, DayNight, FaceTarget, FloatAway, FollowCamera, GAMEPLAY_BEHAVIORS, GameFlow, Health, Interactable, Lifetime, MoveTo, Oscillate, PathFollow, Patrol, Pickup, Projectile, SavePoint, ScoreKeeper, Spawner, Wander, WaveSpawner, ZombieAI, goToScene, hitStop, phaseOf, registerGameplayBehaviors, restartScene, screenFlash };