@playcanvas/web-components 0.11.1 → 0.13.0

package/dist/scene.d.cts

@@ -0,0 +1,117 @@
+import type { Scene } from 'playcanvas';
+import { Color, Vec3 } from 'playcanvas';
+import { AsyncElement } from './async-element.cjs';
+/**
+ * The SceneElement interface provides properties and methods for manipulating
+ * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-scene/ | `<pc-scene>`} elements.
+ * The SceneElement interface also inherits the properties and methods of the
+ * {@link HTMLElement} interface.
+ */
+declare class SceneElement extends AsyncElement {
+    /**
+     * The fog type of the scene.
+     */
+    private _fog;
+    /**
+     * The color of the fog.
+     */
+    private _fogColor;
+    /**
+     * The density of the fog.
+     */
+    private _fogDensity;
+    /**
+     * The start distance of the fog.
+     */
+    private _fogStart;
+    /**
+     * The end distance of the fog.
+     */
+    private _fogEnd;
+    /**
+     * The gravity of the scene.
+     */
+    private _gravity;
+    private _scene;
+    /**
+     * The PlayCanvas scene instance. `null` until the element is ready — await
+     * {@link whenReady} or the element's `ready()` promise before accessing it.
+     * @returns The scene instance, or `null`.
+     */
+    get scene(): Scene | null;
+    connectedCallback(): Promise<void>;
+    disconnectedCallback(): void;
+    private _updateSceneSettings;
+    /**
+     * Applies gravity to the rigid body system. Resolved through `closestApp` rather than
+     * `parentElement` so that a `<pc-scene>` nested inside a wrapper element behaves the same as
+     * a direct child, matching how `connectedCallback` resolves the application.
+     *
+     * @param value - The gravity to apply.
+     */
+    private _applyGravity;
+    /**
+     * Sets the fog type of the scene. Can be `none`, `linear`, `exp` or `exp2`. Defaults to
+     * `none`.
+     * @param value - The fog type.
+     */
+    set fog(value: "linear" | "none" | "exp" | "exp2");
+    /**
+     * Gets the fog type of the scene.
+     * @returns The fog type.
+     */
+    get fog(): "linear" | "none" | "exp" | "exp2";
+    /**
+     * Sets the fog color of the scene.
+     * @param value - The fog color.
+     */
+    set fogColor(value: Color);
+    /**
+     * Gets the fog color of the scene.
+     * @returns The fog color.
+     */
+    get fogColor(): Color;
+    /**
+     * Sets the fog density of the scene.
+     * @param value - The fog density.
+     */
+    set fogDensity(value: number);
+    /**
+     * Gets the fog density of the scene.
+     * @returns The fog density.
+     */
+    get fogDensity(): number;
+    /**
+     * Sets the fog start distance of the scene.
+     * @param value - The fog start distance.
+     */
+    set fogStart(value: number);
+    /**
+     * Gets the fog start distance of the scene.
+     * @returns The fog start distance.
+     */
+    get fogStart(): number;
+    /**
+     * Sets the fog end distance of the scene.
+     * @param value - The fog end distance.
+     */
+    set fogEnd(value: number);
+    /**
+     * Gets the fog end distance of the scene.
+     * @returns The fog end distance.
+     */
+    get fogEnd(): number;
+    /**
+     * Sets the gravity of the scene.
+     * @param value - The gravity.
+     */
+    set gravity(value: Vec3);
+    /**
+     * Gets the gravity of the scene.
+     * @returns The gravity.
+     */
+    get gravity(): Vec3;
+    static get observedAttributes(): string[];
+    attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
+}
+export { SceneElement };

package/dist/scene.d.ts

@@ -1,6 +1,6 @@
 import type { Scene } from 'playcanvas';
 import { Color, Vec3 } from 'playcanvas';
