@fps-games/editor 0.1.1-beta.6 → 0.1.1-beta.8

package/dist/local-editor-harness.js

@@ -1,6 +1,6 @@
-import { createEditorSession, createInspectorRegistry, DEFAULT_EDITOR_TRANSFORM_OPERATION_SETTINGS, createInspectorEditPayload, computeEditorTransformActionTargets, mergeInspectorSections, normalizeEditorTransformConstraint, serializedMultiObjectToInspectorObject, serializedObjectToInspectorObject, validateSceneGraphDelete, validateSceneGraphDrop, validateSceneGraphGroupSelection, validateSceneGraphMove, validateSceneGraphRename, } from '@fps-games/editor-core';
+import { createEditorSession, createInspectorRegistry, DEFAULT_EDITOR_TRANSFORM_OPERATION_SETTINGS, DEFAULT_EDITOR_VIEWPORT_TOOL_STATE, createEmptyEditorViewportSpatialOverlayState, cloneEditorViewportToolState, cloneEditorViewportSpatialOverlayState, createInspectorEditPayload, computeEditorTransformActionTargets, mergeInspectorSections, normalizeEditorTransformConstraint, resolveEditorSelectionCommand, serializedMultiObjectToInspectorObject, serializedObjectToInspectorObject, validateSceneGraphDelete, validateSceneGraphDrop, validateSceneGraphGroupSelection, validateSceneGraphMove, validateSceneGraphRename, } from '@fps-games/editor-core';
 import { createLocalEditorBrowserUi, } from '@fps-games/editor-browser';
