@viamrobotics/motion-tools 1.34.4 → 1.34.6

package/dist/components/App.svelte

@@ -10,7 +10,7 @@
 	import { type Component, onMount, type Snippet } from 'svelte'
 	import { ThemeUtils } from 'svelte-tweakpane-ui'
 
-	import type { FragmentInfo } from '../hooks/usePartConfig.svelte'
+	import type { FragmentInfo } from '../hooks/useFragmentInfo.svelte'
 
 	import Controls from './overlay/controls/Controls.svelte'
 	import Dashboard from './overlay/dashboard/Dashboard.svelte'
@@ -20,6 +20,7 @@
 	import { provideWorld, traits, useQuery } from '../ecs'
 	import { type CameraPose, provideCameraControls } from '../hooks/useControls.svelte'
 	import { provideEnvironment } from '../hooks/useEnvironment.svelte'
+	import { provideFragmentInfo } from '../hooks/useFragmentInfo.svelte'
 	import { providePartConfig } from '../hooks/usePartConfig.svelte'
 	import { createPartIDContext } from '../hooks/usePartID.svelte'
 	import { provideSettings } from '../hooks/useSettings.svelte'
@@ -39,7 +40,6 @@
 	interface LocalConfigProps {
 		current: Struct
 		isDirty: boolean
-		componentNameToFragmentInfo: Record<string, FragmentInfo>
 		setLocalPartConfig: (config: Struct) => void
 	}
 
@@ -48,6 +48,12 @@
 		inputBindingsEnabled?: boolean
 		localConfigProps?: LocalConfigProps
 
+		/**
+		 * Maps a component name to the fragment that defines it. Embedded hosts
+		 * supply this; in standalone it is computed from fragment queries (omit).
+		 */
+		componentNameToFragmentInfo?: Record<string, FragmentInfo>
+
 		/**
 		 * Allows adding additional tabs to the settings panel
 		 */
@@ -81,6 +87,7 @@
 		partID = '',
 		inputBindingsEnabled = true,
 		localConfigProps,
+		componentNameToFragmentInfo,
 		cameraPose,
 		settingsTabs,
 		children: appChildren,
@@ -104,6 +111,11 @@
 
 	let root = $state.raw<HTMLElement>()
 
