@fps-games/editor 0.1.1-beta.1 → 0.1.1-beta.2

package/dist/local-editor-harness.js

@@ -1,4 +1,4 @@
-import { createEditorSession, createInspectorRegistry, createInspectorEditPayload, mergeInspectorSections, serializedMultiObjectToInspectorObject, serializedObjectToInspectorObject, validateSceneGraphDelete, validateSceneGraphDrop, validateSceneGraphGroupSelection, validateSceneGraphMove, validateSceneGraphRename, } from '@fps-games/editor-core';
+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 { createLocalEditorBrowserUi, } from '@fps-games/editor-browser';
 import { createBabylonEditorProjection, createBabylonEditorWorld, createBabylonProjectionSelectionController, createBabylonSceneViewCameraController, createBabylonSceneViewInputController, createBabylonTransformGizmoController, focusEditorViewportSelection, } from '@fps-games/editor-babylon';
 export function createLocalEditorHarness(options) {
@@ -22,6 +22,9 @@ export function createLocalEditorHarness(options) {
         transformTool: 'select',
         transformSpace: 'world',
         transformConstraint: 'axis',
+        transformOperationSettings: cloneTransformOperationSettings(DEFAULT_EDITOR_TRANSFORM_OPERATION_SETTINGS),
+        duplicateDrag: null,
+        armedPlacement: null,
         resizeHandler: null,
         status: 'Game running',
         statusTone: 'default',
@@ -55,7 +58,7 @@ export function createLocalEditorHarness(options) {
                     harness.render();
             },
             onCreateFromAsset: (assetId) => {
-                if (addAssetToDocument(state, options, assetId))
+                if (createAssetFromBrowserIntent(state, options, assetId))
                     harness.render();
             },
             onSelectHierarchyItem: (input) => {
@@ -102,7 +105,9 @@ export function createLocalEditorHarness(options) {
             },
             onTransformToolChange: (tool) => {
                 state.transformTool = tool;
+                state.transformConstraint = normalizeTransformConstraint(tool, state.transformConstraint);
                 state.gizmo?.setTool(tool);
+                state.gizmo?.setConstraint(state.transformConstraint);
                 harness.render();
             },
             onTransformSpaceChange: (space) => {
@@ -111,10 +116,51 @@ export function createLocalEditorHarness(options) {
                 harness.render();
             },
             onTransformConstraintChange: (constraint) => {
-                state.transformConstraint = constraint;
-                state.gizmo?.setConstraint(constraint);
+                state.transformConstraint = normalizeTransformConstraint(state.transformTool, constraint);
+                state.gizmo?.setConstraint(state.transformConstraint);
                 harness.render();
             },
+            onTransformSnapEnabledChange: (enabled) => {
+                state.transformOperationSettings = updateTransformOperationSettings(state.transformOperationSettings, {
+                    snap: {
+                        ...state.transformOperationSettings.snap,
+                        enabled,
+                    },
+                });
+                state.gizmo?.setOperationSettings(state.transformOperationSettings);
+                state.status = enabled ? 'Transform snap enabled' : 'Transform snap disabled';
+                harness.render();
+            },
+            onTransformSnapStepChange: (input) => {
+                const value = normalizePositiveStep(input.value);
+                if (value == null)
+                    return;
+                const snap = { ...state.transformOperationSettings.snap };
+                if (input.kind === 'move')
+                    snap.moveStep = value;
+                else if (input.kind === 'rotate')
+                    snap.rotateStepDegrees = value;
+                else
+                    snap.scaleStep = value;
+                state.transformOperationSettings = updateTransformOperationSettings(state.transformOperationSettings, { snap });
+                state.gizmo?.setOperationSettings(state.transformOperationSettings);
+                state.status = `Transform snap ${input.kind} step ${value}`;
+                harness.render();
+            },
+            onPlacementModeChange: (mode) => {
+                state.transformOperationSettings = updateTransformOperationSettings(state.transformOperationSettings, {
+                    placementMode: normalizePlacementMode(mode),
+                });
+                state.gizmo?.setOperationSettings(state.transformOperationSettings);
+                if (state.transformOperationSettings.placementMode === 'off')
+                    clearArmedPlacement(state);
+                state.status = `Placement mode: ${state.transformOperationSettings.placementMode}`;
+                harness.render();
+            },
+            onTransformAction: (action) => {
+                if (executeTransformAction(state, options, action))
+                    harness.render();
+            },
             onFocusSelection: () => {
                 if (focusSelectedProjection(state))
                     harness.render();
@@ -268,6 +314,49 @@ export function mergeLocalEditorHarnessInspectorComponentSections(input) {
         }),
     };
 }
+function normalizeTransformConstraint(tool, constraint) {
+    return normalizeEditorTransformConstraint(tool, constraint) ?? 'axis';
+}
+function cloneTransformOperationSettings(settings) {
+    return {
+        snap: {
+            enabled: settings.snap.enabled,
+            moveStep: settings.snap.moveStep,
+            rotateStepDegrees: settings.snap.rotateStepDegrees,
+            scaleStep: settings.snap.scaleStep,
+        },
+        placementMode: settings.placementMode,
+    };
+}
+function updateTransformOperationSettings(current, patch) {
+    return {
+        ...current,
+        ...patch,
+        snap: patch.snap
+            ? { ...current.snap, ...patch.snap }
+            : { ...current.snap },
+    };
+}
+function normalizePositiveStep(value) {
+    if (!Number.isFinite(value) || value <= 0)
+        return null;
+    return Number(value.toFixed(4));
+}
+function normalizePlacementMode(mode) {
+    return mode === 'ground' || mode === 'surface' ? mode : 'off';
+}
+function validateTransformActionSelection(state, action) {
+    const selection = state.session?.getState().selection;
+    const selectedCount = selection?.selectedIds.length ?? 0;
+    if (action.startsWith('align-')) {
+        return selectedCount >= 2 && selection?.activeId
+            ? { ok: true }
+            : { ok: false, message: 'Align needs at least 2 selected objects and an active object' };
+    }
+    return selectedCount >= 3
+        ? { ok: true }
+        : { ok: false, message: 'Distribute needs at least 3 selected objects' };
+}
 async function createEditorWorld(state, options, render) {
     disposeEditorWorld(state);
     const canvas = options.worldAdapter.getCanvas();
@@ -301,8 +390,8 @@ async function createEditorWorld(state, options, render) {
         logger: console,
         onDragStart(event) {
             state.status = event.targetIds.length > 1
-                ? `Dragging ${event.tool} ${event.targetIds.length} objects`
-                : `Dragging ${event.tool} ${event.nodeId ?? event.activeId ?? 'selection'}`;
+                ? `Dragging ${event.duplicate ? 'duplicate ' : ''}${event.tool} ${event.targetIds.length} objects`
+                : `Dragging ${event.duplicate ? 'duplicate ' : ''}${event.tool} ${event.nodeId ?? event.activeId ?? 'selection'}`;
             render();
         },
         onDragUpdate() {
@@ -313,12 +402,20 @@ async function createEditorWorld(state, options, render) {
             render();
         },
         onDragCancel(event) {
+            if (event.duplicate && cancelDuplicateDrag(state, options)) {
+                render();
+                return;
+            }
             state.status = event.targetIds.length > 1
                 ? `Canceled ${event.tool} ${event.targetIds.length} objects`
                 : `Canceled ${event.tool} ${event.nodeId ?? event.activeId ?? 'selection'}`;
             render();
         },
+        onDuplicateDragStart(input) {
+            return beginDuplicateDrag(state, options, input);
+        },
     });
+    gizmo.setOperationSettings(state.transformOperationSettings);
     gizmo.setConstraint(state.transformConstraint);
     const selectionController = createBabylonProjectionSelectionController({
         scene: world.scene,
@@ -348,7 +445,17 @@ async function createEditorWorld(state, options, render) {
         isGizmoDragCandidate: (event) => gizmo.isGizmoDragCandidate(event),
         isBoxSelectCandidate: (event) => selectionController.isBoxSelectionCandidate(event),
         isViewPlaneMoveCandidate: (event) => gizmo.isViewPlaneMoveCandidate(event),
+        isPlacementCandidate: () => isPlacementArmed(state),
         onPointerIntentStart(event) {
+            if (event.state.intent === 'gizmo-drag') {
+                gizmo.preparePointerDrag(event.originalEvent);
+                return;
+            }
+            if (event.state.intent === 'placement') {
+                if (previewArmedPlacement(state, event.originalEvent))
+                    render();
+                return;
+            }
             if (event.state.intent === 'view-plane-move') {
                 if (gizmo.beginViewPlaneMove(event.originalEvent))
                     render();
@@ -359,6 +466,11 @@ async function createEditorWorld(state, options, render) {
             }
         },
         onPointerIntentMove(event) {
+            if (event.state.intent === 'placement') {
+                if (previewArmedPlacement(state, event.originalEvent))
+                    render();
+                return;
+            }
             if (event.state.intent === 'view-plane-move') {
                 if (gizmo.updateViewPlaneMove(event.originalEvent))
                     render();
@@ -373,6 +485,11 @@ async function createEditorWorld(state, options, render) {
             }
         },
         onPointerIntentEnd(event) {
+            if (event.state.intent === 'placement') {
+                if (commitArmedPlacement(state, options, event.originalEvent))
+                    render();
+                return;
+            }
             if (event.state.intent === 'view-plane-move') {
                 if (gizmo.endViewPlaneMove(event.originalEvent))
                     render();
@@ -383,6 +500,11 @@ async function createEditorWorld(state, options, render) {
             }
         },
         onPointerIntentCancel(event) {
+            if (event.state.intent === 'placement') {
+                state.gizmo?.setPlacementMarker(null);
+                render();
+                return;
+            }
             if (event.state.intent === 'view-plane-move') {
                 gizmo.cancelDrag();
                 render();
@@ -803,6 +925,193 @@ function syncSelectionToProjection(state, selection) {
     state.gizmo?.setSelection(selection);
     state.gizmo?.refreshSelection();
 }
+function executeTransformAction(state, options, action) {
+    if (state.mode !== 'editor' || !state.session)
+        return false;
+    const document = state.session.getState().workingDocument;
+    const selection = state.session.getState().selection;
+    cancelActiveOperation(state);
+    const validation = validateTransformActionSelection(state, action);
+    if (!validation.ok) {
+        state.status = validation.message;
+        return true;
+    }
+    const beforeTransforms = state.projection?.readNodeTransforms(selection.selectedIds) ?? {};
+    const transformTargets = selection.selectedIds
+        .map((id) => {
+        const transform = beforeTransforms[id];
+        return transform ? { id, transform } : null;
+    })
+        .filter((target) => !!target);
+    const targets = computeEditorTransformActionTargets({
+        action,
+        activeId: selection.activeId,
+        targets: transformTargets,
+    });
+    if (targets.length === 0) {
+        state.status = `Transform action rejected: ${action}`;
+        return true;
+    }
+    const changedTargets = targets.filter(target => !editorTransformSnapshotsEqual(target.before, target.after));
+    if (changedTargets.length === 0) {
+        state.status = `Transform action unchanged: ${action}`;
+        return true;
+    }
+    const patch = options.documentAdapter.createTransformBatchPatch?.({
+        document,
+        targetIds: changedTargets.map(target => target.id),
+        activeId: selection.activeId,
+        tool: 'move',
+        space: 'world',
+        constraint: action === 'align-all' ? 'free' : 'axis',
+        pivot: createTransformActionPivot(targets),
+        targets: changedTargets,
+    });
+    if (!patch) {
+        state.status = `Transform action ignored: ${action}`;
+        return true;
+    }
+    const result = state.session.dispatch({
+        type: 'document.patch',
+        label: patch.label ?? formatTransformActionStatus(action, changedTargets.length),
+        patch: patch.patch,
+        targetId: selection.activeId ?? changedTargets[0]?.id,
+    });
+    if (!result.documentChanged) {
+        state.status = `Transform action unchanged: ${action}`;
+        return true;
+    }
+    const changedIds = patch.changedIds ?? changedTargets.map(target => target.id);
+    syncProjectionForChangedIds(state, options, result.workingDocument, changedIds);
+    state.summary = summarizeDocument(options, result.workingDocument, state.session.getSource());
+    state.status = patch.label ?? formatTransformActionStatus(action, changedTargets.length);
+    return true;
+}
+function createTransformActionPivot(targets) {
+    const center = averageTransformTargetPositions(targets);
+    return {
+        mode: 'selection-center',
+        position: center,
+    };
+}
+function averageTransformTargetPositions(targets) {
+    if (targets.length === 0)
+        return { x: 0, y: 0, z: 0 };
+    return {
+        x: targets.reduce((sum, target) => sum + target.before.position.x, 0) / targets.length,
+        y: targets.reduce((sum, target) => sum + target.before.position.y, 0) / targets.length,
+        z: targets.reduce((sum, target) => sum + target.before.position.z, 0) / targets.length,
+    };
+}
+function editorTransformSnapshotsEqual(left, right) {
+    return editorVec3Equal(left.position, right.position)
+        && editorVec3Equal(left.rotation, right.rotation)
+        && editorVec3Equal(left.scale, right.scale);
+}
+function editorVec3Equal(left, right) {
+    return Math.abs(left.x - right.x) < 0.000000001
+        && Math.abs(left.y - right.y) < 0.000000001
+        && Math.abs(left.z - right.z) < 0.000000001;
+}
+function formatTransformActionStatus(action, count) {
+    return `${action} ${count} object${count === 1 ? '' : 's'}`;
+}
+function createAssetFromBrowserIntent(state, options, assetId) {
+    if (state.transformOperationSettings.placementMode === 'off') {
+        return addAssetToDocument(state, options, assetId);
+    }
+    return armAssetPlacement(state, options, assetId);
+}
+function armAssetPlacement(state, options, assetId) {
+    if (state.mode !== 'editor')
+        return false;
+    cancelActiveOperation(state);
+    const asset = state.assets.find(candidate => resolveAssetId(options, candidate) === assetId);
+    if (!asset)
+        return false;
+    state.armedPlacement = { assetId, asset };
+    state.gizmo?.setPlacementMarker(null);
+    state.status = `Placement armed: ${formatAssetLabel(asset, assetId)} (${state.transformOperationSettings.placementMode})`;
+    return true;
+}
+function isPlacementArmed(state) {
+    return state.mode === 'editor'
+        && !!state.armedPlacement
+        && state.transformOperationSettings.placementMode !== 'off';
+}
+function previewArmedPlacement(state, event) {
+    if (!isPlacementArmed(state))
+        return false;
+    const hit = pickArmedPlacementHit(state, event);
+    state.gizmo?.setPlacementMarker(hit);
+    const mode = state.transformOperationSettings.placementMode;
+    state.status = hit
+        ? `Placement ${mode}: ${formatVec3(hit.position)}`
+        : `Placement ${mode}: no hit`;
+    return true;
+}
+function commitArmedPlacement(state, options, event) {
+    if (!isPlacementArmed(state) || !state.session)
+        return false;
+    const armed = state.armedPlacement;
+    const session = state.session;
+    const beforeDocument = session.getState().workingDocument;
+    const hit = pickArmedPlacementHit(state, event);
+    if (!armed || !hit) {
+        state.gizmo?.setPlacementMarker(null);
+        state.status = 'Placement rejected: no hit';
+        return true;
+    }
+    const patch = options.documentAdapter.createPlacedAssetPatch?.({
+        document: beforeDocument,
+        asset: armed.asset,
+        hit,
+    });
+    if (!patch) {
+        state.status = 'Placement rejected: document adapter does not support placed assets';
+        return true;
+    }
+    const result = session.dispatch({
+        type: 'document.patch',
+        label: patch.label ?? `Place ${armed.assetId}`,
+        patch: patch.patch,
+        targetId: patch.createdId ?? undefined,
+    });
+    if (!result.documentChanged) {
+        state.status = 'Placement unchanged';
+        return true;
+    }
+    const createdId = patch.createdId
+        ?? options.documentAdapter.findCreatedId?.(beforeDocument, result.workingDocument)
+        ?? null;
+    let selection = result.selection;
+    if (createdId && isNodeSelectableInDocument(options, result.workingDocument, createdId)) {
+        selection = session.dispatch({
+            type: 'selection.replace',
+            selectedIds: [createdId],
+            activeId: createdId,
+            label: 'Select Placed Item',
+        }).selection;
+    }
+    else {
+        selection = sanitizeSelection(state, options, result.workingDocument, selection) ?? selection;
+    }
+    clearArmedPlacement(state);
+    rebuildProjectionFromDocument(state, options, result.workingDocument, selection);
+    state.summary = summarizeDocument(options, result.workingDocument, session.getSource());
+    state.status = patch.label ?? `Placed ${formatAssetLabel(armed.asset, armed.assetId)} at ${formatVec3(hit.position)}`;
+    return true;
+}
+function pickArmedPlacementHit(state, event) {
+    const mode = state.transformOperationSettings.placementMode;
+    return mode === 'off'
+        ? null
+        : state.gizmo?.pickPlacementHit(event.clientX, event.clientY, mode) ?? null;
+}
+function clearArmedPlacement(state) {
+    state.armedPlacement = null;
+    state.gizmo?.setPlacementMarker(null);
+}
 function addAssetToDocument(state, options, assetId) {
     if (state.mode !== 'editor')
         return false;
@@ -971,6 +1280,86 @@ function findInspectorPropertyByPath(inspector, path) {
     }
     return null;
 }
+function beginDuplicateDrag(state, options, input) {
+    if (state.mode !== 'editor' || !state.session)
+        return null;
+    if (state.duplicateDrag)
+        return null;
+    const document = state.session.getState().workingDocument;
+    const patch = options.documentAdapter.createDuplicateSelectionPatch?.({
+        document,
+        targetIds: input.targetIds,
+        activeId: input.activeId,
+        transforms: input.beforeTransforms,
+    });
+    if (!patch || patch.createdIds.length === 0) {
+        state.status = 'Duplicate drag rejected';
+        return null;
+    }
+    const originalSelection = state.session.getSelection();
+    const result = state.session.dispatch({
+        type: 'document.patch',
+        label: patch.label ?? `Duplicate ${input.targetIds.length} object(s)`,
+        patch: patch.patch,
+        targetId: patch.activeId ?? patch.createdIds[patch.createdIds.length - 1] ?? undefined,
+    });
+    if (!result.documentChanged) {
+        state.status = 'Duplicate drag unchanged';
+        return null;
+    }
+    const createdIds = patch.createdIds.filter(id => isNodeSelectableInDocument(options, result.workingDocument, id));
+    if (createdIds.length === 0) {
+        const undone = state.session.undo();
+        if (undone)
+            rebuildProjectionFromDocument(state, options, undone.workingDocument, originalSelection);
+        state.status = 'Duplicate drag rejected: duplicated selection is not selectable';
+        return null;
+    }
+    const activeId = patch.activeId && createdIds.includes(patch.activeId)
+        ? patch.activeId
+        : createdIds[createdIds.length - 1] ?? null;
+    const selectionResult = state.session.dispatch({
+        type: 'selection.replace',
+        selectedIds: createdIds,
+        activeId,
+        label: 'Select Duplicate Drag Targets',
+    });
+    state.duplicateDrag = {
+        originalSelection,
+        createdIds,
+        activeId,
+    };
+    rebuildProjectionFromDocument(state, options, result.workingDocument, selectionResult.selection);
+    if (patch.reprojectIds?.length)
+        reprojectProjectionForChangedIds(state, options, result.workingDocument, patch.reprojectIds);
+    else
+        syncProjectionForChangedIds(state, options, result.workingDocument, patch.changedIds ?? createdIds);
+    state.summary = summarizeDocument(options, result.workingDocument, state.session.getSource());
+    state.status = patch.label ?? `Duplicated ${createdIds.length} object(s)`;
+    return {
+        targetIds: createdIds,
+        activeId,
+    };
+}
+function cancelDuplicateDrag(state, options) {
+    const duplicate = state.duplicateDrag;
+    if (!duplicate || !state.session)
+        return false;
+    state.duplicateDrag = null;
+    const undone = state.session.undo();
+    if (!undone)
+        return false;
+    const selectionResult = state.session.dispatch({
+        type: 'selection.replace',
+        selectedIds: duplicate.originalSelection.selectedIds,
+        activeId: duplicate.originalSelection.activeId,
+        label: 'Restore Duplicate Drag Selection',
+    });
+    rebuildProjectionFromDocument(state, options, undone.workingDocument, selectionResult.selection);
+    state.summary = summarizeDocument(options, undone.workingDocument, state.session.getSource());
+    state.status = `Canceled duplicate drag ${duplicate.createdIds.length} object(s)`;
+    return true;
+}
 function commitGizmoTransform(state, options, event) {
     if (state.mode !== 'editor' || !state.session)
         return false;
@@ -981,8 +1370,10 @@ function commitGizmoTransform(state, options, event) {
             document,
         });
         if (!patch) {
-            restoreBatchTransformPreview(state, event.targets);
-            state.status = `Ignored ${event.tool} ${event.targetIds.length} objects`;
+            if (!cancelDuplicateDrag(state, options)) {
+                restoreBatchTransformPreview(state, event.targets);
+                state.status = `Ignored ${event.tool} ${event.targetIds.length} objects`;
+            }
             return false;
         }
         const result = state.session.dispatch({
@@ -990,11 +1381,14 @@ function commitGizmoTransform(state, options, event) {
             label: patch.label ?? `${event.tool} ${event.targetIds.length} objects`,
             patch: patch.patch,
             targetId: event.activeId ?? undefined,
+        }, {
+            mergeWithPrevious: event.targetIds.some(id => state.duplicateDrag?.createdIds.includes(id)) === true,
         });
         syncProjectionForDispatchResult(state, options, result);
         syncProjectionForChangedIds(state, options, result.workingDocument, patch.changedIds ?? event.targetIds);
         state.summary = summarizeDocument(options, result.workingDocument, state.session.getSource());
         state.status = patch.label ?? `${event.tool} ${event.targetIds.length} objects`;
+        state.duplicateDrag = null;
         return result.documentChanged;
     }
     const patch = options.documentAdapter.createTransformPatch?.({
@@ -1002,12 +1396,15 @@ function commitGizmoTransform(state, options, event) {
         targetId: event.nodeId,
         tool: event.tool,
         space: event.space,
+        constraint: event.constraint,
         before: event.before,
         after: event.after,
     });
     if (!patch) {
-        state.projection?.setNodeTransformPreview(event.nodeId, event.before);
-        state.status = `Ignored ${event.tool} ${event.nodeId}`;
+        if (!cancelDuplicateDrag(state, options)) {
+            state.projection?.setNodeTransformPreview(event.nodeId, event.before);
+            state.status = `Ignored ${event.tool} ${event.nodeId}`;
+        }
         return false;
     }
     const result = state.session.dispatch({
@@ -1015,6 +1412,8 @@ function commitGizmoTransform(state, options, event) {
         label: patch.label ?? `${event.tool} ${event.nodeId}`,
         patch: patch.patch,
         targetId: event.nodeId,
+    }, {
+        mergeWithPrevious: state.duplicateDrag?.createdIds.includes(event.nodeId) === true,
     });
     if (patch.changedIds)
         syncProjectionForChangedIds(state, options, result.workingDocument, patch.changedIds);
@@ -1022,6 +1421,7 @@ function commitGizmoTransform(state, options, event) {
         syncProjectionForDispatchResult(state, options, result, patch.changedId ?? event.nodeId);
     state.summary = summarizeDocument(options, result.workingDocument, state.session.getSource());
     state.status = patch.label ?? `${event.tool} ${event.nodeId}`;
+    state.duplicateDrag = null;
     return result.documentChanged;
 }
 function isTransformBatchCommit(event) {
@@ -1040,6 +1440,7 @@ function cancelActiveOperation(state) {
     state.sceneViewInput?.cancelActiveIntent();
     state.selectionController?.cancelBoxSelection();
     cancelActiveGizmoDrag(state);
+    clearArmedPlacement(state);
 }
 function focusSelectedProjection(state) {
     if (state.mode !== 'editor')
@@ -1072,6 +1473,17 @@ function formatEditorStatusTime(timestamp) {
     const pad = (value) => String(value).padStart(2, '0');
     return `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
 }
+function formatVec3(value) {
+    return `${formatPlacementNumber(value.x)}, ${formatPlacementNumber(value.y)}, ${formatPlacementNumber(value.z)}`;
+}
+function formatPlacementNumber(value) {
+    return Number.isFinite(value) ? Number(value.toFixed(3)).toString() : String(value);
+}
+function formatAssetLabel(asset, fallback) {
+    const record = isObjectRecord(asset) ? asset : null;
+    const label = record?.label ?? record?.displayName ?? record?.name;
+    return typeof label === 'string' && label.trim() ? label : fallback;
+}
 function undoSessionChange(state, options) {
     cancelActiveOperation(state);
     const result = state.session?.undo();
@@ -1083,7 +1495,7 @@ function undoSessionChange(state, options) {
     return true;
 }
 function redoSessionChange(state, options) {
-    cancelActiveGizmoDrag(state);
+    cancelActiveOperation(state);
     const result = state.session?.redo();
     if (!result)
         return false;
@@ -1188,6 +1600,13 @@ function createUiState(state, options) {
             dragPhase: state.gizmo?.getState().dragPhase ?? 'idle',
             draggingNodeId: state.gizmo?.getState().draggingNodeId ?? null,
         },
+        transformOperations: {
+            settings: cloneTransformOperationSettings(state.transformOperationSettings),
+            selectedCount: selectedIds.length,
+            activeId,
+            canAlign: selectedIds.length >= 2 && activeId != null,
+            canDistribute: selectedIds.length >= 3,
+        },
         session: sessionState
             ? {
                 source: sessionState.source,