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

package/dist/editor-commands/capabilities/selection.js

@@ -0,0 +1,60 @@
+import { EDITOR_COMMAND_ID, } from '@fps-games/editor-protocol';
+import { createLocalEditorCommandFailure } from '../diagnostics.js';
+import { cloneEditorCommandSelection, getEditorCommandSafeSceneHierarchy, getEditorCommandSafeSceneSelection, hasEditorCommandSafeSceneScope, isEditorCommandHierarchyObjectSelectable, } from '../shared.js';
+export function createLocalEditorCommandSelectionSource(state, options, operations) {
+    return {
+        getSelection() {
+            return cloneEditorCommandSelection(getEditorCommandSafeSceneSelection(operations));
+        },
+        setSelection(input) {
+            if (!hasEditorCommandSafeSceneScope(operations)) {
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.SELECTION_SET, 'Scene selection is unavailable outside the Scene Hierarchy scope.', { code: 'selection.sceneScopeRequired' });
+            }
+            const objectIds = normalizeEditorCommandSelectionInput(input);
+            if (!objectIds) {
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.SELECTION_SET, 'selection.set requires objectId or objectIds.', { code: 'selection.invalidInput' });
+            }
+            const activeId = input.activeId && objectIds.includes(input.activeId)
+                ? input.activeId
+                : objectIds[objectIds.length - 1] ?? null;
+            if (objectIds.length > 0) {
+                const document = state.session?.getState({ cloneDocuments: false }).workingDocument ?? null;
+                const hierarchy = document ? getEditorCommandSafeSceneHierarchy(operations) : [];
+                const invalidId = objectIds.find(id => !document || !isEditorCommandHierarchyObjectSelectable(options, document, id, hierarchy));
+                if (invalidId) {
+                    return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.SELECTION_SET, `Object is not selectable: ${invalidId}`, { code: 'selection.notSelectable', objectId: invalidId });
+                }
+            }
+            const command = objectIds.length > 0
+                ? {
+                    type: 'selection.replace',
+                    selectedIds: objectIds,
+                    activeId,
+                    label: 'Agent Selection',
+                }
+                : { type: 'selection.clear', label: 'Agent Selection' };
+            operations.dispatchSelectionCommand(command, true);
+            return {
+                selection: cloneEditorCommandSelection(getEditorCommandSafeSceneSelection(operations)),
+            };
+        },
+    };
+}
+function normalizeEditorCommandSelectionInput(input) {
+    const ids = Array.isArray(input.objectIds) ? input.objectIds : input.objectId ? [input.objectId] : null;
+    if (!ids)
+        return null;
+    const normalized = [];
+    const seen = new Set();
+    for (const id of ids) {
+        if (typeof id !== 'string')
+            continue;
+        const trimmed = id.trim();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        normalized.push(trimmed);
+    }
+    return normalized;
+}
+//# sourceMappingURL=selection.js.map

package/dist/editor-commands/capabilities/selection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection.js","sourceRoot":"","sources":["../../../src/editor-commands/capabilities/selection.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  EDITOR_COMMAND_ID,\n  type EditorCommandSelectionSetInput,\n} from '@fps-games/editor-protocol';\nimport type { SelectionCommand } from '@fps-games/editor-core';\nimport { createLocalEditorCommandFailure } from '../diagnostics.js';\nimport type { LocalEditorCommandSelectionSource } from '../source-types.js';\nimport {\n  cloneEditorCommandSelection,\n  getEditorCommandSafeSceneHierarchy,\n  getEditorCommandSafeSceneSelection,\n  hasEditorCommandSafeSceneScope,\n  isEditorCommandHierarchyObjectSelectable,\n  type LocalEditorCommandCapabilitySourceOperations,\n  type LocalEditorCommandHarnessState,\n} from '../shared.js';\nimport type { LocalEditorHarnessOptions } from '../../local-editor-harness.js';\n\nexport function createLocalEditorCommandSelectionSource<TDocument, TPatch, TAsset>(\n  state: LocalEditorCommandHarnessState<TDocument, TPatch>,\n  options: LocalEditorHarnessOptions<TDocument, TPatch, TAsset>,\n  operations: LocalEditorCommandCapabilitySourceOperations<TDocument>,\n): LocalEditorCommandSelectionSource {\n  return {\n    getSelection() {\n      return cloneEditorCommandSelection(getEditorCommandSafeSceneSelection(operations));\n    },\n    setSelection(input) {\n      if (!hasEditorCommandSafeSceneScope(operations)) {\n        return createLocalEditorCommandFailure(\n          EDITOR_COMMAND_ID.SELECTION_SET,\n          'Scene selection is unavailable outside the Scene Hierarchy scope.',\n          { code: 'selection.sceneScopeRequired' },\n        );\n      }\n      const objectIds = normalizeEditorCommandSelectionInput(input);\n      if (!objectIds) {\n        return createLocalEditorCommandFailure(\n          EDITOR_COMMAND_ID.SELECTION_SET,\n          'selection.set requires objectId or objectIds.',\n          { code: 'selection.invalidInput' },\n        );\n      }\n      const activeId = input.activeId && objectIds.includes(input.activeId)\n        ? input.activeId\n        : objectIds[objectIds.length - 1] ?? null;\n      if (objectIds.length > 0) {\n        const document = state.session?.getState({ cloneDocuments: false }).workingDocument ?? null;\n        const hierarchy = document ? getEditorCommandSafeSceneHierarchy(operations) : [];\n        const invalidId = objectIds.find(\n          id => !document || !isEditorCommandHierarchyObjectSelectable(options, document, id, hierarchy),\n        );\n        if (invalidId) {\n          return createLocalEditorCommandFailure(\n            EDITOR_COMMAND_ID.SELECTION_SET,\n            `Object is not selectable: ${invalidId}`,\n            { code: 'selection.notSelectable', objectId: invalidId },\n          );\n        }\n      }\n      const command: SelectionCommand = objectIds.length > 0\n        ? {\n            type: 'selection.replace',\n            selectedIds: objectIds,\n            activeId,\n            label: 'Agent Selection',\n          }\n        : { type: 'selection.clear', label: 'Agent Selection' };\n      operations.dispatchSelectionCommand(command, true);\n      return {\n        selection: cloneEditorCommandSelection(getEditorCommandSafeSceneSelection(operations)),\n      };\n    },\n  };\n}\n\nfunction normalizeEditorCommandSelectionInput(input: EditorCommandSelectionSetInput): string[] | null {\n  const ids = Array.isArray(input.objectIds) ? input.objectIds : input.objectId ? [input.objectId] : null;\n  if (!ids) return null;\n  const normalized: string[] = [];\n  const seen = new Set<string>();\n  for (const id of ids) {\n    if (typeof id !== 'string') continue;\n    const trimmed = id.trim();\n    if (!trimmed || seen.has(trimmed)) continue;\n    seen.add(trimmed);\n    normalized.push(trimmed);\n  }\n  return normalized;\n}\n"]}