-import { createBabylonEditorProjection, createBabylonEditorWorld, createBabylonProjectionSelectionController, createBabylonSceneCameraPreviewController, createBabylonSceneViewCameraController, createBabylonSceneViewInputController, createBabylonTransformGizmoController, focusEditorViewportSelection, } from '@fps-games/editor-babylon';
+import { createBabylonEditorProjection, createBabylonEditorWorld, createBabylonProjectionSelectionController, createBabylonSceneCameraPreviewController, createBabylonSceneViewCameraController, createBabylonSceneViewInputController, createBabylonSceneViewMeasurementController, createBabylonSceneViewSpatialOverlayController, createBabylonTransformGizmoController, focusEditorViewportSelection, } from '@fps-games/editor-babylon';
 export function createLocalEditorHarness(options) {
     const root = options.root ?? document.body;
     const state = {
@@ -13,18 +13,25 @@ export function createLocalEditorHarness(options) {
         babylon: null,
         engine: null,
         world: null,
+        grid: null,
+        gridVisible: true,
         projection: null,
         gizmo: null,
         sceneCameraPreview: null,
         sceneCameraPreviewEnabled: false,
         sceneViewInput: null,
         sceneViewCamera: null,
+        sceneViewMeasurement: null,
+        sceneViewSpatialOverlay: null,
         selectionController: null,
         boxSelection: null,
         transformTool: 'select',
         transformSpace: 'world',
         transformConstraint: 'axis',
         transformOperationSettings: cloneTransformOperationSettings(DEFAULT_EDITOR_TRANSFORM_OPERATION_SETTINGS),
+        viewportTools: cloneEditorViewportToolState(DEFAULT_EDITOR_VIEWPORT_TOOL_STATE),
+        viewportMeasurement: createEmptyViewportMeasurement(),
+        viewportSpatialOverlay: createEmptyEditorViewportSpatialOverlayState(),
         duplicateDrag: null,
         armedPlacement: null,
         resizeHandler: null,
@@ -69,6 +76,10 @@ export function createLocalEditorHarness(options) {
                 if (selectItem(state, options, input))
                     harness.render();
             },
+            onSelectionCommand: (command) => {
+                if (dispatchSelectionCommand(state, options, command))
+                    harness.render();
+            },
             onSceneGraphRename: (intent) => {
                 if (renameSceneGraphNode(state, options, intent))
                     harness.render();
@@ -77,6 +88,12 @@ export function createLocalEditorHarness(options) {
                 if (createSceneGraphGroup(state, options, intent))
                     harness.render();
             },
+            onSceneGraphCreatePrimitive: options.documentAdapter.createSceneGraphCreatePrimitivePatch
+                ? (intent) => {
+                    if (createSceneGraphPrimitive(state, options, intent))
+                        harness.render();
+                }
+                : undefined,
             onSceneGraphDelete: (intent) => {
                 if (deleteSceneGraphNodes(state, options, intent))
                     harness.render();
@@ -174,14 +191,42 @@ export function createLocalEditorHarness(options) {
                 if (executeTransformAction(state, options, action))
                     harness.render();
             },
+            onViewportViewPresetChange: (preset) => {
+                if (setViewportViewPreset(state, preset))
+                    harness.render();
+            },
+            onViewportProjectionModeChange: (mode) => {
+                if (setViewportProjectionMode(state, mode))
+                    harness.render();
+            },
+            onViewportOverlaySettingsChange: (settings) => {
+                if (setViewportOverlaySettings(state, settings))
+                    harness.render();
+            },
+            onViewportUtilityToolChange: (tool) => {
+                if (setViewportUtilityTool(state, tool))
+                    harness.render();
+            },
+            onViewportMeasurementClear: () => {
+                if (clearViewportMeasurement(state))
+                    harness.render();
+            },
             onSceneCameraPreviewToggle: (enabled) => {
                 if (setSceneCameraPreviewEnabled(state, options, enabled))
                     harness.render();
             },
+            onGridVisibleChange: (visible) => {
+                if (setGridVisible(state, visible))
+                    harness.render();
+            },
             onFocusSelection: () => {
                 if (focusSelectedProjection(state))
                     harness.render();
             },
+            onCancelEditorIntent: () => {
+                if (cancelEditorIntent(state, options))
+                    harness.render();
+            },
             onCancelActiveOperation: () => {
                 cancelActiveOperation(state);
                 harness.render();
@@ -191,6 +236,9 @@ export function createLocalEditorHarness(options) {
     harness = {
         render() {
             syncSceneCameraPreview(state, options);
+            syncViewportCameraState(state);
+            syncViewportMeasurementState(state);
+            syncViewportSpatialOverlay(state);
             ui.update(createUiState(state, options));
         },
         setTheme(theme) {
@@ -404,6 +452,224 @@ function normalizePositiveStep(value) {
 function normalizePlacementMode(mode) {
     return mode === 'ground' || mode === 'surface' ? mode : 'off';
 }
+function normalizeViewportViewPreset(preset) {
+    return preset === 'top' || preset === 'front' || preset === 'right' ? preset : 'perspective';
+}
+function normalizeViewportProjectionMode(mode) {
+    return mode === 'orthographic' ? 'orthographic' : 'perspective';
+}
+function createEmptyViewportMeasurement() {
+    return {
+        active: false,
+        start: null,
+        end: null,
+        preview: null,
+        distance: null,
+        screenStart: null,
+        screenEnd: null,
+        screenPreview: null,
+        label: null,
+    };
+}
+function cloneViewportMeasurement(measurement) {
+    return {
+        active: measurement.active,
+        start: measurement.start ? { ...measurement.start } : null,
+        end: measurement.end ? { ...measurement.end } : null,
+        preview: measurement.preview ? { ...measurement.preview } : null,
+        distance: measurement.distance,
+        screenStart: measurement.screenStart ? { ...measurement.screenStart } : null,
+        screenEnd: measurement.screenEnd ? { ...measurement.screenEnd } : null,
+        screenPreview: measurement.screenPreview ? { ...measurement.screenPreview } : null,
+        label: measurement.label ? { ...measurement.label } : null,
+    };
+}
+function setViewportViewPreset(state, preset) {
+    if (state.sceneCameraPreviewEnabled) {
+        state.status = 'Viewport view unavailable during Scene Camera preview';
+        state.statusTone = 'warning';
+        state.statusToneStatus = state.status;
+        state.statusDetails = 'Disable Scene Camera preview before switching editor viewport views.';
+        return true;
+    }
+    const nextPreset = normalizeViewportViewPreset(preset);
+    const target = resolveViewportPresetTarget(state);
+    const radius = resolveViewportPresetRadius(state);
+    const changed = state.sceneViewCamera?.setViewPreset(nextPreset, { target, radius }) ?? false;
+    if (!changed)
+        return false;
+    const cameraState = state.sceneViewCamera?.getState();
+    state.viewportTools = {
+        ...state.viewportTools,
+        viewPreset: cameraState?.viewPreset ?? nextPreset,
+        projectionMode: cameraState?.projectionMode ?? (nextPreset === 'perspective' ? 'perspective' : 'orthographic'),
+    };
+    state.status = `Viewport view: ${state.viewportTools.viewPreset}`;
+    state.statusTone = 'default';
+    state.statusToneStatus = state.status;
+    state.statusDetails = '';
+    return true;
+}
+function setViewportProjectionMode(state, mode) {
+    if (state.sceneCameraPreviewEnabled) {
+        state.status = 'Viewport projection unavailable during Scene Camera preview';
+        state.statusTone = 'warning';
+        state.statusToneStatus = state.status;
+        state.statusDetails = 'Disable Scene Camera preview before switching editor viewport projection.';
+        return true;
+    }
+    const nextMode = normalizeViewportProjectionMode(mode);
+    const changed = state.sceneViewCamera?.setProjectionMode(nextMode) ?? false;
+    if (!changed)
+        return false;
+    const cameraState = state.sceneViewCamera?.getState();
+    state.viewportTools = {
+        ...state.viewportTools,
+        projectionMode: cameraState?.projectionMode ?? nextMode,
+    };
+    state.status = `Viewport projection: ${state.viewportTools.projectionMode}`;
+    state.statusTone = 'default';
+    state.statusToneStatus = state.status;
+    state.statusDetails = '';
+    return true;
+}
+function setViewportOverlaySettings(state, settings) {
+    state.viewportTools = {
+        ...state.viewportTools,
+        overlay: {
+            ...state.viewportTools.overlay,
+            bounds: settings.bounds ?? state.viewportTools.overlay.bounds,
+            dimensions: settings.dimensions ?? state.viewportTools.overlay.dimensions,
+            edgeLengths: settings.edgeLengths ?? state.viewportTools.overlay.edgeLengths,
+            anchor: settings.anchor ?? state.viewportTools.overlay.anchor,
+        },
+    };
+    state.status = 'Viewport overlay settings updated';
+    state.statusTone = 'default';
+    state.statusToneStatus = state.status;
+    state.statusDetails = '';
+    return true;
+}
+function setViewportUtilityTool(state, tool) {
+    const nextTool = tool === 'measure-distance' ? 'measure-distance' : 'none';
+    state.viewportTools = {
+        ...state.viewportTools,
+        activeUtilityTool: nextTool,
+    };
+    if (nextTool === 'measure-distance') {
+        state.viewportMeasurement = {
+            ...cloneViewportMeasurement(state.viewportMeasurement),
+            active: !!state.viewportMeasurement.start && !state.viewportMeasurement.end,
+        };
+        state.status = 'Measure distance: pick first XZ ground point';
+    }
+    else {
+        const unfinishedMeasurement = state.viewportMeasurement.active
+            || (!!state.viewportMeasurement.start && !state.viewportMeasurement.end);
+        state.viewportMeasurement = unfinishedMeasurement
+            ? state.sceneViewMeasurement?.clear() ?? createEmptyViewportMeasurement()
+            : {
+                ...cloneViewportMeasurement(state.viewportMeasurement),
+                active: false,
+                preview: null,
+                screenPreview: null,
+            };
+        state.status = 'Viewport utility: none';
+    }
+    state.statusTone = 'default';
+    state.statusToneStatus = state.status;
+    state.statusDetails = '';
+    return true;
+}
+function clearViewportMeasurement(state) {
+    state.viewportMeasurement = state.sceneViewMeasurement?.clear() ?? createEmptyViewportMeasurement();
+    state.viewportTools = {
+        ...state.viewportTools,
+        activeUtilityTool: 'none',
+    };
+    state.status = 'Measurement cleared';
+    state.statusTone = 'default';
+    state.statusToneStatus = state.status;
+    state.statusDetails = '';
+    return true;
+}
+export function applyLocalEditorHarnessViewportMeasurementPointerStart(state, event) {
+    if (state.viewportTools.activeUtilityTool !== 'measure-distance')
+        return false;
+    if (!state.viewportMeasurement.start || state.viewportMeasurement.end) {
+        const next = state.sceneViewMeasurement?.beginAt(event.clientX, event.clientY) ?? null;
+        if (!next)
+            return false;
+        state.viewportMeasurement = next;
+        state.status = 'Measure distance: pick second XZ ground point';
+        state.statusTone = 'default';
+        state.statusToneStatus = state.status;
+        state.statusDetails = '';
+        return true;
+    }
+    const next = state.sceneViewMeasurement?.completeAt(event.clientX, event.clientY) ?? null;
+    if (!next)
+        return false;
+    state.viewportMeasurement = next;
+    state.viewportTools = {
+        ...state.viewportTools,
+        activeUtilityTool: 'none',
+    };
+    state.status = `Measured distance: ${formatViewportMeasurementDistance(next.distance)} units`;
+    state.statusTone = 'default';
+    state.statusToneStatus = state.status;
+    state.statusDetails = next.start && next.end
+        ? `A (${formatViewportMeasurementDistance(next.start.x)}, ${formatViewportMeasurementDistance(next.start.z)}) · B (${formatViewportMeasurementDistance(next.end.x)}, ${formatViewportMeasurementDistance(next.end.z)})`
+        : '';
+    return true;
+}
+export function applyLocalEditorHarnessViewportMeasurementPointerMove(state, event) {
+    if (state.viewportTools.activeUtilityTool !== 'measure-distance')
+        return false;
+    const next = state.sceneViewMeasurement?.previewAt(event.clientX, event.clientY) ?? null;
+    if (!next)
+        return false;
+    state.viewportMeasurement = next;
+    return true;
+}
+export function applyLocalEditorHarnessViewportMeasurementPointerEnd(_state) {
+    return false;
+}
+function handleViewportMeasurementStart(state, event) {
+    return applyLocalEditorHarnessViewportMeasurementPointerStart(state, event);
+}
+function handleViewportMeasurementMove(state, event) {
+    return applyLocalEditorHarnessViewportMeasurementPointerMove(state, event);
+}
+function handleViewportMeasurementEnd(state) {
+    return applyLocalEditorHarnessViewportMeasurementPointerEnd(state);
+}
+function formatViewportMeasurementDistance(value) {
+    if (!Number.isFinite(value))
+        return '0';
+    const rounded = Math.abs(value) < 0.005 ? 0 : value;
+    return rounded.toFixed(2).replace(/\.?0+$/, '');
+}
+function resolveViewportPresetTarget(state) {
+    const selection = state.session?.getState().selection;
+    const activeId = selection?.activeId ?? null;
+    if (!activeId || selection?.selectedIds.length !== 1)
+        return null;
+    const bounds = state.projection?.getSelectionBounds([activeId]) ?? null;
+    return bounds?.center ?? null;
+}
+function resolveViewportPresetRadius(state) {
+    const selection = state.session?.getState().selection;
+    const activeId = selection?.activeId ?? null;
+    if (!activeId || selection?.selectedIds.length !== 1)
+        return undefined;
+    const bounds = state.projection?.getSelectionBounds([activeId]) ?? null;
+    if (!bounds)
+        return undefined;
+    const size = bounds.size;
+    const radius = Math.hypot(size.x, size.y, size.z);
+    return Number.isFinite(radius) && radius > 0 ? Math.max(radius * 1.5, 2) : undefined;
+}
 function validateTransformActionSelection(state, action) {
     const selection = state.session?.getState().selection;
     const selectedCount = selection?.selectedIds.length ?? 0;
@@ -430,10 +696,12 @@ async function createEditorWorld(state, options, render) {
         cameraTarget: options.world?.cameraTarget,
         cameraRadius: options.world?.cameraRadius,
         clearColor: options.world?.clearColor,
+        sky: options.world?.sky,
         useRightHandedSystem: options.world?.useRightHandedSystem,
         enableDefaultCameraControls: false,
     });
-    options.createGrid?.(babylon, world.scene);
+    const grid = options.createGrid?.(babylon, world.scene) ?? null;
+    grid?.setVisible(state.gridVisible);
     const projection = createBabylonEditorProjection({
         babylon,
         scene: world.scene,
@@ -498,6 +766,10 @@ async function createEditorWorld(state, options, render) {
             render();
         },
     });
+    const sceneViewMeasurement = createBabylonSceneViewMeasurementController({
+        babylon,
+        scene: world.scene,
+    });
     const sceneViewInput = createBabylonSceneViewInputController({
         canvas,
         isEnabled: () => state.mode === 'editor',
@@ -505,7 +777,13 @@ async function createEditorWorld(state, options, render) {
         isBoxSelectCandidate: (event) => selectionController.isBoxSelectionCandidate(event),
         isViewPlaneMoveCandidate: (event) => gizmo.isViewPlaneMoveCandidate(event),
         isPlacementCandidate: () => isPlacementArmed(state),
+        isMeasurementCandidate: () => state.viewportTools.activeUtilityTool === 'measure-distance',
         onPointerIntentStart(event) {
+            if (event.state.intent === 'measurement') {
+                if (handleViewportMeasurementStart(state, event.originalEvent))
+                    render();
+                return;
+            }
             if (event.state.intent === 'gizmo-drag') {
                 gizmo.preparePointerDrag(event.originalEvent);
                 return;
@@ -525,6 +803,11 @@ async function createEditorWorld(state, options, render) {
             }
         },
         onPointerIntentMove(event) {
+            if (event.state.intent === 'measurement') {
+                if (handleViewportMeasurementMove(state, event.originalEvent))
+                    render();
+                return;
+            }
             if (event.state.intent === 'placement') {
                 if (previewArmedPlacement(state, event.originalEvent))
                     render();
@@ -544,6 +827,11 @@ async function createEditorWorld(state, options, render) {
             }
         },
         onPointerIntentEnd(event) {
+            if (event.state.intent === 'measurement') {
+                if (handleViewportMeasurementEnd(state))
+                    render();
+                return;
+            }
             if (event.state.intent === 'placement') {
                 if (commitArmedPlacement(state, options, event.originalEvent))
                     render();
@@ -559,6 +847,10 @@ async function createEditorWorld(state, options, render) {
             }
         },
         onPointerIntentCancel(event) {
+            if (event.state.intent === 'measurement') {
+                render();
+                return;
+            }
             if (event.state.intent === 'placement') {
                 state.gizmo?.setPlacementMarker(null);
                 render();
@@ -593,6 +885,10 @@ async function createEditorWorld(state, options, render) {
         scene: world.scene,
         editorCamera: world.camera,
     });
+    const sceneViewSpatialOverlay = createBabylonSceneViewSpatialOverlayController({
+        babylon,
+        scene: world.scene,
+    });
     const document = state.session?.getState().workingDocument;
     if (document) {
         projection.projectNodes(options.documentAdapter.getProjectionNodes(document));
@@ -606,11 +902,14 @@ async function createEditorWorld(state, options, render) {
     state.babylon = babylon;
     state.engine = engine;
     state.world = world;
+    state.grid = grid;
     state.projection = projection;
     state.gizmo = gizmo;
     state.sceneCameraPreview = sceneCameraPreview;
     state.sceneViewInput = sceneViewInput;
     state.sceneViewCamera = sceneViewCamera;
+    state.sceneViewMeasurement = sceneViewMeasurement;
+    state.sceneViewSpatialOverlay = sceneViewSpatialOverlay;
     state.selectionController = selectionController;
     state.resizeHandler = resize;
 }
@@ -624,15 +923,27 @@ function disposeEditorWorld(state) {
     state.sceneCameraPreviewEnabled = false;
     state.sceneViewCamera?.dispose();
     state.sceneViewCamera = null;
+    state.sceneViewMeasurement?.dispose();
+    state.sceneViewMeasurement = null;
+    state.sceneViewSpatialOverlay?.dispose();
+    state.sceneViewSpatialOverlay = null;
     state.sceneViewInput?.dispose();
     state.sceneViewInput = null;
     state.selectionController?.dispose();
     state.selectionController = null;
     state.boxSelection = null;
+    state.viewportSpatialOverlay = createEmptyEditorViewportSpatialOverlayState();
+    state.viewportMeasurement = createEmptyViewportMeasurement();
+    state.viewportTools = {
+        ...state.viewportTools,
+        activeUtilityTool: 'none',
+    };
     state.gizmo?.dispose();
     state.gizmo = null;
     state.projection?.dispose();
     state.projection = null;
+    state.grid?.dispose();
+    state.grid = null;
     state.engine?.stopRenderLoop?.();
     state.world?.dispose();
     state.engine?.dispose?.();
@@ -665,26 +976,16 @@ function selectItem(state, options, input) {
         return false;
     if (!isDocumentNodeSelectable(state, options, input.id))
         return false;
-    const command = input.toggle
-        ? {
-            type: 'selection.toggle',
-            selectedIds: [input.id],
-            activeId: input.id,
-            label: 'Toggle Selection',
-        }
-        : input.additive
-            ? {
-                type: 'selection.add',
-                selectedIds: [input.id],
-                activeId: input.id,
-                label: 'Add Selection',
-            }
-            : {
-                type: 'selection.replace',
-                selectedIds: [input.id],
-                activeId: input.id,
-                label: 'Select Item',
-            };
+    const selection = state.session?.getState().selection ?? { selectedIds: [], activeId: null };
+    const command = resolveEditorSelectionCommand({
+        selection,
+        targetIds: [input.id],
+        activeId: input.id,
+        gesture: 'click',
+        modifier: input.toggle ? 'toggle' : input.additive ? 'additive' : 'replace',
+    });
+    if (!command)
+        return false;
     return dispatchSelectionCommand(state, options, command);
 }
 function handleContextAction(state, options, action) {
@@ -708,7 +1009,15 @@ function handleContextAction(state, options, action) {
         return createSceneGraphGroup(state, options, {
             parentId: action.parentId ?? null,
             activeId: action.activeId ?? null,
-            name: 'Group',
+            name: 'Empty',
+        });
+    }
+    if (action.action === 'create-primitive') {
+        return createSceneGraphPrimitive(state, options, {
+            parentId: action.parentId ?? null,
+            activeId: action.activeId ?? null,
+            shape: action.shape,
+            name: action.name,
         });
     }
     if (action.action === 'delete') {
@@ -781,17 +1090,17 @@ function createSceneGraphGroup(state, options, intent) {
     cancelActiveOperation(state);
     const patch = options.documentAdapter.createSceneGraphCreateGroupPatch?.(document, intent);
     if (!patch) {
-        state.status = 'Create group rejected';
+        state.status = 'Create empty rejected';
         return true;
     }
     const result = state.session.dispatch({
         type: 'document.patch',
-        label: patch.label ?? 'Create Empty Group',
+        label: patch.label ?? 'Create Empty',
         patch: patch.patch,
         targetId: patch.createdId ?? undefined,
     });
     if (!result.documentChanged) {
-        state.status = 'Create group unchanged';
+        state.status = 'Create empty unchanged';
         return true;
     }
     const createdId = patch.createdId ?? null;
@@ -801,12 +1110,47 @@ function createSceneGraphGroup(state, options, intent) {
             type: 'selection.replace',
             selectedIds: [createdId],
             activeId: createdId,
-            label: 'Select Created Group',
+            label: 'Select Created Empty',
         }).selection;
     }
     rebuildProjectionFromDocument(state, options, result.workingDocument, selection);
     state.summary = summarizeDocument(options, result.workingDocument, state.session.getSource());
-    state.status = patch.label ?? (createdId ? `Created group ${createdId}` : 'Created group');
+    state.status = patch.label ?? (createdId ? `Created empty ${createdId}` : 'Created empty');
+    return true;
+}
+function createSceneGraphPrimitive(state, options, intent) {
+    const document = state.session?.getState().workingDocument;
+    if (state.mode !== 'editor' || !state.session || !document)
+        return false;
+    cancelActiveOperation(state);
+    const patch = options.documentAdapter.createSceneGraphCreatePrimitivePatch?.(document, intent);
+    if (!patch) {
+        state.status = `Create ${intent.shape} rejected`;
+        return true;
+    }
+    const result = state.session.dispatch({
+        type: 'document.patch',
+        label: patch.label ?? `Create ${intent.shape}`,
+        patch: patch.patch,
+        targetId: patch.createdId ?? undefined,
+    });
+    if (!result.documentChanged) {
+        state.status = `Create ${intent.shape} unchanged`;
+        return true;
+    }
+    const createdId = patch.createdId ?? null;
+    let selection = result.selection;
+    if (createdId && isNodeSelectableInDocument(options, result.workingDocument, createdId)) {
+        selection = state.session.dispatch({
+            type: 'selection.replace',
+            selectedIds: [createdId],
+            activeId: createdId,
+            label: 'Select Created Primitive',
+        }).selection;
+    }
+    rebuildProjectionFromDocument(state, options, result.workingDocument, selection);
+    state.summary = summarizeDocument(options, result.workingDocument, state.session.getSource());
+    state.status = patch.label ?? (createdId ? `Created ${intent.shape} ${createdId}` : `Created ${intent.shape}`);
     return true;
 }
 function deleteSceneGraphNodes(state, options, intent) {
@@ -996,27 +1340,27 @@ function groupSceneGraphSelection(state, options, intent) {
     const hierarchy = options.documentAdapter.getHierarchyItems(document);
     const coreValidation = validateSceneGraphGroupSelection(hierarchy, intent);
     if (!coreValidation.ok) {
-        state.status = `Group selection rejected: ${coreValidation.reason ?? 'invalid scene graph group selection'}`;
+        state.status = `Parent selection rejected: ${coreValidation.reason ?? 'invalid scene graph parent selection'}`;
         return true;
     }
     const projectValidation = options.documentAdapter.validateSceneGraphGroupSelection?.(document, intent);
     if (projectValidation && !projectValidation.ok) {
-        state.status = `Group selection rejected: ${projectValidation.reason ?? 'project validation failed'}`;
+        state.status = `Parent selection rejected: ${projectValidation.reason ?? 'project validation failed'}`;
         return true;
     }
     const patch = options.documentAdapter.createSceneGraphGroupSelectionPatch?.(document, intent);
     if (!patch) {
-        state.status = 'Group selection rejected';
+        state.status = 'Parent selection rejected';
         return true;
     }
     const result = state.session.dispatch({
         type: 'document.patch',
-        label: patch.label ?? 'Group Selection',
+        label: patch.label ?? 'Parent Selection',
         patch: patch.patch,
         targetId: patch.createdId,
     });
     if (!result.documentChanged) {
-        state.status = 'Group selection unchanged';
+        state.status = 'Parent selection unchanged';
         return true;
     }
     let selection = result.selection;
@@ -1025,7 +1369,7 @@ function groupSceneGraphSelection(state, options, intent) {
             type: 'selection.replace',
             selectedIds: [patch.createdId],
             activeId: patch.createdId,
-            label: 'Select Created Group',
+            label: 'Select Created Parent',
         }).selection;
     }
     else {
@@ -1033,7 +1377,7 @@ function groupSceneGraphSelection(state, options, intent) {
     }
     rebuildProjectionFromDocument(state, options, result.workingDocument, selection);
     state.summary = summarizeDocument(options, result.workingDocument, state.session.getSource());
-    state.status = patch.label ?? `Grouped ${patch.changedIds?.length ?? intent.ids.length} node(s)`;
+    state.status = patch.label ?? `Parented ${patch.changedIds?.length ?? intent.ids.length} node(s)`;
     return true;
 }
 function sanitizeSelection(state, options, document, selection) {
@@ -1593,6 +1937,21 @@ function cancelActiveOperation(state) {
     cancelActiveGizmoDrag(state);
     clearArmedPlacement(state);
 }
+function cancelEditorIntent(state, options) {
+    if (state.mode !== 'editor')
+        return false;
+    if (state.viewportTools.activeUtilityTool === 'measure-distance'
+        || state.viewportMeasurement.start
+        || state.viewportMeasurement.end) {
+        return clearViewportMeasurement(state);
+    }
+    const selection = state.session?.getSelection();
+    if (selection && selection.selectedIds.length > 0) {
+        return dispatchSelectionCommand(state, options, { type: 'selection.clear', label: 'Clear Selection' });
+    }
+    cancelActiveOperation(state);
+    return true;
+}
 function focusSelectedProjection(state) {
     if (state.mode !== 'editor')
         return false;
@@ -1716,6 +2075,18 @@ function setSceneCameraPreviewEnabled(state, options, enabled) {
     state.status = 'Scene Camera preview enabled';
     return true;
 }
+function setGridVisible(state, visible) {
+    const nextVisible = visible === true;
+    if (state.gridVisible === nextVisible)
+        return false;
+    state.gridVisible = nextVisible;
+    state.grid?.setVisible(nextVisible);
+    state.status = nextVisible ? 'Grid visible' : 'Grid hidden';
+    state.statusTone = 'default';
+    state.statusToneStatus = state.status;
+    state.statusDetails = '';
+    return true;
+}
 function syncSceneCameraPreview(state, options) {
     const controller = state.sceneCameraPreview;
     if (!controller)
@@ -1733,6 +2104,40 @@ function syncSceneCameraPreview(state, options) {
     controller.setActive(true, rig);
     return controller.isActive();
 }
+function syncViewportCameraState(state) {
+    const cameraState = state.sceneViewCamera?.getState();
+    if (!cameraState)
+        return;
+    state.viewportTools = {
+        ...state.viewportTools,
+        viewPreset: cameraState.viewPreset,
+        projectionMode: cameraState.projectionMode,
+    };
+}
+function syncViewportSpatialOverlay(state) {
+    const overlay = state.sceneViewSpatialOverlay;
+    const selection = state.session?.getState().selection;
+    const activeId = selection?.activeId ?? null;
+    if (state.mode !== 'editor' || !overlay || !activeId || selection?.selectedIds.length !== 1) {
+        state.viewportSpatialOverlay = createEmptyEditorViewportSpatialOverlayState();
+        return;
+    }
+    const bounds = state.projection?.getSelectionBounds([activeId]) ?? null;
+    const anchor = state.projection?.readNodeTransform(activeId)?.position ?? bounds?.center ?? null;
+    state.viewportSpatialOverlay = overlay.compute({
+        nodeId: activeId,
+        bounds,
+        anchor,
+        settings: state.viewportTools.overlay,
+    });
+}
+function syncViewportMeasurementState(state) {
+    if (state.mode !== 'editor')
+        return;
+    const measurement = state.sceneViewMeasurement?.getState();
+    if (measurement)
+        state.viewportMeasurement = measurement;
+}
 function hasSceneCameraPreviewRig(state, options) {
     const document = state.session?.getState().workingDocument ?? null;
     return !!document && !!options.documentAdapter.getSceneCameraPreviewRig?.(document);
@@ -1784,6 +2189,9 @@ function createUiState(state, options) {
         inspectorObject,
         inspectorMultiObject,
         boxSelection: state.boxSelection,
+        coordinateAxes: options.world?.coordinateAxes === false
+            ? null
+            : createSceneViewCoordinateAxesState(state),
         transformTool: {
             activeTool: state.gizmo?.getState().tool ?? state.transformTool,
             activeSpace: state.gizmo?.getState().space ?? state.transformSpace,
@@ -1798,10 +2206,17 @@ function createUiState(state, options) {
             canAlign: selectedIds.length >= 2 && activeId != null,
             canDistribute: selectedIds.length >= 3,
         },
+        viewportTools: cloneEditorViewportToolState(state.viewportTools),
+        viewportMeasurement: cloneViewportMeasurement(state.viewportMeasurement),
+        viewportSpatialOverlay: cloneEditorViewportSpatialOverlayState(state.viewportSpatialOverlay),
         sceneCameraPreview: {
             enabled: state.sceneCameraPreviewEnabled,
             available: hasSceneCameraPreviewRig(state, options),
         },
+        grid: {
+            visible: state.gridVisible,
+            available: !!state.grid,
+        },
         session: sessionState
             ? {
                 source: sessionState.source,
@@ -1813,6 +2228,89 @@ function createUiState(state, options) {
             : null,
     };
 }
+function createSceneViewCoordinateAxesState(state) {
+    if (state.mode !== 'editor')
+        return null;
+    const scene = state.world?.scene ?? null;
+    const camera = scene?.activeCamera ?? state.world?.camera ?? null;
+    const Vector3 = state.babylon?.Vector3;
+    if (!scene || !camera || !Vector3)
+        return null;
+    const right = readSceneViewCameraDirection(camera, Vector3, { x: 1, y: 0, z: 0 });
+    const up = readSceneViewCameraDirection(camera, Vector3, { x: 0, y: 1, z: 0 });
+    const forward = readSceneViewCameraForward(scene, camera, Vector3);
+    if (!right || !up || !forward)
+        return null;
+    return {
+        axes: [
+            createSceneViewCoordinateAxis('x', 'X', '#ff4b70', { x: 1, y: 0, z: 0 }, right, up, forward),
+            createSceneViewCoordinateAxis('y', 'Y', '#75ff42', { x: 0, y: 1, z: 0 }, right, up, forward),
+            createSceneViewCoordinateAxis('z', 'Z', '#4f86ff', { x: 0, y: 0, z: 1 }, right, up, forward),
+        ],
+    };
+}
+function createSceneViewCoordinateAxis(id, label, color, worldAxis, cameraRight, cameraUp, cameraForward) {
+    const screenX = dotSceneViewAxisVec3(worldAxis, cameraRight);
+    const screenY = -dotSceneViewAxisVec3(worldAxis, cameraUp);
+    const projectedLength = Math.hypot(screenX, screenY);
+    const fallback = getSceneViewAxisFallbackDirection(id);
+    const direction = projectedLength > 0.0001
+        ? { x: screenX / projectedLength, y: screenY / projectedLength }
+        : fallback;
+    return {
+        id,
+        label,
+        color,
+        x: direction.x,
+        y: direction.y,
+        depth: dotSceneViewAxisVec3(worldAxis, cameraForward),
+        scale: clampNumber(projectedLength, 0.36, 1),
+    };
+}
+function readSceneViewCameraDirection(camera, Vector3, local) {
+    if (!camera?.getDirection)
+        return null;
+    try {
+        return normalizeSceneViewAxisVec3(camera.getDirection(new Vector3(local.x, local.y, local.z)));
+    }
+    catch {
+        return null;
+    }
+}
+function readSceneViewCameraForward(scene, camera, Vector3) {
+    const rayDirection = normalizeSceneViewAxisVec3(camera?.getForwardRay?.()?.direction);
+    if (rayDirection)
+        return rayDirection;
+    return readSceneViewCameraDirection(camera, Vector3, {
+        x: 0,
+        y: 0,
+        z: scene?.useRightHandedSystem ? -1 : 1,
+    });
+}
+function normalizeSceneViewAxisVec3(value) {
+    const x = Number(value?.x) || 0;
+    const y = Number(value?.y) || 0;
+    const z = Number(value?.z) || 0;
+    const length = Math.hypot(x, y, z);
+    if (!Number.isFinite(length) || length <= 0.000001)
+        return null;
+    return { x: x / length, y: y / length, z: z / length };
+}
+function dotSceneViewAxisVec3(left, right) {
+    return left.x * right.x + left.y * right.y + left.z * right.z;
+}
+function getSceneViewAxisFallbackDirection(id) {
+    if (id === 'x')
+        return { x: 1, y: 0 };
+    if (id === 'y')
+        return { x: 0, y: -1 };
+    return { x: -1, y: 0 };
+}
+function clampNumber(value, min, max) {
+    if (!Number.isFinite(value))
+        return min;
+    return Math.min(max, Math.max(min, value));
+}
 function withRuntimeInspectorSections(state, options, document, inspectorObject) {
     const baseInspectorObject = withInspectorComponentSections(state, options, document, inspectorObject);
     const activeId = inspectorObject.activeId;