@zylem/game-lib 0.7.0 → 0.8.0

package/dist/vector-CiSHbivc.d.ts

@@ -0,0 +1,133 @@
+import { EntityHandle, Simulation } from '@zylem/behaviors/core';
+import { Vector3, Vector2 } from 'three';
+
+interface PhysicsVector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+interface PhysicsQuaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+interface PhysicsPose {
+    position: PhysicsVector3;
+    rotation: PhysicsQuaternion;
+}
+interface PhysicsPoseHistory {
+    previous: PhysicsPose;
+    current: PhysicsPose;
+}
+interface PhysicsRenderPoseProvider {
+    getPoseHistory(): PhysicsPoseHistory;
+    getRenderPose(alpha: number): PhysicsPose;
+}
+
+/** Shared step counter owned by the world; lets bodies know a step has run. */
+interface SimulationStepClock {
+    steps: number;
+}
+declare class SimulationBody implements PhysicsRenderPoseProvider {
+    private readonly simulation;
+    readonly handle: EntityHandle;
+    private readonly clock;
+    private readonly poseScratch;
+    private readonly renderScratch;
+    private readonly previousScratch;
+    constructor(simulation: Simulation, handle: EntityHandle, clock: SimulationStepClock);
+    translation(): PhysicsVector3;
+    rotation(): PhysicsQuaternion;
+    linvel(): PhysicsVector3;
+    angvel(): PhysicsVector3;
+    setTranslation(translation: PhysicsVector3, _wakeUp?: boolean): void;
+    setRotation(rotation: PhysicsQuaternion, _wakeUp?: boolean): void;
+    setLinvel(velocity: PhysicsVector3, _wakeUp?: boolean): void;
+    setAngvel(velocity: PhysicsVector3, _wakeUp?: boolean): void;
+    applyImpulse(impulse: PhysicsVector3, _wakeUp?: boolean): void;
+    /**
+     * Damping is fixed at body-creation time in the wasm runtime; there is no
+     * live setter FFI yet, so this is accepted (for `MoveableBodyLike`
+     * compatibility) but has no effect.
+     */
+    setLinearDamping(_damping: number): void;
+    /**
+     * Gravity scale is fixed at body-creation time in the wasm runtime; there is
+     * no live setter FFI yet, so this is accepted for Rapier compat but has no
+     * effect. Prefer `gravityScale` on the body definition at spawn time when
+     * possible.
+     */
+    setGravityScale(_scale: number, _wakeUp?: boolean): void;
+    private bodyInfo;
+    bodyType(): number;
+    mass(): number;
+    isSleeping(): boolean;
+    isEnabled(): boolean;
+    private livePose;
+    private static slotToPose;
+    getPoseHistory(): PhysicsPoseHistory;
+    getRenderPose(alpha: number): PhysicsPose;
+    /**
+     * True when the latest render buffer marks this body as sleeping.
+     * Used by instancing to skip matrix writes for settled piles.
+     */
+    isRenderSleeping(): boolean;
+    /**
+     * Zero-allocation render-pose read for hot paths (instanced rendering of
+     * thousands of bodies). Interpolates the previous → current fixed-step
+     * poses straight from the shared render buffer into the provided
+     * out-parameters — no intermediate pose objects.
+     */
+    writeRenderPose(alpha: number, outPosition: {
+        x: number;
+        y: number;
+        z: number;
+    }, outRotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }): void;
+    private writeLivePose;
+}
+
+type Vec2 = Vector2;
+type Vec3 = Vector3 | Vec3Components;
+type Vec2Components = {
+    x: number;
+    y: number;
+};
+type Vec3Components = {
+    x: number;
+    y: number;
+    z: number;
+};
+type Vec2Tuple = readonly [number?, number?] & {
+    x?: number;
+    y?: number;
+};
+type Vec3Tuple = readonly [number?, number?, number?] & {
+    x?: number;
+    y?: number;
+    z?: number;
+};
+type Vec2Input = Vec2 | {
+    x?: number;
+    y?: number;
+} | Vec2Tuple;
+type Vec3Input = Vec3 | {
+    x?: number;
+    y?: number;
+    z?: number;
+} | Vec3Tuple;
+declare const VEC2_ZERO: Readonly<Vec2Components>;
+declare const VEC2_ONE: Readonly<Vec2Components>;
+declare const VEC3_ZERO: Readonly<Vec3Components>;
+declare const VEC3_ONE: Readonly<Vec3Components>;
+declare function normalizeVec2(input?: Vec2Input | null, defaults?: Vec2Input | Partial<Vec2Components>): Vec2Components;
+declare function normalizeVec3(input?: Vec3Input | null, defaults?: Vec3Input | Partial<Vec3Components>): Vec3Components;
+declare function toThreeVector2(input?: Vec2Input | null, defaults?: Vec2Input | Partial<Vec2Components>): Vector2;
+declare function toThreeVector3(input?: Vec3Input | null, defaults?: Vec3Input | Partial<Vec3Components>): Vector3;
+
+export { type SimulationStepClock as S, type Vec2 as V, type Vec2Components as a, type Vec2Input as b, type Vec3 as c, type Vec3Components as d, type Vec3Input as e, VEC2_ONE as f, VEC2_ZERO as g, VEC3_ONE as h, VEC3_ZERO as i, normalizeVec3 as j, toThreeVector3 as k, SimulationBody as l, normalizeVec2 as n, toThreeVector2 as t };

