@fps-games/editor 0.2.1-beta.3 → 0.2.1-beta.4

package/dist/{agent-bridge → editor-commands}/capabilities/prefabs.js

@@ -1,20 +1,20 @@
-import { EDITOR_AGENT_BRIDGE_CAPABILITY_ID, } from '@fps-games/editor-protocol';
-import { createLocalEditorAgentBridgeFailure, isLocalEditorAgentBridgeVec3 } from '../diagnostics.js';
-import { createAgentBridgeSafePrefabReadModel, normalizeAgentBridgeString, } from '../shared.js';
-import { findAgentBridgeVisibleAssetInfo, listAgentBridgeVisibleAssetInfos } from './assets.js';
+import { EDITOR_COMMAND_ID, } from '@fps-games/editor-protocol';
+import { createLocalEditorCommandFailure, isLocalEditorCommandVec3 } from '../diagnostics.js';
+import { createEditorCommandSafePrefabReadModel, normalizeEditorCommandString, } from '../shared.js';
+import { findEditorCommandVisibleAssetInfo, listEditorCommandVisibleAssetInfos } from './assets.js';
 const PREFAB_STAGE_ITEM_PREFIX = 'prefab-node:';
 const PREFAB_ROOT_NODE_ID = 'prefab-root';
 const ZERO_VEC3 = { x: 0, y: 0, z: 0 };
 const ONE_VEC3 = { x: 1, y: 1, z: 1 };
-export function createLocalEditorAgentBridgePrefabSource(state, options, renderUi, operations) {
+export function createLocalEditorCommandPrefabSource(state, options, renderUi, operations) {
     return {
         resolvePrefab(input) {
             return resolvePrefabs(state, options, operations, input);
         },
-        async openStage(input) {
+        async openStage(input, context) {
             const resolved = resolvePrefabs(state, options, operations, input);
             if (!resolved.resolvedPrefab) {
-                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_OPEN, resolved.ambiguous
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.PREFAB_STAGE_OPEN, resolved.ambiguous
                     ? 'Prefab query matched multiple prefab assets; provide assetId or browserAssetId.'
                     : 'Prefab asset not found.', { code: resolved.ambiguous ? 'prefab.ambiguous' : 'prefab.notFound' });
             }
@@ -29,68 +29,68 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
                 };
             }
             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' });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_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',
-            });
+            }, context?.serializedAuthoringAccess);
             if (!output) {
-                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_OPEN, `Prefab stage unavailable: ${resolved.resolvedPrefab.assetId}`, { code: 'prefab.stageOpenFailed' });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.PREFAB_STAGE_OPEN, `Prefab stage unavailable: ${resolved.resolvedPrefab.assetId}`, { code: 'prefab.stageOpenFailed' });
             }
             renderUi();
             return output;
         },
-        async exitStage(input) {
+        async exitStage(input, context) {
             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' });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.PREFAB_STAGE_EXIT, 'The current Prefab stage has unsaved changes.', { code: 'prefab.stageDirty' });
             }
-            const output = await operations.exitPrefabStage({ dirtyAction: input.dirtyAction ?? 'reject' });
+            const output = await operations.exitPrefabStage({ dirtyAction: input.dirtyAction ?? 'reject' }, context?.serializedAuthoringAccess);
             if (output.exited)
                 renderUi();
             return output;
         },
-        async saveStage() {
-            const changed = await operations.savePrefabStage();
+        async saveStage(_input, context) {
+            const changed = await operations.savePrefabStage(context?.serializedAuthoringAccess);
             const stage = operations.getPrefabStage();
             if (!stage) {
-                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_SAVE, 'No Prefab stage is open.', { code: 'prefab.stageNotOpen' });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.PREFAB_STAGE_SAVE, 'No Prefab stage is open.', { code: 'prefab.stageNotOpen' });
             }
             renderUi();
             return { changed, stage, status: state.status };
         },
