@vgai/engine 0.5.4 → 0.5.6

package/dist/ecs/scene-index.js

@@ -0,0 +1,331 @@
+/**
+ * `createSceneIndex` — the LIVE scene index (punchlist P2, `observe`).
+ *
+ * `scene-query.ts` answers "which objects carry tag X?" by walking the whole
+ * graph on every call, and it tells nobody when the answer changes. This
+ * module is the notified half: a tag/entity-id index kept current as objects
+ * join and leave the scene, plus the change signals a game needs so it never
+ * has to poll.
+ *
+ * ## The one event primitive is `EventTarget`
+ *
+ * There is no bus, no emitter class, no `subscribe()` returning a closure.
+ * `index.events` is a plain `EventTarget` dispatching `CustomEvent`s, and
+ * **unsubscribe is `AbortSignal`** — the platform's own answer:
+ *
+ * ```ts
+ * const ac = new AbortController();
+ * ctx.sceneIndex.events.addEventListener(
+ *   'tagadded',
+ *   (e) => console.log((e as SceneIndexEvent<'tagadded'>).detail.object.name),
+ *   { signal: ac.signal },
+ * );
+ * ac.abort(); // done — nothing to remember, nothing to leak
+ * ```
+ *
+ * {@link onSceneIndexEvent} is the same call with the detail typed for you.
+ * `index.eventsFor(obj)` is the per-object target (Roblox's `inst.Changed`):
+ * the same events, already filtered to one object, so a listener that only
+ * cares about one entity does not filter by hand.
+ *
+ * ## How the index stays live: three's own parent events, not a monkeypatch
+ *
+ * three r155+ dispatches `childadded`/`childremoved` on the **parent** from
+ * `Object3D.add`/`remove` (and therefore from `attach`, `clear`,
+ * `removeFromParent`, and R3F's reconciler, which all go through those two).
+ * The index subscribes to those two events on every object it indexes; on
+ * `childadded` it walks the new subtree, indexes it, and subscribes each
+ * node, and on `childremoved` it does the inverse. `Object3D.prototype` is
+ * NOT patched — nothing in this repo patches a library prototype.
+ *
+ * Consequences worth knowing:
+ *
+ * - **The quiet-frame cost is zero.** The index registers no system and runs
+ *   no per-frame reconcile; it does work only when three tells it something
+ *   moved. Nothing here ticks.
+ * - **Reparenting nets out to one entry.** `parent.add(obj)` removes `obj`
+ *   from its old parent first, so a move inside the indexed tree fires
+ *   `childremoved` then `childadded` — unindex, then index. The object ends
+ *   up indexed exactly once (and a listener sees an `entityremoved` followed
+ *   by an `entityadded`, which is the truth about what happened).
+ * - **Splicing `parent.children` by hand is invisible to the index**, because
+ *   it is invisible to three as well. Use `add`/`remove`.
+ *
+ * ## Tags are stored where they always were
+ *
+ * `addTag`/`removeTag` write the existing `userData['tags']` array, so
+ * `queryByTag` keeps returning the truth and nothing has to be migrated. The
+ * index is the fast, notified path over the same storage. A game that writes
+ * `userData['tags']` by hand gets a stale index — that is not prevented, it is
+ * repaired: call {@link SceneIndex.reindex} on the object.
+ *
+ * ## Attributes
+ *
+ * `getAttribute`/`setAttribute`/`deleteAttribute` are typed accessors over ONE
+ * new reserved userData key, `attributes` (registered in `ecs/user-data.ts`,
+ * `Record<string, string | number | boolean>`). They emit `attributechanged`
+ * only when the value actually changes, so a re-set of the same value is
+ * silent.
+ *
+ * ## What this deliberately does NOT do
+ *
+ * - **No property-level `Changed` on transforms.** three does not notify on
+ *   `position.set(...)`; faking it means diffing every transform every frame,
+ *   and a signal that is really a per-frame poll is worse than no signal —
+ *   it hides its own cost. Read the transform when you need it, or drive the
+ *   change from the code that made it.
+ * - **No `Touched`.** Contact/trigger events are Rapier's, dispatched through
+ *   `ctx.collisions.onCollision`. A second path would be a second truth.
+ * - **No 2D index.** This module indexes a three graph only.
+ */
+import { deleteUserData, getUserData, setUserData } from './user-data';
+/**
+ * `addEventListener` with the detail typed — the ONLY convenience over the
+ * platform call, and it returns nothing on purpose: unsubscribe stays
+ * `AbortSignal` (`{ signal }`), never a returned closure.
+ */
+export function onSceneIndexEvent(target, type, listener, options) {
+    target.addEventListener(type, (event) => {
+        const custom = event;
+        listener(custom.detail, custom);
+    }, options);
+}
+function readTags(obj) {
+    const tags = getUserData(obj, 'tags');
+    return Array.isArray(tags) ? tags : [];
+}
+function readAttributes(obj) {
+    const attributes = getUserData(obj, 'attributes');
+    return attributes && typeof attributes === 'object' ? attributes : undefined;
+}
+/**
+ * Build a live index over `root` and everything currently under it. One index
+ * per three root; the root adapter creates it and exposes it as
+ * `ctx.sceneIndex`.
+ */
+export function createSceneIndex(root) {
+    const events = new EventTarget();
+    // Weak on purpose: the per-object target exists only while something else
+    // still references the object. The index keeps NO map from target back to
+    // object, so a removed-and-forgotten object can be collected with its target.
+    const objectTargets = new WeakMap();
+    const indexed = new Set();
+    const tagged = new Map();
+    // Arrays, not single values: a project that mints the same entityId twice
+    // must not blind `byEntityId` for the survivor when one of them is removed.
+    const byId = new Map();
+    // The tag/id snapshot each object was indexed under, so unindexing (and
+    // `reindex`) can undo exactly what indexing did even if `userData` has been
+    // rewritten by hand in between.
+    const indexedTags = new WeakMap();
+    const indexedIds = new WeakMap();
+    let disposed = false;
+    function emit(type, detail) {
+        // Two distinct CustomEvent instances: one Event object cannot carry two
+        // `target`s, and re-dispatching a dispatched event is a spec footgun.
+        events.dispatchEvent(new CustomEvent(type, { detail }));
+        const perObject = objectTargets.get(detail.object);
+        if (perObject)
+            perObject.dispatchEvent(new CustomEvent(type, { detail }));
+    }
+    function addToTagIndex(obj, tag) {
+        let set = tagged.get(tag);
+        if (!set) {
+            set = new Set();
+            tagged.set(tag, set);
+        }
+        set.add(obj);
+    }
+    function removeFromTagIndex(obj, tag) {
+        const set = tagged.get(tag);
+        if (!set)
+            return;
+        set.delete(obj);
+        if (set.size === 0)
+            tagged.delete(tag);
+    }
+    function addToIdIndex(obj, id) {
+        const list = byId.get(id);
+        if (list) {
+            if (!list.includes(obj))
+                list.push(obj);
+        }
+        else {
+            byId.set(id, [obj]);
+        }
+    }
+    function removeFromIdIndex(obj, id) {
+        const list = byId.get(id);
+        if (!list)
+            return;
+        const at = list.indexOf(obj);
+        if (at !== -1)
+            list.splice(at, 1);
+        if (list.length === 0)
+            byId.delete(id);
+    }
+    const onChildAdded = (event) => {
+        indexSubtree(event.child);
+    };
+    const onChildRemoved = (event) => {
+        unindexSubtree(event.child);
+    };
+    /** Point the tag entries at whatever `userData['tags']` says right now,
+     *  undoing whatever the object was previously indexed under. */
+    function syncTags(obj) {
+        for (const tag of indexedTags.get(obj) ?? [])
+            removeFromTagIndex(obj, tag);
+        const tags = [...new Set(readTags(obj))];
+        indexedTags.set(obj, tags);
+        for (const tag of tags)
+            addToTagIndex(obj, tag);
+    }
+    /** Same, for the entity-id entry. */
+    function syncId(obj) {
+        const previous = indexedIds.get(obj);
+        if (previous !== undefined)
+            removeFromIdIndex(obj, previous);
+        indexedIds.delete(obj);
+        const id = getUserData(obj, 'entityId');
+        if (typeof id === 'string' && id !== '') {
+            indexedIds.set(obj, id);
+            addToIdIndex(obj, id);
+        }
+    }
+    function indexOne(obj) {
+        if (indexed.has(obj))
+            return;
+        indexed.add(obj);
+        // three's EventDispatcher de-dupes an identical (type, listener) pair, so
+        // this is idempotent even if an object somehow arrives twice.
+        obj.addEventListener('childadded', onChildAdded);
+        obj.addEventListener('childremoved', onChildRemoved);
+        syncTags(obj);
+        syncId(obj);
+        emit('entityadded', { object: obj });
+    }
+    function unindexOne(obj) {
+        if (!indexed.has(obj))
+            return;
+        indexed.delete(obj);
+        obj.removeEventListener('childadded', onChildAdded);
+        obj.removeEventListener('childremoved', onChildRemoved);
+        for (const tag of indexedTags.get(obj) ?? [])
+            removeFromTagIndex(obj, tag);
+        indexedTags.delete(obj);
+        const id = indexedIds.get(obj);
+        if (id !== undefined) {
+            removeFromIdIndex(obj, id);
+            indexedIds.delete(obj);
+        }
+        emit('entityremoved', { object: obj });
+    }
+    function indexSubtree(subtreeRoot) {
+        if (disposed)
+            return;
+        subtreeRoot.traverse(indexOne);
+    }
+    function unindexSubtree(subtreeRoot) {
+        if (disposed)
+            return;
+        // `traverse` still works on a detached subtree: `remove` only broke the
+        // link to the parent, the children below are intact.
+        subtreeRoot.traverse(unindexOne);
+    }
+    indexSubtree(root);
+    return {
+        events,
+        eventsFor(obj) {
+            let target = objectTargets.get(obj);
+            if (!target) {
+                target = new EventTarget();
+                objectTargets.set(obj, target);
+            }
+            return target;
+        },
+        byTag(tag) {
+            const set = tagged.get(tag);
+            return set ? [...set] : [];
+        },
+        byEntityId(id) {
+            return byId.get(id)?.[0];
+        },
+        has(obj) {
+            return indexed.has(obj);
+        },
+        addTag(obj, tag) {
+            const tags = readTags(obj);
+            if (tags.includes(tag))
+                return;
+            setUserData(obj, 'tags', [...tags, tag]);
+            if (indexed.has(obj)) {
+                indexedTags.set(obj, [...(indexedTags.get(obj) ?? []), tag]);
+                addToTagIndex(obj, tag);
+            }
+            emit('tagadded', { object: obj, tag });
+        },
+        removeTag(obj, tag) {
+            const tags = readTags(obj);
+            if (!tags.includes(tag))
+                return;
+            setUserData(obj, 'tags', tags.filter((t) => t !== tag));
+            if (indexed.has(obj)) {
+                indexedTags.set(obj, (indexedTags.get(obj) ?? []).filter((t) => t !== tag));
+                removeFromTagIndex(obj, tag);
+            }
+            emit('tagremoved', { object: obj, tag });
+        },
+        hasTag(obj, tag) {
+            return readTags(obj).includes(tag);
+        },
+        getAttribute(obj, name) {
+            return readAttributes(obj)?.[name];
+        },
+        setAttribute(obj, name, value) {
+            const attributes = readAttributes(obj);
+            const previous = attributes?.[name];
+            if (previous === value)
+                return;
+            if (attributes)
+                attributes[name] = value;
+            else
+                setUserData(obj, 'attributes', { [name]: value });
+            emit('attributechanged', { object: obj, name, value, previous });
+        },
+        deleteAttribute(obj, name) {
+            const attributes = readAttributes(obj);
+            if (!attributes || !(name in attributes))
+                return;
+            const previous = attributes[name];
+            delete attributes[name];
+            if (Object.keys(attributes).length === 0)
+                deleteUserData(obj, 'attributes');
+            emit('attributechanged', { object: obj, name, value: undefined, previous });
+        },
+        reindex(obj) {
+            if (disposed)
+                return;
+            obj.traverse((node) => {
+                if (indexed.has(node)) {
+                    syncTags(node);
+                    syncId(node);
+                }
+                else {
+                    indexOne(node);
+                }
+            });
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            for (const obj of indexed) {
+                obj.removeEventListener('childadded', onChildAdded);
+                obj.removeEventListener('childremoved', onChildRemoved);
+            }
+            indexed.clear();
+            tagged.clear();
+            byId.clear();
+        },
+    };
+}

