@fps-games/editor 0.1.5-beta.5 → 0.1.7-beta.1

package/node_modules/@fps-games/editor-playable-sdk/dist/document/helpers.js

@@ -1,3 +1,20 @@
+import { mergeArtistMaterialProfiles, } from '@fps-games/editor-protocol';
+import { isEditorSceneArtistMaterialPatchPath, normalizeEditorSceneMaterialSlotOwnerPath, readEditorSceneChildMaterialBindingOwnerPath, readEditorSceneMaterialSlotBindingSlotId, } from '../material-binding/paths.js';
+export const EDITOR_SCENE_PREFAB_COMPOSITION_VERSION = 1;
+export const EDITOR_SCENE_PREFAB_LEGACY_ROOT_NODE_ID = 'prefab-root';
+export const EDITOR_SCENE_PREFAB_LEGACY_MODEL_NODE_ID = 'prefab-model';
+const EDITOR_SCENE_PREFAB_OVERRIDE_FIELD_PATH_PREFIX = 'prefab.';
+const EDITOR_SCENE_PREFAB_CORE_MATERIAL_OVERRIDE_PROFILE_FIELD_PATHS = new Set([
+    'profile.baseColor.color',
+    'profile.baseColor.texture.textureAssetId',
+    'profile.normal.texture.textureAssetId',
+    'profile.normal.strength',
+    'profile.metallic',
+    'profile.roughness',
+    'profile.emission.color',
+    'profile.emission.intensity',
+    'profile.emission.texture.textureAssetId',
+]);
 export function cloneEditorSceneDocument(document) {
     return structuredClone(document);
 }
