@playcanvas/web-components 0.11.1 → 0.13.0

package/dist/custom-elements.json

@@ -8,7 +8,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "The AppElement interface provides properties and methods for manipulating\n[`<pc-app>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-app/) elements.\nThe AppElement interface also inherits the properties and methods of the\nHTMLElement interface.\n",
+          "description": "The AppElement interface provides properties and methods for manipulating\n[`<pc-app>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-app/) elements.\nThe AppElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nThe element is sized like a replaced element such as `<video>`: a block-level box that the\npage's CSS controls, 300x150 by default. The application's canvas always fills the element,\nand the drawing buffer resolution follows the element's size (capped by `max-pixel-ratio`),\ntracked live via a ResizeObserver — so the element can be embedded at any size, resized by\nits container, or made fullscreen with ordinary CSS such as `width: 100vw; height: 100dvh`.\n",
           "name": "AppElement",
           "members": [
             {
@@ -95,9 +95,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -142,7 +142,7 @@
                   "description": "The entity to look up."
                 }
               ],
-              "description": "Returns the `<pc-entity>` element whose backing entity is `entity`, or `null` if the\nentity was not created by an element of this application - for example, a node inside a\nmodel's instantiated hierarchy, or an entity created through the engine API."
+              "description": "Returns the `<pc-entity>` or `<pc-node>` element whose backing entity is `entity`, or\n`null` if the entity is not fronted by an element of this application - for example, an\nunbound node inside a model's instantiated hierarchy, or an entity created through the\nengine API."
             },
             {
               "kind": "field",
@@ -222,6 +222,13 @@
             }
           ],
           "events": [
+            {
+              "name": "error",
+              "type": {
+                "text": "ErrorEvent"
+              },
+              "description": "Fired when the application cannot boot because no graphics device could be created (for example, a browser with WebGL disabled). `message` names the requested backends and `error` holds the underlying failure. The element never becomes ready and `app` stays `null` — listen for this event to show a fallback UI. Removing the element and re-inserting it retries the boot with its current attributes. Does not bubble."
+            },
             {
               "name": "progress",
               "type": {
@@ -339,9 +346,66 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "The AssetElement interface provides properties and methods for manipulating\n[`<pc-asset>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-asset/) elements.\nThe AssetElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nThe element becomes ready once the containing application has started and the asset is in the\nstate declared by the markup: loaded for preloaded assets (even if loading failed — check the\nasset's `resource`), or registered and awaiting a load for `lazy` assets. Elements inserted\nwhile the application is running are created and registered on insertion, and begin loading\nimmediately unless `lazy`. A `pc-asset` must be a direct child of `pc-app` — elements placed\nelsewhere, or with an unsupported asset type, never become ready.\n\nApart from `lazy`, these attributes are read once when the asset is created, so changing them\nlater has no effect.\n",
+          "description": "The AssetElement interface provides properties and methods for manipulating\n[`<pc-asset>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-asset/) elements.\nThe AssetElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nThe element becomes ready once the containing application has started and the asset is in the\nstate declared by the markup: loaded for preloaded assets (even if loading failed — check the\nasset's `resource`), or registered and awaiting a load for `lazy` assets. Elements inserted\nwhile the application is running are created and registered on insertion, and begin loading\nimmediately unless `lazy`. A `pc-asset` must be a direct child of `pc-app` — elements placed\nelsewhere, or with an unsupported asset type, never become ready.\n\nFor `texture` and `textureatlas` assets, the texture options (`address-u`, `address-v`,\n`min-filter`, `mag-filter`, `anisotropy`, `mipmaps`, `srgb`, `flip-y`) apply when the texture is\ncreated and — like `lazy` — are observed: changing one updates a texture that has already\nloaded, and removing one restores the engine default. Changing `srgb` or `mipmaps` on a loaded\ntexture recreates the underlying GPU resource, so prefer declaring those up front. Each option\noverrides the matching key in the `data` JSON; options left unset write nothing, leaving the\nengine's per-format defaults in force.\n\nApart from `lazy` and the texture options, these attributes are read once when the asset is\ncreated, so changing them later has no effect.\n",
           "name": "AssetElement",
           "members": [
+            {
+              "kind": "field",
+              "name": "addressU",
+              "description": "Gets the texture's horizontal (U) address mode.",
+              "parameters": [
+                {
+                  "description": "The address mode, or `null` to use the engine default of 'repeat'.",
+                  "name": "value"
+                }
+              ],
+              "type": {
+                "text": "AddressMode | null"
+              },
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              }
+            },
+            {
+              "kind": "field",
+              "name": "addressV",
+              "description": "Gets the texture's vertical (V) address mode.",
+              "parameters": [
+                {
+                  "description": "The address mode, or `null` to use the engine default of 'repeat'.",
+                  "name": "value"
+                }
+              ],
+              "type": {
+                "text": "AddressMode | null"
+              },
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              }
+            },
+            {
+              "kind": "field",
+              "name": "anisotropy",
+              "description": "Gets the texture's maximum anisotropic filtering level.",
+              "parameters": [
+                {
+                  "description": "The anisotropy level, or `null` to use the engine default of 1.",
+                  "name": "value"
+                }
+              ],
+              "type": {
+                "text": "number | null"
+              },
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              }
+            },
             {
               "kind": "field",
               "name": "asset",
@@ -373,9 +437,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -387,6 +451,25 @@
                 "module": "src/async-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "flipY",
+              "description": "Gets whether the texture's image data is flipped vertically at upload.",
+              "parameters": [
+                {
+                  "description": "The flip flag, or `null` to use the engine default of `false`.",
+                  "name": "value"
+                }
+              ],
+              "type": {
+                "text": "boolean | null"
+              },
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              }
+            },
             {
               "kind": "method",
               "name": "get",
@@ -423,6 +506,63 @@
                 }
               }
             },
