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

package/dist/local-editor-harness.js

@@ -1,4 +1,4 @@
-import { createEditorSession, validateSceneGraphDelete, validateSceneGraphDrop, validateSceneGraphRename, } from '@fps-games/editor-core';
+import { createEditorSession, createInspectorRegistry, createInspectorEditPayload, mergeInspectorSections, 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) {
@@ -24,11 +24,15 @@ export function createLocalEditorHarness(options) {
         transformConstraint: 'axis',
         resizeHandler: null,
         status: 'Game running',
+        statusTone: 'default',
+        statusToneStatus: 'Game running',
+        statusDetails: '',
         summary: '',
     };
     let harness;
     const ui = createLocalEditorBrowserUi({
         root,
+        inspector: options.inspector,
         callbacks: {
             onEnterEditor: () => {
                 void runExclusive(state, harness.render, () => harness.enterEditor());
@@ -74,12 +78,26 @@ export function createLocalEditorHarness(options) {
                 if (dropSceneGraphNode(state, options, intent))
                     harness.render();
             },
+            onSceneGraphMove: (intent) => {
+                if (moveSceneGraphNodes(state, options, intent))
+                    harness.render();
+            },
+            onSceneGraphGroupSelection: (intent) => {
+                if (groupSceneGraphSelection(state, options, intent))
+                    harness.render();
+            },
+            onContextAction: (action) => {
+                if (handleContextAction(state, options, action))
+                    harness.render();
+            },
             onAssetFilterChange: (value) => {
                 state.assetFilter = value;
                 harness.render();
             },
             onPropertyInput: (input) => {
-                if (patchSerializedProperty(state, options, input))
+                const previousStatus = state.status;
+                const patched = patchSerializedProperty(state, options, input);
+                if (patched || state.status !== previousStatus)
                     harness.render();
             },
             onTransformToolChange: (tool) => {
@@ -154,7 +172,11 @@ export function createLocalEditorHarness(options) {
                     expectedRevision: source.ref.revision,
                 });
                 if (!hostResult.ok || !hostResult.document) {
-                    state.status = summarizeAuthoringFailure(hostResult);
+                    const failureStatus = summarizeLocalEditorAuthoringFailure(hostResult);
+                    state.status = failureStatus.status;
+                    state.statusTone = 'error';
+                    state.statusToneStatus = state.status;
+                    state.statusDetails = failureStatus.details;
                     state.summary = summarizeDocument(options, document, source);
                     return false;
                 }
@@ -188,6 +210,9 @@ export function createLocalEditorHarness(options) {
             }
             state.summary = result.summary ?? summarizeDocument(options, preparedDocument, savedSource ?? null);
             state.status = 'Scene saved';
+            state.statusTone = 'success';
+            state.statusToneStatus = state.status;
+            state.statusDetails = '';
             return true;
         },
         async saveAndRunGame() {
@@ -203,6 +228,9 @@ export function createLocalEditorHarness(options) {
             state.session = null;
             state.source = null;
             state.status = 'Reloading game';
+            state.statusTone = 'default';
+            state.statusToneStatus = state.status;
+            state.statusDetails = '';
             await options.persistenceAdapter.runGame();
         },
         dispose() {
@@ -214,6 +242,32 @@ export function createLocalEditorHarness(options) {
     harness.render();
     return harness;
 }
+export function mergeLocalEditorHarnessInspectorComponentSections(input) {
+    const components = input.components;
+    if (!components)
+        return input.inspectorObject;
+    const context = {
+        ...input.inspectorObject.selection,
+        ...input.context,
+        targetIds: input.context?.targetIds ?? input.inspectorObject.targetIds,
+        activeId: input.context?.activeId ?? input.inspectorObject.activeId,
+        document: input.context?.document ?? input.inspectorObject.document ?? input.inspectorObject.selection.document,
+    };
+    const componentSections = getInspectorComponentSections({
+        components,
+        context,
+        componentConflict: input.componentConflict,
+        propertyConflict: input.propertyConflict,
+    });
+    if (componentSections.length === 0)
+        return input.inspectorObject;
+    return {
+        ...input.inspectorObject,
+        sections: mergeInspectorSections(input.inspectorObject.sections, componentSections, {
+            propertyConflict: input.propertyConflict,
+        }),
+    };
+}
 async function createEditorWorld(state, options, render) {
     disposeEditorWorld(state);
     const canvas = options.worldAdapter.getCanvas();
@@ -406,6 +460,9 @@ async function runExclusive(state, render, action) {
     }
     catch (error) {
         state.status = error instanceof Error ? error.message : String(error);
+        state.statusTone = 'error';
+        state.statusToneStatus = state.status;
+        state.statusDetails = state.status;
         console.error('[LocalEditorHarness] action failed', error);
     }
     finally {
@@ -440,6 +497,38 @@ function selectItem(state, options, input) {
             };
     return dispatchSelectionCommand(state, options, command);
 }
+function handleContextAction(state, options, action) {
+    if (action.region !== 'hierarchy')
+        return false;
+    if (action.action === 'focus') {
+        const activeId = action.activeId ?? action.targetIds[action.targetIds.length - 1] ?? null;
+        const selectionChanged = activeId && !state.session?.getState().selection.selectedIds.includes(activeId)
+            ? dispatchSelectionCommand(state, options, {
+                type: 'selection.replace',
+                selectedIds: [activeId],
+                activeId,
+                label: 'Select Context Target',
+            })
+            : false;
+        return focusSelectedProjection(state) || selectionChanged;
+    }
+    if (action.action === 'rename')
+        return false;
+    if (action.action === 'create-group') {
+        return createSceneGraphGroup(state, options, {
+            parentId: action.parentId ?? null,
+            activeId: action.activeId ?? null,
+            name: 'Group',
+        });
+    }
+    if (action.action === 'delete') {
+        return deleteSceneGraphNodes(state, options, {
+            ids: action.targetIds,
+            activeId: action.activeId ?? null,
+        });
+    }
+    return false;
+}
 function dispatchSelectionCommand(state, options, command) {
     if (state.mode !== 'editor')
         return false;
@@ -601,6 +690,99 @@ function dropSceneGraphNode(state, options, intent) {
     state.status = patch.label ?? `Reparented ${intent.draggedId}`;
     return true;
 }
+function moveSceneGraphNodes(state, options, intent) {
+    const document = state.session?.getState().workingDocument;
+    if (state.mode !== 'editor' || !state.session || !document)
+        return false;
+    cancelActiveOperation(state);
+    const hierarchy = options.documentAdapter.getHierarchyItems(document);
+    const coreValidation = validateSceneGraphMove(hierarchy, intent);
+    if (!coreValidation.ok) {
+        state.status = `Move rejected: ${coreValidation.reason ?? 'invalid scene graph move'}`;
+        return true;
+    }
+    const projectValidation = options.documentAdapter.validateSceneGraphMove?.(document, intent);
+    if (projectValidation && !projectValidation.ok) {
+        state.status = `Move rejected: ${projectValidation.reason ?? 'project validation failed'}`;
+        return true;
+    }
+    if (!options.documentAdapter.createSceneGraphMovePatch && intent.placement === 'inside' && intent.ids.length === 1 && intent.targetId) {
+        return dropSceneGraphNode(state, options, {
+            draggedId: intent.ids[0],
+            targetId: intent.targetId,
+            placement: 'inside',
+            preserveWorldTransform: intent.preserveWorldTransform,
+        });
+    }
+    const patch = options.documentAdapter.createSceneGraphMovePatch?.(document, intent);
+    if (!patch) {
+        state.status = 'Move rejected';
+        return true;
+    }
+    const result = state.session.dispatch({
+        type: 'document.patch',
+        label: patch.label ?? `Move ${intent.ids.length} node(s)`,
+        patch: patch.patch,
+        targetId: intent.ids[0] ?? undefined,
+    });
+    if (!result.documentChanged) {
+        state.status = 'Move unchanged';
+        return true;
+    }
+    const selection = sanitizeSelection(state, options, result.workingDocument, result.selection) ?? result.selection;
+    rebuildProjectionFromDocument(state, options, result.workingDocument, selection);
+    state.summary = summarizeDocument(options, result.workingDocument, state.session.getSource());
+    state.status = patch.label ?? `Moved ${patch.changedIds?.length ?? intent.ids.length} node(s)`;
+    return true;
+}
+function groupSceneGraphSelection(state, options, intent) {
+    const document = state.session?.getState().workingDocument;
+    if (state.mode !== 'editor' || !state.session || !document)
+        return false;
+    cancelActiveOperation(state);
+    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'}`;
+        return true;
+    }
+    const projectValidation = options.documentAdapter.validateSceneGraphGroupSelection?.(document, intent);
+    if (projectValidation && !projectValidation.ok) {
+        state.status = `Group selection rejected: ${projectValidation.reason ?? 'project validation failed'}`;
+        return true;
+    }
+    const patch = options.documentAdapter.createSceneGraphGroupSelectionPatch?.(document, intent);
+    if (!patch) {
+        state.status = 'Group selection rejected';
+        return true;
+    }
+    const result = state.session.dispatch({
+        type: 'document.patch',
+        label: patch.label ?? 'Group Selection',
+        patch: patch.patch,
+        targetId: patch.createdId,
+    });
+    if (!result.documentChanged) {
+        state.status = 'Group selection unchanged';
+        return true;
+    }
+    let selection = result.selection;
+    if (patch.createdId && isNodeSelectableInDocument(options, result.workingDocument, patch.createdId)) {
+        selection = state.session.dispatch({
+            type: 'selection.replace',
+            selectedIds: [patch.createdId],
+            activeId: patch.createdId,
+            label: 'Select Created Group',
+        }).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 ?? `Grouped ${patch.changedIds?.length ?? intent.ids.length} node(s)`;
+    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)
@@ -668,19 +850,30 @@ function patchSerializedProperty(state, options, input) {
         return false;
     const document = state.session.getState().workingDocument;
     const targetIds = input.targetIds && input.targetIds.length > 0 ? input.targetIds : [input.targetId];
+    const transaction = createInspectorEditTransaction(state, options, document, input, targetIds);
+    if (!transaction.ok) {
+        state.status = transaction.message;
+        return false;
+    }
+    const payload = transaction.payload;
     if (targetIds.length > 1) {
         const patch = options.documentAdapter.createSerializedMultiPropertyPatch?.({
             document,
             targetIds,
             activeId: state.session.getState().selection.activeId,
-            path: input.path,
-            value: input.value,
+            path: payload.path,
+            value: payload.value,
+            control: payload.control,
+            valueType: payload.valueType,
+            commitMode: payload.commitMode,
+            persistence: payload.persistence,
+            source: payload.source,
         });
         if (!patch)
             return false;
         const result = state.session.dispatch({
             type: 'document.patch',
-            label: patch.label ?? `Patch ${input.path} on ${targetIds.length} objects`,
+            label: patch.label ?? `Patch ${payload.path} on ${targetIds.length} objects`,
             patch: patch.patch,
             targetId: state.session.getState().selection.activeId ?? undefined,
         });
@@ -688,30 +881,96 @@ function patchSerializedProperty(state, options, input) {
             return false;
         const changedIds = patch.changedIds ?? targetIds;
         const workingDocument = result.workingDocument;
-        syncProjectionForChangedIds(state, options, workingDocument, changedIds);
+        if (patch.reprojectIds?.length)
+            reprojectProjectionForChangedIds(state, options, workingDocument, patch.reprojectIds);
+        else
+            syncProjectionForChangedIds(state, options, workingDocument, changedIds);
         state.summary = summarizeDocument(options, workingDocument, state.session.getSource());
-        state.status = patch.label ?? `Patch ${input.path} on ${targetIds.length} objects`;
+        state.status = patch.label ?? `Patch ${payload.path} on ${targetIds.length} objects`;
         return true;
     }
     const patch = options.documentAdapter.createSerializedPropertyPatch({
-        ...input,
         document,
+        targetId: payload.targetId,
+        targetIds: payload.targetIds,
+        path: payload.path,
+        value: payload.value,
+        control: payload.control,
+        valueType: payload.valueType,
+        commitMode: payload.commitMode,
+        persistence: payload.persistence,
+        source: payload.source,
     });
     if (!patch)
         return false;
     const result = state.session.dispatch({
         type: 'document.patch',
-        label: patch.label ?? `Patch ${input.path}`,
+        label: patch.label ?? `Patch ${payload.path}`,
         patch: patch.patch,
     });
-    if (patch.changedIds)
+    if (patch.reprojectIds?.length)
+        reprojectProjectionForChangedIds(state, options, result.workingDocument, patch.reprojectIds);
+    else if (patch.changedIds)
         syncProjectionForChangedIds(state, options, result.workingDocument, patch.changedIds);
     else
-        syncProjectionForDispatchResult(state, options, result, patch.changedId ?? input.targetId);
+        syncProjectionForDispatchResult(state, options, result, patch.changedId ?? payload.targetId);
     state.summary = summarizeDocument(options, result.workingDocument, state.session.getSource());
-    state.status = patch.label ?? `Patched ${input.path}`;
+    state.status = patch.label ?? `Patched ${payload.path}`;
     return true;
 }
+function createInspectorEditTransaction(state, options, document, input, targetIds) {
+    const property = findInspectorPropertyForEdit(state, options, document, input, targetIds);
+    if (!property) {
+        return { ok: false, message: `Inspector property not found: ${input.path}.` };
+    }
+    const result = createInspectorEditPayload(property, {
+        targetId: input.targetId,
+        targetIds: input.targetIds,
+        path: input.path,
+        value: input.value,
+        control: input.control,
+        valueType: input.valueType,
+        commitMode: input.commitMode,
+        persistence: input.persistence,
+        source: input.source,
+    });
+    if (!result.ok)
+        return { ok: false, message: result.message };
+    return { ok: true, payload: result.value };
+}
+function findInspectorPropertyForEdit(state, options, document, input, targetIds) {
+    const inspector = createInspectorObjectForEdit(state, options, document, input, targetIds);
+    if (!inspector)
+        return null;
+    return findInspectorPropertyByPath(inspector, input.path);
+}
+function createInspectorObjectForEdit(state, options, document, input, targetIds) {
+    if (targetIds.length > 1) {
+        const activeId = state.session?.getState().selection.activeId ?? input.targetId ?? null;
+        const inspector = options.documentAdapter.getInspectorMultiObject?.(document, targetIds, activeId) ?? null;
+        if (inspector)
+            return withInspectorComponentSections(state, options, document, inspector);
+        const serializedMultiObject = options.documentAdapter.getSerializedMultiObject?.(document, targetIds, activeId) ?? null;
+        return serializedMultiObject
+            ? withInspectorComponentSections(state, options, document, serializedMultiObjectToInspectorObject(serializedMultiObject, document))
+            : null;
+    }
+    const inspector = options.documentAdapter.getInspectorObject?.(document, input.targetId) ?? null;
+    if (inspector)
+        return withInspectorComponentSections(state, options, document, inspector);
+    const serializedObject = options.documentAdapter.getSerializedObject(document, input.targetId);
+    return serializedObject
+        ? withInspectorComponentSections(state, options, document, serializedObjectToInspectorObject(serializedObject, document))
+        : null;
+}
+function findInspectorPropertyByPath(inspector, path) {
+    for (const section of inspector.sections) {
+        const property = section.properties.find(candidate => candidate.path === path);
+        if (property)
+            return property;
+    }
+    return null;
+}
 function commitGizmoTransform(state, options, event) {
     if (state.mode !== 'editor' || !state.session)
         return false;
@@ -865,15 +1124,45 @@ function syncProjectionForChangedIds(state, options, document, changedIds) {
     const selection = state.session?.getState().selection ?? { selectedIds: [], activeId: null };
     syncSelectionToProjection(state, selection);
 }
+function reprojectProjectionForChangedIds(state, options, document, changedIds) {
+    for (const changedId of changedIds) {
+        const projectedNode = options.documentAdapter.getProjectionNode(document, changedId);
+        if (projectedNode)
+            state.projection?.projectNode(projectedNode);
+    }
+    const selection = state.session?.getState().selection ?? { selectedIds: [], activeId: null };
+    syncSelectionToProjection(state, selection);
+    state.gizmo?.refreshSelection();
+}
 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;
+    const serializedObject = document && activeId && selectedIds.length === 1
+        ? options.documentAdapter.getSerializedObject(document, activeId)
+        : null;
+    const serializedMultiObject = document && selectedIds.length > 1
+        ? options.documentAdapter.getSerializedMultiObject?.(document, selectedIds, activeId) ?? null
+        : null;
+    const inspectorObjectBase = document && activeId && selectedIds.length === 1
+        ? options.documentAdapter.getInspectorObject?.(document, activeId) ?? (serializedObject ? serializedObjectToInspectorObject(serializedObject, document) : null)
+        : null;
+    const inspectorMultiObjectBase = document && selectedIds.length > 1
+        ? options.documentAdapter.getInspectorMultiObject?.(document, selectedIds, activeId) ?? (serializedMultiObject ? serializedMultiObjectToInspectorObject(serializedMultiObject, document) : null)
+        : null;
+    const inspectorObject = document && inspectorObjectBase
+        ? withRuntimeInspectorSections(state, options, document, inspectorObjectBase)
+        : inspectorObjectBase;
+    const inspectorMultiObject = document && inspectorMultiObjectBase
+        ? withRuntimeInspectorSections(state, options, document, inspectorMultiObjectBase)
+        : inspectorMultiObjectBase;
     return {
         mode: state.mode,
         busy: state.busy,
         status: state.status,
+        statusTone: state.statusToneStatus === state.status ? state.statusTone : 'default',
+        statusDetails: state.statusToneStatus === state.status ? state.statusDetails : '',
         summary: state.summary,
         assetFilter: state.assetFilter,
         assets: state.assets
@@ -887,12 +1176,10 @@ function createUiState(state, options) {
             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,
+        serializedObject,
+        serializedMultiObject,
+        inspectorObject,
+        inspectorMultiObject,
         boxSelection: state.boxSelection,
         transformTool: {
             activeTool: state.gizmo?.getState().tool ?? state.transformTool,
@@ -912,12 +1199,159 @@ function createUiState(state, options) {
             : null,
     };
 }
+function withRuntimeInspectorSections(state, options, document, inspectorObject) {
+    const baseInspectorObject = withInspectorComponentSections(state, options, document, inspectorObject);
+    const activeId = inspectorObject.activeId;
+    const projectionNode = activeId ? options.documentAdapter.getProjectionNode(document, activeId) : null;
+    const projectedRoot = activeId ? state.projection?.getProjectedNode(activeId)?.root ?? null : null;
+    const context = {
+        document,
+        targetIds: baseInspectorObject.targetIds,
+        activeId,
+        inspectorObject: baseInspectorObject,
+        projectionNode,
+        projectedRoot,
+    };
+    const runtimeSections = [
+        ...createDefaultRuntimeInspectorSections(context),
+        ...(options.documentAdapter.getRuntimeInspectorSections?.(context) ?? []),
+    ];
+    const sections = mergeInspectorSections(baseInspectorObject.sections, runtimeSections, {
+        propertyConflict: options.inspector?.propertyConflict,
+    });
+    return {
+        ...baseInspectorObject,
+        sections,
+    };
+}
+function withInspectorComponentSections(state, options, document, inspectorObject) {
+    const context = createHarnessInspectorSelectionContext(state, document, inspectorObject);
+    return mergeLocalEditorHarnessInspectorComponentSections({
+        inspectorObject,
+        components: options.inspector?.components,
+        context,
+        componentConflict: options.inspector?.componentConflict,
+        propertyConflict: options.inspector?.propertyConflict,
+    });
+}
+function getInspectorComponentSections(input) {
+    if (isInspectorRegistry(input.components))
+        return input.components.getSections(input.context);
+    const registry = createInspectorRegistry({
+        onConflict: input.componentConflict,
+        propertyConflict: input.propertyConflict,
+    });
+    for (const component of input.components)
+        registry.register(component);
+    return registry.getSections(input.context);
+}
+function createHarnessInspectorSelectionContext(state, document, inspectorObject) {
+    const activeId = inspectorObject.activeId;
+    const projectedRoot = activeId ? state.projection?.getProjectedNode(activeId)?.root ?? null : null;
+    return {
+        ...inspectorObject.selection,
+        targetIds: inspectorObject.targetIds,
+        activeId,
+        document,
+        runtimeTarget: inspectorObject.selection.runtimeTarget ?? projectedRoot ?? undefined,
+    };
+}
+function isInspectorRegistry(components) {
+    return !Array.isArray(components)
+        && typeof components.getSections === 'function';
+}
+function createDefaultRuntimeInspectorSections(context) {
+    if (context.targetIds.length !== 1)
+        return [];
+    const root = context.projectedRoot;
+    const projectionNode = context.projectionNode;
+    if (!root && !projectionNode)
+        return [];
+    const properties = [];
+    if (projectionNode) {
+        properties.push(createRuntimeInspectorProperty('runtime.projection.nodeId', 'Projected ID', projectionNode.id, properties.length));
+        const assetSource = projectionNode.asset?.sourceId ?? projectionNode.asset?.id ?? '';
+        if (assetSource)
+            properties.push(createRuntimeInspectorProperty('runtime.projection.assetSource', 'Asset Source', assetSource, properties.length));
+    }
+    const runtimeClass = readRuntimeClassName(root);
+    if (runtimeClass)
+        properties.push(createRuntimeInspectorProperty('runtime.root.className', 'Runtime Class', runtimeClass, properties.length));
+    const runtimeName = readRuntimeStringProperty(root, 'name');
+    if (runtimeName)
+        properties.push(createRuntimeInspectorProperty('runtime.root.name', 'Runtime Name', runtimeName, properties.length));
+    const childCount = readRuntimeChildCount(root);
+    if (childCount != null)
+        properties.push(createRuntimeInspectorProperty('runtime.root.children', 'Runtime Children', childCount, properties.length));
+    if (properties.length === 0)
+        return [];
+    return [{
+            id: 'runtimeDiagnostics',
+            title: 'Runtime Diagnostics',
+            order: 900,
+            placement: 'body',
+            persistence: 'runtime',
+            runtimeOnly: true,
+            properties,
+        }];
+}
+function createRuntimeInspectorProperty(path, label, value, order) {
+    return {
+        path,
+        label,
+        valueType: typeof value === 'number' ? 'number' : typeof value === 'boolean' ? 'boolean' : typeof value === 'object' ? 'object' : 'string',
+        control: 'readonly',
+        value,
+        readOnly: true,
+        persistence: 'runtime',
+        commitMode: 'blur',
+        order,
+    };
+}
+function readRuntimeClassName(value) {
+    const record = isObjectRecord(value) ? value : null;
+    const getter = record?.getClassName;
+    if (typeof getter === 'function') {
+        const className = getter.call(value);
+        if (typeof className === 'string' && className.trim())
+            return className;
+    }
+    const constructorName = record?.constructor && typeof record.constructor === 'function'
+        ? record.constructor.name
+        : '';
+    return constructorName && constructorName !== 'Object' ? constructorName : null;
+}
+function readRuntimeStringProperty(value, key) {
+    if (!isObjectRecord(value))
+        return null;
+    const raw = value[key];
+    return typeof raw === 'string' && raw.trim() ? raw : null;
+}
+function readRuntimeChildCount(value) {
+    if (!isObjectRecord(value))
+        return null;
+    const children = value.getChildren;
+    if (typeof children === 'function') {
+        const result = children.call(value);
+        return Array.isArray(result) ? result.length : null;
+    }
+    return null;
+}
+function isObjectRecord(value) {
+    return !!value && typeof value === 'object';
+}
 function summarizeDocument(options, document, _source) {
     return options.documentAdapter.summarize?.(document) ?? '';
 }
-function summarizeAuthoringFailure(result) {
+export function summarizeLocalEditorAuthoringFailure(result) {
     const diagnostic = result.diagnostics.find(item => item.severity === 'error') ?? result.diagnostics[0];
-    return diagnostic?.message ?? result.reason ?? 'Authoring source commit failed';
+    const status = diagnostic?.message ?? result.reason ?? 'Authoring source commit failed';
+    const diagnostics = summarizeDiagnostics(result.diagnostics);
+    const details = [
+        result.reason ? `Reason: ${result.reason}` : '',
+        diagnostics ? `Diagnostics: ${diagnostics}` : '',
+    ].filter(Boolean).join('\n') || status;
+    return { status, details };
 }
 function summarizeDiagnostics(diagnostics) {
     if (!diagnostics?.length)