@playcanvas/web-components 0.12.0 → 0.13.1

package/dist/components/sound-component.d.cts

@@ -0,0 +1,108 @@
+import type { SoundComponent } from 'playcanvas';
+import { ComponentElement } from './component.cjs';
+/**
+ * The SoundComponentElement interface provides properties and methods for manipulating
+ * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-sounds/ | `<pc-sounds>`} elements.
+ * The SoundComponentElement interface also inherits the properties and methods of the
+ * {@link HTMLElement} interface.
+ *
+ * @category Components
+ */
+declare class SoundComponentElement extends ComponentElement {
+    private _distanceModel;
+    private _maxDistance;
+    private _pitch;
+    private _positional;
+    private _refDistance;
+    private _rollOffFactor;
+    private _volume;
+    /** @ignore */
+    constructor();
+    protected getInitialComponentData(): {
+        distanceModel: "linear" | "exponential" | "inverse";
+        maxDistance: number;
+        pitch: number;
+        positional: boolean;
+        refDistance: number;
+        rollOffFactor: number;
+        volume: number;
+    };
+    /**
+     * Gets the underlying PlayCanvas sound component.
+     * @returns The sound component.
+     */
+    get component(): SoundComponent;
+    /**
+     * Sets which algorithm to use to reduce the volume of the sound as it moves away from the listener.
+     * @param value - The distance model.
+     */
+    set distanceModel(value: 'exponential' | 'inverse' | 'linear');
+    /**
+     * Gets which algorithm to use to reduce the volume of the sound as it moves away from the listener.
+     * @returns The distance model.
+     */
+    get distanceModel(): 'exponential' | 'inverse' | 'linear';
+    /**
+     * Sets the maximum distance from the listener at which audio falloff stops.
+     * @param value - The max distance.
+     */
+    set maxDistance(value: number);
+    /**
+     * Gets the maximum distance from the listener at which audio falloff stops.
+     * @returns The max distance.
+     */
+    get maxDistance(): number;
+    /**
+     * Sets the pitch of the sound.
+     * @param value - The pitch.
+     */
+    set pitch(value: number);
+    /**
+     * Gets the pitch of the sound.
+     * @returns The pitch.
+     */
+    get pitch(): number;
+    /**
+     * Sets the positional flag of the sound.
+     * @param value - The positional flag.
+     */
+    set positional(value: boolean);
+    /**
+     * Gets the positional flag of the sound.
+     * @returns The positional flag.
+     */
+    get positional(): boolean;
+    /**
+     * Sets the reference distance for reducing volume as the sound source moves further from the listener. Defaults to 1.
+     * @param value - The ref distance.
+     */
+    set refDistance(value: number);
+    /**
+     * Gets the reference distance for reducing volume as the sound source moves further from the listener.
+     * @returns The ref distance.
+     */
+    get refDistance(): number;
+    /**
+     * Sets the factor used in the falloff equation. Defaults to 1.
+     * @param value - The roll-off factor.
+     */
+    set rollOffFactor(value: number);
+    /**
+     * Gets the factor used in the falloff equation.
+     * @returns The roll-off factor.
+     */
+    get rollOffFactor(): number;
+    /**
+     * Sets the volume of the sound.
+     * @param value - The volume.
+     */
+    set volume(value: number);
+    /**
+     * Gets the volume of the sound.
+     * @returns The volume.
+     */
+    get volume(): number;
+    static get observedAttributes(): string[];
+    attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
+}
+export { SoundComponentElement };

package/dist/components/sound-component.d.ts

@@ -1,5 +1,5 @@
 import type { SoundComponent } from 'playcanvas';