-        discardStage() {
-            const changed = operations.discardPrefabStage();
+        async discardStage(_input, context) {
+            const changed = await operations.discardPrefabStage(context?.serializedAuthoringAccess);
             const stage = operations.getPrefabStage();
             if (!stage) {
-                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_DISCARD, 'No Prefab stage is open.', { code: 'prefab.stageNotOpen' });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_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 || '';
+            const assetId = normalizeEditorCommandString(input.assetId) || details?.stage.assetId || '';
             const displayNameResult = normalizePrefabEditableName(input.displayName);
             if (!assetId || !displayNameResult.ok) {
                 const displayNameError = displayNameResult.ok ? '' : displayNameResult.message;
-                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_ASSET_RENAME, !assetId ? 'Prefab asset id is required.' : displayNameError, {
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.PREFAB_ASSET_RENAME, !assetId ? 'Prefab asset id is required.' : displayNameError, {
                     code: !assetId ? 'prefab.invalidInput' : 'prefab.invalidName',
                     details: { assetId: input.assetId, displayName: input.displayName },
                 });
             }
-            const asset = findAgentBridgeVisibleAssetInfo(state, options, assetId);
+            const asset = findEditorCommandVisibleAssetInfo(state, options, assetId);
             if (!asset || !isPrefabAsset(asset)) {
-                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_ASSET_RENAME, `Prefab asset not found: ${assetId}`, { code: 'prefab.notFound', details: { assetId } });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.PREFAB_ASSET_RENAME, `Prefab asset not found: ${assetId}`, { code: 'prefab.notFound', details: { assetId } });
             }
-            const conflict = listAgentBridgeVisibleAssetInfos(state, options)
+            const conflict = listEditorCommandVisibleAssetInfos(state, options)
                 .find(candidate => candidate.assetId !== assetId
                 && isPrefabAsset(candidate)
                 && candidate.displayName.trim().toLowerCase() === displayNameResult.name.toLowerCase());
             if (conflict) {
-                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_ASSET_RENAME, `Prefab name already exists: ${displayNameResult.name}`, {
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.PREFAB_ASSET_RENAME, `Prefab name already exists: ${displayNameResult.name}`, {
                     code: 'asset.nameConflict',
                     details: { assetId, conflictingAssetId: conflict.assetId, displayName: displayNameResult.name },
                 });
@@ -113,7 +113,7 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
                 value: displayNameResult.name,
             });
             if (!patched) {
-                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_ASSET_RENAME, `Prefab rename action unavailable: ${assetId}`, { code: 'prefab.actionUnavailable', details: { assetId } });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.PREFAB_ASSET_RENAME, `Prefab rename action unavailable: ${assetId}`, { code: 'prefab.actionUnavailable', details: { assetId } });
             }
             renderUi();
             const stageActive = !!operations.getPrefabStageDetails() && operations.getPrefabStageDetails()?.stage.assetId === assetId;
@@ -128,28 +128,28 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
         getScene(input) {
             const details = operations.getPrefabStageDetails();
             if (!details || !isRequestedPrefabStage(details.stage, input.assetId)) {
-                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_SCENE_GET, createPrefabStageUnavailableMessage(input.assetId), { code: 'prefab.stageNotOpen', details: { assetId: input.assetId } });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.PREFAB_SCENE_GET, createPrefabStageUnavailableMessage(input.assetId), { code: 'prefab.stageNotOpen', details: { assetId: input.assetId } });
             }
-            return createSafePrefabSceneOutput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_SCENE_GET, details, operations);
+            return createSafePrefabSceneOutput(EDITOR_COMMAND_ID.PREFAB_SCENE_GET, details, operations);
         },
         selectNode(input) {
             const nodeId = normalizePrefabNodeId(input.nodeId);
             const details = operations.getPrefabStageDetails();
             if (!details || !nodeId) {
-                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SELECT, nodeId ? 'Prefab stage is not open.' : 'Prefab node id is required.', { code: nodeId ? 'prefab.stageNotOpen' : 'prefab.invalidInput', details: { nodeId: input.nodeId } });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.PREFAB_NODE_SELECT, nodeId ? 'Prefab stage is not open.' : 'Prefab node id is required.', { code: nodeId ? 'prefab.stageNotOpen' : 'prefab.invalidInput', details: { nodeId: input.nodeId } });
             }