-import { AsyncElement } from './async-element';
+import { AsyncElement } from './async-element.js';
 /**
  * The SceneElement interface provides properties and methods for manipulating
  * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-scene/ | `<pc-scene>`} elements.

package/dist/sky.d.cts

@@ -0,0 +1,121 @@
+import { Vec3 } from 'playcanvas';
+import { AsyncElement } from './async-element.cjs';
+/**
+ * The SkyElement interface provides properties and methods for manipulating
+ * `<pc-sky>` elements. The SkyElement interface also inherits the properties and
+ * methods of the {@link HTMLElement} interface.
+ */
+declare class SkyElement extends AsyncElement {
+    private _asset;
+    private _center;
+    private _intensity;
+    private _rotation;
+    private _mipLevel;
+    private _lighting;
+    private _scale;
+    private _type;
+    private _scene;
+    private _appElement;
+    /**
+     * Incremented on every new load and on disconnect, and captured by a load when it starts. A
+     * load that resumes from an await or a load callback abandons itself if the value has moved
+     * on, so a superseded load cannot generate a skybox for a scene it no longer configures.
+     */
+    private _loadGeneration;
+    /**
+     * The pending asset-load subscription of the current load, if it is waiting for its asset.
+     * Held so that whatever supersedes the load can detach the handler from the asset, rather
+     * than leave it registered until the asset loads (or forever, if it never does).
+     */
+    private _loadHandle;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _detachLoadHandler;
+    private _generateSkybox;
+    private _loadSkybox;
+    private _unloadSkybox;
+    /**
+     * Sets the id of the `pc-asset` to use for the skybox.
+     * @param value - The asset ID.
+     */
+    set asset(value: string);
+    /**
+     * Gets the id of the `pc-asset` to use for the skybox.
+     * @returns The asset ID.
+     */
+    get asset(): string;
+    /**
+     * Sets the center of the skybox.
+     * @param value - The center.
+     */
+    set center(value: Vec3);
+    /**
+     * Gets the center of the skybox.
+     * @returns The center.
+     */
+    get center(): Vec3;
+    /**
+     * Sets the intensity of the skybox.
+     * @param value - The intensity.
+     */
+    set intensity(value: number);
+    /**
+     * Gets the intensity of the skybox.
+     * @returns The intensity.
+     */
+    get intensity(): number;
+    /**
+     * Sets whether the skybox is used as a light source.
+     * @param value - Whether to use lighting.
+     */
+    set lighting(value: boolean);
+    /**
+     * Gets whether the skybox is used as a light source.
+     * @returns Whether to use lighting.
+     */
+    get lighting(): boolean;
+    /**
+     * Sets the mip level of the skybox, where 0 is the sharpest. Raising it selects a blurrier mip,
+     * which is how a skybox is softened without blurring the texture itself.
+     * @param value - The mip level.
+     */
+    set mipLevel(value: number);
+    /**
+     * Gets the mip level of the skybox.
+     * @returns The mip level.
+     */
+    get mipLevel(): number;
+    /**
+     * Sets the Euler rotation of the skybox.
+     * @param value - The rotation.
+     */
+    set rotation(value: Vec3);
+    /**
+     * Gets the Euler rotation of the skybox.
+     * @returns The rotation.
+     */
+    get rotation(): Vec3;
+    /**
+     * Sets the scale of the skybox.
+     * @param value - The scale.
+     */
+    set scale(value: Vec3);
+    /**
+     * Gets the scale of the skybox.
+     * @returns The scale.
+     */
+    get scale(): Vec3;
+    /**
+     * Sets the type of the skybox.
+     * @param value - The type.
+     */
+    set type(value: 'box' | 'dome' | 'infinite' | 'none');
+    /**
+     * Gets the type of the skybox.
+     * @returns The type.
+     */
+    get type(): "box" | "dome" | "infinite" | "none";
+    static get observedAttributes(): string[];
+    attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
+}
+export { SkyElement };

package/dist/sky.d.ts

@@ -1,5 +1,5 @@
 import { Vec3 } from 'playcanvas';