-import { ComponentElement } from './component';
+import { ComponentElement } from './component.js';
 /**
  * The SoundComponentElement interface provides properties and methods for manipulating
  * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-sounds/ | `<pc-sounds>`} elements.

package/dist/components/sound-slot.d.cts

@@ -0,0 +1,134 @@
+import type { SoundSlot } from 'playcanvas';
+import { AsyncElement } from '../async-element.cjs';
+import { SoundComponentElement } from './sound-component.cjs';
+/**
+ * The SoundSlotElement interface provides properties and methods for manipulating
+ * `<pc-sound>` elements. The SoundSlotElement interface also inherits the properties and
+ * methods of the {@link AsyncElement} interface.
+ */
+declare class SoundSlotElement extends AsyncElement {
+    private _asset;
+    private _autoPlay;
+    private _duration;
+    private _loop;
+    private _name;
+    private _overlap;
+    private _pitch;
+    private _startTime;
+    private _volume;
+    /**
+     * The `<pc-sounds>` this slot was added to, captured at connect time.
+     *
+     * `disconnectedCallback` cannot rediscover it: by the time the element is disconnected its
+     * `parentElement` is already `null`, so a lookup would both fail to find the component and
+     * emit a misleading "must be a direct child" warning for what is an ordinary removal.
+     */
+    private _soundElement;
+    /**
+     * Incremented on every connect and disconnect, and captured by connectedCallback on entry —
+     * a resume from an await abandons itself if the value has moved on, so a stale callback can
+     * neither act on a torn-down tree nor add its slot alongside a re-inserted element's own
+     * callback.
+     */
+    private _connectionGeneration;
+    /**
+     * The sound slot.
+     */
+    soundSlot: SoundSlot | null;
+    connectedCallback(): Promise<void>;
+    disconnectedCallback(): void;
+    protected get soundElement(): SoundComponentElement | null;
+    /**
+     * Sets the id of the `pc-asset` to use for the sound slot.
+     * @param value - The asset.
+     */
+    set asset(value: string);
+    /**
+     * Gets the id of the `pc-asset` to use for the sound slot.
+     * @returns The asset.
+     */
+    get asset(): string;
+    /**
+     * Sets the auto play flag of the sound slot.
+     * @param value - The auto play flag.
+     */
+    set autoPlay(value: boolean);
+    /**
+     * Gets the auto play flag of the sound slot.
+     * @returns The auto play flag.
+     */
+    get autoPlay(): boolean;
+    /**
+     * Sets the duration of the sound slot, in seconds (or `null` to play the whole clip).
+     * @param value - The duration.
+     */
+    set duration(value: number | null);
+    /**
+     * Gets the duration of the sound slot.
+     * @returns The duration.
+     */
+    get duration(): number | null;
+    /**
+     * Sets the loop flag of the sound slot.
+     * @param value - The loop flag.
+     */
+    set loop(value: boolean);
+    /**
+     * Gets the loop flag of the sound slot.
+     * @returns The loop flag.
+     */
+    get loop(): boolean;
+    /**
+     * Sets the name of the sound slot.
+     * @param value - The name.
+     */
+    set name(value: string);
+    /**
+     * Gets the name of the sound slot.
+     * @returns The name.
+     */
+    get name(): string;
+    /**
+     * Sets the overlap flag of the sound slot.
+     * @param value - The overlap flag.
+     */
+    set overlap(value: boolean);
+    /**
+     * Gets the overlap flag of the sound slot.
+     * @returns The overlap flag.
+     */
+    get overlap(): boolean;
+    /**
+     * Sets the pitch of the sound slot.
+     * @param value - The pitch.
+     */
+    set pitch(value: number);
+    /**
+     * Gets the pitch of the sound slot.
+     * @returns The pitch.
+     */
+    get pitch(): number;
+    /**
+     * Sets the start time of the sound slot.
+     * @param value - The start time.
+     */
+    set startTime(value: number);
+    /**
+     * Gets the start time of the sound slot.
+     * @returns The start time.
+     */
+    get startTime(): number;
+    /**
+     * Sets the volume of the sound slot.
+     * @param value - The volume.
+     */
+    set volume(value: number);
+    /**
+     * Gets the volume of the sound slot.
+     * @returns The volume.
+     */
+    get volume(): number;
+    static get observedAttributes(): string[];
+    attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
+}
+export { SoundSlotElement };

package/dist/components/sound-slot.d.ts

@@ -1,6 +1,6 @@
 import type { SoundSlot } from 'playcanvas';
