@fps-games/editor 0.1.6-beta.1 → 0.1.7-beta.2

package/dist/agent-bridge/register.js

@@ -0,0 +1,908 @@
+import { EDITOR_AGENT_BRIDGE_CAPABILITY_ID, EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS, EDITOR_AGENT_BRIDGE_SCHEMA_VERSION, } from '@fps-games/editor-protocol';
+import { createLocalEditorAgentBridgeFailure } from './diagnostics.js';
+// Static baked shadow authoring is intentionally hidden until the workflow is redesigned.
+const EDITOR_SHADOW_STATIC_AUTHORING_ENABLED = false;
+export function registerLocalEditorAgentBridgeCapabilities(bridge, sources) {
+    const unregister = [
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.ASSET_LIBRARY_LIST,
+                title: 'List asset library',
+                description: 'List standard project assets after editorReady=true. Use this before placing assets; returned assetId values are stable inputs for asset.info.get, asset.analysis.get, and object.createFromAsset.',
+                layer: 'editor',
+                category: 'asset',
+                stability: 'experimental',
+                access: 'read',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.ASSET_LIBRARY_LIST],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.ASSET_LIBRARY_LIST, input);
+                return normalized.ok ? sources.assets.listAssets(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.ASSET_INFO_GET,
+                title: 'Get asset info',
+                description: 'Read complete serializable metadata for one standard project asset by assetId. It does not read original file bytes and should be used before placement when catalog metadata matters.',
+                layer: 'editor',
+                category: 'asset',
+                stability: 'experimental',
+                access: 'read',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.ASSET_INFO_GET],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.ASSET_INFO_GET, input);
+                return normalized.ok ? sources.assets.getAssetInfo(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.ASSET_ANALYSIS_GET,
+                title: 'Get asset analysis',
+                description: 'Read SDK-generated raw asset structure analysis from asset metadata. Use for GLB/GLTF mesh/material complexity and PNG/JPEG/WebP image dimensions before creating or inspecting assets.',
+                layer: 'editor',
+                category: 'asset',
+                stability: 'experimental',
+                access: 'read',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.ASSET_ANALYSIS_GET],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.ASSET_ANALYSIS_GET, input);
+                return normalized.ok ? sources.assets.getAssetAnalysis(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_RESOLVE,
+                title: 'Resolve prefab asset',
+                description: 'Resolve prefab assets by assetId, browserAssetId, exact name, or fuzzy query after editorReady=true. Use asset.library.list(kind=prefab) or this capability before prefab.stage.open.',
+                layer: 'editor',
+                category: 'prefab',
+                stability: 'experimental',
+                access: 'read',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_RESOLVE],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_RESOLVE, input);
+                return normalized.ok ? sources.prefabs.resolvePrefab(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_OPEN,
+                title: 'Open prefab stage',
+                description: 'Enter the prefab preview/edit stage for a prefab asset after editorReady=true. Prefer this over double-clicking the Asset Library; it is idempotent when the requested prefab is already open.',
+                layer: 'editor',
+                category: 'prefab',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_OPEN],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_OPEN, input);
+                return normalized.ok ? sources.prefabs.openStage(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_EXIT,
+                title: 'Exit prefab stage',
+                description: 'Exit the current prefab preview/edit stage and return to the scene editor. This is idempotent and returns exited=false when no prefab stage is open.',
+                layer: 'editor',
+                category: 'prefab',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_EXIT],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_EXIT, input);
+                return normalized.ok ? sources.prefabs.exitStage(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_ASSET_RENAME,
+                title: 'Rename prefab asset',
+                description: 'Rename a prefab asset displayName through the editor asset action patch pipeline. In an open Prefab stage, assetId may be omitted to rename the current prefab; this does not rename existing scene prefab instances or readonly GLB source nodes.',
+                layer: 'editor',
+                category: 'prefab',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_ASSET_RENAME],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_ASSET_RENAME, input);
+                return normalized.ok ? sources.prefabs.renameAsset(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_SCENE_GET,
+                title: 'Get prefab composition scene',
+                description: 'Read the editable Prefab Scene Tree for the currently open Prefab stage. Use after prefab.stage.open before prefab.node.* writes; this does not expose raw GLB source nodes as editable prefab nodes.',
+                layer: 'editor',
+                category: 'prefab',
+                stability: 'experimental',
+                access: 'read',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_SCENE_GET],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_SCENE_GET, input);
+                return normalized.ok ? sources.prefabs.getScene(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SELECT,
+                title: 'Select prefab node',
+                description: 'Select an editable node inside the current Prefab stage. Use node ids from prefab.scene.get; this changes Prefab stage selection, not main scene selection.',
+                layer: 'editor',
+                category: 'prefab',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SELECT],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SELECT, input);
+                return normalized.ok ? sources.prefabs.selectNode(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_FROM_ASSET,
+                title: 'Create prefab node from asset',
+                description: 'Add a model or child prefab asset into the currently open Prefab stage through the editor asset action patch pipeline. Use asset.library.list first; this writes the prefab document, not the main scene.',
+                layer: 'editor',
+                category: 'prefab',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_FROM_ASSET],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_FROM_ASSET, input);
+                return normalized.ok ? sources.prefabs.createNodeFromAsset(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_GROUP,
+                title: 'Create prefab group node',
+                description: 'Add an empty group node to the currently open Prefab stage through the editor prefab node mutation path. Use it as a composition container before adding or reparenting model, primitive, or child prefab nodes.',
+                layer: 'editor',
+                category: 'prefab',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_GROUP],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_GROUP, input);
+                return normalized.ok ? sources.prefabs.createGroupNode(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_PRIMITIVE,
+                title: 'Create prefab primitive node',
+                description: 'Add a primitive helper node to the currently open Prefab stage through the editor prefab node mutation path. Use for composition layout tests, blockers, receivers, and simple placeholders.',
+                layer: 'editor',
+                category: 'prefab',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_PRIMITIVE],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_PRIMITIVE, input);
+                return normalized.ok ? sources.prefabs.createPrimitiveNode(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_TRANSFORM,
+                title: 'Set prefab node transform',
+                description: 'Set position, rotation, and/or scale for an editable Prefab stage node. This routes through prefab node document patches and does not mutate projection or runtime JSON directly.',
+                layer: 'editor',
+                category: 'prefab',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_TRANSFORM],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_TRANSFORM, input);
+                return normalized.ok ? sources.prefabs.setNodeTransform(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_REPARENT,
+                title: 'Reparent prefab node',
+                description: 'Move an editable Prefab stage node under another prefab node. The reducer rejects root reparenting and cyclic parents.',
+                layer: 'editor',
+                category: 'prefab',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_REPARENT],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_REPARENT, input);
+                return normalized.ok ? sources.prefabs.reparentNode(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_RENAME,
+                title: 'Rename prefab node',
+                description: 'Rename a non-root editable node inside the current Prefab stage. Root names follow prefab.asset.rename, and readonly GLB Source Structure names are not editable.',
+                layer: 'editor',
+                category: 'prefab',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_RENAME],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_RENAME, input);
+                return normalized.ok ? sources.prefabs.renameNode(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_DELETE,
+                title: 'Delete prefab node',
+                description: 'Delete an editable node from the current Prefab stage through prefab document mutation. Root deletion and invalid nodes return structured diagnostics.',
+                layer: 'editor',
+                category: 'prefab',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_DELETE],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_DELETE, input);
+                return normalized.ok ? sources.prefabs.deleteNode(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_SOURCE_STRUCTURE_GET,
+                title: 'Get prefab source structure',
+                description: 'Read readonly source asset anatomy for a prefab model node or asset. This reports SDK asset analysis metadata and is not an editable Prefab Scene Tree.',
+                layer: 'editor',
+                category: 'prefab',
+                stability: 'experimental',
+                access: 'read',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_SOURCE_STRUCTURE_GET],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_SOURCE_STRUCTURE_GET, input);
+                return normalized.ok ? sources.prefabs.getSourceStructure(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_MATERIAL_SLOTS_LIST,
+                title: 'List prefab material slots',
+                description: 'List editable material override targets for a prefab model node or asset from SDK materialSlots metadata. Use before future material/shadow tuning; read-only slots are optional.',
+                layer: 'editor',
+                category: 'prefab',
+                stability: 'experimental',
+                access: 'read',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_MATERIAL_SLOTS_LIST],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_MATERIAL_SLOTS_LIST, input);
+                return normalized.ok ? sources.prefabs.listMaterialSlots(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_MODE_GET,
+                title: 'Get host mode',
+                description: 'Read host lifecycle state without changing mode. Use as optional preflight or diagnostics; editorReady=true means the host is in editor mode, has an active editor session, and is not busy.',
+                layer: 'host',
+                category: 'lifecycle',
+                stability: 'experimental',
+                access: 'read',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_MODE_GET],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_MODE_GET, input);
+                return normalized.ok ? sources.host.getMode(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_EDITOR_ENTER,
+                title: 'Enter editor mode',
+                description: 'Default L1 entry point for agents. Call this to enter or ensure editor mode before L2/L3 editor operations instead of clicking the UI with browser automation. It is idempotent: already-editor hosts return alreadyEditor=true.',
+                layer: 'host',
+                category: 'lifecycle',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_EDITOR_ENTER],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_EDITOR_ENTER, input);
+                return normalized.ok ? sources.host.enterEditor(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_EDITOR_WAIT_READY,
+                title: 'Wait for editor readiness',
+                description: 'Read-only readiness wait. Use after host.editor.enter only when extra confirmation or timeout diagnostics are needed; it does not enter editor mode by itself.',
+                layer: 'host',
+                category: 'lifecycle',
+                stability: 'experimental',
+                access: 'read',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_EDITOR_WAIT_READY],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_EDITOR_WAIT_READY, input);
+                return normalized.ok ? sources.host.waitReady(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.EDITOR_UI_REGIONS_GET,
+                title: 'Get editor workspace regions',
+                description: 'Read the editor workspace region map for agents. It explains left Hierarchy, center Preview, right Inspector/render tabs, bottom Asset Library, top Toolbar, and Agent Bridge Console semantics, and maps each area to preferred capabilities before L0 fallback.',
+                layer: 'editor',
+                category: 'ui',
+                stability: 'experimental',
+                access: 'read',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.EDITOR_UI_REGIONS_GET],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.EDITOR_UI_REGIONS_GET, input);
+                return normalized.ok ? sources.ui.getRegions(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SCENE_OBJECTS_LIST,
+                title: 'List scene objects',
+                description: 'List editor scene objects with hierarchy and transform summaries after editorReady=true. Use returned object ids as stable inputs for selection, transform, viewport, and workflow capabilities.',
+                layer: 'editor',
+                category: 'scene',
+                stability: 'experimental',
+                access: 'read',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SCENE_OBJECTS_LIST],
+            },
+            handler: input => ({ objects: sources.objects.listObjects(input ?? {}) }),
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_RESOLVE,
+                title: 'Resolve scene object',
+                description: 'Resolve editor scene objects by id, exact name/path/type, or fuzzy query after editorReady=true. Use this before write operations when the object id is not already known.',
+                layer: 'editor',
+                category: 'scene',
+                stability: 'experimental',
+                access: 'read',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_RESOLVE],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_RESOLVE, input);
+                return normalized.ok ? sources.objects.resolveObject(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_CREATE_PRIMITIVE,
+                title: 'Create primitive object',
+                description: 'Create a basic scene primitive after editorReady=true. Shapes are cube, sphere, plane, or capsule; the capability uses the editor scene graph create patch and selects the created object when possible.',
+                layer: 'editor',
+                category: 'scene',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_CREATE_PRIMITIVE],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_CREATE_PRIMITIVE, input);
+                return normalized.ok ? sources.objects.createPrimitive(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_CREATE_FROM_ASSET,
+                title: 'Create object from asset',
+                description: 'Create a scene object from a standard asset library asset after editorReady=true. Use asset.library.list and asset.analysis.get first; this capability delegates to the editor harness asset creation path and may select/focus the created object.',
+                layer: 'editor',
+                category: 'asset',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_CREATE_FROM_ASSET],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_CREATE_FROM_ASSET, input);
+                return normalized.ok ? sources.objects.createFromAsset(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_DELETE,
+                title: 'Delete objects',
+                description: 'Delete one or more editor scene objects after editorReady=true. Provide exactly one of objectId or objectIds; protected, locked, readonly, or missing nodes are rejected by scene graph validation.',
+                layer: 'editor',
+                category: 'scene',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_DELETE],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_DELETE, input);
+                return normalized.ok ? sources.objects.deleteObjects(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SELECTION_SET,
+                title: 'Set selection',
+                description: 'Select one or more editor scene objects by object id after editorReady=true. Prefer ids returned by scene.objects.list; this is an editor semantic operation, not a UI click.',
+                layer: 'editor',
+                category: 'selection',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SELECTION_SET],
+            },
+            handler: input => sources.selection.setSelection(input ?? {}),
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_POLICY_GET,
+                title: 'Get shadow policy',
+                description: 'Read Shadow V2 policy and effective resolved plan for a scene object or current Prefab stage node. Use this before editing caster/receiver/light/quality settings; readonly source anatomy is not editable.',
+                layer: 'editor',
+                category: 'shadow',
+                stability: 'experimental',
+                access: 'read',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_POLICY_GET],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_POLICY_GET, input);
+                return normalized.ok ? sources.shadows.getPolicy(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_POLICY_SET,
+                title: 'Set shadow policy',
+                description: 'Write Shadow V2 caster/receiver/mode/light/quality/params for a scene object or editable Prefab stage root/node through editor document patches. This is the default agent path for shadow authoring instead of Inspector clicking.',
+                layer: 'editor',
+                category: 'shadow',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_POLICY_SET],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_POLICY_SET, input);
+                return normalized.ok ? sources.shadows.setPolicy(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_RECEIVERS_LIST,
+                title: 'List shadow receivers',
+                description: 'List candidate shadow receiver nodes for a scene object or Prefab stage preview target. Explicit receivers and shadow.receive settings score above auto plane inference.',
+                layer: 'editor',
+                category: 'shadow',
+                stability: 'experimental',
+                access: 'read',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_RECEIVERS_LIST],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_RECEIVERS_LIST, input);
+                return normalized.ok ? sources.shadows.listReceivers(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_RESOLVE_PREVIEW,
+                title: 'Resolve shadow preview',
+                description: 'Preview the resolved Shadow V2 backend, receiver list, light binding, quality params, and diagnostics without changing editor state. Use after policy changes or before screenshot validation.',
+                layer: 'editor',
+                category: 'shadow',
+                stability: 'experimental',
+                access: 'read',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_RESOLVE_PREVIEW],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_RESOLVE_PREVIEW, input);
+                return normalized.ok ? sources.shadows.resolvePreview(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_INSPECT,
+                title: 'Inspect shadow debug context',
+                description: 'Read the complete Shadow V2 debugging context for a scene object or Prefab stage target: caster, receivers, light, policy, resolved plan, expected footprint, runtime evidence, and diagnostics. Use this before deciding whether a screenshot really shows a shadow.',
+                layer: 'editor',
+                category: 'shadow',
+                stability: 'experimental',
+                access: 'read',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_INSPECT],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_INSPECT, input);
+                return normalized.ok ? sources.shadows.inspectDebug(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_CONTEXT_ENTER,
+                title: 'Enter shadow debug context',
+                description: 'Enter a preview-only Shadow Debug Context for a scene object or Prefab stage target. It automatically keeps the caster, resolved receivers, shadow light, and ambient lights visible, hides unrelated projected objects, applies receiver/footprint/light overlays, and returns inspect plus visibilityMeasure evidence for screenshot validation.',
+                layer: 'editor',
+                category: 'shadow',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_CONTEXT_ENTER],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_CONTEXT_ENTER, input);
+                return normalized.ok ? sources.shadows.enterDebugContext(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_CONTEXT_CLEAR,
+                title: 'Clear shadow debug context',
+                description: 'Clear the preview-only Shadow Debug Context, including protected receiver visibility state and shadow debug overlays. This does not write scene or prefab documents.',
+                layer: 'editor',
+                category: 'shadow',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_CONTEXT_CLEAR],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_CONTEXT_CLEAR, input);
+                return normalized.ok ? sources.shadows.clearDebugContext(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_OVERLAY_SET,
+                title: 'Set shadow debug overlay',
+                description: 'Show preview-only Shadow V2 debug helpers for a scene object or Prefab stage target: caster bounds, receiver bounds, light direction, expected footprint, and artifact bounds. This does not write scene or prefab documents; use before L0 screenshots to avoid visual misjudgment.',
+                layer: 'editor',
+                category: 'shadow',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_OVERLAY_SET],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_OVERLAY_SET, input);
+                return normalized.ok ? sources.shadows.setDebugOverlay(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_OVERLAY_CLEAR,
+                title: 'Clear shadow debug overlay',
+                description: 'Clear preview-only Shadow V2 debug helpers previously created by shadow.debug.overlay.set. This does not write scene or prefab documents.',
+                layer: 'editor',
+                category: 'shadow',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_OVERLAY_CLEAR],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_OVERLAY_CLEAR, input);
+                return normalized.ok ? sources.shadows.clearDebugOverlay(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_VISIBILITY_MEASURE,
+                title: 'Measure shadow visibility',
+                description: 'Return a structured Shadow V2 visibility score for a scene object or Prefab stage target. Use after shadow.debug.inspect or shadow.debug.overlay.set to avoid judging shadow success by screenshot alone. MVP measurement is structural when pixel readback is unavailable.',
+                layer: 'editor',
+                category: 'shadow',
+                stability: 'experimental',
+                access: 'read',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_VISIBILITY_MEASURE],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_VISIBILITY_MEASURE, input);
+                return normalized.ok ? sources.shadows.measureVisibility(normalized.input) : normalized.result;
+            },
+        }),
+        ...(EDITOR_SHADOW_STATIC_AUTHORING_ENABLED ? [
+            bridge.registerCapability({
+                manifest: {
+                    schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                    id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_STATIC_BAKE,
+                    title: 'Bake static shadow',
+                    description: 'Request a static shadow bake for the resolved Shadow V2 scene target through the editor rendering action pipeline. Use after shadow.resolvePreview confirms a static plan and receivers; prefab stage policies bake after placement in a scene.',
+                    layer: 'editor',
+                    category: 'shadow',
+                    stability: 'experimental',
+                    access: 'write',
+                    ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_STATIC_BAKE],
+                },
+                handler: input => {
+                    const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_STATIC_BAKE, input);
+                    return normalized.ok ? sources.shadows.bakeStatic(normalized.input) : normalized.result;
+                },
+            }),
+            bridge.registerCapability({
+                manifest: {
+                    schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                    id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_STATIC_INVALIDATE,
+                    title: 'Invalidate static shadow',
+                    description: 'Mark a static Shadow V2 scene target as stale so agents and users know a rebake is required after transform, receiver, light, or policy changes.',
+                    layer: 'editor',
+                    category: 'shadow',
+                    stability: 'experimental',
+                    access: 'write',
+                    ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_STATIC_INVALIDATE],
+                },
+                handler: input => {
+                    const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_STATIC_INVALIDATE, input);
+                    return normalized.ok ? sources.shadows.invalidateStatic(normalized.input) : normalized.result;
+                },
+            }),
+        ] : []),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.TRANSFORM_MOVE,
+                title: 'Move object',
+                description: 'Move a scene object by absolute position or relative offset after editorReady=true. Provide exactly one of position or offset; the capability uses the editor document adapter path and returns before/after transform state.',
+                layer: 'editor',
+                category: 'transform',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.TRANSFORM_MOVE],
+            },
+            handler: input => sources.transform.move(input),
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.TRANSFORM_SET,
+                title: 'Set object transform',
+                description: 'Set one or more absolute TRS fields on an editor scene object after editorReady=true. Provide objectId and at least one of position, rotation, or scale; the capability uses the editor document adapter path and returns before/after transform state.',
+                layer: 'editor',
+                category: 'transform',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.TRANSFORM_SET],
+            },
+            handler: input => sources.transform.set(input),
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_FOCUS_OBJECT,
+                title: 'Focus object in viewport',
+                description: 'Frame a scene object in the editor viewport after editorReady=true. Use this for semantic viewport focus instead of browser scrolling, dragging, or clicking the canvas.',
+                layer: 'editor',
+                category: 'viewport',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_FOCUS_OBJECT],
+            },
+            handler: input => sources.viewport.focusObject(input),
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_FRAME_SELECTION,
+                title: 'Frame selected object',
+                description: 'Frame the current editor selection in the viewport after editorReady=true. Use after selection.set or transform operations when the active object is already selected.',
+                layer: 'editor',
+                category: 'viewport',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_FRAME_SELECTION],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_FRAME_SELECTION, input);
+                return normalized.ok ? sources.viewport.frameSelection(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_VISIBILITY_SNAPSHOT,
+                title: 'Get preview visibility overrides',
+                description: 'Read preview-only visibility and isolation overrides. Use during visual debugging to understand what the editor viewport is temporarily hiding; this never reads or writes scene/prefab authored visibility.',
+                layer: 'editor',
+                category: 'viewport',
+                stability: 'experimental',
+                access: 'read',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_VISIBILITY_SNAPSHOT],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_VISIBILITY_SNAPSHOT, input);
+                return normalized.ok ? sources.viewport.getVisibilitySnapshot(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_VISIBILITY_SET,
+                title: 'Set preview visibility',
+                description: 'Temporarily hide or show projected objects in the editor viewport for debugging. This is preview-only: it does not change scene object active/visible fields or prefab documents, and authored inactive objects are not revived.',
+                layer: 'editor',
+                category: 'viewport',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_VISIBILITY_SET],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_VISIBILITY_SET, input);
+                return normalized.ok ? sources.viewport.setVisibility(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_VISIBILITY_CLEAR,
+                title: 'Clear preview visibility overrides',
+                description: 'Clear all preview-only visibility and isolation overrides, restoring the viewport to authored active/visible state without writing scene or prefab data.',
+                layer: 'editor',
+                category: 'viewport',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_VISIBILITY_CLEAR],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_VISIBILITY_CLEAR, input);
+                return normalized.ok ? sources.viewport.clearVisibility(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_ISOLATION_ENTER,
+                title: 'Enter preview isolation',
+                description: 'Temporarily isolate projected objects in the editor viewport by hiding unrelated objects. Use this before shadow screenshots to remove visual clutter; this is preview-only and never writes scene or prefab data.',
+                layer: 'editor',
+                category: 'viewport',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_ISOLATION_ENTER],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_ISOLATION_ENTER, input);
+                return normalized.ok ? sources.viewport.enterIsolation(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_CAMERA_GET,
+                title: 'Get viewport camera state',
+                description: 'Read the editor viewport camera state after editorReady=true. Use this to inspect the current view preset, projection, target, pose, radius, and selection before visual analysis.',
+                layer: 'editor',
+                category: 'viewport',
+                stability: 'experimental',
+                access: 'read',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_CAMERA_GET],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_CAMERA_GET, input);
+                return normalized.ok ? sources.viewport.getCamera(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_CAMERA_SET_PRESET,
+                title: 'Set viewport camera preset',
+                description: 'Set a stable editor viewport camera preset after editorReady=true. Prefer top/front/side/iso/threeQuarterTop presets for agent visual analysis before falling back to browser screenshots.',
+                layer: 'editor',
+                category: 'viewport',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_CAMERA_SET_PRESET],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_CAMERA_SET_PRESET, input);
+                return normalized.ok ? sources.viewport.setCameraPreset(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_CAMERA_ORBIT,
+                title: 'Orbit viewport camera',
+                description: 'Apply a semantic yaw/pitch/distance adjustment to the editor viewport camera after editorReady=true. Use for small inspection adjustments after a preset establishes the baseline view.',
+                layer: 'editor',
+                category: 'viewport',
+                stability: 'experimental',
+                access: 'write',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_CAMERA_ORBIT],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_CAMERA_ORBIT, input);
+                return normalized.ok ? sources.viewport.orbitCamera(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.EDITOR_SNAPSHOT_GET,
+                title: 'Get editor snapshot',
+                description: 'Read a lightweight editor summary after editorReady=true. By default it returns mode, busy/dirty/status, selection, and objectCount; request includeObjects with objectLimit only when object summaries are needed.',
+                layer: 'editor',
+                category: 'state',
+                stability: 'experimental',
+                access: 'read',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.EDITOR_SNAPSHOT_GET],
+            },
+            handler: input => {
+                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.EDITOR_SNAPSHOT_GET, input);
+                return normalized.ok ? sources.state.getSnapshot(normalized.input) : normalized.result;
+            },
+        }),
+        bridge.registerCapability({
+            manifest: {
+                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
+                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.EDITOR_STATE_GET,
+                title: 'Get editor state',
+                description: 'Read editor mode, status, selection, dirty state, and optional object summary. Use for verification after L1/L2 operations and for diagnostics before falling back to browser automation.',
+                layer: 'editor',
+                category: 'state',
+                stability: 'experimental',
+                access: 'read',
+                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.EDITOR_STATE_GET],
+            },
+            handler: input => sources.state.getState(input ?? {}),
+        }),
+    ];
+    return () => {
+        for (const unregisterCapability of unregister)
+            unregisterCapability();
+    };
+}
+function normalizeObjectInput(capabilityId, input) {
+    if (input === undefined || input === null)
+        return { ok: true, input: {} };
+    if (typeof input === 'object' && !Array.isArray(input))
+        return { ok: true, input: input };
+    return {
+        ok: false,
+        result: createLocalEditorAgentBridgeFailure(capabilityId, `${capabilityId} input must be an object.`, { code: 'host.invalidInput' }),
+    };
+}
+//# sourceMappingURL=register.js.map