+            {
+              "kind": "field",
+              "name": "magFilter",
+              "description": "Gets the texture's magnification filter.",
+              "parameters": [
+                {
+                  "description": "The filter, or `null` to use the engine default of 'linear'.",
+                  "name": "value"
+                }
+              ],
+              "type": {
+                "text": "MagFilterMode | null"
+              },
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              }
+            },
+            {
+              "kind": "field",
+              "name": "minFilter",
+              "description": "Gets the texture's minification filter.",
+              "parameters": [
+                {
+                  "description": "The filter, or `null` to use the engine default of 'linear-mip-linear'.",
+                  "name": "value"
+                }
+              ],
+              "type": {
+                "text": "MinFilterMode | null"
+              },
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              }
+            },
+            {
+              "kind": "field",
+              "name": "mipmaps",
+              "description": "Gets whether the texture generates and uses mipmaps.",
+              "parameters": [
+                {
+                  "description": "The mipmaps flag, or `null` to use the engine default of `true`.",
+                  "name": "value"
+                }
+              ],
+              "type": {
+                "text": "boolean | null"
+              },
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              }
+            },
             {
               "kind": "method",
               "name": "ready",
@@ -436,6 +576,25 @@
                 "name": "AsyncElement",
                 "module": "src/async-element.ts"
               }