package/dist/web-components.d.ts

@@ -1,20 +1,23 @@
-import { G as Game, D as DeviceProfile } from './game-Cuj5gy7U.js';
-import { DebugTools } from './debug.js';
-import './base-node-life-cycle-CnJ-7zX-.js';
+import { G as Game, D as DeviceProfile } from './game-C1FHVqXl.js';
+import { D as DebugTools } from './debug-state-BPT6jEog.js';
+import './base-node-life-cycle-D2NuN1VB.js';
 import 'three';
-import './game-interfaces-tfpM5NBk.js';
-import './entity-DNkYKfdp.js';
-import '@dimforge/rapier3d-compat';
-import './material-Wz83vTTp.js';
+import './stage-transition-CmGpV4tc.js';
+import './game-interfaces-mchNYSZE.js';
+import './entity-BdSI8CL3.js';
+import '@zylem/behaviors/core';
+import './vector-CiSHbivc.js';
+import './material-9vJ6SZaI.js';
 import 'three/webgpu';
+import './collision-builder-jF-toPIl.js';
 import './events.js';
 import 'mitt';
-import '@zylem/behaviors/core';
-import './world-C9zdyl5d.js';
-import './zylem-stage-runtime-Cs-UDEVU.js';
-import './entity-type-map-C94h2TDW.js';
+import './entity-type-map-Bd69SpAS.js';
+import './entity-DZbFQ1Wg.js';
 import '@zylem/behaviors/particle-emitter';
