@playcanvas/web-components 0.16.0 → 0.17.0

package/dist/pwc.cjs

@@ -29,13 +29,13 @@ class AsyncElement extends HTMLElement {
         return this.parentElement?.closest('pc-app') ?? null;
     }
     /**
-     * The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or
-     * `null` if this element has no such ancestor. The search starts at the parent, so an element
-     * never resolves to itself.
+     * The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or
+     * `<pc-node>` — or `null` if this element has no such ancestor. The search starts at the
+     * parent, so an element never resolves to itself.
      * @returns The closest entity-fronting element, or `null`.
      */
     get closestEntity() {
-        return this.parentElement?.closest('pc-entity, pc-node') ?? null;
+        return this.parentElement?.closest('pc-entity, pc-model, pc-node') ?? null;
     }
     /**
      * Called when the element is fully initialized and ready. Subclasses should call this when
@@ -109,9 +109,9 @@ async function whenReady(target) {
 }
 
 /**
- * The ModuleElement interface provides properties and methods for manipulating
- * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-module/ | `<pc-module>`}
- * elements. The ModuleElement interface also inherits the properties and methods of the
+ * The WasmElement interface provides properties and methods for manipulating
+ * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-wasm/ | `<pc-wasm>`}
+ * elements. The WasmElement interface also inherits the properties and methods of the
  * {@link AsyncElement} interface.
  *
  * The attributes are read once, when the module starts loading - on the element's first
@@ -120,7 +120,7 @@ async function whenReady(target) {
  * modules configure engine-global state that never unloads, so readiness is not re-armed by
  * removing the element, and a re-inserted element does not load again.
  *
- * A `<pc-module>` without a `name` warns and never becomes ready; a containing `<pc-app>` still
+ * A `<pc-wasm>` without a `name` warns and never becomes ready; a containing `<pc-app>` still
  * boots.
  *
  * @attribute {string} name - The name of the WebAssembly module to configure, e.g. `Basis` or
@@ -130,7 +130,7 @@ async function whenReady(target) {
  * @attribute {string} fallback - The URL of the module's asm.js fallback script, used when
  * WebAssembly is unavailable.
  */
