@zylem/game-lib 0.9.6 → 0.9.7

package/dist/debug.d.ts

@@ -1,13 +1,13 @@
-export { D as DEFAULT_SNAP_SETTINGS, w as DebugEntityResolver, v as DebugTools, S as SnapSettings, T as TRANSFORM_TOOLS, x as TransformTool, d as debugState, k as getHoveredEntity, j as getHoveredEntityId, e as getSelectedEntity, g as getSelectedEntityId, h as getSelectedEntityIds, m as getSnapSettings, t as isPickMode, u as isTransformTool, r as registerDebugEntityResolver, l as resolveDebugEntity, p as setAddType, s as setDebugTool, o as setGridVisible, i as setHoveredEntityId, a as setPaused, q as setPickMode, b as setSelectedEntity, c as setSelectedEntityId, f as setSelectedEntityIds, n as setSnapSettings } from './debug-state-DhVkY2aM.js';
-import * as three from 'three';
-import { Group, Scene, Vector3, Camera, Object3D } from 'three';
+export { D as DEFAULT_SNAP_SETTINGS, w as DebugEntityResolver, v as DebugTools, S as SnapSettings, T as TRANSFORM_TOOLS, x as TransformTool, d as debugState, k as getHoveredEntity, j as getHoveredEntityId, e as getSelectedEntity, g as getSelectedEntityId, h as getSelectedEntityIds, m as getSnapSettings, t as isPickMode, u as isTransformTool, r as registerDebugEntityResolver, l as resolveDebugEntity, p as setAddType, s as setDebugTool, o as setGridVisible, i as setHoveredEntityId, a as setPaused, q as setPickMode, b as setSelectedEntity, c as setSelectedEntityId, f as setSelectedEntityIds, n as setSnapSettings } from './debug-state-BgX5Q0Ff.js';
+export { G as GizmoAxis, a as GizmoDelta, b as GizmoMode, d as GizmoRay, T as TransformGizmo, c as closestAxisValue, i as intersectPlane } from './transform-gizmo-DappLQ9w.js';
+import { Scene, Object3D, Vector3 } from 'three';
 import { c as Vec3 } from './vector-D3eDzvcA.js';
-import { G as GameEntity } from './entity-DC0P747T.js';
+import { G as GameEntity } from './entity-CY75JJSw.js';
 export { S as SELECTION_BOUNDS_MARGIN, a as SELECTION_THIN_AXIS_FRACTION, c as SELECTION_THIN_AXIS_MAX, b as SELECTION_THIN_AXIS_MIN, d as SelectionBoundsProvider, m as measureObjectSelectionBounds, p as padSelectionBounds, r as resolveSelectionBounds } from './selection-bounds-BKmSo9aG.js';
 import { WebGPURenderer } from 'three/webgpu';
 import '@zylem/behaviors/core';
 import './simulation-body-zQw-emOr.js';
-import './material-CxxAyJYp.js';
+import './material-D1IVeQc5.js';
 import './collision-builder-BckxkdmA.js';
 import './base-node-idopiSw5.js';
 import './base-node-life-cycle-BK9xebT9.js';
@@ -15,125 +15,6 @@ import './stage-transition-CmGpV4tc.js';
 import './events.js';
 import 'mitt';
 
-type GizmoMode = 'translate' | 'rotate' | 'scale';
-/** Single-axis, planar, and uniform handle identifiers. */
-type GizmoAxis = 'x' | 'y' | 'z' | 'xy' | 'yz' | 'xz' | 'xyz';
-/** A raw, unsnapped drag result in world space. */
-type GizmoDelta = {
-    kind: 'translate';
-    offset: Vector3;
-} | {
-    kind: 'rotate';
-    axis: Vector3;
-    angle: number;
-} | {
-    kind: 'scale';
-    factor: Vector3;
-};
-/** A mouse ray in world space. */
-interface GizmoRay {
-    origin: Vector3;
-    direction: Vector3;
-}
-/**
- * Closest point along an infinite line to a ray, as a distance along the line.
- *
- * Returns `null` when the ray is close enough to parallel with the line that the
- * closest point becomes unstable; see {@link MAX_DRAG_GAIN}.
- */
-declare function closestAxisValue(ray: GizmoRay, origin: Vector3, axis: Vector3): number | null;
-/**
- * Intersect a ray with the plane through `origin` with the given normal.
- *
- * Returns `null` for a plane seen too close to edge-on, where the hit point
- * races away across the plane for very little pointer motion.
- */
-declare function intersectPlane(ray: GizmoRay, origin: Vector3, normal: Vector3, target: Vector3): Vector3 | null;
-declare class TransformGizmo {
-    /** Root added to the scene; carries the pivot transform. */
-    readonly root: Group<three.Object3DEventMap>;
-    private scene;
-    private modeGroups;
-    private handles;
-    private materials;
-    private geometries;
-    private mode;
-    private highlighted;
-    private drag;
-    private raycaster;
-    constructor();
-    addTo(scene: Scene): void;
-    removeFromScene(): void;
-    dispose(): void;
-    setMode(mode: GizmoMode): void;
-    getMode(): GizmoMode;
-    /** Place the gizmo at a pivot and show it. */
-    show(pivot: Vector3): void;
-    hide(): void;
-    get visible(): boolean;
-    get pivot(): Vector3;
-    /**
-     * Keep the gizmo a constant size on screen.
-     *
-     * A world-sized gizmo is unusable in an orbit view: it fills the screen up
-     * close and disappears from a distance.
-     */
-    update(camera: Camera): void;
-    /**
-     * Which handle a ray hits, or `null`.
-     *
-     * Raycasts the gizmo's own meshes rather than the physics world. Handles are
-     * render-only objects with no colliders, so the physics raycast used to pick
-     * entities cannot see them at all.
-     */
-    pick(ray: GizmoRay): GizmoAxis | null;
-    /**
-     * Whether a handle can be dragged from the current viewing angle.
-     *
-     * Each handle type degenerates differently: an arrow aimed at the camera has
-     * no screen-space direction left to follow, while a plane quad or rotation
-     * ring seen edge-on turns a pixel of motion into a huge sweep across it.
-     */
-    private isHandleDraggable;
-    /** Tint a handle to show it is hovered or being dragged. */
-    setHighlight(axis: GizmoAxis | null): void;
-    /**
-     * Begin a drag on a handle.
-     *
-     * @returns `false` when the gesture cannot be tracked (a near-parallel view
-     * of the drag axis), so the caller can ignore the press rather than start a
-     * drag that would jump.
-     */
-    beginDrag(axis: GizmoAxis, ray: GizmoRay, camera: Camera): boolean;
-    /** Raw delta for the current pointer position, or `null` when unusable. */
-    updateDrag(ray: GizmoRay, camera: Camera): GizmoDelta | null;
-    endDrag(): void;
-    get isDragging(): boolean;
-    get draggingAxis(): GizmoAxis | null;
-    private isPlaneAxis;
-    /** Signed angle of the ray's hit point around `normal`, in radians. */
-    private angleOnPlane;
-    /** Distance from pivot to the ray hit on the camera-facing plane. */
-    private cameraPlaneRadius;
-    private applyModeVisibility;
-    private makeMaterial;
-    private track;
-    /**
-     * An invisible, generously sized mesh used only for hit testing.
-     *
-     * The visible shafts and rings are a couple of pixels wide, which is
-     * miserable to click. The raycaster still reaches `visible: false` meshes,
-     * so picking accuracy is decoupled from how thin the handle looks.
-     */
-    private makePicker;
-    private orientAlongAxis;
-    private buildTranslate;
-    private positionPlaneHandle;
-    private buildRotate;
-    private orientRing;
-    private buildScale;
-}
-
 /**
  * The y=0 construction plane, drawn so the snap lattice is legible.
  *
@@ -287,4 +168,4 @@ declare class EntityThumbnailCache {
 /** Shared cache used by the running game to feed editor entity payloads. */
 declare const entityThumbnailCache: EntityThumbnailCache;
 
