@playcanvas/web-components 0.17.0 → 0.18.0

package/dist/vscode.html-custom-data.json

@@ -4,7 +4,7 @@
   "tags": [
     {
       "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>`, `<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.",
+      "description": "The `<pc-app>` element creates a PlayCanvas application and the canvas it renders\ninto, and is the root of every scene. It holds the `<pc-asset>`, `<pc-material>`, `<pc-wasm>` and\n`<pc-scene>` elements, and the page's CSS sizes it, as it would a `<video>`.\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.",
       "attributes": [
         {
           "name": "alpha",
@@ -46,11 +46,16 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-app/"
+        }
+      ]
     },
     {
       "name": "pc-asset",
-      "description": "The AssetElement interface provides properties and methods for manipulating\n[`<pc-asset>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-asset/) elements.\nThe AssetElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nThe element becomes ready once the containing application has started and the asset is in the\nstate declared by the markup: loaded for preloaded assets (even if loading failed — check the\nasset's `resource`), or registered and awaiting a load for `lazy` assets. Elements inserted\nwhile the application is running are created and registered on insertion, and begin loading\nimmediately unless `lazy`. A `pc-asset` must be a direct child of `pc-app` — elements placed\nelsewhere, or with an unsupported asset type, never become ready.\n\nA `lazy` asset loads on first use: the first time any element resolves it by `id` — a model,\na material map, a sky, a script `asset:` reference — or when the `lazy` attribute is removed,\nwhichever comes first. Until then it stays registered and unloaded.\n\nFor `texture` and `textureatlas` assets, the texture options (`address-u`, `address-v`,\n`min-filter`, `mag-filter`, `anisotropy`, `mipmaps`, `srgb`, `flip-y`) apply when the texture is\ncreated and — like `lazy` — are observed: changing one updates a texture that has already\nloaded, and removing one restores the engine default. Changing `srgb` or `mipmaps` on a loaded\ntexture recreates the underlying GPU resource, so prefer declaring those up front. Each option\noverrides the matching key in the `data` JSON; options left unset write nothing, leaving the\nengine's per-format defaults in force.\n\nApart from `lazy` and the texture options, these attributes are read once when the asset is\ncreated, so changing them later has no effect.\n\n---\n\n\n### **Events:**\n - **error** - Fired when the 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 the asset finishes loading, including a `lazy` asset loaded later and any subsequent reloads. Does not bubble — listen on this element, or use a capture-phase listener on an ancestor to observe every asset.\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 - **get(id: _string_): __** - Returns the Asset created by the `<pc-asset>` element with the given `id`, or\n`undefined` if there is no such element or its asset has not been created yet.\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 `<pc-asset>` element declares an asset for the application to load — a model,\ntexture, font, sound, script or JSON file — under an `id` that other elements reference. Must be\na direct child of `<pc-app>`.\n\n---\n\n\n### **Events:**\n - **error** - Fired when the 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 the asset finishes loading, including a `lazy` asset loaded later and any subsequent reloads. Does not bubble — listen on this element, or use a capture-phase listener on an ancestor to observe every asset.\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.",
       "attributes": [
         {
           "name": "address-u",
@@ -157,11 +162,16 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-asset/"
+        }
+      ]
     },
     {
       "name": "pc-entity",
-      "description": "The EntityElement interface provides properties and methods for manipulating\n[`<pc-entity>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-entity/) elements.\nThe EntityElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nThe pointer events below are dispatched by the containing `<pc-app>` element when the pointer\nintersects this entity's geometry. They are only generated while the entity has a listener for\nthem, registered either with addEventListener or with the matching inline `onpointer*`\nattribute.\n\n---\n\n\n### **Events:**\n - **pointerdown** - Fired when a pointer button is pressed over the entity.\n- **pointerenter** - Fired when the pointer moves onto the entity.\n- **pointerleave** - Fired when the pointer moves off the entity.\n- **pointermove** - Fired when the pointer moves over the entity.\n- **pointerup** - Fired when a pointer button is released over the entity.\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 `<pc-entity>` element creates an entity: a named, transformable node of the\nscene hierarchy, and the host for component elements such as `<pc-camera>`, `<pc-light>` and\n`<pc-render>`. Place it in the `<pc-scene>`, or nest it under another `<pc-entity>`, a\n`<pc-model>` or a `<pc-node>` to parent it there.\n\n---\n\n\n### **Events:**\n - **pointerdown** - Fired when a pointer button is pressed over the entity.\n- **pointerenter** - Fired when the pointer moves onto the entity.\n- **pointerleave** - Fired when the pointer moves off the entity.\n- **pointermove** - Fired when the pointer moves over the entity.\n- **pointerup** - Fired when a pointer button is released over the entity.\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.",
       "attributes": [
         {
           "name": "enabled",
@@ -219,11 +229,16 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-entity/"
+        }
+      ]
     },
     {
       "name": "pc-material",
-      "description": "The MaterialElement interface provides properties and methods for manipulating\n[`<pc-material>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-material/) elements.\nThe MaterialElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nA `pc-material` must be a direct child of `pc-app` — elements placed elsewhere log a warning\nand never create a material. Elements inserted while the application is already running are\ncreated on insertion.\n\nThe element is metal/rough by default: unlike a bare `StandardMaterial` it enables the metalness\nworkflow, which is what the `metalness-*` attributes assume and what glTF means by PBR. It also\ndefaults `metalness` to 0 rather than the engine's 1, because those two defaults have to be\nchosen together - the engine's 1 is unreachable under its own `useMetalness` of false, and with\nthe workflow on it would make every material fully metallic, so `<pc-material diffuse=\"crimson\">`\nwould render as dark tinted reflections of an environment that may not exist rather than as a\ncrimson surface. `metalness=\"1\"` remains one attribute away.\n\nThe `roughness` and `roughness-map` attributes are aliases for `gloss` and `gloss-map` that\nadditionally invert the gloss channel; do not mix the two families on one element.\n\nThe two aliases are documented here rather than on an accessor, because they resolve to the\n`gloss` properties and would otherwise inherit gloss's description - which reads inverted.\n\n---\n\n\n### **Methods:**\n - **get(id: _string_): __** - Returns the StandardMaterial created by the `<pc-material>` element with the given\n`id`, or `undefined` if there is no such element or its material has not been created yet.",
+      "description": "The `<pc-material>` element defines a physically based material, which\n`<pc-render>` elements apply by naming its `id`. It is metal/rough by default, with `metalness`\nstarting at 0. Must be a direct child of `<pc-app>`.\n\n---\n",
       "attributes": [
         {
           "name": "alpha-test",
@@ -699,11 +714,16 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-material/"
+        }
+      ]
     },
     {
       "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 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.",
+      "description": "The `<pc-model>` element instantiates a 3D model from a container asset\n(typically a GLB) beneath an entity of its own, so the element's transform and tags place the\ninstance in the scene. Its `<pc-node>` children override what the asset authored. Place it in the\n`<pc-scene>`, or nest it under a `<pc-entity>`, another `<pc-model>` or a `<pc-node>`.\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.",
       "attributes": [
         {
           "name": "asset",
@@ -766,11 +786,16 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-model/"
+        }
+      ]
     },
     {
       "name": "pc-node",
-      "description": "The NodeElement interface provides properties and methods for manipulating\n[`<pc-node>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-node/)\nelements. The NodeElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nA `pc-node` is an override element: where `pc-entity` creates an entity, `pc-node` binds to a\nnode a `pc-model` loaded and declares overrides against the authored asset — components to\nadd, properties to change, content to attach. Attributes present apply as overrides; attributes\nabsent leave authored values untouched, and removing an attribute (or assigning `null` to the\nmatching property) restores the authored value.\n\n`name` selects among the host model's nodes (first match in depth-first order), nesting a\n`pc-node` inside another scopes the search to that subtree, and `index` picks among identically\nnamed matches. When `name` matches more than one node and no `index` is given, the element\nwarns and binds nothing.\n\nThe element becomes ready once bound, and never while unresolved — a missing or ambiguous\nname warns and records the failure in `state`, readiness stays unresolved, and descendants\nwait with it.\n\nThe pointer events below are dispatched by the containing `<pc-app>` element when the pointer\nintersects the bound node's geometry, exactly as for `<pc-entity>`.\n\n---\n\n\n### **Events:**\n - **pointerdown** - Fired when a pointer button is pressed over the node.\n- **pointerenter** - Fired when the pointer moves onto the node.\n- **pointerleave** - Fired when the pointer moves off the node.\n- **pointermove** - Fired when the pointer moves over the node.\n- **pointerup** - Fired when a pointer button is released over the node.\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 `<pc-node>` element binds to a node inside the hierarchy a `<pc-model>`\ninstantiated and declares overrides against it: a transform, an enabled state, tags, components\nto add, or content to attach. Its `name` is a lookup, never a rename. Must be a descendant of\n`<pc-model>`.\n\n---\n\n\n### **Events:**\n - **pointerdown** - Fired when a pointer button is pressed over the node.\n- **pointerenter** - Fired when the pointer moves onto the node.\n- **pointerleave** - Fired when the pointer moves off the node.\n- **pointermove** - Fired when the pointer moves over the node.\n- **pointerup** - Fired when a pointer button is released over the node.\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.",
       "attributes": [
         {
           "name": "enabled",
@@ -838,11 +863,16 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-node/"
+        }
+      ]
     },
     {
       "name": "pc-scene",
-      "description": "The SceneElement interface provides properties and methods for manipulating\n[`<pc-scene>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-scene/) elements.\nThe SceneElement 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 `<pc-scene>` element holds the entity hierarchy the application renders,\nalong with the scene-wide fog and gravity settings. Must be a direct child of `<pc-app>`.\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.",
       "attributes": [
         {
           "name": "fog",
@@ -880,11 +910,16 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-scene/"
+        }
+      ]
     },
     {
       "name": "pc-sky",
-      "description": "The SkyElement interface provides properties and methods for manipulating\n`<pc-sky>` elements. The SkyElement interface also inherits the properties and\nmethods of the HTMLElement 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 `<pc-sky>` element renders a skybox from a texture asset, projected as an\ninfinite background, a box or a dome, and optionally lights the scene from it. Must be a direct\nchild of `<pc-scene>`.\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.",
       "attributes": [
         {
           "name": "asset",
@@ -932,11 +967,16 @@
           ]
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-sky/"
+        }
+      ]
     },
     {
       "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.",
+      "description": "The `<pc-wasm>` element loads a WebAssembly module the engine needs before the\napplication starts — `Ammo` for physics, `Basis` or `DracoDecoderModule` for compressed assets.\nMust be a direct child of `<pc-app>`.\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.",
       "attributes": [
         {
           "name": "fallback",
@@ -959,11 +999,16 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-wasm/"
+        }
+      ]
     },
     {
       "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.",
+      "description": "The `<pc-anim-clip>` element declares one named animation clip on its parent\n`<pc-anim>`, taken from the `asset` it names or, without one, from the enclosing `<pc-model>`'s\nown animations. Must be a direct child of `<pc-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.",
       "attributes": [
         {
           "name": "asset",
@@ -986,11 +1031,16 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-anim-clip/"
+        }
+      ]
     },
     {
       "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.",
+      "description": "The `<pc-anim>` element plays animation clips over its entity's hierarchy, taken\nfrom `<pc-anim-clip>` children or from the enclosing `<pc-model>`'s own animations. The first\nclip plays automatically, and the `clip` attribute switches between them. Must be a child of a\n`<pc-entity>`, `<pc-model>` or `<pc-node>`.\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.",
       "attributes": [
         {
           "name": "activate",
@@ -1018,11 +1068,16 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-anim/"
+        }
+      ]
     },
     {
       "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.",
+      "description": "The `<pc-audio-listener>` element makes its entity the point from which\npositional sounds are heard, typically the entity holding the `<pc-camera>`. Must be a child of a\n`<pc-entity>`, `<pc-model>` or `<pc-node>`.\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.",
       "attributes": [
         {
           "name": "enabled",
@@ -1030,11 +1085,16 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-audio-listener/"
+        }
+      ]
     },
     {
       "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\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.",
+      "description": "The `<pc-button>` element makes its entity respond to pointer input, tinting or\nswapping its image as the pointer hovers, presses and releases it. The entity also needs a\n`<pc-element>` with `use-input` set. Must be a child of a `<pc-entity>`, `<pc-model>` or\n`<pc-node>`.\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.",
       "attributes": [
         {
           "name": "active",
@@ -1112,11 +1172,16 @@
           "values": [{ "name": "tint" }, { "name": "sprite" }]
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-button/"
+        }
+      ]
     },
     {
       "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\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.",
+      "description": "The `<pc-camera>` element renders the scene from its entity's transform, with\nattributes for the projection, field of view, clip planes, clear color and tonemapping. Must be a\nchild of a `<pc-entity>`, `<pc-model>` or `<pc-node>`.\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.",
       "attributes": [
         {
           "name": "clear-color",
@@ -1128,6 +1193,11 @@
           "description": "The clear color buffer of the camera.",
           "values": []
         },
+        {
+          "name": "clear-depth",
+          "description": "The depth value the depth buffer is cleared to.",
+          "values": []
+        },
         {
           "name": "clear-depth-buffer",
           "description": "The clear depth buffer of the camera.",
@@ -1222,11 +1292,16 @@
           ]
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-camera/"
+        }
+      ]
     },
     {
       "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\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.",
+      "description": "The `<pc-collision>` element gives its entity a collision shape — a box, sphere,\ncapsule, cone, cylinder or mesh — for the physics simulation to collide against. Pair it with a\n`<pc-rigid-body>`. Must be a child of a `<pc-entity>`, `<pc-model>` or `<pc-node>`.\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.",
       "attributes": [
         {
           "name": "angular-offset",
@@ -1265,11 +1340,16 @@
           ]
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-collision/"
+        }
+      ]
     },
     {
       "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\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.",
+      "description": "The `<pc-element>` element gives its entity a 2D UI rectangle inside a\n`<pc-screen>` hierarchy, drawing an image, a line of text or nothing (`type=\"image\"`, `\"text\"` or\n`\"group\"`). Must be a child of a `<pc-entity>`, `<pc-model>` or `<pc-node>`.\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.",
       "attributes": [
         {
           "name": "anchor",
@@ -1411,11 +1491,16 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-element/"
+        }
+      ]
     },
     {
       "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\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.",
+      "description": "The `<pc-gsplat>` element renders the 3D Gaussian splats of a `gsplat` asset at\nits entity, with attributes for shadow casting and level of detail. Must be a child of a\n`<pc-entity>`, `<pc-model>` or `<pc-node>`.\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.",
       "attributes": [
         {
           "name": "asset",
@@ -1453,11 +1538,16 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-gsplat/"
+        }
+      ]
     },
     {
       "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. 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.",
+      "description": "The `<pc-joint>` element constrains two rigid bodies to each other — a hinged\ndoor, a swinging chain, a sliding drawer. Its entity's transform is the joint frame, and\n`entity-a` and `entity-b` name the bodies. Must be a child of a `<pc-entity>`, `<pc-model>` or\n`<pc-node>`.\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.",
       "attributes": [
         {
           "name": "angular-damping",
@@ -1645,11 +1735,16 @@
           ]
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-joint/"
+        }
+      ]
     },
     {
       "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.",
+      "description": "The `<pc-layout-child>` element controls how its entity is sized by the\n`<pc-layout-group>` above it, through minimum and maximum sizes and fit proportions. Must be a\nchild of a `<pc-entity>`, `<pc-model>` or `<pc-node>`.\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.",
       "attributes": [
         {
           "name": "enabled",
@@ -1692,11 +1787,16 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-layout-child/"
+        }
+      ]
     },
     {
       "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.",
+      "description": "The `<pc-layout-group>` element arranges its entity's children in a row or\ncolumn, with spacing, padding, alignment and fitting. Must be a child of a `<pc-entity>`,\n`<pc-model>` or `<pc-node>`.\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.",
       "attributes": [
         {
           "name": "alignment",
@@ -1759,12 +1859,27 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-layout-group/"
+        }
+      ]
     },
     {
       "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\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.",
+      "description": "The `<pc-light>` element lights the scene from its entity — as a directional,\nomni or spot light — with attributes for color, intensity, range and shadows. Must be a child of\na `<pc-entity>`, `<pc-model>` or `<pc-node>`.\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.",
       "attributes": [
+        {
+          "name": "cascade-blend",
+          "description": "The cascade blend factor of the light, from 0 (no blending) to 1, which applies only to `directional` lights with `num-cascades` greater than 1.",
+          "values": []
+        },
+        {
+          "name": "cascade-distribution",
+          "description": "The cascade distribution of the light, from 0 (linear split) to 1 (logarithmic split, concentrating shadow resolution near the camera), which applies only to `directional` lights with `num-cascades` greater than 1.",
+          "values": []
+        },
         {
           "name": "cast-shadows",
           "description": "The cast shadows flag of the light.",
@@ -1795,6 +1910,11 @@
           "description": "The normal offset bias of the light.",
           "values": []
         },
+        {
+          "name": "num-cascades",
+          "description": "The number of shadow cascades of the light, an integer from 1 (no cascades) to 4, which applies only to `directional` lights.",
+          "values": []
+        },
         {
           "name": "outer-cone-angle",
           "description": "The outer cone angle of the light.",
@@ -1880,11 +2000,16 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-light/"
+        }
+      ]
     },
     {
       "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",
+      "description": "The `<pc-particle-system>` element emits particles from its entity, with\nattributes for the emitter's shape, rate, lifetime, textures and blending. Must be a child of a\n`<pc-entity>`, `<pc-model>` or `<pc-node>`.\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.",
       "attributes": [
         {
           "name": "asset",
@@ -1897,11 +2022,16 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-particle-system/"
+        }
+      ]
     },
     {
       "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\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.",
+      "description": "The `<pc-render>` element renders one of the engine's built-in primitives at its\nentity — box, sphere, capsule, cone, cylinder or plane — shaded by the `<pc-material>` its\n`material` attribute names. For glTF content, use `<pc-model>` instead. Must be a child of a\n`<pc-entity>`, `<pc-model>` or `<pc-node>`.\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.",
       "attributes": [
         {
           "name": "cast-shadows",
@@ -1936,11 +2066,16 @@
           ]
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-render/"
+        }
+      ]
     },
     {
       "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.",
+      "description": "The `<pc-rigid-body>` element hands its entity to the physics simulation, with\nattributes for its type, mass, friction and restitution. It needs a sibling `<pc-collision>` for\nits shape, and `Ammo` loaded through `<pc-wasm>`. Must be a child of a `<pc-entity>`,\n`<pc-model>` or `<pc-node>`.\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.",
       "attributes": [
         { "name": "angular-damping", "values": [] },
         {
@@ -1972,11 +2107,16 @@
           ]
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-rigid-body/"
+        }
+      ]
     },
     {
       "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\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.",
+      "description": "The `<pc-screen>` element gives its entity a 2D space — in screen space or in the\nworld — that a hierarchy of `<pc-element>` descendants lays out inside. Must be a child of a\n`<pc-entity>`, `<pc-model>` or `<pc-node>`.\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.",
       "attributes": [
         {
           "name": "enabled",
@@ -2006,11 +2146,16 @@
         },
         { "name": "screen-space", "values": [] }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-screen/"
+        }
+      ]
     },
     {
       "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.",
+      "description": "The `<pc-script>` element holds the `<pc-script-instance>` children that attach\nscripts to its entity. Must be a child of a `<pc-entity>`, `<pc-model>` or `<pc-node>`.\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.",
       "attributes": [
         {
           "name": "enabled",
@@ -2018,11 +2163,16 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-script/"
+        }
+      ]
     },
     {
       "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.",
+      "description": "The `<pc-script-instance>` element attaches one script class, named by `name`, to\nthe entity of its parent `<pc-script>`. Its other attributes set script attributes of the same\nname, and `attributes` takes a JSON object instead. Must be a direct child of `<pc-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- **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.",
       "attributes": [
         {
           "name": "attributes",
@@ -2040,11 +2190,16 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-script-instance/"
+        }
+      ]
     },
     {
       "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.",
+      "description": "The `<pc-scroll-view>` element scrolls a larger content entity within a clipped\nviewport at its entity, optionally driven by the `<pc-scrollbar>` elements it references. Must be\na child of a `<pc-entity>`, `<pc-model>` or `<pc-node>`.\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.",
       "attributes": [
         {
           "name": "bounce-amount",
@@ -2117,11 +2272,16 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-scroll-view/"
+        }
+      ]
     },
     {
       "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.",
+      "description": "The `<pc-scrollbar>` element gives its entity a draggable handle reporting a\nposition from 0 to 1, which a `<pc-scroll-view>` references to scroll its content. Must be a\nchild of a `<pc-entity>`, `<pc-model>` or `<pc-node>`.\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.",
       "attributes": [
         {
           "name": "enabled",
@@ -2149,11 +2309,16 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-scrollbar/"
+        }
+      ]
     },
     {
       "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.",
+      "description": "The `<pc-sound>` element holds the `<pc-sound-slot>` children that play sounds at\nits entity, along with the positional audio settings they share. Must be a child of a\n`<pc-entity>`, `<pc-model>` or `<pc-node>`.\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.",
       "attributes": [
         {
           "name": "distance-model",
@@ -2200,11 +2365,16 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-sound/"
+        }
+      ]
     },
     {
       "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.",
+      "description": "The `<pc-sound-slot>` element declares one named sound on its parent `<pc-sound>`\n— its asset, volume, pitch, looping and autoplay. Must be a direct child of `<pc-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.",
       "attributes": [
         {
           "name": "asset",
@@ -2252,7 +2422,12 @@
           "values": []
         }
       ],
-      "references": []
+      "references": [
+        {
+          "name": "User Manual",
+          "url": "https://developer.playcanvas.com/user-manual/web-components/tags/pc-sound-slot/"
+        }
+      ]
     }
   ]
 }