@fps-games/editor 0.2.0-beta.4 → 0.2.1-beta.2

package/dist/agent-bridge/capabilities/prefabs.js

@@ -1,6 +1,6 @@
 import { EDITOR_AGENT_BRIDGE_CAPABILITY_ID, } from '@fps-games/editor-protocol';
 import { createLocalEditorAgentBridgeFailure, isLocalEditorAgentBridgeVec3 } from '../diagnostics.js';
-import { normalizeAgentBridgeString, } from '../shared.js';
+import { createAgentBridgeSafePrefabReadModel, normalizeAgentBridgeString, } from '../shared.js';
 import { findAgentBridgeVisibleAssetInfo, listAgentBridgeVisibleAssetInfos } from './assets.js';
 const PREFAB_STAGE_ITEM_PREFIX = 'prefab-node:';
 const PREFAB_ROOT_NODE_ID = 'prefab-root';
@@ -19,7 +19,7 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
                     : 'Prefab asset not found.', { code: resolved.ambiguous ? 'prefab.ambiguous' : 'prefab.notFound' });
             }
             const currentStage = operations.getPrefabStage();
-            if (isSamePrefabStage(currentStage, resolved.resolvedPrefab)) {
+            if (currentStage && isSamePrefabStage(currentStage, resolved.resolvedPrefab)) {
                 return {
                     opened: false,
                     alreadyOpen: true,
@@ -28,9 +28,13 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
                     status: `Editing Prefab ${currentStage.label}`,
                 };
             }
+            if (currentStage?.dirty && (input.dirtyAction ?? 'reject') === 'reject') {
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_OPEN, 'The current Prefab stage has unsaved changes.', { code: 'prefab.stageDirty' });
+            }
             const output = await operations.openPrefabStage({
                 assetId: resolved.resolvedPrefab.assetId,
                 browserAssetId: resolved.resolvedPrefab.browserAssetId,
+                dirtyAction: input.dirtyAction ?? 'reject',
             });
             if (!output) {
                 return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_OPEN, `Prefab stage unavailable: ${resolved.resolvedPrefab.assetId}`, { code: 'prefab.stageOpenFailed' });
@@ -38,12 +42,34 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
             renderUi();
             return output;
         },
-        async exitStage() {
-            const output = await operations.exitPrefabStage();
+        async exitStage(input) {
+            const currentStage = operations.getPrefabStage();
+            if (currentStage?.dirty && (input.dirtyAction ?? 'reject') === 'reject') {
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_EXIT, 'The current Prefab stage has unsaved changes.', { code: 'prefab.stageDirty' });
+            }
+            const output = await operations.exitPrefabStage({ dirtyAction: input.dirtyAction ?? 'reject' });
             if (output.exited)
                 renderUi();
             return output;
         },
+        async saveStage() {
+            const changed = await operations.savePrefabStage();
+            const stage = operations.getPrefabStage();
+            if (!stage) {
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_SAVE, 'No Prefab stage is open.', { code: 'prefab.stageNotOpen' });
+            }
+            renderUi();
+            return { changed, stage, status: state.status };
+        },
+        discardStage() {
+            const changed = operations.discardPrefabStage();
+            const stage = operations.getPrefabStage();
+            if (!stage) {
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_DISCARD, 'No Prefab stage is open.', { code: 'prefab.stageNotOpen' });
+            }
+            renderUi();
+            return { changed, stage, status: state.status };
+        },
         renameAsset(input) {
             const details = operations.getPrefabStageDetails();
             const assetId = normalizeAgentBridgeString(input.assetId) || details?.stage.assetId || '';
@@ -189,6 +215,47 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
                 select: input.select,
             });
         },
+        createMarkerNode(input) {
+            const details = operations.getPrefabStageDetails();
+            if (!details) {
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_MARKER, 'Prefab stage is not open.', { code: 'prefab.stageNotOpen' });
+            }
+            const beforeScene = createSafePrefabSceneOutput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_MARKER, details, operations);
+            if ('ok' in beforeScene)
+                return beforeScene;
+            const document = state.session?.getState({ cloneDocuments: false }).workingDocument ?? null;
+            const markerType = normalizeAgentBridgeString(input.type);
+            const markerTypes = document ? options.documentAdapter.getMarkerTypeCatalog?.(document) ?? [] : [];
+            if (!markerType || !markerTypes.some(definition => definition.type === markerType)) {
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_MARKER, `Unknown Prefab Marker type: ${markerType || '(empty)'}`, { code: 'prefab.unknownMarkerType', details: { type: input.type } });
+            }
+            const targetFailure = validatePrefabMarkerTargetInput(beforeScene, input.target, null);
+            if (targetFailure)
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_MARKER, targetFailure.message, { code: targetFailure.code, details: targetFailure.details });
+            const parentNodeId = resolvePrefabMutationParentNodeId(input.parentNodeId, beforeScene);
+            const action = {
+                actionId: 'prefab.node.createMarker',
+                targetPrefabAssetId: details.stage.assetId,
+                parentNodeId,
+                value: {
+                    ...createPrefabNodeCreateActionValue(input),
+                    type: markerType,
+                    ...(input.target ? { target: input.target } : {}),
+                    ...(input.tags ? { tags: input.tags } : {}),
+                    ...(input.note !== undefined ? { note: input.note } : {}),
+                    ...(input.color ? { color: input.color } : {}),
+                },
+            };
+            return runPrefabNodeMutation({
+                capabilityId: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_MARKER,
+                state,
+                operations,
+                renderUi,
+                beforeScene,
+                action,
+                select: input.select,
+            });
+        },
         createPrimitiveNode(input) {
             const details = operations.getPrefabStageDetails();
             if (!details) {
@@ -249,6 +316,50 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
                 changedNodeId: nodeId,
             });
         },
