@viamrobotics/motion-tools 1.34.4 → 1.34.6

package/dist/components/Entities/Mesh.svelte

@@ -2,15 +2,13 @@
 	module
 	lang="ts"
 >
-	import { BoxGeometry, EdgesGeometry, SphereGeometry } from 'three'
+	import { EdgesGeometry, SphereGeometry } from 'three'
 
 	/**
 	 * Shared unit geometries — every mesh references these and sets
 	 * dimensions through `mesh.scale`, so resizing never rebuilds GPU buffers.
 	 */
-	const unitBox = new BoxGeometry(1, 1, 1)
 	const unitSphere = new SphereGeometry(1, 16, 12)
-	const unitBoxEdges = new EdgesGeometry(unitBox, 0)
 	const unitSphereEdges = new EdgesGeometry(unitSphere, 0)
 </script>
 
@@ -27,7 +25,6 @@
 	import { traits, useTrait } from '../../ecs'
 	import { poseToObject3d } from '../../transform'
 
-	import AxesHelper from '../AxesHelper.svelte'
 	import Capsule from './Capsule.svelte'
 
 	interface Props extends Omit<ThrelteProps<Mesh>, 'ref'> {
@@ -46,11 +43,9 @@
 	const entityColors = useTrait(() => entity, traits.Colors)
 	const entityColor = useTrait(() => entity, traits.Color)
 	const opacity = useTrait(() => entity, traits.Opacity)
-	const box = useTrait(() => entity, traits.Box)
 	const capsule = useTrait(() => entity, traits.Capsule)
 	const sphere = useTrait(() => entity, traits.Sphere)
 	const bufferGeometry = useTrait(() => entity, traits.BufferGeometry)
-	const showAxesHelper = useTrait(() => entity, traits.ShowAxesHelper)
 	const materialProps = useTrait(() => entity, traits.Material)
 	const renderOrder = useTrait(() => entity, traits.RenderOrder)
 
@@ -98,10 +93,7 @@
 	})
 
 	$effect(() => {
-		if (box.current) {
-			const { x, y, z } = box.current
-			mesh.scale.set(x * 0.001, y * 0.001, z * 0.001)
-		} else if (sphere.current) {
+		if (sphere.current) {
 			mesh.scale.setScalar((sphere.current.r ?? 0) * 0.001)
 		} else {
 			mesh.scale.set(1, 1, 1)
@@ -137,9 +129,7 @@
 		renderOrder={renderOrder.current}
 		{...rest}
 	>
-		{#if box.current || sphere.current}
-			{@const meshGeometry = box.current ? unitBox : unitSphere}
-			{@const edgesGeometry = box.current ? unitBoxEdges : unitSphereEdges}
+		{#if sphere.current}
 			<!--
 				Switch via a derived `is` on the same <T> so `useAttach`'s effect
 				cleanup runs before the new attach. Splitting these across two
@@ -148,7 +138,7 @@
 				it to the pre-attach value (null), leaving the mesh geometryless.
 			-->
 			<T
-				is={meshGeometry}
+				is={unitSphere}
 				dispose={false}
 			/>
 			<T.LineSegments
@@ -156,7 +146,7 @@
 				bvh={{ enabled: false }}
 			>
 				<T
-					is={edgesGeometry}
+					is={unitSphereEdges}
 					dispose={false}
 				/>
 				<T.LineBasicMaterial color={darkenColor(color, 10)} />
@@ -193,11 +183,3 @@
 		{@render children?.()}
 	</T>
 {/if}
-
-{#if showAxesHelper.current}
-	<AxesHelper
-		name={entity}
-		width={3}
-		length={0.1}
-	/>
-{/if}

package/dist/components/Entities/Points.svelte

@@ -9,7 +9,6 @@
 	import { traits, useTrait } from '../../ecs'
 	import { useSettings } from '../../hooks/useSettings.svelte'
 
-	import AxesHelper from '../AxesHelper.svelte'
 	import { useEntityEvents } from './hooks/useEntityEvents.svelte'
 
 	interface Props {
@@ -29,7 +28,6 @@
 	const entityPointSize = useTrait(() => entity, traits.PointSize)
 	const opacity = useTrait(() => entity, traits.Opacity)
 	const invisible = useTrait(() => entity, traits.InheritedInvisible)
-	const showAxesHelper = useTrait(() => entity, traits.ShowAxesHelper)
 	const renderOrder = useTrait(() => entity, traits.RenderOrder)
 	const materialProps = useTrait(() => entity, traits.Material)
 
@@ -134,13 +132,7 @@
 	>
 		<T is={geometry.current} />
 		<T is={material} />
-		{#if showAxesHelper.current}
-			<AxesHelper
-				name={entity}
-				width={3}
-				length={0.1}
-			/>
-		{/if}
+
 		{@render children?.()}
 	</T>
 {/if}

package/dist/components/Entities/composeBoxMatrix.d.ts

@@ -0,0 +1,12 @@
+import type { Entity } from 'koota';
+import { Matrix4 } from 'three';
+/**
+ * Compose a box entity's full render transform into `out`:
+ * `WorldMatrix × Center pose × box dimensions (mm → m)` — the same
+ * composition the per-entity path produced by nesting a dimension-scaled,
+ * center-offset mesh inside a `WorldMatrix`-driven group.
+ *
+ * Returns `false` (leaving `out` untouched) when the entity is missing the
+ * traits needed to place a box.
+ */
+export declare const composeBoxMatrix: (entity: Entity, out: Matrix4) => boolean;

package/dist/components/Entities/composeBoxMatrix.js

@@ -0,0 +1,29 @@
+import { Matrix4, Vector3 } from 'three';
+import { traits } from '../../ecs';
+import { poseToMatrix } from '../../transform';
+const centerMatrix = new Matrix4();
+const dimensions = new Vector3();
+const MM_TO_M = 0.001;
+/**
+ * Compose a box entity's full render transform into `out`:
+ * `WorldMatrix × Center pose × box dimensions (mm → m)` — the same
+ * composition the per-entity path produced by nesting a dimension-scaled,
+ * center-offset mesh inside a `WorldMatrix`-driven group.
+ *
+ * Returns `false` (leaving `out` untouched) when the entity is missing the
+ * traits needed to place a box.
+ */
+export const composeBoxMatrix = (entity, out) => {
+    const box = entity.get(traits.Box);
+    const worldMatrix = entity.get(traits.WorldMatrix);
+    if (!box || !worldMatrix) {
+        return false;
+    }
+    out.copy(worldMatrix);
+    const center = entity.get(traits.Center);
+    if (center) {
+        out.multiply(poseToMatrix(center, centerMatrix));
+    }
+    out.scale(dimensions.set(box.x * MM_TO_M, box.y * MM_TO_M, box.z * MM_TO_M));
+    return true;
+};

package/dist/components/Entities/hooks/useEntityEvents.svelte.d.ts

@@ -1,5 +1,17 @@
 import type { Entity } from 'koota';
 import { type IntersectionEvent } from '@threlte/extras';
+/**
+ * Pointer handlers for a renderer that draws a single entity — every event
+ * targets the closed-over entity.
+ *
+ * Layers invisibility on top of the shared handlers: enter/move/down/click are
+ * suppressed while the entity is invisible (raycasting still hits the visible
+ * leaf mesh of Frame/Geometry/GLTF, so the scene's visibility filter can't
+ * block them — added in #577, migrated to InheritedInvisible in #710).
+ * `onpointerleave` is intentionally left active. The effect tears down a stale
+ * Hovered/InstancedMatrix for an entity that turns invisible while hovered,
+ * since the guarded handlers can no longer fire to clean it up.
+ */
 export declare const useEntityEvents: (entity: () => Entity | undefined) => {
     onpointerenter: (event: IntersectionEvent<MouseEvent>) => void;
     onpointermove: (event: IntersectionEvent<MouseEvent>) => void;
@@ -7,3 +19,18 @@ export declare const useEntityEvents: (entity: () => Entity | undefined) => {
     onpointerdown: (event: IntersectionEvent<MouseEvent>) => void;
     onclick: (event: IntersectionEvent<MouseEvent>) => void;
 };
+/**
+ * Pointer handlers for an instanced renderer that draws many entities through
+ * one object — `entityForEvent` maps each event back to the entity it targets
+ * (typically via `event.instanceId`). Threlte keys hover identity by object
+ * uuid + instance id, so enter/leave fire per instance with the id on the
+ * event. No invisibility watcher: invisible instances are skipped by the
+ * instanced raycast, so they never receive events.
+ */
+export declare const useInstancedEntityEvents: (entityForEvent: (event: IntersectionEvent<MouseEvent>) => Entity | undefined) => {
+    onpointerenter: (event: IntersectionEvent<MouseEvent>) => void;
+    onpointermove: (event: IntersectionEvent<MouseEvent>) => void;
+    onpointerleave: (event: IntersectionEvent<MouseEvent>) => void;
+    onpointerdown: (event: IntersectionEvent<MouseEvent>) => void;
+    onclick: (event: IntersectionEvent<MouseEvent>) => void;
+};

package/dist/components/Entities/hooks/useEntityEvents.svelte.js

@@ -12,43 +12,49 @@ const infoToLocalMatrix = (info, out) => {
     out.makeRotationFromQuaternion(hoverQuat);
     out.setPosition(info.x, info.y, info.z);
 };
-export const useEntityEvents = (entity) => {
+/**
+ * Shared pointer handlers behind `useEntityEvents` and
+ * `useInstancedEntityEvents`. `entityForEvent` maps an event to the entity it
+ * targets. No invisibility handling lives here: single-entity renderers layer
+ * that on in `useEntityEvents`; instanced renderers don't need it because
+ * invisible instances are skipped by the instanced raycast.
+ */
+const createEntityEvents = (entityForEvent, cursor) => {
     const down = new Vector2();
     const world = useWorld();
-    const cursor = useCursor();
-    const invisible = useTrait(entity, traits.InheritedInvisible);
+    const hoverEntity = (currentEntity, event) => {
+        const hoverInfo = updateHoverInfo(currentEntity, event);
+        if (hoverInfo) {
+            infoToLocalMatrix(hoverInfo, tempHoverMatrix);
+            const worldMatrix = currentEntity.get(traits.WorldMatrix);
+            const composed = new Matrix4();
+            if (worldMatrix) {
+                composed.copy(worldMatrix).multiply(tempHoverMatrix);
+            }
+            else {
+                composed.copy(tempHoverMatrix);
+            }
+            currentEntity.add(traits.InstancedMatrix({
+                matrix: composed,
+                index: hoverInfo.index,
+            }));
+        }
+        currentEntity.add(traits.Hovered);
+    };
     const onpointerenter = (event) => {
-        if (invisible.current)
-            return;
         event.stopPropagation();
         cursor.onPointerEnter();
-        const currentEntity = entity();
+        const currentEntity = entityForEvent(event);
         if (currentEntity && !currentEntity.has(traits.Hovered)) {
-            const hoverInfo = updateHoverInfo(currentEntity, event);
-            if (hoverInfo) {
-                infoToLocalMatrix(hoverInfo, tempHoverMatrix);
-                const worldMatrix = currentEntity.get(traits.WorldMatrix);
-                const composed = new Matrix4();
-                if (worldMatrix) {
-                    composed.copy(worldMatrix).multiply(tempHoverMatrix);
-                }
-                else {
-                    composed.copy(tempHoverMatrix);
-                }
-                currentEntity.add(traits.InstancedMatrix({
-                    matrix: composed,
-                    index: hoverInfo.index,
-                }));
-            }
-            currentEntity.add(traits.Hovered);
+            hoverEntity(currentEntity, event);
         }
     };
     const onpointermove = (event) => {
-        if (invisible.current)
-            return;
         event.stopPropagation();
-        const currentEntity = entity();
-        if (currentEntity?.has(traits.Hovered)) {
+        const currentEntity = entityForEvent(event);
+        if (!currentEntity)
+            return;
+        if (currentEntity.has(traits.Hovered)) {
             const hoverInfo = updateHoverInfo(currentEntity, event);
             if (!hoverInfo)
                 return;
@@ -66,11 +72,17 @@ export const useEntityEvents = (entity) => {
             instanced.index = hoverInfo.index;
             currentEntity.changed(traits.InstancedMatrix);
         }
+        else {
+            // A move can target an entity that never got an enter event — e.g.
+            // an instanced renderer recycled an instance id to a new entity
+            // under a motionless cursor — so promote the move to a hover.
+            hoverEntity(currentEntity, event);
+        }
     };
     const onpointerleave = (event) => {
         event.stopPropagation();
         cursor.onPointerLeave();
-        const currentEntity = entity();
+        const currentEntity = entityForEvent(event);
         if (currentEntity?.has(traits.Hovered)) {
             currentEntity.remove(traits.Hovered);
         }
@@ -79,19 +91,14 @@ export const useEntityEvents = (entity) => {
         }
     };
     const onpointerdown = (event) => {
-        if (invisible.current)
-            return;
         down.copy(event.pointer);
     };
     const onclick = (event) => {
-        if (invisible.current) {
-            return;
-        }
         event.stopPropagation();
         if (down.distanceToSquared(event.pointer) >= 0.1) {
             return;
         }
-        const currentEntity = entity();
+        const currentEntity = entityForEvent(event);
         if (!currentEntity)
             return;
         if (event.nativeEvent.shiftKey) {
@@ -116,6 +123,35 @@ export const useEntityEvents = (entity) => {
             currentEntity.add(traits.InstanceId(event.instanceId ?? event.batchId));
         }
     };
+    return {
+        onpointerenter,
+        onpointermove,
+        onpointerleave,
+        onpointerdown,
+        onclick,
+    };
+};
+/**
+ * Pointer handlers for a renderer that draws a single entity — every event
+ * targets the closed-over entity.
+ *
+ * Layers invisibility on top of the shared handlers: enter/move/down/click are
+ * suppressed while the entity is invisible (raycasting still hits the visible
+ * leaf mesh of Frame/Geometry/GLTF, so the scene's visibility filter can't
+ * block them — added in #577, migrated to InheritedInvisible in #710).
+ * `onpointerleave` is intentionally left active. The effect tears down a stale
+ * Hovered/InstancedMatrix for an entity that turns invisible while hovered,
+ * since the guarded handlers can no longer fire to clean it up.
+ */
+export const useEntityEvents = (entity) => {
+    const cursor = useCursor();
+    const invisible = useTrait(entity, traits.InheritedInvisible);
+    const events = createEntityEvents(entity, cursor);
+    const whenVisible = (handler) => (event) => {
+        if (invisible.current)
+            return;
+        handler(event);
+    };
     $effect(() => {
         if (invisible.current) {
             cursor.onPointerLeave();
@@ -129,10 +165,22 @@ export const useEntityEvents = (entity) => {
         }
     });
     return {
-        onpointerenter,
-        onpointermove,
-        onpointerleave,
-        onpointerdown,
-        onclick,
+        onpointerenter: whenVisible(events.onpointerenter),
+        onpointermove: whenVisible(events.onpointermove),
+        onpointerleave: events.onpointerleave,
+        onpointerdown: whenVisible(events.onpointerdown),
+        onclick: whenVisible(events.onclick),
     };
 };
+/**
+ * Pointer handlers for an instanced renderer that draws many entities through
+ * one object — `entityForEvent` maps each event back to the entity it targets
+ * (typically via `event.instanceId`). Threlte keys hover identity by object
+ * uuid + instance id, so enter/leave fire per instance with the id on the
+ * event. No invisibility watcher: invisible instances are skipped by the
+ * instanced raycast, so they never receive events.
+ */
+export const useInstancedEntityEvents = (entityForEvent) => {
+    const cursor = useCursor();
+    return createEntityEvents(entityForEvent, cursor);
+};

package/dist/components/Scene.svelte

@@ -79,7 +79,6 @@
 		plane="xy"
 		sectionColor="#333"
 		infiniteGrid
-		renderOrder={999}
 		cellSize={settings.current.gridCellSize}
 		sectionSize={settings.current.gridSectionSize}
 		fadeOrigin={[0, 0, 0]}

package/dist/components/Selected.svelte

@@ -1,13 +1,15 @@
 <script lang="ts">
 	import { T, useTask, useThrelte } from '@threlte/core'
-	import { BatchedMesh, Box3 } from 'three'
+	import { BatchedMesh, Box3, Matrix4 } from 'three'
 	import { OBB } from 'three/addons/math/OBB.js'
 
+	import { composeBoxMatrix } from './Entities/composeBoxMatrix'
 	import { traits, useQuery } from '../ecs'
 	import { OBBHelper } from '../three/OBBHelper'
 
 	const box3 = new Box3()
 	const obb = new OBB()
+	const boxMatrix = new Matrix4()
 
 	const { scene, invalidate } = useThrelte()
 	const selected = useQuery(traits.Selected)
@@ -17,12 +19,21 @@
 	useTask(
 		() => {
 			for (const [entity, obbHelper] of obbHelpers) {
+				/**
+				 * Boxes render instanced, so the entity's named scene object
+				 * carries no geometry — derive the OBB straight from traits.
+				 */
+				if (composeBoxMatrix(entity, boxMatrix)) {
+					obbHelper.setFromMatrix4(boxMatrix)
+					continue
+				}
+
 				const object = scene.getObjectByName(entity as unknown as string)
 				if (!object) continue
 
 				const instance = entity.get(traits.InstanceId)
-				if (instance !== undefined && instance >= 0) {
-					;(object as BatchedMesh).getBoundingBoxAt(instance, box3)
+				if (instance !== undefined && instance >= 0 && object instanceof BatchedMesh) {
+					object.getBoundingBoxAt(instance, box3)
 					obb.fromBox3(box3)
 					obbHelper.setFromOBB(obb)
 				} else {

package/dist/components/SelectedTransformControls.svelte

@@ -8,15 +8,15 @@
 	import { relations, traits, useQuery, useTrait } from '../ecs'
 	import { useTransformControls } from '../hooks/useControls.svelte'
 	import { useEnvironment } from '../hooks/useEnvironment.svelte'
+	import { useFragmentInfo } from '../hooks/useFragmentInfo.svelte'
 	import { useFrameEditSession } from '../hooks/useFrameEditSession.svelte'
-	import { usePartConfig } from '../hooks/usePartConfig.svelte'
 	import { useSettings } from '../hooks/useSettings.svelte'
 	import { createPose, matrixToPose, poseToMatrix, solveEditedMatrix } from '../transform'
 
 	const { scene } = useThrelte()
 	const settings = useSettings()
 	const environment = useEnvironment()
-	const partConfig = usePartConfig()
+	const fragmentInfo = useFragmentInfo()
 	const transformControls = useTransformControls()
 	const sessions = useFrameEditSession()
 	const selected = useQuery(traits.Selected)
@@ -36,9 +36,7 @@
 		box.current !== undefined || sphere.current !== undefined || capsule.current !== undefined
 	)
 	const isFragmentComponentWithVariables = $derived(
-		name.current &&
-			Object.keys(partConfig.componentNameToFragmentInfo?.[name.current]?.variables ?? {}).length >
-				0
+		name.current && Object.keys(fragmentInfo.current?.[name.current]?.variables ?? {}).length > 0
 	)
 
 	// Mesh sets name={entity} on its inner mesh, so getObjectByName resolves

package/dist/components/overlay/Details.svelte

@@ -46,6 +46,7 @@
 	import { useConfigFrames } from '../../hooks/useConfigFrames.svelte'
 	import { useCameraControls } from '../../hooks/useControls.svelte'
 	import { useEnvironment } from '../../hooks/useEnvironment.svelte'
+	import { useFragmentInfo } from '../../hooks/useFragmentInfo.svelte'
 	import { useLinkedEntities } from '../../hooks/useLinked.svelte'
 	import { usePartConfig } from '../../hooks/usePartConfig.svelte'
 	import { usePartID } from '../../hooks/usePartID.svelte'
@@ -66,6 +67,7 @@
 	const resourceByName = useResourceByName()
 	const configFrames = useConfigFrames()
 	const partConfig = usePartConfig()
+	const fragmentInfo = useFragmentInfo()
 	const partID = usePartID()
 	const settings = useSettings()
 	const environment = useEnvironment()
@@ -104,9 +106,7 @@
 	const isFrameNode = $derived(!!framesAPI.current)
 	const isGeometry = $derived(!!geometriesAPI.current)
 	const isFragmentComponentWithVariables = $derived(
-		name.current &&
-			Object.keys(partConfig.componentNameToFragmentInfo?.[name.current]?.variables ?? {}).length >
-				0
+		name.current && Object.keys(fragmentInfo.current?.[name.current]?.variables ?? {}).length > 0
 	)
 	const showEditFrameOptions = $derived(
 		isFrameNode && partConfig.hasEditPermissions && !isFragmentComponentWithVariables
@@ -435,7 +435,12 @@
 			</p>
 		{/if}
 
-		<h3 class="text-subtle-2 pt-3 pb-2">Details</h3>
+		<h3
+			class="text-subtle-2 pt-3 pb-2"
+			data-testid="details-header"
+		>
+			Details
+		</h3>
 
 		<div class="flex flex-col gap-2.5">
 			{#if !customDetails.current}

package/dist/hooks/plugins/bvh.svelte.js

@@ -25,6 +25,15 @@ export const bvh = (raycaster, options) => {
                 return;
             if (opts.enabled === false)
                 return;
+            /**
+             * `InstancedMesh2` brings its own per-instance BVH raycast (and a
+             * real `bvh` field, so it can't even take a `bvh` opt-out prop —
+             * Threlte would assign the prop onto the object and clobber it).
+             * Patching it with three-mesh-bvh's `acceleratedRaycast` would
+             * test only the unit geometry, so skip it entirely.
+             */
+            if (ref.isInstancedMesh2)
+                return;
             if (isInstanceOf(ref, 'Points') &&
                 /**
                  * This check is necessary, there are some strange cases where points are coming in from PCDs without any position data

package/dist/hooks/useConfigFrames.svelte.js

@@ -2,11 +2,13 @@ import { Transform } from '@viamrobotics/sdk';
 import { getContext, setContext } from 'svelte';
 import { createTransformFromFrame } from '../frame';
 import { useEnvironment } from './useEnvironment.svelte';
+import { useFragmentInfo } from './useFragmentInfo.svelte';
 import { usePartConfig } from './usePartConfig.svelte';
 const key = Symbol('config-frames-context');
 export const provideConfigFrames = () => {
     const environment = useEnvironment();
     const partConfig = usePartConfig();
+    const fragmentInfo = useFragmentInfo();
     $effect(() => {
         environment.current.viewerMode = partConfig.isDirty ? 'edit' : 'monitor';
     });
@@ -25,12 +27,12 @@ export const provideConfigFrames = () => {
     });
     const [fragmentFrames, fragmentUnsetFrameNames] = $derived.by(() => {
         const { fragment_mods: fragmentMods = [] } = partConfig.current;
-        const fragmentDefinedComponents = Object.keys(partConfig.componentNameToFragmentInfo ?? {});
+        const fragmentDefinedComponents = Object.keys(fragmentInfo.current ?? {});
         const results = {};
         const unsetResults = [];
         // deal with fragment defined components
         for (const fragmentComponentName of fragmentDefinedComponents || []) {
-            const fragmentId = partConfig.componentNameToFragmentInfo[fragmentComponentName].id;
+            const fragmentId = fragmentInfo.current[fragmentComponentName].id;
             const fragmentMod = fragmentMods?.find((mod) => mod.fragment_id === fragmentId);
             if (!fragmentMod) {
                 continue;
@@ -64,7 +66,7 @@ export const provideConfigFrames = () => {
          * any whose frame the user has $unset.
          */
         const unsetFragmentNames = new Set(fragmentUnsetFrameNames);
-        for (const name of Object.keys(partConfig.componentNameToFragmentInfo)) {
+        for (const name of Object.keys(fragmentInfo.current)) {
             if (!unsetFragmentNames.has(name)) {
                 validFrames.add(name);
             }

package/dist/hooks/useFragmentInfo.svelte.d.ts

@@ -0,0 +1,24 @@
+import type { Frame } from '../frame';
+export interface FragmentInfo {
+    id: string;
+    frame?: Frame;
+    variables: Record<string, string>;
+}
+interface FragmentInfoContext {
+    /** componentName -> the fragment that defines it ({ id, variables }) */
+    current: Record<string, FragmentInfo>;
+}
+/**
+ * Single source of truth for which components are defined by a fragment.
+ *
+ * Embedded hosts own this knowledge and pass it as a top-level App prop; in
+ * standalone we derive it from the part's `getRobotPart` -> `getFragment`
+ * queries. Mode is fixed for the session (the prop is either always defined or
+ * always undefined), mirroring `providePartConfig`.
+ *
+ * Must be provided BEFORE `providePartConfig`, whose frame-edit routing
+ * consumes `useFragmentInfo()` to choose part-frame vs fragment-mod writes.
+ */
+export declare const provideFragmentInfo: (partID: () => string, embeddedMap: () => Record<string, FragmentInfo> | undefined) => void;
+export declare const useFragmentInfo: () => FragmentInfoContext;
+export {};

package/dist/hooks/useFragmentInfo.svelte.js

@@ -0,0 +1,86 @@
+import { createAppQuery } from '@viamrobotics/svelte-sdk';
+import { getContext, setContext } from 'svelte';
+const key = Symbol('fragment-info-context');
+/**
+ * Single source of truth for which components are defined by a fragment.
+ *
+ * Embedded hosts own this knowledge and pass it as a top-level App prop; in
+ * standalone we derive it from the part's `getRobotPart` -> `getFragment`
+ * queries. Mode is fixed for the session (the prop is either always defined or
+ * always undefined), mirroring `providePartConfig`.
+ *
+ * Must be provided BEFORE `providePartConfig`, whose frame-edit routing
+ * consumes `useFragmentInfo()` to choose part-frame vs fragment-mod writes.
+ */
+export const provideFragmentInfo = (partID, embeddedMap) => {
+    const embedded = $derived(embeddedMap());
+    const config = $derived(embedded ? { current: embedded } : useStandaloneFragmentInfo(partID));
+    setContext(key, {
+        get current() {
+            return config.current;
+        },
+    });
+};
+export const useFragmentInfo = () => {
+    return getContext(key);
+};
+const useStandaloneFragmentInfo = (partID) => {
+    const partQuery = createAppQuery('getRobotPart', () => [partID()], {
+        refetchInterval: false,
+    });
+    const networkPartConfig = $derived(partQuery.data?.part?.robotConfig);
+    const configJSON = $derived.by(() => {
+        if (!networkPartConfig) {
+            return undefined;
+        }
+        try {
+            return networkPartConfig.toJson();
+        }
+        catch {
+            return undefined;
+        }
+    });
+    const fragmentQueries = $derived((configJSON?.fragments ?? []).map((fragmentId) => {
+        const id = typeof fragmentId === 'string' ? fragmentId : fragmentId.id;
+        return createAppQuery('getFragment', () => [id], { refetchInterval: false });
+    }));
+    const fragmentIdToVariables = $derived.by(() => {
+        const results = {};
+        for (const fragment of configJSON?.fragments ?? []) {
+            const id = typeof fragment === 'string' ? fragment : fragment.id;
+            const variables = typeof fragment === 'string' ? {} : (fragment.variables ?? {});
+            results[id] = variables;
+        }
+        return results;
+    });
+    const componentNameToFragmentInfo = $derived.by(() => {
+        const results = {};
+        for (const query of fragmentQueries) {
+            if (!query.data) {
+                continue;
+            }
+            const fragmentId = query.data.id;
+            const components = query.data?.fragment?.fields['components']?.kind;
+            if (components?.case === 'listValue') {
+                for (const component of components.value.values) {
+                    if (component.kind.case === 'structValue') {
+                        const componentName = component.kind.value.fields['name']?.kind;
+                        if (componentName?.case === 'stringValue') {
+                            results[componentName.value] = {
+                                id: fragmentId,
+                                frame: component.kind.value.fields['frame'].toJson(),
+                                variables: fragmentIdToVariables[fragmentId] ?? {},
+                            };
+                        }
+                    }
+                }
+            }
+        }
+        return results;
+    });
+    return {
+        get current() {
+            return componentNameToFragmentInfo;
+        },
+    };
+};