+            },
+            {
+              "kind": "field",
+              "name": "srgb",
+              "description": "Gets whether the texture holds sRGB (gamma-encoded) color data.",
+              "parameters": [
+                {
+                  "description": "The sRGB flag, or `null` to use the engine default of `false`.",
+                  "name": "value"
+                }
+              ],
+              "type": {
+                "text": "boolean | null"
+              },
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              }
             }
           ],
           "events": [
@@ -466,6 +625,33 @@
             }
           ],
           "attributes": [
+            {
+              "name": "address-u",
+              "type": {
+                "text": "'repeat' | 'clamp' | 'mirror'"
+              },
+              "fieldName": "addressU",
+              "default": "repeat",
+              "description": "The texture's horizontal (U) address mode."
+            },
+            {
+              "name": "address-v",
+              "type": {
+                "text": "'repeat' | 'clamp' | 'mirror'"
+              },
+              "fieldName": "addressV",
+              "default": "repeat",
+              "description": "The texture's vertical (V) address mode."
+            },
+            {
+              "name": "anisotropy",
+              "type": {
+                "text": "number"
+              },
+              "fieldName": "anisotropy",
+              "default": "1",
+              "description": "The texture's maximum anisotropic filtering level."
+            },
             {
               "type": {
                 "text": "string"
@@ -480,6 +666,15 @@
               "description": "Additional asset data, as a JSON object.",
               "name": "data"
             },
+            {
+              "name": "flip-y",
+              "type": {
+                "text": "boolean"
+              },
+              "fieldName": "flipY",
+              "default": "false",
+              "description": "Whether the texture's image data is flipped vertically at upload."
+            },
             {
               "type": {
                 "text": "string"
@@ -503,6 +698,33 @@
               "default": "false",
               "description": "Whether the asset should be loaded lazily."
             },
+            {
+              "name": "mag-filter",
+              "type": {
+                "text": "'nearest' | 'linear'"
+              },
+              "fieldName": "magFilter",
+              "default": "linear",
+              "description": "The texture's magnification filter."
+            },
+            {
+              "name": "min-filter",
+              "type": {
+                "text": "'nearest' | 'linear' | 'nearest-mip-nearest' | 'linear-mip-nearest' | 'nearest-mip-linear' | 'linear-mip-linear'"
+              },
+              "fieldName": "minFilter",
+              "default": "linear-mip-linear",
+              "description": "The texture's minification filter."
+            },
+            {
+              "name": "mipmaps",
+              "type": {
+                "text": "boolean"
+              },
+              "fieldName": "mipmaps",
+              "default": "true",
+              "description": "Whether the texture generates and uses mipmaps."
+            },
             {
               "type": {
                 "text": "number"
@@ -524,6 +746,15 @@
               "description": "The URL of the asset to load.",
               "name": "src"
             },
+            {
+              "name": "srgb",
+              "type": {
+                "text": "boolean"
+              },
+              "fieldName": "srgb",
+              "default": "false",
+              "description": "Whether the texture holds sRGB (gamma-encoded) color data."
+            },
             {
               "type": {
                 "text": "string"
@@ -586,9 +817,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -638,7 +869,7 @@
               "description": "The tag name of the element to wait for (e.g. `'pc-app'`)."
             }
           ],
-          "description": "Waits for the first element matching the given tag name to be fully initialized. Note that the\npromise never settles if the element cannot finish initializing (for example, a `<pc-script>`\nthat is not a direct child of `<pc-scripts>`). A component element outside a `<pc-entity>` is\nthe exception: it still becomes ready, but its `component` is `null`. Either way, a misplaced\nelement logs a warning naming the parent it requires."
+          "description": "Waits for the first element matching the given tag name to be fully initialized. Note that the\npromise never settles if the element cannot finish initializing (for example, a `<pc-script>`\nthat is not a direct child of `<pc-scripts>`, or a `<pc-app>` that could not create a graphics\ndevice — listen for its `error` event instead). A component element outside a `<pc-entity>` is\nthe exception: it still becomes ready, but its `component` is `null`. Either way, a misplaced\nelement logs a warning naming the parent it requires."
         },
         {
           "kind": "function",
@@ -676,7 +907,7 @@
               "description": "A CSS selector matching the element to wait for (e.g. `'#my-app'`)."
             }
           ],
-          "description": "Waits for the first element matching the given CSS selector to be fully initialized. Note that\nthe promise never settles if the element cannot finish initializing (for example, a `<pc-script>`\nthat is not a direct child of `<pc-scripts>`). A component element outside a `<pc-entity>` is\nthe exception: it still becomes ready, but its `component` is `null`. Either way, a misplaced\nelement logs a warning naming the parent it requires."
+          "description": "Waits for the first element matching the given CSS selector to be fully initialized. Note that\nthe promise never settles if the element cannot finish initializing (for example, a `<pc-script>`\nthat is not a direct child of `<pc-scripts>`, or a `<pc-app>` that could not create a graphics\ndevice — listen for its `error` event instead). A component element outside a `<pc-entity>` is\nthe exception: it still becomes ready, but its `component` is `null`. Either way, a misplaced\nelement logs a warning naming the parent it requires."
         },
         {
           "kind": "function",
@@ -725,12 +956,12 @@
     },
     {
       "kind": "javascript-module",
-      "path": "src/entity.ts",
+      "path": "src/entity-base.ts",
       "declarations": [
         {
           "kind": "class",
-          "description": "The EntityElement interface provides properties and methods for manipulating\n[`<pc-entity>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-entity/) elements.\nThe EntityElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nThe pointer events below are dispatched by the containing `<pc-app>` element when the pointer\nintersects this entity's geometry. They are only generated while the entity has a listener for\nthem, registered either with addEventListener or with the matching inline `onpointer*`\nattribute.\n",
-          "name": "EntityElement",
+          "description": "The base class for elements that front an engine Entity: `<pc-entity>`, which creates\none, and `<pc-node>`, which binds to one inside a model's instantiated hierarchy. It carries\nwhat both need — the `entity` contract, registration with the owning application (which joins\npicked scene nodes back to elements by identity, never by name), and the pointer listener\nbookkeeping that lets the application lazily attach its canvas handlers.",
+          "name": "EntityBaseElement",
           "members": [
             {
               "kind": "method",
@@ -779,9 +1010,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -793,29 +1024,13 @@
                 "module": "src/async-element.ts"
               }
             },
-            {
-              "kind": "field",
-              "name": "enabled",
-              "description": "Gets the enabled state of the entity.",
-              "parameters": [
-                {
-                  "description": "Whether the entity is enabled.",
-                  "name": "value"
-                }
-              ],
-              "return": {
-                "type": {
-                  "text": ""
-                }
-              }
-            },
             {
               "kind": "field",
               "name": "entity",
               "type": {
                 "text": "Entity | null"
               },
-              "description": "The PlayCanvas entity instance. `null` until the element is ready, and again once it has\nbeen removed from the document — await whenReady or the element's `ready()`\npromise before accessing it.",
+              "description": "The PlayCanvas entity instance. `null` until the element is ready, and again once the\nentity is gone — await whenReady or the element's `ready()` promise before\naccessing it.",
               "return": {
                 "type": {
                   "text": ""
@@ -823,38 +1038,6 @@
               },
               "readonly": true
             },
-            {
-              "kind": "field",
-              "name": "name",
-              "description": "Gets the name of the entity.",
-              "parameters": [
-                {
-                  "description": "The name of the entity.",
-                  "name": "value"
-                }
-              ],
-              "return": {
-                "type": {
-                  "text": ""
-                }
-              }
-            },
-            {
-              "kind": "field",
-              "name": "position",
-              "description": "Gets the position of the entity.",
-              "parameters": [
-                {
-                  "description": "The position of the entity.",
-                  "name": "value"
-                }
-              ],
-              "return": {
-                "type": {
-                  "text": ""
-                }
-              }
-            },
             {
               "kind": "method",
               "name": "ready",
@@ -893,34 +1076,248 @@
                   }
                 }
               ]
-            },
+            }
+          ],
+          "events": [
             {
-              "kind": "field",
-              "name": "rotation",
-              "description": "Gets the rotation of the entity.",
-              "parameters": [
-                {
-                  "description": "The rotation of the entity.",
-                  "name": "value"
-                }
-              ],
-              "return": {
-                "type": {
-                  "text": ""
-                }
+              "name": "ready",
+              "type": {
+                "text": "CustomEvent"
+              },
+              "description": "Fired when the element is fully initialized — once per readiness cycle, so an element that is torn down and re-initialized (for example by removing and re-inserting it) fires it again. Bubbles and is composed.",
+              "inheritedFrom": {
+                "name": "AsyncElement",
+                "module": "src/async-element.ts"
               }
-            },
-            {
-              "kind": "field",
-              "name": "scale",
-              "description": "Gets the scale of the entity.",
-              "parameters": [
-                {
-                  "description": "The scale of the entity.",
-                  "name": "value"
-                }
-              ],
-              "return": {
+            }
+          ],
+          "superclass": {
+            "name": "AsyncElement",
+            "module": "/src/async-element"
+          }
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "EntityBaseElement",
+          "declaration": {
+            "name": "EntityBaseElement",
+            "module": "src/entity-base.ts"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/entity.ts",
+      "declarations": [
+        {
+          "kind": "class",
+          "description": "The EntityElement interface provides properties and methods for manipulating\n[`<pc-entity>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-entity/) elements.\nThe EntityElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nThe pointer events below are dispatched by the containing `<pc-app>` element when the pointer\nintersects this entity's geometry. They are only generated while the entity has a listener for\nthem, registered either with addEventListener or with the matching inline `onpointer*`\nattribute.\n",
+          "name": "EntityElement",
+          "members": [
+            {
+              "kind": "method",
+              "name": "addEventListener",
+              "parameters": [
+                {
+                  "name": "type",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "listener",
+                  "type": {
+                    "text": "EventListener"
+                  }
+                },
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "boolean | AddEventListenerOptions"
+                  }
+                }
+              ],
+              "inheritedFrom": {
+                "name": "EntityBaseElement",
+                "module": "src/entity-base.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "closestApp",
+              "type": {
+                "text": "AppElement | null"
+              },
+              "description": "The nearest ancestor `<pc-app>` element, or `null` if this element has no `<pc-app>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "AsyncElement",
+                "module": "src/async-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "closestEntity",
+              "type": {
+                "text": "EntityBaseElement | null"
+              },
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "AsyncElement",
+                "module": "src/async-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "enabled",
+              "description": "Gets the enabled state of the entity.",
+              "parameters": [
+                {
+                  "description": "Whether the entity is enabled.",
+                  "name": "value"
+                }
+              ],
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              }
+            },
+            {
+              "kind": "field",
+              "name": "entity",
+              "type": {
+                "text": "Entity | null"
+              },
+              "description": "The PlayCanvas entity instance. `null` until the element is ready, and again once the\nentity is gone — await whenReady or the element's `ready()` promise before\naccessing it.",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "EntityBaseElement",
+                "module": "src/entity-base.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "name",
+              "description": "Gets the name of the entity.",
+              "parameters": [
+                {
+                  "description": "The name of the entity.",
+                  "name": "value"
+                }
+              ],
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              }
+            },
+            {
+              "kind": "field",
+              "name": "position",
+              "description": "Gets the position of the entity.",
+              "parameters": [
+                {
+                  "description": "The position of the entity.",
+                  "name": "value"
+                }
+              ],
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              }
+            },
+            {
+              "kind": "method",
+              "name": "ready",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "description": "Returns a promise that resolves with this element when it's ready. This is the low-level\nprimitive underlying whenReady, which is the recommended way to wait for elements.\n\nReadiness tracks the element's current lifecycle: once a ready element is torn down (for\nexample by removing it from the document), this returns a fresh promise that resolves when\nthe element is next ready. A promise obtained earlier stays resolved — call this again\nafter re-inserting an element rather than reusing a promise from before its removal.",
+              "inheritedFrom": {
+                "name": "AsyncElement",
+                "module": "src/async-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "removeEventListener",
+              "parameters": [
+                {
+                  "name": "type",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "listener",
+                  "type": {
+                    "text": "EventListener"
+                  }
+                },
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "boolean | EventListenerOptions"
+                  }
+                }
+              ],
+              "inheritedFrom": {
+                "name": "EntityBaseElement",
+                "module": "src/entity-base.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "rotation",
+              "description": "Gets the rotation of the entity.",
+              "parameters": [
+                {
+                  "description": "The rotation of the entity.",
+                  "name": "value"
+                }
+              ],
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              }
+            },
+            {
+              "kind": "field",
+              "name": "scale",
+              "description": "Gets the scale of the entity.",
+              "parameters": [
+                {
+                  "description": "The scale of the entity.",
+                  "name": "value"
+                }
+              ],
+              "return": {
                 "type": {
                   "text": ""
                 }
@@ -1010,43 +1407,43 @@
               "description": "The name of the entity."
             },
             {
-              "name": "onpointerdown",
               "type": {
                 "text": "string"
               },
               "description": "Script to run when a pointer button is pressed over the entity.",
+              "name": "onpointerdown",
               "fieldName": "onpointerdown"
             },
             {
-              "name": "onpointerenter",
               "type": {
                 "text": "string"
               },
               "description": "Script to run when the pointer moves onto the entity.",
+              "name": "onpointerenter",
               "fieldName": "onpointerenter"
             },
             {
-              "name": "onpointerleave",
               "type": {
                 "text": "string"
               },
               "description": "Script to run when the pointer moves off the entity.",
+              "name": "onpointerleave",
               "fieldName": "onpointerleave"
             },
             {
-              "name": "onpointermove",
               "type": {
                 "text": "string"
               },
               "description": "Script to run when the pointer moves over the entity.",
+              "name": "onpointermove",
               "fieldName": "onpointermove"
             },
             {
-              "name": "onpointerup",
               "type": {
                 "text": "string"
               },
               "description": "Script to run when a pointer button is released over the entity.",
+              "name": "onpointerup",
               "fieldName": "onpointerup"
             },
             {
@@ -1086,8 +1483,8 @@
             }
           ],
           "superclass": {
-            "name": "AsyncElement",
-            "module": "/src/async-element"
+            "name": "EntityBaseElement",
+            "module": "/src/entity-base"
           },
           "tagName": "pc-entity",
           "customElement": true
@@ -1317,6 +1714,14 @@
             "module": "src/index.ts"
           }
         },