package/dist/ecs/scene-query.d.ts

@@ -0,0 +1,6 @@
+import type * as THREE from 'three';
+/** All objects in the graph carrying the given tag (depth-first, document order). */
+export declare function queryByTag(root: THREE.Object3D, tag: string): THREE.Object3D[];
+/** All objects in the graph with the given name (depth-first, document order). */
+export declare function queryByName(root: THREE.Object3D, name: string): THREE.Object3D[];
+//# sourceMappingURL=scene-query.d.ts.map

package/dist/ecs/scene-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene-query.d.ts","sourceRoot":"","sources":["../../src/ecs/scene-query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AA0BpC,qFAAqF;AACrF,wBAAgB,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,QAAQ,EAAE,CAM9E;AAED,kFAAkF;AAClF,wBAAgB,WAAW,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC,QAAQ,EAAE,CAMhF"}

package/dist/ecs/scene-query.js

@@ -0,0 +1,40 @@
+import { getUserData } from './user-data';
+/**
+ * Runtime queries over a loaded THREE scene graph (P1.6d).
+ *
+ * These helpers walk a THREE.Object3D graph and read entity metadata off
+ * `userData`, so gameplay code can find objects by tag or name without
+ * bookkeeping its own indexes.
+ *
+ * Canonical metadata locations:
+ *   - tags:       `userData['tags']` (string[])
+ *   - name:       `Object3D.name`
+ *
+ * These are one-shot walks that notify nobody. For a repeated query, or for a
+ * signal when the answer changes, use the LIVE index instead —
+ * `ctx.sceneIndex` (`./scene-index.ts`): it reads the same `userData['tags']`
+ * storage, answers without traversing, and dispatches `entityadded`/
+ * `entityremoved`/`tagadded`/`tagremoved` on an `EventTarget`.
+ */
+function getTags(obj) {
+    const direct = getUserData(obj, 'tags');
+    return Array.isArray(direct) ? direct : [];
+}
+/** All objects in the graph carrying the given tag (depth-first, document order). */
+export function queryByTag(root, tag) {
+    const matches = [];
+    root.traverse((obj) => {
+        if (getTags(obj).includes(tag))
+            matches.push(obj);
+    });
+    return matches;
+}
+/** All objects in the graph with the given name (depth-first, document order). */
+export function queryByName(root, name) {
+    const matches = [];
+    root.traverse((obj) => {
+        if (obj.name === name)
+            matches.push(obj);
+    });
+    return matches;
+}