+	provideFragmentInfo(
+		() => partID,
+		() => componentNameToFragmentInfo
+	)
+
 	providePartConfig(
 		() => partID,
 		() => localConfigProps

package/dist/components/App.svelte.d.ts

@@ -1,18 +1,22 @@
 import type { Struct } from '@viamrobotics/sdk';
 import type { Entity } from 'koota';
 import { type Component, type Snippet } from 'svelte';
-import type { FragmentInfo } from '../hooks/usePartConfig.svelte';
+import type { FragmentInfo } from '../hooks/useFragmentInfo.svelte';
 import { type CameraPose } from '../hooks/useControls.svelte';
 interface LocalConfigProps {
     current: Struct;
     isDirty: boolean;
-    componentNameToFragmentInfo: Record<string, FragmentInfo>;
     setLocalPartConfig: (config: Struct) => void;
 }
 interface Props {
     partID?: string;
     inputBindingsEnabled?: boolean;
     localConfigProps?: LocalConfigProps;
+    /**
+     * Maps a component name to the fragment that defines it. Embedded hosts
+     * supply this; in standalone it is computed from fragment queries (omit).
+     */
+    componentNameToFragmentInfo?: Record<string, FragmentInfo>;
     /**
      * Allows adding additional tabs to the settings panel
      */

package/dist/components/AxesHelper.svelte

@@ -12,11 +12,12 @@
 		depthTest?: boolean
 	}
 
-	const {
+	let {
 		length = 1,
 		width = 0.1,
 		axesColors = ['red', 'green', 'blue'],
 		depthTest = true,
+		ref = $bindable(),
 		...rest
 	}: Props = $props()
 
@@ -66,6 +67,7 @@
 	is={line}
 	{...rest}
 	bvh={{ enabled: false }}
+	bind:ref
 >
 	<T is={geometry} />
 	<T

package/dist/components/AxesHelper.svelte.d.ts

@@ -6,6 +6,6 @@ interface Props extends ThrelteProps<Line2> {
     axesColors?: [x: string, y: string, z: string];
     depthTest?: boolean;
 }
-declare const AxesHelper: import("svelte").Component<Props, {}, "">;
+declare const AxesHelper: import("svelte").Component<Props, {}, "ref">;
 type AxesHelper = ReturnType<typeof AxesHelper>;
 export default AxesHelper;

package/dist/components/Entities/Arrows/Arrows.svelte

@@ -5,7 +5,6 @@
 
 	import type { InstancedArrows } from '../../../three/InstancedArrows/InstancedArrows'
 
-	import AxesHelper from '../../AxesHelper.svelte'
 	import { useEntityEvents } from '../hooks/useEntityEvents.svelte'
 	import { traits, useTag, useTrait } from '../../../ecs'
 	import { meshBoundsRaycast, raycast } from '../../../three/InstancedArrows/raycast'
@@ -21,7 +20,6 @@
 	const worldMatrix = useTrait(() => entity, traits.WorldMatrix)
 	const selected = useTag(() => entity, traits.Selected)
 	const invisible = useTrait(() => entity, traits.InheritedInvisible)
-	const showAxesHelper = useTrait(() => entity, traits.ShowAxesHelper)
 
 	const events = useEntityEvents(() => entity)
 
@@ -59,11 +57,4 @@
 		bvh={{ enabled: false }}
 		raycast={() => null}
 	/>
-	{#if showAxesHelper.current}
-		<AxesHelper
-			name={entity}
-			width={3}
-			length={0.1}
-		/>
-	{/if}
 </T>

package/dist/components/Entities/AxesHelper.svelte

@@ -0,0 +1,38 @@
+<script lang="ts">
+	import type { Entity } from 'koota'
+	import type { Line2 } from 'three/addons'
+
+	import { useThrelte } from '@threlte/core'
+
+	import { traits, useTrait } from '../../ecs'
+
+	import AxesHelper from '../AxesHelper.svelte'
+
+	interface Props {
+		entity: Entity
+	}
+
+	let { entity }: Props = $props()
+
+	const { invalidate } = useThrelte()
+
+	let ref = $state.raw<Line2>()
+
+	const worldMatrix = useTrait(() => entity, traits.WorldMatrix)
+
+	$effect(() => {
+		if (worldMatrix.current) {
+			ref?.matrix.copy(worldMatrix.current)
+			ref?.updateMatrixWorld()
+			invalidate()
+		}
+	})
+</script>
+
+<AxesHelper
+	bind:ref
+	name={entity}
+	width={3}
+	length={0.1}
+	matrixAutoUpdate={false}
+/>

package/dist/components/Entities/AxesHelper.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Entity } from 'koota';
+import AxesHelper from '../AxesHelper.svelte';
+interface Props {
+    entity: Entity;
+}
+declare const AxesHelper: import("svelte").Component<Props, {}, "">;
+type AxesHelper = ReturnType<typeof AxesHelper>;
+export default AxesHelper;

package/dist/components/Entities/AxesHelpers.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+	import { Not } from 'koota'
+
+	import { traits, useQuery } from '../../ecs'
+
+	import AxesHelper from './AxesHelper.svelte'
+
+	const entities = useQuery(traits.ShowAxesHelper, Not(traits.Invisible))
+</script>
+
+{#each entities.current as entity (entity)}
+	<AxesHelper {entity} />
+{/each}

package/dist/{plugins/LLMSceneBuilder/AISettings.svelte.d.ts → components/Entities/AxesHelpers.svelte.d.ts}

@@ -1,18 +1,5 @@
-export default AISettings;
-type AISettings = SvelteComponent<{
-    [x: string]: never;
-}, {
-    [evt: string]: CustomEvent<any>;
-}, {}> & {
-    $$bindings?: string | undefined;
-};
-declare const AISettings: $$__sveltets_2_IsomorphicComponent<{
-    [x: string]: never;
-}, {
-    [evt: string]: CustomEvent<any>;
-}, {}, {}, string>;
 interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
-    new (options: import("svelte").ComponentConstructorOptions<Props>): import("svelte").SvelteComponent<Props, Events, Slots> & {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
         $$bindings?: Bindings;
     } & Exports;
     (internal: unknown, props: {
@@ -24,3 +11,8 @@ interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> =
     };
     z_$$bindings?: Bindings;
 }
+declare const AxesHelpers: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type AxesHelpers = InstanceType<typeof AxesHelpers>;
+export default AxesHelpers;

package/dist/components/Entities/Boxes.svelte

@@ -0,0 +1,290 @@
+<!--
+@component
+
+Renders every entity with `Box` + `WorldMatrix` traits as one pair of
+instanced draw calls (toon-shaded faces + edge lines) instead of a mesh
+per box. Trait events are coalesced into a microtask flush, mirroring
+the `WorldMatrix` system, so a burst of changes (one reconcile tick)
+becomes a single batch of instance writes and one `invalidate()`.
+
+The faces mesh is also the pointer-interaction surface: `InstancedMesh2`
+raycasts per instance (skipping invisible ones) and stamps `instanceId`
+on each hit, which `useInstancedEntityEvents` maps back to the entity.
+-->
+<script lang="ts">
+	import type { Entity } from 'koota'
+
+	import { createRadixSort, InstancedMesh2 } from '@three.ez/instanced-mesh'
+	import { T, useThrelte } from '@threlte/core'
+	import {
+		BoxGeometry,
+		Color,
+		EdgesGeometry,
+		LineBasicMaterial,
+		Matrix4,
+		MeshToonMaterial,
+		Sphere,
+		Vector3,
+	} from 'three'
+
+	import { asColor } from '../../buffer'
+	import { colors, darkenColor, subtypeToColor } from '../../color'
+	import { traits, useWorld } from '../../ecs'
+	import { useResourceByName } from '../../hooks/useResourceByName.svelte'
+
+	import { composeBoxMatrix } from './composeBoxMatrix'
+	import { useInstancedEntityEvents } from './hooks/useEntityEvents.svelte'
+
+	const { invalidate, renderer } = useThrelte()
+	const world = useWorld()
+	const resourceByName = useResourceByName()
+
+	/**
+	 * Shared unit geometries — every instance references these and sets its
+	 * dimensions through the per-instance matrix scale, so resizing never
+	 * rebuilds GPU buffers.
+	 */
+	const unitBox = new BoxGeometry(1, 1, 1)
+	const unitBoxEdges = new EdgesGeometry(unitBox, 0)
+
+	/**
+	 * Box meshes render transparent by default (`Opacity` trait absent → 0.7,
+	 * depth write off — same as `Mesh.svelte`); per-instance alpha is written
+	 * via `setOpacityAt`. The base color stays white so per-instance colors
+	 * aren't tinted. Whole-object culling is disabled because the library
+	 * culls per instance against a bounding sphere it derives from each
+	 * instance matrix.
+	 */
+	const instancedBoxes = new InstancedMesh2(
+		unitBox,
+		new MeshToonMaterial({ transparent: true, depthWrite: false }),
+		{ renderer }
+	)
+	instancedBoxes.sortObjects = true
+	instancedBoxes.customSort = createRadixSort(instancedBoxes)
+	instancedBoxes.frustumCulled = false
+
+	/**
+	 * Keep raycasts on the library's linear (non-BVH) path, but neutralize
+	 * its gate: the whole-object bounding sphere is computed once on the
+	 * first raycast (usually before any boxes have streamed in) and never
+	 * invalidated, leaving instances unhittable. Pin it open and let the
+	 * per-instance early-outs do the pruning — for an always-animating
+	 * scene this beats `computeBVH()`, which would re-insert every moving
+	 * box into the tree on every kinematics tick.
+	 */
+	instancedBoxes.boundingSphere = new Sphere(new Vector3(), Infinity)
+
+	const instancedBoxEdges = new InstancedMesh2(unitBoxEdges, new LineBasicMaterial(), {
+		renderer,
+	})
+	instancedBoxEdges.frustumCulled = false
+
+	/**
+	 * `InstancedMesh2` extends `Mesh`, so on its own it would draw the edge
+	 * geometry as triangles. Re-tagging the object makes the renderer emit
+	 * `gl.LINES`; the library's instancing shader patch still applies because
+	 * `LineBasicMaterial` compiles from the same chunk-based `basic` program
+	 * its patched shader chunks target.
+	 *
+	 * @three.ez/instanced-mesh ^0.3.15 — patches the 'basic' shader chunks shared
+	 * by MeshBasicMaterial and LineBasicMaterial. Re-validate if upgrading the library.
+	 */
+	Object.assign(instancedBoxEdges, { isMesh: false, isLine: true, isLineSegments: true })
+
+	/**
+	 * Faces and edges are separate meshes with independent free lists, so each
+	 * entity tracks its faces id and edges id separately. `entityByInstanceId`
+	 * is keyed by faces id — only the faces mesh raycasts (edges set
+	 * `raycast={() => null}`), so a hit's `instanceId` is always a faces id.
+	 */
+	type InstanceIds = { face: number; edge: number }
+	const instanceIdByEntity = new Map<Entity, InstanceIds>()
+	const entityByInstanceId = new Map<number, Entity>()
+
+	const events = useInstancedEntityEvents((event) =>
+		event.instanceId === undefined ? undefined : entityByInstanceId.get(event.instanceId)
+	)
+
+	const matrix = new Matrix4()
+	const colorUtil = new Color()
+
+	/** Same resolution order as `Frame.svelte`. */
+	const resolveColor = (entity: Entity): Color => {
+		const vertexColors = entity.get(traits.Colors)
+		if (vertexColors && vertexColors.length >= 3) {
+			return asColor(vertexColors, colorUtil)
+		}
+
+		const color = entity.get(traits.Color)
+		if (color) {
+			return colorUtil.setRGB(color.r, color.g, color.b)
+		}
+
+		const subtype = resourceByName.current[entity.get(traits.Name) ?? '']?.subtype
+		return subtypeToColor(subtype) ?? colorUtil.set(colors.default)
+	}
+
+	const writeAppearance = (entity: Entity, ids: InstanceIds) => {
+		const color = resolveColor(entity)
+		const visible = !entity.has(traits.InheritedInvisible)
+
+		instancedBoxes.setColorAt(ids.face, color)
+		instancedBoxes.setOpacityAt(ids.face, entity.get(traits.Opacity) ?? 0.7)
+		instancedBoxes.setVisibilityAt(ids.face, visible)
+
+		instancedBoxEdges.setColorAt(ids.edge, darkenColor(color, 10))
+		instancedBoxEdges.setVisibilityAt(ids.edge, visible)
+
+		/**
+		 * Mirrors `useEntityEvents`' invisibility watcher: an instance that
+		 * vanishes under a motionless cursor gets no pointerleave until the
+		 * pointer moves, so drop its hover state here.
+		 */
+		if (!visible && entity.has(traits.Hovered)) {
+			entity.remove(traits.Hovered)
+		}
+	}
+
+	/** Caller composes the instance transform into `matrix` first. */
+	const addInstance = (entity: Entity) => {
+		let face = -1
+		instancedBoxes.addInstances(1, (_obj, index) => {
+			face = index
+		})
+		instancedBoxes.setMatrixAt(face, matrix)
+
+		let edge = -1
+		instancedBoxEdges.addInstances(1, (_obj, index) => {
+			edge = index
+		})
+		instancedBoxEdges.setMatrixAt(edge, matrix)
+
+		const ids = { face, edge }
+		instanceIdByEntity.set(entity, ids)
+		entityByInstanceId.set(face, entity)
+		writeAppearance(entity, ids)
+	}
+
+	const removeInstance = (entity: Entity, ids: InstanceIds) => {
+		instanceIdByEntity.delete(entity)
+		entityByInstanceId.delete(ids.face)
+		instancedBoxes.removeInstances(ids.face)
+		instancedBoxEdges.removeInstances(ids.edge)
+	}
+
+	/**
+	 * Transform work (matrix/dimension changes, adds, removes) is tracked
+	 * separately from appearance work (color/opacity/visibility) so a robot
+	 * in motion only rewrites matrices, not the color texture.
+	 */
+	const dirtyTransform = new Set<Entity>()
+	const dirtyAppearance = new Set<Entity>()
+	let scheduled = false
+
+	const flush = () => {
+		if (dirtyTransform.size === 0 && dirtyAppearance.size === 0) {
+			return
+		}
+
+		for (const entity of dirtyTransform) {
+			const ids = instanceIdByEntity.get(entity)
+
+			if (entity.isAlive() && composeBoxMatrix(entity, matrix)) {
+				if (ids === undefined) {
+					addInstance(entity)
+				} else {
+					instancedBoxes.setMatrixAt(ids.face, matrix)
+					instancedBoxEdges.setMatrixAt(ids.edge, matrix)
+				}
+			} else if (ids !== undefined) {
+				removeInstance(entity, ids)
+			}
+		}
+
+		for (const entity of dirtyAppearance) {
+			const ids = instanceIdByEntity.get(entity)
+			if (ids !== undefined && entity.isAlive()) {
+				writeAppearance(entity, ids)
+			}
+		}
+
+		dirtyTransform.clear()
+		dirtyAppearance.clear()
+		invalidate()
+	}
+
+	const schedule = () => {
+		if (scheduled) return
+		scheduled = true
+		queueMicrotask(() => {
+			scheduled = false
+			flush()
+		})
+	}
+
+	/**
+	 * `WorldMatrix` changes fire for every entity on every kinematics tick —
+	 * filter to box entities before touching the dirty sets. `instanceIdByEntity`
+	 * catches entities whose `Box` trait was just removed.
+	 */
+	const enqueue = (dirty: Set<Entity>) => (entity: Entity) => {
+		if (!entity.has(traits.Box) && !instanceIdByEntity.has(entity)) return
+		dirty.add(entity)
+		schedule()
+	}
+
+	const enqueueTransform = enqueue(dirtyTransform)
+	const enqueueAppearance = enqueue(dirtyAppearance)
+
+	$effect(() => {
+		// Initial sync: existing boxes need both an instance allocated (transform)
+		// and appearance written once. At runtime the sets diverge — motion enqueues
+		// transform alone, so appearance buffers aren't rewritten per kinematics tick.
+		for (const entity of world.query(traits.Box)) {
+			dirtyTransform.add(entity)
+			dirtyAppearance.add(entity)
+		}
+		if (dirtyTransform.size > 0) schedule()
+
+		const unsubs = [
+			world.onAdd(traits.Box, enqueueTransform),
+			world.onChange(traits.Box, enqueueTransform),
+			world.onRemove(traits.Box, enqueueTransform),
+			world.onAdd(traits.WorldMatrix, enqueueTransform),
+			world.onChange(traits.WorldMatrix, enqueueTransform),
+			world.onRemove(traits.WorldMatrix, enqueueTransform),
+			world.onAdd(traits.Center, enqueueTransform),
+			world.onChange(traits.Center, enqueueTransform),
+			world.onRemove(traits.Center, enqueueTransform),
+
+			world.onAdd(traits.Color, enqueueAppearance),
+			world.onChange(traits.Color, enqueueAppearance),
+			world.onRemove(traits.Color, enqueueAppearance),
+			world.onAdd(traits.Colors, enqueueAppearance),
+			world.onChange(traits.Colors, enqueueAppearance),
+			world.onRemove(traits.Colors, enqueueAppearance),
+			world.onAdd(traits.Opacity, enqueueAppearance),
+			world.onChange(traits.Opacity, enqueueAppearance),
+			world.onRemove(traits.Opacity, enqueueAppearance),
+			world.onAdd(traits.InheritedInvisible, enqueueAppearance),
+			world.onRemove(traits.InheritedInvisible, enqueueAppearance),
+		]
+
+		return () => {
+			for (const unsub of unsubs) unsub()
+			dirtyTransform.clear()
+			dirtyAppearance.clear()
+		}
+	})
+</script>
+
+<T
+	is={instancedBoxes}
+	{...events}
+/>
+
+<T
+	is={instancedBoxEdges}
+	raycast={() => null}
+/>

package/dist/components/Entities/Boxes.svelte.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Renders every entity with `Box` + `WorldMatrix` traits as one pair of
+ * instanced draw calls (toon-shaded faces + edge lines) instead of a mesh
+ * per box. Trait events are coalesced into a microtask flush, mirroring
+ * the `WorldMatrix` system, so a burst of changes (one reconcile tick)
+ * becomes a single batch of instance writes and one `invalidate()`.
+ *
+ * The faces mesh is also the pointer-interaction surface: `InstancedMesh2`
+ * raycasts per instance (skipping invisible ones) and stamps `instanceId`
+ * on each hit, which `useInstancedEntityEvents` maps back to the entity.
+ */
+declare const Boxes: import("svelte").Component<Record<string, never>, {}, "">;
+type Boxes = ReturnType<typeof Boxes>;
+export default Boxes;

package/dist/components/Entities/Entities.svelte

@@ -5,6 +5,8 @@
 	import { useSettings } from '../../hooks/useSettings.svelte'
 
 	import Arrows from './Arrows/ArrowGroups.svelte'
+	import AxesHelpers from './AxesHelpers.svelte'
+	import Boxes from './Boxes.svelte'
 	import Frame from './Frame.svelte'
 	import Geometry from './Geometry.svelte'
 	import GLTF from './GLTF.svelte'
@@ -32,8 +34,8 @@
 	 */
 	const worldStateEntities = useQuery(
 		traits.WorldStateStoreAPI,
-		Not(traits.Points, traits.LinePositions, traits.GLTF),
-		Or(traits.Box, traits.Capsule, traits.Sphere, traits.BufferGeometry, traits.ReferenceFrame)
+		Not(traits.Points, traits.Box, traits.LinePositions, traits.GLTF),
+		Or(traits.Capsule, traits.Sphere, traits.BufferGeometry, traits.ReferenceFrame)
 	)
 
 	/**
@@ -42,8 +44,8 @@
 	 */
 	const drawServiceEntities = useQuery(
 		traits.DrawServiceAPI,
-		Not(traits.Points, traits.LinePositions, traits.GLTF),
-		Or(traits.Box, traits.Capsule, traits.Sphere, traits.BufferGeometry, traits.ReferenceFrame)
+		Not(traits.Points, traits.Box, traits.LinePositions, traits.GLTF),
+		Or(traits.Capsule, traits.Sphere, traits.BufferGeometry, traits.ReferenceFrame)
 	)
 
 	/**
@@ -55,7 +57,8 @@
 		Not(traits.WorldStateStoreAPI),
 		Not(traits.DrawServiceAPI),
 		Not(traits.Points),
-		Or(traits.Box, traits.Capsule, traits.Sphere, traits.BufferGeometry, traits.ReferenceFrame)
+		Not(traits.Box),
+		Or(traits.Capsule, traits.Sphere, traits.BufferGeometry, traits.ReferenceFrame)
 	)
 
 	const points = useQuery(traits.Points)
@@ -102,6 +105,8 @@
 {/each}
 
 <Arrows />
+<AxesHelpers />
+<Boxes />
 
 {#if enableLabels}
 	<Labels />

package/dist/components/Entities/GLTF.svelte

@@ -21,7 +21,6 @@
 
 	import { traits, useTrait } from '../../ecs'
 
-	import AxesHelper from '../AxesHelper.svelte'
 	import { useEntityEvents } from './hooks/useEntityEvents.svelte'
 
 	interface Props extends ThrelteProps<Object3D> {
@@ -36,7 +35,6 @@
 	const worldMatrix = useTrait(() => entity, traits.WorldMatrix)
 	const gltfTrait = useTrait(() => entity, traits.GLTF)
 	const invisible = useTrait(() => entity, traits.InheritedInvisible)
-	const showAxesHelper = useTrait(() => entity, traits.ShowAxesHelper)
 	const events = useEntityEvents(() => entity)
 
 	const animationName = $derived(gltfTrait.current?.animationName)
@@ -83,13 +81,6 @@
 </script>
 
 <T is={group}>
-	{#if showAxesHelper.current}
-		<AxesHelper
-			name={entity}
-			width={3}
-			length={0.1}
-		/>
-	{/if}
 	{#if $gltf}
 		<T
 			is={$gltf.scene as Object3D}

package/dist/components/Entities/Line.svelte

@@ -9,7 +9,6 @@
 	import { isVertexColors, STRIDE } from '../../buffer'
 	import { traits, useTrait } from '../../ecs'
 
-	import AxesHelper from '../AxesHelper.svelte'
 	import { useEntityEvents } from './hooks/useEntityEvents.svelte'
 	import LineDots from './LineDots.svelte'
 	import LineGeometry from './LineGeometry.svelte'
@@ -35,7 +34,6 @@
 	const opacity = useTrait(() => entity, traits.Opacity)
 	const screenSpace = useTrait(() => entity, traits.ScreenSpace)
 	const invisible = useTrait(() => entity, traits.InheritedInvisible)
-	const showAxesHelper = useTrait(() => entity, traits.ShowAxesHelper)
 
 	const events = useEntityEvents(() => entity)
 
@@ -96,13 +94,6 @@
 		linewidth={(lineWidth.current ?? 5) * (screenSpace.current ? 1 : 0.001)}
 		depthTest={materialProps.current?.depthTest ?? true}
 	/>
-	{#if showAxesHelper.current}
-		<AxesHelper
-			name={entity}
-			width={3}
-			length={0.1}
-		/>
-	{/if}
 
 	{#if linePositions.current && dotSize.current}
 		<LineDots