package/dist/editor-commands/capabilities/shadows.d.ts

@@ -0,0 +1,5 @@
+import type { LocalEditorCommandShadowSource } from '../source-types.js';
+import { type LocalEditorCommandCapabilitySourceOperations, type LocalEditorCommandHarnessState } from '../shared.js';
+import type { LocalEditorHarnessOptions } from '../../local-editor-harness.js';
+export declare function createLocalEditorCommandShadowSource<TDocument, TPatch, TAsset>(state: LocalEditorCommandHarnessState<TDocument, TPatch>, options: LocalEditorHarnessOptions<TDocument, TPatch, TAsset>, renderUi: () => void, operations: LocalEditorCommandCapabilitySourceOperations<TDocument>): LocalEditorCommandShadowSource;
+//# sourceMappingURL=shadows.d.ts.map

package/dist/editor-commands/capabilities/shadows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadows.d.ts","sourceRoot":"","sources":["../../../src/editor-commands/capabilities/shadows.ts"],"names":[],"mappings":"AAgFA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,EAOL,KAAK,4CAA4C,EACjD,KAAK,8BAA8B,EAKpC,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAwF/E,wBAAgB,oCAAoC,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAC5E,KAAK,EAAE,8BAA8B,CAAC,SAAS,EAAE,MAAM,CAAC,EACxD,OAAO,EAAE,yBAAyB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAC7D,QAAQ,EAAE,MAAM,IAAI,EACpB,UAAU,EAAE,4CAA4C,CAAC,SAAS,CAAC,GAClE,8BAA8B,CA2fhC"}

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

@@ -1,8 +1,8 @@
 import { collectEditorShadowReceiverCandidates, detectEditorSceneDirectionalLightOrientationDrift, findEditorSceneModelRenderer, findEditorScenePrefabAsset, findEditorScenePrefabNode, findEditorSceneTransform, normalizeEditorSceneLightDirectionVector, readEditorScenePrefabNodes, readEditorScenePrefabRootNodeId, resolveEditorSceneGameObjectShadowSettings, resolveEditorSceneGameObjectRuntimeEntityIds, resolveEditorScenePrefabInstanceRelation, resolveEditorShadowPlan, } from '@fps-games/editor-playable-sdk';
 import { assertEditorShadowSettingsContract, assertShadowMapExperimentConfig, createShadowMapExperimentPlanSnapshot, createShadowMapExperimentPlanFingerprint, mergeEditorShadowSettings, readEditorShadowSettings, resolveEditorShadowParams, } from '@fps-games/playable-rendering';
