@viamrobotics/motion-tools 1.26.1 → 1.26.2

package/dist/ecs/provideWorldMatrix.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Mount the world-matrix reactor: keeps `WorldMatrix` in sync with the
+ * cumulative `parent.WorldMatrix × local rendered` for every entity whose
+ * `Matrix` / `EditedMatrix` / `LiveMatrix` / `Scale` / `ChildOf` changes.
+ * Microtask-deferred so a burst of changes (e.g. one `useFrames` reconcile
+ * tick) coalesces into a single subtree walk.
+ */
+export declare const provideWorldMatrix: () => void;

package/dist/ecs/provideWorldMatrix.svelte.js

@@ -0,0 +1,13 @@
+import { useWorld } from './useWorld';
+import { installWorldMatrixListeners } from './worldMatrix';
+/**
+ * Mount the world-matrix reactor: keeps `WorldMatrix` in sync with the
+ * cumulative `parent.WorldMatrix × local rendered` for every entity whose
+ * `Matrix` / `EditedMatrix` / `LiveMatrix` / `Scale` / `ChildOf` changes.
+ * Microtask-deferred so a burst of changes (e.g. one `useFrames` reconcile
+ * tick) coalesces into a single subtree walk.
+ */
+export const provideWorldMatrix = () => {
+    const world = useWorld();
+    $effect(() => installWorldMatrixListeners(world));
+};

package/dist/ecs/traits.d.ts

@@ -1,7 +1,7 @@
 import type { GLTF as ThreeGltf } from 'three/examples/jsm/loaders/GLTFLoader.js';
 import { Geometry as ViamGeometry } from '@viamrobotics/sdk';
 import { type Entity } from 'koota';
-import { BufferGeometry as ThreeBufferGeometry } from 'three';
+import { Matrix4, BufferGeometry as ThreeBufferGeometry } from 'three';
 export declare const Name: import("koota").Trait<() => string>;
 export declare const UUID: import("koota").Trait<() => string>;
 /**
@@ -12,33 +12,12 @@ export declare const UUID: import("koota").Trait<() => string>;
  * adding this trait directly.
  */
 export declare const Orphan: import("koota").Trait<() => string>;