-import './default-controls-BGc61yYl.js';
+import 'three/addons/lines/webgpu/Line2.js';
+import './zylem-camera-C3bn6BTI.js';
+import './default-controls-0-vCnli7.js';
 
 /**
  * State interface for editor-to-game communication

package/dist/web-components.js

@@ -1,9 +1 @@
-import{a as n,c as o,e as a}from"./chunk-CDPY4VOQ.js";var s=class r extends HTMLElement{_game=null;_state={};container;resizeObserver=null;_viewportProfile="auto";static HOST_CONFIG_MARKER=Symbol("zylem:host-config");constructor(){super(),this.attachShadow({mode:"open"});let e=document.createElement("style");e.textContent=`
-      :host {
-        display: block;
-        width: 100%;
-        height: 100%;
-        min-width: 0;
-        min-height: 0;
-      }
-    `,this.container=document.createElement("div"),this.container.style.width="100%",this.container.style.height="100%",this.container.style.position="relative",this.container.style.outline="none",this.container.tabIndex=0,this.shadowRoot.append(e,this.container)}focus(){this.container.focus()}connectedCallback(){typeof ResizeObserver<"u"&&!this.resizeObserver&&(this.resizeObserver=new ResizeObserver(()=>{this.syncDisplayRuntime()}),this.resizeObserver.observe(this)),this.syncDisplayRuntime()}set game(e){this._game&&this._game.dispose(),this._game=e,this.attachHostContainer(e),this.syncDisplayRuntime(),e.start()}get game(){return this._game}set state(e){this._state=e,this.syncDebugState(),this.syncToolbarState()}get state(){return this._state}set viewportProfile(e){let t=e==="mobile"||e==="desktop"?e:"auto";this._viewportProfile!==t&&(this._viewportProfile=t,this.syncDisplayRuntime())}get viewportProfile(){return this._viewportProfile}static get observedAttributes(){return["viewport-profile"]}attributeChangedCallback(e,t,i){e==="viewport-profile"&&(this.viewportProfile=i??"auto")}syncDebugState(){let e=this._state.gameState?.debugFlag;e!==void 0&&(n.enabled=e)}syncToolbarState(){let{tool:e,paused:t}=this._state.toolbarState??{};e!==void 0&&a(e),t!==void 0&&o(t)}disconnectedCallback(){this.resizeObserver?.disconnect(),this.resizeObserver=null,this._game&&(this._game.dispose(),this._game=null)}attachHostContainer(e){let t=r.HOST_CONFIG_MARKER,i=e.options.find(l=>!!l?.[t]);if(i){i.container=this.container;return}e.options.push({container:this.container,[t]:!0})}syncDisplayRuntime(){if(!this._game)return;let e=this.getBoundingClientRect(),t=Math.round(e.width||this.clientWidth||0),i=Math.round(e.height||this.clientHeight||0);this._game.setDisplayRuntime({deviceProfile:this._viewportProfile,viewportSize:t>0&&i>0?{width:t,height:i}:void 0})}};customElements.define("zylem-game",s);export{s as ZylemGameElement};
+import{a}from"./chunk-TAUWDQZF.js";import"./chunk-JQKS42G4.js";export{a as ZylemGameElement};

package/dist/{zylem-stage-runtime-Cs-UDEVU.d.ts → zylem-camera-C3bn6BTI.d.ts}

@@ -1,9 +1,7 @@
-import { h as SetupFunction, a as Inputs } from './base-node-life-cycle-CnJ-7zX-.js';
-import { G as GameEntity } from './entity-DNkYKfdp.js';
-import { Object3D, Vector2, Scene, Camera, Vector3, Quaternion, RenderTarget, Texture, Color } from 'three';
-import { S as StageEntity, E as Entity, L as LifecycleFunction, Z as ZylemWorld } from './world-C9zdyl5d.js';
+import { Object3D, Vector2, Scene, Camera, Vector3, Quaternion, RenderTarget, Texture } from 'three';
+import { S as StageEntity } from './entity-DZbFQ1Wg.js';
 import { WebGPURenderer, RenderPipeline } from 'three/webgpu';
-import { o as ZylemShader } from './material-Wz83vTTp.js';
+import { R as ResolvedStageTransition } from './stage-transition-CmGpV4tc.js';
 
 declare const Perspectives: {
     readonly FirstPerson: "first-person";
@@ -24,16 +22,6 @@ interface CameraDebugDelegate {
     resolveTarget(uuid: string): Object3D | null;
 }
 
-/**
- * Renderer type option.
- *
- * @deprecated game-lib now always renders with WebGPU (Three.js
- * {@link WebGPURenderer}, which keeps its own internal WebGL2 fallback for
- * devices without WebGPU). This type is retained only so existing public
- * APIs (e.g. `CameraOptions.rendererType`) keep type-checking; the value is
- * ignored by the renderer.
- */
-type RendererType = 'auto' | 'webgpu' | 'webgl';
 /**
  * The renderer instance type. game-lib standardizes on {@link WebGPURenderer}.
  */
@@ -48,6 +36,22 @@ interface Viewport {
     width: number;
     height: number;
 }