-export { ConstructionGrid, type EntityFocusContext, EntityThumbnailCache, type EntityThumbnailCacheEntry, type EntityThumbnailResult, type GizmoAxis, type GizmoDelta, type GizmoMode, type GizmoRay, type Quat, TransformGizmo, closestAxisValue, degreesToRadians, entityThumbnailCache, eulerToQuaternion, focusEntity, intersectPlane, quaternionToEuler, radiansToDegrees, registerEntityFocusContext, snapScale, snapToIncrement, snapVec3 };
+export { ConstructionGrid, type EntityFocusContext, EntityThumbnailCache, type EntityThumbnailCacheEntry, type EntityThumbnailResult, type Quat, degreesToRadians, entityThumbnailCache, eulerToQuaternion, focusEntity, quaternionToEuler, radiansToDegrees, registerEntityFocusContext, snapScale, snapToIncrement, snapVec3 };

package/dist/{entity-DC0P747T.d.ts → entity-CY75JJSw.d.ts}

@@ -1,8 +1,8 @@
-import { BufferGeometry, Material, Mesh, Group, Vector3, Color, ShaderMaterial } from 'three';
+import { BufferGeometry, Material, Mesh, Group, Vector3, Object3D, Color, ShaderMaterial } from 'three';
 import { SimulationColliderDefinition, TransformState, SimulationBodyDefinition, MoveableEntity, BehaviorRuntime, Vector, BehaviorDescriptor, BehaviorHandle, BehaviorRef } from '@zylem/behaviors/core';
 import { a as SimulationBody } from './simulation-body-zQw-emOr.js';
-import { c as Vec3, e as Vec3Input, b as Vec2Input } from './vector-D3eDzvcA.js';
-import { M as MaterialBuilder, e as MaterialOptions } from './material-CxxAyJYp.js';
+import { c as Vec3, e as Vec3Input, b as Vec2Input, d as Vec3Components } from './vector-D3eDzvcA.js';
+import { M as MaterialBuilder, g as MaterialOptions } from './material-D1IVeQc5.js';
 import { C as CollisionBuilder, L as LockAxesInput, a as CollisionOptions } from './collision-builder-BckxkdmA.js';
 import { B as BaseNode, N as NodeInterface } from './base-node-idopiSw5.js';
 import { a as SetupContext, U as UpdateContext, D as DestroyContext, k as LoadedContext, l as CleanupContext } from './base-node-life-cycle-BK9xebT9.js';
@@ -268,6 +268,68 @@ interface Action {
     reset(): void;
 }
 