-import { EDITOR_AGENT_BRIDGE_CAPABILITY_ID, } from '@fps-games/editor-protocol';
-import { createLocalEditorAgentBridgeFailure, editorTransformSnapshotToAgentTransform, } from '../diagnostics.js';
-import { createAgentBridgeSafePrefabReadModel, getAgentBridgeSafeSceneSelection, hasAgentBridgeSafeSceneScope, isAgentBridgeSafeSceneObjectId, normalizeAgentBridgeIdList, normalizeAgentBridgeString, } from '../shared.js';
+import { EDITOR_COMMAND_ID, } from '@fps-games/editor-protocol';
+import { createLocalEditorCommandFailure, editorTransformSnapshotToAgentTransform, } from '../diagnostics.js';
+import { createEditorCommandSafePrefabReadModel, getEditorCommandSafeSceneSelection, hasEditorCommandSafeSceneScope, isEditorCommandSafeSceneObjectId, normalizeEditorCommandIdList, normalizeEditorCommandString, } from '../shared.js';
 const SHADOW_POLICY_FIELDS = [
     'shadow.cast',
     'shadow.receive',
@@ -20,35 +20,35 @@ const SHADOW_POLICY_FIELDS = [
     'shadow.params.bakeSamples',
     'shadow.params.blurKernel',
 ];
-export function createLocalEditorAgentBridgeShadowSource(state, options, renderUi, operations) {
+export function createLocalEditorCommandShadowSource(state, options, renderUi, operations) {
     return {
         getShadowMapExperimentConfig() {
-            const config = readShadowMapExperimentConfig(options, EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_CONFIG_GET);
+            const config = readShadowMapExperimentConfig(options, EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_CONFIG_GET);
             if (!config.ok)
                 return config.result;
             return createShadowMapExperimentConfigOutput(config.config);
         },
         getShadowMapExperimentPolicy(input) {
-            const config = readShadowMapExperimentConfig(options, EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_POLICY_GET);
+            const config = readShadowMapExperimentConfig(options, EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_POLICY_GET);
             if (!config.ok)
                 return config.result;
-            const resolved = resolveShadowMapExperimentTarget(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_POLICY_GET, state, input, operations);
+            const resolved = resolveShadowMapExperimentTarget(EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_POLICY_GET, state, input, operations);
             if (!resolved.ok)
                 return resolved.result;
             return createShadowMapExperimentPolicyOutput(resolved.target, config.config, readShadowMapExperimentPlan(options, resolved.target.rawDocument));
         },
         setShadowMapExperimentPolicy(input) {
-            const config = readShadowMapExperimentConfig(options, EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_POLICY_SET);
+            const config = readShadowMapExperimentConfig(options, EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_POLICY_SET);
             if (!config.ok)
                 return config.result;
             if (!config.config) {
-                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_POLICY_SET, 'Shadow Map experiment config is not available.', { code: 'shadowMapExperiment.configMissing' });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_POLICY_SET, 'Shadow Map experiment config is not available.', { code: 'shadowMapExperiment.configMissing' });
             }
             const validation = validateShadowMapExperimentPolicySetInput(input, config.config);
             if (!validation.ok) {
-                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_POLICY_SET, validation.message, { code: 'shadowMapExperiment.invalidInput', details: { scope: input.scope } });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_POLICY_SET, validation.message, { code: 'shadowMapExperiment.invalidInput', details: { scope: input.scope } });
             }
-            const resolved = resolveShadowMapExperimentTarget(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_POLICY_SET, state, input, operations);
+            const resolved = resolveShadowMapExperimentTarget(EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_POLICY_SET, state, input, operations);
             if (!resolved.ok)
                 return resolved.result;
             return setShadowMapExperimentPolicy(state, options, renderUi, operations, resolved.target, input, config.config);
@@ -56,7 +56,7 @@ export function createLocalEditorAgentBridgeShadowSource(state, options, renderU
         previewShadowMapExperimentPlan() {
             const rawDocument = state.session?.getState({ cloneDocuments: false }).workingDocument;
             if (state.mode !== 'editor' || !rawDocument) {
-                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_PLAN_PREVIEW, 'Editor is not in edit mode.', { code: 'editor.notReady' });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_PLAN_PREVIEW, 'Editor is not in edit mode.', { code: 'editor.notReady' });
             }
             const plan = readShadowMapExperimentPlan(options, rawDocument);
             return { plan: plan ? structuredClone(plan) : null };
@@ -64,7 +64,7 @@ export function createLocalEditorAgentBridgeShadowSource(state, options, renderU
         snapshotShadowMapExperimentRuntime() {
             const rawDocument = state.session?.getState({ cloneDocuments: false }).workingDocument;
             if (state.mode !== 'editor' || !rawDocument) {
-                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_RUNTIME_SNAPSHOT, 'Editor is not in edit mode.', { code: 'editor.notReady' });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_RUNTIME_SNAPSHOT, 'Editor is not in edit mode.', { code: 'editor.notReady' });
             }
             const evidence = operations.getShadowPreviewDebugInfo?.()?.shadowMapExperiment ?? null;
             const sourcePlan = readShadowMapExperimentPlan(options, rawDocument);
@@ -87,7 +87,7 @@ export function createLocalEditorAgentBridgeShadowSource(state, options, renderU
             };
         },
         getPolicy(input) {
-            const resolved = resolveShadowTarget(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_POLICY_GET, state, input, operations);
+            const resolved = resolveShadowTarget(EDITOR_COMMAND_ID.SHADOW_POLICY_GET, state, input, operations);
             if (!resolved.ok)
                 return resolved.result;
             return createShadowPolicyGetOutput(resolved.target, resolveCanonicalShadowMapExperimentPlan(options, resolved.target, operations));
@@ -95,9 +95,9 @@ export function createLocalEditorAgentBridgeShadowSource(state, options, renderU
         setPolicy(input) {
             const policy = normalizeShadowPolicy(input.policy);
             if (!policy.ok) {
-                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_POLICY_SET, policy.message, { code: 'shadow.invalidInput', details: { hasPolicy: input.policy != null } });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.SHADOW_POLICY_SET, policy.message, { code: 'shadow.invalidInput', details: { hasPolicy: input.policy != null } });
             }
-            const resolved = resolveShadowTarget(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_POLICY_SET, state, input, operations);
+            const resolved = resolveShadowTarget(EDITOR_COMMAND_ID.SHADOW_POLICY_SET, state, input, operations);
             if (!resolved.ok)
                 return resolved.result;
             if (resolved.target.kind === 'scene') {
@@ -106,7 +106,7 @@ export function createLocalEditorAgentBridgeShadowSource(state, options, renderU
             return setPrefabStageShadowPolicy(renderUi, operations, resolved.target, policy.settings);
         },
         listReceivers(input) {
-            const resolved = resolveShadowTarget(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_RECEIVERS_LIST, state, input, operations);
+            const resolved = resolveShadowTarget(EDITOR_COMMAND_ID.SHADOW_RECEIVERS_LIST, state, input, operations);
             if (!resolved.ok)
                 return resolved.result;
             const casterId = getResolvedTargetCasterId(resolved.target);
@@ -127,12 +127,12 @@ export function createLocalEditorAgentBridgeShadowSource(state, options, renderU
         resolvePreview(input) {
             const policy = input.policy === undefined ? { ok: true, settings: undefined } : normalizeShadowPolicy(input.policy);
             if (!policy.ok) {
-                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_RESOLVE_PREVIEW, policy.message, { code: 'shadow.invalidInput', details: { hasPolicy: input.policy != null } });
+                return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.SHADOW_RESOLVE_PREVIEW, policy.message, { code: 'shadow.invalidInput', details: { hasPolicy: input.policy != null } });
             }
-            const resolved = resolveShadowTarget(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_RESOLVE_PREVIEW, state, input, operations);
+            const resolved = resolveShadowTarget(EDITOR_COMMAND_ID.SHADOW_RESOLVE_PREVIEW, state, input, operations);
             if (!resolved.ok)
                 return resolved.result;
-            const receiverIds = normalizeAgentBridgeIdList(input.receiverIds ?? []);
+            const receiverIds = normalizeEditorCommandIdList(input.receiverIds ?? []);
             const casterId = getResolvedTargetCasterId(resolved.target);
             const planInput = {
                 document: resolved.target.document,
@@ -179,7 +179,7 @@ export function createLocalEditorAgentBridgeShadowSource(state, options, renderU
             };
         },
         inspectDebug(input) {
-            const resolved = resolveShadowTarget(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_INSPECT, state, input, operations);
+            const resolved = resolveShadowTarget(EDITOR_COMMAND_ID.SHADOW_DEBUG_INSPECT, state, input, operations);
             if (!resolved.ok)
                 return resolved.result;
             return createShadowDebugInspectOutput(resolved.target, state, {
@@ -190,7 +190,7 @@ export function createLocalEditorAgentBridgeShadowSource(state, options, renderU
             });
         },
         enterDebugContext(input) {
-            const resolved = resolveShadowTarget(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_CONTEXT_ENTER, state, input, operations);
+            const resolved = resolveShadowTarget(EDITOR_COMMAND_ID.SHADOW_DEBUG_CONTEXT_ENTER, state, input, operations);
             if (!resolved.ok)
                 return resolved.result;
             return enterShadowDebugContext(state, renderUi, operations, resolved.target, input, resolveCanonicalShadowMapExperimentPlan(options, resolved.target, operations));
@@ -199,7 +199,7 @@ export function createLocalEditorAgentBridgeShadowSource(state, options, renderU
             return clearShadowDebugContext(state, renderUi, operations);
         },
         setDebugOverlay(input) {
-            const resolved = resolveShadowTarget(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_OVERLAY_SET, state, input, operations);
+            const resolved = resolveShadowTarget(EDITOR_COMMAND_ID.SHADOW_DEBUG_OVERLAY_SET, state, input, operations);
             if (!resolved.ok)
                 return resolved.result;
             const inspect = createShadowDebugInspectOutput(resolved.target, state, {
@@ -241,7 +241,7 @@ export function createLocalEditorAgentBridgeShadowSource(state, options, renderU
             };
         },
         measureVisibility(input) {
-            const resolved = resolveShadowTarget(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_VISIBILITY_MEASURE, state, input, operations);
+            const resolved = resolveShadowTarget(EDITOR_COMMAND_ID.SHADOW_DEBUG_VISIBILITY_MEASURE, state, input, operations);
             if (!resolved.ok)
                 return resolved.result;
             const inspect = createShadowDebugInspectOutput(resolved.target, state, {
@@ -253,10 +253,10 @@ export function createLocalEditorAgentBridgeShadowSource(state, options, renderU
             return createShadowDebugVisibilityMeasureOutput(inspect, input);
         },
         async bakeStatic(input) {
-            const resolved = resolveShadowTarget(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_STATIC_BAKE, state, input, operations);
+            const resolved = resolveShadowTarget(EDITOR_COMMAND_ID.SHADOW_STATIC_BAKE, state, input, operations);
             if (!resolved.ok)
                 return resolved.result;
-            const receiverIds = normalizeAgentBridgeIdList(input.receiverIds ?? []);
+            const receiverIds = normalizeEditorCommandIdList(input.receiverIds ?? []);
             const casterId = getResolvedTargetCasterId(resolved.target);
             const quality = input.quality && input.quality !== 'inherit' ? input.quality : undefined;
             const effectivePolicy = getResolvedTargetShadowPolicy(resolved.target);
@@ -324,7 +324,7 @@ export function createLocalEditorAgentBridgeShadowSource(state, options, renderU
             };
         },
         invalidateStatic(input) {
-            const resolved = resolveShadowTarget(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_STATIC_INVALIDATE, state, input, operations);
+            const resolved = resolveShadowTarget(EDITOR_COMMAND_ID.SHADOW_STATIC_INVALIDATE, state, input, operations);
             if (!resolved.ok)
                 return resolved.result;
             const targetDiagnostics = createShadowTargetDiagnostics(resolved.target);
@@ -413,7 +413,7 @@ function readShadowMapExperimentConfig(options, capabilityId) {
     catch (error) {
         return {
             ok: false,
-            result: createLocalEditorAgentBridgeFailure(capabilityId, error instanceof Error ? error.message : String(error), { code: 'shadowMapExperiment.invalidConfig' }),
+            result: createLocalEditorCommandFailure(capabilityId, error instanceof Error ? error.message : String(error), { code: 'shadowMapExperiment.invalidConfig' }),
         };
     }
 }
@@ -624,7 +624,7 @@ function resolveShadowMapExperimentTarget(capabilityId, state, input, operations
     if (state.mode !== 'editor' || !state.session) {
         return {
             ok: false,
-            result: createLocalEditorAgentBridgeFailure(capabilityId, 'Editor is not in edit mode.', { code: 'editor.notReady' }),
+            result: createLocalEditorCommandFailure(capabilityId, 'Editor is not in edit mode.', { code: 'editor.notReady' }),
         };
     }
     const sessionState = state.session.getState({ cloneDocuments: false });
@@ -632,16 +632,16 @@ function resolveShadowMapExperimentTarget(capabilityId, state, input, operations
     if (!document) {
         return {
             ok: false,
-            result: createLocalEditorAgentBridgeFailure(capabilityId, 'Shadow Map profiles require an editor scene document.', {
+            result: createLocalEditorCommandFailure(capabilityId, 'Shadow Map profiles require an editor scene document.', {
                 code: 'shadowMapExperiment.unsupportedDocument',
             }),
         };
     }
     if (input.scope === 'scene') {
-        if (!hasAgentBridgeSafeSceneScope(operations)) {
+        if (!hasEditorCommandSafeSceneScope(operations)) {
             return {
                 ok: false,
-                result: createLocalEditorAgentBridgeFailure(capabilityId, 'Scene Shadow Map profiles require the active Scene Hierarchy scope.', {
+                result: createLocalEditorCommandFailure(capabilityId, 'Scene Shadow Map profiles require the active Scene Hierarchy scope.', {
                     code: 'shadowMapExperiment.scopeMismatch',
                 }),
             };
@@ -657,14 +657,14 @@ function resolveShadowMapExperimentTarget(capabilityId, state, input, operations
         };
     }
     if (input.scope === 'object') {
-        const objectId = normalizeAgentBridgeString(input.objectId);
-        const gameObject = objectId && isAgentBridgeSafeSceneObjectId(operations, objectId)
+        const objectId = normalizeEditorCommandString(input.objectId);
+        const gameObject = objectId && isEditorCommandSafeSceneObjectId(operations, objectId)
             ? findShadowGameObject(document, objectId)
             : null;
         if (!gameObject) {
             return {
                 ok: false,
-                result: createLocalEditorAgentBridgeFailure(capabilityId, objectId
+                result: createLocalEditorCommandFailure(capabilityId, objectId
                     ? `Shadow Map target object not found: ${objectId}`
                     : 'objectId is required for object scope.', {
                     code: objectId ? 'shadowMapExperiment.targetNotFound' : 'shadowMapExperiment.targetRequired',
@@ -687,7 +687,7 @@ function resolveShadowMapExperimentTarget(capabilityId, state, input, operations
     if (input.scope !== 'prefab-node') {
         return {
             ok: false,
-            result: createLocalEditorAgentBridgeFailure(capabilityId, `Unsupported Shadow Map target scope: ${String(input.scope)}`, {
+            result: createLocalEditorCommandFailure(capabilityId, `Unsupported Shadow Map target scope: ${String(input.scope)}`, {
                 code: 'shadowMapExperiment.invalidScope',
             }),
         };
@@ -696,16 +696,16 @@ function resolveShadowMapExperimentTarget(capabilityId, state, input, operations
     if (!details) {
         return {
             ok: false,
-            result: createLocalEditorAgentBridgeFailure(capabilityId, 'Open the target Prefab stage before editing a prefab-node profile.', {
+            result: createLocalEditorCommandFailure(capabilityId, 'Open the target Prefab stage before editing a prefab-node profile.', {
                 code: 'prefab.stageNotOpen',
             }),
         };
     }
-    const requestedAssetId = normalizeAgentBridgeString(input.prefabAssetId);
+    const requestedAssetId = normalizeEditorCommandString(input.prefabAssetId);
     if (requestedAssetId && requestedAssetId !== details.stage.assetId && requestedAssetId !== details.stage.browserAssetId) {
         return {
             ok: false,
-            result: createLocalEditorAgentBridgeFailure(capabilityId, `Open Prefab stage does not match ${requestedAssetId}.`, {
+            result: createLocalEditorCommandFailure(capabilityId, `Open Prefab stage does not match ${requestedAssetId}.`, {
                 code: 'prefab.stageAssetMismatch',
                 details: { requestedAssetId, openAssetId: details.stage.assetId },
             }),
@@ -714,7 +714,7 @@ function resolveShadowMapExperimentTarget(capabilityId, state, input, operations
     if (!hasActivePrefabHierarchyScope(operations, details)) {
         return {
             ok: false,
-            result: createLocalEditorAgentBridgeFailure(capabilityId, 'Open Prefab stage does not own the active Hierarchy authority.', {
+            result: createLocalEditorCommandFailure(capabilityId, 'Open Prefab stage does not own the active Hierarchy authority.', {
                 code: 'shadowMapExperiment.scopeMismatch',
                 details: { prefabAssetId: details.stage.assetId },
             }),
@@ -722,13 +722,13 @@ function resolveShadowMapExperimentTarget(capabilityId, state, input, operations
     }
     const prefabAsset = findEditorScenePrefabAsset(document, details.stage.assetId);
     const rootNodeId = readEditorScenePrefabRootNodeId(prefabAsset);
-    const safeModel = createAgentBridgeSafePrefabReadModel(operations.getHierarchyReadModel(), details.nodeDetails);
+    const safeModel = createEditorCommandSafePrefabReadModel(operations.getHierarchyReadModel(), details.nodeDetails);
     const nodeId = resolveSafePrefabNodeAuthoredId(safeModel, normalizePrefabNodeId(input.nodeId));
     const node = prefabAsset && nodeId ? findEditorScenePrefabNode(prefabAsset, nodeId) : null;
     if (!prefabAsset || !rootNodeId || !nodeId || !node) {
         return {
             ok: false,
-            result: createLocalEditorAgentBridgeFailure(capabilityId, `Prefab node not found: ${nodeId ?? '(none)'}`, {
+            result: createLocalEditorCommandFailure(capabilityId, `Prefab node not found: ${nodeId ?? '(none)'}`, {
                 code: 'prefab.nodeNotFound',
                 details: { prefabAssetId: details.stage.assetId, nodeId },
             }),
@@ -875,11 +875,11 @@ function resolveEffectiveShadowMapExperimentBehaviorProfile(resolved, config, pl
 function readAssetShadowMapExperimentBehaviorProfile(asset) {
     if (!isRecord(asset) || !isRecord(asset.defaults) || !isRecord(asset.defaults.shadowMapExperiment))
         return null;
-    return normalizeAgentBridgeString(asset.defaults.shadowMapExperiment.behaviorProfile) || null;
+    return normalizeEditorCommandString(asset.defaults.shadowMapExperiment.behaviorProfile) || null;
 }
 function setShadowMapExperimentPolicy(state, options, renderUi, operations, resolved, input, config) {
     if (!state.session) {
-        return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_POLICY_SET, 'Editor is not in edit mode.', { code: 'editor.notReady' });
+        return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_POLICY_SET, 'Editor is not in edit mode.', { code: 'editor.notReady' });
     }
     const authored = readAuthoredShadowMapExperimentProfiles(resolved);
     const hasQualityProfile = Object.prototype.hasOwnProperty.call(input, 'qualityProfile');
@@ -900,7 +900,7 @@ function setShadowMapExperimentPolicy(state, options, renderUi, operations, reso
             ...(hasBehaviorProfile ? { behaviorProfile: input.behaviorProfile ?? null } : {}),
         });
         if (!patch) {
-            return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_POLICY_SET, 'The project rendering capability does not expose a scene Shadow Map profile patch.', { code: 'shadowMapExperiment.scenePatchUnavailable' });
+            return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_POLICY_SET, 'The project rendering capability does not expose a scene Shadow Map profile patch.', { code: 'shadowMapExperiment.scenePatchUnavailable' });
         }
         const result = state.session.dispatch({
             type: 'document.patch',
@@ -922,7 +922,7 @@ function setShadowMapExperimentPolicy(state, options, renderUi, operations, reso
             source: 'custom',
         });
         if (!patch) {
-            return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_POLICY_SET, `Unable to create Shadow Map profile patch for ${resolved.objectId}.`, { code: 'shadowMapExperiment.objectPatchUnavailable', objectId: resolved.objectId });
+            return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_POLICY_SET, `Unable to create Shadow Map profile patch for ${resolved.objectId}.`, { code: 'shadowMapExperiment.objectPatchUnavailable', objectId: resolved.objectId });
         }
         const result = state.session.dispatch({
             type: 'document.patch',
@@ -941,7 +941,7 @@ function setShadowMapExperimentPolicy(state, options, renderUi, operations, reso
             value: input.behaviorProfile == null ? null : { behaviorProfile: input.behaviorProfile },
         });
         if (!changed) {
-            return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_POLICY_SET, `Shadow Map profile action did not change prefab node: ${resolved.nodeId}`, { code: 'shadowMapExperiment.prefabPatchUnavailable', details: { prefabAssetId: resolved.prefabAssetId, nodeId: resolved.nodeId } });
+            return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_POLICY_SET, `Shadow Map profile action did not change prefab node: ${resolved.nodeId}`, { code: 'shadowMapExperiment.prefabPatchUnavailable', details: { prefabAssetId: resolved.prefabAssetId, nodeId: resolved.nodeId } });
         }
     }
     if (changed) {
@@ -951,7 +951,7 @@ function setShadowMapExperimentPolicy(state, options, renderUi, operations, reso
         operations.refreshShadowPreview?.();
         renderUi();
     }
-    const nextResolved = resolveShadowMapExperimentTarget(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_POLICY_GET, state, resolved.target, operations);
+    const nextResolved = resolveShadowMapExperimentTarget(EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_POLICY_GET, state, resolved.target, operations);
     if (!nextResolved.ok)
         return nextResolved.result;
     return {
@@ -992,7 +992,7 @@ function createShadowDebugInspectOutput(resolved, state, options = {}, extraOpti
     const casterId = getResolvedTargetCasterId(resolved);
     const projectionContext = options.projectionContext ?? createIdentityShadowProjectionContext();
     const effectivePolicy = getResolvedTargetShadowPolicy(resolved);
-    const receiverIds = normalizeAgentBridgeIdList(options.receiverIds ?? []);
+    const receiverIds = normalizeEditorCommandIdList(options.receiverIds ?? []);
     const planInput = {
         document: resolved.document,
         casterId,
@@ -1038,7 +1038,7 @@ function createShadowDebugInspectOutput(resolved, state, options = {}, extraOpti
 }
 function enterShadowDebugContext(state, renderUi, operations, resolved, input, canonicalPlan = null) {
     const projectionContext = createShadowProjectionContext(resolved, operations);
-    const receiverIds = normalizeAgentBridgeIdList(input.receiverIds ?? []);
+    const receiverIds = normalizeEditorCommandIdList(input.receiverIds ?? []);
     const initialInspect = createShadowDebugInspectOutput(resolved, state, {
         receiverIds,
         projectionContext,
@@ -1070,7 +1070,7 @@ function enterShadowDebugContext(state, renderUi, operations, resolved, input, c
     }
     const objectIds = state.projection?.getProjectedNodeIds?.() ?? [...projectionKeepIds];
     if (objectIds.length === 0) {
-        return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_CONTEXT_ENTER, 'Viewport projection is unavailable or has no projected objects for Shadow Debug Context.', { code: 'viewport.projectionUnavailable' });
+        return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.SHADOW_DEBUG_CONTEXT_ENTER, 'Viewport projection is unavailable or has no projected objects for Shadow Debug Context.', { code: 'viewport.projectionUnavailable' });
     }
     const nextOverrides = {};
     for (const objectId of objectIds)
@@ -1086,7 +1086,7 @@ function enterShadowDebugContext(state, renderUi, operations, resolved, input, c
                 id,
                 projectionContext.resolveProjectionId(id),
             ])])];
-    state.previewVisibility.reason = normalizeAgentBridgeString(input.reason)
+    state.previewVisibility.reason = normalizeEditorCommandString(input.reason)
         || `Shadow Debug Context for ${targetId}`;
     state.projection?.clearPreviewVisibilityOverrides?.();
     const entries = state.projection?.setPreviewVisibilityOverrides?.(nextOverrides) ?? [];
@@ -1245,7 +1245,7 @@ function collectShadowDebugAmbientLightIds(document, shadowLightId) {
 function createShadowDebugOverlayItems(inspect, input) {
     const items = [];
     const flags = readShadowDebugOverlayFlags(input);
-    const receiverIds = new Set(normalizeAgentBridgeIdList(input.receiverIds ?? []));
+    const receiverIds = new Set(normalizeEditorCommandIdList(input.receiverIds ?? []));
     const targetId = inspect.caster?.objectId ?? inspect.caster?.nodeId ?? 'target';
     const casterBounds = createOverlayBounds(inspect.caster?.bounds);
     if (flags.showCasterBounds && casterBounds) {
@@ -1322,10 +1322,10 @@ function createShadowDebugVisibilityMeasureOutput(inspect, input) {
             severity: 'info',
             source: 'editor',
             code: 'shadow.pixelReadbackUnavailable',
-            message: 'Pixel readback is not available in this editor bridge session, so shadow visibility is measured structurally from policy, receivers, footprint, and runtime evidence.',
+            message: 'Pixel readback is not available in this renderer attachment, so shadow visibility is measured structurally from policy, receivers, footprint, and runtime evidence.',
         },
     ];
-    const requestedReceiverIds = normalizeAgentBridgeIdList(input.receiverIds ?? []);
+    const requestedReceiverIds = normalizeEditorCommandIdList(input.receiverIds ?? []);
     const renderableCount = inspect.runtimeEvidence.renderableShadowPrimitiveCount ?? 0;
     let visibleScore = 0;
     let coverage = 0;
@@ -1534,7 +1534,7 @@ function createOverlayBoundsFromCenterSize(center, size) {
 }
 function setSceneShadowPolicy(state, options, renderUi, operations, resolved, policy) {
     if (!state.session) {
-        return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_POLICY_SET, 'Editor is not in edit mode.', { code: 'editor.notReady', objectId: resolved.objectId });
+        return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.SHADOW_POLICY_SET, 'Editor is not in edit mode.', { code: 'editor.notReady', objectId: resolved.objectId });
     }
     let changed = false;
     let workingDocument = resolved.rawDocument;
@@ -1579,7 +1579,7 @@ function setSceneShadowPolicy(state, options, renderUi, operations, resolved, po
     const nextDocument = asEditorSceneDocument(workingDocument);
     const nextObject = nextDocument ? findShadowGameObject(nextDocument, resolved.objectId) : null;
     if (!nextDocument || !nextObject) {
-        return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_POLICY_SET, `Shadow target disappeared after patch: ${resolved.objectId}`, { code: 'shadow.targetMissing', objectId: resolved.objectId });
+        return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.SHADOW_POLICY_SET, `Shadow target disappeared after patch: ${resolved.objectId}`, { code: 'shadow.targetMissing', objectId: resolved.objectId });
     }
     const output = createShadowPolicyGetOutput({
         kind: 'scene',
@@ -1608,7 +1608,7 @@ function setPrefabStageShadowPolicy(renderUi, operations, resolved, policy) {
             value: policy ?? null,
         });
     if (!changed) {
-        return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_POLICY_SET, `Shadow policy action did not change prefab node: ${resolved.nodeId}`, { code: 'shadow.policyUnchanged', details: { assetId: resolved.details.stage.assetId, nodeId: resolved.nodeId } });
+        return createLocalEditorCommandFailure(EDITOR_COMMAND_ID.SHADOW_POLICY_SET, `Shadow policy action did not change prefab node: ${resolved.nodeId}`, { code: 'shadow.policyUnchanged', details: { assetId: resolved.details.stage.assetId, nodeId: resolved.nodeId } });
     }
     renderUi();
     const nextDetails = operations.getPrefabStageDetails() ?? resolved.details;
@@ -1659,26 +1659,26 @@ function resolveShadowTarget(capabilityId, state, input, operations) {
     if (state.mode !== 'editor' || !state.session) {
         return {
             ok: false,
-            result: createLocalEditorAgentBridgeFailure(capabilityId, 'Editor is not in edit mode.', { code: 'editor.notReady' }),
+            result: createLocalEditorCommandFailure(capabilityId, 'Editor is not in edit mode.', { code: 'editor.notReady' }),
         };
     }
     const sessionState = state.session.getState({ cloneDocuments: false });
     const document = asEditorSceneDocument(sessionState.workingDocument);
-    const objectId = normalizeAgentBridgeString(input.objectId);
+    const objectId = normalizeEditorCommandString(input.objectId);
     if (objectId) {
         if (!document) {
             return {
                 ok: false,
-                result: createLocalEditorAgentBridgeFailure(capabilityId, 'Shadow capabilities require an editor scene document.', {
+                result: createLocalEditorCommandFailure(capabilityId, 'Shadow capabilities require an editor scene document.', {
                     code: 'shadow.unsupportedDocument',
                     details: { objectId },
                 }),
             };
         }
-        if (!isAgentBridgeSafeSceneObjectId(operations, objectId)) {
+        if (!isEditorCommandSafeSceneObjectId(operations, objectId)) {
             return {
                 ok: false,
-                result: createLocalEditorAgentBridgeFailure(capabilityId, `Shadow target object is unavailable in the safe Scene Hierarchy projection: ${objectId}`, {
+                result: createLocalEditorCommandFailure(capabilityId, `Shadow target object is unavailable in the safe Scene Hierarchy projection: ${objectId}`, {
                     code: 'shadow.targetNotFound',
                     objectId,
                 }),
@@ -1688,7 +1688,7 @@ function resolveShadowTarget(capabilityId, state, input, operations) {
         if (!gameObject) {
             return {
                 ok: false,
-                result: createLocalEditorAgentBridgeFailure(capabilityId, `Shadow target object not found: ${objectId}`, {
+                result: createLocalEditorCommandFailure(capabilityId, `Shadow target object not found: ${objectId}`, {
                     code: 'shadow.targetNotFound',
                     objectId,
                 }),
@@ -1711,7 +1711,7 @@ function resolveShadowTarget(capabilityId, state, input, operations) {
         if (!hasActivePrefabHierarchyScope(operations, details)) {
             return {
                 ok: false,
-                result: createLocalEditorAgentBridgeFailure(capabilityId, 'Open Prefab stage does not own the active Hierarchy authority.', {
+                result: createLocalEditorCommandFailure(capabilityId, 'Open Prefab stage does not own the active Hierarchy authority.', {
                     code: 'shadow.scopeMismatch',
                     details: { prefabAssetId: details.stage.assetId },
                 }),
@@ -1721,7 +1721,7 @@ function resolveShadowTarget(capabilityId, state, input, operations) {
         if (prefabTarget)
             return { ok: true, target: prefabTarget };
     }
-    const activeId = normalizeAgentBridgeString(getAgentBridgeSafeSceneSelection(operations).activeId);
+    const activeId = normalizeEditorCommandString(getEditorCommandSafeSceneSelection(operations).activeId);
     if (activeId && document) {
         const gameObject = findShadowGameObject(document, activeId);
         if (gameObject) {
@@ -1740,20 +1740,20 @@ function resolveShadowTarget(capabilityId, state, input, operations) {
     }
     return {
         ok: false,
-        result: createLocalEditorAgentBridgeFailure(capabilityId, 'Shadow target is required. Provide objectId, or open a Prefab stage and provide nodeId/assetId.', {
+        result: createLocalEditorCommandFailure(capabilityId, 'Shadow target is required. Provide objectId, or open a Prefab stage and provide nodeId/assetId.', {
             code: 'shadow.targetRequired',
             details: { objectId: input.objectId, nodeId: input.nodeId, assetId: 'assetId' in input ? input.assetId : undefined },
         }),
     };
 }
 function resolvePrefabShadowTargetFromDetails(details, input, operations) {
-    const requestedAssetId = 'assetId' in input ? normalizeAgentBridgeString(input.assetId) : '';
+    const requestedAssetId = 'assetId' in input ? normalizeEditorCommandString(input.assetId) : '';
     if (requestedAssetId && requestedAssetId !== details.stage.assetId && requestedAssetId !== details.stage.browserAssetId)
         return null;
     const model = operations.getHierarchyReadModel();
     if (!hasActivePrefabHierarchyScope(operations, details, model))
         return null;
-    const safeModel = createAgentBridgeSafePrefabReadModel(model, details.nodeDetails);
+    const safeModel = createEditorCommandSafePrefabReadModel(model, details.nodeDetails);
     const nodes = listPrefabShadowNodes(safeModel);
     const nodeId = resolveSafePrefabNodeAuthoredId(safeModel, normalizePrefabNodeId(input.nodeId));
     const node = nodes.find(candidate => candidate.id === nodeId) ?? null;
@@ -1919,7 +1919,7 @@ function readRenderingActionStaticBakeSourceNodeIds(result) {
     const details = result.details;
     if (!Object.prototype.hasOwnProperty.call(details, 'sourceNodeIds'))
         return null;
-    return normalizeAgentBridgeIdList(readRenderingActionStringList(details.sourceNodeIds));
+    return normalizeEditorCommandIdList(readRenderingActionStringList(details.sourceNodeIds));
 }
 function readRenderingActionStringList(value) {
     return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
@@ -1959,7 +1959,7 @@ function createShadowDebugRuntimeEvidence(plan, receivers, shadowPreviewDebugInf
             severity: 'warning',
             source: 'editor',
             code: 'shadow.staticArtifactEvidenceUnavailable',
-            message: 'Static-baked shadow visibility requires a baked artifact; this editor bridge session does not expose artifact presence evidence to shadow.debug.visibilityMeasure.',
+            message: 'Static-baked shadow visibility requires a baked artifact; this renderer attachment does not expose artifact presence evidence to shadow.debug.visibilityMeasure.',
         });
     }
     return {
@@ -2570,7 +2570,7 @@ function projectCasterBoundsToReceiver(casterBounds, receiverBounds, direction)
 }
 function readShadowProjectionBounds(state, targetId, projectionContext) {
     const projectionId = projectionContext.resolveProjectionId(targetId);
-    return createAgentBridgeBounds(state.projection?.getSelectionBounds([projectionId]) ?? null);
+    return createEditorCommandBounds(state.projection?.getSelectionBounds([projectionId]) ?? null);
 }
 function readShadowPreviewEffectiveVisible(state, targetId, projectionContext, authoredVisible) {
     const projectionId = projectionContext.resolveProjectionId(targetId);
@@ -2582,7 +2582,7 @@ function readShadowPreviewEffectiveVisible(state, targetId, projectionContext, a
     const override = overrides[projectionId] ?? overrides[targetId];
     return authoredVisible && override !== false;
 }
-function createAgentBridgeBounds(bounds) {
+function createEditorCommandBounds(bounds) {
     if (!bounds)
         return undefined;
     const half = {
@@ -2658,7 +2658,7 @@ function findShadowGameObject(document, objectId) {
     return document.scene.gameObjects.find(gameObject => gameObject.id === objectId) ?? null;
 }
 function normalizePrefabNodeId(value) {
-    const id = normalizeAgentBridgeString(value);
+    const id = normalizeEditorCommandString(value);
     return id.startsWith('prefab-node:') ? id.slice('prefab-node:'.length) : id;
 }
 function readBoolean(value, fallback) {