@@ -7,6 +24,932 @@ export function findEditorSceneTransform(gameObject) {
 export function findEditorSceneModelRenderer(gameObject) {
     return gameObject.components.find(isEditorSceneModelRendererComponent) ?? null;
 }
+export function isEditorScenePrefabAsset(asset) {
+    return asset?.type === 'prefab' && readEditorSceneNonEmptyString(asset.prefab?.sourceAssetId) != null;
+}
+export function isEditorScenePrefabInstance(gameObject) {
+    return readEditorSceneNonEmptyString(gameObject?.prefab?.prefabId) != null;
+}
+export function resolveEditorScenePrefabSourceAssetId(prefabAsset) {
+    return readEditorSceneNonEmptyString(prefabAsset?.prefab?.sourceAssetId);
+}
+export function readEditorScenePrefabRootNodeId(prefabAsset) {
+    if (!prefabAsset?.prefab)
+        return null;
+    const nodes = readEditorScenePrefabExplicitNodes(prefabAsset.prefab);
+    const explicitRootNodeId = readEditorSceneNonEmptyString(prefabAsset.prefab.rootNodeId);
+    if (explicitRootNodeId && nodes.some(node => node.id === explicitRootNodeId))
+        return explicitRootNodeId;
+    const explicitRoot = nodes.find(node => node.kind === 'root' && !node.parentId);
+    if (explicitRoot)
+        return explicitRoot.id;
+    if (nodes.length > 0)
+        return null;
+    const legacyRoot = createEditorScenePrefabLegacyRootNode(prefabAsset);
+    return legacyRoot ? legacyRoot.id : null;
+}
+export function readEditorScenePrefabNodes(prefabAsset) {
+    if (!prefabAsset?.prefab)
+        return [];
+    const explicitNodes = readEditorScenePrefabExplicitNodes(prefabAsset.prefab);
+    if (explicitNodes.length > 0)
+        return explicitNodes;
+    return createEditorScenePrefabLegacyCompositionNodes(prefabAsset);
+}
+export function findEditorScenePrefabNode(prefabAsset, nodeId) {
+    const normalizedNodeId = readEditorSceneNonEmptyString(nodeId);
+    if (!normalizedNodeId)
+        return null;
+    return readEditorScenePrefabNodes(prefabAsset).find(node => node.id === normalizedNodeId) ?? null;
+}
+export function readEditorScenePrefabNodeChildren(prefabAsset, parentNodeId) {
+    const normalizedParentId = readEditorSceneNonEmptyString(parentNodeId);
+    return readEditorScenePrefabNodes(prefabAsset).filter((node) => {
+        const parentId = readEditorSceneNonEmptyString(node.parentId);
+        return normalizedParentId ? parentId === normalizedParentId : !parentId;
+    });
+}
+export function ensureEditorScenePrefabComposition(prefabAsset) {
+    if (!isEditorScenePrefabAsset(prefabAsset)) {
+        return createEditorScenePrefabMutationResult(prefabAsset, false, null, [{
+                code: 'prefab.invalidDefinition',
+                severity: 'error',
+                message: `Asset "${prefabAsset.id}" is not a valid prefab definition.`,
+                assetId: prefabAsset.id,
+            }]);
+    }
+    const next = cloneEditorScenePrefabAssetWithComposition(prefabAsset);
+    return createEditorScenePrefabMutationResult(next, JSON.stringify(next.prefab) !== JSON.stringify(prefabAsset.prefab));
+}
+export function selectEditorScenePrefabNode(prefabAsset, nodeId) {
+    const prepared = ensureEditorScenePrefabComposition(prefabAsset);
+    if (!prepared.ok)
+        return prepared;
+    const normalizedNodeId = readEditorSceneNonEmptyString(nodeId);
+    const node = normalizedNodeId ? findEditorScenePrefabNode(prepared.prefabAsset, normalizedNodeId) : null;
+    if (!node) {
+        return createEditorScenePrefabMutationResult(prepared.prefabAsset, false, null, [{
+                code: 'prefab.nodeNotFound',
+                severity: 'error',
+                message: `Prefab node "${nodeId}" was not found.`,
+                assetId: prefabAsset.id,
+                nodeId,
+            }]);
+    }
+    return createEditorScenePrefabMutationResult(prepared.prefabAsset, false, node, [], {
+        selectedNodeId: node.id,
+    });
+}
+export function renameEditorScenePrefabAsset(document, assetId, displayName) {
+    const normalizedAssetId = readEditorSceneNonEmptyString(assetId);
+    const prefabAsset = normalizedAssetId
+        ? document.assets.find(asset => asset.id === normalizedAssetId && isEditorScenePrefabAsset(asset))
+        : null;
+    if (!prefabAsset) {
+        return createEditorScenePrefabMutationResult({
+            id: normalizedAssetId ?? String(assetId ?? ''),
+            type: 'prefab',
+            prefab: { sourceAssetId: '' },
+        }, false, null, [{
+                code: 'prefab.invalidDefinition',
+                severity: 'error',
+                message: `Prefab asset "${assetId}" was not found.`,
+                assetId,
+            }]);
+    }
+    const nameResult = normalizeEditorScenePrefabEditableName(displayName);
+    if (!nameResult.ok) {
+        return createEditorScenePrefabMutationResult(prefabAsset, false, null, [{
+                code: 'prefab.invalidName',
+                severity: 'error',
+                message: nameResult.message,
+                assetId: prefabAsset.id,
+            }]);
+    }
+    const normalizedDisplayName = nameResult.name;
+    const lowerName = normalizedDisplayName.toLowerCase();
+    const conflict = document.assets.find(candidate => (candidate.id !== prefabAsset.id
+        && isEditorScenePrefabAsset(candidate)
+        && readEditorSceneNonEmptyString(candidate.displayName)?.toLowerCase() === lowerName));
+    if (conflict) {
+        return createEditorScenePrefabMutationResult(prefabAsset, false, null, [{
+                code: 'prefab.nameConflict',
+                severity: 'error',
+                message: `Prefab asset name "${normalizedDisplayName}" is already used by "${conflict.id}".`,
+                assetId: prefabAsset.id,
+            }]);
+    }
+    if (prefabAsset.displayName === normalizedDisplayName) {
+        return createEditorScenePrefabMutationResult(prefabAsset, false);
+    }
+    const next = cloneEditorScenePrefabAssetWithComposition({
+        ...structuredClone(prefabAsset),
+        displayName: normalizedDisplayName,
+    });
+    const rootNodeId = readEditorScenePrefabRootNodeId(next);
+    if (rootNodeId && Array.isArray(next.prefab?.nodes)) {
+        const rootIndex = next.prefab.nodes.findIndex(node => node.id === rootNodeId);
+        if (rootIndex >= 0) {
+            next.prefab.nodes = [...next.prefab.nodes];
+            next.prefab.nodes[rootIndex] = {
+                ...structuredClone(next.prefab.nodes[rootIndex]),
+                name: normalizedDisplayName,
+            };
+        }
+    }
+    return createEditorScenePrefabMutationResult(next, true);
+}
+export function renameEditorScenePrefabNode(prefabAsset, nodeId, name) {
+    const prepared = ensureEditorScenePrefabComposition(prefabAsset);
+    if (!prepared.ok)
+        return prepared;
+    const normalizedNodeId = readEditorSceneNonEmptyString(nodeId);
+    const node = normalizedNodeId ? findEditorScenePrefabNode(prepared.prefabAsset, normalizedNodeId) : null;
+    if (!node) {
+        return createEditorScenePrefabMutationResult(prepared.prefabAsset, false, null, [{
+                code: 'prefab.nodeNotFound',
+                severity: 'error',
+                message: `Prefab node "${nodeId}" was not found.`,
+                assetId: prefabAsset.id,
+                nodeId,
+            }]);
+    }
+    const rootNodeId = readEditorScenePrefabRootNodeId(prepared.prefabAsset);
+    if (node.id === rootNodeId) {
+        return createEditorScenePrefabMutationResult(prepared.prefabAsset, false, node, [{
+                code: 'prefab.rootRenameRejected',
+                severity: 'error',
+                message: 'Prefab root node name follows the prefab asset displayName; use prefab.asset.rename instead.',
+                assetId: prefabAsset.id,
+                nodeId: node.id,
+            }]);
+    }
+    const nameResult = normalizeEditorScenePrefabEditableName(name);
+    if (!nameResult.ok) {
+        return createEditorScenePrefabMutationResult(prepared.prefabAsset, false, node, [{
+                code: 'prefab.invalidName',
+                severity: 'error',
+                message: nameResult.message,
+                assetId: prefabAsset.id,
+                nodeId: node.id,
+            }]);
+    }
+    const normalizedName = nameResult.name;
+    const siblings = readEditorScenePrefabNodeChildren(prepared.prefabAsset, node.parentId);
+    const conflict = siblings.find(candidate => (candidate.id !== node.id
+        && readEditorSceneNonEmptyString(candidate.name)?.toLowerCase() === normalizedName.toLowerCase()));
+    if (conflict) {
+        return createEditorScenePrefabMutationResult(prepared.prefabAsset, false, node, [{
+                code: 'prefab.nameConflict',
+                severity: 'error',
+                message: `Prefab node name "${normalizedName}" is already used by sibling "${conflict.id}".`,
+                assetId: prefabAsset.id,
+                nodeId: node.id,
+                parentId: node.parentId,
+            }]);
+    }
+    return updateEditorScenePrefabNode(prepared.prefabAsset, node.id, (candidate) => ({
+        ...candidate,
+        name: normalizedName,
+    }));
+}
+export function createEditorScenePrefabNodeFromAsset(prefabAsset, asset, options = {}) {
+    const prepared = ensureEditorScenePrefabComposition(prefabAsset);
+    if (!prepared.ok)
+        return prepared;
+    if (asset.id === prefabAsset.id) {
+        return createEditorScenePrefabMutationResult(prepared.prefabAsset, false, null, [{
+                code: 'prefab.selfReferenceRejected',
+                severity: 'error',
+                message: `Prefab "${prefabAsset.id}" cannot contain itself directly.`,
+                assetId: asset.id,
+            }]);
+    }
+    const parentResult = resolveEditorScenePrefabMutationParent(prepared.prefabAsset, options.parentId);
+    if (!parentResult.ok)
+        return createEditorScenePrefabMutationResult(prepared.prefabAsset, false, null, parentResult.diagnostics);
+    const nodes = readEditorScenePrefabNodes(prepared.prefabAsset);
+    const isChildPrefab = isEditorScenePrefabAsset(asset);
+    const isModel = asset.type !== 'prefab' && (asset.type === 'glb' || asset.type === 'model' || asset.type === 'gltf');
+    if (!isChildPrefab && !isModel) {
+        return createEditorScenePrefabMutationResult(prepared.prefabAsset, false, null, [{
+                code: 'prefab.assetUnsupported',
+                severity: 'error',
+                message: `Asset "${asset.id}" cannot be added to a prefab composition.`,
+                assetId: asset.id,
+            }]);
+    }
+    const node = {
+        id: options.id ?? createUniqueEditorScenePrefabNodeId(nodes, `${isChildPrefab ? 'prefab' : 'model'}-${asset.id}`),
+        ...(options.guid ? { guid: options.guid } : {}),
+        name: options.name ?? asset.displayName ?? asset.id,
+        parentId: parentResult.parentId,
+        kind: isChildPrefab ? 'prefabInstance' : 'model',
+        ...(options.transform ? { transform: structuredClone(options.transform) } : {}),
+        ...(isChildPrefab ? { childPrefabId: asset.id } : { sourceAssetId: asset.id }),
+        ...(readEditorSceneNonEmptyString(options.sourceNodePath) ? { sourceNodePath: readEditorSceneNonEmptyString(options.sourceNodePath) } : {}),
+    };
+    return appendEditorScenePrefabNode(prepared.prefabAsset, node);
+}
+export function createEditorScenePrefabPrimitiveNode(prefabAsset, options) {
+    const prepared = ensureEditorScenePrefabComposition(prefabAsset);
+    if (!prepared.ok)
+        return prepared;
+    const parentResult = resolveEditorScenePrefabMutationParent(prepared.prefabAsset, options.parentId);
+    if (!parentResult.ok)
+        return createEditorScenePrefabMutationResult(prepared.prefabAsset, false, null, parentResult.diagnostics);
+    const shape = readEditorSceneNonEmptyString(options.shape);
+    if (!shape) {
+        return createEditorScenePrefabMutationResult(prepared.prefabAsset, false, null, [{
+                code: 'prefab.assetUnsupported',
+                severity: 'error',
+                message: 'Prefab primitive shape must be a non-empty string.',
+                assetId: prefabAsset.id,
+            }]);
+    }
+    const nodes = readEditorScenePrefabNodes(prepared.prefabAsset);
+    const node = {
+        id: options.id ?? createUniqueEditorScenePrefabNodeId(nodes, `primitive-${shape}`),
+        ...(options.guid ? { guid: options.guid } : {}),
+        name: options.name ?? `${shape[0].toUpperCase()}${shape.slice(1)}`,
+        parentId: parentResult.parentId,
+        kind: 'primitive',
+        primitive: { shape },
+        ...(options.transform ? { transform: structuredClone(options.transform) } : {}),
+    };
+    return appendEditorScenePrefabNode(prepared.prefabAsset, node);
+}
+export function createEditorScenePrefabGroupNode(prefabAsset, options = {}) {
+    const prepared = ensureEditorScenePrefabComposition(prefabAsset);
+    if (!prepared.ok)
+        return prepared;
+    const parentResult = resolveEditorScenePrefabMutationParent(prepared.prefabAsset, options.parentId);
+    if (!parentResult.ok)
+        return createEditorScenePrefabMutationResult(prepared.prefabAsset, false, null, parentResult.diagnostics);
+    const nodes = readEditorScenePrefabNodes(prepared.prefabAsset);
+    const node = {
+        id: options.id ?? createUniqueEditorScenePrefabNodeId(nodes, 'group'),
+        ...(options.guid ? { guid: options.guid } : {}),
+        name: options.name ?? 'Empty',
+        parentId: parentResult.parentId,
+        kind: 'group',
+        ...(options.transform ? { transform: structuredClone(options.transform) } : {}),
+    };
+    return appendEditorScenePrefabNode(prepared.prefabAsset, node);
+}
+export function setEditorScenePrefabNodeTransform(prefabAsset, nodeId, transform) {
+    const prepared = ensureEditorScenePrefabComposition(prefabAsset);
+    if (!prepared.ok)
+        return prepared;
+    if (!transform || transform.type !== 'Transform') {
+        return createEditorScenePrefabMutationResult(prepared.prefabAsset, false, null, [{
+                code: 'prefab.invalidTransform',
+                severity: 'error',
+                message: `Prefab node "${nodeId}" requires a Transform component payload.`,
+                assetId: prefabAsset.id,
+                nodeId,
+            }]);
+    }
+    return updateEditorScenePrefabNode(prepared.prefabAsset, nodeId, (node) => ({
+        ...node,
+        transform: structuredClone(transform),
+    }));
+}
+export function setEditorScenePrefabNodeShadow(prefabAsset, nodeId, shadow) {
+    const prepared = ensureEditorScenePrefabComposition(prefabAsset);
+    if (!prepared.ok)
+        return prepared;
+    return updateEditorScenePrefabNode(prepared.prefabAsset, nodeId, (node) => {
+        const defaults = { ...(node.defaults ?? {}) };
+        if (shadow && Object.keys(shadow).length > 0)
+            defaults.shadow = structuredClone(shadow);
+        else
+            delete defaults.shadow;
+        if (Object.keys(defaults).length > 0)
+            return { ...node, defaults };
+        const { defaults: _defaults, ...rest } = node;
+        return rest;
+    });
+}
+export function reparentEditorScenePrefabNode(prefabAsset, nodeId, parentId) {
+    const prepared = ensureEditorScenePrefabComposition(prefabAsset);
+    if (!prepared.ok)
+        return prepared;
+    const rootNodeId = readEditorScenePrefabRootNodeId(prepared.prefabAsset);
+    if (nodeId === rootNodeId) {
+        return createEditorScenePrefabMutationResult(prepared.prefabAsset, false, null, [{
+                code: 'prefab.rootReparentRejected',
+                severity: 'error',
+                message: 'Prefab root node cannot be reparented.',
+                assetId: prefabAsset.id,
+                nodeId,
+            }]);
+    }
+    const nodes = readEditorScenePrefabNodes(prepared.prefabAsset);
+    if (!nodes.some(node => node.id === nodeId)) {
+        return createEditorScenePrefabMutationResult(prepared.prefabAsset, false, null, [{
+                code: 'prefab.nodeNotFound',
+                severity: 'error',
+                message: `Prefab node "${nodeId}" was not found.`,
+                assetId: prefabAsset.id,
+                nodeId,
+            }]);
+    }
+    if (!nodes.some(node => node.id === parentId)) {
+        return createEditorScenePrefabMutationResult(prepared.prefabAsset, false, null, [{
+                code: 'prefab.parentNotFound',
+                severity: 'error',
+                message: `Prefab parent node "${parentId}" was not found.`,
+                assetId: prefabAsset.id,
+                nodeId,
+                parentId,
+            }]);
+    }
+    if (nodeId === parentId || isEditorScenePrefabNodeDescendant(nodes, parentId, nodeId)) {
+        return createEditorScenePrefabMutationResult(prepared.prefabAsset, false, null, [{
+                code: 'prefab.cycleReparentRejected',
+                severity: 'error',
+                message: `Prefab node "${nodeId}" cannot be parented under its own descendant "${parentId}".`,
+                assetId: prefabAsset.id,
+                nodeId,
+                parentId,
+            }]);
+    }
+    return updateEditorScenePrefabNode(prepared.prefabAsset, nodeId, (node) => ({
+        ...node,
+        parentId,
+    }));
+}
+export function deleteEditorScenePrefabNode(prefabAsset, nodeId) {
+    const prepared = ensureEditorScenePrefabComposition(prefabAsset);
+    if (!prepared.ok)
+        return prepared;
+    const rootNodeId = readEditorScenePrefabRootNodeId(prepared.prefabAsset);
+    if (nodeId === rootNodeId) {
+        return createEditorScenePrefabMutationResult(prepared.prefabAsset, false, null, [{
+                code: 'prefab.rootDeleteRejected',
+                severity: 'error',
+                message: 'Prefab root node cannot be deleted.',
+                assetId: prefabAsset.id,
+                nodeId,
+            }]);
+    }
+    const nodes = readEditorScenePrefabNodes(prepared.prefabAsset);
+    const target = nodes.find(node => node.id === nodeId);
+    if (!target) {
+        return createEditorScenePrefabMutationResult(prepared.prefabAsset, false, null, [{
+                code: 'prefab.nodeNotFound',
+                severity: 'error',
+                message: `Prefab node "${nodeId}" was not found.`,
+                assetId: prefabAsset.id,
+                nodeId,
+            }]);
+    }
+    const deleted = new Set();
+    collectEditorScenePrefabNodeSubtree(nodes, nodeId, deleted);
+    const next = structuredClone(prepared.prefabAsset);
+    next.prefab = structuredClone(next.prefab);
+    next.prefab.nodes = nodes.filter(node => !deleted.has(node.id));
+    return createEditorScenePrefabMutationResult(next, true, target, [], {
+        deletedNodeIds: [...deleted],
+    });
+}
+function createEditorScenePrefabMutationResult(prefabAsset, changed, node = null, diagnostics = [], extra = {}) {
+    return {
+        ok: diagnostics.every(diagnostic => diagnostic.severity !== 'error'),
+        changed,
+        prefabAsset,
+        ...(extra.selectedNodeId ? { selectedNodeId: extra.selectedNodeId } : {}),
+        ...(extra.createdNodeId ? { createdNodeId: extra.createdNodeId } : {}),
+        ...(extra.deletedNodeIds ? { deletedNodeIds: [...extra.deletedNodeIds] } : {}),
+        ...(node ? { node: structuredClone(node) } : {}),
+        diagnostics: diagnostics.map(diagnostic => ({ ...diagnostic })),
+    };
+}
+function cloneEditorScenePrefabAssetWithComposition(prefabAsset) {
+    const next = structuredClone(prefabAsset);
+    const nodes = readEditorScenePrefabNodes(prefabAsset);
+    next.prefab = structuredClone(next.prefab);
+    next.prefab.compositionVersion = EDITOR_SCENE_PREFAB_COMPOSITION_VERSION;
+    next.prefab.nodes = nodes;
+    const rootNodeId = readEditorScenePrefabRootNodeId({ ...prefabAsset, prefab: { ...prefabAsset.prefab, nodes } });
+    if (rootNodeId)
+        next.prefab.rootNodeId = rootNodeId;
+    else
+        delete next.prefab.rootNodeId;
+    return next;
+}
+function resolveEditorScenePrefabMutationParent(prefabAsset, parentId) {
+    const rootNodeId = readEditorScenePrefabRootNodeId(prefabAsset);
+    const normalizedParentId = readEditorSceneNonEmptyString(parentId) ?? rootNodeId;
+    if (!normalizedParentId || !findEditorScenePrefabNode(prefabAsset, normalizedParentId)) {
+        return {
+            ok: false,
+            diagnostics: [{
+                    code: 'prefab.parentNotFound',
+                    severity: 'error',
+                    message: `Prefab parent node "${normalizedParentId ?? parentId ?? 'root'}" was not found.`,
+                    assetId: prefabAsset.id,
+                    ...(normalizedParentId ? { parentId: normalizedParentId } : {}),
+                }],
+        };
+    }
+    return { ok: true, parentId: normalizedParentId };
+}
+function appendEditorScenePrefabNode(prefabAsset, node) {
+    const next = structuredClone(prefabAsset);
+    const nodes = readEditorScenePrefabNodes(prefabAsset);
+    const nodeId = createUniqueEditorScenePrefabNodeId(nodes, node.id);
+    const nextNode = {
+        ...structuredClone(node),
+        id: nodeId,
+    };
+    next.prefab = structuredClone(next.prefab);
+    next.prefab.compositionVersion = EDITOR_SCENE_PREFAB_COMPOSITION_VERSION;
+    const rootNodeId = readEditorScenePrefabRootNodeId(prefabAsset);
+    if (rootNodeId)
+        next.prefab.rootNodeId = rootNodeId;
+    else
+        delete next.prefab.rootNodeId;
+    next.prefab.nodes = [...nodes, nextNode];
+    return createEditorScenePrefabMutationResult(next, true, nextNode, [], {
+        createdNodeId: nextNode.id,
+        selectedNodeId: nextNode.id,
+    });
+}
+function updateEditorScenePrefabNode(prefabAsset, nodeId, update) {
+    const nodes = readEditorScenePrefabNodes(prefabAsset);
+    const index = nodes.findIndex(node => node.id === nodeId);
+    if (index < 0) {
+        return createEditorScenePrefabMutationResult(prefabAsset, false, null, [{
+                code: 'prefab.nodeNotFound',
+                severity: 'error',
+                message: `Prefab node "${nodeId}" was not found.`,
+                assetId: prefabAsset.id,
+                nodeId,
+            }]);
+    }
+    const updated = update(structuredClone(nodes[index]));
+    const nextNodes = [...nodes];
+    nextNodes[index] = updated;
+    const next = structuredClone(prefabAsset);
+    next.prefab = structuredClone(next.prefab);
+    next.prefab.compositionVersion = EDITOR_SCENE_PREFAB_COMPOSITION_VERSION;
+    const rootNodeId = readEditorScenePrefabRootNodeId(prefabAsset);
+    if (rootNodeId)
+        next.prefab.rootNodeId = rootNodeId;
+    else
+        delete next.prefab.rootNodeId;
+    next.prefab.nodes = nextNodes;
+    return createEditorScenePrefabMutationResult(next, JSON.stringify(nodes[index]) !== JSON.stringify(updated), updated, [], {
+        selectedNodeId: updated.id,
+    });
+}
+function createUniqueEditorScenePrefabNodeId(nodes, preferredId) {
+    const used = new Set(nodes.map(node => node.id));
+    const base = normalizeEditorScenePrefabIdentifierPart(preferredId) ?? 'prefab_node';
+    if (!used.has(base))
+        return base;
+    let suffix = 1;
+    let candidate = `${base}_${suffix}`;
+    while (used.has(candidate)) {
+        suffix += 1;
+        candidate = `${base}_${suffix}`;
+    }
+    return candidate;
+}
+function isEditorScenePrefabNodeDescendant(nodes, candidateNodeId, ancestorNodeId) {
+    let current = nodes.find(node => node.id === candidateNodeId);
+    const visited = new Set();
+    while (current?.parentId) {
+        if (current.parentId === ancestorNodeId)
+            return true;
+        if (visited.has(current.parentId))
+            return false;
+        visited.add(current.parentId);
+        current = nodes.find(node => node.id === current?.parentId);
+    }
+    return false;
+}
+function collectEditorScenePrefabNodeSubtree(nodes, nodeId, output) {
+    if (output.has(nodeId))
+        return;
+    output.add(nodeId);
+    for (const child of nodes.filter(node => node.parentId === nodeId)) {
+        collectEditorScenePrefabNodeSubtree(nodes, child.id, output);
+    }
+}
+export function createEditorScenePrefabDefinitionFromAsset(sourceAsset, options = {}) {
+    return {
+        id: options.id ?? `${sourceAsset.id}-prefab`,
+        ...(options.guid ? { guid: options.guid } : {}),
+        type: 'prefab',
+        displayName: options.displayName ?? createEditorScenePrefabDisplayName(sourceAsset),
+        category: options.category ?? 'Prefab',
+        prefab: {
+            sourceAssetId: sourceAsset.id,
+            ...(sourceAsset.guid ? { sourceAssetGuid: sourceAsset.guid } : {}),
+            ...(options.defaults ? { defaults: { ...options.defaults } } : {}),
+            compositionVersion: EDITOR_SCENE_PREFAB_COMPOSITION_VERSION,
+            rootNodeId: EDITOR_SCENE_PREFAB_LEGACY_ROOT_NODE_ID,
+            nodes: [
+                {
+                    id: EDITOR_SCENE_PREFAB_LEGACY_ROOT_NODE_ID,
+                    name: options.displayName ?? createEditorScenePrefabDisplayName(sourceAsset),
+                    kind: 'root',
+                    ...(options.defaults ? { defaults: { ...options.defaults } } : {}),
+                },
+                {
+                    id: EDITOR_SCENE_PREFAB_LEGACY_MODEL_NODE_ID,
+                    name: sourceAsset.displayName ?? sourceAsset.id,
+                    parentId: EDITOR_SCENE_PREFAB_LEGACY_ROOT_NODE_ID,
+                    kind: 'model',
+                    sourceAssetId: sourceAsset.id,
+                },
+            ],
+        },
+        ...(options.metadata ? { metadata: { ...options.metadata } } : {}),
+    };
+}
+function readEditorScenePrefabExplicitNodes(prefab) {
+    if (!Array.isArray(prefab.nodes))
+        return [];
+    const nodes = [];
+    for (const rawNode of prefab.nodes) {
+        const node = readEditorScenePrefabNode(rawNode);
+        if (node && !nodes.some(existing => existing.id === node.id))
+            nodes.push(node);
+    }
+    return structuredClone(nodes);
+}
+function readEditorScenePrefabNode(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const record = value;
+    const id = readEditorSceneNonEmptyString(record.id);
+    if (!id || !isEditorScenePrefabNodeKind(record.kind))
+        return null;
+    return {
+        id,
+        ...(readEditorSceneNonEmptyString(record.guid) ? { guid: readEditorSceneNonEmptyString(record.guid) } : {}),
+        ...(readEditorSceneNonEmptyString(record.name) ? { name: readEditorSceneNonEmptyString(record.name) } : {}),
+        ...(readEditorSceneNonEmptyString(record.parentId) ? { parentId: readEditorSceneNonEmptyString(record.parentId) } : {}),
+        kind: record.kind,
+        ...(record.transform ? { transform: structuredClone(record.transform) } : {}),
+        ...(readEditorSceneNonEmptyString(record.sourceAssetId) ? { sourceAssetId: readEditorSceneNonEmptyString(record.sourceAssetId) } : {}),
+        ...(readEditorSceneNonEmptyString(record.sourceNodePath) ? { sourceNodePath: readEditorSceneNonEmptyString(record.sourceNodePath) } : {}),
+        ...(readEditorSceneNonEmptyString(record.childPrefabId) ? { childPrefabId: readEditorSceneNonEmptyString(record.childPrefabId) } : {}),
+        ...(record.primitive ? { primitive: structuredClone(record.primitive) } : {}),
+        ...(record.light ? { light: structuredClone(record.light) } : {}),
+        ...(record.defaults ? { defaults: structuredClone(record.defaults) } : {}),
+        ...(record.overrides ? { overrides: structuredClone(record.overrides) } : {}),
+        ...(record.metadata ? { metadata: structuredClone(record.metadata) } : {}),
+    };
+}
+function isEditorScenePrefabNodeKind(value) {
+    return value === 'root'
+        || value === 'group'
+        || value === 'model'
+        || value === 'primitive'
+        || value === 'light'
+        || value === 'prefabInstance'
+        || value === 'collision';
+}
+function createEditorScenePrefabLegacyCompositionNodes(prefabAsset) {
+    const root = createEditorScenePrefabLegacyRootNode(prefabAsset);
+    const sourceAssetId = resolveEditorScenePrefabSourceAssetId(prefabAsset);
+    if (!root || !sourceAssetId)
+        return [];
+    return [
+        root,
+        {
+            id: EDITOR_SCENE_PREFAB_LEGACY_MODEL_NODE_ID,
+            name: readEditorSceneNonEmptyString(prefabAsset.displayName) ?? sourceAssetId,
+            parentId: root.id,
+            kind: 'model',
+            sourceAssetId,
+        },
+    ];
+}
+function createEditorScenePrefabLegacyRootNode(prefabAsset) {
+    if (!resolveEditorScenePrefabSourceAssetId(prefabAsset))
+        return null;
+    return {
+        id: EDITOR_SCENE_PREFAB_LEGACY_ROOT_NODE_ID,
+        name: readEditorSceneNonEmptyString(prefabAsset.displayName) ?? 'Prefab',
+        kind: 'root',
+        ...(prefabAsset.prefab?.defaults ? { defaults: structuredClone(prefabAsset.prefab.defaults) } : {}),
+        ...(prefabAsset.prefab?.overrides ? { overrides: structuredClone(prefabAsset.prefab.overrides) } : {}),
+    };
+}
+export function createEditorScenePrefabInstanceGameObject(input) {
+    const sourceAssetId = resolveEditorScenePrefabSourceAssetId(input.prefabAsset);
+    if (!sourceAssetId) {
+        throw new Error(`Prefab asset "${input.prefabAsset.id}" does not define a source asset.`);
+    }
+    const defaults = input.prefabAsset.prefab?.defaults;
+    return {
+        id: input.id,
+        ...(input.guid ? { guid: input.guid } : {}),
+        name: input.name ?? input.prefabAsset.displayName ?? input.prefabAsset.id,
+        kind: 'instance',
+        ...(input.parentId ? { parentId: input.parentId } : {}),
+        active: input.active ?? defaults?.active ?? true,
+        ...(input.shadowMode ?? defaults?.shadowMode ? { shadowMode: input.shadowMode ?? defaults?.shadowMode } : {}),
+        ...(input.shadow ?? defaults?.shadow ? { shadow: structuredClone(input.shadow ?? defaults?.shadow) } : {}),
+        prefab: {
+            prefabId: input.prefabAsset.id,
+            ...(input.prefabAsset.guid ? { prefabGuid: input.prefabAsset.guid } : {}),
+            sourceAssetId,
+        },
+        ...(input.metadata ? { metadata: { ...input.metadata } } : {}),
+        ...(input.overrides !== undefined ? { overrides: input.overrides } : {}),
+        components: [
+            input.transform,
+            {
+                type: 'ModelRenderer',
+                assetId: sourceAssetId,
+            },
+        ],
+    };
+}
+export function createEditorScenePrefabDefinitionFromGameObject(document, gameObjectId, options = {}) {
+    const gameObject = findEditorSceneGameObject(document, gameObjectId);
+    if (!gameObject)
+        return null;
+    const modelRenderer = findEditorSceneModelRenderer(gameObject);
+    const sourceAssetId = readEditorSceneNonEmptyString(modelRenderer?.assetId);
+    if (!sourceAssetId)
+        return null;
+    const sourceAsset = document.assets.find(asset => asset.id === sourceAssetId);
+    if (!sourceAsset || isEditorScenePrefabAsset(sourceAsset))
+        return null;
+    const displayName = options.displayName
+        ?? createEditorScenePrefabDisplayName({ id: gameObject.id, displayName: gameObject.name ?? sourceAsset.displayName });
+    return createEditorScenePrefabDefinitionFromAsset(sourceAsset, {
+        id: options.id ?? createUniqueEditorScenePrefabAssetId(document, `${gameObject.id}-prefab`),
+        guid: options.guid ?? options.createGuid?.() ?? createEditorScenePrefabGuid(),
+        displayName,
+        category: options.category,
+        defaults: options.defaults,
+        metadata: options.metadata,
+    });
+}
+export function createEditorSceneDuplicatedPrefabDefinition(document, prefabAssetId, options = {}) {
+    const source = document.assets.find(asset => asset.id === prefabAssetId);
+    if (!source || !isEditorScenePrefabAsset(source))
+        return null;
+    const sourcePrefab = structuredClone(source.prefab);
+    const displayName = options.displayName
+        ?? createUniqueEditorScenePrefabDisplayName(document.assets.map(asset => asset.displayName ?? asset.id), `${source.displayName ?? source.id} Copy`);
+    return {
+        ...structuredClone(source),
+        id: options.id ?? createUniqueEditorScenePrefabAssetId(document, `${source.id}_copy`),
+        guid: options.guid ?? options.createGuid?.() ?? createEditorScenePrefabGuid(),
+        displayName,
+        category: options.category ?? source.category,
+        prefab: {
+            ...sourcePrefab,
+            ...(sourcePrefab.defaults ? { defaults: { ...sourcePrefab.defaults } } : {}),
+        },
+        ...(options.metadata ? { metadata: { ...options.metadata } } : {}),
+    };
+}
+export function readEditorScenePrefabOverrideMaterialPath(path) {
+    if (!path.startsWith(EDITOR_SCENE_PREFAB_OVERRIDE_FIELD_PATH_PREFIX))
+        return null;
+    const materialPath = path.slice(EDITOR_SCENE_PREFAB_OVERRIDE_FIELD_PATH_PREFIX.length);
+    return isEditorSceneArtistMaterialPatchPath(materialPath) ? materialPath : null;
+}
+export function isEditorScenePrefabOverridePath(path) {
+    return readEditorScenePrefabOverrideMaterialPath(path) != null;
+}
+export function isEditorScenePrefabCoreMaterialOverridePath(path) {
+    const materialPath = readEditorScenePrefabOverrideMaterialPath(path);
+    if (!materialPath)
+        return false;
+    if (materialPath.endsWith('.materialAssetId'))
+        return true;
+    const profilePath = readEditorScenePrefabOverrideProfileFieldPath(path);
+    return profilePath != null && EDITOR_SCENE_PREFAB_CORE_MATERIAL_OVERRIDE_PROFILE_FIELD_PATHS.has(profilePath);
+}
+export function readEditorScenePrefabOverrideProfileFieldPath(path) {
+    const materialPath = readEditorScenePrefabOverrideMaterialPath(path);
+    if (!materialPath)
+        return null;
+    const marker = '.override.';
+    const markerIndex = materialPath.lastIndexOf(marker);
+    if (markerIndex < 0)
+        return null;
+    const profilePath = materialPath.slice(markerIndex + marker.length);
+    return profilePath ? `profile.${profilePath}` : null;
+}
+export function patchEditorScenePrefabOverride(prefabAsset, path, value) {
+    const materialPath = readEditorScenePrefabOverrideMaterialPath(path);
+    if (!materialPath || !isEditorScenePrefabAsset(prefabAsset))
+        return prefabAsset;
+    const segments = splitEditorScenePrefabOverrideFieldPath(materialPath);
+    if (!segments)
+        return prefabAsset;
+    const next = structuredClone(prefabAsset);
+    next.prefab = structuredClone(next.prefab ?? prefabAsset.prefab);
+    applyEditorScenePrefabOverrideJsonPatch(next.prefab, segments, value);
+    const prunedOverrides = pruneEditorScenePrefabOverrides(next.prefab?.overrides);
+    if (prunedOverrides) {
+        next.prefab.overrides = prunedOverrides;
+    }
+    else {
+        delete next.prefab.overrides;
+    }
+    return JSON.stringify(next) === JSON.stringify(prefabAsset) ? prefabAsset : next;
+}
+export function mergeEditorSceneMaterialBindingOverrides(base, override) {
+    const baseMaterialAssetId = readEditorSceneNonEmptyString(base?.materialAssetId);
+    const overrideMaterialAssetId = readEditorSceneNonEmptyString(override?.materialAssetId);
+    const profile = mergeArtistMaterialProfiles(base?.override, override?.override);
+    return pruneEditorSceneMaterialBinding({
+        ...(overrideMaterialAssetId ?? baseMaterialAssetId
+            ? { materialAssetId: overrideMaterialAssetId ?? baseMaterialAssetId }
+            : {}),
+        ...(hasEditorSceneObjectFields(profile) ? { override: profile } : {}),
+    });
+}
+export function mergeEditorScenePrefabOverrides(base, override) {
+    const next = {};
+    const materialBinding = mergeEditorSceneMaterialBindingOverrides(base?.materialBinding, override?.materialBinding);
+    if (materialBinding)
+        next.materialBinding = materialBinding;
+    const materialSlotBindings = mergeEditorSceneMaterialBindingRecords(base?.materialSlotBindings, override?.materialSlotBindings);
+    if (materialSlotBindings)
+        next.materialSlotBindings = materialSlotBindings;
+    const childMaterialBindings = mergeEditorSceneMaterialBindingRecords(base?.childMaterialBindings, override?.childMaterialBindings);
+    if (childMaterialBindings)
+        next.childMaterialBindings = childMaterialBindings;
+    return hasEditorSceneObjectFields(next) ? next : undefined;
+}
+export function resolveEditorScenePrefabInstanceEffectiveOverrides(document, gameObjectId) {
+    const relation = resolveEditorScenePrefabInstanceRelation(document, gameObjectId);
+    if (!relation.gameObject || !relation.prefab)
+        return undefined;
+    return mergeEditorScenePrefabOverrides(relation.definition?.prefab?.overrides, readEditorScenePrefabOverrides(relation.gameObject.overrides));
+}
+export function createEditorScenePrefabAgentSummary(document, gameObjectId) {
+    const relation = resolveEditorScenePrefabInstanceRelation(document, gameObjectId);
+    if (!relation.gameObject || !relation.prefab)
+        return null;
+    const errorCount = relation.diagnostics.filter(diagnostic => diagnostic.severity === 'error').length;
+    const warningCount = relation.diagnostics.filter(diagnostic => diagnostic.severity === 'warning').length;
+    const sourceAssetId = resolveEditorScenePrefabSourceAssetId(relation.definition)
+        ?? readEditorSceneNonEmptyString(relation.prefab.sourceAssetId)
+        ?? undefined;
+    const effectiveOverrides = resolveEditorScenePrefabInstanceEffectiveOverrides(document, gameObjectId);
+    const summary = {
+        kind: 'prefab-instance',
+        status: errorCount > 0 ? 'error' : warningCount > 0 ? 'warning' : 'ok',
+        prefabId: relation.prefab.prefabId,
+        ...(relation.prefab.prefabGuid ? { prefabGuid: relation.prefab.prefabGuid } : {}),
+        ...(readEditorSceneNonEmptyString(relation.definition?.displayName)
+            ? { prefabDisplayName: readEditorSceneNonEmptyString(relation.definition?.displayName) }
+            : {}),
+        ...(sourceAssetId ? { sourceAssetId } : {}),
+        ...(readEditorSceneNonEmptyString(relation.sourceAsset?.guid) ? { sourceAssetGuid: readEditorSceneNonEmptyString(relation.sourceAsset?.guid) } : {}),
+        ...(readEditorSceneNonEmptyString(relation.sourceAsset?.displayName)
+            ? { sourceAssetDisplayName: readEditorSceneNonEmptyString(relation.sourceAsset?.displayName) }
+            : {}),
+        ...(readEditorSceneNonEmptyString(relation.prefab.sourceAssetId) ? { instanceSourceAssetId: readEditorSceneNonEmptyString(relation.prefab.sourceAssetId) } : {}),
+        diagnostics: relation.diagnostics.map(diagnostic => ({ ...diagnostic })),
+        materialTargets: createEditorScenePrefabAgentMaterialTargets(relation.sourceAsset),
+        ...(effectiveOverrides ? { effectiveOverrides } : {}),
+    };
+    return summary;
+}
+export function resolveEditorScenePrefabInstanceRelation(document, gameObjectId) {
+    const gameObject = findEditorSceneGameObject(document, gameObjectId);
+    const diagnostics = [];
+    const prefab = isEditorScenePrefabInstance(gameObject) ? gameObject.prefab : null;
+    if (!gameObject || !prefab) {
+        diagnostics.push({
+            code: 'not-prefab-instance',
+            severity: 'info',
+            message: gameObject
+                ? `GameObject "${gameObject.id}" is not a prefab instance.`
+                : `GameObject "${gameObjectId}" was not found.`,
+        });
+        return {
+            gameObject,
+            prefab: null,
+            definition: null,
+            sourceAsset: null,
+            diagnostics,
+        };
+    }
+    const definition = document.assets.find(asset => asset.id === prefab.prefabId && isEditorScenePrefabAsset(asset));
+    if (!definition) {
+        diagnostics.push({
+            code: 'missing-prefab-definition',
+            severity: 'error',
+            message: `Prefab definition "${prefab.prefabId}" was not found.`,
+            prefabId: prefab.prefabId,
+        });
+    }
+    const expectedSourceAssetId = resolveEditorScenePrefabSourceAssetId(definition) ?? readEditorSceneNonEmptyString(prefab.sourceAssetId);
+    if (definition && prefab.sourceAssetId && expectedSourceAssetId && prefab.sourceAssetId !== expectedSourceAssetId) {
+        diagnostics.push({
+            code: 'source-asset-mismatch',
+            severity: 'warning',
+            message: `Prefab instance source "${prefab.sourceAssetId}" does not match definition source "${expectedSourceAssetId}".`,
+            prefabId: prefab.prefabId,
+            expectedSourceAssetId,
+            actualSourceAssetId: prefab.sourceAssetId,
+        });
+    }
+    const sourceAsset = expectedSourceAssetId
+        ? document.assets.find(asset => asset.id === expectedSourceAssetId)
+        : undefined;
+    if (expectedSourceAssetId && !sourceAsset) {
+        diagnostics.push({
+            code: 'missing-source-asset',
+            severity: 'error',
+            message: `Prefab source asset "${expectedSourceAssetId}" was not found.`,
+            prefabId: prefab.prefabId,
+            sourceAssetId: expectedSourceAssetId,
+        });
+    }
+    if (expectedSourceAssetId) {
+        const sourcePrefabIds = document.assets
+            .filter(asset => isEditorScenePrefabAsset(asset) && resolveEditorScenePrefabSourceAssetId(asset) === expectedSourceAssetId)
+            .map(asset => asset.id);
+        if (sourcePrefabIds.length > 1) {
+            diagnostics.push({
+                code: 'duplicate-source-prefab',
+                severity: 'info',
+                message: `Source asset "${expectedSourceAssetId}" is referenced by ${sourcePrefabIds.length} prefab definitions.`,
+                prefabId: prefab.prefabId,
+                sourceAssetId: expectedSourceAssetId,
+            });
+        }
+    }
+    return {
+        gameObject,
+        prefab,
+        definition: definition ?? null,
+        sourceAsset: sourceAsset ?? null,
+        diagnostics,
+    };
+}
+function createEditorScenePrefabAgentMaterialTargets(sourceAsset) {
+    const rawSlots = Array.isArray(sourceAsset?.metadata?.materialSlots) ? sourceAsset.metadata.materialSlots : [];
+    const targets = [];
+    for (const [index, rawSlot] of rawSlots.entries()) {
+        const slot = readEditorScenePrefabAgentMaterialSlot(rawSlot);
+        if (!slot)
+            continue;
+        const targetKey = slot.slotId ?? slot.ownerNodePath;
+        const bindingPath = slot.slotId
+            ? `prefab.overrides.materialSlotBindings.${slot.slotId}`
+            : `prefab.overrides.childMaterialBindings.${slot.ownerNodePath}`;
+        targets.push({
+            kind: slot.slotId ? 'material-slot' : 'owner-node-path',
+            label: slot.label ?? slot.materialName ?? slot.ownerNodePath ?? `Material Slot ${index + 1}`,
+            bindingPath,
+            materialAssetIdPath: `${bindingPath}.materialAssetId`,
+            overridePath: `${bindingPath}.override`,
+            ...(slot.slotId ? { slotId: slot.slotId } : {}),
+            ...(slot.ownerNodePath ? { ownerNodePath: slot.ownerNodePath } : {}),
+            ...(slot.sourceMaterialIndex != null ? { sourceMaterialIndex: slot.sourceMaterialIndex } : {}),
+            ...(slot.materialName ? { sourceMaterialName: slot.materialName } : {}),
+        });
+        if (!targetKey)
+            targets.pop();
+    }
+    return targets;
+}
+function readEditorScenePrefabAgentMaterialSlot(value) {
+    if (typeof value === 'string') {
+        const ownerNodePath = normalizeEditorSceneMaterialSlotOwnerPath(readEditorSceneNonEmptyString(value) ?? '');
+        return ownerNodePath ? { ownerNodePath } : null;
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const record = value;
+    const ownerNodePath = normalizeEditorSceneMaterialSlotOwnerPath(readEditorSceneNonEmptyString(record.ownerNodePath)
+        ?? readEditorSceneNonEmptyString(record.path)
+        ?? readEditorSceneNonEmptyString(record.name)
+        ?? '');
+    const slotId = readEditorSceneNonEmptyString(record.slotId) ?? undefined;
+    if (!slotId && !ownerNodePath)
+        return null;
+    const label = readEditorSceneNonEmptyString(record.label) ?? undefined;
+    const materialName = readEditorSceneNonEmptyString(record.materialName) ?? undefined;
+    const sourceMaterialIndex = Number.isInteger(record.sourceMaterialIndex) ? record.sourceMaterialIndex : undefined;
+    return {
+        ...(slotId ? { slotId } : {}),
+        ownerNodePath,
+        ...(label ? { label } : {}),
+        ...(materialName ? { materialName } : {}),
+        ...(sourceMaterialIndex != null ? { sourceMaterialIndex } : {}),
+    };
+}
 export function readEditorSceneNodeKind(gameObject) {
     if (gameObject.kind === 'group'
         || gameObject.kind === 'instance'
@@ -14,6 +957,8 @@ export function readEditorSceneNodeKind(gameObject) {
         || gameObject.kind === 'primitive') {
         return gameObject.kind;
     }
+    if (isEditorScenePrefabInstance(gameObject))
+        return 'instance';
     if (gameObject.primitive)
         return 'primitive';
     if (findEditorSceneModelRenderer(gameObject))
@@ -27,8 +972,7 @@ export function resolveEditorSceneGameObjectRendering(gameObject) {
         ? gameObject.rendering
         : undefined;
     const renderingGroupId = readEditorSceneGameObjectRenderingGroupId(rendering?.renderingGroupId);
-    const alphaIndex = readEditorSceneFiniteNumber(rendering?.alphaIndex)
-        ?? readEditorSceneLegacyGroundDecalAlphaIndex(gameObject);
+    const alphaIndex = readEditorSceneFiniteNumber(rendering?.alphaIndex);
     const resolved = {};
     if (renderingGroupId != null)
         resolved.renderingGroupId = renderingGroupId;
@@ -48,13 +992,204 @@ function isEditorSceneTransformComponent(component) {
 function isEditorSceneModelRendererComponent(component) {
     return component.type === 'ModelRenderer';
 }
-function readEditorSceneLegacyGroundDecalAlphaIndex(gameObject) {
-    const groundDecal = gameObject.groundDecal;
-    if (!groundDecal || typeof groundDecal !== 'object' || Array.isArray(groundDecal))
-        return null;
-    return readEditorSceneFiniteNumber(groundDecal.alphaIndex);
-}
 function readEditorSceneFiniteNumber(value) {
     return typeof value === 'number' && Number.isFinite(value) ? value : null;
 }
+function readEditorSceneNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
+}
+function normalizeEditorScenePrefabEditableName(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 findEditorSceneGameObject(document, gameObjectId) {
+    return document.scene.gameObjects.find(gameObject => gameObject.id === gameObjectId) ?? null;
+}
+function createEditorScenePrefabDisplayName(sourceAsset) {
+    const displayName = readEditorSceneNonEmptyString(sourceAsset.displayName)
+        ?? readEditorSceneNonEmptyString(sourceAsset.id)
+        ?? 'Prefab';
+    return `${displayName} Prefab`;
+}
+function createEditorScenePrefabGuid() {
+    const randomId = globalThis.crypto?.randomUUID?.() ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+    return `prefab_${randomId}`;
+}
+function createUniqueEditorScenePrefabAssetId(document, preferredId) {
+    const used = new Set(document.assets.map(asset => asset.id));
+    const base = normalizeEditorScenePrefabIdentifierPart(preferredId) ?? 'prefab';
+    if (!used.has(base))
+        return base;
+    let suffix = 1;
+    let candidate = `${base}_${suffix}`;
+    while (used.has(candidate)) {
+        suffix += 1;
+        candidate = `${base}_${suffix}`;
+    }
+    return candidate;
+}
+function createUniqueEditorScenePrefabDisplayName(existingNames, preferredName) {
+    const used = new Set(existingNames
+        .map(name => readEditorSceneNonEmptyString(name))
+        .filter((name) => !!name));
+    if (!used.has(preferredName))
+        return preferredName;
+    let suffix = 1;
+    let candidate = `${preferredName} ${suffix}`;
+    while (used.has(candidate)) {
+        suffix += 1;
+        candidate = `${preferredName} ${suffix}`;
+    }
+    return candidate;
+}
+function normalizeEditorScenePrefabIdentifierPart(value) {
+    const raw = readEditorSceneNonEmptyString(value);
+    if (!raw)
+        return null;
+    const normalized = raw
+        .replace(/\s+/g, '_')
+        .replace(/[^a-zA-Z0-9_:-]/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_+|_+$/g, '');
+    return normalized || null;
+}
+function splitEditorScenePrefabOverrideFieldPath(path) {
+    if (path === 'overrides.materialBinding.materialAssetId') {
+        return ['overrides', 'materialBinding', 'materialAssetId'];
+    }
+    const rootOverridePrefix = 'overrides.materialBinding.override.';
+    if (path.startsWith(rootOverridePrefix)) {
+        const profilePath = path.slice(rootOverridePrefix.length);
+        return splitEditorScenePrefabProfilePath(['overrides', 'materialBinding', 'override'], profilePath);
+    }
+    const slotMaterialAssetId = readEditorSceneMaterialSlotBindingSlotId(path, 'materialAssetId');
+    if (slotMaterialAssetId) {
+        return ['overrides', 'materialSlotBindings', slotMaterialAssetId, 'materialAssetId'];
+    }
+    const slotOverrideId = readEditorSceneMaterialSlotBindingSlotId(path, 'override');
+    if (slotOverrideId) {
+        const profilePath = readEditorSceneBindingOverrideProfilePath(path);
+        return profilePath
+            ? splitEditorScenePrefabProfilePath(['overrides', 'materialSlotBindings', slotOverrideId, 'override'], profilePath)
+            : null;
+    }
+    const childMaterialAssetId = readEditorSceneChildMaterialBindingOwnerPath(path, 'materialAssetId');
+    if (childMaterialAssetId) {
+        return ['overrides', 'childMaterialBindings', childMaterialAssetId, 'materialAssetId'];
+    }
+    const childOverrideOwnerPath = readEditorSceneChildMaterialBindingOwnerPath(path, 'override');
+    if (childOverrideOwnerPath) {
+        const profilePath = readEditorSceneBindingOverrideProfilePath(path);
+        return profilePath
+            ? splitEditorScenePrefabProfilePath(['overrides', 'childMaterialBindings', childOverrideOwnerPath, 'override'], profilePath)
+            : null;
+    }
+    return null;
+}
+function readEditorSceneBindingOverrideProfilePath(path) {
+    const marker = '.override.';
+    const markerIndex = path.lastIndexOf(marker);
+    if (markerIndex < 0)
+        return null;
+    const profilePath = path.slice(markerIndex + marker.length);
+    return profilePath ? profilePath : null;
+}
+function splitEditorScenePrefabProfilePath(prefix, profilePath) {
+    const profileSegments = profilePath.split('.').filter(Boolean);
+    if (profileSegments.length === 0 || profileSegments.some(isUnsafeEditorScenePrefabOverridePathSegment))
+        return null;
+    return [...prefix, ...profileSegments];
+}
+function applyEditorScenePrefabOverrideJsonPatch(target, segments, value) {
+    if (segments.some(isUnsafeEditorScenePrefabOverridePathSegment))
+        return;
+    let cursor = target;
+    for (const segment of segments.slice(0, -1)) {
+        const current = cursor[segment];
+        if (!current || typeof current !== 'object' || Array.isArray(current)) {
+            cursor[segment] = {};
+        }
+        cursor = cursor[segment];
+    }
+    const leaf = segments[segments.length - 1];
+    if (!leaf)
+        return;
+    if (value == null)
+        delete cursor[leaf];
+    else
+        cursor[leaf] = structuredClone(value);
+}
+function pruneEditorScenePrefabOverrides(overrides) {
+    if (!overrides || typeof overrides !== 'object' || Array.isArray(overrides))
+        return undefined;
+    const source = overrides;
+    const next = {};
+    const materialBinding = pruneEditorSceneMaterialBinding(source.materialBinding);
+    if (materialBinding)
+        next.materialBinding = materialBinding;
+    const materialSlotBindings = pruneEditorSceneMaterialBindingRecord(source.materialSlotBindings);
+    if (materialSlotBindings)
+        next.materialSlotBindings = materialSlotBindings;
+    const childMaterialBindings = pruneEditorSceneMaterialBindingRecord(source.childMaterialBindings);
+    if (childMaterialBindings)
+        next.childMaterialBindings = childMaterialBindings;
+    return hasEditorSceneObjectFields(next) ? next : undefined;
+}
+function pruneEditorSceneMaterialBinding(binding) {
+    if (!binding || typeof binding !== 'object' || Array.isArray(binding))
+        return undefined;
+    const source = binding;
+    const materialAssetId = readEditorSceneNonEmptyString(source.materialAssetId);
+    const profile = mergeArtistMaterialProfiles(source.override);
+    const next = {
+        ...(materialAssetId ? { materialAssetId } : {}),
+        ...(hasEditorSceneObjectFields(profile) ? { override: profile } : {}),
+    };
+    return hasEditorSceneObjectFields(next) ? next : undefined;
+}
+function pruneEditorSceneMaterialBindingRecord(record) {
+    if (!record || typeof record !== 'object' || Array.isArray(record))
+        return undefined;
+    const next = {};
+    for (const [key, binding] of Object.entries(record)) {
+        const normalizedKey = readEditorSceneNonEmptyString(key);
+        if (!normalizedKey)
+            continue;
+        const prunedBinding = pruneEditorSceneMaterialBinding(binding);
+        if (prunedBinding)
+            next[normalizedKey] = prunedBinding;
+    }
+    return hasEditorSceneObjectFields(next) ? next : undefined;
+}
+function mergeEditorSceneMaterialBindingRecords(base, override) {
+    const keys = new Set([
+        ...Object.keys(base ?? {}),
+        ...Object.keys(override ?? {}),
+    ]);
+    const next = {};
+    for (const key of keys) {
+        const binding = mergeEditorSceneMaterialBindingOverrides(base?.[key], override?.[key]);
+        if (binding)
+            next[key] = binding;
+    }
+    return hasEditorSceneObjectFields(next) ? next : undefined;
+}
+function readEditorScenePrefabOverrides(value) {
+    return pruneEditorScenePrefabOverrides(value);
+}
+function hasEditorSceneObjectFields(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length > 0;
+}
+function isUnsafeEditorScenePrefabOverridePathSegment(segment) {
+    return segment === '__proto__' || segment === 'prototype' || segment === 'constructor';
+}
 //# sourceMappingURL=helpers.js.map