-import { AsyncElement } from '../async-element';
-import { SoundComponentElement } from './sound-component';
+import { AsyncElement } from '../async-element.js';
+import { SoundComponentElement } from './sound-component.js';
 /**
  * The SoundSlotElement interface provides properties and methods for manipulating
  * `<pc-sound>` elements. The SoundSlotElement interface also inherits the properties and

package/dist/custom-elements.json

@@ -8,7 +8,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "The AppElement interface provides properties and methods for manipulating\n[`<pc-app>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-app/) elements.\nThe AppElement interface also inherits the properties and methods of the\nHTMLElement interface.\n",
+          "description": "The AppElement interface provides properties and methods for manipulating\n[`<pc-app>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-app/) elements.\nThe AppElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nThe element is sized like a replaced element such as `<video>`: a block-level box that the\npage's CSS controls, 300x150 by default. The application's canvas always fills the element,\nand the drawing buffer resolution follows the element's size (capped by `max-pixel-ratio`),\ntracked live via a ResizeObserver — so the element can be embedded at any size, resized by\nits container, or made fullscreen with ordinary CSS such as `width: 100vw; height: 100dvh`.\n",
           "name": "AppElement",
           "members": [
             {
@@ -222,6 +222,13 @@
             }
           ],
           "events": [
+            {
+              "name": "error",
+              "type": {
+                "text": "ErrorEvent"
+              },
+              "description": "Fired when the application cannot boot because no graphics device could be created (for example, a browser with WebGL disabled). `message` names the requested backends and `error` holds the underlying failure. The element never becomes ready and `app` stays `null` — listen for this event to show a fallback UI. Removing the element and re-inserting it retries the boot with its current attributes. Does not bubble."
+            },
             {
               "name": "progress",
               "type": {
@@ -339,7 +346,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "The AssetElement interface provides properties and methods for manipulating\n[`<pc-asset>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-asset/) elements.\nThe AssetElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nThe element becomes ready once the containing application has started and the asset is in the\nstate declared by the markup: loaded for preloaded assets (even if loading failed — check the\nasset's `resource`), or registered and awaiting a load for `lazy` assets. Elements inserted\nwhile the application is running are created and registered on insertion, and begin loading\nimmediately unless `lazy`. A `pc-asset` must be a direct child of `pc-app` — elements placed\nelsewhere, or with an unsupported asset type, never become ready.\n\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",
+          "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",
           "name": "AssetElement",
           "members": [
             {
@@ -862,7 +869,7 @@
               "description": "The tag name of the element to wait for (e.g. `'pc-app'`)."
             }
           ],
-          "description": "Waits for the first element matching the given tag name to be fully initialized. Note that the\npromise never settles if the element cannot finish initializing (for example, a `<pc-script>`\nthat is not a direct child of `<pc-scripts>`). A component element outside a `<pc-entity>` is\nthe exception: it still becomes ready, but its `component` is `null`. Either way, a misplaced\nelement logs a warning naming the parent it requires."
+          "description": "Waits for the first element matching the given tag name to be fully initialized. Note that the\npromise never settles if the element cannot finish initializing (for example, a `<pc-script>`\nthat is not a direct child of `<pc-scripts>`, or a `<pc-app>` that could not create a graphics\ndevice — listen for its `error` event instead). A component element outside a `<pc-entity>` is\nthe exception: it still becomes ready, but its `component` is `null`. Either way, a misplaced\nelement logs a warning naming the parent it requires."
         },
         {
           "kind": "function",
@@ -900,7 +907,7 @@
               "description": "A CSS selector matching the element to wait for (e.g. `'#my-app'`)."
             }
           ],
-          "description": "Waits for the first element matching the given CSS selector to be fully initialized. Note that\nthe promise never settles if the element cannot finish initializing (for example, a `<pc-script>`\nthat is not a direct child of `<pc-scripts>`). A component element outside a `<pc-entity>` is\nthe exception: it still becomes ready, but its `component` is `null`. Either way, a misplaced\nelement logs a warning naming the parent it requires."
+          "description": "Waits for the first element matching the given CSS selector to be fully initialized. Note that\nthe promise never settles if the element cannot finish initializing (for example, a `<pc-script>`\nthat is not a direct child of `<pc-scripts>`, or a `<pc-app>` that could not create a graphics\ndevice — listen for its `error` event instead). A component element outside a `<pc-entity>` is\nthe exception: it still becomes ready, but its `component` is `null`. Either way, a misplaced\nelement logs a warning naming the parent it requires."
         },
         {
           "kind": "function",
@@ -4089,8 +4096,60 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "The ModuleElement interface provides properties and methods for manipulating\n[`<pc-module>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-module/) elements.\nThe ModuleElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nNote that these attributes are read once when the element is created, so changing them later\nhas no effect.\n",
+          "description": "The ModuleElement interface provides properties and methods for manipulating\n[`<pc-module>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-module/)\nelements. The ModuleElement interface also inherits the properties and methods of the\nAsyncElement interface.\n\nThe attributes are read once, when the module starts loading - on the element's first\nconnection, or earlier if a containing `<pc-app>` boots first and collects it - so changing\nthem later has no effect. The element becomes ready once the module has loaded. WebAssembly\nmodules configure engine-global state that never unloads, so readiness is not re-armed by\nremoving the element, and a re-inserted element does not load again.\n\nA `<pc-module>` without a `name` warns and never becomes ready; a containing `<pc-app>` still\nboots.\n",
           "name": "ModuleElement",
+          "members": [
+            {
+              "kind": "field",
+              "name": "closestApp",
+              "type": {
+                "text": "AppElement | null"
+              },
+              "description": "The nearest ancestor `<pc-app>` element, or `null` if this element has no `<pc-app>`\nancestor. The search starts at the parent, so an element never resolves to itself.",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "AsyncElement",
+                "module": "src/async-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "closestEntity",
+              "type": {
+                "text": "EntityBaseElement | null"
+              },
+              "description": "The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or\n`null` if this element has no such ancestor. The search starts at the parent, so an element\nnever resolves to itself.",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "AsyncElement",
+                "module": "src/async-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "ready",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "description": "Returns a promise that resolves with this element when it's ready. This is the low-level\nprimitive underlying whenReady, which is the recommended way to wait for elements.\n\nReadiness tracks the element's current lifecycle: once a ready element is torn down (for\nexample by removing it from the document), this returns a fresh promise that resolves when\nthe element is next ready. A promise obtained earlier stays resolved — call this again\nafter re-inserting an element rather than reusing a promise from before its removal.",
+              "inheritedFrom": {
+                "name": "AsyncElement",
+                "module": "src/async-element.ts"
+              }
+            }
+          ],
           "attributes": [
             {
               "type": {
@@ -4122,25 +4181,24 @@
             }
           ],
           "superclass": {
-            "name": "HTMLElement"
+            "name": "AsyncElement",
+            "module": "/src/async-element"
           },
           "tagName": "pc-module",
-          "customElement": true
-        },
-        {
-          "kind": "variable",
-          "name": "glueUrl",
-          "default": "this.getAttribute('glue')!"
-        },
-        {
-          "kind": "variable",
-          "name": "wasmUrl",
-          "default": "this.getAttribute('wasm')!"
-        },
-        {
-          "kind": "variable",
-          "name": "fallbackUrl",
-          "default": "this.getAttribute('fallback')!"
+          "customElement": true,
+          "events": [
+            {
+              "name": "ready",
+              "type": {
+                "text": "CustomEvent"
+              },
+              "description": "Fired when the element is fully initialized — once per readiness cycle, so an element that is torn down and re-initialized (for example by removing and re-inserting it) fires it again. Bubbles and is composed.",
+              "inheritedFrom": {
+                "name": "AsyncElement",
+                "module": "src/async-element.ts"
+              }
+            }
+          ]
         }
       ],
       "exports": [

package/dist/entity-base.d.cts

@@ -0,0 +1,67 @@
+import type { Entity } from 'playcanvas';
+import type { AppElement } from './app.cjs';
+import { AsyncElement } from './async-element.cjs';
+/**
+ * The attribute names of the inline `onpointer*` event handlers, shared by every element that
+ * fronts an engine entity. Spread into `observedAttributes` by subclasses.
+ * @ignore
+ */
+declare const POINTER_ATTRIBUTES: readonly ["onpointerenter", "onpointerleave", "onpointerdown", "onpointerup", "onpointermove"];
+/**
+ * The base class for elements that front an engine {@link Entity}: `<pc-entity>`, which creates
+ * one, and `<pc-node>`, which binds to one inside a model's instantiated hierarchy. It carries
+ * what both need — the `entity` contract, registration with the owning application (which joins
+ * picked scene nodes back to elements by identity, never by name), and the pointer listener
+ * bookkeeping that lets the application lazily attach its canvas handlers.
+ */
+declare class EntityBaseElement extends AsyncElement {
+    protected _entity: Entity | null;
+    /**
+     * The application element this entity is registered with, cached at registration time so the
+     * entity can be unregistered even once this element has left the DOM.
+     */
+    protected _appElement: AppElement | null;
+    /**
+     * The pointer event listeners for the entity.
+     */
+    private _listeners;
+    /**
+     * The event types for which an inline `onpointer*` attribute is currently present.
+     */
+    private _inlineHandlerTypes;
+    /**
+     * The PlayCanvas entity instance. `null` until the element is ready, and again once the
+     * entity is gone — await {@link whenReady} or the element's `ready()` promise before
+     * accessing it.
+     * @returns The entity instance, or `null`.
+     */
+    get entity(): Entity | null;
+    /**
+     * Registers `entity` as this element's backing entity with the owning application, which
+     * joins engine nodes back to elements by identity (never by name).
+     *
+     * @param entity - The entity to register.
+     */
+    protected _registerEntity(entity: Entity): void;
+    /**
+     * Removes the registration for `entity`.
+     *
+     * @param entity - The entity to unregister.
+     */
+    protected _unregisterEntity(entity: Entity): void;
+    /**
+     * Tracks whether an inline `onpointer*` attribute is present. The browser itself compiles and
+     * runs these attributes — they are standard `GlobalEventHandlers`, so setting one replaces
+     * the previous handler and removing it removes the handler, exactly like `onclick` on any
+     * HTML element. But because they bypass {@link addEventListener}, the connect/disconnect
+     * bookkeeping that lets the application lazily attach its canvas pointer handlers must be
+     * kept in sync here.
+     *
+     * @param name - The attribute name (e.g. 'onpointerdown').
+     * @param value - The attribute value, or `null` when the attribute has been removed.
+     */
+    protected _updateInlineHandler(name: string, value: string | null): void;
+    addEventListener(type: string, listener: EventListener, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListener, options?: boolean | EventListenerOptions): void;
+}
+export { EntityBaseElement, POINTER_ATTRIBUTES };