+/**
+ * A postprocessing effect for the render pipeline. Receives the current
+ * pipeline node (initially the scene pass) and returns the transformed node.
+ * `ctx.scenePass` is the original scene `PassNode` for effects that need
+ * extra channels (depth, velocity, ...). `ctx.scene`/`ctx.camera` are the
+ * rendered scene and camera, for effects that build their own scene pass
+ * (e.g. pixelation, retro). Such pass-replacing effects should be first in
+ * the effect chain — the default scene pass simply goes unused.
+ *
+ * Structurally compatible with `ZylemPostEffect` from `@zylem/shaders`.
+ */
+type ZylemPostEffect = (inputNode: any, ctx: {
+    scenePass: any;
+    scene: any;
+    camera: any;
+}) => any;
 /**
  * Check if WebGPU is supported in the current browser.
  *
@@ -81,14 +85,17 @@ declare class RendererManager {
      */
     renderScale: number;
     screenResolution: Vector2;
-    /**
-     * @deprecated Always `'webgpu'`. Retained for backward compatibility.
-     */
-    rendererType: RendererType;
     private _initialized;
     private _sceneRef;
     private _lastAnimationTimestamp;
-    constructor(screenResolution?: Vector2, _rendererType?: RendererType);
+    /** Registered postprocessing effects, applied in order over the scene pass. */
+    private _postEffects;
+    /** Scene/camera the current pipeline was built for (for rebuilds). */
+    private _postSceneRef;
+    private _postCameraRef;
+    /** In-flight stage transition, if any. */
+    private _transition;
+    constructor(screenResolution?: Vector2);
     /**
      * Check if the renderer has been initialized
      */