+        {
+          "kind": "js",
+          "name": "EntityBaseElement",
+          "declaration": {
+            "name": "EntityBaseElement",
+            "module": "src/index.ts"
+          }
+        },
         {
           "kind": "js",
           "name": "MaterialElement",
@@ -1333,6 +1738,14 @@
             "module": "src/index.ts"
           }
         },
+        {
+          "kind": "js",
+          "name": "NodeElement",
+          "declaration": {
+            "name": "NodeElement",
+            "module": "src/index.ts"
+          }
+        },
         {
           "kind": "js",
           "name": "SceneElement",
@@ -3526,7 +3939,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "The ModelElement interface provides properties and methods for manipulating\n[`<pc-model>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-model/) elements.\nThe ModelElement interface also inherits the properties and methods of the\nHTMLElement interface.\n",
+          "description": "The ModelElement interface provides properties and methods for manipulating\n[`<pc-model>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-model/) elements.\nThe ModelElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nThe element becomes ready once its container asset has loaded and the instantiated hierarchy has\nbeen added to the scene — `entity` is non-null by then. A failed load also settles readiness,\nwith `entity` remaining `null`: readiness means the load settled, not that it succeeded — listen\nfor `error`, or check `entity`, to tell the outcomes apart. Changing `asset` re-arms readiness\nand instantiates anew, so a `ready()` obtained after the change resolves against the new\nhierarchy. A `pc-model` outside a `pc-app`, or referencing an unknown asset id, warns and never\nbecomes ready.\n",
           "name": "ModelElement",
           "members": [
             {
@@ -3570,9 +3983,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -3613,23 +4026,21 @@
               }
             }
           ],