+        setNodeMarker(input) {
+            const details = operations.getPrefabStageDetails();
+            const nodeId = normalizePrefabNodeId(input.nodeId);
+            if (!details || !nodeId) {
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_MARKER, details ? 'Prefab node id is required.' : 'Prefab stage is not open.', { code: details ? 'prefab.invalidInput' : 'prefab.stageNotOpen', details: { nodeId: input.nodeId } });
+            }
+            const beforeScene = createSafePrefabSceneOutput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_MARKER, details, operations);
+            if ('ok' in beforeScene)
+                return beforeScene;
+            const node = beforeScene.nodes.find(candidate => candidate.nodeId === nodeId) ?? null;
+            if (!node)
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_MARKER, `Prefab node not found: ${nodeId}`, { code: 'prefab.nodeNotFound', details: { nodeId } });
+            if (node.kind !== 'marker')
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_MARKER, `Prefab node is not a Marker: ${nodeId}`, { code: 'prefab.nodeKindMismatch', details: { nodeId, kind: node.kind } });
+            const document = state.session?.getState({ cloneDocuments: false }).workingDocument ?? null;
+            const markerTypes = document ? options.documentAdapter.getMarkerTypeCatalog?.(document) ?? [] : [];
+            if (input.type !== undefined && !markerTypes.some(definition => definition.type === input.type)) {
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_MARKER, `Unknown Prefab Marker type: ${input.type}`, { code: 'prefab.unknownMarkerType', details: { nodeId, type: input.type } });
+            }
+            const targetFailure = validatePrefabMarkerTargetInput(beforeScene, input.target, nodeId);
+            if (targetFailure)
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_MARKER, targetFailure.message, { code: targetFailure.code, details: targetFailure.details });
+            const value = {
+                ...(input.type !== undefined ? { type: input.type } : {}),
+                ...(input.target !== undefined ? { target: input.target } : {}),
+                ...(input.tags !== undefined ? { tags: input.tags } : {}),
+                ...(input.note !== undefined ? { note: input.note } : {}),
+                ...(input.color !== undefined ? { color: input.color } : {}),
+            };
+            return runPrefabNodeMutation({
+                capabilityId: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_MARKER,
+                state,
+                operations,
+                renderUi,
+                beforeScene,
+                action: {
+                    actionId: 'prefab.node.setMarker',
+                    targetPrefabAssetId: details.stage.assetId,
+                    nodeId,
+                    value,
+                },
+                changedNodeId: nodeId,
+            });
+        },
         reparentNode(input) {
             return runNodeIdMutation({
                 capabilityId: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_REPARENT,
@@ -394,43 +505,73 @@ function isRequestedPrefabStage(stage, assetId) {
     return !normalized || stage.assetId === normalized || stage.browserAssetId === normalized;
 }
 function createSafePrefabSceneOutput(capabilityId, details, operations) {
-    const projection = operations.getHierarchyProjection();
-    const expectedScopeId = `prefab-stage:${details.stage.assetId}`;
-    if (!projection
-        || projection.scopeKind !== 'prefab-stage'
-        || projection.scopeId !== expectedScopeId) {
-        return createLocalEditorAgentBridgeFailure(capabilityId, 'Prefab Hierarchy projection is unavailable or does not match the active Prefab Stage.', {
-            code: 'prefab.hierarchyProjectionUnavailable',
+    const model = operations.getHierarchyReadModel();
+    const expectedScopeKey = `prefab-stage:${details.stage.assetId}`;
+    if (model.snapshot.scopeType !== 'prefab-stage'
+        || model.snapshot.scopeKey !== expectedScopeKey) {
+        return createLocalEditorAgentBridgeFailure(capabilityId, 'Prefab Hierarchy scope is unavailable or does not match the active Prefab Stage.', {
+            code: 'prefab.hierarchyScopeUnavailable',
             details: {
                 assetId: details.stage.assetId,
-                expectedScopeId,
-                actualScopeId: projection?.scopeId,
-                actualScopeKind: projection?.scopeKind,
+                expectedScopeKey,
+                actualScopeKey: model.snapshot.scopeKey,
+                actualScopeType: model.snapshot.scopeType,
+                authorityToken: model.authorityToken,
+                revision: model.snapshot.revision,
             },
         });
     }
-    const safeNodeIds = new Set(projection.targets.map(target => target.targetId));
-    for (const node of projection.nodes) {
-        if (node.sourceKind !== 'root')
-            continue;
-        const rootNodeId = normalizePrefabNodeId(node.id);
-        if (rootNodeId)
-            safeNodeIds.add(rootNodeId);
-    }
-    return createPrefabSceneOutput(details, safeNodeIds);
-}
-function createPrefabSceneOutput(details, safeNodeIds) {
-    const nodes = listPrefabSceneNodes(details.structureItems)
-        .filter(node => safeNodeIds.has(node.nodeId));
-    const rootNodeId = nodes.find(node => node.kind === 'root')?.nodeId
+    return createPrefabSceneOutput(details, createAgentBridgeSafePrefabReadModel(model, details.nodeDetails));
+}
+function createPrefabSceneOutput(details, safeModel) {
+    const pathByNodeId = new Map();
+    const nodes = safeModel.nodes.flatMap((safeNode) => {
+        const kind = normalizePrefabNodeKind(safeNode.details?.kind)
+            ?? normalizePrefabNodeRole(safeNode.role);
+        if (!kind)
+            return [];
+        const parentPath = safeNode.parentNodeId ? pathByNodeId.get(safeNode.parentNodeId) : undefined;
+        const path = parentPath ? `${parentPath}/${safeNode.label}` : safeNode.label;
+        pathByNodeId.set(safeNode.nodeId, path);
+        const detail = safeNode.details;
+        const transform = readPrefabItemTransform(detail?.transform);
+        const primitive = readPrefabPrimitive(detail?.primitive);
+        return [{
+                nodeId: safeNode.nodeId,
+                ...(detail?.guid ? { guid: detail.guid } : {}),
+                name: safeNode.label,
+                kind,
+                parentNodeId: safeNode.parentNodeId,
+                ...(path ? { path } : {}),
+                ...(detail?.sourceAssetId ? { sourceAssetId: detail.sourceAssetId } : {}),
+                ...(detail?.sourceNodePath ? { sourceNodePath: detail.sourceNodePath } : {}),
+                ...(detail?.childPrefabId ? { childPrefabId: detail.childPrefabId } : {}),
+                ...(transform ? { transform } : {}),
+                ...(primitive ? { primitive } : {}),
+                ...(Object.keys(readRecord(detail?.marker)).length > 0
+                    ? { marker: structuredClone(readRecord(detail?.marker)) }
+                    : {}),
+                ...(Object.keys(readRecord(detail?.defaults)).length > 0
+                    ? { defaults: structuredClone(readRecord(detail?.defaults)) }
+                    : {}),
+                ...(Object.keys(readRecord(detail?.overrides)).length > 0
+                    ? { overrides: structuredClone(readRecord(detail?.overrides)) }
+                    : {}),
+                ...(detail?.readonly != null ? { readonly: detail.readonly } : {}),
+            }];
+    });
+    const safeNodeIds = new Set(nodes.map(node => node.nodeId));
+    const rootNodeId = safeModel.nodes.find(node => node.role === 'root' && safeNodeIds.has(node.nodeId))?.nodeId
         ?? nodes.find(node => !node.parentNodeId)?.nodeId
         ?? PREFAB_ROOT_NODE_ID;
-    const rawSelectedNodeId = getSelectedPrefabNodeId(details.stage.selectedItemId);
-    const selectedNodeId = rawSelectedNodeId && safeNodeIds.has(rawSelectedNodeId)
-        ? rawSelectedNodeId
+    const selectedNodeId = safeModel.activeNodeId && safeNodeIds.has(safeModel.activeNodeId)
+        ? safeModel.activeNodeId
+        : null;
+    const selectedRowId = selectedNodeId
+        ? safeModel.nodes.find(node => node.nodeId === selectedNodeId)?.rowId ?? null
         : null;
     return {
-        stage: details.stage,
+        stage: { ...details.stage, selectedItemId: selectedRowId },
         rootNodeId,
         selectedNodeId,
         nodes,
@@ -446,43 +587,6 @@ function createPrefabSceneOutput(details, safeNodeIds) {
             : {}),
     };
 }
-function listPrefabSceneNodes(items) {
-    const nodes = [];
-    const visit = (item, parentNodeId, parentPath) => {
-        const nodeId = normalizePrefabNodeId(item.nodeId ?? item.id);
-        const isPrefabNode = item.itemType === 'prefab-node' || !!item.nodeId || item.id.startsWith(PREFAB_STAGE_ITEM_PREFIX);
-        const kind = normalizePrefabNodeKind(item.kind);
-        const path = parentPath ? `${parentPath}/${item.label}` : item.label;
-        const currentParentNodeId = isPrefabNode && nodeId ? nodeId : parentNodeId;
-        if (isPrefabNode && nodeId && kind) {
-            const transform = readPrefabItemTransform(item.transform);
-            const primitive = readPrefabPrimitive(item.primitive);
-            const node = {
-                nodeId,
-                ...(item.guid ? { guid: item.guid } : {}),
-                name: item.label,
-                kind,
-                ...(parentNodeId ? { parentNodeId } : { parentNodeId: null }),
-                ...(path ? { path } : {}),
-                ...(item.sourceAssetId ? { sourceAssetId: item.sourceAssetId } : {}),
-                ...(item.sourceNodePath ? { sourceNodePath: item.sourceNodePath } : {}),
-                ...(item.childPrefabId ? { childPrefabId: item.childPrefabId } : {}),
-                ...(transform ? { transform } : {}),
-                ...(primitive ? { primitive } : {}),
-                ...(Object.keys(readRecord(item.defaults)).length > 0 ? { defaults: structuredClone(readRecord(item.defaults)) } : {}),
-                ...(Object.keys(readRecord(item.overrides)).length > 0 ? { overrides: structuredClone(readRecord(item.overrides)) } : {}),
-                ...(item.readonly != null ? { readonly: item.readonly } : {}),
-            };
-            nodes.push(node);
-        }
-        for (const child of item.children ?? []) {
-            visit(child, currentParentNodeId, path);
-        }
-    };
-    for (const item of items)
-        visit(item, null, '');
-    return nodes;
-}
 function normalizePrefabNodeKind(kind) {
     if (kind === 'root'
         || kind === 'group'
@@ -490,11 +594,17 @@ function normalizePrefabNodeKind(kind) {
         || kind === 'primitive'
         || kind === 'light'
         || kind === 'prefabInstance'
+        || kind === 'marker'
         || kind === 'collision') {
         return kind;
     }
     return null;
 }
+function normalizePrefabNodeRole(role) {
+    if (role === 'root' || role === 'group' || role === 'marker')
+        return role;
+    return role === 'object' ? 'model' : null;
+}
 function normalizePrefabNodeId(value) {
     const id = normalizeAgentBridgeString(value);
     return id.startsWith(PREFAB_STAGE_ITEM_PREFIX) ? id.slice(PREFAB_STAGE_ITEM_PREFIX.length) : id;
@@ -518,16 +628,41 @@ function createPrefabAssetRenameOutput(input) {
 function createPrefabStageItemId(nodeId) {
     return `${PREFAB_STAGE_ITEM_PREFIX}${nodeId}`;
 }
-function getSelectedPrefabNodeId(itemId) {
-    const nodeId = normalizePrefabNodeId(itemId);
-    return nodeId || null;
-}
 function resolvePrefabMutationParentNodeId(inputParentNodeId, scene) {
     const parentNodeId = normalizePrefabNodeId(inputParentNodeId);
     if (parentNodeId)
         return parentNodeId;
     return scene.selectedNodeId || scene.rootNodeId;
 }
+function validatePrefabMarkerTargetInput(scene, target, markerNodeId) {
+    if (target == null)
+        return null;
+    const targetId = normalizePrefabNodeId(target.id);
+    if (markerNodeId && targetId === markerNodeId) {
+        return {
+            code: 'prefab.markerSelfTarget',
+            message: 'A Prefab Marker cannot target itself.',
+            details: { nodeId: markerNodeId, targetId },
+        };
+    }
+    const targetNode = scene.nodes.find(node => node.nodeId === targetId) ?? null;
+    if (!targetNode) {
+        return {
+            code: 'prefab.markerTargetNotFound',
+            message: `Prefab Marker target is outside the current composition or missing: ${targetId}`,
+            details: { nodeId: markerNodeId, targetId, targetKind: target.kind },
+        };
+    }
+    const expectedKind = targetNode.kind === 'marker' ? 'marker' : 'scene-object';
+    if (target.kind !== expectedKind) {
+        return {
+            code: 'prefab.markerTargetKindMismatch',
+            message: `Prefab Marker target kind must be ${expectedKind} for node ${targetId}.`,
+            details: { nodeId: markerNodeId, targetId, targetKind: target.kind, expectedKind },
+        };
+    }
+    return null;
+}
 function createPrefabNodeCreateActionValue(input) {
     const name = normalizeAgentBridgeString(input.name);
     const sourceNodePath = normalizeAgentBridgeString(input.sourceNodePath);