+/**
+ * Pointer roles for gameplay placement.
+ *
+ * A hover or droppable area is metadata on an entity plus a box the cursor ray
+ * is tested against. The physics raycast is the wrong tool for this: it skips
+ * sensors, and an invisible hotspot should not have to be a solid collider to
+ * be clickable. Areas with a mesh already in the scene use that mesh's world
+ * bounds; everyone else uses `options.position` and `options.size`.
+ */
+
+/** Anything the stage can test with a pointer ray. GameEntity satisfies this. */
+interface PointerTargetEntity {
+    uuid: string;
+    options?: {
+        position?: Vec3Input;
+        size?: Vec3Input;
+    };
+    group?: Object3D;
+    mesh?: Object3D;
+    getPose?: () => {
+        position: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    } | null;
+}
+/** Where the cursor is, and whether an armed placement would accept it. */
+interface PointerAreaContext {
+    area: PointerTargetEntity;
+    position: Vec3Components;
+    normal: Vec3Components;
+    /** True when nothing is armed, or when the armed payload may land here. */
+    valid: boolean;
+    payload: unknown;
+}
+/** The pose a click would commit, including when it is not over an area. */
+interface PlacementPointContext {
+    position: Vec3Components;
+    normal: Vec3Components;
+    area: PointerTargetEntity | null;
+    valid: boolean;
+    payload: unknown;
+}
+interface HoverAreaOptions {
+    onEnter?: (ctx: PointerAreaContext) => void;
+    onLeave?: (ctx: PointerAreaContext) => void;
+    onMove?: (ctx: PointerAreaContext) => void;
+    onClick?: (ctx: PointerAreaContext) => void;
+}
+interface DroppableAreaOptions extends HoverAreaOptions {
+    /** Omit to accept every payload. */
+    accepts?: (payload: unknown, area: PointerTargetEntity) => boolean;
+    /** Called after a placement commits on this area. Not a second spawn. */
+    onDrop?: (ctx: PlacementPointContext) => void;
+    /**
+     * `area` sits the preview on this area's center (a grid cell).
+     * `hit` keeps it on the ray's intersection with the area.
+     */
+    placeAt?: 'area' | 'hit';
+}
+
 interface CollisionContext<T, O extends GameEntityOptions, TGlobals extends Record<string, unknown> = any> {
     entity: T;
     other: GameEntity<O | any>;
@@ -553,6 +615,18 @@ declare class GameEntity<O extends GameEntityOptions> extends BaseNode<O> implem
      */
     onCollision(callback: (params: CollisionContext<this, O>) => void, options?: CollisionRegistrationOptions): this;
     onCollision(...callbacks: ((params: CollisionContext<this, O>) => void)[]): this;
+    /**
+     * This entity is a pointer hotspot. The stage reports enter, leave, move,
+     * and click while the cursor ray is over its bounds. One pointer role per
+     * entity; a later {@link droppableArea} replaces this one.
+     */
+    hoverArea(options?: HoverAreaOptions): this;
+    /**
+     * This entity accepts a placement drop. Includes the hover callbacks.
+     * `accepts` defaults to every payload. `onDrop` runs after a commit and
+     * does not spawn a second entity.
+     */
+    droppableArea(options?: DroppableAreaOptions): this;
     /**
      * Use a behavior on this entity via typed descriptor.
      * Behaviors will be auto-registered as systems when the entity is spawned.
@@ -680,4 +754,4 @@ declare class GameEntity<O extends GameEntityOptions> extends BaseNode<O> implem
  */
 declare function create(options?: Partial<GameEntityOptions>): GameEntity<GameEntityOptions>;
 
-export { type Action as A, EntityMeshBuilder as B, type CollisionComponent as C, EntityCollisionBuilder as D, EntityBuilder as E, GameEntity as G, type GameEntityOptions as a, boxCollision as b, create as c, coneCollision as d, cylinderCollision as e, pillCollision as f, planeCollision as g, rotateYEuler as h, rotateEuler as i, rotateX as j, rotateY as k, rotateZ as l, setRotationY as m, setRotationX as n, setRotationZ as o, pyramidCollision as p, setRotationDegrees as q, rotateInDirection as r, sphereCollision as s, setRotationDegreesY as t, setRotationDegreesX as u, setRotationDegreesZ as v, setRotation as w, getRotation as x, GameEntityLifeCycle as y, zoneCollision as z };
+export { type Action as A, getRotation as B, type CollisionComponent as C, type DroppableAreaOptions as D, GameEntityLifeCycle as E, EntityBuilder as F, GameEntity as G, type HoverAreaOptions as H, EntityMeshBuilder as I, EntityCollisionBuilder as J, type PointerAreaContext as P, type PlacementPointContext as a, type PointerTargetEntity as b, create as c, type GameEntityOptions as d, boxCollision as e, coneCollision as f, cylinderCollision as g, pillCollision as h, planeCollision as i, rotateYEuler as j, rotateEuler as k, rotateX as l, rotateY as m, rotateZ as n, setRotationY as o, pyramidCollision as p, setRotationX as q, rotateInDirection as r, sphereCollision as s, setRotationZ as t, setRotationDegrees as u, setRotationDegreesY as v, setRotationDegreesX as w, setRotationDegreesZ as x, setRotation as y, zoneCollision as z };

package/dist/{entity-type-map-B0S5cfv7.d.ts → entity-type-map-BMaPY8cd.d.ts}

@@ -1,9 +1,9 @@
 import { Vector3, Sprite, Texture, Color, Box3, Object3D, ColorRepresentation, Light, Fog, FogExp2, Scene, Raycaster } from 'three';
 import { B as BaseNode } from './base-node-idopiSw5.js';
-import { G as GameEntity, a as GameEntityOptions } from './entity-DC0P747T.js';
+import { G as GameEntity, d as GameEntityOptions } from './entity-CY75JJSw.js';
 import { d as Vec3Components, e as Vec3Input, b as Vec2Input } from './vector-D3eDzvcA.js';
 import { U as UpdateContext, a as SetupContext, D as DestroyContext, l as CleanupContext } from './base-node-life-cycle-BK9xebT9.js';
-import { T as TexturePath, e as MaterialOptions } from './material-CxxAyJYp.js';
+import { T as TexturePath, g as MaterialOptions } from './material-D1IVeQc5.js';
 import { d as SelectionBoundsProvider } from './selection-bounds-BKmSo9aG.js';
 import { Simulation } from '@zylem/behaviors/core';
 import { E as Entity } from './entity-BIf_a4dl.js';

package/dist/entity.d.ts

@@ -1,11 +1,11 @@
-import { ak as ScreenAnchor } from './entity-type-map-B0S5cfv7.js';
-export { A as ACTOR_TYPE, a1 as AmbientLightOptions, B as BOX_TYPE, F as CONE_TYPE, L as CYLINDER_TYPE, C as CollisionShapeType, D as DISK_TYPE, a3 as DirectionalLightOptions, am as EntityForType, al as EntityTypeMap, a9 as FOG_TYPE, a2 as HemisphereLightOptions, $ as LIGHT_TYPE, ac as LINE_TYPE, a6 as LightShadowOptions, af as LinePickResult, o as OnEnterParams, p as OnExitParams, O as OnHeldParams, W as PARTICLE_SYSTEM_TYPE, Q as PILL_TYPE, P as PLANE_TYPE, I as PYRAMID_TYPE, a4 as PointLightOptions, R as RECT_TYPE, w as RectShape, S as SPHERE_TYPE, f as SPRITE_TYPE, a5 as SpotLightOptions, h as SpriteAnimation, g as SpriteImage, i as SpriteSheet, T as TEXT_TYPE, n as ZONE_TYPE, r as ZylemActor, Z as ZylemBox, E as ZylemCone, K as ZylemCylinder, y as ZylemDisk, a8 as ZylemFog, ai as ZylemFogHeightOptions, aj as ZylemFogNoiseOptions, ag as ZylemFogOptions, ah as ZylemFogType, _ as ZylemLight, a0 as ZylemLightOptions, ab as ZylemLine, ae as ZylemLineOptions, V as ZylemParticleSystem, X as ZylemParticleSystemOptions, N as ZylemPill, k as ZylemPlane, H as ZylemPyramid, v as ZylemRect, b as ZylemSphere, e as ZylemSprite, t as ZylemText, m as ZylemZone, q as createActor, c as createBox, z as createCone, J as createCylinder, x as createDisk, a7 as createFog, Y as createLight, aa as createLine, U as createParticleSystem, M as createPill, j as createPlane, G as createPyramid, u as createRect, a as createSphere, d as createSprite, s as createText, l as createZone, ad as pickZylemLine } from './entity-type-map-B0S5cfv7.js';
-import { G as GameEntity, a as GameEntityOptions, E as EntityBuilder, B as EntityMeshBuilder, D as EntityCollisionBuilder } from './entity-DC0P747T.js';
-export { C as CollisionComponent, b as boxCollision, d as coneCollision, c as create, e as cylinderCollision, f as pillCollision, g as planeCollision, p as pyramidCollision, s as sphereCollision, z as zoneCollision } from './entity-DC0P747T.js';
+import { ak as ScreenAnchor } from './entity-type-map-BMaPY8cd.js';
+export { A as ACTOR_TYPE, a1 as AmbientLightOptions, B as BOX_TYPE, F as CONE_TYPE, L as CYLINDER_TYPE, C as CollisionShapeType, D as DISK_TYPE, a3 as DirectionalLightOptions, am as EntityForType, al as EntityTypeMap, a9 as FOG_TYPE, a2 as HemisphereLightOptions, $ as LIGHT_TYPE, ac as LINE_TYPE, a6 as LightShadowOptions, af as LinePickResult, o as OnEnterParams, p as OnExitParams, O as OnHeldParams, W as PARTICLE_SYSTEM_TYPE, Q as PILL_TYPE, P as PLANE_TYPE, I as PYRAMID_TYPE, a4 as PointLightOptions, R as RECT_TYPE, w as RectShape, S as SPHERE_TYPE, f as SPRITE_TYPE, a5 as SpotLightOptions, h as SpriteAnimation, g as SpriteImage, i as SpriteSheet, T as TEXT_TYPE, n as ZONE_TYPE, r as ZylemActor, Z as ZylemBox, E as ZylemCone, K as ZylemCylinder, y as ZylemDisk, a8 as ZylemFog, ai as ZylemFogHeightOptions, aj as ZylemFogNoiseOptions, ag as ZylemFogOptions, ah as ZylemFogType, _ as ZylemLight, a0 as ZylemLightOptions, ab as ZylemLine, ae as ZylemLineOptions, V as ZylemParticleSystem, X as ZylemParticleSystemOptions, N as ZylemPill, k as ZylemPlane, H as ZylemPyramid, v as ZylemRect, b as ZylemSphere, e as ZylemSprite, t as ZylemText, m as ZylemZone, q as createActor, c as createBox, z as createCone, J as createCylinder, x as createDisk, a7 as createFog, Y as createLight, aa as createLine, U as createParticleSystem, M as createPill, j as createPlane, G as createPyramid, u as createRect, a as createSphere, d as createSprite, s as createText, l as createZone, ad as pickZylemLine } from './entity-type-map-BMaPY8cd.js';
+import { G as GameEntity, d as GameEntityOptions, F as EntityBuilder, I as EntityMeshBuilder, J as EntityCollisionBuilder } from './entity-CY75JJSw.js';
+export { C as CollisionComponent, e as boxCollision, f as coneCollision, c as create, g as cylinderCollision, h as pillCollision, i as planeCollision, p as pyramidCollision, s as sphereCollision, z as zoneCollision } from './entity-CY75JJSw.js';
 import { Color, Mesh } from 'three';
 import { B as BaseNode } from './base-node-idopiSw5.js';
 import { b as Vec2Input, e as Vec3Input } from './vector-D3eDzvcA.js';
-import { e as MaterialOptions } from './material-CxxAyJYp.js';
+import { g as MaterialOptions } from './material-D1IVeQc5.js';
 import './base-node-life-cycle-BK9xebT9.js';
 import './stage-transition-CmGpV4tc.js';
 import './selection-bounds-BKmSo9aG.js';

package/dist/entity.js

@@ -1 +1 @@
-import{a as ma,b as na,c as oa,d as pa,e as qa}from"./chunk-Y23IJJPD.js";import{a as ba,b as ca,c as da,d as ea,e as fa,f as ga,g as ha,h as ia,i as ja,j as ka,l as la}from"./chunk-YRHRMVHS.js";import{a as X,b as Y,c as Z,d as _,e as $,f as aa}from"./chunk-FUZDTRCU.js";import{A as J,B as K,C as L,D as M,E as N,J as R,K as S,L as T,M as U,N as V,O as W,b as j,c as k,d as l,e as m,f as n,g as o,h as p,i as q,j as r,k as s,l as t,m as u,n as v,o as w,p as x,q as y,r as z,s as A,t as B,u as C,v as D,w as E,x as F,y as G,z as I}from"./chunk-5V52N34T.js";import{A as O,B as P,C as Q,c as a,d as b,e as c,f as d,g as e,h as f,i as g,j as h,u as i,z as H}from"./chunk-VXE3CV3K.js";import"./chunk-6FGXC4T6.js";import"./chunk-AIQ6IVT5.js";import"./chunk-QXVH6POE.js";import"./chunk-UUOPT2N4.js";import"./chunk-EVYHPR3J.js";import"./chunk-4QLJUQSJ.js";import"./chunk-7WRQ2UAN.js";import"./chunk-XRP4JJXL.js";import"./chunk-WOT6VMZA.js";export{X as ACTOR_TYPE,p as BOX_TYPE,v as CONE_TYPE,B as CYLINDER_TYPE,I as DISK_TYPE,_ as FOG_TYPE,U as LIGHT_TYPE,ha as LINE_TYPE,ma as PARTICLE_SYSTEM_TYPE,E as PILL_TYPE,L as PLANE_TYPE,y as PYRAMID_TYPE,R as RECT_TYPE,s as SPHERE_TYPE,ea as SPRITE_TYPE,ba as TEXT_TYPE,O as ZONE_TYPE,Y as ZylemActor,q as ZylemBox,w as ZylemCone,C as ZylemCylinder,J as ZylemDisk,$ as ZylemFog,V as ZylemLight,ja as ZylemLine,na as ZylemParticleSystem,F as ZylemPill,M as ZylemPlane,z as ZylemPyramid,S as ZylemRect,t as ZylemSphere,fa as ZylemSprite,ca as ZylemText,P as ZylemZone,a as boxCollision,j as boxMesh,c as coneCollision,l as coneMesh,i as create,Z as createActor,r as createBox,x as createCone,pa as createCooldownIcon,D as createCylinder,K as createDisk,H as createEntity,la as createEntityFactory,aa as createFog,W as createLight,ka as createLine,oa as createParticleSystem,G as createPill,N as createPlane,A as createPyramid,T as createRect,u as createSphere,ga as createSprite,da as createText,Q as createZone,e as cylinderCollision,n as cylinderMesh,qa as destroy,ia as pickZylemLine,f as pillCollision,o as pillMesh,g as planeCollision,d as pyramidCollision,m as pyramidMesh,b as sphereCollision,k as sphereMesh,h as zoneCollision};
+import{a as ma,b as na,c as oa,d as pa,e as qa}from"./chunk-CVKEWWIH.js";import{a as ba,b as ca,c as da,d as ea,e as fa,f as ga,g as ha,h as ia,i as ja,j as ka,l as la}from"./chunk-63T3K5EQ.js";import{a as X,b as Y,c as Z,d as _,e as $,f as aa}from"./chunk-M2FZ224T.js";import{A as J,B as K,C as L,D as M,E as N,J as R,K as S,L as T,M as U,N as V,O as W,b as j,c as k,d as l,e as m,f as n,g as o,h as p,i as q,j as r,k as s,l as t,m as u,n as v,o as w,p as x,q as y,r as z,s as A,t as B,u as C,v as D,w as E,x as F,y as G,z as I}from"./chunk-DYD7MDWO.js";import{d as H,e as O,f as P,g as Q}from"./chunk-IHGRFR4H.js";import{E as i,c as a,d as b,e as c,f as d,g as e,h as f,i as g,j as h}from"./chunk-AJSIVGDX.js";import"./chunk-EVYHPR3J.js";import"./chunk-XRP4JJXL.js";import"./chunk-Q22Z4PBD.js";import"./chunk-AIQ6IVT5.js";import"./chunk-QXVH6POE.js";import"./chunk-UUOPT2N4.js";import"./chunk-4QLJUQSJ.js";import"./chunk-7WRQ2UAN.js";import"./chunk-WOT6VMZA.js";export{X as ACTOR_TYPE,p as BOX_TYPE,v as CONE_TYPE,B as CYLINDER_TYPE,I as DISK_TYPE,_ as FOG_TYPE,U as LIGHT_TYPE,ha as LINE_TYPE,ma as PARTICLE_SYSTEM_TYPE,E as PILL_TYPE,L as PLANE_TYPE,y as PYRAMID_TYPE,R as RECT_TYPE,s as SPHERE_TYPE,ea as SPRITE_TYPE,ba as TEXT_TYPE,O as ZONE_TYPE,Y as ZylemActor,q as ZylemBox,w as ZylemCone,C as ZylemCylinder,J as ZylemDisk,$ as ZylemFog,V as ZylemLight,ja as ZylemLine,na as ZylemParticleSystem,F as ZylemPill,M as ZylemPlane,z as ZylemPyramid,S as ZylemRect,t as ZylemSphere,fa as ZylemSprite,ca as ZylemText,P as ZylemZone,a as boxCollision,j as boxMesh,c as coneCollision,l as coneMesh,i as create,Z as createActor,r as createBox,x as createCone,pa as createCooldownIcon,D as createCylinder,K as createDisk,H as createEntity,la as createEntityFactory,aa as createFog,W as createLight,ka as createLine,oa as createParticleSystem,G as createPill,N as createPlane,A as createPyramid,T as createRect,u as createSphere,ga as createSprite,da as createText,Q as createZone,e as cylinderCollision,n as cylinderMesh,qa as destroy,ia as pickZylemLine,f as pillCollision,o as pillMesh,g as planeCollision,d as pyramidCollision,m as pyramidMesh,b as sphereCollision,k as sphereMesh,h as zoneCollision};

package/dist/{game-mu6OSCrq.d.ts → game-CmkhPP-9.d.ts}

@@ -1,14 +1,14 @@
 import { e as InputPlayerNumber, f as InputProvider, I as Inputs, a as SetupContext, U as UpdateContext, D as DestroyContext, m as IGame, h as SetupFunction, g as UpdateFunction, j as DestroyFunction, S as StageNavigationOptions } from './base-node-life-cycle-BK9xebT9.js';
 import { G as GameInputConfig, B as BaseGlobals, Z as ZylemGameConfig } from './game-interfaces-vF5sRi1n.js';
 import { B as BaseNode } from './base-node-idopiSw5.js';
-import { B as BaseEntityInterface, q as Stage } from './stage-B_KdSEK6.js';
-import { y as GameEntityLifeCycle } from './entity-DC0P747T.js';
+import { B as BaseEntityInterface, q as Stage } from './stage-CCGJh9TD.js';
+import { E as GameEntityLifeCycle } from './entity-CY75JJSw.js';
 import { Color, Vector3 } from 'three';
 import { d as Vec3Components } from './vector-D3eDzvcA.js';
 import { D as DefaultTouchControlsOptions } from './default-controls-CAKJ5zlo.js';
 import { GameEvents } from './events.js';
 import { Simulation } from '@zylem/behaviors/core';
-import { l as ZylemCamera, R as RendererManager } from './zylem-camera-CWhIGXlW.js';
+import { l as ZylemCamera, R as RendererManager } from './zylem-camera-BA3VPFlS.js';
 import { S as StageTransitionConfig } from './stage-transition-CmGpV4tc.js';
 
 declare class InputManager {

package/dist/game-default-LAGMEHNQ.js

@@ -0,0 +1 @@
+import{z as e}from"./chunk-UKNMIHAP.js";import"./chunk-KL7NGD76.js";import"./chunk-WBQ5TNRZ.js";import"./chunk-BH53MBAZ.js";import"./chunk-UG22Z42P.js";import"./chunk-Y5IU6IA5.js";import"./chunk-47HAZZWF.js";import"./chunk-273CUPEO.js";import"./chunk-UM5VNQPY.js";import"./chunk-2HSR5XDQ.js";import"./chunk-D2PATZCC.js";import"./chunk-M2FZ224T.js";import"./chunk-IHGRFR4H.js";import"./chunk-AJSIVGDX.js";import"./chunk-EVYHPR3J.js";import"./chunk-XRP4JJXL.js";import"./chunk-Q22Z4PBD.js";import"./chunk-AIQ6IVT5.js";import"./chunk-QXVH6POE.js";import"./chunk-UUOPT2N4.js";import"./chunk-4QLJUQSJ.js";import"./chunk-7WRQ2UAN.js";import"./chunk-WOT6VMZA.js";import{proxy as t}from"valtio/vanilla";var s=()=>({id:"zylem",globals:{},stages:[e()],debug:!1,time:0,input:void 0}),a=t({...s()});function o(){return{id:a.id??"zylem",globals:a.globals??{},stages:a.stages??[e()],debug:a.debug,time:a.time,input:a.input}}export{o as getGameDefaultConfig};

package/dist/graphics.d.ts

@@ -1,6 +1,6 @@
-import { b as ZylemTSLShader } from './material-CxxAyJYp.js';
-export { d as ZylemShader, Z as ZylemShaderObject, c as createNodeMaterialFromTSL, a as isGLSLShader, i as isTSLShader } from './material-CxxAyJYp.js';
-export { Z as ZylemPostEffect } from './zylem-camera-CWhIGXlW.js';
+import { e as ZylemTSLShader } from './material-D1IVeQc5.js';
+export { E as EntityGlowOptions, f as ZylemShader, Z as ZylemShaderObject, b as applyEntityGlow, d as createEntityGlowMaterial, c as createNodeMaterialFromTSL, a as isGLSLShader, i as isTSLShader } from './material-D1IVeQc5.js';
+export { Z as ZylemPostEffect } from './zylem-camera-BA3VPFlS.js';
 export { S as StageTransitionConfig, a as StageTransitionEasing, Z as ZylemTransitionShader, c as crossfadeTransitionShader } from './stage-transition-CmGpV4tc.js';
 export { Fn, abs, asin, atan, clamp, cos, dot, exp, float, floor, fract, length, max, min, mix, mod, normalize, positionWorld, positionWorldDirection, pow, sin, smoothstep, step, time, uniform, uv, vec2, vec3, vec4 } from 'three/tsl';
 import 'three';

package/dist/graphics.js

@@ -1 +1 @@
-import{a as n,b as o,c as p,d as q,e as r,f as s,g as t,h as u,i as v,j as w,k as x,l as y,m as z,n as A,o as B,p as C,q as D,r as E,s as F,t as G,u as H,v as I,w as J}from"./chunk-QB3NL7VQ.js";import{c as a,d as b,h as c,i as d,k as e,l as f,m as g,n as h,o as i,p as j,q as k,r as l}from"./chunk-6FGXC4T6.js";import"./chunk-QXVH6POE.js";import{a as m}from"./chunk-7GYFZKK7.js";import"./chunk-7WRQ2UAN.js";import"./chunk-WOT6VMZA.js";export{l as Fn,y as abs,x as asin,w as atan,t as clamp,v as cos,n as createBackgroundShader,e as createNodeMaterialFromTSL,m as crossfadeTransitionShader,G as dot,z as exp,k as float,E as floor,F as fract,d as isGLSLShader,c as isTSLShader,H as length,C as max,D as min,r as mix,J as mod,q as normalize,a as objectVertexShader,p as positionWorld,o as positionWorldDirection,A as pow,u as sin,s as smoothstep,b as standardShader,B as step,h as time,f as uniform,g as uv,I as vec2,i as vec3,j as vec4};
+import{a as p,b as q,c as r,d as s,e as t,f as u,g as v,h as w,i as x,j as y,k as z,l as A,m as B,n as C,o as D,p as E,q as F,r as G,s as H,t as I,u as J,v as K,w as L}from"./chunk-4DAITCJS.js";import{a as o}from"./chunk-7GYFZKK7.js";import{c as a,d as b,h as c,i as d,j as e,k as f,m as g,n as h,o as i,p as j,q as k,r as l,s as m,t as n}from"./chunk-Q22Z4PBD.js";import"./chunk-QXVH6POE.js";import"./chunk-7WRQ2UAN.js";import"./chunk-WOT6VMZA.js";export{n as Fn,A as abs,d as applyEntityGlow,z as asin,y as atan,v as clamp,x as cos,p as createBackgroundShader,c as createEntityGlowMaterial,g as createNodeMaterialFromTSL,o as crossfadeTransitionShader,I as dot,B as exp,m as float,G as floor,H as fract,f as isGLSLShader,e as isTSLShader,J as length,E as max,F as min,t as mix,L as mod,s as normalize,a as objectVertexShader,r as positionWorld,q as positionWorldDirection,C as pow,w as sin,u as smoothstep,b as standardShader,D as step,j as time,h as uniform,i as uv,K as vec2,k as vec3,l as vec4};

package/dist/{material-CxxAyJYp.d.ts → material-D1IVeQc5.d.ts}

@@ -1,9 +1,49 @@
-import { Blending, Side, Color, Material } from 'three';
+import { Color, Material, Blending, Side } from 'three';
 import { MeshBasicNodeMaterial } from 'three/webgpu';
 import { b as Vec2Input } from './vector-D3eDzvcA.js';
 
 declare function shortHash(objString: string): string;
 
+/**
+ * Inexpensive fresnel glow for an entity material.
+ *
+ * This is one extra term in the material shader. It does not add a bloom
+ * pass or a second mesh.
+ */
+interface EntityGlowOptions {
+    /** Glow color. Defaults to the material color, then white. */
+    color?: Color | string;
+    /** Brightness multiplier. Default `2.8`. */
+    intensity?: number;
+    /**
+     * How far a flat-color glow extends past the surface, in local units.
+     * `0` keeps the mesh size. Default `0.06`. Ignored when glow is added
+     * as emissive light on a textured or custom-shader material.
+     */
+    size?: number;
+    /**
+     * How quickly brightness falls toward the silhouette.
+     * Higher values keep the hot core tighter. Default `1.6`.
+     */
+    falloff?: number;
+}
+interface ResolvedEntityGlow {
+    color: Color | string;
+    intensity: number;
+    size: number;
+    falloff: number;
+}
+/**
+ * Unlit additive glow. Bright at the center and faded at a slightly expanded
+ * silhouette, so a small mesh reads as a soft halo in a single draw.
+ */
+declare function createEntityGlowMaterial(options: ResolvedEntityGlow): MeshBasicNodeMaterial;
+/**
+ * Add a fresnel emissive term to an existing node material.
+ * The original color, texture, or shader stays in place.
+ */
+declare function applyEntityGlow(material: Material, options: ResolvedEntityGlow): void;
+
 /**
  * GLSL shader object (traditional WebGL approach).
  *
@@ -63,6 +103,12 @@ interface MaterialOptions {
      * This flag is ignored.
      */
     useTSL?: boolean;
+    /**
+     * Soft fresnel glow in the material shader. A flat color becomes an unlit
+     * additive halo. A texture or custom shader keeps its surface and gains
+     * emissive rim light. This does not add a bloom pass.
+     */
+    glow?: boolean | EntityGlowOptions;
 }
 type SharedGeometryMap = Map<symbol, number>;
 interface SharedMaterialMapEntry {
@@ -123,4 +169,4 @@ declare class MaterialBuilder {
  */
 declare function createNodeMaterialFromTSL(tslShader: ZylemTSLShader, opacity?: number): MeshBasicNodeMaterial;
 
-export { MaterialBuilder as M, type TexturePath as T, type ZylemShaderObject as Z, isGLSLShader as a, type ZylemTSLShader as b, createNodeMaterialFromTSL as c, type ZylemShader as d, type MaterialOptions as e, isTSLShader as i };
+export { type EntityGlowOptions as E, MaterialBuilder as M, type TexturePath as T, type ZylemShaderObject as Z, isGLSLShader as a, applyEntityGlow as b, createNodeMaterialFromTSL as c, createEntityGlowMaterial as d, type ZylemTSLShader as e, type ZylemShader as f, type MaterialOptions as g, isTSLShader as i };

package/dist/placement-session-BNQoL7Jb.d.ts

@@ -0,0 +1,82 @@
+import { G as GameEntity, a as PlacementPointContext } from './entity-CY75JJSw.js';
+import { e as Vec3Input, d as Vec3Components } from './vector-D3eDzvcA.js';
+
+/**
+ * The object drawn under the cursor while a placement is armed.
+ *
+ * It is not spawned. Spawning it would put a ghost in `childrenMap`, the
+ * entity list, and the physics world, and the pointer ray would hit the thing
+ * it is trying to place. The render object is cloned (geometry and materials
+ * included, so disposing the throwaway source cannot blank the preview) and
+ * parented to a scene group, the same idea as the editor's PlacementGhost.
+ * Materials are kept, not replaced with a flat color, so a sprite still looks
+ * like the sprite. Opacity is animated here; `onFrame` can drive the rest.
+ */
+
+interface RepresentativeLook {
+    opacity?: number;
+    color?: number | string;
+}
+interface RepresentativeFrame {
+    delta: number;
+    opacity: number;
+    setOpacity: (opacity: number) => void;
+    valid: boolean;
+    position: Vec3Components;
+}
+interface EntityRepresentativeOptions {
+    /** Resting opacity when a look doesn't override it. Defaults to 0.45. */
+    opacity?: number;
+    /** Seconds to fade in, and to fade between valid and invalid. */
+    fadeIn?: number;
+    /** Seconds to fade out when the session ends. */
+    fadeOut?: number;
+    valid?: RepresentativeLook;
+    invalid?: RepresentativeLook;
+    /** Added to the preview only. The spawned entity does not inherit it. */
+    offset?: Vec3Input;
+    onFrame?: (state: RepresentativeFrame) => void;
+}
+type RepresentativeSource = GameEntity<any> | (() => GameEntity<any>);
+interface EntityRepresentative {
+    source: RepresentativeSource;
+    options: EntityRepresentativeOptions;
+}
+/** What follows the cursor. The stage builds the preview when the session arms. */
+declare function entityRepresentative(source: RepresentativeSource, options?: EntityRepresentativeOptions): EntityRepresentative;
+
+/**
+ * Authoring types for a click-to-place session.
+ *
+ * The session is armed on the stage. The representative follows the cursor,
+ * and a left click asks `spawnOnClick` for the entity to add. Drag-to-drop is
+ * not this session — picking something up is a hover-area click that arms one.
+ */
+
+interface ArmPlacementOptions {
+    representative: EntityRepresentative;
+    /** Handed to droppable `accepts` and to `spawnOnClick`. Author-defined. */
+    payload?: unknown;
+    /**
+     * Left click while armed. Return an entity (or a factory / promise the
+     * stage can spawn) to add it. Return `null` or `false` to reject the click.
+     * Called only when the cursor is somewhere a placement is allowed.
+     */
+    spawnOnClick?: (ctx: PlacementPointContext) => unknown;
+    /** Stay armed after a successful click so the next click places another. */
+    repeat?: boolean;
+    /** World-unit lattice. Omit to keep the hit point or the area center. */
+    snap?: number;
+    /**
+     * Where the preview sits while a droppable is under the cursor.
+     * Defaults to the area's own `placeAt`, then `'area'`.
+     */
+    placeAt?: 'area' | 'hit';
+}
+interface PlacementSession {
+    cancel(): void;
+    setPayload(payload: unknown): void;
+    setRepresentative(representative: EntityRepresentative): void;
+}
+
+export { type ArmPlacementOptions as A, type EntityRepresentative as E, type PlacementSession as P, type RepresentativeFrame as R, type EntityRepresentativeOptions as a, type RepresentativeLook as b, type RepresentativeSource as c, entityRepresentative as e };

package/dist/placement.d.ts

@@ -0,0 +1,52 @@
+import { B as BaseNode } from './base-node-idopiSw5.js';
+import { d as GameEntityOptions, H as HoverAreaOptions, G as GameEntity, P as PointerAreaContext, D as DroppableAreaOptions, a as PlacementPointContext } from './entity-CY75JJSw.js';
+export { b as PointerTargetEntity } from './entity-CY75JJSw.js';
+export { A as ArmPlacementOptions, E as EntityRepresentative, a as EntityRepresentativeOptions, P as PlacementSession, R as RepresentativeFrame, b as RepresentativeLook, c as RepresentativeSource, e as entityRepresentative } from './placement-session-BNQoL7Jb.js';
+import './base-node-life-cycle-BK9xebT9.js';
+import 'three';
+import './stage-transition-CmGpV4tc.js';
+import '@zylem/behaviors/core';
+import './simulation-body-zQw-emOr.js';
+import './vector-D3eDzvcA.js';
+import './material-D1IVeQc5.js';
+import 'three/webgpu';
+import './collision-builder-BckxkdmA.js';
+import './events.js';
+import 'mitt';
+
+/**
+ * Invisible pointer volumes.
+ *
+ * These are entities so they join a stage the same way a box does, but they
+ * have no collider. Hit testing is a ray against the authored box — a sensor
+ * would be skipped by the solid-only physics raycast, and a hotspot should
+ * not push characters around. An existing mesh can take the same role with
+ * `entity.hoverArea(...)` / `entity.droppableArea(...)`.
+ */
+
+type HoverAreaEntityOptions = GameEntityOptions & HoverAreaOptions;
+type DroppableAreaEntityOptions = GameEntityOptions & DroppableAreaOptions;
+declare const HOVER_AREA_TYPE: unique symbol;
+declare const DROPPABLE_AREA_TYPE: unique symbol;
+declare class ZylemHoverArea extends GameEntity<HoverAreaEntityOptions> {
+    static type: symbol;
+    protected areaName: string;
+    constructor(options?: HoverAreaEntityOptions);
+    create(): this;
+    onEnter(callback: (ctx: PointerAreaContext) => void): this;
+    onLeave(callback: (ctx: PointerAreaContext) => void): this;
+    onMove(callback: (ctx: PointerAreaContext) => void): this;
+    onClick(callback: (ctx: PointerAreaContext) => void): this;
+}
+declare class ZylemDroppableArea extends ZylemHoverArea {
+    static type: symbol;
+    protected areaName: string;
+    onDrop(callback: (ctx: PlacementPointContext) => void): this;
+    accepts(predicate: NonNullable<DroppableAreaOptions['accepts']>): this;
+}
+type HoverAreaArgs = BaseNode | Partial<HoverAreaEntityOptions>;
+type DroppableAreaArgs = BaseNode | Partial<DroppableAreaEntityOptions>;
+declare function createHoverArea(...args: Array<HoverAreaArgs>): ZylemHoverArea;
+declare function createDroppableArea(...args: Array<DroppableAreaArgs>): ZylemDroppableArea;
+
+export { DROPPABLE_AREA_TYPE, DroppableAreaOptions, HOVER_AREA_TYPE, HoverAreaOptions, PlacementPointContext, PointerAreaContext, ZylemDroppableArea, ZylemHoverArea, createDroppableArea, createHoverArea };

package/dist/placement.js

@@ -0,0 +1 @@
+import{a as b,b as c,c as d,d as e,e as f,f as g}from"./chunk-MJ7RGE47.js";import{c as a}from"./chunk-Y5IU6IA5.js";import"./chunk-AJSIVGDX.js";import"./chunk-EVYHPR3J.js";import"./chunk-XRP4JJXL.js";import"./chunk-Q22Z4PBD.js";import"./chunk-AIQ6IVT5.js";import"./chunk-QXVH6POE.js";import"./chunk-7WRQ2UAN.js";import"./chunk-WOT6VMZA.js";export{c as DROPPABLE_AREA_TYPE,b as HOVER_AREA_TYPE,e as ZylemDroppableArea,d as ZylemHoverArea,g as createDroppableArea,f as createHoverArea,a as entityRepresentative};