-            const scene = createSafePrefabSceneOutput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SELECT, details, operations);
+            const scene = createSafePrefabSceneOutput(EDITOR_COMMAND_ID.PREFAB_NODE_SELECT, details, operations);
             if ('ok' in scene)
                 return scene;
             const node = scene.nodes.find(candidate => candidate.nodeId === nodeId) ?? null;
             if (!node) {
-                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SELECT, `Prefab node not found: ${nodeId}`, { code: 'prefab.nodeNotFound', details: { assetId: details.stage.assetId, nodeId } });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.PREFAB_NODE_SELECT, `Prefab node not found: ${nodeId}`, { code: 'prefab.nodeNotFound', details: { assetId: details.stage.assetId, nodeId } });
             }
             const changed = operations.selectPrefabStageItem(createPrefabStageItemId(nodeId));
             if (changed)
                 renderUi();
             const nextDetails = operations.getPrefabStageDetails() ?? details;
-            const nextScene = createSafePrefabSceneOutput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SELECT, nextDetails, operations);
+            const nextScene = createSafePrefabSceneOutput(EDITOR_COMMAND_ID.PREFAB_NODE_SELECT, nextDetails, operations);
             if ('ok' in nextScene)
                 return nextScene;
             const selectedNode = nextScene.nodes.find(candidate => candidate.nodeId === nodeId) ?? node;
@@ -161,14 +161,14 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
         },
         createNodeFromAsset(input) {
             const details = operations.getPrefabStageDetails();
-            const assetId = normalizeAgentBridgeString(input.assetId);
-            const asset = findAgentBridgeVisibleAssetInfo(state, options, assetId);
+            const assetId = normalizeEditorCommandString(input.assetId);
+            const asset = findEditorCommandVisibleAssetInfo(state, options, assetId);
             if (!details || !asset || !assetId) {
-                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_FROM_ASSET, !details
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_FROM_ASSET, !details
                     ? 'Prefab stage is not open.'
                     : `Asset not found: ${assetId || '(empty)'}`, { code: !details ? 'prefab.stageNotOpen' : 'asset.notFound', details: { assetId } });
             }
-            const beforeScene = createSafePrefabSceneOutput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_FROM_ASSET, details, operations);
+            const beforeScene = createSafePrefabSceneOutput(EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_FROM_ASSET, details, operations);
             if ('ok' in beforeScene)
                 return beforeScene;
             const parentNodeId = resolvePrefabMutationParentNodeId(input.parentNodeId, beforeScene);
@@ -181,7 +181,7 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
                 value: createPrefabNodeCreateActionValue(input),
             };
             return runPrefabNodeMutation({
-                capabilityId: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_FROM_ASSET,
+                capabilityId: EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_FROM_ASSET,
                 state,
                 operations,
                 renderUi,
@@ -193,9 +193,9 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
         createGroupNode(input) {
             const details = operations.getPrefabStageDetails();
             if (!details) {
-                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_GROUP, 'Prefab stage is not open.', { code: 'prefab.stageNotOpen' });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_GROUP, 'Prefab stage is not open.', { code: 'prefab.stageNotOpen' });
             }
-            const beforeScene = createSafePrefabSceneOutput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_GROUP, details, operations);
+            const beforeScene = createSafePrefabSceneOutput(EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_GROUP, details, operations);
             if ('ok' in beforeScene)
                 return beforeScene;
             const parentNodeId = resolvePrefabMutationParentNodeId(input.parentNodeId, beforeScene);
@@ -206,7 +206,7 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
                 value: createPrefabNodeCreateActionValue(input),
             };
             return runPrefabNodeMutation({
-                capabilityId: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_GROUP,
+                capabilityId: EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_GROUP,
                 state,
                 operations,
                 renderUi,
@@ -218,20 +218,20 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
         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' });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_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);
+            const beforeScene = createSafePrefabSceneOutput(EDITOR_COMMAND_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 markerType = normalizeEditorCommandString(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 } });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_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 });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_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',
@@ -247,7 +247,7 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
                 },
             };
             return runPrefabNodeMutation({
-                capabilityId: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_MARKER,
+                capabilityId: EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_MARKER,
                 state,
                 operations,
                 renderUi,
@@ -259,9 +259,9 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
         createPrimitiveNode(input) {
             const details = operations.getPrefabStageDetails();
             if (!details) {
-                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_PRIMITIVE, 'Prefab stage is not open.', { code: 'prefab.stageNotOpen' });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_PRIMITIVE, 'Prefab stage is not open.', { code: 'prefab.stageNotOpen' });
             }
-            const beforeScene = createSafePrefabSceneOutput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_PRIMITIVE, details, operations);
+            const beforeScene = createSafePrefabSceneOutput(EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_PRIMITIVE, details, operations);
             if ('ok' in beforeScene)
                 return beforeScene;
             const parentNodeId = resolvePrefabMutationParentNodeId(input.parentNodeId, beforeScene);