-          "attributes": [
+          "events": [
             {
-              "name": "asset",
+              "name": "error",
               "type": {
-                "text": "string"
+                "text": "ErrorEvent"
               },
-              "fieldName": "asset",
-              "description": "The id of the `pc-asset` to use for the model."
-            }
-          ],
-          "superclass": {
-            "name": "AsyncElement",
-            "module": "/src/async-element"
-          },
-          "tagName": "pc-model",
-          "customElement": true,
-          "events": [
+              "description": "Fired when the container asset fails to load, with the engine's error in `message`. Does not bubble. The element still becomes ready — readiness means the load settled, not that it succeeded."
+            },
+            {
+              "name": "load",
+              "type": {
+                "text": "Event"
+              },
+              "description": "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."
+            },
             {
               "name": "ready",
               "type": {
@@ -3641,7 +4052,23 @@
                 "module": "src/async-element.ts"
               }
             }
-          ]
+          ],
+          "attributes": [
+            {
+              "name": "asset",
+              "type": {
+                "text": "string"
+              },
+              "fieldName": "asset",
+              "description": "The id of the `pc-asset` to use for the model."
+            }
+          ],
+          "superclass": {
+            "name": "AsyncElement",
+            "module": "/src/async-element"
+          },
+          "tagName": "pc-model",
+          "customElement": true
         }
       ],
       "exports": [
@@ -3669,8 +4096,60 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "The ModuleElement interface provides properties and methods for manipulating\n[`<pc-module>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-module/) elements.\nThe ModuleElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nNote that these attributes are read once when the element is created, so changing them later\nhas no effect.\n",
+          "description": "The ModuleElement interface provides properties and methods for manipulating\n[`<pc-module>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-module/)\nelements. The ModuleElement interface also inherits the properties and methods of the\nAsyncElement interface.\n\nThe attributes are read once, when the module starts loading - on the element's first\nconnection, or earlier if a containing `<pc-app>` boots first and collects it - so changing\nthem later has no effect. The element becomes ready once the module has loaded. WebAssembly\nmodules configure engine-global state that never unloads, so readiness is not re-armed by\nremoving the element, and a re-inserted element does not load again.\n\nA `<pc-module>` without a `name` warns and never becomes ready; a containing `<pc-app>` still\nboots.\n",
           "name": "ModuleElement",
+          "members": [
+            {
+              "kind": "field",
+              "name": "closestApp",
+              "type": {
+                "text": "AppElement | null"
+              },
+              "description": "The nearest ancestor `<pc-app>` element, or `null` if this element has no `<pc-app>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "AsyncElement",
+                "module": "src/async-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "closestEntity",
+              "type": {
+                "text": "EntityBaseElement | null"
+              },
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "AsyncElement",
+                "module": "src/async-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "ready",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "description": "Returns a promise that resolves with this element when it's ready. This is the low-level\nprimitive underlying whenReady, which is the recommended way to wait for elements.\n\nReadiness tracks the element's current lifecycle: once a ready element is torn down (for\nexample by removing it from the document), this returns a fresh promise that resolves when\nthe element is next ready. A promise obtained earlier stays resolved — call this again\nafter re-inserting an element rather than reusing a promise from before its removal.",
+              "inheritedFrom": {
+                "name": "AsyncElement",
+                "module": "src/async-element.ts"
+              }
+            }
+          ],
           "attributes": [
             {
               "type": {
@@ -3702,25 +4181,24 @@
             }
           ],
           "superclass": {
-            "name": "HTMLElement"
+            "name": "AsyncElement",
+            "module": "/src/async-element"
           },
           "tagName": "pc-module",
-          "customElement": true
-        },
-        {
-          "kind": "variable",
-          "name": "glueUrl",
-          "default": "this.getAttribute('glue')!"
-        },
-        {
-          "kind": "variable",
-          "name": "wasmUrl",
-          "default": "this.getAttribute('wasm')!"
-        },
-        {
-          "kind": "variable",
-          "name": "fallbackUrl",
-          "default": "this.getAttribute('fallback')!"
+          "customElement": true,
+          "events": [
+            {
+              "name": "ready",
+              "type": {
+                "text": "CustomEvent"
+              },
+              "description": "Fired when the element is fully initialized — once per readiness cycle, so an element that is torn down and re-initialized (for example by removing and re-inserting it) fires it again. Bubbles and is composed.",
+              "inheritedFrom": {
+                "name": "AsyncElement",
+                "module": "src/async-element.ts"
+              }
+            }
+          ]
         }
       ],
       "exports": [
@@ -3742,6 +4220,476 @@
         }
       ]
     },
