@woosh/meep-engine 3.21.0 → 3.22.0

package/README.md

@@ -1,213 +1,96 @@
-# Meep Engine
-
-**Desktop-grade real-time graphics in the browser, in a JavaScript engine you import from and drive in code.**
-
-[🕹️ Examples](https://meep.company-named.com/examples/) · [📚 Documentation](https://meep.company-named.com/docs/getting-started/) · [🚀 Quick Start Template](https://gitlab.company-named.com/travnik/dream-engine-template) · [📄 Licence](#licence--pricing)
-
-```shell
-npm install @woosh/meep-engine
-```
-
-**Start here:** the package ships a guide to the first thirty minutes at
-`samples/engine/README.md` - the Vite stanza you need, why your scene should be authored in
-metres, photometric reference values, and how input reaches the engine. The worked example beside
-it, `samples/engine/first-scene`, boots the engine, lights a scene and reads the keyboard in about
-eighty lines.
-
-**Proprietary and source-available.** You get all ~6,200 fine-grained ES modules, unobfuscated,
-under a licence that lets you ship. Need a lerp function? Import the module that holds it and pay
-for those four lines.
-
----
-
-meep has one renderer, not a kit of parts. Every feature is part of a single frame and works off
-the same shared data, so a character's shadow, the decal on the wall behind it and the fog in
-between are computed together and agree with each other. There is one path rather than a
-combinatorial number of them, so it is tuned once - by the engine, not by you.
-
-That is not how browser rendering usually goes. Most WebGPU and WebGL renderers are a rasterizer
-plus an ecosystem: you assemble the frame yourself out of plugins written without knowledge of each
-other, so a stack can have shadows, decals, global illumination, anti-aliasing and volumetric fog
-on paper and still not have them working together - and every plugin is another set of numbers to
-tune, per scene and per device.
-
-**Shadows, ambient occlusion, indirect lighting, auto-exposure, anti-aliasing and transparency are
-all on by default, with nothing to configure.** No quality tiers to author, no per-device profiles,
-no exposure value to pick, no shadow cascade splits to hand-tune. You put a scene together and it
-holds its frame rate across a wide range of hardware without you doing anything about it.
-
-In development since 2013, shipped in a commercial Steam release, and held to **~15,000 tests** -
-determinism, adversarial and shader-emulation suites among them.
-
----
-
-# The renderer
-
-A GPU-driven deferred renderer on WebGPU. It lives under `src/shade/`, which is where the `Shade*`
-type names come from.
-
-## What you get
-
-* **Thousands of dynamic lights.** Lighting is one pass over the screen however many lights are in
-  the scene. A light adds work only on the pixels it actually touches - not another pass, not
-  another draw - so lights are something you place rather than something you budget.
-* **Shadows from every light, with nothing to set up.** No fixed limit on how many lights cast
-  shadows. Cascade distances come from your camera, each shadow's resolution from how large that
-  light looks on screen, and refresh priority from what has changed. There is no per-light shadow
-  setting to get wrong.
-* **Scene complexity is nearly free on the CPU.** All opaque geometry is submitted in a couple of
-  draw calls, whether the scene holds one object or a hundred thousand. Visibility is decided on
-  the GPU, so adding objects does not add CPU work per object.
-* **You don't pay for what you can't see.** Geometry hidden behind other geometry is dropped on the
-  GPU before anything shades it, and this works below the level of whole objects - a mesh half
-  behind a wall does not cost its hidden half. A dense interior costs roughly what you can see of it.
-* **Overlapping geometry doesn't multiply cost.** Deferred shading means a surface hidden behind
-  another is not shaded twice. Materials are evaluated once per visible pixel, after the scene is
-  drawn.
-* **Features you turn off cost nothing.** The frame is assembled as a graph, and work that nothing
-  consumes is dropped before it reaches the GPU. That applies to passes you add as well - you
-  extend the frame by declaring where your work goes, not by patching the renderer.
-
-If you want the mechanisms behind these - visibility buffer, meshlet clustering, clustered lighting,
-occlusion culling, the frame graph - they are in **the renderer contract**, which ships in the
-package at `src/shade/RENDERER_CONTRACT.md`. It also covers how to put a model on the screen and
-how to add your own work to the frame.
-
-## Scaling across hardware
-
-**One build covers a wide hardware range, and you don't author the tiers.** When frames start
-costing more than the budget - on a weaker GPU, or because the scene got busy - the engine renders
-internally at a lower resolution and upscales back to the display, adjusting continuously as
-conditions change. Nothing in your application is involved: this is wired up by default when you
-construct an `Engine`.
-
-Anti-aliasing is what does the upscaling, and it is on by default. Out of the box the internal and
-display resolutions are the same, so you get anti-aliasing at native resolution and no upscaling
-until something needs the headroom.
-
-It holds a **floor rather than a target**: 30 FPS by default, taking no action on hardware that is
-already clearing it, and trading resolution down to 43% before it runs out of room. What it costs
-is one re-converging frame each time the resolution steps, since temporal history is discarded.
-
-To override or opt out:
-
-```js
-engine.graphics.dynamic_resolution.enabled = false;      // or .target_frame_rate / .min_scale
-engine.graphics.renderer.feature_taa_enabled = false;    // only valid after start()
-```
-
-Two things to know. Anti-aliasing is the only thing that upscales, so switching it off while the
-resolution scale is below full leaves the frame un-upscaled. And if you drive the `Renderer`
-directly rather than through `Engine`, none of this is wired for you.
-
-A neural network-based upscaler ships alongside the default one, weights included and no setup
-needed - one assignment away at `renderer.upscale_type = ShadeUpscalerType.NSS`.
-
-## Correct by default
-
-The out-of-the-box configuration is the expensive-and-correct one, not the safe-and-cheap one.
-
-**On, with nothing to configure:** shadows · ambient occlusion · indirect lighting · anti-aliasing ·
-auto-exposure · tonemapping · bloom · sharpening · order-independent transparency. Virtual texturing
-is available system-wide and opts in per material.
-
-* **Shadows** need no numbers from you. Cascade distances come from your camera, shadow map sizes
-  from how large each light looks on screen, and depth bias from constants that work. There is no
-  cascade array to hand-tune and no shadow budget to apportion.
-* **Auto-exposure** needs no exposure value. The engine meters the scene's brightness each frame,
-  weighted toward the centre of the image and ignoring the brightest and darkest few percent so a
-  bright sky or a dark corner does not drag the whole frame, then eases toward it - faster when the
-  scene brightens than when it darkens, the way an eye does. Walk from a dark interior into daylight
-  and it adjusts.
-* **Tonemapping** picks its own operator from the display: ACES on SDR, and a dedicated HDR curve
-  when the display is HDR.
-
-Opt-in, off by default: screen-space reflections, motion blur, depth of field, ReSTIR direct
-lighting, and a reference path tracer.
-
-**Global illumination** defaults to image-based. There is also a baked volumetric GI mode - probe
-bricks through the scene volume, in the shape Unreal's volumetric lightmaps take - which dynamic and
-skinned objects sample as they move through it. It bakes in-engine, from a live scene and renderer,
-so the precompute is a call you make rather than a tool you leave the engine for. Opaque and
-transparent surfaces both use it, so turning it on does not leave them lit differently.
-
----
-
-## Everything else
-
-The rest of what a game needs, in the same package. Each links out to its own documentation.
-
-* **Architecture.** A real ECS - one component per type per entity - with parent/child hierarchy
-  available without a scene graph. Allocation-conscious on the hot paths, so frame times stay flat
-  rather than sawtoothing against the garbage collector.
-* **Physics.** Deterministic rigid bodies in pure JavaScript, no WebAssembly and no worker threads,
-  with the determinism covered by replay tests - which is what lets it sit under rollback netcode.
-  Convex and mesh collision, continuous collision detection for fast movers, and bodies that stop
-  costing anything once they settle. A raycast vehicle, a character controller that handles stairs
-  and slopes, and inverse kinematics. [Fluid simulation](https://meep.company-named.com/docs/physics/fluid/) is
-  separate and can run off the main thread.
-* **Audio.** The Wwise/FMOD feature set without the middleware: events, a mixer bus tree, real-time
-  parameters, voice stealing, snapshots and ducking, all authored as engine data you can serialize.
-  Opt-in [acoustic simulation](https://meep.company-named.com/docs/audio/overview/) adds occlusion, transmission
-  and reverb driven by the scene's own geometry.
-* **[Networking](https://meep.company-named.com/docs/platform/networking/).** Server-authoritative
-  rollback: client-side prediction, reconciliation, and binary snapshots. Transports for WebRTC,
-  WebTransport, WebSocket and Node UDP, plus loopback and deliberately lossy ones for tests.
-  Bandwidth metering, packet record and replay, and cross-peer desync detection.
-* **Navigation & AI.** Grid A\*, and a [navigation
-  mesh](https://meep.company-named.com/docs/physics/navigation-meshes/) with any-angle paths and
-  obstacle carving at build time. Behaviour trees and blackboards, [Monte-Carlo tree
-  search](https://meep.company-named.com/docs/ai-and-simulation/) for agents that search a game tree
-  rather than follow one, and a planner for spending limited resources. Ray, box, frustum and point
-  queries against the scene.
-* **Procedural generation.** [A rule-driven grid
-  generator](https://meep.company-named.com/docs/generation/overview/): cellular automata, layered
-  grids, rule sets that place markers and spawn entities, theme-driven selection. Generation
-  composes as tasks over shared state, so building a world is a graph of steps rather than a script.
-* **Assets & codecs.** glTF, including meshopt compression, loading into **entities** rather than
-  one opaque tree. PNG, JPEG and AVIF decoded in-engine - the AV1 codec is a from-scratch encoder
-  *and* decoder in pure JavaScript, no WebAssembly. Web-first asset streaming, and binary
-  serialization that upgrades across versions.
-* **Tooling.** An in-app editor that attaches to and detaches from a running engine. GPU profile
-  capture that records per-pass timings and leaves the build entirely when you don't import it. A
-  software WebGPU implementation and a WGSL interpreter, so shaders and pipelines are testable on
-  machines with no GPU.
-* **Everything smaller.** Input across touch, mouse, keyboard and gamepad behind one abstraction ·
-  an optional DOM UI layer, replaceable with React or Vue · colour management with perceptual
-  spaces, HDR transfer functions, tone mapping and gamut clipping · node graphs · achievements ·
-  localisation · key-value storage over IndexedDB.
-
----
-
-## Shipping a build
-
-The engine carries ~6,100 assertions. They throw while you develop, and
-[`@rollup/plugin-strip`](https://github.com/rollup/plugins/tree/master/packages/strip) takes them
-out of a production build - its defaults already cover `assert.*`:
-
-```js
-// vite.config.js
-import strip from '@rollup/plugin-strip';
-export default defineConfig({
-    plugins: [{ ...strip(), apply: 'build' }]
-});
-```
-
-Note that those defaults also strip `console.*`.
-
----
-
-## Licence & pricing
-
-Copyright © 2026 Company Named Limited. All rights reserved.
-
-**Free for small projects.** You can build and ship commercially at no cost for as long as a project
-stays under US$50,000 in funding and US$50,000 in revenue. Evaluating the engine and building
-internal prototypes are free whatever your funding. Paid tiers - Indie, Standard, and Enterprise -
-raise that ceiling for a one-time fee per project, and add 24 months of major-version coverage.
-
-Short version: ship anything you like, just don't redistribute the source and don't build a
-competing engine.
-
-See the `LICENSE` file in the package for the terms covering this package, and the
-[pricing page](https://meep.company-named.com/pricing/) for the tier ladder.
+# Meep Engine
+
+**Build richly lit 3D worlds for the web in JavaScript.**
+
+Meep is a game engine with a GPU-driven WebGPU renderer, physics, spatial audio, rollback
+networking and an in-app editor.
+
+[Examples](https://meep.company-named.com/examples/) · [Documentation](https://meep.company-named.com/docs/getting-started/) · [Licence & pricing](https://meep.company-named.com/pricing/)
+
+## Getting started
+
+```shell
+npm install @woosh/meep-engine
+```
+
+Follow the [installation guide](https://meep.company-named.com/docs/installation/) for setup and
+WebGPU requirements. The package includes `samples/engine/first-scene/main.js`, a scene with
+lighting and keyboard input.
+
+## Rendering
+
+Lighting, shadows, decals, transparency and volumetric fog work together in an integrated pipeline
+with shared scene data.
+
+* **Thousands of dynamic lights.** The engine manages shadow coverage, resolution and updates,
+  while lighting work is concentrated on the pixels each light reaches.
+* **Large scenes with low CPU overhead.** GPU visibility culling and batched geometry keep draw
+  calls low as scenes grow. Deferred shading concentrates material evaluation on visible surfaces.
+* **Adaptive resolution.** The engine adjusts rendering resolution and upscales to the display size
+  to help maintain frame rate as load changes. This is enabled by default through `Engine`.
+* **Custom rendering passes.** Add effects through render extensions. The frame graph orders the
+  work by its dependencies and removes unused passes automatically.
+
+Shadows, ambient occlusion, image-based indirect lighting, auto-exposure, anti-aliasing and order-independent
+transparency are enabled by default, alongside tonemapping, bloom and sharpening. Tonemapping
+adapts to SDR and HDR displays.
+
+Optional features include baked volumetric global illumination, screen-space reflections, motion
+blur, depth of field, virtual texturing, a neural upscaler and a reference path tracer.
+
+See the [renderer guide](https://meep.company-named.com/docs/rendering/overview/) for scene setup,
+rendering controls and custom passes.
+
+## Engine features
+
+* **Architecture.** An entity-component system with parent/child hierarchies and allocation-conscious
+  hot paths.
+* **Physics.** Deterministic JavaScript rigid bodies, convex and mesh collision, continuous collision
+  detection, character and vehicle controllers, and inverse kinematics, plus
+  [fluid simulation](https://meep.company-named.com/docs/physics/fluid/).
+* **[Audio](https://meep.company-named.com/docs/audio/overview/).** Events, mixer buses, real-time
+  parameters, snapshots and ducking, with optional scene-driven occlusion, transmission and reverb.
+* **[Networking](https://meep.company-named.com/docs/platform/networking/).** Server-authoritative
+  rollback with prediction, reconciliation and binary snapshots over WebRTC, WebTransport,
+  WebSocket or Node UDP.
+* **Navigation & AI.** Grid and [navigation mesh](https://meep.company-named.com/docs/physics/navigation-meshes/)
+  pathfinding, behaviour trees, blackboards and [Monte-Carlo tree search](https://meep.company-named.com/docs/ai-and-simulation/).
+* **[Procedural generation](https://meep.company-named.com/docs/generation/overview/).** Rule-driven
+  grids, entity placement and reusable themes, composed as generation tasks.
+* **Assets.** glTF with meshopt compression, asset streaming, PNG/JPEG/AVIF decoding and versioned
+  binary serialization.
+* **Tools.** An editor for live scenes, per-pass GPU profiling, and a software WebGPU implementation
+  for shader and pipeline testing.
+* **Input & UI.** Touch, mouse, keyboard and gamepad input, an optional DOM UI layer, localisation,
+  achievements and persistent storage.
+
+In development since 2013 and used in a commercial Steam release. Automated tests cover physics
+determinism, networking and shader execution.
+
+## Production builds
+
+Use `@rollup/plugin-strip` to remove development assertions from production bundles. For Vite:
+
+```js
+// vite.config.js
+import { defineConfig } from 'vite';
+import strip from '@rollup/plugin-strip';
+
+export default defineConfig({
+    plugins: [{ ...strip(), apply: 'build' }]
+});
+```
+
+The plugin's defaults strip both `assert.*` and `console.*` calls.
+
+## Licence & pricing
+
+**Free for small projects.** Projects with both cumulative funding and cumulative revenue under
+US$50,000 each can ship commercially at no cost. Evaluation and internal prototypes are free
+regardless of funding. Paid licences are a one-time fee per project and include 24 months of
+major-version coverage.
+
+See the [licence overview](https://meep.company-named.com/license/) and
+[pricing page](https://meep.company-named.com/pricing/) for details. The package terms are in `LICENSE`.
+
+Copyright © 2026 Company Named Limited. All rights reserved.

package/editor/particles/effect/ParticleEffectDocument.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleEffectDocument.d.ts","sourceRoot":"","sources":["../../../../editor/particles/effect/ParticleEffectDocument.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"ParticleEffectDocument.d.ts","sourceRoot":"","sources":["../../../../editor/particles/effect/ParticleEffectDocument.js"],"names":[],"mappings":"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"}

package/editor/particles/effect/ParticleEffectDocument.js

@@ -173,7 +173,6 @@ export class ParticleEffectDocument {
         projection: EMITTER_PROJECTION.BILLBOARD,
         lighting: false,
         soft_depth: false,
-        sort: false,
         cull: false,
         /** image to draw with, by URL; null draws against the default atlas, a white texel */
         texture: null,
@@ -891,7 +890,6 @@ export class ParticleEffectDocument {
                 projection: this.emitter.projection,
                 lighting: this.emitter.lighting,
                 soft_depth: this.emitter.soft_depth,
-                sort: this.emitter.sort,
                 cull: this.emitter.cull,
             },
             texture: this.emitter.texture,
@@ -910,7 +908,6 @@ export class ParticleEffectDocument {
             projection: this.emitter.projection,
             lighting: this.emitter.lighting,
             soft_depth: this.emitter.soft_depth,
-            sort: this.emitter.sort,
             cull: this.emitter.cull,
         });
     }

package/editor/particles/effect/ParticleReferenceSimulation.js

@@ -21,7 +21,7 @@ import { execute_particle_vm } from "../../../src/shade/renderer/particles/vm/Pa
  * on the same records, and what differs is only how many of them and who draws the result.
  *
  * What it deliberately does not do is anything the GPU passes do *around* the VM: no coherence
- * bucketing, no depth sort, no occupancy, no transparency pipeline. Those decide how a frame is
+ * bucketing, no measured bounds, no occupancy, no transparency pipeline. Those decide how a frame is
  * built, not what a particle is, and a preview that reproduced them would be a second renderer to
  * keep in step.
  *

package/editor/persistence/SceneMetadata.d.ts

@@ -4,12 +4,17 @@
 export class SceneMetadata {
     /**
      *
-     * @param {string} name
-     * @param {number} timestamp
-     * @param {number} byte_size
+     * @param {Object} options
+     * @param {string} options.name
+     * @param {number} options.timestamp
+     * @param {number} options.byte_size
      * @returns {SceneMetadata}
      */
-    static from({ name, timestamp, byte_size }: string): SceneMetadata;
+    static from({ name, timestamp, byte_size }: {
+        name: string;
+        timestamp: number;
+        byte_size: number;
+    }): SceneMetadata;
     /**
      * @type {string}
      */

package/editor/persistence/SceneMetadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SceneMetadata.d.ts","sourceRoot":"","sources":["../../../editor/persistence/SceneMetadata.js"],"names":[],"mappings":"AAAA;;GAEG;AACH;IAkBI;;;;;;OAMG;IACH,4CALW,MAAM,GAGJ,aAAa,CAUzB;IAhCD;;OAEG;IACH,MAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,WAFU,MAAM,CAEF;IAmBd;;;;MAMC;IAED;;;;aAIC;CACJ"}
+{"version":3,"file":"SceneMetadata.d.ts","sourceRoot":"","sources":["../../../editor/persistence/SceneMetadata.js"],"names":[],"mappings":"AAAA;;GAEG;AACH;IAkBI;;;;;;;OAOG;IACH;QAL2B,IAAI,EAApB,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,SAAS,EAAzB,MAAM;QACJ,aAAa,CAUzB;IAjCD;;OAEG;IACH,MAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,WAFU,MAAM,CAEF;IAoBd;;;;MAMC;IAED;;;;aAIC;CACJ"}

package/editor/persistence/SceneMetadata.js

@@ -21,9 +21,10 @@ export class SceneMetadata {
 
     /**
      *
-     * @param {string} name
-     * @param {number} timestamp
-     * @param {number} byte_size
+     * @param {Object} options
+     * @param {string} options.name
+     * @param {number} options.timestamp
+     * @param {number} options.byte_size
      * @returns {SceneMetadata}
      */
     static from({ name, timestamp, byte_size }) {

package/editor/tools/TransformToolV2.d.ts

@@ -15,7 +15,7 @@ export class TransformToolV2 extends Tool {
     /**
      * @type {ObservedValue<string>} one of {@link TransformMode}
      */
-    mode: any;
+    mode: ObservedValue<string>;
     /**
      * @type {TransformControls|null}
      */
@@ -65,6 +65,7 @@ export class TransformToolV2 extends Tool {
     handleKeyboardEvent(event: KeyboardEvent): void;
 }
 import Tool from "./engine/Tool.js";
+import ObservedValue from "../../src/core/model/ObservedValue.js";
 import { TransformControls } from "./v2/TransformControls.js";
 import { Transform64 } from "../../src/engine/ecs/transform/Transform64.js";
 //# sourceMappingURL=TransformToolV2.d.ts.map

package/editor/tools/TransformToolV2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransformToolV2.d.ts","sourceRoot":"","sources":["../../../editor/tools/TransformToolV2.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;GAWG;AACH;IACI,aAA2B;IAE3B;;OAEG;IACH,UAAkD;IAElD;;OAEG;IACH,YAFU,iBAAiB,GAAC,IAAI,CAEd;IAElB;;;OAGG;IACH,gBAFU,OAAO,CAEM;IAuBnB;;;OAGG;IACH,kBAFU,IAAI,MAAM,EAAE,WAAW,CAAC,CAED;IAGrC;;;OAGG;IACH,kCAEC;IAED;;OAEG;IACH,wCAEC;IAED;;;OAGG;IACH,mBAFa,MAAM,CAclB;IAED,iCAUC;IAED,0BAiCC;IAED;;OAEG;IACH,6BAgFC;IAED;;OAEG;IACH,wBA+BC;IA2DD,6BAgCC;IAED,4BAEC;IAED,6BAEC;IAED,4BAQC;IAED;;;OAGG;IACH,2BAFW,aAAa,QAkBvB;CACJ;iBAnZgB,kBAAkB;kCACD,2BAA2B;4BAJjC,+CAA+C"}
+{"version":3,"file":"TransformToolV2.d.ts","sourceRoot":"","sources":["../../../editor/tools/TransformToolV2.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;GAWG;AACH;IACI,aAA2B;IAE3B;;OAEG;IACH,MAFU,cAAc,MAAM,CAAC,CAEmB;IAElD;;OAEG;IACH,YAFU,iBAAiB,GAAC,IAAI,CAEd;IAElB;;;OAGG;IACH,gBAFU,OAAO,CAEM;IAuBnB;;;OAGG;IACH,kBAFU,IAAI,MAAM,EAAE,WAAW,CAAC,CAED;IAGrC;;;OAGG;IACH,kCAEC;IAED;;OAEG;IACH,wCAEC;IAED;;;OAGG;IACH,mBAFa,MAAM,CAclB;IAED,iCAUC;IAED,0BAiCC;IAED;;OAEG;IACH,6BAgFC;IAED;;OAEG;IACH,wBA+BC;IA2DD,6BAgCC;IAED,4BAEC;IAED,6BAEC;IAED,4BAQC;IAED;;;OAGG;IACH,2BAFW,aAAa,QAkBvB;CACJ;iBAnZgB,kBAAkB;0BAJT,uCAAuC;kCAK/B,2BAA2B;4BAJjC,+CAA+C"}

package/editor/tools/engine/Tool.d.ts

@@ -1,7 +1,7 @@
 export default Tool;
 declare class Tool {
     name: any;
-    mode: ObservedValue;
+    mode: ObservedValue<any>;
     settings: {};
     modifiers: {
         shift: boolean;

package/editor/tools/engine/Tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Tool.d.ts","sourceRoot":"","sources":["../../../../editor/tools/engine/Tool.js"],"names":[],"mappings":";AAIA;IAGI,UAAY;IACZ,oBAA2B;IAC3B,aAAc;IACd;;;MAGE;IAEF;;;OAGG;IACH,QAFU,SAAO,IAAI,CAEP;IAEd;;;OAGG;IACH,QAFU,SAAO,IAAI,CAEP;IAEd;;;OAGG;IACH,MAFU,cAAc,CAEM;IAS9B;;;OAGG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,yCAFa,OAAK,IAAI,CAIrB;IAED;;;OAGG;IACH,YAFa,SAAS,GAAC,MAAM,CAI5B;IAED,qBAEC;IAED;;OAEG;IACH,mBAEC;IAED;;OAEG;IACH,iBAEC;IAED;;OAEG;IACH,eAEC;IAED;;;;;;OAMG;IACH,cAIC;IAED;;;;;OAKG;IACH,aASC;IAED;;;;OAIG;IACH,oBAEC;IAED;;;OAGG;IACH,mBAEC;IAED,kCAEC;;CACJ;0BA7IyB,0CAA0C;2BADzC,2CAA2C;0BAE5C,gBAAgB"}
+{"version":3,"file":"Tool.d.ts","sourceRoot":"","sources":["../../../../editor/tools/engine/Tool.js"],"names":[],"mappings":";AAIA;IAGI,UAAY;IACZ,yBAA2B;IAC3B,aAAc;IACd;;;MAGE;IAEF;;;OAGG;IACH,QAFU,SAAO,IAAI,CAEP;IAEd;;;OAGG;IACH,QAFU,SAAO,IAAI,CAEP;IAEd;;;OAGG;IACH,MAFU,cAAc,CAEM;IAS9B;;;OAGG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,yCAFa,OAAK,IAAI,CAIrB;IAED;;;OAGG;IACH,YAFa,SAAS,GAAC,MAAM,CAI5B;IAED,qBAEC;IAED;;OAEG;IACH,mBAEC;IAED;;OAEG;IACH,iBAEC;IAED;;OAEG;IACH,eAEC;IAED;;;;;;OAMG;IACH,cAIC;IAED;;;;;OAKG;IACH,aASC;IAED;;;;OAIG;IACH,oBAEC;IAED;;;OAGG;IACH,mBAEC;IAED,kCAEC;;CACJ;0BA7IyB,0CAA0C;2BADzC,2CAA2C;0BAE5C,gBAAgB"}

package/editor/tools/engine/ToolEngine.d.ts

@@ -1,7 +1,7 @@
 export default ToolEngine;
 declare class ToolEngine {
     tools: List<any>;
-    active: ObservedValue;
+    active: ObservedValue<any>;
     engine: any;
     isRunning: boolean;
     shutdownCallbacks: any[];

package/editor/tools/engine/ToolEngine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ToolEngine.d.ts","sourceRoot":"","sources":["../../../../editor/tools/engine/ToolEngine.js"],"names":[],"mappings":";AAYA;IACI,iBAAmB;IACnB,sBAAiC;IACjC,YAAc;IACd,mBAAkB;IAClB,yBAAuB;IACvB,aAAe;IA2Bf;;;OAGG;IACH,gBAFU,MAAM,CAEc;IAE9B;;;OAGG;IACH,cAFU,MAAM,CAEY;IAE5B;;OAEG;IACH,8BAEC;IAED,8BAOC;IAED,mBA8BC;IAED;;;;OAIG;IACH,8CA2EC;IAzEG,eAAoB;IA2ExB;;;;;OAKG;IACH;;;;;OAKG;IACH,gCAUC;IAED,oBAeC;IAED,iBAwBC;;CACJ;iBA7PgB,2CAA2C;0BAElC,0CAA0C;mBADjD,2CAA2C"}
+{"version":3,"file":"ToolEngine.d.ts","sourceRoot":"","sources":["../../../../editor/tools/engine/ToolEngine.js"],"names":[],"mappings":";AAYA;IACI,iBAAmB;IACnB,2BAAiC;IACjC,YAAc;IACd,mBAAkB;IAClB,yBAAuB;IACvB,aAAe;IA2Bf;;;OAGG;IACH,gBAFU,MAAM,CAEc;IAE9B;;;OAGG;IACH,cAFU,MAAM,CAEY;IAE5B;;OAEG;IACH,8BAEC;IAED,8BAOC;IAED,mBA8BC;IAED;;;;OAIG;IACH,8CA2EC;IAzEG,eAAoB;IA2ExB;;;;;OAKG;IACH;;;;;OAKG;IACH,gCAUC;IAED,oBAeC;IAED,iBAwBC;;CACJ;iBA7PgB,2CAA2C;0BAElC,0CAA0C;mBADjD,2CAA2C"}

package/editor/view/ecs/EntityEditor.d.ts

@@ -2,11 +2,11 @@ export default EntityEditor;
 declare class EntityEditor extends View {
     constructor(editor: any);
     el: Element;
-    model: ObservedValue;
+    model: ObservedValue<any>;
     /**
      * @type {ObservedValue<EntityManager>}
      */
-    entityManager: any;
+    entityManager: ObservedValue<EntityManager>;
     components: List<any>;
     /**
      *
@@ -19,6 +19,7 @@ declare class EntityEditor extends View {
 }
 import View from "../../../src/view/View.js";
 import ObservedValue from '../../../src/core/model/ObservedValue.js';
+import { EntityManager } from "../../../src/engine/ecs/EntityManager.js";
 import List from '../../../src/core/collection/list/List.js';
 import { ComponentControlView } from "./ComponentControlView.js";
 import LabelView from '../../../src/view/common/LabelView.js';

package/editor/view/ecs/EntityEditor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityEditor.d.ts","sourceRoot":"","sources":["../../../../editor/view/ecs/EntityEditor.js"],"names":[],"mappings":";AAkBA;IAYI,yBAyOC;IAhOG,YAAkB;IAGlB,qBAAoC;IACpC;;OAEG;IACH,mBAA4C;IAC5C,sBAA4B;IAU5B;;;OAGG;IACH,sBAFU,mCAAiC,CAEN;IAsGrC,wBAEE;IAiGF,aAAkB;;CAazB;iBAzQgB,2BAA2B;0BATlB,0CAA0C;iBADnD,2CAA2C;qCAcvB,2BAA2B;sBAT1C,uCAAuC"}
+{"version":3,"file":"EntityEditor.d.ts","sourceRoot":"","sources":["../../../../editor/view/ecs/EntityEditor.js"],"names":[],"mappings":";AAkBA;IAYI,yBAyOC;IAhOG,YAAkB;IAGlB,0BAAoC;IACpC;;OAEG;IACH,eAFU,cAAc,aAAa,CAAC,CAEM;IAC5C,sBAA4B;IAU5B;;;OAGG;IACH,sBAFU,mCAAiC,CAEN;IAsGrC,wBAEE;IAiGF,aAAkB;;CAazB;iBAzQgB,2BAA2B;0BATlB,0CAA0C;8BAEtC,0CAA0C;iBAHvD,2CAA2C;qCAcvB,2BAA2B;sBAT1C,uCAAuC"}

package/editor/view/ecs/EntityList.d.ts

@@ -2,10 +2,14 @@ export default EntityListView;
 declare class EntityListView extends View {
     /**
      *
-     * @param {Editor} editor
-     * @param { ((entity: number, ecd: EntityComponentDataset, view: View) => void)[]} decorators
+     * @param {Object} options
+     * @param {Editor} options.editor
+     * @param { ((entity: number, ecd: EntityComponentDataset, view: View) => void)[]} options.decorators
      */
-    constructor({ editor, decorators }: Editor);
+    constructor({ editor, decorators }: {
+        editor: Editor;
+        decorators: ((entity: number, ecd: EntityComponentDataset, view: View) => void)[];
+    });
     el: HTMLDivElement;
     on: {};
     editor: Editor;

package/editor/view/ecs/EntityList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityList.d.ts","sourceRoot":"","sources":["../../../../editor/view/ecs/EntityList.js"],"names":[],"mappings":";AA6DA;IAGI;;;;OAIG;IACH,4CAmJC;IA1JD,mBAAmC;IAgB3B,OAAY;IAQhB,eAAoB;IAuGpB;;;;;;MAUC;IAmBL,eAEC;CAsCJ;iBA1PgB,2BAA2B"}
+{"version":3,"file":"EntityList.d.ts","sourceRoot":"","sources":["../../../../editor/view/ecs/EntityList.js"],"names":[],"mappings":";AA6DA;IAGI;;;;;OAKG;IACH;QAH2B,MAAM;QAC0D,UAAU,EAAzF,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,wBAAwB,EAAE,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC,EAAE;OAqJhF;IA3JD,mBAAmC;IAiB3B,OAAY;IAQhB,eAAoB;IAuGpB;;;;;;MAUC;IAmBL,eAEC;CAsCJ;iBA3PgB,2BAA2B"}

package/editor/view/ecs/EntityList.js

@@ -64,8 +64,9 @@ class EntityListView extends View {
 
     /**
      *
-     * @param {Editor} editor
-     * @param { ((entity: number, ecd: EntityComponentDataset, view: View) => void)[]} decorators
+     * @param {Object} options
+     * @param {Editor} options.editor
+     * @param { ((entity: number, ecd: EntityComponentDataset, view: View) => void)[]} options.decorators
      */
     constructor({
                     editor,

package/editor/view/ecs/components/common/NumericIntervalController.d.ts

@@ -1,10 +1,15 @@
 export class NumericIntervalController extends View {
     /**
      *
-     * @param {NumericInterval} interval
-     * @param {string} tag
+     * @param {Object} options
+     * @param {NumericInterval} options.interval
+     * @param {string} options.tag
      */
-    constructor({ interval, tag }: NumericInterval);
+    constructor({ interval, tag }: {
+        interval: NumericInterval;
+        tag: string;
+    });
+    el: HTMLElement;
 }
 import View from "../../../../../src/view/View.js";
 //# sourceMappingURL=NumericIntervalController.d.ts.map

package/editor/view/ecs/components/common/NumericIntervalController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NumericIntervalController.d.ts","sourceRoot":"","sources":["../../../../../../editor/view/ecs/components/common/NumericIntervalController.js"],"names":[],"mappings":"AAMA;IACI;;;;OAIG;IACH,gDAkDC;CACJ;iBA7DgB,iCAAiC"}
+{"version":3,"file":"NumericIntervalController.d.ts","sourceRoot":"","sources":["../../../../../../editor/view/ecs/components/common/NumericIntervalController.js"],"names":[],"mappings":"AAMA;IACI;;;;;OAKG;IACH;QAHoC,QAAQ;QACjB,GAAG,EAAnB,MAAM;OAoDhB;IA/CG,gBAAqC;CAgD5C;iBA9DgB,iCAAiC"}

package/editor/view/ecs/components/common/NumericIntervalController.js

@@ -7,8 +7,9 @@ import { NumberController } from "./NumberController.js";
 export class NumericIntervalController extends View {
     /**
      *
-     * @param {NumericInterval} interval
-     * @param {string} tag
+     * @param {Object} options
+     * @param {NumericInterval} options.interval
+     * @param {string} options.tag
      */
     constructor({ interval, tag = 'div' }) {
         super();

package/editor/view/ecs/components/common/TextController.d.ts

@@ -5,10 +5,14 @@
 export class TextController extends View {
     /**
      *
-     * @param {string[]} [classList]
-     * @param {string} [value]
+     * @param {Object} [options]
+     * @param {string[]} [options.classList]
+     * @param {string} [options.value]
      */
-    constructor({ classList, value }?: string[]);
+    constructor({ classList, value }?: {
+        classList?: string[];
+        value?: string;
+    });
     /**
      *
      * @type {ObservedString}

package/editor/view/ecs/components/common/TextController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TextController.d.ts","sourceRoot":"","sources":["../../../../../../editor/view/ecs/components/common/TextController.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH;IACI;;;;OAIG;IACH,mCAHW,MAAM,EAAE,EA+ClB;IAvCG;;;OAGG;IACH,OAFU,cAAc,CAEL;IAGnB,qBAAY;CAiCnB;iBAzDgB,iCAAiC;2BADvB,iDAAiD"}
+{"version":3,"file":"TextController.d.ts","sourceRoot":"","sources":["../../../../../../editor/view/ecs/components/common/TextController.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH;IACI;;;;;OAKG;IACH;QAH8B,SAAS,GAA5B,MAAM,EAAE;QACS,KAAK,GAAtB,MAAM;OA8ChB;IAvCG;;;OAGG;IACH,OAFU,cAAc,CAEL;IAGnB,qBAAY;CAiCnB;iBA1DgB,iCAAiC;2BADvB,iDAAiD"}

package/editor/view/ecs/components/common/TextController.js

@@ -8,8 +8,9 @@ import View from "../../../../../src/view/View.js";
 export class TextController extends View {
     /**
      *
-     * @param {string[]} [classList]
-     * @param {string} [value]
+     * @param {Object} [options]
+     * @param {string[]} [options.classList]
+     * @param {string} [options.value]
      */
     constructor({ classList = [], value = "" } = {}) {
         super();

package/editor/view/library/MeshLibraryView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MeshLibraryView.d.ts","sourceRoot":"","sources":["../../../../editor/view/library/MeshLibraryView.js"],"names":[],"mappings":";AAuGA;IACI;;;;;OAKG;IACH,8CAHW,6BAA6B,EA6DvC;IAnDG,YAAgB;IAEhB,kBAAwB;IA4CxB,mBAAoB;CAM3B;iBAzKgB,2BAA2B;iBAI3B,2CAA2C"}
+{"version":3,"file":"MeshLibraryView.d.ts","sourceRoot":"","sources":["../../../../editor/view/library/MeshLibraryView.js"],"names":[],"mappings":";AAwGA;IACI;;;;;OAKG;IACH,8CAHW,6BAA6B,EA6DvC;IAnDG,YAAgB;IAEhB,kBAAwB;IA4CxB,mBAAoB;CAM3B;iBA1KgB,2BAA2B;iBAI3B,2CAA2C"}