-class ModuleElement extends AsyncElement {
+class WasmElement extends AsyncElement {
     _loadPromise = null;
     connectedCallback() {
         this._getLoadPromise();
@@ -138,7 +138,7 @@ class ModuleElement extends AsyncElement {
     async _loadModule() {
         const name = this.getAttribute('name');
         if (!name) {
-            console.warn("pc-module requires a 'name' attribute - no module was configured");
+            console.warn("pc-wasm requires a 'name' attribute - no module was configured");
             return;
         }
         const config = {
@@ -173,7 +173,7 @@ class ModuleElement extends AsyncElement {
         return this._loadPromise;
     }
 }
-customElements.define('pc-module', ModuleElement);
+customElements.define('pc-wasm', WasmElement);
 
 /** Covers the 0.2s opacity transition; jsdom never fires transitionend, so removal is timed. */
 const REMOVAL_DELAY_MS = 250;
@@ -730,6 +730,12 @@ const getEntity = (ref) => {
 
 /** The pointer event types the application synthesizes on `<pc-entity>` elements via picking. */
 const pointerEventTypes = ['pointermove', 'pointerdown', 'pointerup', 'pointerenter', 'pointerleave'];
+/**
+ * The event types whose listeners make an element a hover target. Hover resolution walks past
+ * elements listening for none of them, so a silent element never swallows an ancestor's
+ * enter/leave pair.
+ */
+const hoverEventTypes = ['pointerenter', 'pointerleave', 'pointermove'];
 /**
  * Gives `pc-app` the sizing contract of a replaced element (`<video>`, `<img>`): a block-level
  * box that the page's CSS sizes, defaulting to the canvas's own 300x150 intrinsic size, with the
@@ -804,9 +810,9 @@ class AppElement extends AsyncElement {
     _bootGeneration = 0;
     /**
      * The elements backing this application's entities, keyed by the entity itself. Registered
-     * by EntityElement at creation (and NodeElement at binding) and removed when an entity is
-     * destroyed or unbound, this joins engine scene nodes back to their owning elements by
-     * identity - never by name.
+     * by entity-owning elements at creation (pc-entity, and pc-model for its host) and by
+     * NodeElement at binding, and removed when an entity is destroyed or unbound, this joins
+     * engine scene nodes back to their owning elements by identity - never by name.
      */
     _entityElements = new Map();
     _picker = null;
@@ -885,7 +891,7 @@ class AppElement extends AsyncElement {
         // there, leaving the element permanently unready: no canvas, no entities, no application.
         //
         // Upgrading is the fix here rather than skipping whatever has not upgraded, because a
-        // <pc-module> is the one child that nothing else ever builds on its own behalf - skipping
+        // <pc-wasm> is the one child that nothing else ever builds on its own behalf - skipping
         // it would drop the wasm module the app asked for, silently and only for cloned apps.
         // Upgrading runs each descendant's connectedCallback synchronously, a few lines earlier
         // than the parser's path runs them but into the same state they see there: no application
@@ -894,10 +900,10 @@ class AppElement extends AsyncElement {
         // as any other disconnect is. An already-upgraded subtree - every other insertion path -
         // is left completely untouched.
         customElements.upgrade(this);
-        // Get all pc-module elements that are direct children of the pc-app element
-        const moduleElements = this.querySelectorAll(':scope > pc-module');
+        // Get all pc-wasm elements that are direct children of the pc-app element
+        const wasmElements = this.querySelectorAll(':scope > pc-wasm');
         // Wait for all modules to load
-        await Promise.all(Array.from(moduleElements).map((module) => module._getLoadPromise()));
+        await Promise.all(Array.from(wasmElements).map((element) => element._getLoadPromise()));
         // The element may have been removed while the modules loaded. Nothing beyond the loading
         // bar exists yet, and disconnectedCallback has already destroyed that.
         if (generation !== this._bootGeneration) {
@@ -1067,14 +1073,15 @@ class AppElement extends AsyncElement {
         Array.from(materialElements).forEach((materialElement) => {
             materialElement._createMaterial();
         });
-        // Create all entities
-        const entityElements = this.querySelectorAll('pc-entity');
-        Array.from(entityElements).forEach((entityElement) => {
-            entityElement._createEntity(app);
+        // Create all entities. pc-model joins the sweep because it owns a host entity of its
+        // own; its instantiated content arrives later, beneath that host.
+        const ownerElements = this.querySelectorAll('pc-entity, pc-model');
+        Array.from(ownerElements).forEach((ownerElement) => {
+            ownerElement._createEntity(app);
         });
         // Build hierarchy
-        entityElements.forEach((entityElement) => {
-            entityElement._buildHierarchy(app);
+        ownerElements.forEach((ownerElement) => {
+            ownerElement._buildHierarchy(app);
         });
         // Building the hierarchy dispatched each entity's ready event synchronously, and a
         // listener may have removed the element. The sweep itself degrades safely - destroying
@@ -1185,7 +1192,7 @@ class AppElement extends AsyncElement {
         // created from onpointer* attributes when their elements were first upgraded, or
         // listeners carried over from before a re-boot)
         pointerEventTypes.forEach((type) => {
-            const anyListeners = Array.from(this.querySelectorAll('pc-entity, pc-node')).some((entity) => entity._hasListeners(type));
+            const anyListeners = Array.from(this.querySelectorAll('pc-entity, pc-model, pc-node')).some((entity) => entity._hasListeners(type));
             if (anyListeners) {
                 this._onPointerListenerAdded(type);
             }
@@ -1235,10 +1242,10 @@ class AppElement extends AsyncElement {
         this._entityElements.delete(entity);
     }
     /**
-     * Returns the `<pc-entity>` or `<pc-node>` element whose backing entity is `entity`, or
-     * `null` if the entity is not fronted by an element of this application - for example, an
-     * unbound node inside a model's instantiated hierarchy, or an entity created through the
-     * engine API.
+     * Returns the `<pc-entity>`, `<pc-model>` or `<pc-node>` element whose backing entity is
+     * `entity`, or `null` if the entity is not fronted by an element of this application - for
+     * example, an unbound node inside a model's instantiated hierarchy, or an entity created
+     * through the engine API.
      *
      * @param entity - The entity to look up.
      * @returns The element fronting the entity, or `null`.
@@ -1247,18 +1254,19 @@ class AppElement extends AsyncElement {
         return this._entityElements.get(entity) ?? null;
     }
     /**
-     * Resolves the element that owns a picked node: the nearest node up the parent chain -
-     * starting with the node itself - that is fronted by a `<pc-entity>` or `<pc-node>` of this
-     * application. A hit inside a model's instantiated hierarchy therefore resolves to the
-     * nearest bound `<pc-node>`, or failing that the element hosting the model.
+     * Resolves the element that owns hover for a picked node: the nearest node up the parent
+     * chain - starting with the node itself - whose element listens for any of the hover event
+     * types. Skipping silent elements matches {@link _elementWithListener}, so a registered
+     * element with no hover listeners (a `<pc-model>` host, a plain child entity) is transparent
+     * to hover rather than swallowing a listening ancestor's enter/leave pair.
      *
      * @param node - The picked node, or `null`.
-     * @returns The owning element, or `null`.
+     * @returns The hover-owning element, or `null`.
      */
-    _elementFromNode(node) {
+    _hoverTarget(node) {
         while (node !== null) {
             const element = this._entityElements.get(node);
-            if (element) {
+            if (element && hoverEventTypes.some((type) => element._hasListeners(type))) {
                 return element;
             }
             node = node.parent;
@@ -1394,9 +1402,10 @@ class AppElement extends AsyncElement {
         const node = await this._pickNode(event);
         if (token !== this._pickToken || !this._picker)
             return;
-        // The hovered element is the nearest one up the node's parent chain, listening or not -
-        // dispatch is gated per event type below
-        const newHoverEntity = this._elementFromNode(node);
+        // The hovered element is the nearest one up the node's parent chain with a hover
+        // listener - the nearest-listener rule down/up use. Dispatch is still gated per event
+        // type below: having any hover listener selects the target, each event needs its own.
+        const newHoverEntity = this._hoverTarget(node);
         // Handle enter/leave events
         if (this._hoveredEntity !== newHoverEntity) {
             if (this._hoveredEntity && this._hoveredEntity._hasListeners('pointerleave')) {
@@ -1448,7 +1457,7 @@ class AppElement extends AsyncElement {
         }
     }
     _onPointerListenerRemoved(type) {
-        const hasListeners = Array.from(this.querySelectorAll('pc-entity, pc-node')).some((entity) => entity._hasListeners(type));
+        const hasListeners = Array.from(this.querySelectorAll('pc-entity, pc-model, pc-node')).some((entity) => entity._hasListeners(type));
         if (!hasListeners && this._canvas) {
             this._hasPointerListeners[type] = false;
             const handler = type === 'pointerenter' || type === 'pointerleave'
@@ -1639,11 +1648,12 @@ const POINTER_ATTRIBUTES = [
     'onpointermove'
 ];
 /**
- * The base class for elements that front an engine {@link Entity}: `<pc-entity>`, which creates
- * one, and `<pc-node>`, which binds to one inside a model's instantiated hierarchy. It carries
- * what both need — the `entity` contract, registration with the owning application (which joins
- * picked scene nodes back to elements by identity, never by name), and the pointer listener
- * bookkeeping that lets the application lazily attach its canvas handlers.
+ * The base class for elements that front an engine {@link Entity}: `<pc-entity>` and
+ * `<pc-model>`, which create one, and `<pc-node>`, which binds to one inside a model's
+ * instantiated hierarchy. It carries what all of them need — the `entity` contract, registration
+ * with the owning application (which joins picked scene nodes back to elements by identity,
+ * never by name), and the pointer listener bookkeeping that lets the application lazily attach
+ * its canvas handlers.
  */
 class EntityBaseElement extends AsyncElement {
     _entity = null;
@@ -1746,17 +1756,17 @@ class EntityBaseElement extends AsyncElement {
 }
 
 /**
- * Creates and parents the entities of every descendant `<pc-entity>` of `root`, in two passes so
- * that no parent's existence depends on document order. Called wherever a subtree could not build
- * itself: an element inserted into an application that is already running, and a `<pc-node>` whose
- * children waited for it to bind.
+ * Creates and parents the entities of every descendant entity-owning element of `root`, in two
+ * passes so that no parent's existence depends on document order. Called wherever a subtree could
+ * not build itself: an element inserted into an application that is already running, and a
+ * `<pc-node>` whose children waited for it to bind.
  *
  * Descendants that are not yet custom elements are skipped, because there is nothing useful to do
  * for them and reaching for `_createEntity` would throw. A subtree cloned from a `<template>`
  * arrives entirely unupgraded — template content lives in an inert document, where custom element
  * definitions are never looked up — and appending the clone upgrades its elements in tree order,
  * an element before its descendants. So a sweep from an element's own `connectedCallback` sees
- * plain `HTMLElement`s below it. Each becomes an `EntityElement` moments later and its own
+ * plain `HTMLElement`s below it. Each becomes an entity-owning element moments later and its own
  * `connectedCallback` creates and parents it, by which time the ancestor it parents under has its
  * entity — the same guarantee tree order gives this sweep.
  *
@@ -1765,35 +1775,18 @@ class EntityBaseElement extends AsyncElement {
  * @internal
  */
 const buildDescendantEntities = (root, app) => {
-    const children = Array.from(root.querySelectorAll('pc-entity')).filter((child) => child instanceof EntityElement);
+    const children = Array.from(root.querySelectorAll('pc-entity, pc-model')).filter((child) => child instanceof EntityOwnerElement);
     children.forEach((child) => child._createEntity(app));
     children.forEach((child) => child._buildHierarchy(app));
 };
 /**
- * The EntityElement interface provides properties and methods for manipulating
- * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-entity/ | `<pc-entity>`} elements.
- * The EntityElement interface also inherits the properties and methods of the
- * {@link HTMLElement} interface.
- *
- * The pointer events below are dispatched by the containing `<pc-app>` element when the pointer
- * intersects this entity's geometry. They are only generated while the entity has a listener for
- * them, registered either with {@link addEventListener} or with the matching inline `onpointer*`
- * attribute.
- *
- * @attribute {string} onpointerenter - Script to run when the pointer moves onto the entity.
- * @attribute {string} onpointerleave - Script to run when the pointer moves off the entity.
- * @attribute {string} onpointermove - Script to run when the pointer moves over the entity.
- * @attribute {string} onpointerdown - Script to run when a pointer button is pressed over the
- * entity.
- * @attribute {string} onpointerup - Script to run when a pointer button is released over the
- * entity.
- * @fires {PointerEvent} pointerenter - Fired when the pointer moves onto the entity.
- * @fires {PointerEvent} pointerleave - Fired when the pointer moves off the entity.
- * @fires {PointerEvent} pointermove - Fired when the pointer moves over the entity.
- * @fires {PointerEvent} pointerdown - Fired when a pointer button is pressed over the entity.
- * @fires {PointerEvent} pointerup - Fired when a pointer button is released over the entity.
+ * The base class for elements that create and own their backing entity: `<pc-entity>` and
+ * `<pc-model>`, whose host entity carries the same authored properties. It carries the cached
+ * property state, entity creation and parenting, and the reset that follows the entity's
+ * destruction. `<pc-node>` sits outside this class: it borrows an entity a model instantiated,
+ * and its properties are nullable overrides rather than owned values.
  */
-class EntityElement extends EntityBaseElement {
+class EntityOwnerElement extends EntityBaseElement {
     /**
      * Whether the entity is enabled.
      */
@@ -1819,7 +1812,8 @@ class EntityElement extends EntityBaseElement {
      */
     _tags = [];
     /**
-     * Whether the hierarchy has been built for this entity.
+     * Whether the hierarchy has been built for this entity — set once {@link _buildHierarchy} has
+     * parented it. Read by subclasses that gate work on the entity being in the scene graph.
      */
     _built = false;
     /**
@@ -1872,10 +1866,10 @@ class EntityElement extends EntityBaseElement {
         this._resetReady();
     }
     /**
-     * Parents the backing entity: under the entity of the nearest ancestor `<pc-entity>` or
-     * `<pc-node>` when there is one, and under the application root otherwise. Called by the
-     * containing `<pc-app>` element once a sweep has created every entity, so a parent's
-     * existence never depends on document order.
+     * Parents the backing entity: under the entity of the nearest ancestor `<pc-entity>`,
+     * `<pc-model>` or `<pc-node>` when there is one, and under the application root otherwise.
+     * Called by the containing `<pc-app>` element once a sweep has created every entity, so a
+     * parent's existence never depends on document order.
      *
      * @param app - The application whose root adopts parentless entities.
      * @internal
@@ -1890,6 +1884,13 @@ class EntityElement extends EntityBaseElement {
         if (closestEntity && !closestEntity.entity) {
             return;
         }
+        // An owner that exists but is not yet parented is itself deferred behind an unresolved
+        // node further up. Building beneath it would announce readiness for an entity that is
+        // not in the scene graph; stay unbuilt with it - the node's bind sweeps the whole
+        // subtree, ancestors before descendants.
+        if (closestEntity instanceof EntityOwnerElement && !closestEntity._built) {
+            return;
+        }
         this._built = true;
         if (closestEntity?.entity) {
             closestEntity.entity.addChild(this.entity);
@@ -1897,35 +1898,16 @@ class EntityElement extends EntityBaseElement {
         else {
             app.root.addChild(this.entity);
         }
-        this._onReady();
+        this._onBuilt();
     }
-    connectedCallback() {
-        // Wait for app to be ready
-        const closestApp = this.closestApp;
-        if (!closestApp) {
-            // An entity outside an application is inert and never becomes ready, so awaiting it
-            // hangs. Warn rather than fail silently, naming the parent it requires, as every other
-            // misplaced element does.
-            const name = this.getAttribute('name');
-            const label = name ? ` '${name}'` : '';
-            console.warn(`pc-entity${label} must be a descendant of pc-app - entity not created`);
-            return;
-        }
-        // If app is already running, create entity immediately
-        if (closestApp._hierarchyReady) {
-            const app = closestApp.app;
-            this._createEntity(app);
-            this._buildHierarchy(app);
-            // Handle any child entities that might exist
-            buildDescendantEntities(this, app);
-        }
-    }
-    disconnectedCallback() {
-        // Destroying the entity destroys its whole subtree, and the engine fires 'destroy' for
-        // every entity in it - so _onEntityDestroy resets this element AND every descendant
-        // element before the descendants' own disconnectedCallbacks run. Their entities are null
-        // by then, making this call a no-op for them.
-        this._entity?.destroy();
+    /**
+     * Called by {@link _buildHierarchy} once the backing entity has been parented — exactly once
+     * per build cycle. The default announces readiness, which is what a parented `<pc-entity>`
+     * means; `<pc-model>` overrides it to start loading content instead, because its readiness
+     * tracks the content settling rather than the host entering the scene graph.
+     */
+    _onBuilt() {
+        this._onReady();
     }
     /**
      * Sets the enabled state of the entity.
@@ -2030,6 +2012,70 @@ class EntityElement extends EntityBaseElement {
     get tags() {
         return this._tags;
     }
+}
+
+/**
+ * The EntityElement interface provides properties and methods for manipulating
+ * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-entity/ | `<pc-entity>`} elements.
+ * The EntityElement interface also inherits the properties and methods of the
+ * {@link HTMLElement} interface.
+ *
+ * The pointer events below are dispatched by the containing `<pc-app>` element when the pointer
+ * intersects this entity's geometry. They are only generated while the entity has a listener for
+ * them, registered either with {@link addEventListener} or with the matching inline `onpointer*`
+ * attribute.
+ *
+ * @attribute {boolean} enabled - The enabled state of the entity.
+ * @attribute {string} name - The name of the entity.
+ * @attribute {string} position - The position of the entity.
+ * @attribute {string} rotation - The rotation of the entity.
+ * @attribute {string} scale - The scale of the entity.
+ * @attribute {string} tags - The tags of the entity.
+ * @attribute {string} onpointerenter - Script to run when the pointer moves onto the entity.
+ * @attribute {string} onpointerleave - Script to run when the pointer moves off the entity.
+ * @attribute {string} onpointermove - Script to run when the pointer moves over the entity.
+ * @attribute {string} onpointerdown - Script to run when a pointer button is pressed over the
+ * entity.
+ * @attribute {string} onpointerup - Script to run when a pointer button is released over the
+ * entity.
+ * @fires {PointerEvent} pointerenter - Fired when the pointer moves onto the entity.
+ * @fires {PointerEvent} pointerleave - Fired when the pointer moves off the entity.
+ * @fires {PointerEvent} pointermove - Fired when the pointer moves over the entity.
+ * @fires {PointerEvent} pointerdown - Fired when a pointer button is pressed over the entity.
+ * @fires {PointerEvent} pointerup - Fired when a pointer button is released over the entity.
+ */
+class EntityElement extends EntityOwnerElement {
+    connectedCallback() {
+        // Wait for app to be ready
+        const closestApp = this.closestApp;
+        if (!closestApp) {
+            // An entity outside an application is inert and never becomes ready, so awaiting it
+            // hangs. Warn rather than fail silently, naming the parent it requires, as every other
+            // misplaced element does.
+            const name = this.getAttribute('name');
+            const label = name ? ` '${name}'` : '';
+            console.warn(`pc-entity${label} must be a descendant of pc-app - entity not created`);
+            return;
+        }
+        // If app is already running, create entity immediately
+        if (closestApp._hierarchyReady) {
+            const app = closestApp.app;
+            this._createEntity(app);
+            this._buildHierarchy(app);
+            // Handle any child entities that might exist. A build that deferred (an unresolved
+            // pc-node above) defers the whole subtree with it - the node's bind sweeps it.
+            if (this._built) {
+                buildDescendantEntities(this, app);
+            }
+        }
+    }
+    disconnectedCallback() {
+        // Destroying the entity destroys its whole subtree, and the engine fires 'destroy' for
+        // every entity in it - so _onEntityDestroy resets this element AND every descendant
+        // element before the descendants' own disconnectedCallbacks run. Their entities are null
+        // by then, making this call a no-op for them.
+        this._entity?.destroy();
+    }
     static get observedAttributes() {
         return ['enabled', 'name', 'position', 'rotation', 'scale', 'tags', ...POINTER_ATTRIBUTES];
     }
@@ -2967,14 +3013,42 @@ const formatHierarchy = (root, counts) => {
  * The ModelElement interface also inherits the properties and methods of the
  * {@link HTMLElement} interface.
  *
- * The element becomes ready once its container asset has loaded and the instantiated hierarchy has
- * been added to the scene — `entity` is non-null by then. A failed load also settles readiness,
- * with `entity` remaining `null`: readiness means the load settled, not that it succeeded — listen
- * for `error`, or check `entity`, to tell the outcomes apart. Changing `asset` re-arms readiness
- * and instantiates anew, so a `ready()` obtained after the change resolves against the new
- * hierarchy. A `pc-model` outside a `pc-app`, or referencing an unknown asset id, warns and never
- * becomes ready.
+ * The element creates and fronts a stable host entity: `entity` is that host, created when the
+ * application builds its hierarchy and kept across `asset` changes, so the element's transform
+ * and tags are instance placement that composes with whatever transform the asset authored on
+ * its root. The instantiated content is parented beneath the host and exposed as
+ * {@link contentEntity}.
+ *
+ * The element becomes ready once its current asset selection has settled: the container asset
+ * has loaded and its content root has been parented beneath the host, the load has failed
+ * (`contentEntity` stays `null` — listen for `error`, or check `contentEntity`, to tell the
+ * outcomes apart), or no asset is assigned at all. Changing `asset` re-arms readiness and
+ * instantiates anew, so a `ready()` obtained after the change resolves against the new content.
+ * A `pc-model` outside a `pc-app`, or referencing an unknown asset id, warns and never becomes
+ * ready.
+ *
+ * The pointer events below are dispatched by the containing `<pc-app>` element when the pointer
+ * intersects the model's geometry, exactly as for `<pc-entity>` — a hit on a content node that no
+ * `pc-node` fronts resolves to this element.
  *
+ * @attribute {boolean} enabled - The enabled state of the model.
+ * @attribute {string} name - The name of the model.
+ * @attribute {string} position - The position of the model.
+ * @attribute {string} rotation - The rotation of the model.
+ * @attribute {string} scale - The scale of the model.
+ * @attribute {string} tags - The tags of the model.
+ * @attribute {string} onpointerenter - Script to run when the pointer moves onto the model.
+ * @attribute {string} onpointerleave - Script to run when the pointer moves off the model.
+ * @attribute {string} onpointermove - Script to run when the pointer moves over the model.
+ * @attribute {string} onpointerdown - Script to run when a pointer button is pressed over the
+ * model.
+ * @attribute {string} onpointerup - Script to run when a pointer button is released over the
+ * model.
+ * @fires {PointerEvent} pointerenter - Fired when the pointer moves onto the model.
+ * @fires {PointerEvent} pointerleave - Fired when the pointer moves off the model.
+ * @fires {PointerEvent} pointermove - Fired when the pointer moves over the model.
+ * @fires {PointerEvent} pointerdown - Fired when a pointer button is pressed over the model.
+ * @fires {PointerEvent} pointerup - Fired when a pointer button is released over the model.
  * @fires {Event} load - Fired each time a container asset finishes instantiating, including
  * re-instantiation after `asset` changes. Does not bubble — listen on this element, or use a
  * capture-phase listener on an ancestor.
@@ -2982,14 +3056,14 @@ const formatHierarchy = (root, counts) => {
  * error in `message`. Does not bubble. The element still becomes ready — readiness means the load
  * settled, not that it succeeded.
  */
-class ModelElement extends AsyncElement {
+class ModelElement extends EntityOwnerElement {
     _asset = '';
-    _entity = null;
+    _contentEntity = null;
     /**
-     * Incremented on every new load and on disconnect, and captured by a load when it starts. A
-     * load that resumes from an await or a load callback abandons itself if the value has moved
-     * on, so a superseded load can neither instantiate a second entity nor parent one that has
-     * since been destroyed.
+     * Incremented on every new load, on disconnect, and when the host entity dies, and captured
+     * by a load when it starts. A load that resumes from an await or a load callback abandons
+     * itself if the value has moved on, so a superseded load can neither instantiate a second
+     * content root nor parent one under a host a newer cycle has already replaced.
      */
     _loadGeneration = 0;
     /**
@@ -3000,12 +3074,13 @@ class ModelElement extends AsyncElement {
     _loadHandle = null;
     _errorHandle = null;
     /**
-     * The root entity of the instantiated model. `null` until the container asset has loaded
-     * and been instantiated, and again once the element has been removed from the document.
-     * @returns The model's root entity, or `null`.
+     * The root entity of the instantiated model content, parented beneath the host entity.
+     * `null` until the container asset has loaded and been instantiated, after a failed load,
+     * and again once the element has been removed from the document.
+     * @returns The content root entity, or `null`.
      */
-    get entity() {
-        return this._entity;
+    get contentEntity() {
+        return this._contentEntity;
     }
     /**
      * Returns a snapshot of the instantiated node tree, or `null` while there is none (the
@@ -3017,12 +3092,13 @@ class ModelElement extends AsyncElement {
      * is the printable form.
      *
      * The snapshot is plain data, computed afresh each call: it does not follow later changes
-     * to the hierarchy, and mutating it changes nothing.
+     * to the hierarchy, and mutating it changes nothing. It covers the instantiated content
+     * only — the host entity the element fronts is not part of the asset's node tree.
      *
      * @returns The root of the instantiated node tree, or `null`.
      */
     hierarchy() {
-        const root = this._entity;
+        const root = this._contentEntity;
         if (!root) {
             return null;
         }
@@ -3062,18 +3138,53 @@ class ModelElement extends AsyncElement {
         // A model outside an application is inert and never becomes ready, so awaiting it hangs.
         // Warn rather than fail silently, naming the parent it requires, as every other misplaced
         // element does.
-        if (!this.closestApp) {
+        const closestApp = this.closestApp;
+        if (!closestApp) {
             const label = this._asset ? ` '${this._asset}'` : '';
             console.warn(`pc-model${label} must be a descendant of pc-app - model not created`);
             return;
         }
-        this._loadModel();
+        // If the app is already running, create the host immediately; during a boot, the app's
+        // own sweep does it. Either way, _onBuilt starts the content load once the host is
+        // parented.
+        if (closestApp._hierarchyReady) {
+            const app = closestApp.app;
+            this._createEntity(app);
+            this._buildHierarchy(app);
+            // A build that deferred (an unresolved pc-node above) defers the whole subtree with
+            // it - the node's bind sweeps it.
+            if (this._built) {
+                buildDescendantEntities(this, app);
+            }
+        }
     }
     disconnectedCallback() {
+        // Destroying the host destroys the instantiated content with it, and the destroy hook
+        // resets the element. The generation guard comes first so a load suspended on an await
+        // cannot resume against the torn-down element.
         this._loadGeneration++;
         this._detachLoadHandlers();
-        this._unloadModel();
-        this._resetReady();
+        this._entity?.destroy();
+    }
+    /**
+     * Starts (or restarts) the content load once the host has been parented. Readiness is not
+     * announced here — it tracks the content settling, not the host entering the scene graph.
+     */
+    _onBuilt() {
+        this._loadContent();
+    }
+    /**
+     * Extends the owner reset for the content: the engine's destroy cascade has already taken
+     * the content root down with the host subtree, so only the reference and the in-flight load
+     * are dropped here. The next build re-creates the host and re-instantiates the content.
+     *
+     * @param entity - The host entity that was destroyed.
+     */
+    _onEntityDestroy(entity) {
+        this._loadGeneration++;
+        this._detachLoadHandlers();
+        this._contentEntity = null;
+        super._onEntityDestroy(entity);
     }
     _detachLoadHandlers() {
         this._loadHandle?.off();
@@ -3082,51 +3193,34 @@ class ModelElement extends AsyncElement {
         this._errorHandle = null;
     }
     /**
-     * Resolves readiness and dispatches the `load` event. Called once the instantiated hierarchy
-     * has been parented — readiness means "in the scene graph", matching `pc-entity`, so a ready
-     * model's entity always has world transforms.
+     * Resolves readiness and dispatches the `load` event. Called once the instantiated content
+     * has been parented beneath the host — the host itself is already in the scene graph by
+     * then, so a ready model's content always has world transforms.
      */
     _announceLoad() {
         this._onReady();
         this.dispatchEvent(new Event('load'));
     }
     _instantiate(container) {
-        const generation = this._loadGeneration;
-        const entity = container.instantiateRenderEntity();
-        this._entity = entity;
-        // The parent's readiness re-arms when it is torn down, so these can resume in a later
-        // connection cycle. The entity is captured above and the generation re-checked, so a
-        // stale resume cannot parent an entity a newer cycle has already destroyed.
-        const parentEntityElement = this.closestEntity;
-        if (parentEntityElement) {
-            parentEntityElement.ready().then(() => {
-                if (generation !== this._loadGeneration) {
-                    return;
-                }
-                parentEntityElement.entity.addChild(entity);
-                this._announceLoad();
-            });
-        }
-        else {
-            const appElement = this.closestApp;
-            if (appElement) {
-                appElement.ready().then(() => {
-                    if (generation !== this._loadGeneration) {
-                        return;
-                    }
-                    appElement.app.root.addChild(entity);
-                    this._announceLoad();
-                });
-            }
-        }
-    }
-    async _loadModel() {
-        this._unloadModel();
+        const content = container.instantiateRenderEntity();
+        this._contentEntity = content;
+        this._entity.addChild(content);
+        this._announceLoad();
+    }
+    _destroyContent() {
+        this._contentEntity?.destroy();
+        this._contentEntity = null;
+    }
+    async _loadContent() {
+        // The old content goes down synchronously, so a reader that checks after an asset change
+        // never sees the outgoing hierarchy. The host survives - components and child entities
+        // attached to it carry over to the new content.
+        this._destroyContent();
         // Supersede any load already in flight - only the newest load may instantiate
         const generation = ++this._loadGeneration;
         this._detachLoadHandlers();
         // Re-arm readiness so a waiter obtained after an asset change resolves against the new
-        // hierarchy. A no-op on first connection, where readiness is still pending.
+        // content. A no-op on first connection, where readiness is still pending.
         this._resetReady();
         const appElement = this.closestApp;
         if (!appElement) {
@@ -3138,14 +3232,23 @@ class ModelElement extends AsyncElement {
         if (generation !== this._loadGeneration) {
             return;
         }
+        // The host may not be parented yet - a model under a pc-node that has not bound, reached
+        // through the asset setter. Nothing settles here: _onBuilt re-runs this load once the
+        // host builds.
+        if (!this._entity || !this._built) {
+            return;
+        }
+        if (this._asset === '') {
+            // No asset assigned is a settled selection: the element is a usable host (components
+            // attach, waiters resolve) with no content. Assigning an asset later re-arms.
+            this._onReady();
+            return;
+        }
         const asset = useAsset(this._asset);
         if (!asset) {
-            // An empty id is a legitimate transient (the asset may be assigned later); a
-            // non-empty one that resolves to nothing is a dead end - say so rather than staying
+            // A non-empty id that resolves to nothing is a dead end - say so rather than staying
             // silently pending.
-            if (this._asset) {
-                console.warn(`pc-model could not find asset '${this._asset}' - model not created`);
-            }
+            console.warn(`pc-model could not find asset '${this._asset}' - model not created`);
             return;
         }
         if (asset.loaded) {
@@ -3167,7 +3270,7 @@ class ModelElement extends AsyncElement {
                 if (generation !== this._loadGeneration) {
                     return;
                 }
-                // A failed load settles readiness with a null entity, mirroring pc-asset:
+                // A failed load settles readiness with a null contentEntity, mirroring pc-asset:
                 // readiness means the load settled, not that it succeeded.
                 this.dispatchEvent(new ErrorEvent('error', {
                     message: err instanceof Error ? err.message : String(err)
@@ -3176,10 +3279,6 @@ class ModelElement extends AsyncElement {
             });
         }
     }
-    _unloadModel() {
-        this._entity?.destroy();
-        this._entity = null;
-    }
     /**
      * Sets the id of the `pc-asset` to use for the model.
      * @param value - The asset ID.
@@ -3187,7 +3286,7 @@ class ModelElement extends AsyncElement {
     set asset(value) {
         this._asset = value;
         if (this.isConnected) {
-            this._loadModel();
+            this._loadContent();
         }
     }
     /**
@@ -3198,13 +3297,38 @@ class ModelElement extends AsyncElement {
         return this._asset;
     }
     static get observedAttributes() {
-        return ['asset'];
+        return ['asset', 'enabled', 'name', 'position', 'rotation', 'scale', 'tags', ...POINTER_ATTRIBUTES];
     }
     attributeChangedCallback(name, _oldValue, newValue) {
         switch (name) {
             case 'asset':
                 this.asset = newValue ?? '';
                 break;
+            case 'enabled':
+                this.enabled = parseBool(newValue, true);
+                break;
+            case 'name':
+                this.name = newValue ?? 'Untitled';
+                break;
+            case 'position':
+                this.position = parseVec3(newValue, playcanvas.Vec3.ZERO, name);
+                break;
+            case 'rotation':
+                this.rotation = parseVec3(newValue, playcanvas.Vec3.ZERO, name);
+                break;
+            case 'scale':
+                this.scale = parseVec3(newValue, playcanvas.Vec3.ONE, name);
+                break;
+            case 'tags':
+                this.tags = parseTags(newValue);
+                break;
+            case 'onpointerenter':
+            case 'onpointerleave':
+            case 'onpointerdown':
+            case 'onpointerup':
+            case 'onpointermove':
+                this._updateInlineHandler(name, newValue);
+                break;
         }
     }
 }
@@ -3295,7 +3419,7 @@ class ComponentElement extends AsyncElement {
             // A component can only exist on an entity, so an element placed outside one is inert.
             // It still becomes ready (with a null `component`), so warn rather than fail silently
             const label = this.id ? ` '${this.id}'` : '';
-            console.warn(`${this.tagName.toLowerCase()}${label} must be a descendant of pc-entity - component not added`);
+            console.warn(`${this.tagName.toLowerCase()}${label} must be a descendant of pc-entity, pc-model or pc-node - component not added`);
             return;
         }
         await entityElement.ready();
@@ -3383,8 +3507,9 @@ class ComponentElement extends AsyncElement {
     }
     /**
      * The PlayCanvas component instance. `null` until the element is ready, and also for an
-     * element that is not a descendant of a `<pc-entity>` — await {@link whenReady} or the
-     * element's `ready()` promise before accessing it.
+     * element that is not a descendant of an entity-fronting element (`<pc-entity>`,
+     * `<pc-model>` or `<pc-node>`) — await {@link whenReady} or the element's `ready()` promise
+     * before accessing it.
      * @returns The component instance, or `null`.
      */
     get component() {
@@ -3437,6 +3562,8 @@ class ComponentElement extends AsyncElement {
  * the underlying {@link AnimComponent} (via {@link component}) for playback state beyond what
  * this element exposes.
  *
+ * Engine component: {@link AnimComponent} (`anim`).
+ *
  * @category Components
  */
 class AnimComponentElement extends ComponentElement {
@@ -3458,6 +3585,11 @@ class AnimComponentElement extends ComponentElement {
      * The name of the active clip.
      */
     _clip = '';
+    /**
+     * The binding root this element last assigned through {@link _applyRootBone}, distinguishing
+     * its own writes from a `rootBone` assigned through the engine API — which is left alone.
+     */
+    _managedRootBone = null;
     /**
      * The element the model-readiness listener is attached to, held so disconnection can detach
      * it after `closestEntity` no longer resolves.
@@ -3483,27 +3615,71 @@ class AnimComponentElement extends ComponentElement {
      */
     _warnedClip = null;
     /**
-     * Rebinds when a model under the host announces readiness. The engine resolves each curve
-     * once, at the first tick after assignment, and never retries — and its mesh-instance
+     * Rebinds when a model that is not this component's host announces readiness — a sibling or
+     * deeper model whose content changed under the assigned clips. The engine resolves each
+     * curve once, at the first tick after assignment, and never retries — and its mesh-instance
      * broadcast fires before an instantiated hierarchy is parented, so a model that loads after
-     * the clips were assigned would otherwise stay silently unbound. A re-instantiation of the
-     * implicit clip source (the parent `<pc-model>`) means a new container, so the clip set
-     * refreshes instead — unless every clip declares its own asset, where a rebind suffices.
+     * the clips were assigned would otherwise stay silently unbound. The host model's own cycles
+     * are excluded: those re-enter through {@link initComponent}, which refreshes the whole clip
+     * set against the new container.
      */
     _onModelReady = (event) => {
         if (!(event.target instanceof ModelElement) || !this.component) {
             return;
         }
-        if (event.target === this.parentElement) {
-            const implicit = this._autoAssigned ||
-                [...this._assignedClips.values()].some(clip => !clip.asset);
-            if (implicit) {
-                this._refreshClips();
-                return;
-            }
+        // The host model's own readiness cycle already re-initialized this component through
+        // ComponentElement's host-ready listener, which is attached first and so has run by now.
+        // Acting here too would resolve every track twice and capture the playhead-restore
+        // snapshot mid-rebuild.
+        if (event.target === this._modelListenerTarget) {
+            return;
         }
+        // A model cycle can replace the skeleton source's host entity (a rebuild under a
+        // retargeting pc-node), so the binding root is re-asserted before the rebind.
+        this._applyRootBone();
         this.component.rebind();
     };
+    /**
+     * The model whose host entity scopes this component's curve binding: the parent `pc-model`,
+     * or the sole `pc-model` among the parent's direct children (the arrangement where clips
+     * live in a library asset beside the skeleton). `null` when there is no such model, or more
+     * than one — an ambiguous skeleton is left to the engine's name-based resolution.
+     */
+    _skeletonSource() {
+        const parent = this.parentElement;
+        if (parent instanceof ModelElement) {
+            return parent;
+        }
+        const models = parent ? parent.querySelectorAll(':scope > pc-model') : null;
+        return models?.length === 1 && models[0] instanceof ModelElement ? models[0] : null;
+    }
+    /**
+     * Keeps the component's binding root pointing at the skeleton source's host entity. The host
+     * wraps the instantiated content, so left at its default — the component's own entity — the
+     * engine binder mis-resolves curves that target the asset's root node: its fallback treats
+     * the graph as the asset root once the root is no longer a direct child.
+     *
+     * Authoritative in both directions for values this element assigned: a source appearing pins
+     * its host, and a source dissolving (the model gone, or a second model making the skeleton
+     * ambiguous) clears the pin rather than leaving it on a stale host. A root assigned through
+     * the engine API is never overwritten — the user's choice outranks the managed default.
+     * Writes are skipped while unchanged, because the engine setter itself triggers a rebind.
+     */
+    _applyRootBone() {
+        const component = this.component;
+        // A non-null root this element did not assign came through the engine API. A fresh
+        // component starts at null, which is always reclaimable.
+        if (component.rootBone !== null && component.rootBone !== this._managedRootBone) {
+            return;
+        }
+        const host = this._skeletonSource()?.entity ?? null;
+        if (component.rootBone !== host) {
+            // The engine setter accepts null - restoring the component's own entity as the
+            // binding graph - but its declared type does not
+            component.rootBone = host;
+        }
+        this._managedRootBone = host;
+    }
     /** @ignore */
     constructor() {
         super('anim');
@@ -3528,7 +3704,16 @@ class AnimComponentElement extends ComponentElement {
             host.addEventListener('ready', this._onModelReady);
             this._modelListenerTarget = host;
         }
-        this._applyClips();
+        this._applyRootBone();
+        if (this.component.baseLayer) {
+            // The component survived the host's readiness cycle (a pc-model reloading content on
+            // its stable host entity). A loaded graph cannot be reassigned in place, so drop it
+            // and reassign from the current source, restoring the active clip and playhead.
+            this._refreshClips();
+        }
+        else {
+            this._applyClips();
+        }
     }
     disconnectedCallback() {
         this._modelListenerTarget?.removeEventListener('ready', this._onModelReady);
@@ -3538,6 +3723,7 @@ class AnimComponentElement extends ComponentElement {
         this._sourceGeneration++;
         this._assignedClips.clear();
         this._autoAssigned = false;
+        this._managedRootBone = null;
         super.disconnectedCallback();
     }
     /**
@@ -3706,6 +3892,10 @@ class AnimComponentElement extends ComponentElement {
         if (!component) {
             return;
         }
+        // A clip-set change is also a chance for the skeleton source to have changed shape (a
+        // clip child appearing or leaving can accompany a model coming or going) - re-derive the
+        // binding root before the reassignment binds against it.
+        this._applyRootBone();
         const layer = component.baseLayer;
         const restore = layer ? {
             state: layer.activeState,
@@ -4313,14 +4503,16 @@ class AnimClipElement extends AsyncElement {
 customElements.define('pc-anim-clip', AnimClipElement);
 
 /**
- * The ListenerComponentElement interface provides properties and methods for manipulating
- * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-listener/ | `<pc-listener>`} elements.
- * The ListenerComponentElement interface also inherits the properties and methods of the
+ * The AudioListenerComponentElement interface provides properties and methods for manipulating
+ * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-audio-listener/ | `<pc-audio-listener>`} elements.
+ * The AudioListenerComponentElement interface also inherits the properties and methods of the
  * {@link HTMLElement} interface.
  *
+ * Engine component: {@link AudioListenerComponent} (`audiolistener`).
+ *
  * @category Components
  */
-class ListenerComponentElement extends ComponentElement {
+class AudioListenerComponentElement extends ComponentElement {
     /** @ignore */
     constructor() {
         super('audiolistener');
@@ -4333,7 +4525,7 @@ class ListenerComponentElement extends ComponentElement {
         return super.component;
     }
 }
-customElements.define('pc-listener', ListenerComponentElement);
+customElements.define('pc-audio-listener', AudioListenerComponentElement);
 
 const transitionModes = new Map([
     ['tint', playcanvas.BUTTON_TRANSITION_MODE_TINT],
@@ -4345,6 +4537,8 @@ const transitionModes = new Map([
  * The ButtonComponentElement interface also inherits the properties and methods of the
  * {@link HTMLElement} interface.
  *
+ * Engine component: {@link ButtonComponent} (`button`).
+ *
  * @category Components
  */
 class ButtonComponentElement extends ComponentElement {
@@ -4425,7 +4619,9 @@ class ButtonComponentElement extends ComponentElement {
     }
     /**
      * Sets the reference (CSS selector, element id or entity name) to the `<pc-entity>` whose image
-     * element is used for visual transitions. Defaults to the button's own entity.
+     * element is used for visual transitions. Defaults to the button's own entity — inside a
+     * `<pc-model>`, that is the model's host entity, so supply an explicit reference to target a
+     * UI entity instead.
      * @param value - The image entity reference.
      */
     set image(value) {
@@ -4744,6 +4940,8 @@ const tonemaps = new Map([
  * The CameraComponentElement interface also inherits the properties and methods of the
  * {@link HTMLElement} interface.
  *
+ * Engine component: {@link CameraComponent} (`camera`).
+ *
  * @category Components
  */
 class CameraComponentElement extends ComponentElement {
@@ -5229,6 +5427,8 @@ customElements.define('pc-camera', CameraComponentElement);
  * retargets or rebinds picks up the new node's geometry. An entity with no asset-backed render
  * component warns, and the collider has no shape.
  *
+ * Engine component: {@link CollisionComponent} (`collision`).
+ *
  * @category Components
  */
 class CollisionComponentElement extends ComponentElement {
@@ -5265,7 +5465,9 @@ class CollisionComponentElement extends ComponentElement {
      * no attribute to supply it - so the host's visible geometry, the meaning a mesh collider
      * on a glTF node carries, fills the gap. Runs on every application (so a rebound `pc-node`
      * recomputes it) and on a runtime switch to `type="mesh"`; an explicitly assigned
-     * `renderAsset` is never overwritten.
+     * `renderAsset` is never overwritten. A `pc-model` host entity never carries a render
+     * component (the instantiated content beneath it does), so a mesh collider that should take
+     * an asset's geometry belongs on a bound `pc-node`.
      */
     _applyMeshGeometryDefault() {
         const component = this.component;
@@ -5410,6 +5612,13 @@ customElements.define('pc-collision', CollisionComponentElement);
  * The ElementComponentElement interface also inherits the properties and methods of the
  * {@link HTMLElement} interface.
  *
+ * Despite the name, this is not a base class or a generic wrapper: it is the engine's 2D UI
+ * component, which gives its host entity a rectangle in a `<pc-screen>` hierarchy that draws
+ * either an image, a line of text or nothing (`type="image"`, `"text"` or `"group"`). The tag
+ * spells the engine component it adds, as every component element does.
+ *
+ * Engine component: {@link ElementComponent} (`element`).
+ *
  * @category Components
  */
 class ElementComponentElement extends ComponentElement {
@@ -6098,6 +6307,8 @@ customElements.define('pc-element', ElementComponentElement);
  * constraint breaks. A broken joint no longer constrains its bodies; calling `refreshFrames()` on
  * the underlying component re-attaches it. Bubbles and is composed.
  *
+ * Engine component: {@link JointComponent} (`joint`).
+ *
  * @category Components
  */
 class JointComponentElement extends ComponentElement {
@@ -6956,10 +7167,12 @@ customElements.define('pc-joint', JointComponentElement);
 
 /**
  * The LayoutChildComponentElement interface provides properties and methods for manipulating
- * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-layoutchild/ | `<pc-layoutchild>`} elements.
+ * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-layout-child/ | `<pc-layout-child>`} elements.
  * The LayoutChildComponentElement interface also inherits the properties and methods of the
  * {@link HTMLElement} interface.
  *
+ * Engine component: {@link LayoutChildComponent} (`layoutchild`).
+ *
  * @category Components
  */
 class LayoutChildComponentElement extends ComponentElement {
@@ -7152,7 +7365,7 @@ class LayoutChildComponentElement extends ComponentElement {
         }
     }
 }
-customElements.define('pc-layoutchild', LayoutChildComponentElement);
+customElements.define('pc-layout-child', LayoutChildComponentElement);
 
 const orientations$1 = new Map([
     ['horizontal', playcanvas.ORIENTATION_HORIZONTAL],
@@ -7166,10 +7379,12 @@ const fittings = new Map([
 ]);
 /**
  * The LayoutGroupComponentElement interface provides properties and methods for manipulating
- * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-layoutgroup/ | `<pc-layoutgroup>`} elements.
+ * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-layout-group/ | `<pc-layout-group>`} elements.
  * The LayoutGroupComponentElement interface also inherits the properties and methods of the
  * {@link HTMLElement} interface.
  *
+ * Engine component: {@link LayoutGroupComponent} (`layoutgroup`).
+ *
  * @category Components
  */
 class LayoutGroupComponentElement extends ComponentElement {
@@ -7409,7 +7624,7 @@ class LayoutGroupComponentElement extends ComponentElement {
         }
     }
 }
-customElements.define('pc-layoutgroup', LayoutGroupComponentElement);
+customElements.define('pc-layout-group', LayoutGroupComponentElement);
 
 const shadowTypes = new Map([
     ['pcf1-16f', playcanvas.SHADOW_PCF1_16F],
@@ -7428,6 +7643,8 @@ const shadowTypes = new Map([
  * The LightComponentElement interface also inherits the properties and methods of the
  * {@link HTMLElement} interface.
  *
+ * Engine component: {@link LightComponent} (`light`).
+ *
  * @category Components
  */
 class LightComponentElement extends ComponentElement {
@@ -7909,10 +8126,12 @@ customElements.define('pc-light', LightComponentElement);
 
 /**
  * The ParticleSystemComponentElement interface provides properties and methods for manipulating
- * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-particles/ | `<pc-particles>`} elements.
+ * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-particle-system/ | `<pc-particle-system>`} elements.
  * The ParticleSystemComponentElement interface also inherits the properties and methods of the
  * {@link HTMLElement} interface.
  *
+ * Engine component: {@link ParticleSystemComponent} (`particlesystem`).
+ *
  * @category Components
  */
 class ParticleSystemComponentElement extends ComponentElement {
@@ -8031,7 +8250,7 @@ class ParticleSystemComponentElement extends ComponentElement {
         }
     }
 }
-customElements.define('pc-particles', ParticleSystemComponentElement);
+customElements.define('pc-particle-system', ParticleSystemComponentElement);
 
 const blendTypes = new Map([
     ['none', playcanvas.BLEND_NONE],
@@ -10263,6 +10482,8 @@ customElements.define('pc-material', MaterialElement);
  * to `box`). It does not cover the engine's `asset` render type, since there is no way to supply
  * a render asset here — use `pc-model` for glTF content instead.
  *
+ * Engine component: {@link RenderComponent} (`render`).
+ *
  * @category Components
  */
 class RenderComponentElement extends ComponentElement {
@@ -10387,10 +10608,12 @@ customElements.define('pc-render', RenderComponentElement);
 
 /**
  * The RigidBodyComponentElement interface provides properties and methods for manipulating
- * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-rigidbody/ | `<pc-rigidbody>`} elements.
+ * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-rigid-body/ | `<pc-rigid-body>`} elements.
  * The RigidBodyComponentElement interface also inherits the properties and methods of the
  * {@link HTMLElement} interface.
  *
+ * Engine component: {@link RigidBodyComponent} (`rigidbody`).
+ *
  * @category Components
  */
 class RigidBodyComponentElement extends ComponentElement {
@@ -10582,7 +10805,7 @@ class RigidBodyComponentElement extends ComponentElement {
         }
     }
 }
-customElements.define('pc-rigidbody', RigidBodyComponentElement);
+customElements.define('pc-rigid-body', RigidBodyComponentElement);
 
 // The engine's SCALEMODE_* constants are the strings 'none' and 'blend', so this map happens to be
 // an identity. It is still the right shape: it supplies parseEnum's valid-name list, it is what the
@@ -10598,6 +10821,8 @@ const scaleModes = new Map([
  * The ScreenComponentElement interface also inherits the properties and methods of the
  * {@link HTMLElement} interface.
  *
+ * Engine component: {@link ScreenComponent} (`screen`).
+ *
  * @category Components
  */
 class ScreenComponentElement extends ComponentElement {
@@ -10750,6 +10975,8 @@ const orientations = new Map([
  * The ScrollbarComponentElement interface also inherits the properties and methods of the
  * {@link HTMLElement} interface.
  *
+ * Engine component: {@link ScrollbarComponent} (`scrollbar`).
+ *
  * @category Components
  */
 class ScrollbarComponentElement extends ComponentElement {
@@ -10885,10 +11112,12 @@ const visibilities = new Map([
 ]);
 /**
  * The ScrollViewComponentElement interface provides properties and methods for manipulating
- * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-scrollview/ | `<pc-scrollview>`} elements.
+ * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-scroll-view/ | `<pc-scroll-view>`} elements.
  * The ScrollViewComponentElement interface also inherits the properties and methods of the
  * {@link HTMLElement} interface.
  *
+ * Engine component: {@link ScrollViewComponent} (`scrollview`).
+ *
  * @category Components
  */
 class ScrollViewComponentElement extends ComponentElement {
@@ -11247,11 +11476,11 @@ class ScrollViewComponentElement extends ComponentElement {
         }
     }
 }
-customElements.define('pc-scrollview', ScrollViewComponentElement);
+customElements.define('pc-scroll-view', ScrollViewComponentElement);
 
 /**
- * The ScriptElement interface provides properties and methods for manipulating
- * `<pc-script>` elements. The ScriptElement interface also inherits the properties and
+ * The ScriptInstanceElement interface provides properties and methods for manipulating
+ * `<pc-script-instance>` elements. The ScriptInstanceElement interface also inherits the properties and
  * methods of the {@link AsyncElement} interface.
  *
  * Script attributes can be supplied through two channels:
@@ -11273,7 +11502,7 @@ customElements.define('pc-scrollview', ScrollViewComponentElement);
  * new-name one, re-applying both attribute channels to it.
  *
  * The element becomes ready once its script instance has been created by the parent
- * `<pc-scripts>` element.
+ * `<pc-script>` element.
  *
  * @fires {CustomEvent} scriptattributeschange - Fired when the script's attributes change. The
  * `detail` carries the new `attributes` object. Bubbles.
@@ -11282,11 +11511,11 @@ customElements.define('pc-scrollview', ScrollViewComponentElement);
  * @fires {CustomEvent} scriptnamechange - Fired when the script is renamed on a live element. The
  * `detail` carries `oldName` and `newName`. Bubbles.
  */
-class ScriptElement extends AsyncElement {
+class ScriptInstanceElement extends AsyncElement {
     _attributes = {};
     _enabled = true;
     /**
-     * The Script instance created for this element by its parent `<pc-scripts>` element.
+     * The Script instance created for this element by its parent `<pc-script>` element.
      * @internal
      */
     _script = null;
@@ -11332,11 +11561,11 @@ class ScriptElement extends AsyncElement {
     }
     /**
      * Sets the name of the script to create. The `name` attribute is the single source of truth
-     * (it is what the parent `<pc-scripts>` element reads when creating the instance), so the
+     * (it is what the parent `<pc-script>` element reads when creating the instance), so the
      * property writes through to it — assigning before insertion works as expected:
      *
      * ```js
-     * const script = document.createElement('pc-script');
+     * const script = document.createElement('pc-script-instance');
      * script.name = 'rotate';
      * scriptsElement.appendChild(script);
      * await script.ready();
@@ -11363,10 +11592,10 @@ class ScriptElement extends AsyncElement {
         return this._script;
     }
     connectedCallback() {
-        // Script instances are created by the parent pc-scripts element, so an element placed
+        // Script instances are created by the parent pc-script element, so an element placed
         // anywhere else is inert and never becomes ready - warn rather than hang silently
-        if (this.parentElement?.tagName !== 'PC-SCRIPTS') {
-            console.warn(`pc-script '${this.getAttribute('name')}' must be a direct child of pc-scripts - script not created`);
+        if (this.parentElement?.tagName !== 'PC-SCRIPT') {
+            console.warn(`pc-script-instance '${this.getAttribute('name')}' must be a direct child of pc-script - script not created`);
         }
     }
     disconnectedCallback() {
@@ -11377,7 +11606,7 @@ class ScriptElement extends AsyncElement {
         this._resetReady();
     }
     /**
-     * Called by the parent `<pc-scripts>` element when the script instance has been created.
+     * Called by the parent `<pc-script>` element when the script instance has been created.
      * Creation can happen more than once per connection (a runtime `name` change recreates the
      * instance), but `_onReady` signals readiness at most once per cycle.
      * @internal
@@ -11399,7 +11628,7 @@ class ScriptElement extends AsyncElement {
                     this.scriptAttributes = JSON.parse(newValue);
                 }
                 catch (error) {
-                    console.warn(`Invalid 'attributes' JSON on pc-script '${this.getAttribute('name')}': ${error.message}`);
+                    console.warn(`Invalid 'attributes' JSON on pc-script-instance '${this.getAttribute('name')}': ${error.message}`);
                 }
                 break;
             case 'enabled':
@@ -11419,14 +11648,14 @@ class ScriptElement extends AsyncElement {
         }
     }
 }
-customElements.define('pc-script', ScriptElement);
+customElements.define('pc-script-instance', ScriptInstanceElement);
 
 /**
- * Attributes on `pc-script` that never map to script attributes: the element's own API (derived
+ * Attributes on `pc-script-instance` that never map to script attributes: the element's own API (derived
  * from its observed attributes) plus reserved and global HTML attribute names.
  */
 const RESERVED_ATTRIBUTES = new Set([
-    ...ScriptElement.observedAttributes,
+    ...ScriptInstanceElement.observedAttributes,
     'accesskey',
     'autocapitalize',
     'autofocus',
@@ -11457,7 +11686,7 @@ const RESERVED_ATTRIBUTES = new Set([
     'translate'
 ]);
 /**
- * Checks whether a `pc-script` attribute name is reserved (and so never maps to a script
+ * Checks whether a `pc-script-instance` attribute name is reserved (and so never maps to a script
  * attribute). Reserved names are the element's own API, global HTML attribute names, `data-*`
  * and `aria-*` attributes, names starting with `_` (framework-stamped attributes), and real
  * inline event handler names (`onclick` etc. — detected via the platform, so script attributes
@@ -11613,10 +11842,12 @@ const findCaseMatch = (script, key) => {
 };
 /**
  * The ScriptComponentElement interface provides properties and methods for manipulating
- * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-scripts/ | `<pc-scripts>`} elements.
+ * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-script/ | `<pc-script>`} elements.
  * The ScriptComponentElement interface also inherits the properties and methods of the
  * {@link HTMLElement} interface.
  *
+ * Engine component: {@link ScriptComponent} (`script`).
+ *
  * @category Components
  */
 class ScriptComponentElement extends ComponentElement {
@@ -11633,14 +11864,23 @@ class ScriptComponentElement extends ComponentElement {
     }
     connectedCallback() {
         // (Re-)observe on every connection - disconnectedCallback disconnects the observer.
-        // Attribute changes on child pc-script elements are watched here too: per-property
+        // Attribute changes on child pc-script-instance elements are watched here too: per-property
         // script attributes are not statically known, so they cannot use observedAttributes.
         this.observer.observe(this, { childList: true, subtree: true, attributes: true });
         return super.connectedCallback();
     }
     initComponent() {
-        // Handle initial script elements
-        this.querySelectorAll(':scope > pc-script').forEach((scriptElement) => {
+        this.querySelectorAll(':scope > pc-script-instance').forEach((scriptElement) => {
+            // A host readiness cycle re-runs this against a component that can have survived it
+            // (a pc-model reloading content on its stable host entity). The engine rejects a
+            // duplicate create - returning null, silently in production builds - which would
+            // skip attribute application entirely. A surviving instance is re-asserted instead,
+            // so both cycle outcomes leave the component reflecting the element's declared state.
+            const script = this.scriptFor(scriptElement);
+            if (script) {
+                this.applyDeclaredState(script, scriptElement);
+                return;
+            }
             this.createScript(scriptElement);
         });
     }
@@ -11774,9 +12014,9 @@ class ScriptComponentElement extends ComponentElement {
         this.mergeDeep(script, converted);
     }
     /**
-     * Returns the camelCase keys of the per-property attributes present on a `pc-script`
+     * Returns the camelCase keys of the per-property attributes present on a `pc-script-instance`
      * element.
-     * @param scriptElement - The `pc-script` element.
+     * @param scriptElement - The `pc-script-instance` element.
      * @returns The camelCase keys.
      */
     inlineKeys(scriptElement) {
@@ -11789,10 +12029,10 @@ class ScriptComponentElement extends ComponentElement {
         return keys;
     }
     /**
-     * Resolves the script instance owned by a `pc-script` element. Returns `null` when the
+     * Resolves the script instance owned by a `pc-script-instance` element. Returns `null` when the
      * element has no created script, or when its name resolves to a script created by a
      * different element (e.g. a duplicate-named sibling).
-     * @param scriptElement - The `pc-script` element.
+     * @param scriptElement - The `pc-script-instance` element.
      * @returns The owned script, or `null`.
      */
     scriptFor(scriptElement) {
@@ -11821,7 +12061,7 @@ class ScriptComponentElement extends ComponentElement {
         }
     }
     /**
-     * Handles a runtime `name` change on a child `pc-script`, swapping the engine script instance
+     * Handles a runtime `name` change on a child `pc-script-instance`, swapping the engine script instance
      * to match. Without this the element would keep pointing at the old-name instance: the old
      * script would go on running while every subsequent update (attribute changes, enable
      * changes, destruction on removal) resolved the new name and silently no-opped.
@@ -11832,8 +12072,8 @@ class ScriptComponentElement extends ComponentElement {
      */
     handleScriptNameChange(event) {
         const scriptElement = event.target;
-        // Only direct children are managed, matching initComponent's ':scope > pc-script'
-        // contract - the event bubbles, so a deeper pc-script must not be created here
+        // Only direct children are managed, matching initComponent's ':scope > pc-script-instance'
+        // contract - the event bubbles, so a deeper pc-script-instance must not be created here
         if (scriptElement.parentElement !== this)
             return;
         // Before the component exists there is nothing to swap: initComponent creates from
@@ -11850,11 +12090,11 @@ class ScriptComponentElement extends ComponentElement {
         this.createScript(scriptElement);
     }
     /**
-     * Creates the script instance for a `pc-script` element. The instance is created disabled,
+     * Creates the script instance for a `pc-script-instance` element. The instance is created disabled,
      * the element's converted attributes are merged over the instance's defaults (which is what
      * allows plain numeric arrays to be typed against those defaults), and only then is the
      * declared enabled state applied — so `initialize()` runs with every attribute in place.
-     * @param scriptElement - The `pc-script` element to create the script instance for.
+     * @param scriptElement - The `pc-script-instance` element to create the script instance for.
      * @returns The created script, or `null`.
      */
     createScript(scriptElement) {
@@ -11865,21 +12105,30 @@ class ScriptComponentElement extends ComponentElement {
         if (!script)
             return null;
         scriptElement._script = script;
-        // The JSON blob first with per-property-shadowed keys stripped, then the per-property
-        // attributes: each property is written exactly once and individual attributes win
+        this.applyDeclaredState(script, scriptElement);
+        scriptElement._onScriptCreated();
+        return script;
+    }
+    /**
+     * Applies a `pc-script-instance` element's declared state to a script instance: the `attributes` JSON
+     * first with per-property-shadowed keys stripped, then the per-property attributes — each
+     * property is written exactly once and individual attributes win — and finally the declared
+     * enabled state, so `initialize()` runs with every attribute in place.
+     * @param script - The script instance.
+     * @param scriptElement - The `pc-script-instance` element holding the declared state.
+     */
+    applyDeclaredState(script, scriptElement) {
         this.applyAttributes(script, scriptElement.scriptAttributes, this.inlineKeys(scriptElement));
         this.applyInlineAttributes(script, scriptElement);
         script.enabled = scriptElement.enabled;
-        scriptElement._onScriptCreated();
-        return script;
     }
     /**
-     * Applies the per-property attributes present on a `pc-script` element — any attribute that
+     * Applies the per-property attributes present on a `pc-script-instance` element — any attribute that
      * is not part of the element's own API or a reserved HTML attribute name. These are applied
      * after the `attributes` JSON, so an individual attribute always takes precedence over the
      * blob.
      * @param script - The script to apply the attributes to.
-     * @param scriptElement - The `pc-script` element holding the attributes.
+     * @param scriptElement - The `pc-script-instance` element holding the attributes.
      */
     applyInlineAttributes(script, scriptElement) {
         const scriptName = scriptElement.getAttribute('name') ?? '';
@@ -11890,10 +12139,10 @@ class ScriptComponentElement extends ComponentElement {
         }
     }
     /**
-     * Applies a single per-property attribute change to the script of a `pc-script` element.
+     * Applies a single per-property attribute change to the script of a `pc-script-instance` element.
      * When the attribute has been removed, the value from the `attributes` JSON (if any) takes
      * effect again.
-     * @param scriptElement - The `pc-script` element whose attribute changed.
+     * @param scriptElement - The `pc-script-instance` element whose attribute changed.
      * @param attributeName - The name of the changed attribute.
      */
     applyScriptProperty(scriptElement, attributeName) {
@@ -11929,7 +12178,7 @@ class ScriptComponentElement extends ComponentElement {
         try {
             const current = script[key];
             if (typeof current === 'function' || SCRIPT_API_MEMBERS.has(key)) {
-                console.warn(`Ignoring attribute '${attributeName}' on pc-script '${scriptName}' - '${key}' is part of the Script API.`);
+                console.warn(`Ignoring attribute '${attributeName}' on pc-script-instance '${scriptName}' - '${key}' is part of the Script API.`);
                 return;
             }
             if (typeof current === 'string') {
@@ -11985,10 +12234,10 @@ class ScriptComponentElement extends ComponentElement {
     }
     handleMutations(mutations) {
         for (const mutation of mutations) {
-            // Handle per-property attribute changes on child pc-script elements
+            // Handle per-property attribute changes on child pc-script-instance elements
             if (mutation.type === 'attributes') {
                 const target = mutation.target;
-                if (target instanceof ScriptElement &&
+                if (target instanceof ScriptInstanceElement &&
                     target.parentElement === this &&
                     mutation.attributeName &&
                     !isReservedAttribute(mutation.attributeName)) {
@@ -11998,16 +12247,16 @@ class ScriptComponentElement extends ComponentElement {
             }
             // Only direct children are managed - the observer watches the subtree for attribute
             // changes, but deeper childList records must not create or destroy scripts
-            // (matching initComponent's ':scope > pc-script' contract)
+            // (matching initComponent's ':scope > pc-script-instance' contract)
             if (mutation.target !== this) {
                 continue;
             }
-            // Handle removed nodes first, so that replacing a pc-script with a same-named one
+            // Handle removed nodes first, so that replacing a pc-script-instance with a same-named one
             // destroys the old script before the replacement is created. Only destroy a script
             // this element actually owns - a duplicate-named element whose own create() failed
             // must not take down the live script on removal.
             mutation.removedNodes.forEach((node) => {
-                if (node instanceof ScriptElement) {
+                if (node instanceof ScriptInstanceElement) {
                     const scriptName = node.getAttribute('name');
                     if (scriptName &&
                         node._script &&
@@ -12020,7 +12269,7 @@ class ScriptComponentElement extends ComponentElement {
             });
             // Handle added nodes
             mutation.addedNodes.forEach((node) => {
-                if (node instanceof ScriptElement) {
+                if (node instanceof ScriptInstanceElement) {
                     this.createScript(node);
                 }
             });
@@ -12038,14 +12287,16 @@ class ScriptComponentElement extends ComponentElement {
         return super.component;
     }
 }
-customElements.define('pc-scripts', ScriptComponentElement);
+customElements.define('pc-script', ScriptComponentElement);
 
 /**
  * The SoundComponentElement interface provides properties and methods for manipulating
- * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-sounds/ | `<pc-sounds>`} elements.
+ * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-sound/ | `<pc-sound>`} elements.
  * The SoundComponentElement interface also inherits the properties and methods of the
  * {@link HTMLElement} interface.
  *
+ * Engine component: {@link SoundComponent} (`sound`).
+ *
  * @category Components
  */
 class SoundComponentElement extends ComponentElement {
@@ -12236,11 +12487,11 @@ class SoundComponentElement extends ComponentElement {
         }
     }
 }
-customElements.define('pc-sounds', SoundComponentElement);
+customElements.define('pc-sound', SoundComponentElement);
 
 /**
  * The SoundSlotElement interface provides properties and methods for manipulating
- * `<pc-sound>` elements. The SoundSlotElement interface also inherits the properties and
+ * `<pc-sound-slot>` elements. The SoundSlotElement interface also inherits the properties and
  * methods of the {@link AsyncElement} interface.
  */
 class SoundSlotElement extends AsyncElement {
@@ -12254,7 +12505,7 @@ class SoundSlotElement extends AsyncElement {
     _startTime = 0;
     _volume = 1;
     /**
-     * The `<pc-sounds>` this slot was added to, captured at connect time.
+     * The `<pc-sound>` this slot was added to, captured at connect time.
      *
      * `disconnectedCallback` cannot rediscover it: by the time the element is disconnected its
      * `parentElement` is already `null`, so a lookup would both fail to find the component and
@@ -12317,7 +12568,7 @@ class SoundSlotElement extends AsyncElement {
     get soundElement() {
         const soundElement = this.parentElement;
         if (!(soundElement instanceof SoundComponentElement)) {
-            console.warn('pc-sound must be a direct child of a pc-sounds element');
+            console.warn('pc-sound-slot must be a direct child of a pc-sound element');
             return null;
         }
         return soundElement;
@@ -12513,7 +12764,7 @@ class SoundSlotElement extends AsyncElement {
         }
     }
 }
-customElements.define('pc-sound', SoundSlotElement);
+customElements.define('pc-sound-slot', SoundSlotElement);
 
 /**
  * The GSplatComponentElement interface provides properties and methods for manipulating
@@ -12521,6 +12772,8 @@ customElements.define('pc-sound', SoundSlotElement);
  * The GSplatComponentElement interface also inherits the properties and methods of the
  * {@link HTMLElement} interface.
  *
+ * Engine component: {@link GSplatComponent} (`gsplat`).
+ *
  * @category Components
  */
 class GSplatComponentElement extends ComponentElement {
@@ -12942,7 +13195,10 @@ class NodeElement extends EntityBaseElement {
      * is retained untouched — a redundant edit must not flicker overrides through a revert.
      */
     _rebind() {
-        const hostEntity = this._host?.entity ?? null;
+        // A model fronts a host entity of its own; the names this element resolves are the
+        // asset's, so the search starts at the instantiated content root, not the wrapper.
+        const host = this._host;
+        const hostEntity = (host instanceof ModelElement ? host.contentEntity : host?.entity) ?? null;
         if (!hostEntity || !this._name) {
             // Host not instantiated (or nothing to look up yet): return to pending. An assigned
             // name arriving later, or the host's next cycle, resolves it.
@@ -13039,8 +13295,9 @@ class NodeElement extends EntityBaseElement {
         }
         this._revertOverrides();
         // Attachment points anchor to the bound node, so they cannot outlive the binding. Each
-        // destroyed entity resets its element, which the next _buildChildren re-creates.
-        this.querySelectorAll('pc-entity').forEach((child) => {
+        // destroyed entity resets its element, which the next _buildChildren re-creates - a
+        // model host among them re-instantiates its content when it rebuilds.
+        this.querySelectorAll('pc-entity, pc-model').forEach((child) => {
             if (child.closestEntity === this) {
                 child.entity?.destroy();
             }
@@ -14071,6 +14328,7 @@ exports.AnimComponentElement = AnimComponentElement;
 exports.AppElement = AppElement;
 exports.AssetElement = AssetElement;
 exports.AsyncElement = AsyncElement;
+exports.AudioListenerComponentElement = AudioListenerComponentElement;
 exports.ButtonComponentElement = ButtonComponentElement;
 exports.CameraComponentElement = CameraComponentElement;
 exports.CollisionComponentElement = CollisionComponentElement;
@@ -14078,15 +14336,14 @@ exports.ComponentElement = ComponentElement;
 exports.ElementComponentElement = ElementComponentElement;
 exports.EntityBaseElement = EntityBaseElement;
 exports.EntityElement = EntityElement;
+exports.EntityOwnerElement = EntityOwnerElement;
 exports.GSplatComponentElement = GSplatComponentElement;
 exports.JointComponentElement = JointComponentElement;
 exports.LayoutChildComponentElement = LayoutChildComponentElement;
 exports.LayoutGroupComponentElement = LayoutGroupComponentElement;
 exports.LightComponentElement = LightComponentElement;
-exports.ListenerComponentElement = ListenerComponentElement;
 exports.MaterialElement = MaterialElement;
 exports.ModelElement = ModelElement;
-exports.ModuleElement = ModuleElement;
 exports.NodeElement = NodeElement;
 exports.ParticleSystemComponentElement = ParticleSystemComponentElement;
 exports.RenderComponentElement = RenderComponentElement;
@@ -14094,11 +14351,12 @@ exports.RigidBodyComponentElement = RigidBodyComponentElement;
 exports.SceneElement = SceneElement;
 exports.ScreenComponentElement = ScreenComponentElement;
 exports.ScriptComponentElement = ScriptComponentElement;
-exports.ScriptElement = ScriptElement;
+exports.ScriptInstanceElement = ScriptInstanceElement;
 exports.ScrollViewComponentElement = ScrollViewComponentElement;
 exports.ScrollbarComponentElement = ScrollbarComponentElement;
 exports.SkyElement = SkyElement;
 exports.SoundComponentElement = SoundComponentElement;
 exports.SoundSlotElement = SoundSlotElement;
+exports.WasmElement = WasmElement;
 exports.whenReady = whenReady;
 //# sourceMappingURL=pwc.cjs.map