@viamrobotics/motion-tools 1.19.1 → 1.22.0

package/dist/components/overlay/dashboard/Dashboard.svelte

@@ -38,40 +38,50 @@
 	</fieldset>
 
 	<!-- transform -->
-	{#if settings.current.transforming}
-		<fieldset class="flex">
-			<Button
-				icon="cursor-move"
-				active={settings.current.transformMode === 'translate'}
-				description="Translate"
-				hotkey="1"
-				onclick={() => {
-					settings.current.transformMode = 'translate'
-				}}
-			/>
-			<Button
-				icon="sync"
-				active={settings.current.transformMode === 'rotate'}
-				description="Rotate"
-				hotkey="2"
-				class="-ml-px"
-				onclick={() => {
-					settings.current.transformMode = 'rotate'
-				}}
-			/>
-			<Button
-				icon="resize"
-				active={settings.current.transformMode === 'scale'}
-				description="Scale"
-				hotkey="3"
-				class="-ml-px"
-				onclick={() => {
-					settings.current.transformMode = 'scale'
-				}}
-			/>
-		</fieldset>
+	<fieldset class="flex">
+		<Button
+			icon="mouse-pointer"
+			active={settings.current.transformMode === 'none'}
+			description="No transform controls"
+			hotkey="0"
+			onclick={() => {
+				settings.current.transformMode = 'none'
+			}}
+		/>
+		<Button
+			icon="cursor-move"
+			active={settings.current.transformMode === 'translate'}
+			description="Translate"
+			hotkey="1"
+			class="-ml-px"
+			onclick={() => {
+				settings.current.transformMode = 'translate'
+			}}
+		/>
+		<Button
+			icon="sync"
+			active={settings.current.transformMode === 'rotate'}
+			description="Rotate"
+			hotkey="2"
+			class="-ml-px"
+			onclick={() => {
+				settings.current.transformMode = 'rotate'
+			}}
+		/>
+		<Button
+			icon="resize"
+			active={settings.current.transformMode === 'scale'}
+			description="Scale"
+			hotkey="3"
+			class="-ml-px"
+			onclick={() => {
+				settings.current.transformMode = 'scale'
+			}}
+		/>
+	</fieldset>
 
-		<!-- snapping -->
+	<!-- snapping -->
+	{#if settings.current.transformMode !== 'none'}
 		<fieldset class="flex">
 			<Button
 				icon={settings.current.snapping ? 'magnet' : 'magnet-off'}

package/dist/draw.d.ts

@@ -2,18 +2,31 @@ import type { TransformWithUUID } from '@viamrobotics/sdk';
 import type { Entity, Trait, World } from 'koota';
 import type { Transform as TransformProto } from './buf/common/v1/common_pb';
 import type { Drawing } from './buf/draw/v1/drawing_pb';
+import type { Relationship } from './metadata';
 import { type Metadata } from './metadata';
 export type Transform = TransformWithUUID | TransformProto;
-type Options = {
+export declare const uuidBytesToString: (bytes: Uint8Array | undefined) => string | undefined;
+export declare const uuidStringToBytes: (uuid: string) => Uint8Array<ArrayBuffer>;
+interface DrawOptions {
     removable?: boolean;
+}
+export declare const drawTransform: (world: World, { referenceFrame, poseInObserverFrame, physicalObject, metadata, uuid }: Transform, api: Trait, { removable }?: DrawOptions) => {
+    entity: Entity;
+    relationships: import("@bufbuild/protobuf").PlainMessage<import("./buf/draw/v1/metadata_pb").Relationship>[] | undefined;
 };
-export declare const drawTransform: (world: World, { referenceFrame, poseInObserverFrame, physicalObject, metadata }: Transform, api: Trait, options?: Options) => Entity;
-export declare const drawDrawing: (world: World, drawing: Drawing, api: Trait, options?: Options) => Entity[];
-export declare const updateTransform: (entity: Entity, { poseInObserverFrame, physicalObject, metadata }: Transform, options?: Options) => void;
-export declare const updateMetadata: (entity: Entity, metadata: Metadata, { pointCloud }?: {
+export interface DrawingResult {
+    entity: Entity;
+    relationships: Relationship[] | undefined;
+}
+export declare const drawDrawing: (world: World, drawing: Drawing, api: Trait, { removable }?: DrawOptions) => DrawingResult;
+export declare const updateTransform: (entity: Entity, { poseInObserverFrame, physicalObject, metadata }: Transform, { removable }?: DrawOptions) => {
+    entity: Entity;
+    relationships: import("@bufbuild/protobuf").PlainMessage<import("./buf/draw/v1/metadata_pb").Relationship>[] | undefined;
+};
+interface MetadataOptions {
     pointCloud?: boolean;
-}) => void;
-export declare const updateDrawing: (world: World, entities: Entity[], drawing: Drawing, api: Trait, options?: Options) => Entity[];
-export declare const addColorTraits: (entity: Entity, colors: Uint8Array) => void;
-export declare const setColorTraits: (entity: Entity, colors: Uint8Array) => void;
+}
+export declare const updateMetadata: (entity: Entity, metadata: Metadata, { pointCloud }?: MetadataOptions) => void;
+export declare const updateDrawing: (world: World, entity: Entity, drawing: Drawing, { removable }?: DrawOptions) => DrawingResult;
+export declare const updateModel: (world: World, entity: Entity, drawing: Drawing, api: Trait, { removable }?: DrawOptions) => DrawingResult;
 export {};

package/dist/draw.js

@@ -1,8 +1,9 @@
 import { Vector3, Vector4 } from 'three';
 import { NURBSCurve } from 'three/addons/curves/NURBSCurve.js';
+import { UuidTool } from 'uuid-tool';
 import { createBufferGeometry, preAllocateBufferGeometry, updateBufferGeometry, writeBufferGeometryRange, } from './attribute';
 import { asFloat32Array, asOpacity, asRGB, inMeters, isSingleColor, isVertexColors, STRIDE, } from './buffer';
-import { traits } from './ecs';
+import { relations, traits } from './ecs';
 import { parsePcdInWorker } from './loaders/pcd';
 import { metadataFromStruct } from './metadata';
 import { createPose } from './transform';
@@ -21,12 +22,28 @@ const DEFAULT_LINE_DOT_COLORS = new Uint8Array([0, 0, 139]);
 const DEFAULT_POINTS_COLORS = new Uint8Array([51, 51, 51]);
 const DEFAULT_NURBS_COLORS = new Uint8Array([0, 255, 255]);
 const DEFAULT_OPACITY = 1;
-export const drawTransform = (world, { referenceFrame, poseInObserverFrame, physicalObject, metadata }, api, options = { removable: true }) => {
+export const uuidBytesToString = (bytes) => {
+    if (!bytes || bytes.length === 0)
+        return undefined;
+    return UuidTool.toString([...bytes]);
+};
+export const uuidStringToBytes = (uuid) => {
+    const arr = new Uint8Array(16);
+    arr.set(UuidTool.toBytes(uuid));
+    return arr;
+};
+const isModel = (drawing) => {
+    return drawing.physicalObject?.geometryType?.case === 'model';
+};
+export const drawTransform = (world, { referenceFrame, poseInObserverFrame, physicalObject, metadata, uuid }, api, { removable = true } = {}) => {
     const entityTraits = [
         traits.Name(referenceFrame),
         traits.Pose(createPose(poseInObserverFrame?.pose)),
         api,
     ];
+    const uuidStr = uuidBytesToString(uuid);
+    if (uuidStr)
+        entityTraits.push(traits.UUID(uuidStr));
     if (physicalObject) {
         entityTraits.push(traits.Geometry(physicalObject));
         const center = physicalObject.center;
@@ -36,7 +53,7 @@ export const drawTransform = (world, { referenceFrame, poseInObserverFrame, phys
     else {
         entityTraits.push(traits.ReferenceFrame);
     }
-    if (options.removable)
+    if (removable)
         entityTraits.push(traits.Removable);
     entityTraits.push(...traits.getParentTrait(poseInObserverFrame?.referenceFrame));
     const parsedMetadata = metadataFromStruct(metadata?.fields);
@@ -60,23 +77,28 @@ export const drawTransform = (world, { referenceFrame, poseInObserverFrame, phys
     const entity = world.spawn(...entityTraits);
     if (pointCloud)
         parsePointCloud(world, entity, pointCloud, parsedMetadata);
-    return entity;
+    return { entity, relationships: parsedMetadata.relationships };
 };
-export const drawDrawing = (world, drawing, api, options = { removable: true }) => {
-    const { referenceFrame, poseInObserverFrame, physicalObject, metadata } = drawing;
-    if (physicalObject?.geometryType?.case === 'model')
-        return drawModel(world, drawing, api, options);
-    const entity = world.spawn(traits.Name(referenceFrame), traits.Pose(createPose(poseInObserverFrame?.pose)), api, ...traits.getParentTrait(poseInObserverFrame?.referenceFrame));
-    if (options.removable)
+export const drawDrawing = (world, drawing, api, { removable = true } = {}) => {
+    const { referenceFrame, poseInObserverFrame, metadata, uuid } = drawing;
+    if (isModel(drawing)) {
+        return drawModel(world, drawing, api, { removable });
+    }
+    const uuidTraits = [];
+    const uuidStr = uuidBytesToString(uuid);
+    if (uuidStr)
+        uuidTraits.push(traits.UUID(uuidStr));
+    const entity = world.spawn(traits.Name(referenceFrame), traits.Pose(createPose(poseInObserverFrame?.pose)), api, ...traits.getParentTrait(poseInObserverFrame?.referenceFrame), ...uuidTraits);
+    if (removable)
         entity.add(traits.Removable);
     if (metadata?.showAxesHelper)
         entity.add(traits.ShowAxesHelper);
     if (metadata?.invisible)
         entity.add(traits.Invisible);
     applyShape(entity, drawing);
-    return [entity];
+    return { entity, relationships: metadata?.relationships };
 };
-export const updateTransform = (entity, { poseInObserverFrame, physicalObject, metadata }, options = { removable: true }) => {
+export const updateTransform = (entity, { poseInObserverFrame, physicalObject, metadata }, { removable = true } = {}) => {
     entity.set(traits.Pose, createPose(poseInObserverFrame?.pose));
     traits.setParentTrait(entity, poseInObserverFrame?.referenceFrame);
     if (physicalObject) {
@@ -89,13 +111,15 @@ export const updateTransform = (entity, { poseInObserverFrame, physicalObject, m
             entity.remove(traits.Center);
         }
     }
-    updateMetadata(entity, metadataFromStruct(metadata?.fields), {
+    const parsedMetadata = metadataFromStruct(metadata?.fields);
+    updateMetadata(entity, parsedMetadata, {
         pointCloud: isPointCloud(physicalObject?.geometryType),
     });
-    if (options.removable)
+    if (removable)
         entity.add(traits.Removable);
-    if (!options.removable)
+    if (!removable)
         entity.remove(traits.Removable);
+    return { entity, relationships: parsedMetadata.relationships };
 };
 export const updateMetadata = (entity, metadata, { pointCloud = false } = {}) => {
     if (metadata.showAxesHelper)
@@ -116,20 +140,10 @@ export const updateMetadata = (entity, metadata, { pointCloud = false } = {}) =>
     }
     entity.set(traits.Opacity, asOpacity(opacities, DEFAULT_OPACITY));
 };
-export const updateDrawing = (world, entities, drawing, api, options = { removable: true }) => {
-    const { poseInObserverFrame, physicalObject, metadata } = drawing;
-    if (physicalObject?.geometryType?.case === 'model') {
-        for (const entity of entities) {
-            if (world.has(entity))
-                entity.destroy();
-        }
-        return drawDrawing(world, drawing, api, options);
-    }
-    if (entities.length === 0)
-        return entities;
-    const entity = entities[0];
+export const updateDrawing = (world, entity, drawing, { removable = true } = {}) => {
+    const { poseInObserverFrame, metadata } = drawing;
     if (!world.has(entity))
-        return entities;
+        return { entity, relationships: metadata?.relationships };
     entity.set(traits.Pose, createPose(poseInObserverFrame?.pose));
     traits.setParentTrait(entity, poseInObserverFrame?.referenceFrame);
     if (metadata?.showAxesHelper)
@@ -140,8 +154,17 @@ export const updateDrawing = (world, entities, drawing, api, options = { removab
         entity.add(traits.Invisible);
     if (!metadata?.invisible)
         entity.remove(traits.Invisible);
+    if (removable)
+        entity.add(traits.Removable);
+    if (!removable)
+        entity.remove(traits.Removable);
     updateShape(entity, drawing);
-    return entities;
+    return { entity, relationships: metadata?.relationships };
+};
+export const updateModel = (world, entity, drawing, api, { removable = true } = {}) => {
+    if (world.has(entity))
+        entity.destroy();
+    return drawDrawing(world, drawing, api, { removable });
 };
 const applyShape = (entity, { physicalObject, metadata }) => {
     const colors = metadata?.colors;
@@ -242,32 +265,39 @@ const applyShape = (entity, { physicalObject, metadata }) => {
         }
     }
 };
-const drawModel = (world, { referenceFrame, poseInObserverFrame, physicalObject, metadata }, api, { removable = true }) => {
-    const entities = [];
-    const geometryType = physicalObject?.geometryType;
-    if (geometryType?.case !== 'model')
-        return entities;
+const drawModel = (world, model, api, { removable = true }) => {
+    const { referenceFrame, physicalObject, poseInObserverFrame, metadata, uuid } = model;
+    const { animationName, assets, scale } = physicalObject.geometryType.value;
     const baseTraits = [
         traits.Name(referenceFrame),
         traits.Pose(createPose(poseInObserverFrame?.pose)),
         api,
         ...traits.getParentTrait(poseInObserverFrame?.referenceFrame),
     ];
+    const uuidStr = uuidBytesToString(uuid);
+    if (uuidStr)
+        baseTraits.push(traits.UUID(uuidStr));
     if (removable)
         baseTraits.push(traits.Removable);
     if (metadata?.invisible)
         baseTraits.push(traits.Invisible);
-    entities.push(world.spawn(...baseTraits, traits.ReferenceFrame));
-    const { scale, animationName } = geometryType.value;
+    if (metadata?.showAxesHelper)
+        baseTraits.push(traits.ShowAxesHelper);
+    const root = world.spawn(...baseTraits, traits.ReferenceFrame);
     let i = 1;
-    for (const asset of geometryType.value.assets) {
+    for (const asset of assets) {
         const subEntityTraits = [
             traits.Name(`${referenceFrame} model ${i++}`),
             traits.Parent(referenceFrame),
+            relations.ChildOf(root),
             api,
         ];
         if (scale)
             subEntityTraits.push(traits.Scale(scale));
+        if (metadata?.invisible)
+            subEntityTraits.push(traits.Invisible);
+        if (metadata?.showAxesHelper)
+            subEntityTraits.push(traits.ShowAxesHelper);
         if (asset.content.case === 'url') {
             subEntityTraits.push(traits.GLTF({
                 source: { url: asset.content.value },
@@ -280,9 +310,9 @@ const drawModel = (world, { referenceFrame, poseInObserverFrame, physicalObject,
                 animationName: animationName ?? DEFAULT_ANIMATION_NAME,
             }));
         }
-        entities.push(world.spawn(...subEntityTraits));
+        world.spawn(...subEntityTraits);
     }
-    return entities;
+    return { entity: root, relationships: metadata?.relationships };
 };
 const parsePointCloud = (world, entity, pointCloud, metadata) => {
     parsePcdInWorker(new Uint8Array(pointCloud)).then((pointcloud) => {
@@ -422,7 +452,7 @@ const updateShape = (entity, { physicalObject, metadata }) => {
         }
     }
 };
-export const addColorTraits = (entity, colors) => {
+const addColorTraits = (entity, colors) => {
     if (isVertexColors(colors)) {
         entity.add(traits.Colors(colors));
     }
@@ -430,7 +460,7 @@ export const addColorTraits = (entity, colors) => {
         entity.add(traits.Color(asRGB(colors, rgb)));
     }
 };
-export const setColorTraits = (entity, colors) => {
+const setColorTraits = (entity, colors) => {
     if (isVertexColors(colors)) {
         if (entity.has(traits.Colors))
             entity.set(traits.Colors, colors);

package/dist/ecs/relations.js

@@ -1,5 +1,5 @@
 import { relation } from 'koota';
-export const ChildOf = relation({ exclusive: true });
+export const ChildOf = relation({ exclusive: true, autoDestroy: 'orphan' });
 export const SubEntityLinkType = {
     HoverLink: 'HoverLink',
 };

package/dist/ecs/traits.d.ts

@@ -4,6 +4,7 @@ import { type ConfigurableTrait, type Entity } from 'koota';
 import { BufferGeometry as ThreeBufferGeometry } from 'three';
 export declare const Name: import("koota").Trait<() => string>;
 export declare const Parent: import("koota").Trait<() => string>;
+export declare const UUID: import("koota").Trait<() => string>;
 export declare const Pose: import("koota").Trait<{
     x: number;
     y: number;
@@ -22,6 +23,15 @@ export declare const EditedPose: import("koota").Trait<{
     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;
+}>;
 export declare const Center: import("koota").Trait<{
     x: number;
     y: number;
@@ -77,6 +87,7 @@ export declare const Color: import("koota").Trait<{
  */
 export declare const Material: import("koota").Trait<{
     depthTest: boolean;
+    depthWrite: boolean;
 }>;
 export declare const DepthTest: import("koota").Trait<() => boolean>;
 export declare const Arrow: import("koota").Trait<() => boolean>;
@@ -144,6 +155,12 @@ export declare const SnapshotAPI: import("koota").Trait<() => boolean>;
  * Marker trait for entities created from user-dropped files (PLY, PCD, etc.)
  */
 export declare const DroppedFile: import("koota").Trait<() => boolean>;
+/**
+ * Marker trait for entities the dashboard's TransformControls may attach to —
+ * editable frames and ad-hoc custom geometries. Other entity kinds (lines,
+ * points, batched arrows, etc.) are deliberately excluded.
+ */
+export declare const Transformable: import("koota").Trait<() => boolean>;
 export declare const ShowAxesHelper: import("koota").Trait<() => boolean>;
 /**
  * Marker trait for entities that should be rendered in screen space (CSS pixels)

package/dist/ecs/traits.js

@@ -8,8 +8,10 @@ import { parsePcdInWorker } from '../loaders/pcd';
 import { parsePlyInput } from '../ply';
 export const Name = trait(() => '');
 export const Parent = trait(() => 'world');
+export const UUID = 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 });
 export const Center = trait({ x: 0, y: 0, z: 0, oX: 0, oY: 0, oZ: 1, theta: 0 });
 export const InstancedPose = trait({
     x: 0,
@@ -53,6 +55,7 @@ export const Color = trait({ r: 0, g: 0, b: 0 });
  */
 export const Material = trait({
     depthTest: false,
+    depthWrite: true,
 });
 export const DepthTest = trait(() => true);
 export const Arrow = trait(() => true);
@@ -101,6 +104,12 @@ export const SnapshotAPI = trait(() => true);
  * Marker trait for entities created from user-dropped files (PLY, PCD, etc.)
  */
 export const DroppedFile = trait(() => true);
+/**
+ * Marker trait for entities the dashboard's TransformControls may attach to —
+ * editable frames and ad-hoc custom geometries. Other entity kinds (lines,
+ * points, batched arrows, etc.) are deliberately excluded.
+ */
+export const Transformable = trait(() => true);
 export const ShowAxesHelper = trait(() => true);
 /**
  * Marker trait for entities that should be rendered in screen space (CSS pixels)

package/dist/editing/FrameEditSession.d.ts

@@ -0,0 +1,37 @@
+import type { Pose } from '@viamrobotics/sdk';
+import type { Entity } from 'koota';
+import type { Frame } from '../frame';
+export type UpdateFrameFn = (componentName: string, referenceFrame: string, pose: Pose, geometry?: Frame['geometry']) => void;
+export type DeleteFrameFn = (componentName: string) => void;
+/**
+ * A single user gesture against one or more frames (drag, parent change, geometry tweak).
+ * Owns the affected entities until commit() or abort() runs. Snapshots their pre-gesture
+ * trait state so abort() can restore — both the ECS view and the dirty part config.
+ *
+ * Replaces the Transforming marker trait: while a session is active, useFrames asks
+ * `session.owns(entity)` instead of inspecting a per-entity flag.
+ */
+export declare class FrameEditSession {
+    #private;
+    private snapshots;
+    private updateFrame;
+    private deleteFrame;
+    private onClose;
+    constructor(entities: Entity[], updateFrame: UpdateFrameFn, deleteFrame: DeleteFrameFn, onClose: () => void);
+    get isClosed(): boolean;
+    owns(entity: Entity | undefined): boolean;
+    stagePose: (entity: Entity, pose: Partial<Pose>) => void;
+    stageGeometry: (entity: Entity, geometry: Frame["geometry"]) => void;
+    stageParent: (entity: Entity, parent: string) => void;
+    stageDelete: (entity: Entity) => void;
+    /**
+     * Validate and close. Returns true on success. On invalid pose data
+     * (NaN/infinite from a degenerate gizmo state), aborts and returns false.
+     */
+    commit: () => boolean;
+    /**
+     * Restore each owned entity's traits to its pre-session state and re-issue
+     * an updateFrame so the dirty part config matches.
+     */
+    abort: () => void;
+}

package/dist/editing/FrameEditSession.js

@@ -0,0 +1,178 @@
+import { traits } from '../ecs';
+import { isFinitePose } from '../transform';
+const captureGeometry = (entity) => {
+    const box = entity.get(traits.Box);
+    if (box)
+        return { type: 'box', box: { ...box } };
+    const sphere = entity.get(traits.Sphere);
+    if (sphere)
+        return { type: 'sphere', sphere: { ...sphere } };
+    const capsule = entity.get(traits.Capsule);
+    if (capsule)
+        return { type: 'capsule', capsule: { ...capsule } };
+    return { type: 'none' };
+};
+const restoreGeometryTrait = (entity, snap) => {
+    if (snap.type === 'none') {
+        entity.remove(traits.Box, traits.Sphere, traits.Capsule);
+        return;
+    }
+    if (snap.type === 'box' && snap.box) {
+        entity.remove(traits.Sphere, traits.Capsule);
+        if (entity.has(traits.Box))
+            entity.set(traits.Box, snap.box);
+        else
+            entity.add(traits.Box(snap.box));
+        return;
+    }
+    if (snap.type === 'sphere' && snap.sphere) {
+        entity.remove(traits.Box, traits.Capsule);
+        if (entity.has(traits.Sphere))
+            entity.set(traits.Sphere, snap.sphere);
+        else
+            entity.add(traits.Sphere(snap.sphere));
+        return;
+    }
+    if (snap.type === 'capsule' && snap.capsule) {
+        entity.remove(traits.Box, traits.Sphere);
+        if (entity.has(traits.Capsule))
+            entity.set(traits.Capsule, snap.capsule);
+        else
+            entity.add(traits.Capsule(snap.capsule));
+    }
+};
+const snapshotToFrameGeometry = (snap) => {
+    if (snap.type === 'box' && snap.box)
+        return { type: 'box', ...snap.box };
+    if (snap.type === 'sphere' && snap.sphere)
+        return { type: 'sphere', ...snap.sphere };
+    if (snap.type === 'capsule' && snap.capsule)
+        return { type: 'capsule', ...snap.capsule };
+    return { type: 'none' };
+};
+const liveGeometry = (entity) => snapshotToFrameGeometry(captureGeometry(entity));
+/**
+ * A single user gesture against one or more frames (drag, parent change, geometry tweak).
+ * Owns the affected entities until commit() or abort() runs. Snapshots their pre-gesture
+ * trait state so abort() can restore — both the ECS view and the dirty part config.
+ *
+ * Replaces the Transforming marker trait: while a session is active, useFrames asks
+ * `session.owns(entity)` instead of inspecting a per-entity flag.
+ */
+export class FrameEditSession {
+    snapshots = new Map();
+    updateFrame;
+    deleteFrame;
+    onClose;
+    #closed = false;
+    constructor(entities, updateFrame, deleteFrame, onClose) {
+        this.updateFrame = updateFrame;
+        this.deleteFrame = deleteFrame;
+        this.onClose = onClose;
+        for (const entity of entities) {
+            const name = entity.get(traits.Name);
+            const editedPose = entity.get(traits.EditedPose);
+            if (!name || !editedPose)
+                continue;
+            this.snapshots.set(entity, {
+                name,
+                parent: entity.get(traits.Parent) ?? 'world',
+                editedPose: { ...editedPose },
+                geometry: captureGeometry(entity),
+            });
+        }
+    }
+    get isClosed() {
+        return this.#closed;
+    }
+    owns(entity) {
+        return entity !== undefined && !this.#closed && this.snapshots.has(entity);
+    }
+    stagePose = (entity, pose) => {
+        const snap = this.snapshots.get(entity);
+        if (!snap || this.#closed)
+            return;
+        const current = entity.get(traits.EditedPose);
+        if (!current)
+            return;
+        const next = { ...current, ...pose };
+        entity.set(traits.EditedPose, next);
+        this.updateFrame(snap.name, entity.get(traits.Parent) ?? 'world', next, liveGeometry(entity));
+    };
+    stageGeometry = (entity, geometry) => {
+        const snap = this.snapshots.get(entity);
+        if (!snap || this.#closed || !geometry)
+            return;
+        if (geometry.type === 'none') {
+            entity.remove(traits.Box, traits.Sphere, traits.Capsule);
+        }
+        else if (geometry.type === 'box') {
+            const data = { x: geometry.x, y: geometry.y, z: geometry.z };
+            restoreGeometryTrait(entity, { type: 'box', box: data });
+        }
+        else if (geometry.type === 'sphere') {
+            restoreGeometryTrait(entity, { type: 'sphere', sphere: { r: geometry.r } });
+        }
+        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, entity.get(traits.Parent) ?? 'world', editedPose, geometry);
+        }
+    };
+    stageParent = (entity, parent) => {
+        const snap = this.snapshots.get(entity);
+        if (!snap || this.#closed)
+            return;
+        traits.setParentTrait(entity, parent === 'world' ? undefined : parent);
+        const editedPose = entity.get(traits.EditedPose);
+        if (editedPose) {
+            this.updateFrame(snap.name, parent, editedPose, liveGeometry(entity));
+        }
+    };
+    stageDelete = (entity) => {
+        const snap = this.snapshots.get(entity);
+        if (!snap || this.#closed)
+            return;
+        this.deleteFrame(snap.name);
+    };
+    /**
+     * Validate and close. Returns true on success. On invalid pose data
+     * (NaN/infinite from a degenerate gizmo state), aborts and returns false.
+     */
+    commit = () => {
+        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;
+            }
+        }
+        this.#close();
+        return true;
+    };
+    /**
+     * Restore each owned entity's traits to its pre-session state and re-issue
+     * an updateFrame so the dirty part config matches.
+     */
+    abort = () => {
+        if (this.#closed)
+            return;
+        for (const [entity, snap] of this.snapshots) {
+            if (entity.isAlive()) {
+                entity.set(traits.EditedPose, snap.editedPose);
+                traits.setParentTrait(entity, snap.parent === 'world' ? undefined : snap.parent);
+                restoreGeometryTrait(entity, snap.geometry);
+            }
+            this.updateFrame(snap.name, snap.parent, snap.editedPose, snapshotToFrameGeometry(snap.geometry));
+        }
+        this.#close();
+    };
+    #close = () => {
+        this.#closed = true;
+        this.onClose();
+    };
+}

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

@@ -6,6 +6,8 @@ declare const ConnectionStatus: {
 type ConnectionStatusType = (typeof ConnectionStatus)[keyof typeof ConnectionStatus];
 interface Context {
     connectionStatus: ConnectionStatusType;
+    createRelationship: (sourceUuid: string, targetUuid: string, type: string, indexMapping?: string) => Promise<void>;
+    deleteRelationship: (sourceUuid: string, targetUuid: string) => Promise<void>;
 }
 export declare function provideDrawService(): void;
 export declare function useDrawService(): Context;