-import { AsyncElement } from './async-element';
+import { AsyncElement } from './async-element.js';
 /**
  * The SkyElement interface provides properties and methods for manipulating
  * `<pc-sky>` elements. The SkyElement interface also inherits the properties and

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\n---\n\n\n### **Events:**\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>` element whose backing entity is `entity`, or `null` if the\nentity was not created by an element of this application - for example, a node inside a\nmodel's instantiated hierarchy, or an entity created through the engine API.\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>` 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.",
       "attributes": [
         {
           "name": "alpha",
@@ -50,8 +50,31 @@
     },
     {
       "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\nApart from `lazy`, these attributes are read once when the asset is created, so changing them\nlater 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 AssetElement interface provides properties and methods for manipulating\n[`<pc-asset>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-asset/) elements.\nThe AssetElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nThe element becomes ready once the containing application has started and the asset is in the\nstate declared by the markup: loaded for preloaded assets (even if loading failed — check the\nasset's `resource`), or registered and awaiting a load for `lazy` assets. Elements inserted\nwhile the application is running are created and registered on insertion, and begin loading\nimmediately unless `lazy`. A `pc-asset` must be a direct child of `pc-app` — elements placed\nelsewhere, or with an unsupported asset type, never become ready.\n\nFor `texture` and `textureatlas` assets, the texture options (`address-u`, `address-v`,\n`min-filter`, `mag-filter`, `anisotropy`, `mipmaps`, `srgb`, `flip-y`) apply when the texture is\ncreated and — like `lazy` — are observed: changing one updates a texture that has already\nloaded, and removing one restores the engine default. Changing `srgb` or `mipmaps` on a loaded\ntexture recreates the underlying GPU resource, so prefer declaring those up front. Each option\noverrides the matching key in the `data` JSON; options left unset write nothing, leaving the\nengine's per-format defaults in force.\n\nApart from `lazy` and the texture options, these attributes are read once when the asset is\ncreated, so changing them later has no effect.\n\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.",
       "attributes": [
+        {
+          "name": "address-u",
+          "description": "The texture's horizontal (U) address mode.",
+          "values": [
+            { "name": "repeat" },
+            { "name": "clamp" },
+            { "name": "mirror" }
+          ]
+        },
+        {
+          "name": "address-v",
+          "description": "The texture's vertical (V) address mode.",
+          "values": [
+            { "name": "repeat" },
+            { "name": "clamp" },
+            { "name": "mirror" }
+          ]
+        },
+        {
+          "name": "anisotropy",
+          "description": "The texture's maximum anisotropic filtering level.",
+          "values": []
+        },
         {
           "name": "atlas",
           "description": "For a `sprite` asset, the `id` of the texture atlas asset it uses. The atlas must be declared before the sprite.",
@@ -62,6 +85,11 @@
           "description": "Additional asset data, as a JSON object.",
           "values": []
         },
+        {
+          "name": "flip-y",
+          "description": "Whether the texture's image data is flipped vertically at upload.",
+          "values": []
+        },
         {
           "name": "frame-keys",
           "description": "For a `sprite` asset, the atlas frame keys it uses, separated by spaces or commas.",
@@ -77,6 +105,28 @@
           "description": "Whether the asset should be loaded lazily.",
           "values": []
         },
+        {
+          "name": "mag-filter",
+          "description": "The texture's magnification filter.",
+          "values": [{ "name": "nearest" }, { "name": "linear" }]
+        },
+        {
+          "name": "min-filter",
+          "description": "The texture's minification filter.",
+          "values": [
+            { "name": "nearest" },
+            { "name": "linear" },
+            { "name": "nearest-mip-nearest" },
+            { "name": "linear-mip-nearest" },
+            { "name": "nearest-mip-linear" },
+            { "name": "linear-mip-linear" }
+          ]
+        },
+        {
+          "name": "mipmaps",
+          "description": "Whether the texture generates and uses mipmaps.",
+          "values": []
+        },
         {
           "name": "pixels-per-unit",
           "description": "For a `sprite` asset, the number of pixels per world unit.",
@@ -96,6 +146,11 @@
           "description": "The URL of the asset to load.",
           "values": []
         },
+        {
+          "name": "srgb",
+          "description": "Whether the texture holds sRGB (gamma-encoded) color data.",
+          "values": []
+        },
         {
           "name": "type",
           "description": "The asset type. Inferred from the `src` file extension when omitted.",
@@ -643,7 +698,7 @@
     },
     {
       "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\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 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 - **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.",
       "attributes": [
         {
           "name": "asset",
@@ -655,7 +710,7 @@
     },
     {
       "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/) elements.\nThe ModuleElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nNote that these attributes are read once when the element is created, so changing them later\nhas no effect.\n\n---\n",
+      "description": "The ModuleElement interface provides properties and methods for manipulating\n[`<pc-module>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-module/)\nelements. The ModuleElement interface also inherits the properties and methods of the\nAsyncElement interface.\n\nThe attributes are read once, when the module starts loading - on the element's first\nconnection, or earlier if a containing `<pc-app>` boots first and collects it - so changing\nthem later has no effect. The element becomes ready once the module has loaded. WebAssembly\nmodules configure engine-global state that never unloads, so readiness is not re-armed by\nremoving the element, and a re-inserted element does not load again.\n\nA `<pc-module>` without a `name` warns and never becomes ready; a containing `<pc-app>` still\nboots.\n\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.",
       "attributes": [
         {
           "name": "fallback",
@@ -680,6 +735,73 @@
       ],
       "references": []
     },
+    {
+      "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.",
+      "attributes": [
+        {
+          "name": "enabled",
+          "description": "Overrides the node's enabled state.",
+          "values": []
+        },
+        {
+          "name": "index",
+          "description": "Which match to bind when `name` matches more than one node, 0-based in depth-first order. Optional for a unique match; required for an ambiguous one.",
+          "values": []
+        },
+        {
+          "name": "name",
+          "description": "The name of the node to bind, resolved within the nearest ancestor `pc-model` (or `pc-node`) once it has instantiated.",
+          "values": []
+        },
+        {
+          "name": "onpointerdown",
+          "description": "Script to run when a pointer button is pressed over the node.",
+          "values": []
+        },
+        {
+          "name": "onpointerenter",
+          "description": "Script to run when the pointer moves onto the node.",
+          "values": []
+        },
+        {
+          "name": "onpointerleave",
+          "description": "Script to run when the pointer moves off the node.",
+          "values": []
+        },
+        {
+          "name": "onpointermove",
+          "description": "Script to run when the pointer moves over the node.",
+          "values": []
+        },
+        {
+          "name": "onpointerup",
+          "description": "Script to run when a pointer button is released over the node.",
+          "values": []
+        },
+        {
+          "name": "position",
+          "description": "Overrides the node's local position, as an \"x y z\" triple.",
+          "values": []
+        },
+        {
+          "name": "rotation",
+          "description": "Overrides the node's local rotation (Euler angles), as an \"x y z\" triple.",
+          "values": []
+        },
+        {
+          "name": "scale",
+          "description": "Overrides the node's local scale, as an \"x y z\" triple.",
+          "values": []
+        },
+        {
+          "name": "tags",
+          "description": "Overrides the node's tags, separated by spaces or commas.",
+          "values": []
+        }
+      ],
+      "references": []
+    },
     {
       "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.",
@@ -968,7 +1090,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\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\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.",
       "attributes": [
         {
           "name": "angular-offset",