@@ -122,6 +129,35 @@ declare class RendererManager {
      * replacement for the old `EffectComposer` + `RenderPass`.
      */
     setupPostProcessing(scene: Scene, camera: Camera): void;
+    /** Whether a stage transition is currently in flight. */
+    get transitionActive(): boolean;
+    /**
+     * Arm a stage transition: renders one final frame of the outgoing scene
+     * into a texture, to be blended with the incoming stage's frames once
+     * its pipeline is set up. Call before tearing down the outgoing stage.
+     */
+    beginSnapshotTransition(resolved: ResolvedStageTransition, scene: Scene, camera: Camera): void;
+    /**
+     * Complete the active transition immediately: rebuild the normal
+     * pipeline, release transition resources, and fire `onComplete`.
+     * No-op when no transition is active.
+     */
+    finishTransition(): void;
+    /**
+     * Drop the active transition without rebuilding the pipeline (renderer
+     * teardown path). Still fires `onComplete`.
+     */
+    private cancelTransition;
+    private releaseTransitionResources;
+    /** Advance transition progress; called once per render-loop frame. */
+    private advanceTransition;
+    /**
+     * Register postprocessing effects (e.g. from `@zylem/shaders`). Effects
+     * are applied in order between the scene pass and the display output
+     * transform. If a pipeline is already active it is rebuilt immediately;
+     * otherwise the effects apply on the next {@link setupPostProcessing}.
+     */
+    setPostProcessingEffects(effects: ZylemPostEffect[]): void;
     /**
      * Set the supersampling (SSAA) multiplier. Takes effect on the next
      * {@link setupPostProcessing}. `1` = native resolution (default).
@@ -364,7 +400,6 @@ declare class ZylemCamera {
     screenResolution: Vector2;
     _perspective: PerspectiveType;
     frustumSize: number;
-    rendererType: RendererType;
     sceneRef: Scene | null;
     /** Name for camera manager lookup. */
     name: string;
@@ -404,7 +439,7 @@ declare class ZylemCamera {
     private _rendererManager;
     /** Elapsed time tracker for CameraContext. */
     private _elapsedTime;
-    constructor(perspective: PerspectiveType, screenResolution: Vector2, frustumSize?: number, rendererType?: RendererType);
+    constructor(perspective: PerspectiveType, screenResolution: Vector2, frustumSize?: number);
     /**
      * Setup the camera with a scene and renderer manager.
      */
@@ -491,6 +526,10 @@ declare class ZylemCamera {
      * Skipped when _skipDebugOrbit is true so the pipeline always runs.
      */
     setDebugDelegate(delegate: CameraDebugDelegate | null): void;
+    /**
+     * Frame the debug orbit camera on an Object3D (AABB fit).
+     */
+    frameObject(object: Object3D): void;
     /**
      * Directly set the camera position.
      */
@@ -533,245 +572,4 @@ declare class ZylemCamera {
     private createCameraForPerspective;
 }
 
-/**
- * CameraManager orchestrates multiple cameras per stage.
- *
- * Responsibilities:
- * - Named camera registry (add/remove/get by name or reference)
- * - Active camera list management (determines which cameras render)
- * - Always-available debug camera with orbit controls
- * - Per-frame update of all active cameras' perspective controllers
- * - Coordinating rendering via RendererManager for all active viewports
- */
-declare class CameraManager {
-    /** Named camera registry */
-    private cameras;
-    /** Currently active cameras, ordered by render layer (first = bottom) */
-    private _activeCameras;
-    /** Auto-created debug camera with orbit controls */
-    private _debugCamera;
-    /** Reference to the shared renderer manager */
-    private _rendererManager;
-    /** Scene reference */
-    private _sceneRef;
-    /** Counter for auto-generated camera names */
-    private _autoNameCounter;
-    constructor();
-    /**
-     * Get the list of currently active cameras.
-     */
-    get activeCameras(): ReadonlyArray<ZylemCamera>;
-    /**
-     * Get the primary active camera (first in the active list).
-     */
-    get primaryCamera(): ZylemCamera | null;
-    /**
-     * Get the debug camera.
-     */
-    get debugCamera(): ZylemCamera | null;
-    /**
-     * Get all registered cameras.
-     */
-    get allCameras(): ReadonlyArray<ZylemCamera>;
-    /**
-     * Add a camera to the manager.
-     * If no name is provided, one is auto-generated.
-     * The first camera added becomes the active camera.
-     *
-     * @param camera The ZylemCamera instance to add
-     * @param name Optional name for lookup
-     * @returns The assigned name
-     */
-    addCamera(camera: ZylemCamera, name?: string): string;
-    /**
-     * Remove a camera by name or reference.
-     * Cannot remove the debug camera via this method.
-     */
-    removeCamera(nameOrRef: string | ZylemCamera): boolean;
-    /**
-     * Set a camera as the primary active camera (replaces all active cameras
-     * except additional viewport cameras).
-     *
-     * @param nameOrRef Camera name or reference to activate
-     */
-    setActiveCamera(nameOrRef: string | ZylemCamera): boolean;
-    /**
-     * Add a camera as an additional active camera (for split-screen or PiP).
-     */
-    addActiveCamera(nameOrRef: string | ZylemCamera): boolean;
-    /**
-     * Remove a camera from the active render list (does not remove from registry).
-     */
-    deactivateCamera(nameOrRef: string | ZylemCamera): boolean;
-    /**
-     * Get a camera by name.
-     */
-    getCamera(name: string): ZylemCamera | null;
-    /**
-     * Setup all cameras with the given scene and renderer manager.
-     * Also creates the debug camera.
-     */
-    setup(scene: Scene, rendererManager: RendererManager): Promise<void>;
-    /**
-     * Update all active cameras' controllers.
-     */
-    update(delta: number): void;
-    /**
-     * Render all active cameras through the renderer manager.
-     * RTT cameras (those with a renderTarget) are rendered first to their
-     * offscreen textures, then viewport cameras are rendered to the screen.
-     */
-    render(scene: Scene): void;
-    private updateOrbitingCamerasForRender;
-    /**
-     * Create a default third-person camera if no cameras have been added.
-     */
-    ensureDefaultCamera(): ZylemCamera;
-    /**
-     * Dispose all cameras and cleanup.
-     */
-    dispose(): void;
-    /**
-     * Create the always-available debug camera with orbit controls.
-     */
-    private createDebugCamera;
-    /**
-     * Resolve a camera from a name or reference.
-     */
-    private resolveCamera;
-}
-
-interface SceneState {
-    backgroundColor: Color | string;
-    backgroundImage: string | null;
-    backgroundShader?: ZylemShader | null;
-    /**
-     * When `false`, skip the engine's built-in ambient + directional lights so
-     * the caller can configure the scene's lighting entirely via
-     * `createLight(...)` entities. Defaults to `true` for backward
-     * compatibility with existing demos.
-     */
-    defaultLighting?: boolean;
-}
-declare class ZylemScene implements Entity<ZylemScene> {
-    type: string;
-    _setup?: SetupFunction<ZylemScene>;
-    scene: Scene;
-    /** @deprecated Use cameraManager instead */
-    zylemCamera: ZylemCamera;
-    cameraManager: CameraManager | null;
-    containerElement: HTMLElement | null;
-    update: LifecycleFunction<ZylemScene>;
-    _collision?: ((entity: any, other: any, globals?: any) => void) | undefined;
-    _destroy?: ((globals?: any) => void) | undefined;
-    name?: string | undefined;
-    tag?: Set<string> | undefined;
-    private skyboxMaterial;
-    private skyboxMesh;
-    constructor(id: string, camera: ZylemCamera, state: SceneState);
-    /**
-     * Create a large inverted box with the shader for a skybox effect.
-     *
-     * WebGPU-only: background shaders must be authored in TSL
-     * ({@link ZylemTSLShader}). A GLSL shader logs a warning and is ignored
-     * (the solid background color is kept).
-     */
-    private setupBackgroundShader;
-    setup(): void;
-    destroy(): void;
-    /**
-     * Setup camera with the scene.
-     * Supports both legacy single camera and CameraManager modes.
-     */
-    setupCamera(scene: Scene, camera: ZylemCamera, rendererManager?: RendererManager): Promise<void>;
-    /**
-     * Setup with a CameraManager (multi-camera support).
-     */
-    setupCameraManager(scene: Scene, cameraManager: CameraManager, rendererManager: RendererManager): Promise<void>;
-    /**
-     * Add a camera (rig or direct) to the scene graph.
-     */
-    private addCameraToScene;
-    /**
-     * Setup scene lighting
-     */
-    setupLighting(scene: Scene): void;
-    /**
-     * Update renderer size - delegates to camera manager or camera
-     */
-    updateRenderer(width: number, height: number): void;
-    /**
-     * Add object to scene
-     */
-    add(object: Object3D, position?: Vector3): void;
-    /**
-     * Add game entity to scene
-     */
-    addEntity(entity: GameEntity<any>): void;
-    /**
-     * Add an entity's group or mesh to the scene (for late-loaded models).
-     * Uses entity's current body position if physics is active.
-     *
-     * Fog entities ({@link ZylemFog}) are routed through the normal add
-     * pipeline so their empty placeholder group is parented for cleanup,
-     * but they also get an `attachToScene` call that wires `scene.fog`
-     * and starts the optional material patcher.
-     */
-    addEntityGroup(entity: GameEntity<any>): void;
-    private isAttachedOutsideScene;
-    /**
-     * Add debug helpers to scene
-     */
-    debugScene(): void;
-    /**
-     * Per-frame skybox hook. Ensures the skybox cube follows the active camera
-     * position so it always appears infinitely far away regardless of camera
-     * movement. TSL background shaders animate via the `time` node, which the
-     * renderer advances automatically.
-     */
-    updateSkybox(_delta: number): void;
-}
-
-/**
- * Host-provided debug signals for wasm runtime adapters (no direct `debugState` import in adapters).
- */
-interface RuntimeDebugBinding {
-    /** When true, show wasm-side diagnostics (e.g. instanced collision heat tint). */
-    runtimeDiagnostics(): boolean;
-}
-interface StageRuntimeContext {
-    scene: ZylemScene;
-    world: ZylemWorld;
-    camera: ZylemCamera;
-    /** Optional; when set, adapters may enable extra runtime visualization. */
-    debug?: RuntimeDebugBinding;
-}
-interface StageRuntimeStepContext extends StageRuntimeContext {
-    delta: number;
-    inputs: Inputs;
-}
-interface StageRuntimeAdapter {
-    init(context: StageRuntimeContext): Promise<void> | void;
-    step(context: StageRuntimeStepContext): void;
-    destroy(context: StageRuntimeContext | null): void;
-    ownsEntity(entity: GameEntity<any>): boolean;
-    rendersEntity(entity: GameEntity<any>): boolean;
-    registerEntity(entity: GameEntity<any>): void;
-    unregisterEntity(entity: GameEntity<any>): void;
-    /**
-     * Optional: when implemented, the stage debug delegate will draw the
-     * returned line segments alongside the TS Rapier debug overlay so wasm
-     * runtime adapters can visualize their own colliders. Returning `null`
-     * (or omitting the method entirely) disables the second pass.
-     */
-    getDebugRender?(): {
-        vertices: Float32Array;
-        colors: Float32Array;
-    } | null;
-}
-interface ZylemRuntimeStageAdapterSource {
-    source: RequestInfo | URL | ArrayBuffer;
-}
-declare function createZylemRuntimeStageAdapter(options: ZylemRuntimeStageAdapterSource): StageRuntimeAdapter;
-
-export { type CameraBehavior as C, type PerspectiveType as P, type RuntimeDebugBinding as R, type StageRuntimeAdapter as S, type TransformLike as T, type Viewport as V, type ZylemRenderer as Z, type StageRuntimeContext as a, type StageRuntimeStepContext as b, createZylemRuntimeStageAdapter as c, Perspectives as d, type RendererType as e, CameraManager as f, type CameraPose as g, type PoseDelta as h, isWebGPUSupported as i, type CameraContext as j, type CameraPerspective as k, type CameraAction as l, type CameraPipelineState as m, CameraPipeline as n, ZylemCamera as o, ZylemScene as p, RendererManager as q };
+export { type CameraPose as C, type PerspectiveType as P, RendererManager as R, type TransformLike as T, type Viewport as V, type ZylemPostEffect as Z, Perspectives as a, type ZylemRenderer as b, type PoseDelta as c, type CameraContext as d, type CameraPerspective as e, type CameraBehavior as f, type CameraAction as g, type CameraPipelineState as h, isWebGPUSupported as i, CameraPipeline as j, ZylemCamera as k };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zylem/game-lib",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "type": "module",
   "description": "A powerful and easy-to-use framework for creating simple 3D digital interactive applications using TypeScript.",
   "license": "MIT",
@@ -68,13 +68,25 @@
     "./runtime": {
       "types": "./dist/runtime.d.ts",
       "import": "./dist/runtime.js"
-    }
+    },
+    "./schema": {
+      "types": "./dist/schema.d.ts",
+      "import": "./dist/schema.js"
+    },
+    "./api/rollup": "./dist/api/game-lib.d.ts",
+    "./api/report": "./dist/api/game-lib.api.md",
+    "./api/model": "./dist/api/game-lib.api.json",
+    "./api/typedoc": "./dist/api/game-lib.typedoc.json",
+    "./schema/entity": "./dist/schema/entity.schema.json",
+    "./schema/stage": "./dist/schema/stage.schema.json",
+    "./schema/game-config": "./dist/schema/game-config.schema.json",
+    "./schema/stage-config": "./dist/schema/stage-config.schema.json",
+    "./schema/input-config": "./dist/schema/input-config.schema.json"
   },
   "keywords": [
     "game",
     "three",
     "typescript",
-    "rapier3d",
     "physics",
     "framework",
     "vite",
@@ -86,51 +98,47 @@
     "dist"
   ],
   "dependencies": {
-    "comlink": "^4.4.2",
     "@dgreenheck/three-pinata": "^2.0.1",
-    "@dimforge/rapier3d-compat": "^0.11.2",
     "@sinclair/typebox": "^0.34.41",
-    "@zylem/behaviors": "^0.3.0",
     "@types/howler": "^2.2.12",
+    "@zylem/behaviors": "link:../../../behaviors",
+    "comlink": "^4.4.2",
     "howler": "^2.2.4",
     "idb-keyval": "^6.2.2",
     "msgpackr": "^1.11.5",
     "nanoid": "^5.1.5",
     "stats.js": "^0.17.0",
-    "three": "^0.184.0",
+    "three": "^0.185.0",
     "typescript-fsm": "^1.6.0",
     "valtio": "^2.1.7"
   },
   "peerDependencies": {
-    "@dimforge/rapier3d-compat": "^0.11.2",
-    "@zylem/runtime": "^0.1.0",
     "howler": "^2.2.4",
     "nanoid": "^5.1.5",
-    "three": "^0.184.0",
+    "three": "^0.185.0",
     "valtio": "^2.1.7"
   },
-  "peerDependenciesMeta": {
-    "@zylem/runtime": {
-      "optional": true
-    }
-  },
   "devDependencies": {
+    "@microsoft/api-extractor": "^7.58.9",
     "@types/node": "^20.19.13",
     "@types/stats.js": "^0.17.4",
-    "@types/three": "^0.184.0",
+    "@types/three": "^0.185.0",
+    "@typescript/native-preview": "latest",
     "happy-dom": "^18.0.1",
     "jsdom": "^27.2.0",
     "tslib": "^2.8.1",
     "tsup": "^8.5.1",
+    "typedoc": "^0.28.20",
     "typescript": "6.0.3",
-    "@typescript/native-preview": "latest",
     "vite-plugin-solid": "^2.11.8",
-    "vitest": "^4.0.9",
-    "@zylem/runtime": "0.1.0"
+    "vitest": "^4.0.9"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "tsup && pnpm api:extract && pnpm api:typedoc && pnpm schema:emit",
     "dev": "tsup --watch",
+    "api:extract": "mkdir -p dist/api temp && api-extractor run --local --verbose",
+    "api:typedoc": "mkdir -p dist/api && typedoc --options typedoc.json",
+    "schema:emit": "node --experimental-strip-types ./scripts/emit-json-schemas.ts",
     "lint": "biome check .",
     "typecheck": "tsgo --noEmit",
     "test": "vitest --reporter=verbose",

package/dist/chunk-73VZQZUL.js

@@ -1 +0,0 @@
-import{c as l,d as c,h as a,k as d}from"./chunk-G2IIMSUH.js";import{ActiveCollisionTypes as D,ColliderDesc as g,RigidBodyDesc as h,RigidBodyType as p,Vector3 as I}from"@dimforge/rapier3d-compat";var u=new Map,m=0;function C(o){let e=u.get(o);return e===void 0&&(e=m++%16,u.set(o,e)),e}function x(o){let e=0;return o.forEach(t=>{let i=C(t);e|=1<<i}),e}var y=class{static=!1;sensor=!1;gravity=new I(0,0,0);build(e){let t=this.bodyDesc({isDynamicBody:!this.static}),i=this.collider(e),s=e.collisionType;if(s){let f=C(s),r=65535;e.collisionFilter&&(r=x(e.collisionFilter)),i.setCollisionGroups(f<<16|r)}let{KINEMATIC_FIXED:n,DEFAULT:b}=D;return i.activeCollisionTypes=this.sensor?n:b,[t,i]}withCollision(e){return this.sensor=e?.sensor??this.sensor,this.static=e?.static??this.static,this}collider(e){let t=d(e.size,c),i={x:t.x/2,y:t.y/2,z:t.z/2},s=g.cuboid(i.x,i.y,i.z),n=a(e.position,l);return s.setTranslation(n.x,n.y,n.z),s}bodyDesc({isDynamicBody:e=!0}){let t=e?p.Dynamic:p.Fixed;return new h(t).setTranslation(0,0,0).setGravityScale(1).setCanSleep(!1).setCcdEnabled(!0)}};export{C as a,x as b,y as c};