+    {
+      "kind": "javascript-module",
+      "path": "src/node.ts",
+      "declarations": [
+        {
+          "kind": "class",
+          "description": "The NodeElement interface provides properties and methods for manipulating\n[`<pc-node>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-node/)\nelements. The NodeElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nA `pc-node` is an override element: where `pc-entity` creates an entity, `pc-node` binds to a\nnode a `pc-model` loaded and declares overrides against the authored asset — components to\nadd, properties to change, content to attach. Attributes present apply as overrides; attributes\nabsent leave authored values untouched, and removing an attribute (or assigning `null` to the\nmatching property) restores the authored value.\n\n`name` selects among the host model's nodes (first match in depth-first order), nesting a\n`pc-node` inside another scopes the search to that subtree, and `index` picks among identically\nnamed matches. When `name` matches more than one node and no `index` is given, the element\nwarns and binds nothing.\n\nThe element becomes ready once bound, and never while unresolved — a missing or ambiguous\nname warns and records the failure in `state`, readiness stays unresolved, and descendants\nwait with it.\n\nThe pointer events below are dispatched by the containing `<pc-app>` element when the pointer\nintersects the bound node's geometry, exactly as for `<pc-entity>`.\n",
+          "name": "NodeElement",
+          "members": [
+            {
+              "kind": "method",
+              "name": "addEventListener",
+              "parameters": [
+                {
+                  "name": "type",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "listener",
+                  "type": {
+                    "text": "EventListener"
+                  }
+                },
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "boolean | AddEventListenerOptions"
+                  }
+                }
+              ],
+              "inheritedFrom": {
+                "name": "EntityBaseElement",
+                "module": "src/entity-base.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "closestApp",
+              "type": {
+                "text": "AppElement | null"
+              },
+              "description": "The nearest ancestor `<pc-app>` element, or `null` if this element has no `<pc-app>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "AsyncElement",
+                "module": "src/async-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "closestEntity",
+              "type": {
+                "text": "EntityBaseElement | null"
+              },
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "AsyncElement",
+                "module": "src/async-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "enabled",
+              "description": "Gets the enabled override.",
+              "parameters": [
+                {
+                  "description": "The enabled state, or `null`.",
+                  "name": "value"
+                }
+              ],
+              "type": {
+                "text": "boolean | null"
+              },
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              }
+            },
+            {
+              "kind": "field",
+              "name": "entity",
+              "type": {
+                "text": "Entity | null"
+              },
+              "description": "The PlayCanvas entity instance. `null` until the element is ready, and again once the\nentity is gone — await whenReady or the element's `ready()` promise before\naccessing it.",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "EntityBaseElement",
+                "module": "src/entity-base.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "index",
+              "description": "Gets which match to bind.",
+              "parameters": [
+                {
+                  "description": "The match index, or `null`.",
+                  "name": "value"
+                }
+              ],
+              "type": {
+                "text": "number | null"
+              },
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              }
+            },
+            {
+              "kind": "field",
+              "name": "name",
+              "description": "Gets the name of the node to bind.",
+              "parameters": [
+                {
+                  "description": "The node name.",
+                  "name": "value"
+                }
+              ],
+              "type": {
+                "text": "string"
+              },
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              }
+            },
+            {
+              "kind": "field",
+              "name": "path",
+              "type": {
+                "text": "string | null"
+              },
+              "description": "The path of the bound node below the search root, `/`-separated, or `null` while not\nbound.",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "position",
+              "description": "Gets the local position override.",
+              "parameters": [
+                {
+                  "description": "The position, or `null`.",
+                  "name": "value"
+                }
+              ],
+              "type": {
+                "text": "Vec3 | null"
+              },
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              }
+            },
+            {
+              "kind": "method",
+              "name": "ready",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "description": "Returns a promise that resolves with this element when it's ready. This is the low-level\nprimitive underlying whenReady, which is the recommended way to wait for elements.\n\nReadiness tracks the element's current lifecycle: once a ready element is torn down (for\nexample by removing it from the document), this returns a fresh promise that resolves when\nthe element is next ready. A promise obtained earlier stays resolved — call this again\nafter re-inserting an element rather than reusing a promise from before its removal.",
+              "inheritedFrom": {
+                "name": "AsyncElement",
+                "module": "src/async-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "removeEventListener",
+              "parameters": [
+                {
+                  "name": "type",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "listener",
+                  "type": {
+                    "text": "EventListener"
+                  }
+                },
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "boolean | EventListenerOptions"
+                  }
+                }
+              ],
+              "inheritedFrom": {
+                "name": "EntityBaseElement",
+                "module": "src/entity-base.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "rotation",
+              "description": "Gets the local rotation override.",
+              "parameters": [
+                {
+                  "description": "The rotation, or `null`.",
+                  "name": "value"
+                }
+              ],
+              "type": {
+                "text": "Vec3 | null"
+              },
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              }
+            },
+            {
+              "kind": "field",
+              "name": "scale",
+              "description": "Gets the local scale override.",
+              "parameters": [
+                {
+                  "description": "The scale, or `null`.",
+                  "name": "value"
+                }
+              ],
+              "type": {
+                "text": "Vec3 | null"
+              },
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              }
+            },
+            {
+              "kind": "field",
+              "name": "state",
+              "type": {
+                "text": "NodeBindingState"
+              },
+              "description": "The binding state: `pending` until the host instantiates and `name` resolves, `bound`\nonce decorated, `missing`/`ambiguous`/`duplicate` when resolution failed (each also\nwarns). Useful for asserting a document's bindings programmatically.",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "tags",
+              "description": "Gets the tags override.",
+              "parameters": [
+                {
+                  "description": "The tags, or `null`.",
+                  "name": "value"
+                }
+              ],
+              "type": {
+                "text": "string[] | null"
+              },
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              }
+            }
+          ],
+          "events": [
+            {
+              "type": {
+                "text": "PointerEvent"
+              },
+              "description": "Fired when a pointer button is pressed over the node.",
+              "name": "pointerdown"
+            },
+            {
+              "type": {
+                "text": "PointerEvent"
+              },
+              "description": "Fired when the pointer moves onto the node.",
+              "name": "pointerenter"
+            },
+            {
+              "type": {
+                "text": "PointerEvent"
+              },
+              "description": "Fired when the pointer moves off the node.",
+              "name": "pointerleave"
+            },
+            {
+              "type": {
+                "text": "PointerEvent"
+              },
+              "description": "Fired when the pointer moves over the node.",
+              "name": "pointermove"
+            },
+            {
+              "type": {
+                "text": "PointerEvent"
+              },
+              "description": "Fired when a pointer button is released over the node.",
+              "name": "pointerup"
+            },
+            {
+              "name": "ready",
+              "type": {
+                "text": "CustomEvent"
+              },
+              "description": "Fired when the element is fully initialized — once per readiness cycle, so an element that is torn down and re-initialized (for example by removing and re-inserting it) fires it again. Bubbles and is composed.",
+              "inheritedFrom": {
+                "name": "AsyncElement",
+                "module": "src/async-element.ts"
+              }
+            }
+          ],
+          "attributes": [
+            {
+              "name": "enabled",
+              "type": {
+                "text": "string"
+              },
+              "description": "Overrides the node's enabled state.",
+              "fieldName": "enabled"
+            },
+            {
+              "name": "index",
+              "type": {
+                "text": "string"
+              },
+              "description": "Which match to bind when `name` matches more than one node, 0-based in depth-first order. Optional for a unique match; required for an ambiguous one.",
+              "fieldName": "index"
+            },
+            {
+              "name": "name",
+              "type": {
+                "text": "string"
+              },
+              "description": "The name of the node to bind, resolved within the nearest ancestor `pc-model` (or `pc-node`) once it has instantiated.",
+              "fieldName": "name"
+            },
+            {
+              "type": {
+                "text": "string"
+              },
+              "description": "Script to run when a pointer button is pressed over the node.",
+              "name": "onpointerdown",
+              "fieldName": "onpointerdown"
+            },
+            {
+              "type": {
+                "text": "string"
+              },
+              "description": "Script to run when the pointer moves onto the node.",
+              "name": "onpointerenter",
+              "fieldName": "onpointerenter"
+            },
+            {
+              "type": {
+                "text": "string"
+              },
+              "description": "Script to run when the pointer moves off the node.",
+              "name": "onpointerleave",
+              "fieldName": "onpointerleave"
+            },
+            {
+              "type": {
+                "text": "string"
+              },
+              "description": "Script to run when the pointer moves over the node.",
+              "name": "onpointermove",
+              "fieldName": "onpointermove"
+            },
+            {
+              "type": {
+                "text": "string"
+              },
+              "description": "Script to run when a pointer button is released over the node.",
+              "name": "onpointerup",
+              "fieldName": "onpointerup"
+            },
+            {
+              "name": "position",
+              "type": {
+                "text": "string"
+              },
+              "description": "Overrides the node's local position, as an \"x y z\" triple.",
+              "fieldName": "position"
+            },
+            {
+              "name": "rotation",
+              "type": {
+                "text": "string"
+              },
+              "description": "Overrides the node's local rotation (Euler angles), as an \"x y z\" triple.",
+              "fieldName": "rotation"
+            },
+            {
+              "name": "scale",
+              "type": {
+                "text": "string"
+              },
+              "description": "Overrides the node's local scale, as an \"x y z\" triple.",
+              "fieldName": "scale"
+            },
+            {
+              "name": "tags",
+              "type": {
+                "text": "string"
+              },
+              "description": "Overrides the node's tags, separated by spaces or commas.",
+              "fieldName": "tags"
+            }
+          ],
+          "superclass": {
+            "name": "EntityBaseElement",
+            "module": "/src/entity-base"
+          },
+          "tagName": "pc-node",
+          "customElement": true
+        }
+      ],
+      "exports": [
+        {
+          "kind": "custom-element-definition",
+          "name": "pc-node",
+          "declaration": {
+            "name": "NodeElement",
+            "module": "src/node.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "NodeElement",
+          "declaration": {
+            "name": "NodeElement",
+            "module": "src/node.ts"
+          }
+        }
+      ]
+    },
     {
       "kind": "javascript-module",
       "path": "src/scene.ts",
@@ -3773,9 +4721,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -4071,9 +5019,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -4356,9 +5304,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -4915,9 +5863,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -5496,7 +6444,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "The CollisionComponentElement interface provides properties and methods for manipulating\n[`<pc-collision>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-collision/) elements.\nThe CollisionComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n",
+          "description": "The CollisionComponentElement interface provides properties and methods for manipulating\n[`<pc-collision>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-collision/) elements.\nThe CollisionComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nFor `type=\"mesh\"`, the collision geometry defaults to the host entity's own render component\n(its render asset) — a collider matching the visible mesh, which is what a mesh collider on a\nglTF node means. The default resolves each time the component applies, so a `pc-node` that\nretargets or rebinds picks up the new node's geometry. An entity with no asset-backed render\ncomponent warns, and the collider has no shape.\n",
           "name": "CollisionComponentElement",
           "members": [
             {
@@ -5529,9 +6477,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -5773,9 +6721,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -5984,9 +6932,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -6736,9 +7684,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -7006,9 +7954,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -7348,9 +8296,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -7726,9 +8674,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -8338,9 +9286,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -8510,9 +9458,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -8710,9 +9658,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -8960,9 +9908,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -9215,9 +10163,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -9468,9 +10416,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -9621,9 +10569,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -9834,9 +10782,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -10102,9 +11050,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -10560,9 +11508,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""
@@ -10923,9 +11871,9 @@
               "kind": "field",
               "name": "closestEntity",
               "type": {
-                "text": "EntityElement | null"
+                "text": "EntityBaseElement | null"
               },
-              "description": "The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
               "return": {
                 "type": {
                   "text": ""