@@ -273,7 +273,7 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
                 value: createPrefabNodeCreateActionValue(input),
             };
             return runPrefabNodeMutation({
-                capabilityId: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_PRIMITIVE,
+                capabilityId: EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_PRIMITIVE,
                 state,
                 operations,
                 renderUi,
@@ -286,14 +286,14 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
             const nodeId = normalizePrefabNodeId(input.nodeId);
             const details = operations.getPrefabStageDetails();
             if (!details || !nodeId) {
-                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_TRANSFORM, nodeId ? 'Prefab stage is not open.' : 'Prefab node id is required.', { code: nodeId ? 'prefab.stageNotOpen' : 'prefab.invalidInput', details: { nodeId: input.nodeId } });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.PREFAB_NODE_SET_TRANSFORM, nodeId ? 'Prefab stage is not open.' : 'Prefab node id is required.', { code: nodeId ? 'prefab.stageNotOpen' : 'prefab.invalidInput', details: { nodeId: input.nodeId } });
             }
-            const beforeScene = createSafePrefabSceneOutput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_TRANSFORM, details, operations);
+            const beforeScene = createSafePrefabSceneOutput(EDITOR_COMMAND_ID.PREFAB_NODE_SET_TRANSFORM, 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_TRANSFORM, `Prefab node not found: ${nodeId}`, { code: 'prefab.nodeNotFound', details: { assetId: details.stage.assetId, nodeId } });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.PREFAB_NODE_SET_TRANSFORM, `Prefab node not found: ${nodeId}`, { code: 'prefab.nodeNotFound', details: { assetId: details.stage.assetId, nodeId } });
             }
             const transform = createPrefabTransformActionValue({
                 position: input.position,
@@ -307,7 +307,7 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
                 value: transform,
             };
             return runPrefabNodeMutation({
-                capabilityId: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_TRANSFORM,
+                capabilityId: EDITOR_COMMAND_ID.PREFAB_NODE_SET_TRANSFORM,
                 state,
                 operations,
                 renderUi,
@@ -320,24 +320,24 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
             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 } });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_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);
