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

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

@@ -0,0 +1,735 @@
+import { EDITOR_AGENT_BRIDGE_CAPABILITY_ID, } from '@fps-games/editor-protocol';
+import { createLocalEditorAgentBridgeFailure, isLocalEditorAgentBridgeVec3 } from '../diagnostics.js';
+import { normalizeAgentBridgeString, } from '../shared.js';
+import { findAgentBridgeVisibleAssetInfo, listAgentBridgeVisibleAssetInfos } from './assets.js';
+const PREFAB_STAGE_ITEM_PREFIX = 'prefab-node:';
+const PREFAB_ROOT_NODE_ID = 'prefab-root';
+const ZERO_VEC3 = { x: 0, y: 0, z: 0 };
+const ONE_VEC3 = { x: 1, y: 1, z: 1 };
+export function createLocalEditorAgentBridgePrefabSource(state, options, renderUi, operations) {
+    return {
+        resolvePrefab(input) {
+            return resolvePrefabs(state, options, operations, input);
+        },
+        openStage(input) {
+            const resolved = resolvePrefabs(state, options, operations, input);
+            if (!resolved.resolvedPrefab) {
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_OPEN, resolved.ambiguous
+                    ? 'Prefab query matched multiple prefab assets; provide assetId or browserAssetId.'
+                    : 'Prefab asset not found.', { code: resolved.ambiguous ? 'prefab.ambiguous' : 'prefab.notFound' });
+            }
+            const currentStage = operations.getPrefabStage();
+            if (isSamePrefabStage(currentStage, resolved.resolvedPrefab)) {
+                return {
+                    opened: false,
+                    alreadyOpen: true,
+                    prefab: resolved.resolvedPrefab,
+                    stage: currentStage,
+                    status: `Editing Prefab ${currentStage.label}`,
+                };
+            }
+            const output = operations.openPrefabStage({
+                assetId: resolved.resolvedPrefab.assetId,
+                browserAssetId: resolved.resolvedPrefab.browserAssetId,
+            });
+            if (!output) {
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_OPEN, `Prefab stage unavailable: ${resolved.resolvedPrefab.assetId}`, { code: 'prefab.stageOpenFailed' });
+            }
+            renderUi();
+            return output;
+        },
+        exitStage() {
+            const output = operations.exitPrefabStage();
+            if (output.exited)
+                renderUi();
+            return output;
+        },
+        renameAsset(input) {
+            const details = operations.getPrefabStageDetails();
+            const assetId = normalizeAgentBridgeString(input.assetId) || details?.stage.assetId || '';
+            const displayNameResult = normalizePrefabEditableName(input.displayName);
+            if (!assetId || !displayNameResult.ok) {
+                const displayNameError = displayNameResult.ok ? '' : displayNameResult.message;
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_ASSET_RENAME, !assetId ? 'Prefab asset id is required.' : displayNameError, {
+                    code: !assetId ? 'prefab.invalidInput' : 'prefab.invalidName',
+                    details: { assetId: input.assetId, displayName: input.displayName },
+                });
+            }
+            const asset = findAgentBridgeVisibleAssetInfo(state, options, assetId);
+            if (!asset || !isPrefabAsset(asset)) {
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_ASSET_RENAME, `Prefab asset not found: ${assetId}`, { code: 'prefab.notFound', details: { assetId } });
+            }
+            const conflict = listAgentBridgeVisibleAssetInfos(state, options)
+                .find(candidate => candidate.assetId !== assetId
+                && isPrefabAsset(candidate)
+                && candidate.displayName.trim().toLowerCase() === displayNameResult.name.toLowerCase());
+            if (conflict) {
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_ASSET_RENAME, `Prefab name already exists: ${displayNameResult.name}`, {
+                    code: 'asset.nameConflict',
+                    details: { assetId, conflictingAssetId: conflict.assetId, displayName: displayNameResult.name },
+                });
+            }
+            const previousDisplayName = asset.displayName;
+            if (previousDisplayName === displayNameResult.name) {
+                return createPrefabAssetRenameOutput({
+                    assetId,
+                    previousDisplayName,
+                    displayName: displayNameResult.name,
+                    stageActive: !!details && details.stage.assetId === assetId,
+                    renamed: false,
+                });
+            }
+            const patched = operations.runPrefabStageAssetAction({
+                actionId: 'asset.rename',
+                assetId,
+                assetKind: 'prefab',
+                targetPrefabAssetId: details?.stage.assetId === assetId ? assetId : undefined,
+                value: displayNameResult.name,
+            });
+            if (!patched) {
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_ASSET_RENAME, `Prefab rename action unavailable: ${assetId}`, { code: 'prefab.actionUnavailable', details: { assetId } });
+            }
+            renderUi();
+            const stageActive = !!operations.getPrefabStageDetails() && operations.getPrefabStageDetails()?.stage.assetId === assetId;
+            return createPrefabAssetRenameOutput({
+                assetId,
+                previousDisplayName,
+                displayName: displayNameResult.name,
+                stageActive,
+                renamed: true,
+            });
+        },
+        getScene(input) {
+            const details = operations.getPrefabStageDetails();
+            if (!details || !isRequestedPrefabStage(details.stage, input.assetId)) {
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_SCENE_GET, createPrefabStageUnavailableMessage(input.assetId), { code: 'prefab.stageNotOpen', details: { assetId: input.assetId } });
+            }
+            return createPrefabSceneOutput(details);
+        },
+        selectNode(input) {
+            const nodeId = normalizePrefabNodeId(input.nodeId);
+            const details = operations.getPrefabStageDetails();
+            if (!details || !nodeId) {
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SELECT, nodeId ? 'Prefab stage is not open.' : 'Prefab node id is required.', { code: nodeId ? 'prefab.stageNotOpen' : 'prefab.invalidInput', details: { nodeId: input.nodeId } });
+            }
+            const scene = createPrefabSceneOutput(details);
+            const node = scene.nodes.find(candidate => candidate.nodeId === nodeId) ?? null;
+            if (!node) {
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SELECT, `Prefab node not found: ${nodeId}`, { code: 'prefab.nodeNotFound', details: { assetId: details.stage.assetId, nodeId } });
+            }
+            const changed = operations.selectPrefabStageItem(createPrefabStageItemId(nodeId));
+            if (changed)
+                renderUi();
+            const nextDetails = operations.getPrefabStageDetails() ?? details;
+            const nextScene = createPrefabSceneOutput(nextDetails);
+            const selectedNode = nextScene.nodes.find(candidate => candidate.nodeId === nodeId) ?? node;
+            return {
+                stage: nextScene.stage,
+                selectedNodeId: nodeId,
+                node: selectedNode,
+            };
+        },
+        createNodeFromAsset(input) {
+            const details = operations.getPrefabStageDetails();
+            const assetId = normalizeAgentBridgeString(input.assetId);
+            const asset = findAgentBridgeVisibleAssetInfo(state, options, assetId);
+            if (!details || !asset || !assetId) {
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_FROM_ASSET, !details
+                    ? 'Prefab stage is not open.'
+                    : `Asset not found: ${assetId || '(empty)'}`, { code: !details ? 'prefab.stageNotOpen' : 'asset.notFound', details: { assetId } });
+            }
+            const beforeScene = createPrefabSceneOutput(details);
+            const parentNodeId = resolvePrefabMutationParentNodeId(input.parentNodeId, beforeScene);
+            const action = {
+                actionId: 'asset.add-to-current-prefab',
+                assetId,
+                assetKind: asset.kind,
+                targetPrefabAssetId: details.stage.assetId,
+                parentNodeId,
+                value: createPrefabNodeCreateActionValue(input),
+            };
+            return runPrefabNodeMutation({
+                capabilityId: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_FROM_ASSET,
+                state,
+                operations,
+                renderUi,
+                beforeScene,
+                action,
+                select: input.select,
+            });
+        },
+        createGroupNode(input) {
+            const details = operations.getPrefabStageDetails();
+            if (!details) {
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_GROUP, 'Prefab stage is not open.', { code: 'prefab.stageNotOpen' });
+            }
+            const beforeScene = createPrefabSceneOutput(details);
+            const parentNodeId = resolvePrefabMutationParentNodeId(input.parentNodeId, beforeScene);
+            const action = {
+                actionId: 'prefab.node.createGroup',
+                targetPrefabAssetId: details.stage.assetId,
+                parentNodeId,
+                value: createPrefabNodeCreateActionValue(input),
+            };
+            return runPrefabNodeMutation({
+                capabilityId: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_GROUP,
+                state,
+                operations,
+                renderUi,
+                beforeScene,
+                action,
+                select: input.select,
+            });
+        },
+        createPrimitiveNode(input) {
+            const details = operations.getPrefabStageDetails();
+            if (!details) {
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_PRIMITIVE, 'Prefab stage is not open.', { code: 'prefab.stageNotOpen' });
+            }
+            const beforeScene = createPrefabSceneOutput(details);
+            const parentNodeId = resolvePrefabMutationParentNodeId(input.parentNodeId, beforeScene);
+            const action = {
+                actionId: 'prefab.node.createPrimitive',
+                targetPrefabAssetId: details.stage.assetId,
+                parentNodeId,
+                primitiveShape: input.shape,
+                value: createPrefabNodeCreateActionValue(input),
+            };
+            return runPrefabNodeMutation({
+                capabilityId: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_PRIMITIVE,
+                state,
+                operations,
+                renderUi,
+                beforeScene,
+                action,
+                select: input.select,
+            });
+        },
+        setNodeTransform(input) {
+            const nodeId = normalizePrefabNodeId(input.nodeId);
+            const details = operations.getPrefabStageDetails();
+            if (!details || !nodeId) {
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_TRANSFORM, nodeId ? 'Prefab stage is not open.' : 'Prefab node id is required.', { code: nodeId ? 'prefab.stageNotOpen' : 'prefab.invalidInput', details: { nodeId: input.nodeId } });
+            }
+            const beforeScene = createPrefabSceneOutput(details);
+            const node = beforeScene.nodes.find(candidate => candidate.nodeId === nodeId) ?? null;
+            if (!node) {
+                return createLocalEditorAgentBridgeFailure(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_TRANSFORM, `Prefab node not found: ${nodeId}`, { code: 'prefab.nodeNotFound', details: { assetId: details.stage.assetId, nodeId } });
+            }
+            const transform = createPrefabTransformActionValue({
+                position: input.position,
+                rotation: input.rotation,
+                scale: input.scale,
+            }, node.transform);
+            const action = {
+                actionId: 'prefab.node.setTransform',
+                targetPrefabAssetId: details.stage.assetId,
+                nodeId,
+                value: transform,
+            };
+            return runPrefabNodeMutation({
+                capabilityId: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_TRANSFORM,
+                state,
+                operations,
+                renderUi,
+                beforeScene,
+                action,
+                changedNodeId: nodeId,
+            });
+        },
+        reparentNode(input) {
+            return runNodeIdMutation({
+                capabilityId: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_REPARENT,
+                state,
+                operations,
+                renderUi,
+                nodeId: input.nodeId,
+                parentNodeId: input.parentNodeId,
+                actionId: 'prefab.node.reparent',
+            });
+        },
+        renameNode(input) {
+            return runNodeIdMutation({
+                capabilityId: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_RENAME,
+                state,
+                operations,
+                renderUi,
+                nodeId: input.nodeId,
+                actionId: 'prefab.node.rename',
+                value: input.name,
+            });
+        },
+        deleteNode(input) {
+            return runNodeIdMutation({
+                capabilityId: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_DELETE,
+                state,
+                operations,
+                renderUi,
+                nodeId: input.nodeId,
+                actionId: 'prefab.node.delete',
+            });
+        },
+        getSourceStructure(input) {
+            const resolved = resolvePrefabAssetForInspection(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_SOURCE_STRUCTURE_GET, state, options, operations, input);
+            if (!resolved.ok)
+                return resolved.result;
+            const structure = createPrefabSourceStructure(resolved.asset, resolved.node);
+            return {
+                stage: resolved.scene.stage,
+                ...(resolved.node ? { nodeId: resolved.node.nodeId } : {}),
+                assetId: resolved.asset.assetId,
+                structure,
+            };
+        },
+        listMaterialSlots(input) {
+            const resolved = resolvePrefabAssetForInspection(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_MATERIAL_SLOTS_LIST, state, options, operations, input);
+            if (!resolved.ok)
+                return resolved.result;
+            const slots = createPrefabMaterialSlots(resolved.asset, resolved.node)
+                .filter(slot => input.includeReadonly === true || slot.editable);
+            return {
+                stage: resolved.scene.stage,
+                ...(resolved.node ? { nodeId: resolved.node.nodeId } : {}),
+                assetId: resolved.asset.assetId,
+                slots,
+            };
+        },
+    };
+}
+function resolvePrefabs(state, options, operations, input) {
+    const assetId = normalizeAgentBridgeString(input.assetId);
+    const browserAssetId = normalizeAgentBridgeString(input.browserAssetId);
+    const name = normalizeAgentBridgeString(input.name).toLowerCase();
+    const query = normalizeAgentBridgeString(input.query).toLowerCase();
+    const includeUnavailable = 'includeUnavailable' in input && input.includeUnavailable === true;
+    const prefabs = listAgentBridgeVisibleAssetInfos(state, options)
+        .filter(asset => isPrefabAsset(asset))
+        .filter(asset => includeUnavailable || asset.placeable !== false)
+        .map(createPrefabSummary);
+    const matches = prefabs.filter(prefab => ((!!assetId && prefab.assetId === assetId)
+        || (!!browserAssetId && prefab.browserAssetId === browserAssetId)
+        || (!!name && prefab.displayName.toLowerCase() === name)
+        || (!!query && prefabMatchesQuery(prefab, query))
+        || (!assetId && !browserAssetId && !name && !query)));
+    const resolvedPrefab = matches.length === 1 ? matches[0] : null;
+    return {
+        prefabs: matches,
+        resolvedPrefab,
+        ambiguous: matches.length > 1,
+        currentStage: operations.getPrefabStage(),
+    };
+}
+function isPrefabAsset(asset) {
+    return String(asset.kind).toLowerCase() === 'prefab'
+        || String(asset.type).toLowerCase() === 'prefab'
+        || !!asset.prefab;
+}
+function createPrefabSummary(asset) {
+    const prefab = readRecord(asset.prefab);
+    const explicitBrowserAssetId = readString(prefab.browserAssetId);
+    const prefabId = readString(prefab.id);
+    const browserAssetId = explicitBrowserAssetId
+        || (prefabId && prefabId !== asset.assetId ? prefabId : undefined)
+        || (asset.prefab ? `prefab:${asset.assetId}` : undefined);
+    const sourceAssetId = readString(prefab.sourceAssetId) || readString(asset.metadata?.sourceAssetId);
+    const sourceAssetGuid = readString(prefab.sourceAssetGuid) || readString(asset.metadata?.sourceAssetGuid);
+    return {
+        assetId: asset.assetId,
+        ...(browserAssetId && browserAssetId !== asset.assetId ? { browserAssetId } : {}),
+        displayName: asset.displayName,
+        ...(sourceAssetId ? { sourceAssetId } : {}),
+        ...(sourceAssetGuid ? { sourceAssetGuid } : {}),
+        placeable: asset.placeable,
+        ...(prefab.readonly === true ? { readonly: true } : {}),
+        status: asset.prefab ? 'ready' : 'metadata-only',
+    };
+}
+function prefabMatchesQuery(prefab, query) {
+    return [
+        prefab.assetId,
+        prefab.browserAssetId,
+        prefab.displayName,
+        prefab.sourceAssetId,
+        prefab.sourceAssetGuid,
+        prefab.status,
+    ].some(value => String(value ?? '').toLowerCase().includes(query));
+}
+function isSamePrefabStage(stage, prefab) {
+    if (!stage)
+        return false;
+    return stage.assetId === prefab.assetId
+        || (!!prefab.browserAssetId && stage.browserAssetId === prefab.browserAssetId);
+}
+function readRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function readString(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+}
+function readPrefabPrimitive(value) {
+    const record = readRecord(value);
+    const shape = readString(record.shape);
+    return shape ? { ...structuredClone(record), shape } : null;
+}
+function createPrefabStageUnavailableMessage(assetId) {
+    const normalized = normalizeAgentBridgeString(assetId);
+    return normalized
+        ? `Prefab stage is not open for asset: ${normalized}`
+        : 'Prefab stage is not open.';
+}
+function isRequestedPrefabStage(stage, assetId) {
+    const normalized = normalizeAgentBridgeString(assetId);
+    return !normalized || stage.assetId === normalized || stage.browserAssetId === normalized;
+}
+function createPrefabSceneOutput(details) {
+    const nodes = listPrefabSceneNodes(details.structureItems);
+    const rootNodeId = nodes.find(node => node.kind === 'root')?.nodeId
+        ?? nodes.find(node => !node.parentNodeId)?.nodeId
+        ?? PREFAB_ROOT_NODE_ID;
+    const selectedNodeId = getSelectedPrefabNodeId(details.stage.selectedItemId);
+    return {
+        stage: details.stage,
+        rootNodeId,
+        selectedNodeId,
+        nodes,
+        ...(nodes.length === 0
+            ? {
+                diagnostics: [{
+                        severity: 'warning',
+                        source: 'editor',
+                        code: 'prefab.sceneEmpty',
+                        message: 'Prefab stage did not expose editable prefab nodes.',
+                    }],
+            }
+            : {}),
+    };
+}
+function listPrefabSceneNodes(items) {
+    const nodes = [];
+    const visit = (item, parentNodeId, parentPath) => {
+        const nodeId = normalizePrefabNodeId(item.nodeId ?? item.id);
+        const isPrefabNode = item.itemType === 'prefab-node' || !!item.nodeId || item.id.startsWith(PREFAB_STAGE_ITEM_PREFIX);
+        const kind = normalizePrefabNodeKind(item.kind);
+        const path = parentPath ? `${parentPath}/${item.label}` : item.label;
+        const currentParentNodeId = isPrefabNode && nodeId ? nodeId : parentNodeId;
+        if (isPrefabNode && nodeId && kind) {
+            const transform = readPrefabItemTransform(item.transform);
+            const primitive = readPrefabPrimitive(item.primitive);
+            const node = {
+                nodeId,
+                ...(item.guid ? { guid: item.guid } : {}),
+                name: item.label,
+                kind,
+                ...(parentNodeId ? { parentNodeId } : { parentNodeId: null }),
+                ...(path ? { path } : {}),
+                ...(item.sourceAssetId ? { sourceAssetId: item.sourceAssetId } : {}),
+                ...(item.sourceNodePath ? { sourceNodePath: item.sourceNodePath } : {}),
+                ...(item.childPrefabId ? { childPrefabId: item.childPrefabId } : {}),
+                ...(transform ? { transform } : {}),
+                ...(primitive ? { primitive } : {}),
+                ...(Object.keys(readRecord(item.defaults)).length > 0 ? { defaults: structuredClone(readRecord(item.defaults)) } : {}),
+                ...(Object.keys(readRecord(item.overrides)).length > 0 ? { overrides: structuredClone(readRecord(item.overrides)) } : {}),
+                ...(item.readonly != null ? { readonly: item.readonly } : {}),
+            };
+            nodes.push(node);
+        }
+        for (const child of item.children ?? []) {
+            visit(child, currentParentNodeId, path);
+        }
+    };
+    for (const item of items)
+        visit(item, null, '');
+    return nodes;
+}
+function normalizePrefabNodeKind(kind) {
+    if (kind === 'root'
+        || kind === 'group'
+        || kind === 'model'
+        || kind === 'primitive'
+        || kind === 'light'
+        || kind === 'prefabInstance'
+        || kind === 'collision') {
+        return kind;
+    }
+    return null;
+}
+function normalizePrefabNodeId(value) {
+    const id = normalizeAgentBridgeString(value);
+    return id.startsWith(PREFAB_STAGE_ITEM_PREFIX) ? id.slice(PREFAB_STAGE_ITEM_PREFIX.length) : id;
+}
+function normalizePrefabEditableName(value) {
+    if (typeof value !== 'string')
+        return { ok: false, message: 'Prefab name must be a string.' };
+    const name = value.trim();
+    if (!name)
+        return { ok: false, message: 'Prefab name cannot be empty.' };
+    if (name.length > 80)
+        return { ok: false, message: 'Prefab name cannot be longer than 80 characters.' };
+    if (/[\u0000-\u001f\u007f/\\]/u.test(name)) {
+        return { ok: false, message: 'Prefab name cannot contain control characters, /, or \\.' };
+    }
+    return { ok: true, name };
+}
+function createPrefabAssetRenameOutput(input) {
+    return { ...input };
+}
+function createPrefabStageItemId(nodeId) {
+    return `${PREFAB_STAGE_ITEM_PREFIX}${nodeId}`;
+}
+function getSelectedPrefabNodeId(itemId) {
+    const nodeId = normalizePrefabNodeId(itemId);
+    return nodeId || null;
+}
+function resolvePrefabMutationParentNodeId(inputParentNodeId, scene) {
+    const parentNodeId = normalizePrefabNodeId(inputParentNodeId);
+    if (parentNodeId)
+        return parentNodeId;
+    return scene.selectedNodeId || scene.rootNodeId;
+}
+function createPrefabNodeCreateActionValue(input) {
+    const name = normalizeAgentBridgeString(input.name);
+    const sourceNodePath = normalizeAgentBridgeString(input.sourceNodePath);
+    const transform = input.position || input.rotation || input.scale
+        ? createPrefabTransformActionValue(input)
+        : undefined;
+    const value = {
+        ...(name ? { name } : {}),
+        ...(sourceNodePath ? { sourceNodePath } : {}),
+        ...(transform ? { transform } : {}),
+    };
+    return Object.keys(value).length > 0 ? value : undefined;
+}
+function createPrefabTransformActionValue(input, before) {
+    return {
+        type: 'Transform',
+        position: clonePrefabVec3(input.position ?? before?.position ?? ZERO_VEC3),
+        rotation: clonePrefabVec3(input.rotation ?? before?.rotation ?? ZERO_VEC3),
+        scale: clonePrefabVec3(input.scale ?? before?.scale ?? ONE_VEC3),
+    };
+}
+function readPrefabItemTransform(value) {
+    const record = readRecord(value);
+    if (Object.keys(record).length === 0)
+        return undefined;
+    const transform = {
+        ...(isLocalEditorAgentBridgeVec3(record.position) ? { position: clonePrefabVec3(record.position) } : {}),
+        ...(isLocalEditorAgentBridgeVec3(record.rotation) ? { rotation: clonePrefabVec3(record.rotation) } : {}),
+        ...(isLocalEditorAgentBridgeVec3(record.scale) ? { scale: clonePrefabVec3(record.scale) } : {}),
+    };
+    return Object.keys(transform).length > 0 ? transform : undefined;
+}
+function clonePrefabVec3(value) {
+    return isLocalEditorAgentBridgeVec3(value) ? { x: value.x, y: value.y, z: value.z } : { ...ZERO_VEC3 };
+}
+function runNodeIdMutation(input) {
+    const nodeId = normalizePrefabNodeId(input.nodeId);
+    const parentNodeId = normalizePrefabNodeId(input.parentNodeId);
+    const details = input.operations.getPrefabStageDetails();
+    if (!details || !nodeId || (input.actionId === 'prefab.node.reparent' && !parentNodeId)) {
+        return createLocalEditorAgentBridgeFailure(input.capabilityId, !details ? 'Prefab stage is not open.' : 'Prefab node id is required.', {
+            code: !details ? 'prefab.stageNotOpen' : 'prefab.invalidInput',
+            details: { nodeId: input.nodeId, parentNodeId: input.parentNodeId },
+        });
+    }
+    const beforeScene = createPrefabSceneOutput(details);
+    const node = beforeScene.nodes.find(candidate => candidate.nodeId === nodeId) ?? null;
+    if (!node) {
+        return createLocalEditorAgentBridgeFailure(input.capabilityId, `Prefab node not found: ${nodeId}`, { code: 'prefab.nodeNotFound', details: { assetId: details.stage.assetId, nodeId } });
+    }
+    if (input.actionId === 'prefab.node.delete' && nodeId === beforeScene.rootNodeId) {
+        return createLocalEditorAgentBridgeFailure(input.capabilityId, 'Prefab root node cannot be deleted.', { code: 'prefab.rootNodeProtected', details: { assetId: details.stage.assetId, nodeId } });
+    }
+    let renameName = null;
+    let previousName = null;
+    if (input.actionId === 'prefab.node.rename') {
+        if (nodeId === beforeScene.rootNodeId) {
+            return createLocalEditorAgentBridgeFailure(input.capabilityId, 'Prefab root node name follows the prefab asset displayName; use prefab.asset.rename instead.', { code: 'prefab.rootRenameUseAssetRename', details: { assetId: details.stage.assetId, nodeId } });
+        }
+        const nameResult = normalizePrefabEditableName(input.value);
+        if (!nameResult.ok) {
+            return createLocalEditorAgentBridgeFailure(input.capabilityId, nameResult.message, { code: 'prefab.invalidName', details: { assetId: details.stage.assetId, nodeId, name: String(input.value ?? '') } });
+        }
+        const conflict = beforeScene.nodes.find(candidate => candidate.nodeId !== nodeId
+            && candidate.parentNodeId === node.parentNodeId
+            && candidate.name?.trim().toLowerCase() === nameResult.name.toLowerCase());
+        if (conflict) {
+            return createLocalEditorAgentBridgeFailure(input.capabilityId, `Prefab node name already exists under the same parent: ${nameResult.name}`, {
+                code: 'prefab.nodeNameConflict',
+                details: { assetId: details.stage.assetId, nodeId, conflictingNodeId: conflict.nodeId, name: nameResult.name },
+            });
+        }
+        previousName = node.name ?? '';
+        renameName = nameResult.name;
+        if (node.name === nameResult.name) {
+            return {
+                nodeId,
+                previousName,
+                name: nameResult.name,
+                selectedNodeId: beforeScene.selectedNodeId,
+                nodes: beforeScene.nodes,
+            };
+        }
+    }
+    const action = {
+        actionId: input.actionId,
+        targetPrefabAssetId: details.stage.assetId,
+        nodeId,
+        ...(parentNodeId ? { parentNodeId } : {}),
+        ...(input.value !== undefined ? { value: input.value } : {}),
+    };
+    const mutationResult = runPrefabNodeMutation({
+        capabilityId: input.capabilityId,
+        state: input.state,
+        operations: input.operations,
+        renderUi: input.renderUi,
+        beforeScene,
+        action,
+        changedNodeId: input.actionId === 'prefab.node.delete' ? undefined : nodeId,
+        deletedNodeIds: input.actionId === 'prefab.node.delete' ? [nodeId] : undefined,
+    });
+    if (input.actionId !== 'prefab.node.rename' || 'ok' in mutationResult)
+        return mutationResult;
+    const renamedNode = mutationResult.nodes.find(candidate => candidate.nodeId === nodeId) ?? null;
+    return {
+        nodeId,
+        previousName: previousName ?? node.name ?? '',
+        name: renamedNode?.name ?? renameName ?? node.name ?? '',
+        selectedNodeId: mutationResult.selectedNodeId,
+        nodes: mutationResult.nodes,
+    };
+}
+function runPrefabNodeMutation(input) {
+    const previousSelectedItemId = input.beforeScene.stage.selectedItemId ?? null;
+    const patched = input.operations.runPrefabStageAssetAction(input.action);
+    if (!patched) {
+        return createLocalEditorAgentBridgeFailure(input.capabilityId, `Prefab action unavailable: ${input.action.actionId}`, {
+            code: 'prefab.actionUnavailable',
+            details: {
+                actionId: input.action.actionId,
+                assetId: input.beforeScene.stage.assetId,
+                nodeId: input.action.nodeId,
+            },
+        });
+    }
+    if (input.select === false && previousSelectedItemId)
+        input.operations.selectPrefabStageItem(previousSelectedItemId);
+    input.renderUi();
+    const afterDetails = input.operations.getPrefabStageDetails();
+    if (!afterDetails) {
+        return createLocalEditorAgentBridgeFailure(input.capabilityId, 'Prefab mutation completed, but Prefab stage is no longer open.', { code: 'prefab.stageClosed' });
+    }
+    const afterScene = createPrefabSceneOutput(afterDetails);
+    const beforeNodeIds = new Set(input.beforeScene.nodes.map(node => node.nodeId));
+    const afterNodeIds = new Set(afterScene.nodes.map(node => node.nodeId));
+    const createdNodeId = afterScene.nodes.find(node => !beforeNodeIds.has(node.nodeId))?.nodeId;
+    const deletedNodeIds = input.deletedNodeIds ?? input.beforeScene.nodes
+        .filter(node => !afterNodeIds.has(node.nodeId))
+        .map(node => node.nodeId);
+    const selectedNodeId = afterScene.selectedNodeId;
+    const changedNodeId = input.changedNodeId ?? createdNodeId ?? selectedNodeId ?? undefined;
+    const node = changedNodeId
+        ? afterScene.nodes.find(candidate => candidate.nodeId === changedNodeId) ?? null
+        : selectedNodeId
+            ? afterScene.nodes.find(candidate => candidate.nodeId === selectedNodeId) ?? null
+            : null;
+    return {
+        stage: afterScene.stage,
+        changed: true,
+        ...(createdNodeId ? { createdNodeId } : {}),
+        ...(changedNodeId ? { changedNodeId } : {}),
+        ...(deletedNodeIds.length > 0 ? { deletedNodeIds } : {}),
+        selectedNodeId,
+        node,
+        rootNodeId: afterScene.rootNodeId,
+        nodes: afterScene.nodes,
+        status: input.state.status,
+        ...(afterScene.diagnostics ? { diagnostics: afterScene.diagnostics } : {}),
+    };
+}
+function resolvePrefabAssetForInspection(capabilityId, state, options, operations, input) {
+    const details = operations.getPrefabStageDetails();
+    if (!details) {
+        return {
+            ok: false,
+            result: createLocalEditorAgentBridgeFailure(capabilityId, 'Prefab stage is not open.', { code: 'prefab.stageNotOpen' }),
+        };
+    }
+    const scene = createPrefabSceneOutput(details);
+    const nodeId = normalizePrefabNodeId(input.nodeId) || scene.selectedNodeId || '';
+    const node = nodeId ? scene.nodes.find(candidate => candidate.nodeId === nodeId) ?? null : null;
+    const assetId = normalizeAgentBridgeString(input.assetId)
+        || node?.sourceAssetId
+        || node?.childPrefabId
+        || '';
+    const asset = assetId ? findAgentBridgeVisibleAssetInfo(state, options, assetId) : null;
+    if (!asset) {
+        return {
+            ok: false,
+            result: createLocalEditorAgentBridgeFailure(capabilityId, `Prefab source asset not found: ${assetId || '(empty)'}`, { code: 'asset.notFound', details: { assetId, nodeId: node?.nodeId } }),
+        };
+    }
+    return {
+        ok: true,
+        scene,
+        asset,
+        node,
+    };
+}
+function createPrefabSourceStructure(asset, node) {
+    const analysis = readRecord(readRecord(asset.metadata).assetAnalysis);
+    return {
+        assetId: asset.assetId,
+        ...(node ? { nodeId: node.nodeId } : {}),
+        ...(node?.sourceNodePath ? { sourceNodePath: node.sourceNodePath } : {}),
+        ...(readNumber(analysis.nodeCount) != null ? { nodeCount: readNumber(analysis.nodeCount) } : {}),
+        ...(readNumber(analysis.meshCount) != null ? { meshCount: readNumber(analysis.meshCount) } : {}),
+        ...(readNumber(analysis.materialCount) != null ? { materialCount: readNumber(analysis.materialCount) } : {}),
+        ...(readNumber(analysis.textureCount) != null ? { textureCount: readNumber(analysis.textureCount) } : {}),
+        ...(Array.isArray(analysis.nodes) ? { nodes: structuredClone(analysis.nodes) } : {}),
+        ...(Array.isArray(analysis.meshes) ? { meshes: structuredClone(analysis.meshes) } : {}),
+        ...(Array.isArray(analysis.materials) ? { materials: structuredClone(analysis.materials) } : {}),
+        ...(readString(asset.relativePath) ? { relativePath: asset.relativePath } : {}),
+        ...(readString(asset.contentHash) ? { contentHash: asset.contentHash } : {}),
+        ...(readString(analysis.summary) ? { summary: readString(analysis.summary) } : {}),
+        ...(readString(analysis.complexity) ? { complexity: readString(analysis.complexity) } : {}),
+        ...(Array.isArray(analysis.diagnostics) ? { diagnostics: structuredClone(analysis.diagnostics) } : {}),
+    };
+}
+function createPrefabMaterialSlots(asset, node) {
+    const slots = readArray(readRecord(asset.metadata).materialSlots);
+    return slots.map((slot, index) => {
+        const slotId = readString(slot.slotId) ?? readString(slot.id);
+        const ownerNodePath = readString(slot.ownerNodePath);
+        const sourceMaterialIndex = readNumber(slot.sourceMaterialIndex);
+        const sourceMaterialName = readString(slot.sourceMaterialName)
+            ?? readString(slot.materialName)
+            ?? readArray(slot.materialNames).map(readString).find(Boolean);
+        const editable = !!slotId || !!ownerNodePath;
+        const bindingPath = slotId
+            ? `prefab.overrides.materialSlotBindings.${slotId}`
+            : ownerNodePath
+                ? `prefab.overrides.childMaterialBindings.${ownerNodePath}`
+                : undefined;
+        return {
+            ...(slotId ? { slotId } : {}),
+            label: readString(slot.label) ?? sourceMaterialName ?? `Material Slot ${index + 1}`,
+            ...(ownerNodePath ? { ownerNodePath } : {}),
+            ...(sourceMaterialIndex != null ? { sourceMaterialIndex } : {}),
+            ...(sourceMaterialName ? { sourceMaterialName } : {}),
+            ...(bindingPath ? { bindingPath, overridePath: bindingPath } : {}),
+            ...(bindingPath ? { materialAssetIdPath: `${bindingPath}.materialAssetId` } : {}),
+            ...(node ? { nodeId: node.nodeId } : {}),
+            editable,
+            ...(!editable ? { readonlyReason: 'Material slot has no stable slotId or owner node path.' } : {}),
+        };
+    });
+}
+function readArray(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => !!item && typeof item === 'object' && !Array.isArray(item))
+        : [];
+}
+function readNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+//# sourceMappingURL=prefabs.js.map