package/dist/ecs/user-data.d.ts

@@ -0,0 +1,193 @@
+/**
+ * Typed registry for `Object3D.userData` keys used by the engine and editor.
+ *
+ * Three.js lets any code stash arbitrary values on `object.userData`, and over
+ * time the engine + editor accumulated ~20 stringly-typed keys that together
+ * form a *parallel object model* — meaning carried entirely in undocumented
+ * string literals. This module is the ONE documented place that lists every
+ * such key, its value type, and what it means. All engine/editor-internal
+ * `userData` access for these keys must go through {@link getUserData} /
+ * {@link setUserData} / {@link hasUserData} / {@link deleteUserData} so the key
+ * strings live in exactly one place and are type-checked at every call site.
+ *
+ * NOTE: This covers engine/editor *internal* keys only. User game code in the
+ * example template may stash its own ad-hoc keys; those are out of scope.
+ *
+ * ## Key reference
+ *
+ * Serialization / identity (load-bearing — editor identity):
+ * - `entityId`            — the entity's stable string id. Presence also marks an
+ *                           Object3D as a "real" entity (vs editor helper/env object).
+ *
+ * Runtime scene-query metadata (read by `scene-query.ts` and `scene-index.ts`):
+ * - `tags`                — string[] tags for `queryByTag` and the live index.
+ * - `attributes`          — per-object `Record<string, string|number|boolean>`
+ *                           of game-defined attributes (P2 `observe`). Written
+ *                           through `SceneIndex.setAttribute`, which emits an
+ *                           `attributechanged` signal; JSON-simple values only,
+ *                           so an attribute survives serialization unchanged.
+ *
+ * Runtime gameplay metadata:
+ * - `forward`             — `[x,y,z]` model-space visual forward exported as
+ *                           ordinary glTF extras for asset-facing validation.
+ * - `navRole`             — `'walkable' | 'obstacle'` navmesh role; collected at runtime.
+ * - `pivot`              — `[x,y,z]` local-space pivot for rotate/scale-around-pivot.
+ * - `splineCurve`         — resolved THREE curve for a spline-following object.
+ * - `_camera`             — THREE.Camera owned by a camera entity (collected on load).
+ * - `_particleSystem`     — three.quarks ParticleSystem (scene-sync registration + census).
+ * - `gaussianSplat`       — native Spark splat metadata used for renderer discovery,
+ *                           inspector facts, bounds, and deterministic disposal.
+ *
+ * Animation (load-bearing — ED5 disposal contract):
+ * - `_animMixer`          — THREE.AnimationMixer driving this subtree's clips.
+ * - `_animClips`          — Map<string, AnimationClip> discovered on the GLTF (E5 —
+ *                           lets game code build its own XState-driven
+ *                           binding via `bindXStateAnimation` over the SAME
+ *                           mixer; see xstate-animation-binding.ts).
+ * - `_availableClips`     — string[] of clip names discovered on the GLTF
+ *                           (inspector dropdown; same names as `_animClips`' keys).
+ * - `_xstateAnimation`    — live native XState/Three binding exposed for
+ *                           play-mode inspection; removed when binding disposes.
+ *
+ * Disposal contract:
+ * - `__sharedGeometry`    — `true` when a mesh's geometry is shared/cached and MUST
+ *                           NOT be disposed by per-object cleanup (P0.2 contract).
+ *
+ * Editor shading overrides (editor-only, see `scene-sync.ts`):
+ * - `__shadeOrig`         — original material(s) stashed before a shading override.
+ * - `__shadeUnlit`        — generated unlit material(s) for the unlit view mode.
+ *
+ * Unmodified-game ingestion (editor-only, see `editor/src/ingest/`):
+ * - `__ingest`            — `true` on every Object3D minted by ingestion; routes
+ *                           edits to live mutation.
+ * - `__ingestNextId`      — monotonic id counter stashed on the captured Scene
+ *                           root so re-reflects keep minting unique ids.
+ *
+ * Editor scene-graph tagging (editor-only):
+ * - `engineInternal`      — `true` on engine-owned infrastructure in the game scene
+ *                           (particle BatchedRenderer, debug-draw + its subtree).
+ *                           The editor's play-mode hierarchy skips these so they
+ *                           don't show up as selectable "entities".
+ * - `authoringRoot`       — explicit opt-in for a runtime descendant to become
+ *                           its own authoring object instead of a part of the
+ *                           nearest ancestor owner.
+ * - `authoringInstance`   — source OID of the custom-component callsite that
+ *                           rendered this existing Object3D. Used to group
+ *                           implementation parts without adding wrappers.
+ * - `authoringLabel`      — authored literal name (or component tag fallback)
+ *                           for that source-backed component instance.
+ * - `editorHelper`        — `true` for editor-only helper objects (gizmos, wireframes).
+ * - `editorHelperType`    — which kind of helper (lights/particles/pivot/navmesh/...).
+ * - `editorIcon`          — `true` for editor billboard icon sprites.
+ * - `skeletonVisible`     — per-entity editor preference for its bone overlay.
+ * - `skeletonEnabled`     — resolved visibility preference on a skeleton helper.
+ * - `envObject`           — `true` for environment objects (ambient light, etc.).
+ * - `splineControlPoint`  — index of a spline control-point drag handle.
+ * - `vcDirIdx`            — view-cube face direction index (0=+X,1=-X,2=+Y,...).
+ */
+import type * as THREE from 'three';
+import type { ParticleSystem } from 'three.quarks';
+import type { XStateAnimationBinding } from '../animation/xstate-animation-binding';
+/** The kinds of editor helper objects tagged via `editorHelperType`. */
+export type EditorHelperType = 'lights' | 'cameras' | 'audio' | 'colliders' | 'joints' | 'lod' | 'splines' | 'particles' | 'particle-shape' | 'pivot' | 'navmesh' | 'skeletons';
+/**
+ * Maps each canonical accessor name to its value type. This is the single
+ * source of truth for what every known `userData` key holds.
+ */
+export interface UserDataSchema {
+    entityId: string;
+    forward: [number, number, number];
+    tags: string[];
+    attributes: Record<string, string | number | boolean>;
+    navRole: 'walkable' | 'obstacle';
+    pivot: [number, number, number];
+    splineCurve: THREE.Curve<THREE.Vector3>;
+    splineControlPoint: number;
+    _camera: THREE.Camera;
+    _particleSystem: ParticleSystem;
+    gaussianSplat: {
+        src: string;
+        numSplats: number;
+    };
+    _animMixer: THREE.AnimationMixer;
+    _animClips: Map<string, THREE.AnimationClip>;
+    _availableClips: string[];
+    _xstateAnimation: XStateAnimationBinding;
+    __sharedGeometry: boolean;
+    __shadeOrig: THREE.Material | THREE.Material[];
+    __shadeUnlit: THREE.Material[];
+    __ingest: boolean;
+    __ingestNextId: number;
+    engineInternal: boolean;
+    authoringRoot: boolean;
+    authoringInstance: string;
+    authoringLabel: string;
+    editorHelper: boolean;
+    editorHelperType: EditorHelperType;
+    editorIcon: boolean;
+    skeletonVisible: boolean;
+    skeletonEnabled: boolean;
+    envObject: boolean;
+    vcDirIdx: number;
+    /** W1a navmesh path-probe preview polyline: the routed waypoints, mirrored
+     *  onto the preview line Object3D so e2e can read the path back from the
+     *  scene graph (`EditorViewport.setNavPathPreview`). */
+    navPathPoints: {
+        x: number;
+        y: number;
+        z: number;
+    }[];
+}
+/** Any key in the typed registry. */
+export type UserDataKey = keyof UserDataSchema;
+/**
+ * Canonical name → literal `userData` string key. The accessor names match the
+ * raw string keys 1:1 (this is the documented set referenced by the AC), so the
+ * literal strings appear in exactly this one place.
+ */
+export declare const UserDataKeys: {
+    readonly entityId: "entityId";
+    readonly forward: "forward";
+    readonly tags: "tags";
+    readonly attributes: "attributes";
+    readonly navRole: "navRole";
+    readonly pivot: "pivot";
+    readonly splineCurve: "splineCurve";
+    readonly splineControlPoint: "splineControlPoint";
+    readonly _camera: "_camera";
+    readonly _particleSystem: "_particleSystem";
+    readonly gaussianSplat: "gaussianSplat";
+    readonly _animMixer: "_animMixer";
+    readonly _animClips: "_animClips";
+    readonly _availableClips: "_availableClips";
+    readonly _xstateAnimation: "_xstateAnimation";
+    readonly __sharedGeometry: "__sharedGeometry";
+    readonly __shadeOrig: "__shadeOrig";
+    readonly __shadeUnlit: "__shadeUnlit";
+    readonly __ingest: "__ingest";
+    readonly __ingestNextId: "__ingestNextId";
+    readonly engineInternal: "engineInternal";
+    readonly authoringRoot: "authoringRoot";
+    readonly authoringInstance: "authoringInstance";
+    readonly authoringLabel: "authoringLabel";
+    readonly editorHelper: "editorHelper";
+    readonly editorHelperType: "editorHelperType";
+    readonly editorIcon: "editorIcon";
+    readonly skeletonVisible: "skeletonVisible";
+    readonly skeletonEnabled: "skeletonEnabled";
+    readonly envObject: "envObject";
+    readonly vcDirIdx: "vcDirIdx";
+    readonly navPathPoints: "navPathPoints";
+};
+/**
+ * Read a typed `userData` value. Returns `undefined` when the key is unset or
+ * when `obj` is nullish (so call sites can pass an optionally-resolved object).
+ */
+export declare function getUserData<K extends UserDataKey>(obj: THREE.Object3D | null | undefined, key: K): UserDataSchema[K] | undefined;
+/** Write a typed `userData` value. */
+export declare function setUserData<K extends UserDataKey>(obj: THREE.Object3D, key: K, value: UserDataSchema[K]): void;
+/** True when `key` is set (not `undefined`) on the object's `userData`. */
+export declare function hasUserData(obj: THREE.Object3D | null | undefined, key: UserDataKey): boolean;
+/** Remove a `userData` key. */
+export declare function deleteUserData(obj: THREE.Object3D, key: UserDataKey): void;
+//# sourceMappingURL=user-data.d.ts.map

package/dist/ecs/user-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-data.d.ts","sourceRoot":"","sources":["../../src/ecs/user-data.ts"],"names":[],"mappings":"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"}