-export declare const Pose: import("koota").Trait<{
-    x: number;
-    y: number;
-    z: number;
-    oX: number;
-    oY: number;
-    oZ: number;
-    theta: number;
-}>;
-export declare const EditedPose: import("koota").Trait<{
-    x: number;
-    y: number;
-    z: number;
-    oX: number;
-    oY: number;
-    oZ: number;
-    theta: number;
-}>;
-export declare const LivePose: import("koota").Trait<{
-    x: number;
-    y: number;
-    z: number;
-    oX: number;
-    oY: number;
-    oZ: number;
-    theta: number;
-}>;
+/**
+ * Static positional offset (e.g. center of a geometry). Stored as a Pose
+ * for the rare cases that need OV+theta semantics (currently unused).
+ * Never composed through the parent chain — the `WorldMatrix` system
+ * doesn't read it.
+ */
 export declare const Center: import("koota").Trait<{
     x: number;
     y: number;
@@ -48,25 +27,42 @@ export declare const Center: import("koota").Trait<{
     oZ: number;
     theta: number;
 }>;
-export declare const InstancedPose: import("koota").Trait<{
-    x: number;
-    y: number;
-    z: number;
-    oX: number;
-    oY: number;
-    oZ: number;
-    theta: number;
+/**
+ * Local-to-parent transform. Stored AoS — one `Matrix4` instance per entity —
+ * not as 16 SoA fields. Every consumer reads all 16 elements of one entity at
+ * a time (`Object3D.matrix.copy`, batched-mesh per-instance writes, the
+ * world-matrix walk). SoA would allocate a fresh 16-field object on every
+ * `entity.get(Matrix)`; AoS returns the `Matrix4` reference, zero allocation
+ * per read, and plugs straight into Three.js. The trade-off — losing
+ * column-iteration locality — is fine because no system iterates a single
+ * matrix element across entities.
+ *
+ * Update pattern: read the `Matrix4` and mutate in place, then call
+ * `entity.changed(Matrix)` so `onChange` listeners (the `WorldMatrix` system,
+ * etc.) fire. Allocate a fresh `Matrix4` only on add.
+ */
+export declare const Matrix: import("koota").Trait<() => Matrix4>;
+/** User-staged local transform during a `FrameEditSession`. */
+export declare const EditedMatrix: import("koota").Trait<() => Matrix4>;
+/**
+ * Live local transform from the robot's kinematics. Composed with `Matrix`
+ * (network baseline) and `EditedMatrix` to produce the rendered transform.
+ */
+export declare const LiveMatrix: import("koota").Trait<() => Matrix4>;
+/**
+ * Cumulative world-space transform — `parent.WorldMatrix × local rendered`.
+ * Maintained by `provideWorldMatrix`. Read by hover label placement,
+ * batched-mesh population, and any other consumer that needs world-space.
+ */
+export declare const WorldMatrix: import("koota").Trait<() => Matrix4>;
+/**
+ * World-space transform of a hovered instance inside a points/arrows batch,
+ * paired with the instance index in the parent batched mesh.
+ */
+export declare const InstancedMatrix: import("koota").Trait<() => {
+    matrix: Matrix4;
     index: number;
 }>;
-export declare const WorldPose: import("koota").Trait<{
-    x: number;
-    y: number;
-    z: number;
-    oX: number;
-    oY: number;
-    oZ: number;
-    theta: number;
-}>;
 export declare const Hovered: import("koota").Trait<() => boolean>;
 export declare const Invisible: import("koota").Trait<() => boolean>;
 /**

package/dist/ecs/traits.js

@@ -1,6 +1,6 @@
 import { Geometry as ViamGeometry } from '@viamrobotics/sdk';
 import { trait } from 'koota';
-import { BufferGeometry as ThreeBufferGeometry } from 'three';
+import { Matrix4, BufferGeometry as ThreeBufferGeometry } from 'three';
 import { createBufferGeometry, updateBufferGeometry } from '../attribute';
 import { ColorFormat } from '../buf/draw/v1/metadata_pb';
 import { createBox, createCapsule, createSphere } from '../geometry';
@@ -16,29 +16,49 @@ export const UUID = trait(() => '');
  * adding this trait directly.
  */
 export const Orphan = trait(() => '');
-export const Pose = trait({ x: 0, y: 0, z: 0, oX: 0, oY: 0, oZ: 1, theta: 0 });
-export const EditedPose = trait({ x: 0, y: 0, z: 0, oX: 0, oY: 0, oZ: 1, theta: 0 });
-export const LivePose = trait({ x: 0, y: 0, z: 0, oX: 0, oY: 0, oZ: 1, theta: 0 });
+/**
+ * Static positional offset (e.g. center of a geometry). Stored as a Pose
+ * for the rare cases that need OV+theta semantics (currently unused).
+ * Never composed through the parent chain — the `WorldMatrix` system
+ * doesn't read it.
+ */
 export const Center = trait({ x: 0, y: 0, z: 0, oX: 0, oY: 0, oZ: 1, theta: 0 });
-export const InstancedPose = trait({
-    x: 0,
-    y: 0,
-    z: 0,
-    oX: 0,
-    oY: 0,
-    oZ: 1,
-    theta: 0,
+/**
+ * Local-to-parent transform. Stored AoS — one `Matrix4` instance per entity —
+ * not as 16 SoA fields. Every consumer reads all 16 elements of one entity at
+ * a time (`Object3D.matrix.copy`, batched-mesh per-instance writes, the
+ * world-matrix walk). SoA would allocate a fresh 16-field object on every
+ * `entity.get(Matrix)`; AoS returns the `Matrix4` reference, zero allocation
+ * per read, and plugs straight into Three.js. The trade-off — losing
+ * column-iteration locality — is fine because no system iterates a single
+ * matrix element across entities.
+ *
+ * Update pattern: read the `Matrix4` and mutate in place, then call
+ * `entity.changed(Matrix)` so `onChange` listeners (the `WorldMatrix` system,
+ * etc.) fire. Allocate a fresh `Matrix4` only on add.
+ */
+export const Matrix = trait(() => new Matrix4());
+/** User-staged local transform during a `FrameEditSession`. */
+export const EditedMatrix = trait(() => new Matrix4());
+/**
+ * Live local transform from the robot's kinematics. Composed with `Matrix`
+ * (network baseline) and `EditedMatrix` to produce the rendered transform.
+ */
+export const LiveMatrix = trait(() => new Matrix4());
+/**
+ * Cumulative world-space transform — `parent.WorldMatrix × local rendered`.
+ * Maintained by `provideWorldMatrix`. Read by hover label placement,
+ * batched-mesh population, and any other consumer that needs world-space.
+ */
+export const WorldMatrix = trait(() => new Matrix4());
+/**
+ * World-space transform of a hovered instance inside a points/arrows batch,
+ * paired with the instance index in the parent batched mesh.
+ */
+export const InstancedMatrix = trait(() => ({
+    matrix: new Matrix4(),
     index: -1,
-});
-export const WorldPose = trait({
-    x: 0,
-    y: 0,
-    z: 0,
-    oX: 0,
-    oY: 0,
-    oZ: 1,
-    theta: 0,
-});
+}));
 export const Hovered = trait(() => true);
 export const Invisible = trait(() => true);
 /**
@@ -174,30 +194,39 @@ export const updateGeometryTrait = (entity, geometry) => {
         return;
     }
     if (geometry.geometryType.case === 'box') {
+        const next = createBox(geometry.geometryType.value);
         if (entity.has(Box)) {
-            entity.set(Box, createBox(geometry.geometryType.value));
+            const cur = entity.get(Box);
+            if (cur.x !== next.x || cur.y !== next.y || cur.z !== next.z)
+                entity.set(Box, next);
         }
         else {
             entity.remove(Capsule, Sphere, BufferGeometry);
-            entity.add(Box(createBox(geometry.geometryType.value)));
+            entity.add(Box(next));
         }
     }
     else if (geometry.geometryType.case === 'capsule') {
+        const next = createCapsule(geometry.geometryType.value);
         if (entity.has(Capsule)) {
-            entity.set(Capsule, createCapsule(geometry.geometryType.value));
+            const cur = entity.get(Capsule);
+            if (cur.r !== next.r || cur.l !== next.l)
+                entity.set(Capsule, next);
         }
         else {
             entity.remove(Box, Sphere, BufferGeometry);
-            entity.add(Capsule(createCapsule(geometry.geometryType.value)));
+            entity.add(Capsule(next));
         }
     }
     else if (geometry.geometryType.case === 'sphere') {
+        const next = createSphere(geometry.geometryType.value);
         if (entity.has(Sphere)) {
-            entity.set(Sphere, createSphere(geometry.geometryType.value));
+            const cur = entity.get(Sphere);
+            if (cur.r !== next.r)
+                entity.set(Sphere, next);
         }
         else {
             entity.remove(Box, Capsule, BufferGeometry);
-            entity.add(Sphere(createSphere(geometry.geometryType.value)));
+            entity.add(Sphere(next));
         }
     }
     else if (geometry.geometryType.case === 'mesh') {

package/dist/ecs/useTrait.svelte.d.ts

@@ -6,14 +6,9 @@ type Schema = {
 type TraitRecordFromSchema<T extends Schema> = T extends AoSFactory ? ReturnType<T> : {
     [P in keyof T]: T[P] extends (...args: never[]) => unknown ? ReturnType<T[P]> : T[P];
 };
-/**
- * The record of a trait.
- * For SoA it is a snapshot of the state for a single entity.
- * For AoS it is the state instance for a single entity.
- */
 type TraitRecord<T extends Trait | Schema> = T extends Trait ? TraitRecordFromSchema<T['schema']> : TraitRecordFromSchema<T>;
 export declare function isWorld(target: Entity | World | null | undefined): target is World;
 export declare function useTrait<T extends Trait>(target: () => Entity | World | undefined | null, trait: T): {
-    current: TraitRecord<T> | undefined;
+    readonly current: TraitRecord<T> | undefined;
 };
 export {};

package/dist/ecs/useTrait.svelte.js

@@ -1,30 +1,37 @@
 import { $internal as internal } from 'koota';
+import { untrack } from 'svelte';
 import { useWorld } from './useWorld';
 export function isWorld(target) {
     return typeof target?.spawn === 'function';
 }
 export function useTrait(target, trait) {
     const contextWorld = useWorld();
-    const targetEntity = $derived(target());
-    const world = $derived(isWorld(targetEntity) ? targetEntity : contextWorld);
-    const entity = $derived(isWorld(targetEntity) ? targetEntity[internal].worldEntity : targetEntity);
-    // Initialize the state with the current value of the trait.
-    let value = $derived(entity?.get(trait));
+    let value = $state.raw();
+    // Version counter to force reactivity when the value reference is the same (AoS traits).
+    // Only read in the getter, never in the effect.
+    let version = $state(0);
     $effect(() => {
-        const onAddUnsub = world.onAdd(trait, (e) => {
+        const t = target();
+        if (!t) {
+            value = undefined;
+            return;
+        }
+        const world = isWorld(t) ? t : contextWorld;
+        const entity = isWorld(t) ? t[internal].worldEntity : t;
+        value = entity.has(trait) ? entity.get(trait) : undefined;
+        const onChangeUnsub = world.onChange(trait, (e) => {
             if (e === entity) {
                 value = e.get(trait);
+                untrack(() => version++);
             }
         });
+        const onAddUnsub = world.onAdd(trait, (e) => {
+            if (e === entity)
+                value = e.get(trait);
+        });
         const onRemoveUnsub = world.onRemove(trait, (e) => {
-            if (e === entity) {
+            if (e === entity)
                 value = undefined;
-            }
-        });
-        const onChangeUnsub = world.onChange(trait, (e) => {
-            if (e === entity) {
-                value = e.get(trait);
-            }
         });
         return () => {
             onChangeUnsub();
@@ -34,6 +41,7 @@ export function useTrait(target, trait) {
     });
     return {
         get current() {
+            void version;
             return value;
         },
     };

package/dist/ecs/worldMatrix.d.ts

@@ -0,0 +1,10 @@
+import { type World } from 'koota';
+/**
+ * Wire up listeners that maintain `WorldMatrix` reactively. Subscribes to
+ * add/change/remove on `Matrix`, `EditedMatrix`, `LiveMatrix`, `Scale`, and
+ * `ChildOf`; enqueues affected entities and flushes on the next microtask.
+ *
+ * Returns an unsubscribe function. Plain function (not a rune hook) so tests
+ * can drive the lifecycle without mounting Svelte.
+ */
+export declare const installWorldMatrixListeners: (world: World) => (() => void);

package/dist/ecs/worldMatrix.js

@@ -0,0 +1,148 @@
+import {} from 'koota';
+import { Matrix4, Vector3 } from 'three';
+import { composeLocalMatrix } from '../transform';
+import { ChildOf } from './relations';
+import { EditedMatrix, LiveMatrix, Matrix, Scale, WorldMatrix } from './traits';
+const scaleVec3 = new Vector3();
+/**
+ * Compute the entity's local-to-parent transform into `out`. Mirrors the
+ * blend used by `Frame.svelte` so `WorldMatrix` agrees with the displayed
+ * scenegraph.
+ *
+ * - All three matrix traits present: `live × baseline⁻¹ × edited`.
+ * - Otherwise: prefer `EditedMatrix` over `Matrix`.
+ *
+ * Returns `true` after writing to `out`; returns `false` and leaves `out`
+ * untouched when the entity has no matrix-shaped trait.
+ */
+const toLocalMatrix = (entity, out) => {
+    const matrix = entity.get(Matrix);
+    const editedMatrix = entity.get(EditedMatrix);
+    const liveMatrix = entity.get(LiveMatrix);
+    if (liveMatrix && matrix && editedMatrix) {
+        composeLocalMatrix(liveMatrix, matrix, editedMatrix, out);
+        return true;
+    }
+    if (editedMatrix) {
+        out.copy(editedMatrix);
+        return true;
+    }
+    if (matrix) {
+        out.copy(matrix);
+        return true;
+    }
+    return false;
+};
+/**
+ * Synchronously compute and write `WorldMatrix` for every entity in `dirty`
+ * and every descendant via `ChildOf`. Memoizes per-entity world matrices in
+ * `cache` so siblings reuse a parent's result. Caller passes a fresh `cache`
+ * map per flush.
+ */
+const recomputeWorldMatrix = (world, entity, cache) => {
+    if (!entity.isAlive())
+        return undefined;
+    const cached = cache.get(entity);
+    if (cached)
+        return cached;
+    // Reuse the entity's existing `WorldMatrix` storage when present so a
+    // flush doesn't allocate a throwaway matrix per entity. First-time
+    // entities get a fresh `Matrix4` that's added as the trait below.
+    const out = entity.get(WorldMatrix) ?? new Matrix4();
+    const hasLocal = toLocalMatrix(entity, out);
+    if (!hasLocal)
+        out.identity();
+    const scale = entity.get(Scale);
+    if (scale) {
+        out.scale(scaleVec3.copy(scale));
+    }
+    const parent = entity.targetFor(ChildOf);
+    if (parent && parent.isAlive()) {
+        const parentWorld = recomputeWorldMatrix(world, parent, cache);
+        if (parentWorld)
+            out.premultiply(parentWorld);
+    }
+    cache.set(entity, out);
+    return out;
+};
+const flushDirty = (world, dirty) => {
+    if (dirty.size === 0)
+        return;
+    const cache = new Map();
+    const expanded = new Set();
+    const collect = (entity) => {
+        if (expanded.has(entity))
+            return;
+        expanded.add(entity);
+        for (const child of world.query(ChildOf(entity))) {
+            collect(child);
+        }
+    };
+    for (const entity of dirty)
+        collect(entity);
+    dirty.clear();
+    for (const entity of expanded) {
+        if (!entity.isAlive())
+            continue;
+        const worldMat = recomputeWorldMatrix(world, entity, cache);
+        if (!worldMat)
+            continue;
+        if (entity.has(WorldMatrix)) {
+            entity.changed(WorldMatrix);
+        }
+        else {
+            entity.add(WorldMatrix(worldMat));
+        }
+    }
+};
+/**
+ * Wire up listeners that maintain `WorldMatrix` reactively. Subscribes to
+ * add/change/remove on `Matrix`, `EditedMatrix`, `LiveMatrix`, `Scale`, and
+ * `ChildOf`; enqueues affected entities and flushes on the next microtask.
+ *
+ * Returns an unsubscribe function. Plain function (not a rune hook) so tests
+ * can drive the lifecycle without mounting Svelte.
+ */
+export const installWorldMatrixListeners = (world) => {
+    const dirty = new Set();
+    let scheduled = false;
+    const enqueue = (entity) => {
+        dirty.add(entity);
+        if (scheduled)
+            return;
+        scheduled = true;
+        queueMicrotask(() => {
+            scheduled = false;
+            flushDirty(world, dirty);
+        });
+    };
+    for (const entity of world.query(Matrix))
+        enqueue(entity);
+    for (const entity of world.query(EditedMatrix))
+        enqueue(entity);
+    for (const entity of world.query(LiveMatrix))
+        enqueue(entity);
+    for (const entity of world.query(Scale))
+        enqueue(entity);
+    const unsubs = [
+        world.onAdd(Matrix, enqueue),
+        world.onChange(Matrix, enqueue),
+        world.onRemove(Matrix, enqueue),
+        world.onAdd(EditedMatrix, enqueue),
+        world.onChange(EditedMatrix, enqueue),
+        world.onRemove(EditedMatrix, enqueue),
+        world.onAdd(LiveMatrix, enqueue),
+        world.onChange(LiveMatrix, enqueue),
+        world.onRemove(LiveMatrix, enqueue),
+        world.onAdd(Scale, enqueue),
+        world.onChange(Scale, enqueue),
+        world.onRemove(Scale, enqueue),
+        world.onAdd(ChildOf, enqueue),
+        world.onChange(ChildOf, enqueue),
+        world.onRemove(ChildOf, enqueue),
+    ];
+    return () => {
+        for (const unsub of unsubs)
+            unsub();
+    };
+};

package/dist/editing/FrameEditSession.js

@@ -1,5 +1,6 @@
 import { hierarchy, traits } from '../ecs';
-import { isFinitePose } from '../transform';
+import { createPose, isFinitePose, matrixToPose, poseToMatrix } from '../transform';
+const tempPose = createPose();
 const captureGeometry = (entity) => {
     const box = entity.get(traits.Box);
     if (box)
@@ -71,13 +72,14 @@ export class FrameEditSession {
         this.onClose = onClose;
         for (const entity of entities) {
             const name = entity.get(traits.Name);
-            const editedPose = entity.get(traits.EditedPose);
-            if (!name || !editedPose)
+            const editedMatrix = entity.get(traits.EditedMatrix);
+            if (!name || !editedMatrix)
                 continue;
+            matrixToPose(editedMatrix, tempPose);
             this.snapshots.set(entity, {
                 name,
                 parent: hierarchy.getParentName(entity) ?? 'world',
-                editedPose: { ...editedPose },
+                editedPose: { ...tempPose },
                 geometry: captureGeometry(entity),
             });
         }
@@ -92,11 +94,13 @@ export class FrameEditSession {
         const snap = this.snapshots.get(entity);
         if (!snap || this.#closed)
             return;
-        const current = entity.get(traits.EditedPose);
+        const current = entity.get(traits.EditedMatrix);
         if (!current)
             return;
-        const next = { ...current, ...pose };
-        entity.set(traits.EditedPose, next);
+        matrixToPose(current, tempPose);
+        const next = { ...tempPose, ...pose };
+        poseToMatrix(next, current);
+        entity.changed(traits.EditedMatrix);
         this.updateFrame(snap.name, hierarchy.getParentName(entity) ?? 'world', next, liveGeometry(entity));
     };
     stageGeometry = (entity, geometry) => {
@@ -116,9 +120,10 @@ export class FrameEditSession {
         else if (geometry.type === 'capsule') {
             restoreGeometryTrait(entity, { type: 'capsule', capsule: { r: geometry.r, l: geometry.l } });
         }
-        const editedPose = entity.get(traits.EditedPose);
-        if (editedPose) {
-            this.updateFrame(snap.name, hierarchy.getParentName(entity) ?? 'world', editedPose, geometry);
+        const editedMatrix = entity.get(traits.EditedMatrix);
+        if (editedMatrix) {
+            matrixToPose(editedMatrix, tempPose);
+            this.updateFrame(snap.name, hierarchy.getParentName(entity) ?? 'world', { ...tempPose }, geometry);
         }
     };
     stageParent = (entity, parent) => {
@@ -126,9 +131,10 @@ export class FrameEditSession {
         if (!snap || this.#closed)
             return;
         hierarchy.setParent(entity, parent === 'world' ? undefined : parent);
-        const editedPose = entity.get(traits.EditedPose);
-        if (editedPose) {
-            this.updateFrame(snap.name, parent, editedPose, liveGeometry(entity));
+        const editedMatrix = entity.get(traits.EditedMatrix);
+        if (editedMatrix) {
+            matrixToPose(editedMatrix, tempPose);
+            this.updateFrame(snap.name, parent, { ...tempPose }, liveGeometry(entity));
         }
     };
     stageDelete = (entity) => {
@@ -145,10 +151,13 @@ export class FrameEditSession {
         if (this.#closed)
             return false;
         for (const [entity] of this.snapshots) {
-            const pose = entity.get(traits.EditedPose);
-            if (pose && !isFinitePose(pose)) {
-                this.abort();
-                return false;
+            const matrix = entity.get(traits.EditedMatrix);
+            if (matrix) {
+                matrixToPose(matrix, tempPose);
+                if (!isFinitePose(tempPose)) {
+                    this.abort();
+                    return false;
+                }
             }
         }
         this.#close();
@@ -163,7 +172,11 @@ export class FrameEditSession {
             return;
         for (const [entity, snap] of this.snapshots) {
             if (entity.isAlive()) {
-                entity.set(traits.EditedPose, snap.editedPose);
+                const matrix = entity.get(traits.EditedMatrix);
+                if (matrix) {
+                    poseToMatrix(snap.editedPose, matrix);
+                    entity.changed(traits.EditedMatrix);
+                }
                 hierarchy.setParent(entity, snap.parent === 'world' ? undefined : snap.parent);
                 restoreGeometryTrait(entity, snap.geometry);
             }

package/dist/hooks/use3DModels.svelte.js

@@ -48,13 +48,13 @@ export const provide3DModels = (partID) => {
                         }
                     });
                 }
-                current = next;
             }
             catch (error) {
                 // some arms may not implement this api yet
                 console.warn(`${client.current.name} returned an error: ${error} when getting 3D models`);
             }
         }
+        current = next;
     };
     $effect(() => {
         const shouldFetchModels = settings.isLoaded && settings.current.renderArmModels.includes('model');

package/dist/hooks/useConfigFrames.svelte.js

@@ -57,6 +57,18 @@ export const provideConfigFrames = () => {
     const frameValues = $derived(Object.values(frames));
     const getParentFrameOptions = (componentName) => {
         const validFrames = new Set(frameValues.map((frame) => frame.referenceFrame));
+        /**
+         * Fragment components without a mod don't appear in frameValues (we only
+         * track frames with explicit $set mods), but the fragment itself supplies
+         * their frame so they render in the scene and are valid parents. Exclude
+         * any whose frame the user has $unset.
+         */
+        const unsetFragmentNames = new Set(fragmentUnsetFrameNames);
+        for (const name of Object.keys(partConfig.componentNameToFragmentId)) {
+            if (!unsetFragmentNames.has(name)) {
+                validFrames.add(name);
+            }
+        }
         validFrames.add('world');
         const frameNameQueue = [componentName];
         while (frameNameQueue.length > 0) {