@playcanvas/web-components 0.15.0 → 0.17.0

package/dist/web-types.json

@@ -1,14 +1,14 @@
 {
   "$schema": "https://raw.githubusercontent.com/JetBrains/web-types/master/schema/web-types.json",
   "name": "@playcanvas/web-components",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "description-markup": "markdown",
   "contributions": {
     "html": {
       "elements": [
         {
           "name": "pc-app",
-          "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\n---\n\n\n### **Events:**\n - **error** - 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.\n- **progress** - Fired while the application preloads its assets. `loaded` and `total` are asset counts, not bytes, and an asset that fails to load still counts as loaded. Fired at least once per boot, and the final event always has `loaded` equal to `total`. Does not bubble.\n- **ready** - 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.\n\n### **Methods:**\n - **elementFromEntity(entity: _Entity_): __** - 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.\n- **ready(): __** - 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.",
+          "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\n---\n\n\n### **Events:**\n - **error** - 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.\n- **progress** - Fired while the application preloads its assets. `loaded` and `total` are asset counts, not bytes, and an asset that fails to load still counts as loaded. Fired at least once per boot, and the final event always has `loaded` equal to `total`. Does not bubble.\n- **ready** - 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.\n\n### **Methods:**\n - **elementFromEntity(entity: _Entity_): __** - Returns the `<pc-entity>`, `<pc-model>` or `<pc-node>` element whose backing entity is\n`entity`, or `null` if the entity is not fronted by an element of this application - for\nexample, an unbound node inside a model's instantiated hierarchy, or an entity created\nthrough the engine API.\n- **ready(): __** - 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.",
           "doc-url": "",
           "attributes": [
             {
@@ -93,7 +93,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
@@ -283,7 +283,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
@@ -437,7 +437,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
@@ -1293,13 +1293,68 @@
         },
         {
           "name": "pc-model",
-          "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\n---\n\n\n### **Events:**\n - **error** - 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.\n- **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.\n- **ready** - 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.\n\n### **Methods:**\n - **hierarchy(): __** - Returns a snapshot of the instantiated node tree, or `null` while there is none (the\ncontainer asset has not loaded, or the element has left the document). One call grounds a\nsession — a browser console, a test, an agent — in the vocabulary `pc-node` binding\nresolves against: the instantiated names (HierarchyNode.name), paths, match\nindices, attached component types and the material assignments of render components\n(HierarchyNode.materials). `String(...)` of the result, or of any node in it,\nis the printable form.\n\nThe snapshot is plain data, computed afresh each call: it does not follow later changes\nto the hierarchy, and mutating it changes nothing.\n- **ready(): __** - 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.",
+          "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 creates and fronts a stable host entity: `entity` is that host, created when the\napplication builds its hierarchy and kept across `asset` changes, so the element's transform\nand tags are instance placement that composes with whatever transform the asset authored on\nits root. The instantiated content is parented beneath the host and exposed as\ncontentEntity.\n\nThe element becomes ready once its current asset selection has settled: the container asset\nhas loaded and its content root has been parented beneath the host, the load has failed\n(`contentEntity` stays `null` — listen for `error`, or check `contentEntity`, to tell the\noutcomes apart), or no asset is assigned at all. Changing `asset` re-arms readiness and\ninstantiates anew, so a `ready()` obtained after the change resolves against the new content.\nA `pc-model` outside a `pc-app`, or referencing an unknown asset id, warns and never becomes\nready.\n\nThe pointer events below are dispatched by the containing `<pc-app>` element when the pointer\nintersects the model's geometry, exactly as for `<pc-entity>` — a hit on a content node that no\n`pc-node` fronts resolves to this element.\n\n---\n\n\n### **Events:**\n - **error** - 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.\n- **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.\n- **pointerdown** - Fired when a pointer button is pressed over the model.\n- **pointerenter** - Fired when the pointer moves onto the model.\n- **pointerleave** - Fired when the pointer moves off the model.\n- **pointermove** - Fired when the pointer moves over the model.\n- **pointerup** - Fired when a pointer button is released over the model.\n- **ready** - 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.\n\n### **Methods:**\n - **hierarchy(): __** - Returns a snapshot of the instantiated node tree, or `null` while there is none (the\ncontainer asset has not loaded, or the element has left the document). One call grounds a\nsession — a browser console, a test, an agent — in the vocabulary `pc-node` binding\nresolves against: the instantiated names (HierarchyNode.name), paths, match\nindices, attached component types and the material assignments of render components\n(HierarchyNode.materials). `String(...)` of the result, or of any node in it,\nis the printable form.\n\nThe snapshot is plain data, computed afresh each call: it does not follow later changes\nto the hierarchy, and mutating it changes nothing. It covers the instantiated content\nonly — the host entity the element fronts is not part of the asset's node tree.\n- **ready(): __** - 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.",
           "doc-url": "",
           "attributes": [
             {
               "name": "asset",
               "description": "The id of the `pc-asset` to use for the model.",
               "value": { "type": "string" }
+            },
+            {
+              "name": "enabled",
+              "description": "The enabled state of the model.",
+              "value": { "type": "boolean", "default": "true" }
+            },
+            {
+              "name": "name",
+              "description": "The name of the model.",
+              "value": { "type": "string" }
+            },
+            {
+              "name": "onpointerdown",
+              "description": "Script to run when a pointer button is pressed over the model.",
+              "value": { "type": "string" }
+            },
+            {
+              "name": "onpointerenter",
+              "description": "Script to run when the pointer moves onto the model.",
+              "value": { "type": "string" }
+            },
+            {
+              "name": "onpointerleave",
+              "description": "Script to run when the pointer moves off the model.",
+              "value": { "type": "string" }
+            },
+            {
+              "name": "onpointermove",
+              "description": "Script to run when the pointer moves over the model.",
+              "value": { "type": "string" }
+            },
+            {
+              "name": "onpointerup",
+              "description": "Script to run when a pointer button is released over the model.",
+              "value": { "type": "string" }
+            },
+            {
+              "name": "position",
+              "description": "The position of the model. Accepts 3 space-separated numbers.",
+              "value": { "type": "string", "default": "0 0 0" }
+            },
+            {
+              "name": "rotation",
+              "description": "The rotation of the model. Accepts 3 space-separated numbers.",
+              "value": { "type": "string", "default": "0 0 0" }
+            },
+            {
+              "name": "scale",
+              "description": "The scale of the model. Accepts 3 space-separated numbers.",
+              "value": { "type": "string", "default": "1 1 1" }
+            },
+            {
+              "name": "tags",
+              "description": "The tags of the model.",
+              "value": { "type": "string" }
             }
           ],
           "events": [
@@ -1313,6 +1368,31 @@
               "type": "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": "pointerdown",
+              "type": "PointerEvent",
+              "description": "Fired when a pointer button is pressed over the model."
+            },
+            {
+              "name": "pointerenter",
+              "type": "PointerEvent",
+              "description": "Fired when the pointer moves onto the model."
+            },
+            {
+              "name": "pointerleave",
+              "type": "PointerEvent",
+              "description": "Fired when the pointer moves off the model."
+            },
+            {
+              "name": "pointermove",
+              "type": "PointerEvent",
+              "description": "Fired when the pointer moves over the model."
+            },
+            {
+              "name": "pointerup",
+              "type": "PointerEvent",
+              "description": "Fired when a pointer button is released over the model."
+            },
             {
               "name": "ready",
               "type": "CustomEvent",
@@ -1333,14 +1413,37 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
+              {
+                "name": "contentEntity",
+                "description": "The root entity of the instantiated model content, parented beneath the host entity.\n`null` until the container asset has loaded and been instantiated, after a failed load,\nand again once the element has been removed from the document.",
+                "type": "Entity | null"
+              },
+              {
+                "name": "enabled",
+                "description": "Gets the enabled state of the entity."
+              },
               {
                 "name": "entity",
-                "description": "The root entity of the instantiated model. `null` until the container asset has loaded\nand been instantiated, and again once the element has been removed from the document.",
+                "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.",
                 "type": "Entity | null"
-              }
+              },
+              { "name": "name", "description": "Gets the name of the entity." },
+              {
+                "name": "position",
+                "description": "Gets the position of the entity."
+              },
+              {
+                "name": "rotation",
+                "description": "Gets the rotation of the entity."
+              },
+              {
+                "name": "scale",
+                "description": "Gets the scale of the entity."
+              },
+              { "name": "tags", "description": "Gets the tags of the entity." }
             ],
             "events": [
               {
@@ -1354,60 +1457,30 @@
                 "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": "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."
-              }
-            ]
-          }
-        },
-        {
-          "name": "pc-module",
-          "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\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
-          "doc-url": "",
-          "attributes": [
-            {
-              "name": "fallback",
-              "description": "The URL of the module's asm.js fallback script, used when WebAssembly is unavailable.",
-              "value": { "type": "string" }
-            },
-            {
-              "name": "glue",
-              "description": "The URL of the module's glue script.",
-              "value": { "type": "string" }
-            },
-            {
-              "name": "name",
-              "description": "The name of the WebAssembly module to configure, e.g. `Basis` or `Ammo`.",
-              "value": { "type": "string" }
-            },
-            {
-              "name": "wasm",
-              "description": "The URL of the module's WebAssembly binary.",
-              "value": { "type": "string" }
-            }
-          ],
-          "events": [
-            {
-              "name": "ready",
-              "type": "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."
-            }
-          ],
-          "js": {
-            "properties": [
+                "name": "pointerdown",
+                "type": "PointerEvent",
+                "description": "Fired when a pointer button is pressed over the model."
+              },
               {
-                "name": "closestApp",
-                "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.",
-                "type": "AppElement | null"
+                "name": "pointerenter",
+                "type": "PointerEvent",
+                "description": "Fired when the pointer moves onto the model."
               },
               {
-                "name": "closestEntity",
-                "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.",
-                "type": "EntityBaseElement | null"
-              }
-            ],
-            "events": [
+                "name": "pointerleave",
+                "type": "PointerEvent",
+                "description": "Fired when the pointer moves off the model."
+              },
+              {
+                "name": "pointermove",
+                "type": "PointerEvent",
+                "description": "Fired when the pointer moves over the model."
+              },
+              {
+                "name": "pointerup",
+                "type": "PointerEvent",
+                "description": "Fired when a pointer button is released over the model."
+              },
               {
                 "name": "ready",
                 "type": "CustomEvent",
@@ -1528,7 +1601,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
@@ -1676,7 +1749,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
@@ -1776,14 +1849,285 @@
           ],
           "js": {
             "properties": [
-              {
-                "name": "asset",
-                "description": "Gets the id of the `pc-asset` to use for the skybox."
-              },
-              {
-                "name": "center",
-                "description": "Gets the center of the skybox."
-              },
+              {
+                "name": "asset",
+                "description": "Gets the id of the `pc-asset` to use for the skybox."
+              },
+              {
+                "name": "center",
+                "description": "Gets the center of the skybox."
+              },
+              {
+                "name": "closestApp",
+                "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.",
+                "type": "AppElement | null"
+              },
+              {
+                "name": "closestEntity",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
+                "type": "EntityBaseElement | null"
+              },
+              {
+                "name": "intensity",
+                "description": "Gets the intensity of the skybox."
+              },
+              {
+                "name": "lighting",
+                "description": "Gets whether the skybox is used as a light source."
+              },
+              {
+                "name": "mipLevel",
+                "description": "Gets the mip level of the skybox."
+              },
+              {
+                "name": "rotation",
+                "description": "Gets the Euler rotation of the skybox."
+              },
+              {
+                "name": "scale",
+                "description": "Gets the scale of the skybox."
+              },
+              { "name": "type", "description": "Gets the type of the skybox." }
+            ],
+            "events": [
+              {
+                "name": "ready",
+                "type": "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."
+              }
+            ]
+          }
+        },
+        {
+          "name": "pc-wasm",
+          "description": "The WasmElement interface provides properties and methods for manipulating\n[`<pc-wasm>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-wasm/)\nelements. The WasmElement 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-wasm>` without a `name` warns and never becomes ready; a containing `<pc-app>` still\nboots.\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
+          "doc-url": "",
+          "attributes": [
+            {
+              "name": "fallback",
+              "description": "The URL of the module's asm.js fallback script, used when WebAssembly is unavailable.",
+              "value": { "type": "string" }
+            },
+            {
+              "name": "glue",
+              "description": "The URL of the module's glue script.",
+              "value": { "type": "string" }
+            },
+            {
+              "name": "name",
+              "description": "The name of the WebAssembly module to configure, e.g. `Basis` or `Ammo`.",
+              "value": { "type": "string" }
+            },
+            {
+              "name": "wasm",
+              "description": "The URL of the module's WebAssembly binary.",
+              "value": { "type": "string" }
+            }
+          ],
+          "events": [
+            {
+              "name": "ready",
+              "type": "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."
+            }
+          ],
+          "js": {
+            "properties": [
+              {
+                "name": "closestApp",
+                "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.",
+                "type": "AppElement | null"
+              },
+              {
+                "name": "closestEntity",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
+                "type": "EntityBaseElement | null"
+              }
+            ],
+            "events": [
+              {
+                "name": "ready",
+                "type": "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."
+              }
+            ]
+          }
+        },
+        {
+          "name": "pc-anim-clip",
+          "description": "The AnimClipElement interface provides properties and methods for manipulating\n[`<pc-anim-clip>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-anim-clip/)\nelements. The AnimClipElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nA clip declares one named animation on its parent `<pc-anim>`. `name` is both the clip's name\nand the track looked up in the clip's source: an explicit `asset` (a `container`, an\n`animation` `.glb`, or an `animclip` JSON), or, without one, the container of the `<pc-model>`\nenclosing the parent `<pc-anim>`. A source holding a single track supplies it whatever it is\nnamed; in a multi-track source the track named `name` is chosen, falling back to the first\nwith a warning. The element becomes ready once its resolved track is assigned.\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
+          "doc-url": "",
+          "attributes": [
+            {
+              "name": "asset",
+              "description": "The id of the `pc-asset` supplying the clip's track.",
+              "value": { "type": "string" }
+            },
+            {
+              "name": "loop",
+              "description": "Whether the clip loops.",
+              "value": { "type": "boolean", "default": "true" }
+            },
+            {
+              "name": "name",
+              "description": "The name of the clip.",
+              "value": { "type": "string" }
+            },
+            {
+              "name": "speed",
+              "description": "The playback speed of the clip.",
+              "value": { "type": "number", "default": "1" }
+            }
+          ],
+          "events": [
+            {
+              "name": "ready",
+              "type": "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."
+            }
+          ],
+          "js": {
+            "properties": [
+              {
+                "name": "asset",
+                "description": "Gets the id of the `pc-asset` supplying the clip's track."
+              },
+              {
+                "name": "closestApp",
+                "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.",
+                "type": "AppElement | null"
+              },
+              {
+                "name": "closestEntity",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
+                "type": "EntityBaseElement | null"
+              },
+              { "name": "loop", "description": "Gets whether the clip loops." },
+              { "name": "name", "description": "Gets the name of the clip." },
+              {
+                "name": "speed",
+                "description": "Gets the playback speed of the clip."
+              }
+            ],
+            "events": [
+              {
+                "name": "ready",
+                "type": "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."
+              }
+            ]
+          }
+        },
+        {
+          "name": "pc-anim",
+          "description": "The AnimComponentElement interface provides properties and methods for manipulating\n[`<pc-anim>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-anim/) elements.\nThe AnimComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nThe element drives animation clips over the host entity's hierarchy. Clips come from\n`<pc-anim-clip>` children — or, when the element is a direct child of a `<pc-model>` and\ndeclares no clips, every animation of that model's container asset is assigned, named by track\nname, in container order. The first clip plays automatically (opt out with `activate=\"false\"`);\nswitch clips declaratively through the `clip` attribute, or imperatively through play\nand transition. Tracks bind to scene nodes by name, so any hierarchy whose node names\nmatch a clip's curves can be animated — a model's skeleton is simply the common case.\n\nThe engine reports no clip completion: a non-looping clip holds its last pose silently. Poll\nthe underlying AnimComponent (via component) for playback state beyond what\nthis element exposes.\n\nEngine component: AnimComponent (`anim`).\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **pause()** - Pauses playback, preserving the playhead — play resumes from where it stopped.\n- **play(name: _string_)** - Resumes playback, optionally switching to a named clip first (a hard cut). A name that\nmatches no clip leaves the selection unchanged.\n- **ready(): __** - 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.\n- **transition(name: _string_, time: _number_)** - Cross-fades to a named clip and ensures playback is running. A name that matches no clip\nleaves the selection unchanged.",
+          "doc-url": "",
+          "attributes": [
+            {
+              "name": "activate",
+              "description": "Whether playback starts automatically once a clip is assigned.",
+              "value": { "type": "boolean", "default": "true" }
+            },
+            {
+              "name": "clip",
+              "description": "The name of the active clip.",
+              "value": { "type": "string" }
+            },
+            {
+              "name": "enabled",
+              "description": "The enabled state of the component.",
+              "value": { "type": "boolean", "default": "true" }
+            },
+            {
+              "name": "speed",
+              "description": "The playback speed multiplier applied across all clips.",
+              "value": { "type": "number", "default": "1" }
+            },
+            {
+              "name": "transition-time",
+              "description": "The cross-fade duration of clip switches made through the `clip` attribute.",
+              "value": { "type": "number", "default": "0" }
+            }
+          ],
+          "events": [
+            {
+              "name": "ready",
+              "type": "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."
+            }
+          ],
+          "js": {
+            "properties": [
+              {
+                "name": "activate",
+                "description": "Gets whether playback starts automatically once a clip is assigned."
+              },
+              {
+                "name": "clip",
+                "description": "Gets the name of the active clip."
+              },
+              {
+                "name": "clips",
+                "description": "Gets the names of the assigned clips.",
+                "type": "string[]"
+              },
+              {
+                "name": "closestApp",
+                "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.",
+                "type": "AppElement | null"
+              },
+              {
+                "name": "closestEntity",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
+                "type": "EntityBaseElement | null"
+              },
+              {
+                "name": "component",
+                "description": "Gets the underlying PlayCanvas anim component.",
+                "type": "Component | null"
+              },
+              {
+                "name": "enabled",
+                "description": "Gets the enabled state of the component."
+              },
+              {
+                "name": "speed",
+                "description": "Gets the playback speed multiplier applied across all clips."
+              },
+              {
+                "name": "transitionTime",
+                "description": "Gets the cross-fade duration of clip switches made through the `clip` attribute."
+              }
+            ],
+            "events": [
+              {
+                "name": "ready",
+                "type": "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."
+              }
+            ]
+          }
+        },
+        {
+          "name": "pc-audio-listener",
+          "description": "The AudioListenerComponentElement interface provides properties and methods for manipulating\n[`<pc-audio-listener>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-audio-listener/) elements.\nThe AudioListenerComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nEngine component: AudioListenerComponent (`audiolistener`).\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
+          "doc-url": "",
+          "attributes": [
+            {
+              "name": "enabled",
+              "description": "The enabled state of the component.",
+              "value": { "type": "boolean", "default": "true" }
+            }
+          ],
+          "events": [
+            {
+              "name": "ready",
+              "type": "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."
+            }
+          ],
+          "js": {
+            "properties": [
               {
                 "name": "closestApp",
                 "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.",
@@ -1791,30 +2135,18 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
-                "name": "intensity",
-                "description": "Gets the intensity of the skybox."
-              },
-              {
-                "name": "lighting",
-                "description": "Gets whether the skybox is used as a light source."
-              },
-              {
-                "name": "mipLevel",
-                "description": "Gets the mip level of the skybox."
-              },
-              {
-                "name": "rotation",
-                "description": "Gets the Euler rotation of the skybox."
+                "name": "component",
+                "description": "Gets the underlying PlayCanvas audio listener component.",
+                "type": "Component | null"
               },
               {
-                "name": "scale",
-                "description": "Gets the scale of the skybox."
-              },
-              { "name": "type", "description": "Gets the type of the skybox." }
+                "name": "enabled",
+                "description": "Gets the enabled state of the component."
+              }
             ],
             "events": [
               {
@@ -1827,7 +2159,7 @@
         },
         {
           "name": "pc-button",
-          "description": "The ButtonComponentElement interface provides properties and methods for manipulating\n[`<pc-button>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-button/) elements.\nThe ButtonComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
+          "description": "The ButtonComponentElement interface provides properties and methods for manipulating\n[`<pc-button>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-button/) elements.\nThe ButtonComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nEngine component: ButtonComponent (`button`).\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
           "doc-url": "",
           "attributes": [
             {
@@ -1926,7 +2258,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
@@ -2002,7 +2334,7 @@
         },
         {
           "name": "pc-camera",
-          "description": "The CameraComponentElement interface provides properties and methods for manipulating\n[`<pc-camera>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-camera/) elements.\nThe CameraComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **endXr()** - Ends the camera's XR mode.\n- **ready(): __** - 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.\n- **startXr(type: _'immersive-ar' | 'immersive-vr'_, space: _'bounded-floor' | 'local' | 'local-floor' | 'unbounded' | 'viewer'_)** - Starts the camera in XR mode.",
+          "description": "The CameraComponentElement interface provides properties and methods for manipulating\n[`<pc-camera>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-camera/) elements.\nThe CameraComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nEngine component: CameraComponent (`camera`).\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **endXr()** - Ends the camera's XR mode.\n- **ready(): __** - 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.\n- **startXr(type: _'immersive-ar' | 'immersive-vr'_, space: _'bounded-floor' | 'local' | 'local-floor' | 'unbounded' | 'viewer'_)** - Starts the camera in XR mode.",
           "doc-url": "",
           "attributes": [
             {
@@ -2143,7 +2475,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
@@ -2236,7 +2568,7 @@
         },
         {
           "name": "pc-collision",
-          "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\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
+          "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\nEngine component: CollisionComponent (`collision`).\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
           "doc-url": "",
           "attributes": [
             {
@@ -2295,7 +2627,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
@@ -2325,7 +2657,7 @@
         },
         {
           "name": "pc-element",
-          "description": "The ElementComponentElement interface provides properties and methods for manipulating\n[`<pc-element>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-element/) elements.\nThe ElementComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
+          "description": "The ElementComponentElement interface provides properties and methods for manipulating\n[`<pc-element>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-element/) elements.\nThe ElementComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nDespite the name, this is not a base class or a generic wrapper: it is the engine's 2D UI\ncomponent, which gives its host entity a rectangle in a `<pc-screen>` hierarchy that draws\neither an image, a line of text or nothing (`type=\"image\"`, `\"text\"` or `\"group\"`). The tag\nspells the engine component it adds, as every component element does.\n\nEngine component: ElementComponent (`element`).\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
           "doc-url": "",
           "attributes": [
             {
@@ -2503,7 +2835,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
@@ -2612,7 +2944,7 @@
         },
         {
           "name": "pc-gsplat",
-          "description": "The GSplatComponentElement interface provides properties and methods for manipulating\n[`<pc-gsplat>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-gsplat/) elements.\nThe GSplatComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
+          "description": "The GSplatComponentElement interface provides properties and methods for manipulating\n[`<pc-gsplat>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-gsplat/) elements.\nThe GSplatComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nEngine component: GSplatComponent (`gsplat`).\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
           "doc-url": "",
           "attributes": [
             {
@@ -2675,7 +3007,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
@@ -2715,7 +3047,7 @@
         },
         {
           "name": "pc-joint",
-          "description": "The JointComponentElement interface provides properties and methods for manipulating\n[`<pc-joint>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-joint/) elements.\nThe JointComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nThe entity holding the joint is not itself constrained. Its world transform defines the joint\nframe — the anchor point and axes the constraint operates about — with the local X axis as the\nprimary axis: a hinge rotates about it, a slider translates along it and a ball joint twists\nabout it. The constrained bodies are referenced by `entity-a` and `entity-b`, both of which need\na rigid body component; leaving `entity-b` empty constrains `entity-a` to a fixed point in world\nspace. The underlying engine component is in alpha, so its API may change.\n\n---\n\n\n### **Events:**\n - **break** - Fired when the impulse on the joint exceeds `break-impulse` and the constraint breaks. A broken joint no longer constrains its bodies; calling `refreshFrames()` on the underlying component re-attaches it. Bubbles and is composed.\n- **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
+          "description": "The JointComponentElement interface provides properties and methods for manipulating\n[`<pc-joint>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-joint/) elements.\nThe JointComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nThe entity holding the joint is not itself constrained. Its world transform defines the joint\nframe — the anchor point and axes the constraint operates about — with the local X axis as the\nprimary axis: a hinge rotates about it, a slider translates along it and a ball joint twists\nabout it. The constrained bodies are referenced by `entity-a` and `entity-b`, both of which need\na rigid body component; leaving `entity-b` empty constrains `entity-a` to a fixed point in world\nspace. The underlying engine component is in alpha, so its API may change.\n\n---\n\n\n### **Events:**\n - **break** - Fired when the impulse on the joint exceeds `break-impulse` and the 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: `JointComponent` (`joint`).\n- **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
           "doc-url": "",
           "attributes": [
             {
@@ -2899,7 +3231,7 @@
             {
               "name": "break",
               "type": "CustomEvent",
-              "description": "Fired when the impulse on the joint exceeds `break-impulse` and the constraint breaks. A broken joint no longer constrains its bodies; calling `refreshFrames()` on the underlying component re-attaches it. Bubbles and is composed."
+              "description": "Fired when the impulse on the joint exceeds `break-impulse` and the 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: `JointComponent` (`joint`)."
             },
             {
               "name": "ready",
@@ -2956,7 +3288,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
@@ -3050,7 +3382,7 @@
               {
                 "name": "break",
                 "type": "CustomEvent",
-                "description": "Fired when the impulse on the joint exceeds `break-impulse` and the constraint breaks. A broken joint no longer constrains its bodies; calling `refreshFrames()` on the underlying component re-attaches it. Bubbles and is composed."
+                "description": "Fired when the impulse on the joint exceeds `break-impulse` and the 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: `JointComponent` (`joint`)."
               },
               {
                 "name": "ready",
@@ -3061,8 +3393,8 @@
           }
         },
         {
-          "name": "pc-layoutchild",
-          "description": "The LayoutChildComponentElement interface provides properties and methods for manipulating\n[`<pc-layoutchild>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-layoutchild/) elements.\nThe LayoutChildComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
+          "name": "pc-layout-child",
+          "description": "The LayoutChildComponentElement interface provides properties and methods for manipulating\n[`<pc-layout-child>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-layout-child/) elements.\nThe LayoutChildComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nEngine component: LayoutChildComponent (`layoutchild`).\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
           "doc-url": "",
           "attributes": [
             {
@@ -3122,7 +3454,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
@@ -3173,8 +3505,8 @@
           }
         },
         {
-          "name": "pc-layoutgroup",
-          "description": "The LayoutGroupComponentElement interface provides properties and methods for manipulating\n[`<pc-layoutgroup>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-layoutgroup/) elements.\nThe LayoutGroupComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
+          "name": "pc-layout-group",
+          "description": "The LayoutGroupComponentElement interface provides properties and methods for manipulating\n[`<pc-layout-group>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-layout-group/) elements.\nThe LayoutGroupComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nEngine component: LayoutGroupComponent (`layoutgroup`).\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
           "doc-url": "",
           "attributes": [
             {
@@ -3257,7 +3589,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
@@ -3313,7 +3645,7 @@
         },
         {
           "name": "pc-light",
-          "description": "The LightComponentElement interface provides properties and methods for manipulating\n[`<pc-light>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-light/) elements.\nThe LightComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
+          "description": "The LightComponentElement interface provides properties and methods for manipulating\n[`<pc-light>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-light/) elements.\nThe LightComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nEngine component: LightComponent (`light`).\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
           "doc-url": "",
           "attributes": [
             {
@@ -3443,7 +3775,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
@@ -3535,57 +3867,8 @@
           }
         },
         {
-          "name": "pc-listener",
-          "description": "The ListenerComponentElement interface provides properties and methods for manipulating\n[`<pc-listener>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-listener/) elements.\nThe ListenerComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
-          "doc-url": "",
-          "attributes": [
-            {
-              "name": "enabled",
-              "description": "The enabled state of the component.",
-              "value": { "type": "boolean", "default": "true" }
-            }
-          ],
-          "events": [
-            {
-              "name": "ready",
-              "type": "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."
-            }
-          ],
-          "js": {
-            "properties": [
-              {
-                "name": "closestApp",
-                "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.",
-                "type": "AppElement | null"
-              },
-              {
-                "name": "closestEntity",
-                "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.",
-                "type": "EntityBaseElement | null"
-              },
-              {
-                "name": "component",
-                "description": "Gets the underlying PlayCanvas audio listener component.",
-                "type": "Component | null"
-              },
-              {
-                "name": "enabled",
-                "description": "Gets the enabled state of the component."
-              }
-            ],
-            "events": [
-              {
-                "name": "ready",
-                "type": "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."
-              }
-            ]
-          }
-        },
-        {
-          "name": "pc-particles",
-          "description": "The ParticleSystemComponentElement interface provides properties and methods for manipulating\n[`<pc-particles>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-particles/) elements.\nThe ParticleSystemComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **pause()** - Pauses the particle system\n- **play()** - Starts playing the particle system\n- **ready(): __** - 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.\n- **reset()** - Resets the particle system\n- **stop()** - Stops the particle system",
+          "name": "pc-particle-system",
+          "description": "The ParticleSystemComponentElement interface provides properties and methods for manipulating\n[`<pc-particle-system>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-particle-system/) elements.\nThe ParticleSystemComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nEngine component: ParticleSystemComponent (`particlesystem`).\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **pause()** - Pauses the particle system\n- **play()** - Starts playing the particle system\n- **ready(): __** - 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.\n- **reset()** - Resets the particle system\n- **stop()** - Stops the particle system",
           "doc-url": "",
           "attributes": [
             {
@@ -3620,7 +3903,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
@@ -3644,7 +3927,7 @@
         },
         {
           "name": "pc-render",
-          "description": "The RenderComponentElement interface provides properties and methods for manipulating\n[`<pc-render>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-render/) elements.\nThe RenderComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nThis element renders one of the engine's built-in primitives, selected with `type` (defaulting\nto `box`). It does not cover the engine's `asset` render type, since there is no way to supply\na render asset here — use `pc-model` for glTF content instead.\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
+          "description": "The RenderComponentElement interface provides properties and methods for manipulating\n[`<pc-render>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-render/) elements.\nThe RenderComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nThis element renders one of the engine's built-in primitives, selected with `type` (defaulting\nto `box`). It does not cover the engine's `asset` render type, since there is no way to supply\na render asset here — use `pc-model` for glTF content instead.\n\nEngine component: RenderComponent (`render`).\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
           "doc-url": "",
           "attributes": [
             {
@@ -3697,7 +3980,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
@@ -3734,8 +4017,8 @@
           }
         },
         {
-          "name": "pc-rigidbody",
-          "description": "The RigidBodyComponentElement interface provides properties and methods for manipulating\n[`<pc-rigidbody>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-rigidbody/) elements.\nThe RigidBodyComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
+          "name": "pc-rigid-body",
+          "description": "The RigidBodyComponentElement interface provides properties and methods for manipulating\n[`<pc-rigid-body>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-rigid-body/) elements.\nThe RigidBodyComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nEngine component: RigidBodyComponent (`rigidbody`).\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
           "doc-url": "",
           "attributes": [
             {
@@ -3800,7 +4083,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
@@ -3831,7 +4114,7 @@
         },
         {
           "name": "pc-screen",
-          "description": "The ScreenComponentElement interface provides properties and methods for manipulating\n[`<pc-screen>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-screen/) elements.\nThe ScreenComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
+          "description": "The ScreenComponentElement interface provides properties and methods for manipulating\n[`<pc-screen>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-screen/) elements.\nThe ScreenComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nEngine component: ScreenComponent (`screen`).\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
           "doc-url": "",
           "attributes": [
             {
@@ -3884,7 +4167,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
@@ -3919,8 +4202,8 @@
           }
         },
         {
-          "name": "pc-scripts",
-          "description": "The ScriptComponentElement interface provides properties and methods for manipulating\n[`<pc-scripts>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-scripts/) elements.\nThe ScriptComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
+          "name": "pc-script",
+          "description": "The ScriptComponentElement interface provides properties and methods for manipulating\n[`<pc-script>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-script/) elements.\nThe ScriptComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nEngine component: ScriptComponent (`script`).\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
           "doc-url": "",
           "attributes": [
             {
@@ -3945,7 +4228,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
@@ -3968,8 +4251,8 @@
           }
         },
         {
-          "name": "pc-script",
-          "description": "The ScriptElement interface provides properties and methods for manipulating\n`<pc-script>` elements. The ScriptElement interface also inherits the properties and\nmethods of the AsyncElement interface.\n\nScript attributes can be supplied through two channels:\n\n- **Per-property attributes**: any non-reserved attribute on the element maps to the script\n  attribute of the same name (kebab-case to camelCase, e.g. `focus-point` → `focusPoint`).\n  Values are parsed according to the type of the attribute's current value — initially the\n  script's declared default (numbers, booleans, strings, Vec2/3/4, Color, Quat as Euler\n  angles) — and the `asset:`/`entity:`/`vec2:`/`vec3:`/`vec4:`/`color:` prefixes may be used\n  to be explicit.\n- **The `attributes` JSON attribute**: an object supporting nested structures and attribute\n  names that collide with reserved HTML attribute names (e.g. `title`).\n\nWhen both specify the same attribute, the per-property attribute wins — at creation and\nwhenever either channel changes at runtime. The element's own `name` and `enabled`\nattributes configure the element itself and are not script attributes.\n\nChanging `name` on a live element destroys the old-name script instance and creates the\nnew-name one, re-applying both attribute channels to it.\n\nThe element becomes ready once its script instance has been created by the parent\n`<pc-scripts>` element.\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n- **scriptattributeschange** - Fired when the script's attributes change. The `detail` carries the new `attributes` object. Bubbles.\n- **scriptenablechange** - Fired when the script's enabled state changes. The `detail` carries the new `enabled` state. Bubbles.\n- **scriptnamechange** - Fired when the script is renamed on a live element. The `detail` carries `oldName` and `newName`. Bubbles.\n\n### **Methods:**\n - **ready(): __** - 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.",
+          "name": "pc-script-instance",
+          "description": "The ScriptInstanceElement interface provides properties and methods for manipulating\n`<pc-script-instance>` elements. The ScriptInstanceElement interface also inherits the properties and\nmethods of the AsyncElement interface.\n\nScript attributes can be supplied through two channels:\n\n- **Per-property attributes**: any non-reserved attribute on the element maps to the script\n  attribute of the same name (kebab-case to camelCase, e.g. `focus-point` → `focusPoint`).\n  Values are parsed according to the type of the attribute's current value — initially the\n  script's declared default (numbers, booleans, strings, Vec2/3/4, Color, Quat as Euler\n  angles) — and the `asset:`/`entity:`/`vec2:`/`vec3:`/`vec4:`/`color:` prefixes may be used\n  to be explicit.\n- **The `attributes` JSON attribute**: an object supporting nested structures and attribute\n  names that collide with reserved HTML attribute names (e.g. `title`).\n\nWhen both specify the same attribute, the per-property attribute wins — at creation and\nwhenever either channel changes at runtime. The element's own `name` and `enabled`\nattributes configure the element itself and are not script attributes.\n\nChanging `name` on a live element destroys the old-name script instance and creates the\nnew-name one, re-applying both attribute channels to it.\n\nThe element becomes ready once its script instance has been created by the parent\n`<pc-script>` element.\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n- **scriptattributeschange** - Fired when the script's attributes change. The `detail` carries the new `attributes` object. Bubbles.\n- **scriptenablechange** - Fired when the script's enabled state changes. The `detail` carries the new `enabled` state. Bubbles.\n- **scriptnamechange** - Fired when the script is renamed on a live element. The `detail` carries `oldName` and `newName`. Bubbles.\n\n### **Methods:**\n - **ready(): __** - 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.",
           "doc-url": "",
           "attributes": [
             {
@@ -4019,7 +4302,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
@@ -4063,96 +4346,8 @@
           }
         },
         {
-          "name": "pc-scrollbar",
-          "description": "The ScrollbarComponentElement interface provides properties and methods for manipulating\n[`<pc-scrollbar>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-scrollbar/) elements.\nThe ScrollbarComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
-          "doc-url": "",
-          "attributes": [
-            {
-              "name": "enabled",
-              "description": "The enabled state of the component.",
-              "value": { "type": "boolean", "default": "true" }
-            },
-            {
-              "name": "handle",
-              "description": "The reference to the `<pc-entity>` used as the scrollbar handle.",
-              "value": { "type": "string" }
-            },
-            {
-              "name": "handle-size",
-              "description": "The size of the handle relative to the size of the track.",
-              "value": { "type": "number", "default": "0.5" }
-            },
-            {
-              "name": "orientation",
-              "description": "The orientation of the scrollbar.",
-              "value": {
-                "type": "'horizontal' | 'vertical'",
-                "default": "horizontal"
-              }
-            },
-            {
-              "name": "value",
-              "description": "The current position value of the scrollbar.",
-              "value": { "type": "number", "default": "0" }
-            }
-          ],
-          "events": [
-            {
-              "name": "ready",
-              "type": "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."
-            }
-          ],
-          "js": {
-            "properties": [
-              {
-                "name": "closestApp",
-                "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.",
-                "type": "AppElement | null"
-              },
-              {
-                "name": "closestEntity",
-                "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.",
-                "type": "EntityBaseElement | null"
-              },
-              {
-                "name": "component",
-                "description": "Gets the underlying PlayCanvas scrollbar component.",
-                "type": "Component | null"
-              },
-              {
-                "name": "enabled",
-                "description": "Gets the enabled state of the component."
-              },
-              {
-                "name": "handle",
-                "description": "Gets the reference to the `<pc-entity>` used as the scrollbar handle."
-              },
-              {
-                "name": "handleSize",
-                "description": "Gets the size of the handle relative to the size of the track."
-              },
-              {
-                "name": "orientation",
-                "description": "Gets the orientation of the scrollbar."
-              },
-              {
-                "name": "value",
-                "description": "Gets the current position value of the scrollbar."
-              }
-            ],
-            "events": [
-              {
-                "name": "ready",
-                "type": "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."
-              }
-            ]
-          }
-        },
-        {
-          "name": "pc-scrollview",
-          "description": "The ScrollViewComponentElement interface provides properties and methods for manipulating\n[`<pc-scrollview>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-scrollview/) elements.\nThe ScrollViewComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
+          "name": "pc-scroll-view",
+          "description": "The ScrollViewComponentElement interface provides properties and methods for manipulating\n[`<pc-scroll-view>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-scroll-view/) elements.\nThe ScrollViewComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nEngine component: ScrollViewComponent (`scrollview`).\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
           "doc-url": "",
           "attributes": [
             {
@@ -4255,7 +4450,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
@@ -4323,8 +4518,96 @@
           }
         },
         {
-          "name": "pc-sounds",
-          "description": "The SoundComponentElement interface provides properties and methods for manipulating\n[`<pc-sounds>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-sounds/) elements.\nThe SoundComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
+          "name": "pc-scrollbar",
+          "description": "The ScrollbarComponentElement interface provides properties and methods for manipulating\n[`<pc-scrollbar>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-scrollbar/) elements.\nThe ScrollbarComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nEngine component: ScrollbarComponent (`scrollbar`).\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
+          "doc-url": "",
+          "attributes": [
+            {
+              "name": "enabled",
+              "description": "The enabled state of the component.",
+              "value": { "type": "boolean", "default": "true" }
+            },
+            {
+              "name": "handle",
+              "description": "The reference to the `<pc-entity>` used as the scrollbar handle.",
+              "value": { "type": "string" }
+            },
+            {
+              "name": "handle-size",
+              "description": "The size of the handle relative to the size of the track.",
+              "value": { "type": "number", "default": "0.5" }
+            },
+            {
+              "name": "orientation",
+              "description": "The orientation of the scrollbar.",
+              "value": {
+                "type": "'horizontal' | 'vertical'",
+                "default": "horizontal"
+              }
+            },
+            {
+              "name": "value",
+              "description": "The current position value of the scrollbar.",
+              "value": { "type": "number", "default": "0" }
+            }
+          ],
+          "events": [
+            {
+              "name": "ready",
+              "type": "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."
+            }
+          ],
+          "js": {
+            "properties": [
+              {
+                "name": "closestApp",
+                "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.",
+                "type": "AppElement | null"
+              },
+              {
+                "name": "closestEntity",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
+                "type": "EntityBaseElement | null"
+              },
+              {
+                "name": "component",
+                "description": "Gets the underlying PlayCanvas scrollbar component.",
+                "type": "Component | null"
+              },
+              {
+                "name": "enabled",
+                "description": "Gets the enabled state of the component."
+              },
+              {
+                "name": "handle",
+                "description": "Gets the reference to the `<pc-entity>` used as the scrollbar handle."
+              },
+              {
+                "name": "handleSize",
+                "description": "Gets the size of the handle relative to the size of the track."
+              },
+              {
+                "name": "orientation",
+                "description": "Gets the orientation of the scrollbar."
+              },
+              {
+                "name": "value",
+                "description": "Gets the current position value of the scrollbar."
+              }
+            ],
+            "events": [
+              {
+                "name": "ready",
+                "type": "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."
+              }
+            ]
+          }
+        },
+        {
+          "name": "pc-sound",
+          "description": "The SoundComponentElement interface provides properties and methods for manipulating\n[`<pc-sound>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-sound/) elements.\nThe SoundComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nEngine component: SoundComponent (`sound`).\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
           "doc-url": "",
           "attributes": [
             {
@@ -4387,7 +4670,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {
@@ -4439,8 +4722,8 @@
           }
         },
         {
-          "name": "pc-sound",
-          "description": "The SoundSlotElement interface provides properties and methods for manipulating\n`<pc-sound>` elements. The SoundSlotElement interface also inherits the properties and\nmethods of the AsyncElement interface.\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
+          "name": "pc-sound-slot",
+          "description": "The SoundSlotElement interface provides properties and methods for manipulating\n`<pc-sound-slot>` elements. The SoundSlotElement interface also inherits the properties and\nmethods of the AsyncElement interface.\n\n---\n\n\n### **Events:**\n - **ready** - 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.\n\n### **Methods:**\n - **ready(): __** - 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.",
           "doc-url": "",
           "attributes": [
             {
@@ -4513,7 +4796,7 @@
               },
               {
                 "name": "closestEntity",
-                "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.",
+                "description": "The nearest ancestor element that fronts an entity — `<pc-entity>`, `<pc-model>` or\n`<pc-node>` — or `null` if this element has no such ancestor. The search starts at the\nparent, so an element never resolves to itself.",
                 "type": "EntityBaseElement | null"
               },
               {