@fps-games/editor 0.1.0

package/dist/local-editor-harness.js

@@ -0,0 +1,969 @@
+import { createEditorSession, validateSceneGraphDelete, validateSceneGraphDrop, 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) {
+    const root = options.root ?? document.body;
+    const state = {
+        mode: 'game',
+        busy: false,
+        session: null,
+        source: null,
+        assets: [],
+        assetFilter: '',
+        babylon: null,
+        engine: null,
+        world: null,
+        projection: null,
+        gizmo: null,
+        sceneViewInput: null,
+        sceneViewCamera: null,
+        selectionController: null,
+        boxSelection: null,
+        transformTool: 'select',
+        transformSpace: 'world',
+        transformConstraint: 'axis',
+        resizeHandler: null,
+        status: 'Game running',
+        summary: '',
+    };
+    let harness;
+    const ui = createLocalEditorBrowserUi({
+        root,
+        callbacks: {
+            onEnterEditor: () => {
+                void runExclusive(state, harness.render, () => harness.enterEditor());
+            },
+            onSaveScene: () => {
+                void runExclusive(state, harness.render, () => harness.saveScene());
+            },
+            onSaveAndRunGame: () => {
+                void runExclusive(state, harness.render, () => harness.saveAndRunGame());
+            },
+            onDiscardAndRunGame: () => {
+                void runExclusive(state, harness.render, () => harness.discardAndRunGame());
+            },
+            onUndo: () => {
+                if (undoSessionChange(state, options))
+                    harness.render();
+            },
+            onRedo: () => {
+                if (redoSessionChange(state, options))
+                    harness.render();
+            },
+            onCreateFromAsset: (assetId) => {
+                if (addAssetToDocument(state, options, assetId))
+                    harness.render();
+            },
+            onSelectHierarchyItem: (input) => {
+                if (selectItem(state, options, input))
+                    harness.render();
+            },
+            onSceneGraphRename: (intent) => {
+                if (renameSceneGraphNode(state, options, intent))
+                    harness.render();
+            },
+            onSceneGraphCreateGroup: (intent) => {
+                if (createSceneGraphGroup(state, options, intent))
+                    harness.render();
+            },
+            onSceneGraphDelete: (intent) => {
+                if (deleteSceneGraphNodes(state, options, intent))
+                    harness.render();
+            },
+            onSceneGraphDrop: (intent) => {
+                if (dropSceneGraphNode(state, options, intent))
+                    harness.render();
+            },
+            onAssetFilterChange: (value) => {
+                state.assetFilter = value;
+                harness.render();
+            },
+            onPropertyInput: (input) => {
+                if (patchSerializedProperty(state, options, input))
+                    harness.render();
+            },
+            onTransformToolChange: (tool) => {
+                state.transformTool = tool;
+                state.gizmo?.setTool(tool);
+                harness.render();
+            },
+            onTransformSpaceChange: (space) => {
+                state.transformSpace = space;
+                state.gizmo?.setSpace(space);
+                harness.render();
+            },
+            onTransformConstraintChange: (constraint) => {
+                state.transformConstraint = constraint;
+                state.gizmo?.setConstraint(constraint);
+                harness.render();
+            },
+            onFocusSelection: () => {
+                if (focusSelectedProjection(state))
+                    harness.render();
+            },
+            onCancelActiveOperation: () => {
+                cancelActiveOperation(state);
+                harness.render();
+            },
+        },
+    });
+    harness = {
+        render() {
+            ui.update(createUiState(state, options));
+        },
+        getHostServices() {
+            return options.hostServices ?? null;
+        },
+        getWorkingDocument() {
+            return state.session?.getState().workingDocument ?? null;
+        },
+        async enterEditor() {
+            const loadedSource = options.persistenceAdapter.loadAuthoringSource
+                ? await options.persistenceAdapter.loadAuthoringSource()
+                : null;
+            const [document, assets] = loadedSource
+                ? [loadedSource.document, loadedSource.assets ?? await options.persistenceAdapter.loadAssets()]
+                : [await loadDocumentFallback(options), await options.persistenceAdapter.loadAssets()];
+            const source = loadedSource?.source ?? null;
+            const preparedDocument = options.documentAdapter.prepareDocument?.(document, assets) ?? document;
+            state.assets = assets;
+            state.source = source;
+            state.session = createEditorSession({
+                source: source ?? undefined,
+                persistedDocument: preparedDocument,
+                cloneDocument: options.documentAdapter.cloneDocument,
+                compareDocuments: options.documentAdapter.compareDocuments,
+                reduceDocument: options.documentAdapter.reduceDocument,
+            });
+            await options.worldAdapter.disposeGameWorld();
+            await createEditorWorld(state, options, harness.render);
+            state.mode = 'editor';
+            state.summary = loadedSource?.summary ?? summarizeDocument(options, preparedDocument, source);
+            state.status = `GameWorld disposed; EditorWorld active; assets=${assets.length}`;
+        },
+        async saveScene() {
+            cancelActiveOperation(state);
+            const document = state.session?.getState().workingDocument ?? await loadDocumentFallback(options);
+            const source = state.session?.getState().source ?? state.source;
+            let savedSource = source;
+            let result;
+            if (source && options.authoringHost) {
+                const hostResult = await options.authoringHost.commitSource({
+                    source,
+                    document,
+                    expectedRevision: source.ref.revision,
+                });
+                if (!hostResult.ok || !hostResult.document) {
+                    state.status = summarizeAuthoringFailure(hostResult);
+                    state.summary = summarizeDocument(options, document, source);
+                    return false;
+                }
+                savedSource = hostResult.source ?? source;
+                result = {
+                    document: hostResult.document,
+                    summary: hostResult.summary ?? summarizeDiagnostics(hostResult.diagnostics),
+                };
+            }
+            else if (source && options.persistenceAdapter.saveAuthoringSource) {
+                const sourceResult = await options.persistenceAdapter.saveAuthoringSource({ source, document });
+                savedSource = sourceResult.source;
+                result = sourceResult;
+            }
+            else {
+                result = await saveDocumentFallback(options, document);
+            }
+            const preparedDocument = options.documentAdapter.prepareDocument?.(result.document, state.assets) ?? result.document;
+            state.source = savedSource ?? null;
+            if (state.session) {
+                state.session.markSaved(preparedDocument, savedSource ?? undefined);
+            }
+            else {
+                state.session = createEditorSession({
+                    source: savedSource ?? undefined,
+                    persistedDocument: preparedDocument,
+                    cloneDocument: options.documentAdapter.cloneDocument,
+                    compareDocuments: options.documentAdapter.compareDocuments,
+                    reduceDocument: options.documentAdapter.reduceDocument,
+                });
+            }
+            state.summary = result.summary ?? summarizeDocument(options, preparedDocument, savedSource ?? null);
+            state.status = 'Scene saved';
+            return true;
+        },
+        async saveAndRunGame() {
+            const saved = await harness.saveScene();
+            if (!saved)
+                return false;
+            await harness.discardAndRunGame();
+            return true;
+        },
+        async discardAndRunGame() {
+            cancelActiveOperation(state);
+            disposeEditorWorld(state);
+            state.session = null;
+            state.source = null;
+            state.status = 'Reloading game';
+            await options.persistenceAdapter.runGame();
+        },
+        dispose() {
+            disposeEditorWorld(state);
+            state.session = null;
+            ui.dispose();
+        },
+    };
+    harness.render();
+    return harness;
+}
+async function createEditorWorld(state, options, render) {
+    disposeEditorWorld(state);
+    const canvas = options.worldAdapter.getCanvas();
+    if (!canvas)
+        throw new Error('Editor canvas not found');
+    const babylon = await options.worldAdapter.loadBabylon();
+    const engine = options.worldAdapter.createEngine(babylon, canvas);
+    const world = createBabylonEditorWorld({
+        engine,
+        canvas,
+        babylon,
+        cameraTarget: options.world?.cameraTarget,
+        cameraRadius: options.world?.cameraRadius,
+        clearColor: options.world?.clearColor,
+        useRightHandedSystem: options.world?.useRightHandedSystem,
+        enableDefaultCameraControls: false,
+    });
+    options.createGrid?.(babylon, world.scene);
+    const projection = createBabylonEditorProjection({
+        babylon,
+        scene: world.scene,
+        importModel: options.worldAdapter.importProjectionModel,
+        logger: console,
+    });
+    const gizmo = createBabylonTransformGizmoController({
+        babylon,
+        scene: world.scene,
+        projection,
+        initialTool: state.transformTool,
+        initialSpace: state.transformSpace,
+        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'}`;
+            render();
+        },
+        onDragUpdate() {
+            render();
+        },
+        onDragEnd(event) {
+            commitGizmoTransform(state, options, event);
+            render();
+        },
+        onDragCancel(event) {
+            state.status = event.targetIds.length > 1
+                ? `Canceled ${event.tool} ${event.targetIds.length} objects`
+                : `Canceled ${event.tool} ${event.nodeId ?? event.activeId ?? 'selection'}`;
+            render();
+        },
+    });
+    gizmo.setConstraint(state.transformConstraint);
+    const selectionController = createBabylonProjectionSelectionController({
+        scene: world.scene,
+        canvas,
+        projection,
+        getTool: () => state.transformTool,
+        getSelection: () => state.session?.getSelection() ?? { selectedIds: [], activeId: null },
+        isSelectable: (nodeId) => isDocumentNodeSelectable(state, options, nodeId),
+        isLocked: (nodeId) => isDocumentNodeLocked(state, options, nodeId),
+        isOperationBlocked: () => state.gizmo?.getState().dragPhase === 'dragging',
+        onSelectionCommand(command) {
+            if (dispatchSelectionCommand(state, options, command))
+                render();
+        },
+        onFocusIntent(nodeId) {
+            if (focusProjectionNode(state, nodeId))
+                render();
+        },
+        onBoxSelectionChange(box) {
+            state.boxSelection = box;
+            render();
+        },
+    });
+    const sceneViewInput = createBabylonSceneViewInputController({
+        canvas,
+        isEnabled: () => state.mode === 'editor',
+        isGizmoDragCandidate: (event) => gizmo.isGizmoDragCandidate(event),
+        isBoxSelectCandidate: (event) => selectionController.isBoxSelectionCandidate(event),
+        isViewPlaneMoveCandidate: (event) => gizmo.isViewPlaneMoveCandidate(event),
+        onPointerIntentStart(event) {
+            if (event.state.intent === 'view-plane-move') {
+                if (gizmo.beginViewPlaneMove(event.originalEvent))
+                    render();
+                return;
+            }
+            if (event.state.intent === 'selection-click' || event.state.intent === 'box-select') {
+                selectionController.beginPointerSelection(event.originalEvent);
+            }
+        },
+        onPointerIntentMove(event) {
+            if (event.state.intent === 'view-plane-move') {
+                if (gizmo.updateViewPlaneMove(event.originalEvent))
+                    render();
+                return;
+            }
+            if (state.sceneViewCamera?.handlePointerIntentMove(event)) {
+                render();
+                return;
+            }
+            if (event.state.intent === 'selection-click' || event.state.intent === 'box-select') {
+                selectionController.updatePointerSelection(event.originalEvent, event.state.intent);
+            }
+        },
+        onPointerIntentEnd(event) {
+            if (event.state.intent === 'view-plane-move') {
+                if (gizmo.endViewPlaneMove(event.originalEvent))
+                    render();
+                return;
+            }
+            if (event.state.intent === 'selection-click' || event.state.intent === 'box-select') {
+                selectionController.endPointerSelection(event.originalEvent, event.state.intent);
+            }
+        },
+        onPointerIntentCancel(event) {
+            if (event.state.intent === 'view-plane-move') {
+                gizmo.cancelDrag();
+                render();
+                return;
+            }
+            if (event.state.intent === 'selection-click' || event.state.intent === 'box-select') {
+                selectionController.cancelBoxSelection();
+                render();
+            }
+        },
+        onDoubleClick(event) {
+            selectionController.handleDoubleClick(event);
+        },
+        onWheel(event) {
+            if (state.sceneViewCamera?.handleWheel(event))
+                render();
+        },
+    });
+    const sceneViewCamera = createBabylonSceneViewCameraController({
+        babylon,
+        scene: world.scene,
+        camera: world.camera,
+        input: sceneViewInput,
+    });
+    const document = state.session?.getState().workingDocument;
+    if (document) {
+        projection.projectNodes(options.documentAdapter.getProjectionNodes(document));
+        const selection = state.session?.getState().selection ?? { selectedIds: [], activeId: null };
+        projection.syncSelection(selection);
+        gizmo.setSelection(selection);
+    }
+    const resize = () => engine.resize?.();
+    window.addEventListener('resize', resize);
+    engine.runRenderLoop?.(() => world.render());
+    state.babylon = babylon;
+    state.engine = engine;
+    state.world = world;
+    state.projection = projection;
+    state.gizmo = gizmo;
+    state.sceneViewInput = sceneViewInput;
+    state.sceneViewCamera = sceneViewCamera;
+    state.selectionController = selectionController;
+    state.resizeHandler = resize;
+}
+function disposeEditorWorld(state) {
+    if (state.resizeHandler) {
+        window.removeEventListener('resize', state.resizeHandler);
+        state.resizeHandler = null;
+    }
+    state.sceneViewCamera?.dispose();
+    state.sceneViewCamera = null;
+    state.sceneViewInput?.dispose();
+    state.sceneViewInput = null;
+    state.selectionController?.dispose();
+    state.selectionController = null;
+    state.boxSelection = null;
+    state.gizmo?.dispose();
+    state.gizmo = null;
+    state.projection?.dispose();
+    state.projection = null;
+    state.engine?.stopRenderLoop?.();
+    state.world?.dispose();
+    state.engine?.dispose?.();
+    state.babylon = null;
+    state.world = null;
+    state.engine = null;
+}
+async function runExclusive(state, render, action) {
+    if (state.busy)
+        return;
+    state.busy = true;
+    render();
+    try {
+        await action();
+    }
+    catch (error) {
+        state.status = error instanceof Error ? error.message : String(error);
+        console.error('[LocalEditorHarness] action failed', error);
+    }
+    finally {
+        state.busy = false;
+        render();
+    }
+}
+function selectItem(state, options, input) {
+    if (state.mode !== 'editor')
+        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',
+            };
+    return dispatchSelectionCommand(state, options, command);
+}
+function dispatchSelectionCommand(state, options, command) {
+    if (state.mode !== 'editor')
+        return false;
+    cancelActiveOperation(state);
+    const session = state.session;
+    if (!session)
+        return false;
+    const result = session.dispatch(command);
+    const sanitized = sanitizeSelection(state, options, result.workingDocument, result.selection);
+    const selection = sanitized ?? result.selection;
+    syncSelectionToProjection(state, selection);
+    return result.selectionChanged || !!sanitized;
+}
+function renameSceneGraphNode(state, options, intent) {
+    const document = state.session?.getState().workingDocument;
+    if (state.mode !== 'editor' || !state.session || !document)
+        return false;
+    cancelActiveOperation(state);
+    const validation = validateSceneGraphRename(options.documentAdapter.getHierarchyItems(document), intent);
+    if (!validation.ok) {
+        state.status = `Rename rejected: ${validation.reason ?? 'invalid scene graph rename'}`;
+        return true;
+    }
+    const patch = options.documentAdapter.createSceneGraphRenamePatch?.(document, intent);
+    if (!patch) {
+        state.status = `Rename rejected: ${intent.id}`;
+        return true;
+    }
+    const result = state.session.dispatch({
+        type: 'document.patch',
+        label: patch.label ?? `Rename ${intent.id}`,
+        patch: patch.patch,
+        targetId: intent.id,
+    });
+    if (!result.documentChanged) {
+        state.status = `Rename unchanged: ${intent.id}`;
+        return true;
+    }
+    rebuildProjectionFromDocument(state, options, result.workingDocument, result.selection);
+    state.summary = summarizeDocument(options, result.workingDocument, state.session.getSource());
+    state.status = patch.label ?? `Renamed ${intent.id}`;
+    return true;
+}
+function createSceneGraphGroup(state, options, intent) {
+    const document = state.session?.getState().workingDocument;
+    if (state.mode !== 'editor' || !state.session || !document)
+        return false;
+    cancelActiveOperation(state);
+    const patch = options.documentAdapter.createSceneGraphCreateGroupPatch?.(document, intent);
+    if (!patch) {
+        state.status = 'Create group rejected';
+        return true;
+    }
+    const result = state.session.dispatch({
+        type: 'document.patch',
+        label: patch.label ?? 'Create Empty Group',
+        patch: patch.patch,
+        targetId: patch.createdId ?? undefined,
+    });
+    if (!result.documentChanged) {
+        state.status = 'Create group 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 Group',
+        }).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');
+    return true;
+}
+function deleteSceneGraphNodes(state, options, intent) {
+    const document = state.session?.getState().workingDocument;
+    if (state.mode !== 'editor' || !state.session || !document)
+        return false;
+    cancelActiveOperation(state);
+    const validation = validateSceneGraphDelete(options.documentAdapter.getHierarchyItems(document), intent);
+    if (!validation.ok) {
+        state.status = `Delete rejected: ${validation.reason ?? 'invalid scene graph delete'}`;
+        return true;
+    }
+    const patch = options.documentAdapter.createSceneGraphDeletePatch?.(document, intent);
+    if (!patch) {
+        state.status = 'Delete rejected';
+        return true;
+    }
+    const result = state.session.dispatch({
+        type: 'document.patch',
+        label: patch.label ?? `Delete ${intent.ids.length} node(s)`,
+        patch: patch.patch,
+        targetId: intent.activeId ?? undefined,
+    });
+    if (!result.documentChanged) {
+        state.status = 'Delete unchanged';
+        return true;
+    }
+    const fallbackSelectionId = patch.fallbackSelectionId ?? null;
+    let selection = result.selection;
+    if (fallbackSelectionId && isNodeSelectableInDocument(options, result.workingDocument, fallbackSelectionId)) {
+        selection = state.session.dispatch({
+            type: 'selection.replace',
+            selectedIds: [fallbackSelectionId],
+            activeId: fallbackSelectionId,
+            label: 'Select Delete Fallback',
+        }).selection;
+    }
+    else {
+        selection = sanitizeSelection(state, options, result.workingDocument, selection) ?? selection;
+    }
+    rebuildProjectionFromDocument(state, options, result.workingDocument, selection);
+    state.summary = summarizeDocument(options, result.workingDocument, state.session.getSource());
+    state.status = patch.label ?? `Deleted ${patch.deletedIds?.length ?? intent.ids.length} node(s)`;
+    return true;
+}
+function dropSceneGraphNode(state, options, intent) {
+    const document = state.session?.getState().workingDocument;
+    if (state.mode !== 'editor' || !state.session || !document)
+        return false;
+    cancelActiveOperation(state);
+    if (intent.placement !== 'inside') {
+        state.status = 'Reparent rejected: sorting is not implemented yet';
+        return true;
+    }
+    const hierarchy = options.documentAdapter.getHierarchyItems(document);
+    const coreValidation = validateSceneGraphDrop(hierarchy, intent);
+    if (!coreValidation.ok) {
+        state.status = `Reparent rejected: ${coreValidation.reason ?? 'invalid scene graph drop'}`;
+        return true;
+    }
+    const projectValidation = options.documentAdapter.validateSceneGraphDrop?.(document, intent);
+    if (projectValidation && !projectValidation.ok) {
+        state.status = `Reparent rejected: ${projectValidation.reason ?? 'project validation failed'}`;
+        return true;
+    }
+    const patch = options.documentAdapter.createSceneGraphDropPatch?.(document, intent);
+    if (!patch) {
+        state.status = 'Reparent rejected';
+        return true;
+    }
+    const result = state.session.dispatch({
+        type: 'document.patch',
+        label: patch.label ?? `Reparent ${intent.draggedId}`,
+        patch: patch.patch,
+        targetId: intent.draggedId,
+    });
+    if (!result.documentChanged) {
+        state.status = `Reparent unchanged: ${intent.draggedId}`;
+        return true;
+    }
+    rebuildProjectionFromDocument(state, options, result.workingDocument, result.selection);
+    state.summary = summarizeDocument(options, result.workingDocument, state.session.getSource());
+    state.status = patch.label ?? `Reparented ${intent.draggedId}`;
+    return true;
+}
+function sanitizeSelection(state, options, document, selection) {
+    const selectedIds = selection.selectedIds.filter(id => isNodeSelectableInDocument(options, document, id));
+    const activeId = selection.activeId && selectedIds.includes(selection.activeId)
+        ? selection.activeId
+        : selectedIds[selectedIds.length - 1] ?? null;
+    if (activeId === selection.activeId && selectedIds.length === selection.selectedIds.length)
+        return null;
+    const result = state.session?.dispatch({
+        type: 'selection.replace',
+        selectedIds,
+        activeId,
+        label: 'Sanitize Selection',
+    });
+    return result?.selection ?? { selectedIds, activeId };
+}
+function syncSelectionToProjection(state, selection) {
+    state.projection?.syncSelection(selection);
+    state.gizmo?.setSelection(selection);
+    state.gizmo?.refreshSelection();
+}
+function addAssetToDocument(state, options, assetId) {
+    if (state.mode !== 'editor')
+        return false;
+    cancelActiveOperation(state);
+    const session = state.session;
+    const beforeDocument = session?.getState().workingDocument;
+    if (!session || !beforeDocument)
+        return false;
+    const asset = state.assets.find(candidate => resolveAssetId(options, candidate) === assetId);
+    if (!asset)
+        return false;
+    const patch = options.documentAdapter.createPatchFromAsset(asset);
+    const result = session.dispatch({
+        type: 'document.patch',
+        label: patch.label ?? 'Create Object From Asset',
+        patch: patch.patch,
+    });
+    const createdId = options.documentAdapter.findCreatedId?.(beforeDocument, result.workingDocument);
+    let selectionResult = null;
+    if (createdId) {
+        selectionResult = session.dispatch({
+            type: 'selection.replace',
+            selectedIds: [createdId],
+            activeId: createdId,
+            label: 'Select Created Item',
+        });
+    }
+    state.summary = summarizeDocument(options, result.workingDocument, session.getSource());
+    state.status = `Added ${assetId}`;
+    if (createdId) {
+        const projectedNode = options.documentAdapter.getProjectionNode(result.workingDocument, createdId);
+        if (projectedNode) {
+            state.projection?.projectNode(projectedNode);
+            if (selectionResult)
+                syncSelectionToProjection(state, selectionResult.selection);
+        }
+    }
+    return true;
+}
+function patchSerializedProperty(state, options, input) {
+    if (state.mode !== 'editor')
+        return false;
+    cancelActiveOperation(state);
+    if (!state.session)
+        return false;
+    const document = state.session.getState().workingDocument;
+    const targetIds = input.targetIds && input.targetIds.length > 0 ? input.targetIds : [input.targetId];
+    if (targetIds.length > 1) {
+        const patch = options.documentAdapter.createSerializedMultiPropertyPatch?.({
+            document,
+            targetIds,
+            activeId: state.session.getState().selection.activeId,
+            path: input.path,
+            value: input.value,
+        });
+        if (!patch)
+            return false;
+        const result = state.session.dispatch({
+            type: 'document.patch',
+            label: patch.label ?? `Patch ${input.path} on ${targetIds.length} objects`,
+            patch: patch.patch,
+            targetId: state.session.getState().selection.activeId ?? undefined,
+        });
+        if (!result.documentChanged)
+            return false;
+        const changedIds = patch.changedIds ?? targetIds;
+        const workingDocument = result.workingDocument;
+        syncProjectionForChangedIds(state, options, workingDocument, changedIds);
+        state.summary = summarizeDocument(options, workingDocument, state.session.getSource());
+        state.status = patch.label ?? `Patch ${input.path} on ${targetIds.length} objects`;
+        return true;
+    }
+    const patch = options.documentAdapter.createSerializedPropertyPatch({
+        ...input,
+        document,
+    });
+    if (!patch)
+        return false;
+    const result = state.session.dispatch({
+        type: 'document.patch',
+        label: patch.label ?? `Patch ${input.path}`,
+        patch: patch.patch,
+    });
+    if (patch.changedIds)
+        syncProjectionForChangedIds(state, options, result.workingDocument, patch.changedIds);
+    else
+        syncProjectionForDispatchResult(state, options, result, patch.changedId ?? input.targetId);
+    state.summary = summarizeDocument(options, result.workingDocument, state.session.getSource());
+    state.status = patch.label ?? `Patched ${input.path}`;
+    return true;
+}
+function commitGizmoTransform(state, options, event) {
+    if (state.mode !== 'editor' || !state.session)
+        return false;
+    const document = state.session.getState().workingDocument;
+    if (isTransformBatchCommit(event)) {
+        const patch = options.documentAdapter.createTransformBatchPatch?.({
+            ...event,
+            document,
+        });
+        if (!patch) {
+            restoreBatchTransformPreview(state, event.targets);
+            state.status = `Ignored ${event.tool} ${event.targetIds.length} objects`;
+            return false;
+        }
+        const result = state.session.dispatch({
+            type: 'document.patch',
+            label: patch.label ?? `${event.tool} ${event.targetIds.length} objects`,
+            patch: patch.patch,
+            targetId: event.activeId ?? undefined,
+        });
+        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`;
+        return result.documentChanged;
+    }
+    const patch = options.documentAdapter.createTransformPatch?.({
+        document,
+        targetId: event.nodeId,
+        tool: event.tool,
+        space: event.space,
+        before: event.before,
+        after: event.after,
+    });
+    if (!patch) {
+        state.projection?.setNodeTransformPreview(event.nodeId, event.before);
+        state.status = `Ignored ${event.tool} ${event.nodeId}`;
+        return false;
+    }
+    const result = state.session.dispatch({
+        type: 'document.patch',
+        label: patch.label ?? `${event.tool} ${event.nodeId}`,
+        patch: patch.patch,
+        targetId: event.nodeId,
+    });
+    if (patch.changedIds)
+        syncProjectionForChangedIds(state, options, result.workingDocument, patch.changedIds);
+    else
+        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}`;
+    return result.documentChanged;
+}
+function isTransformBatchCommit(event) {
+    return 'targets' in event;
+}
+function restoreBatchTransformPreview(state, targets) {
+    const transforms = {};
+    for (const target of targets)
+        transforms[target.id] = target.before;
+    state.projection?.setNodeTransformsPreview(transforms);
+}
+function cancelActiveGizmoDrag(state) {
+    state.gizmo?.cancelDrag();
+}
+function cancelActiveOperation(state) {
+    state.sceneViewInput?.cancelActiveIntent();
+    state.selectionController?.cancelBoxSelection();
+    cancelActiveGizmoDrag(state);
+}
+function focusSelectedProjection(state) {
+    if (state.mode !== 'editor')
+        return false;
+    const activeId = state.session?.getState().selection.activeId ?? null;
+    if (!activeId) {
+        state.status = 'Focus failed: no selection';
+        return true;
+    }
+    return focusProjectionNode(state, activeId);
+}
+function focusProjectionNode(state, nodeId) {
+    if (state.mode !== 'editor')
+        return false;
+    const root = state.projection?.getAttachableRoot(nodeId) ?? null;
+    if (!root) {
+        state.status = `Focus failed: missing projection for ${nodeId}`;
+        return true;
+    }
+    const focused = focusEditorViewportSelection(state.world?.camera ?? null, root, {
+        babylon: state.babylon ?? undefined,
+    });
+    state.status = focused
+        ? `Focused ${nodeId} · ${formatEditorStatusTime(Date.now())}`
+        : `Focus failed: camera could not frame ${nodeId}`;
+    return true;
+}
+function formatEditorStatusTime(timestamp) {
+    const date = new Date(timestamp);
+    const pad = (value) => String(value).padStart(2, '0');
+    return `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+function undoSessionChange(state, options) {
+    cancelActiveOperation(state);
+    const result = state.session?.undo();
+    if (!result)
+        return false;
+    rebuildProjection(state, options, result);
+    state.summary = summarizeDocument(options, result.workingDocument, state.session?.getSource());
+    state.status = `Undo ${result.transaction.label}`;
+    return true;
+}
+function redoSessionChange(state, options) {
+    cancelActiveGizmoDrag(state);
+    const result = state.session?.redo();
+    if (!result)
+        return false;
+    rebuildProjection(state, options, result);
+    state.summary = summarizeDocument(options, result.workingDocument, state.session?.getSource());
+    state.status = `Redo ${result.transaction.label}`;
+    return true;
+}
+function rebuildProjection(state, options, result) {
+    rebuildProjectionFromDocument(state, options, result.workingDocument, result.selection);
+}
+function rebuildProjectionFromDocument(state, options, document, selection) {
+    state.projection?.rebuild(options.documentAdapter.getProjectionNodes(document));
+    const sanitized = sanitizeSelection(state, options, document, selection);
+    syncSelectionToProjection(state, sanitized ?? selection);
+}
+function syncProjectionForDispatchResult(state, options, result, changedId) {
+    if (result.documentChanged && changedId && result.workingDocument) {
+        const projectedNode = options.documentAdapter.getProjectionNode(result.workingDocument, changedId);
+        if (projectedNode)
+            state.projection?.syncNodeTransform(projectedNode);
+    }
+    if (result.selectionChanged) {
+        syncSelectionToProjection(state, result.selection ?? { selectedIds: [], activeId: null });
+    }
+    else if (result.documentChanged) {
+        const selection = state.session?.getState().selection ?? { selectedIds: [], activeId: null };
+        const sanitized = result.workingDocument ? sanitizeSelection(state, options, result.workingDocument, selection) : null;
+        syncSelectionToProjection(state, sanitized ?? selection);
+    }
+}
+function syncProjectionForChangedIds(state, options, document, changedIds) {
+    for (const changedId of changedIds) {
+        const projectedNode = options.documentAdapter.getProjectionNode(document, changedId);
+        if (projectedNode)
+            state.projection?.syncNodeTransform(projectedNode);
+    }
+    const selection = state.session?.getState().selection ?? { selectedIds: [], activeId: null };
+    syncSelectionToProjection(state, selection);
+}
+function createUiState(state, options) {
+    const sessionState = state.session?.getState();
+    const document = sessionState?.workingDocument ?? null;
+    const selectedIds = sessionState?.selection.selectedIds ?? [];
+    const activeId = sessionState?.selection.activeId ?? null;
+    return {
+        mode: state.mode,
+        busy: state.busy,
+        status: state.status,
+        summary: state.summary,
+        assetFilter: state.assetFilter,
+        assets: state.assets
+            .filter(asset => asset.placeable !== false)
+            .map(asset => toBrowserAssetItem(options, asset)),
+        assetCountLabel: `${state.assets.length} assets`,
+        hierarchy: document ? options.documentAdapter.getHierarchyItems(document) : [],
+        selectedIds,
+        activeId,
+        selectionSummary: {
+            count: selectedIds.length,
+            activeId,
+        },
+        serializedObject: document && activeId && selectedIds.length === 1
+            ? options.documentAdapter.getSerializedObject(document, activeId)
+            : null,
+        serializedMultiObject: document && selectedIds.length > 1
+            ? options.documentAdapter.getSerializedMultiObject?.(document, selectedIds, activeId) ?? null
+            : null,
+        boxSelection: state.boxSelection,
+        transformTool: {
+            activeTool: state.gizmo?.getState().tool ?? state.transformTool,
+            activeSpace: state.gizmo?.getState().space ?? state.transformSpace,
+            activeConstraint: state.gizmo?.getState().constraint ?? state.transformConstraint,
+            dragPhase: state.gizmo?.getState().dragPhase ?? 'idle',
+            draggingNodeId: state.gizmo?.getState().draggingNodeId ?? null,
+        },
+        session: sessionState
+            ? {
+                source: sessionState.source,
+                dirty: sessionState.dirty,
+                canUndo: sessionState.canUndo,
+                canRedo: sessionState.canRedo,
+                history: sessionState.history,
+            }
+            : null,
+    };
+}
+function summarizeDocument(options, document, _source) {
+    return options.documentAdapter.summarize?.(document) ?? '';
+}
+function summarizeAuthoringFailure(result) {
+    const diagnostic = result.diagnostics.find(item => item.severity === 'error') ?? result.diagnostics[0];
+    return diagnostic?.message ?? result.reason ?? 'Authoring source commit failed';
+}
+function summarizeDiagnostics(diagnostics) {
+    if (!diagnostics?.length)
+        return undefined;
+    return diagnostics.map(diagnostic => diagnostic.message).join('; ');
+}
+async function loadDocumentFallback(options) {
+    if (!options.persistenceAdapter.loadDocument) {
+        throw new Error('LocalEditorHarness requires loadAuthoringSource or loadDocument.');
+    }
+    return options.persistenceAdapter.loadDocument();
+}
+async function saveDocumentFallback(options, document) {
+    if (!options.persistenceAdapter.saveDocument) {
+        throw new Error('LocalEditorHarness requires saveAuthoringSource or saveDocument.');
+    }
+    return options.persistenceAdapter.saveDocument(document);
+}
+function isDocumentNodeSelectable(state, options, id) {
+    const document = state.session?.getState().workingDocument;
+    if (!document)
+        return false;
+    return isNodeSelectableInDocument(options, document, id);
+}
+function isDocumentNodeLocked(state, options, id) {
+    const document = state.session?.getState().workingDocument;
+    if (!document)
+        return false;
+    return options.documentAdapter.isLocked?.(document, id) ?? false;
+}
+function isNodeSelectableInDocument(options, document, id) {
+    if (options.documentAdapter.isLocked?.(document, id))
+        return false;
+    return options.documentAdapter.isSelectable?.(document, id) ?? true;
+}
+function resolveAssetId(options, asset) {
+    return options.worldAdapter.resolveAssetId?.(asset)
+        ?? asset.id;
+}
+function toBrowserAssetItem(options, asset) {
+    return options.worldAdapter.toBrowserAssetItem?.(asset)
+        ?? {
+            id: asset.id,
+            label: asset.label,
+            meta: asset.meta,
+            disabled: asset.placeable === false,
+        };
+}
+//# sourceMappingURL=local-editor-harness.js.map