+            const beforeScene = createSafePrefabSceneOutput(EDITOR_COMMAND_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 } });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_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 } });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_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 } });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_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 });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_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 } : {}),
@@ -346,7 +346,7 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
                 ...(input.color !== undefined ? { color: input.color } : {}),
             };
             return runPrefabNodeMutation({
-                capabilityId: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_MARKER,
+                capabilityId: EDITOR_COMMAND_ID.PREFAB_NODE_SET_MARKER,
                 state,
                 operations,
                 renderUi,
@@ -362,7 +362,7 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
         },
         reparentNode(input) {
             return runNodeIdMutation({
-                capabilityId: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_REPARENT,
+                capabilityId: EDITOR_COMMAND_ID.PREFAB_NODE_REPARENT,
                 state,
                 operations,
                 renderUi,
@@ -373,7 +373,7 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
         },
         renameNode(input) {
             return runNodeIdMutation({
-                capabilityId: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_RENAME,
+                capabilityId: EDITOR_COMMAND_ID.PREFAB_NODE_RENAME,
                 state,
                 operations,
                 renderUi,
@@ -384,7 +384,7 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
         },
         deleteNode(input) {
             return runNodeIdMutation({
-                capabilityId: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_DELETE,
+                capabilityId: EDITOR_COMMAND_ID.PREFAB_NODE_DELETE,
                 state,
                 operations,
                 renderUi,
@@ -393,7 +393,7 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
             });
         },
         getSourceStructure(input) {
-            const resolved = resolvePrefabAssetForInspection(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_SOURCE_STRUCTURE_GET, state, options, operations, input);
+            const resolved = resolvePrefabAssetForInspection(EDITOR_COMMAND_ID.PREFAB_SOURCE_STRUCTURE_GET, state, options, operations, input);
             if (!resolved.ok)
                 return resolved.result;
             const structure = createPrefabSourceStructure(resolved.asset, resolved.node);
@@ -405,7 +405,7 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
             };
         },
         listMaterialSlots(input) {
-            const resolved = resolvePrefabAssetForInspection(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_MATERIAL_SLOTS_LIST, state, options, operations, input);
+            const resolved = resolvePrefabAssetForInspection(EDITOR_COMMAND_ID.PREFAB_MATERIAL_SLOTS_LIST, state, options, operations, input);
             if (!resolved.ok)
                 return resolved.result;
             const slots = createPrefabMaterialSlots(resolved.asset, resolved.node)
@@ -420,12 +420,12 @@ export function createLocalEditorAgentBridgePrefabSource(state, options, renderU
     };
 }
 function resolvePrefabs(state, options, operations, input) {
-    const assetId = normalizeAgentBridgeString(input.assetId);
-    const browserAssetId = normalizeAgentBridgeString(input.browserAssetId);
-    const name = normalizeAgentBridgeString(input.name).toLowerCase();
-    const query = normalizeAgentBridgeString(input.query).toLowerCase();
+    const assetId = normalizeEditorCommandString(input.assetId);
+    const browserAssetId = normalizeEditorCommandString(input.browserAssetId);
+    const name = normalizeEditorCommandString(input.name).toLowerCase();
+    const query = normalizeEditorCommandString(input.query).toLowerCase();
     const includeUnavailable = 'includeUnavailable' in input && input.includeUnavailable === true;
-    const prefabs = listAgentBridgeVisibleAssetInfos(state, options)
+    const prefabs = listEditorCommandVisibleAssetInfos(state, options)
         .filter(asset => isPrefabAsset(asset))
         .filter(asset => includeUnavailable || asset.placeable !== false)
         .map(createPrefabSummary);
@@ -495,13 +495,13 @@ function readPrefabPrimitive(value) {
     return shape ? { ...structuredClone(record), shape } : null;
 }
 function createPrefabStageUnavailableMessage(assetId) {
-    const normalized = normalizeAgentBridgeString(assetId);
+    const normalized = normalizeEditorCommandString(assetId);
     return normalized
         ? `Prefab stage is not open for asset: ${normalized}`
         : 'Prefab stage is not open.';
 }
 function isRequestedPrefabStage(stage, assetId) {
-    const normalized = normalizeAgentBridgeString(assetId);
+    const normalized = normalizeEditorCommandString(assetId);
     return !normalized || stage.assetId === normalized || stage.browserAssetId === normalized;
 }
 function createSafePrefabSceneOutput(capabilityId, details, operations) {
@@ -509,7 +509,7 @@ function createSafePrefabSceneOutput(capabilityId, details, operations) {
     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.', {
+        return createLocalEditorCommandFailure(capabilityId, 'Prefab Hierarchy scope is unavailable or does not match the active Prefab Stage.', {
             code: 'prefab.hierarchyScopeUnavailable',
             details: {
                 assetId: details.stage.assetId,
@@ -521,7 +521,7 @@ function createSafePrefabSceneOutput(capabilityId, details, operations) {
             },
         });
     }
-    return createPrefabSceneOutput(details, createAgentBridgeSafePrefabReadModel(model, details.nodeDetails));
+    return createPrefabSceneOutput(details, createEditorCommandSafePrefabReadModel(model, details.nodeDetails));
 }
 function createPrefabSceneOutput(details, safeModel) {
     const pathByNodeId = new Map();
@@ -606,7 +606,7 @@ function normalizePrefabNodeRole(role) {
     return role === 'object' ? 'model' : null;
 }
 function normalizePrefabNodeId(value) {
-    const id = normalizeAgentBridgeString(value);
+    const id = normalizeEditorCommandString(value);
     return id.startsWith(PREFAB_STAGE_ITEM_PREFIX) ? id.slice(PREFAB_STAGE_ITEM_PREFIX.length) : id;
 }
 function normalizePrefabEditableName(value) {
@@ -664,8 +664,8 @@ function validatePrefabMarkerTargetInput(scene, target, markerNodeId) {
     return null;
 }
 function createPrefabNodeCreateActionValue(input) {
-    const name = normalizeAgentBridgeString(input.name);
-    const sourceNodePath = normalizeAgentBridgeString(input.sourceNodePath);
+    const name = normalizeEditorCommandString(input.name);
+    const sourceNodePath = normalizeEditorCommandString(input.sourceNodePath);
     const transform = input.position || input.rotation || input.scale
         ? createPrefabTransformActionValue(input)
         : undefined;
@@ -689,21 +689,21 @@ function readPrefabItemTransform(value) {
     if (Object.keys(record).length === 0)
         return undefined;
     const transform = {
-        ...(isLocalEditorAgentBridgeVec3(record.position) ? { position: clonePrefabVec3(record.position) } : {}),
-        ...(isLocalEditorAgentBridgeVec3(record.rotation) ? { rotation: clonePrefabVec3(record.rotation) } : {}),
-        ...(isLocalEditorAgentBridgeVec3(record.scale) ? { scale: clonePrefabVec3(record.scale) } : {}),
+        ...(isLocalEditorCommandVec3(record.position) ? { position: clonePrefabVec3(record.position) } : {}),
+        ...(isLocalEditorCommandVec3(record.rotation) ? { rotation: clonePrefabVec3(record.rotation) } : {}),
+        ...(isLocalEditorCommandVec3(record.scale) ? { scale: clonePrefabVec3(record.scale) } : {}),
     };
     return Object.keys(transform).length > 0 ? transform : undefined;
 }
 function clonePrefabVec3(value) {
-    return isLocalEditorAgentBridgeVec3(value) ? { x: value.x, y: value.y, z: value.z } : { ...ZERO_VEC3 };
+    return isLocalEditorCommandVec3(value) ? { x: value.x, y: value.y, z: value.z } : { ...ZERO_VEC3 };
 }
 function runNodeIdMutation(input) {
     const nodeId = normalizePrefabNodeId(input.nodeId);
     const parentNodeId = normalizePrefabNodeId(input.parentNodeId);
     const details = input.operations.getPrefabStageDetails();
     if (!details || !nodeId || (input.actionId === 'prefab.node.reparent' && !parentNodeId)) {
-        return createLocalEditorAgentBridgeFailure(input.capabilityId, !details ? 'Prefab stage is not open.' : 'Prefab node id is required.', {
+        return createLocalEditorCommandFailure(input.capabilityId, !details ? 'Prefab stage is not open.' : 'Prefab node id is required.', {
             code: !details ? 'prefab.stageNotOpen' : 'prefab.invalidInput',
             details: { nodeId: input.nodeId, parentNodeId: input.parentNodeId },
         });
@@ -713,26 +713,26 @@ function runNodeIdMutation(input) {
         return beforeScene;
     const node = beforeScene.nodes.find(candidate => candidate.nodeId === nodeId) ?? null;
     if (!node) {
-        return createLocalEditorAgentBridgeFailure(input.capabilityId, `Prefab node not found: ${nodeId}`, { code: 'prefab.nodeNotFound', details: { assetId: details.stage.assetId, nodeId } });
+        return createLocalEditorCommandFailure(input.capabilityId, `Prefab node not found: ${nodeId}`, { code: 'prefab.nodeNotFound', details: { assetId: details.stage.assetId, nodeId } });
     }
     if (input.actionId === 'prefab.node.delete' && nodeId === beforeScene.rootNodeId) {
-        return createLocalEditorAgentBridgeFailure(input.capabilityId, 'Prefab root node cannot be deleted.', { code: 'prefab.rootNodeProtected', details: { assetId: details.stage.assetId, nodeId } });
+        return createLocalEditorCommandFailure(input.capabilityId, 'Prefab root node cannot be deleted.', { code: 'prefab.rootNodeProtected', details: { assetId: details.stage.assetId, nodeId } });
     }
     let renameName = null;
     let previousName = null;
     if (input.actionId === 'prefab.node.rename') {
         if (nodeId === beforeScene.rootNodeId) {
-            return createLocalEditorAgentBridgeFailure(input.capabilityId, 'Prefab root node name follows the prefab asset displayName; use prefab.asset.rename instead.', { code: 'prefab.rootRenameUseAssetRename', details: { assetId: details.stage.assetId, nodeId } });
+            return createLocalEditorCommandFailure(input.capabilityId, 'Prefab root node name follows the prefab asset displayName; use prefab.asset.rename instead.', { code: 'prefab.rootRenameUseAssetRename', details: { assetId: details.stage.assetId, nodeId } });
         }
         const nameResult = normalizePrefabEditableName(input.value);
         if (!nameResult.ok) {
-            return createLocalEditorAgentBridgeFailure(input.capabilityId, nameResult.message, { code: 'prefab.invalidName', details: { assetId: details.stage.assetId, nodeId, name: String(input.value ?? '') } });
+            return createLocalEditorCommandFailure(input.capabilityId, nameResult.message, { code: 'prefab.invalidName', details: { assetId: details.stage.assetId, nodeId, name: String(input.value ?? '') } });
         }
         const conflict = beforeScene.nodes.find(candidate => candidate.nodeId !== nodeId
             && candidate.parentNodeId === node.parentNodeId
             && candidate.name?.trim().toLowerCase() === nameResult.name.toLowerCase());
         if (conflict) {
-            return createLocalEditorAgentBridgeFailure(input.capabilityId, `Prefab node name already exists under the same parent: ${nameResult.name}`, {
+            return createLocalEditorCommandFailure(input.capabilityId, `Prefab node name already exists under the same parent: ${nameResult.name}`, {
                 code: 'prefab.nodeNameConflict',
                 details: { assetId: details.stage.assetId, nodeId, conflictingNodeId: conflict.nodeId, name: nameResult.name },
             });
@@ -781,7 +781,7 @@ function runPrefabNodeMutation(input) {
     const previousSelectedItemId = input.beforeScene.stage.selectedItemId ?? null;
     const patched = input.operations.runPrefabStageAssetAction(input.action);
     if (!patched) {
-        return createLocalEditorAgentBridgeFailure(input.capabilityId, `Prefab action unavailable: ${input.action.actionId}`, {
+        return createLocalEditorCommandFailure(input.capabilityId, `Prefab action unavailable: ${input.action.actionId}`, {
             code: 'prefab.actionUnavailable',
             details: {
                 actionId: input.action.actionId,
@@ -795,7 +795,7 @@ function runPrefabNodeMutation(input) {
     input.renderUi();
     const afterDetails = input.operations.getPrefabStageDetails();
     if (!afterDetails) {
-        return createLocalEditorAgentBridgeFailure(input.capabilityId, 'Prefab mutation completed, but Prefab stage is no longer open.', { code: 'prefab.stageClosed' });
+        return createLocalEditorCommandFailure(input.capabilityId, 'Prefab mutation completed, but Prefab stage is no longer open.', { code: 'prefab.stageClosed' });
     }
     const afterScene = createSafePrefabSceneOutput(input.capabilityId, afterDetails, input.operations);
     if ('ok' in afterScene)
@@ -832,7 +832,7 @@ function resolvePrefabAssetForInspection(capabilityId, state, options, operation
     if (!details) {
         return {
             ok: false,
-            result: createLocalEditorAgentBridgeFailure(capabilityId, 'Prefab stage is not open.', { code: 'prefab.stageNotOpen' }),
+            result: createLocalEditorCommandFailure(capabilityId, 'Prefab stage is not open.', { code: 'prefab.stageNotOpen' }),
         };
     }
     const scene = createSafePrefabSceneOutput(capabilityId, details, operations);
@@ -840,15 +840,15 @@ function resolvePrefabAssetForInspection(capabilityId, state, options, operation
         return { ok: false, result: scene };
     const nodeId = normalizePrefabNodeId(input.nodeId) || scene.selectedNodeId || '';
     const node = nodeId ? scene.nodes.find(candidate => candidate.nodeId === nodeId) ?? null : null;
-    const assetId = normalizeAgentBridgeString(input.assetId)
+    const assetId = normalizeEditorCommandString(input.assetId)
         || node?.sourceAssetId
         || node?.childPrefabId
         || '';
-    const asset = assetId ? findAgentBridgeVisibleAssetInfo(state, options, assetId) : null;
+    const asset = assetId ? findEditorCommandVisibleAssetInfo(state, options, assetId) : null;
     if (!asset) {
         return {
             ok: false,
-            result: createLocalEditorAgentBridgeFailure(capabilityId, `Prefab source asset not found: ${assetId || '(empty)'}`, { code: 'asset.notFound', details: { assetId, nodeId: node?.nodeId } }),
+            result: createLocalEditorCommandFailure(capabilityId, `Prefab source asset not found: ${assetId || '(empty)'}`, { code: 'asset.notFound', details: { assetId, nodeId: node?.nodeId } }),
         };
     }
     return {