package/dist/entity-base.d.ts

@@ -1,6 +1,6 @@
 import type { Entity } from 'playcanvas';
-import type { AppElement } from './app';
-import { AsyncElement } from './async-element';
+import type { AppElement } from './app.js';
+import { AsyncElement } from './async-element.js';
 /**
  * The attribute names of the inline `onpointer*` event handlers, shared by every element that
  * fronts an engine entity. Spread into `observedAttributes` by subclasses.

package/dist/entity.d.cts

@@ -0,0 +1,131 @@
+import { Vec3 } from 'playcanvas';
+import { EntityBaseElement } from './entity-base.cjs';
+/**
+ * The EntityElement interface provides properties and methods for manipulating
+ * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-entity/ | `<pc-entity>`} elements.
+ * The EntityElement interface also inherits the properties and methods of the
+ * {@link HTMLElement} interface.
+ *
+ * The pointer events below are dispatched by the containing `<pc-app>` element when the pointer
+ * intersects this entity's geometry. They are only generated while the entity has a listener for
+ * them, registered either with {@link addEventListener} or with the matching inline `onpointer*`
+ * attribute.
+ *
+ * @attribute {string} onpointerenter - Script to run when the pointer moves onto the entity.
+ * @attribute {string} onpointerleave - Script to run when the pointer moves off the entity.
+ * @attribute {string} onpointermove - Script to run when the pointer moves over the entity.
+ * @attribute {string} onpointerdown - Script to run when a pointer button is pressed over the
+ * entity.
+ * @attribute {string} onpointerup - Script to run when a pointer button is released over the
+ * entity.
+ * @fires {PointerEvent} pointerenter - Fired when the pointer moves onto the entity.
+ * @fires {PointerEvent} pointerleave - Fired when the pointer moves off the entity.
+ * @fires {PointerEvent} pointermove - Fired when the pointer moves over the entity.
+ * @fires {PointerEvent} pointerdown - Fired when a pointer button is pressed over the entity.
+ * @fires {PointerEvent} pointerup - Fired when a pointer button is released over the entity.
+ */
+declare class EntityElement extends EntityBaseElement {
+    /**
+     * Whether the entity is enabled.
+     */
+    private _enabled;
+    /**
+     * The name of the entity.
+     */
+    private _name;
+    /**
+     * The position of the entity.
+     */
+    private _position;
+    /**
+     * The rotation of the entity.
+     */
+    private _rotation;
+    /**
+     * The scale of the entity.
+     */
+    private _scale;
+    /**
+     * The tags of the entity.
+     */
+    private _tags;
+    /**
+     * Whether the hierarchy has been built for this entity.
+     */
+    private _built;
+    /**
+     * Handles the destruction of the backing entity. Resets the element so a later re-insertion
+     * starts clean: `_built` must be cleared alongside `_entity`, or _buildHierarchy would bail
+     * and a re-created entity would never be parented. Readiness is re-armed for the same
+     * reason — with the entity gone, a resolved ready promise would resume its awaiters against
+     * a null `entity`.
+     *
+     * @param entity - The entity that was destroyed.
+     */
+    private _onEntityDestroy;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /**
+     * Sets the enabled state of the entity.
+     * @param value - Whether the entity is enabled.
+     */
+    set enabled(value: boolean);
+    /**
+     * Gets the enabled state of the entity.
+     * @returns Whether the entity is enabled.
+     */
+    get enabled(): boolean;
+    /**
+     * Sets the name of the entity.
+     * @param value - The name of the entity.
+     */
+    set name(value: string);
+    /**
+     * Gets the name of the entity.
+     * @returns The name of the entity.
+     */
+    get name(): string;
+    /**
+     * Sets the position of the entity.
+     * @param value - The position of the entity.
+     */
+    set position(value: Vec3);
+    /**
+     * Gets the position of the entity.
+     * @returns The position of the entity.
+     */
+    get position(): Vec3;
+    /**
+     * Sets the rotation of the entity.
+     * @param value - The rotation of the entity.
+     */
+    set rotation(value: Vec3);
+    /**
+     * Gets the rotation of the entity.
+     * @returns The rotation of the entity.
+     */
+    get rotation(): Vec3;
+    /**
+     * Sets the scale of the entity.
+     * @param value - The scale of the entity.
+     */
+    set scale(value: Vec3);
+    /**
+     * Gets the scale of the entity.
+     * @returns The scale of the entity.
+     */
+    get scale(): Vec3;
+    /**
+     * Sets the tags of the entity.
+     * @param value - The tags of the entity.
+     */
+    set tags(value: string[]);
+    /**
+     * Gets the tags of the entity.
+     * @returns The tags of the entity.
+     */
+    get tags(): string[];
+    static get observedAttributes(): string[];
+    attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
+}
+export { EntityElement };

package/dist/entity.d.ts

@@ -1,5 +1,5 @@
 import { Vec3 } from 'playcanvas';
-import { EntityBaseElement } from './entity-base';
+import { EntityBaseElement } from './entity-base.js';
 /**
  * The EntityElement interface provides properties and methods for manipulating
  * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-entity/ | `<pc-entity>`} elements.