@fps-games/editor 0.2.0-beta.3 → 0.2.1-beta.1

package/node_modules/@fps-games/editor-playable-sdk/dist/scene-compiler/compiler.js

@@ -1,12 +1,27 @@
-import { findEditorSceneModelRenderer, findEditorSceneTransform, EDITOR_SCENE_PREFAB_COMPOSITION_VERSION, isEditorScenePrefabAsset, mergeEditorSceneMaterialBindingOverrides, mergeEditorScenePrefabOverrides, readEditorSceneNodeKind, readEditorScenePrefabNodes, readEditorScenePrefabRootNodeId, resolveEditorSceneGameObjectRendering, resolveEditorScenePrefabInstanceRelation, } from '../document/index.js';
+import { findEditorSceneModelRenderer, findEditorSceneTransform, EDITOR_SCENE_PREFAB_COMPOSITION_VERSION, isEditorScenePrefabAsset, mergeEditorSceneMaterialBindingOverrides, mergeEditorScenePrefabOverrides, readEditorSceneNodeKind, readEditorScenePrefabNodes, createEditorScenePrefabInstanceScopedNodeId, rebaseEditorScenePrefabMarkerConfig, readEditorScenePrefabRootNodeId, resolveEditorSceneGameObjectRendering, resolveEditorScenePrefabInstanceRelation, } from '../document/index.js';
 import { resolveEditorSceneMaterialAssetIntegrity, } from '../material-binding/index.js';
 import { resolveEditorShadowPlan, } from '../shadow-system/index.js';
-import { mergeEditorShadowSettings, readEditorShadowSettingsResult, } from '@fps-games/playable-rendering';
+import { FPS_SHADOW_MAP_EXPERIMENT_PLUGIN_ID, FPS_SHADOW_MAP_EXPERIMENT_PLAN_SCHEMA_VERSION, mergeEditorShadowSettings, readEditorShadowSettingsResult, resolveShadowMapExperimentPlan, } from '@fps-games/playable-rendering';
 import { getEditorSceneAuthoringSourceRef, } from '../authoring/index.js';
-import { assertPlayableEditorSceneDocumentContract } from './validation.js';
+import { assertPlayableEditorRuntimeSceneConfig, assertPlayableEditorSceneDocumentContract, } from './validation.js';
 import { assertEditorSceneStaticShadowArtifactContract } from '../static-shadows/index.js';
 export const PLAYABLE_EDITOR_SCENE_COMPILER_ID = '@fps-games/editor.playable-sdk.scene-compiler';
 export const PLAYABLE_EDITOR_SCENE_COMPILER_VERSION = '2';
+export function resolveEditorSceneGameObjectRuntimeEntityIds(editorDocument, gameObjectId) {
+    const compilerDocument = editorDocument;
+    const gameObject = compilerDocument.scene.gameObjects.find(candidate => candidate.id === gameObjectId);
+    if (!gameObject)
+        return [];
+    const materialAssets = resolveCompiledEditorSceneMaterialAssets(compilerDocument);
+    const documentWithResolvedMaterialAssets = {
+        ...compilerDocument,
+        scene: {
+            ...compilerDocument.scene,
+            materialAssets,
+        },
+    };
+    return compileGameObjectToRuntimeNodes(gameObject, getEditorSceneAuthoringSourceRef(compilerDocument), documentWithResolvedMaterialAssets, {}).map(node => node.id);
+}
 export function compileEditorSceneDocumentToSceneConfig(editorDocument, baseSceneConfig, options = {}) {
     assertPlayableEditorSceneDocumentContract(editorDocument);
     const baseSceneRecord = baseSceneConfig;
@@ -41,17 +56,22 @@ export function compileEditorSceneDocumentToSceneConfig(editorDocument, baseScen
         },
     };
     const compiledNodes = compiledGameObjects.flatMap(gameObject => compileGameObjectToRuntimeNodes(gameObject, sourceRef, documentWithResolvedMaterialAssets, options));
+    const runtimeNodes = compiledNodes.map(stripShadowMapExperimentCompilerMetadata);
+    assertUniqueEditorSceneRuntimeNodeIds(rootId, runtimeNodes);
+    assertIsolatedEditorScenePrefabMarkerTargets(rootId, runtimeNodes);
     const compiledScene = {
         rootId,
         assets: documentWithResolvedMaterialAssets.assets
             .filter(isEditorSceneModelAsset)
             .map(compileAsset),
-        nodes: compiledNodes,
+        nodes: runtimeNodes,
         materialAssets,
         materials: previousScene?.materials ?? [],
         textures: previousScene?.textures ?? [],
     };
     nextSceneConfig.scene = compiledScene;
+    nextSceneConfig.plugins = compileShadowMapExperimentPluginEntries(nextSceneConfig.plugins, options.shadowMapExperimentConfig, documentWithResolvedMaterialAssets.scene.shadowMapExperiment, compiledNodes, rootId, sourceRef.revision);
+    assertPlayableEditorRuntimeSceneConfig(nextSceneConfig);
     return {
         sceneConfig: nextSceneConfig,
         summary: {
@@ -61,6 +81,54 @@ export function compileEditorSceneDocumentToSceneConfig(editorDocument, baseScen
         },
     };
 }
+function stripShadowMapExperimentCompilerMetadata(node) {
+    if (!Object.prototype.hasOwnProperty.call(node, 'shadowMapExperiment')
+        && !Object.prototype.hasOwnProperty.call(node, 'shadowMapExperimentInferredUpdateClass'))
+        return node;
+    const { shadowMapExperiment: _compilerMetadata, shadowMapExperimentInferredUpdateClass: _inferredUpdateClass, ...runtimeNode } = node;
+    return runtimeNode;
+}
+function assertUniqueEditorSceneRuntimeNodeIds(rootId, nodes) {
+    const ids = new Set([rootId]);
+    for (let index = 0; index < nodes.length; index += 1) {
+        const nodeId = nodes[index].id;
+        if (ids.has(nodeId)) {
+            const error = new Error(`schema.invalidReference: $.scene.nodes[${index}].id`);
+            Object.assign(error, { code: 'schema.invalidReference', path: `$.scene.nodes[${index}].id`, nodeId });
+            throw error;
+        }
+        ids.add(nodeId);
+    }
+}
+function assertIsolatedEditorScenePrefabMarkerTargets(rootId, nodes) {
+    const nodesById = new Map(nodes.map(node => [node.id, node]));
+    for (let index = 0; index < nodes.length; index += 1) {
+        const markerNode = nodes[index];
+        if (markerNode.source?.component !== 'PrefabMarker' || !('marker' in markerNode) || !markerNode.marker)
+            continue;
+        for (const entry of listEditorSceneRuntimeMarkerTargets(markerNode.marker)) {
+            const targetNode = nodesById.get(entry.target.id);
+            if (entry.target.id !== rootId && (!targetNode || targetNode.source?.objectId === markerNode.source.objectId))
+                continue;
+            const path = `$.scene.nodes[${index}].marker.${entry.path}.id`;
+            const error = new Error(`schema.invalidReference: ${path}`);
+            Object.assign(error, { code: 'schema.invalidReference', path, nodeId: markerNode.id, targetId: entry.target.id });
+            throw error;
+        }
+    }
+}
+function listEditorSceneRuntimeMarkerTargets(marker) {
+    const targets = [];
+    if (marker.target)
+        targets.push({ path: 'target', target: marker.target });
+    if (marker.geometry.kind === 'point' && marker.geometry.target) {
+        targets.push({ path: 'geometry.target', target: marker.geometry.target });
+    }
+    if (marker.geometry.kind === 'object-bounds') {
+        targets.push({ path: 'geometry.target', target: marker.geometry.target });
+    }
+    return targets;
+}
 function resolveCompiledEditorSceneMaterialAssets(editorDocument) {
     const materialAssets = structuredClone(editorDocument.scene.materialAssets ?? []);
     const integrity = resolveEditorSceneMaterialAssetIntegrity(createEditorSceneCompilerMaterialIntegrityDocument(editorDocument, materialAssets));
@@ -176,6 +244,7 @@ function compileAsset(asset) {
     const url = readEditorSceneRuntimeAssetUrl(asset);
     const materialSlots = compileEditorSceneRuntimeMaterialSlots(asset);
     const external = compileEditorSceneRuntimeAssetExternal(asset.external);
+    const defaults = compileEditorSceneRuntimeAssetDefaults(asset.defaults);
     return {
         id: asset.id,
         type: asset.type,
@@ -186,11 +255,20 @@ function compileAsset(asset) {
             : {}),
         ...(typeof asset.singleton === 'boolean' ? { singleton: asset.singleton } : {}),
         ...(typeof asset.materialMode === 'string' ? { materialMode: asset.materialMode } : {}),
-        ...(asset.defaults ? { defaults: structuredClone(asset.defaults) } : {}),
+        ...(defaults !== undefined ? { defaults } : {}),
         ...(external ? { external } : {}),
         ...(materialSlots.length > 0 ? { materialSlots } : {}),
     };
 }
+function compileEditorSceneRuntimeAssetDefaults(value) {
+    if (!value)
+        return undefined;
+    const defaults = structuredClone(value);
+    if (!isRecord(defaults))
+        return defaults;
+    delete defaults.shadowMapExperiment;
+    return Object.keys(defaults).length > 0 ? defaults : undefined;
+}
 function compileEditorSceneRuntimeAssetExternal(value) {
     const external = isRecord(value) ? value : undefined;
     const platformAssetId = readNonEmptyString(external?.platformAssetId);
@@ -259,10 +337,23 @@ function readNonNegativeInteger(value) {
 }
 function compileGameObjectToRuntimeNodes(gameObject, sourceRef, editorDocument, options) {
     const relation = resolveEditorScenePrefabInstanceRelation(editorDocument, gameObject.id);
-    if (relation.definition && isExplicitEditorScenePrefabCompositionAsset(relation.definition)) {
-        return compileEditorScenePrefabCompositionInstance(gameObject, relation.definition, sourceRef, editorDocument, new Set());
-    }
-    return [compileGameObject(gameObject, sourceRef, editorDocument, options)];
+    const compiledNodes = relation.definition && isExplicitEditorScenePrefabCompositionAsset(relation.definition)
+        ? compileEditorScenePrefabCompositionInstance(gameObject, relation.definition, sourceRef, editorDocument, new Set())
+        : [compileGameObject(gameObject, sourceRef, editorDocument, options)];
+    return compiledNodes.map((node) => {
+        const asset = node.kind === 'instance'
+            ? editorDocument.assets.find(candidate => candidate.id === node.instance.assetId)
+            : undefined;
+        const inferredUpdateClass = options.inferShadowMapExperimentUpdateClass?.({
+            gameObject,
+            runtimeNode: stripShadowMapExperimentCompilerMetadata(node),
+            ...(asset ? { asset } : {}),
+        }) ?? inferShadowMapExperimentUpdateClassFromAsset(asset);
+        return {
+            ...node,
+            shadowMapExperimentInferredUpdateClass: inferredUpdateClass,
+        };
+    });
 }
 function compileGameObject(gameObject, sourceRef, editorDocument, options = {}) {
     const transform = findEditorSceneTransform(gameObject);
@@ -271,6 +362,7 @@ function compileGameObject(gameObject, sourceRef, editorDocument, options = {})
     const nodeKind = readEditorSceneNodeKind(gameObject);
     const visualOverrides = compileEditorSceneVisualOverrides(gameObject, editorDocument);
     const rendering = resolveEditorSceneGameObjectRendering(gameObject);
+    const shadowMapExperiment = resolveEditorSceneGameObjectShadowMapExperimentOverride(editorDocument, gameObject);
     const source = {
         sourceId: sourceRef.sourceId,
         sourceType: sourceRef.sourceType,
@@ -285,6 +377,9 @@ function compileGameObject(gameObject, sourceRef, editorDocument, options = {})
         ...(gameObject.parentId ? { parentId: gameObject.parentId } : {}),
         ...(gameObject.active === false ? { enabled: false } : {}),
         ...(gameObject.shadow ? { shadow: structuredClone(gameObject.shadow) } : {}),
+        ...(shadowMapExperiment ? {
+            shadowMapExperiment: structuredClone(shadowMapExperiment),
+        } : {}),
         ...compileEditorSceneGameObjectShadowPlan(editorDocument, gameObject),
         ...(rendering ? { rendering } : {}),
         source,
@@ -310,10 +405,15 @@ function compileGameObject(gameObject, sourceRef, editorDocument, options = {})
     }
     if (!modelRenderer) {
         if (nodeKind === 'transform') {
+            const customRuntimeData = readEditorSceneCompilerCustomTransformRuntimeData(gameObject, options);
+            const customTransformType = customRuntimeData.transformType;
+            delete customRuntimeData.transformType;
+            const transformType = readPlayableEditorRuntimeTransformType(customTransformType)
+                ?? readPlayableEditorRuntimeTransformType(gameObject.transformType);
             return {
                 ...base,
                 kind: 'transform',
-                ...(typeof gameObject.transformType === 'string' ? { transformType: gameObject.transformType } : {}),
+                ...(transformType ? { transformType } : {}),
                 ...(gameObject.camera ? { camera: compileEditorSceneCamera(gameObject.camera) } : {}),
                 ...(gameObject.light ? { light: compileEditorSceneLight(gameObject.light) } : {}),
                 ...(gameObject.marker ? {
@@ -322,7 +422,7 @@ function compileGameObject(gameObject, sourceRef, editorDocument, options = {})
                         ...structuredClone(gameObject.marker),
                     },
                 } : {}),
-                ...readEditorSceneCompilerCustomTransformRuntimeData(gameObject, options),
+                ...customRuntimeData,
                 ...(visualOverrides ? { overrides: visualOverrides } : {}),
             };
         }
@@ -340,6 +440,93 @@ function compileGameObject(gameObject, sourceRef, editorDocument, options = {})
         ...(visualOverrides ? { overrides: visualOverrides } : {}),
     };
 }
+function compileShadowMapExperimentPluginEntries(existing, config, settingsValue, nodes, scopeId, revisionValue) {
+    const entries = (existing ?? []).filter(entry => entry.pluginId !== FPS_SHADOW_MAP_EXPERIMENT_PLUGIN_ID);
+    if (!config)
+        return entries;
+    const settings = settingsValue;
+    const referencedLightNode = nodes.find(node => node.id === config.lightRef);
+    const lightNode = referencedLightNode?.kind === 'transform'
+        && referencedLightNode.light?.type === 'directional'
+        ? referencedLightNode
+        : undefined;
+    if (!referencedLightNode && config.enabled) {
+        throw new Error(`shadowMapExperiment.lightMissing:${config.lightRef}`);
+    }
+    if (referencedLightNode && !lightNode && config.enabled) {
+        throw new Error(`shadowMapExperiment.lightUnsupported:${config.lightRef}`);
+    }
+    const direction = lightNode?.kind === 'transform' && lightNode.light?.type === 'directional'
+        ? [lightNode.light.direction.x, lightNode.light.direction.y, lightNode.light.direction.z]
+        : [0, -1, 0];
+    const plan = resolveShadowMapExperimentPlan({
+        revision: typeof revisionValue === 'number' && Number.isInteger(revisionValue) && revisionValue >= 0
+            ? revisionValue
+            : 0,
+        scopeId,
+        config,
+        settings,
+        lightDirection: direction,
+        objects: nodes
+            .filter(node => node.kind === 'instance' || node.kind === 'primitive')
+            .map(node => ({
+            entityId: node.id,
+            renderableIds: [node.id],
+            ...(node.shadowMapExperiment ? { override: node.shadowMapExperiment } : {}),
+            ...resolveShadowMapExperimentAuthoredFlags(node.shadow),
+            inferredUpdateClass: node.shadowMapExperimentInferredUpdateClass ?? 'static',
+        })),
+    });
+    return [
+        ...entries,
+        {
+            pluginId: FPS_SHADOW_MAP_EXPERIMENT_PLUGIN_ID,
+            schemaVersion: FPS_SHADOW_MAP_EXPERIMENT_PLAN_SCHEMA_VERSION,
+            data: plan,
+        },
+    ];
+}
+function resolveShadowMapExperimentAuthoredFlags(shadow) {
+    return {
+        ...(shadow?.cast === 'none' ? { cast: false } : shadow?.cast === 'enabled' ? { cast: true } : {}),
+        ...(shadow?.receive === 'none' ? { receive: false } : shadow?.receive === 'enabled' ? { receive: true } : {}),
+    };
+}
+function inferShadowMapExperimentUpdateClassFromAsset(asset) {
+    const analysis = isRecord(asset?.metadata?.assetAnalysis)
+        ? asset.metadata.assetAnalysis
+        : undefined;
+    if (!analysis)
+        return 'static';
+    const skinCount = readNonNegativeNumber(analysis.skinCount);
+    const morphTargetCount = readNonNegativeNumber(analysis.morphTargetCount);
+    if (skinCount > 0 || morphTargetCount > 0)
+        return 'skinned';
+    return readNonNegativeNumber(analysis.animationCount) > 0 ? 'dynamic' : 'static';
+}
+function readNonNegativeNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+function mergeShadowMapExperimentOverrides(...values) {
+    for (let index = values.length - 1; index >= 0; index -= 1) {
+        if (values[index])
+            return values[index];
+    }
+    return undefined;
+}
+function resolveEditorSceneGameObjectShadowMapExperimentOverride(document, gameObject) {
+    const modelRenderer = findEditorSceneModelRenderer(gameObject);
+    const relation = resolveEditorScenePrefabInstanceRelation(document, gameObject.id);
+    const sourceAsset = relation.sourceAsset
+        ?? (modelRenderer ? document.assets.find(asset => asset.id === modelRenderer.assetId) : undefined);
+    return mergeShadowMapExperimentOverrides(readEditorSceneAssetShadowMapExperimentOverride(sourceAsset), relation.definition?.prefab?.defaults?.shadowMapExperiment, gameObject.shadowMapExperiment);
+}
+function readEditorSceneAssetShadowMapExperimentOverride(asset) {
+    if (!asset || !isRecord(asset.defaults))
+        return undefined;
+    const value = asset.defaults.shadowMapExperiment;
+    return isRecord(value) ? value : undefined;
+}
 function compileEditorScenePrefabCompositionInstance(gameObject, prefabAsset, sourceRef, editorDocument, visitedPrefabIds) {
     return compileEditorScenePrefabCompositionNodes({
         prefabAsset,
@@ -352,6 +539,7 @@ function compileEditorScenePrefabCompositionInstance(gameObject, prefabAsset, so
         rootTransform: findEditorSceneTransform(gameObject) ?? undefined,
         rootActive: gameObject.active,
         rootShadow: gameObject.shadow,
+        rootShadowMapExperiment: gameObject.shadowMapExperiment,
         instanceOverrides: gameObject.overrides,
         propertyPathPrefix: `assets.${prefabAsset.id}.prefab.nodes`,
         visitedPrefabIds,
@@ -391,7 +579,8 @@ function compileEditorScenePrefabCompositionNodes(input) {
                 propertyPath: input.propertyPathPrefix,
             })];
     }
-    const runtimeIdForNode = (node) => node.id === rootNode.id ? input.rootRuntimeId : `${input.rootRuntimeId}:${node.id}`;
+    const identityScope = { instanceId: input.rootRuntimeId, rootNodeId: rootNode.id };
+    const runtimeIdForNode = (node) => createEditorScenePrefabInstanceScopedNodeId(identityScope, node.id);
     const orderedNodes = orderEditorScenePrefabNodesForCompile(prefabNodes, rootNode.id);
     const primaryModelNodeId = findEditorScenePrefabPrimaryModelNodeId(orderedNodes, input.prefabAsset);
     const compiledNodes = [];
@@ -400,6 +589,7 @@ function compileEditorScenePrefabCompositionNodes(input) {
         const parentId = node.id === rootNode.id
             ? input.rootParentId
             : runtimeIdForNode(prefabNodes.find(candidate => candidate.id === node.parentId) ?? rootNode);
+        const ancestorShadowMapExperiment = resolveEditorScenePrefabAncestorShadowMapExperiment(prefabNodes, node);
         if (node.kind === 'prefabInstance' && node.childPrefabId) {
             const childPrefab = input.editorDocument.assets.find(asset => asset.id === node.childPrefabId);
             if (childPrefab && isExplicitEditorScenePrefabCompositionAsset(childPrefab)) {
@@ -421,6 +611,8 @@ function compileEditorScenePrefabCompositionNodes(input) {
                     rootShadow: isRootPrefabInstance
                         ? mergeEditorShadowSettings(input.prefabAsset.prefab?.defaults?.shadow, node.defaults?.shadow, input.rootShadow)
                         : node.defaults?.shadow,
+                    inheritedShadowMapExperiment: mergeShadowMapExperimentOverrides(input.prefabAsset.prefab?.defaults?.shadowMapExperiment, input.inheritedShadowMapExperiment, ancestorShadowMapExperiment, node.defaults?.shadowMapExperiment),
+                    rootShadowMapExperiment: input.rootShadowMapExperiment,
                     instanceOverrides: isRootPrefabInstance
                         ? mergeEditorSceneCompilerVisualOverrides(mergeEditorSceneCompilerVisualOverrides(readEditorSceneCompilerVisualOverrides(input.prefabAsset.prefab?.overrides), readEditorSceneCompilerVisualOverrides(node.overrides)), readEditorSceneCompilerVisualOverrides(input.instanceOverrides))
                         : node.overrides,
@@ -445,6 +637,7 @@ function compileEditorScenePrefabCompositionNodes(input) {
         compiledNodes.push(compileEditorScenePrefabCompositionNode({
             node,
             rootNode,
+            identityScope,
             prefabAsset: input.prefabAsset,
             runtimeId,
             parentId,
@@ -455,6 +648,9 @@ function compileEditorScenePrefabCompositionNodes(input) {
             rootRuntimeTransform: input.rootTransform,
             rootRuntimeActive: input.rootActive,
             rootRuntimeShadow: input.rootShadow,
+            inheritedShadowMapExperiment: input.inheritedShadowMapExperiment,
+            compositionAncestorShadowMapExperiment: ancestorShadowMapExperiment,
+            rootRuntimeShadowMapExperiment: input.rootShadowMapExperiment,
             instanceOverrides: node.id === primaryModelNodeId ? input.instanceOverrides : undefined,
             propertyPath: `${input.propertyPathPrefix}.${node.id}`,
         }));
@@ -487,6 +683,7 @@ function compileEditorScenePrefabCompositionNode(input) {
         shadow: isRoot
             ? mergeEditorShadowSettings(input.prefabAsset.prefab?.defaults?.shadow, input.node.defaults?.shadow, input.rootRuntimeShadow)
             : mergeEditorShadowSettings(input.prefabAsset.prefab?.defaults?.shadow, input.node.defaults?.shadow),
+        shadowMapExperiment: mergeShadowMapExperimentOverrides(readEditorSceneAssetShadowMapExperimentOverride(sourceAsset), input.prefabAsset.prefab?.defaults?.shadowMapExperiment, input.inheritedShadowMapExperiment, input.compositionAncestorShadowMapExperiment, input.node.defaults?.shadowMapExperiment, input.rootRuntimeShadowMapExperiment),
         sourceAsset,
         editorDocument: input.editorDocument,
         sourceRef: input.sourceRef,
@@ -497,7 +694,9 @@ function compileEditorScenePrefabCompositionNode(input) {
                 ? 'PrefabPrimitive'
                 : input.node.kind === 'light'
                     ? 'PrefabLight'
-                    : 'PrefabNode',
+                    : input.node.kind === 'marker'
+                        ? 'PrefabMarker'
+                        : 'PrefabNode',
         propertyPath: input.propertyPath,
     });
     if (input.node.kind === 'model' && input.node.sourceAssetId) {
@@ -546,11 +745,31 @@ function compileEditorScenePrefabCompositionNode(input) {
             ...(input.node.light ? { light: compileEditorSceneLight(input.node.light) } : {}),
         };
     }
+    if (input.node.kind === 'marker' && input.node.marker) {
+        return {
+            ...base,
+            kind: 'transform',
+            marker: {
+                label: input.node.name ?? input.node.id,
+                ...rebaseEditorScenePrefabMarkerConfig(input.node.marker, input.identityScope),
+            },
+        };
+    }
     return {
         ...base,
         kind: 'group',
     };
 }
+function resolveEditorScenePrefabAncestorShadowMapExperiment(nodes, node) {
+    const byId = new Map(nodes.map(candidate => [candidate.id, candidate]));
+    const ancestors = [];
+    let current = node.parentId ? byId.get(node.parentId) : undefined;
+    while (current) {
+        ancestors.unshift(current);
+        current = current.parentId ? byId.get(current.parentId) : undefined;
+    }
+    return mergeShadowMapExperimentOverrides(...ancestors.map(ancestor => ancestor.defaults?.shadowMapExperiment));
+}
 function compileEditorScenePrefabPlaceholderNode(input) {
     return {
         ...compileEditorScenePrefabRuntimeNodeBase({
@@ -580,6 +799,9 @@ function compileEditorScenePrefabRuntimeNodeBase(input) {
         ...(input.parentId ? { parentId: input.parentId } : {}),
         ...(input.active === false ? { enabled: false } : {}),
         ...(input.shadow ? { shadow: structuredClone(input.shadow) } : {}),
+        ...(input.shadowMapExperiment ? {
+            shadowMapExperiment: structuredClone(input.shadowMapExperiment),
+        } : {}),
         ...compileEditorScenePrefabRuntimeShadowPlan(input),
         source: {
             sourceId: input.sourceRef.sourceId,
@@ -907,6 +1129,12 @@ function readNonEmptyString(value) {
     const trimmed = typeof value === 'string' ? value.trim() : '';
     return trimmed || undefined;
 }
+function readPlayableEditorRuntimeTransformType(value) {
+    // Preserve untrusted strings until the final artifact validator so invalid authored values fail closed.
+    return typeof value === 'string'
+        ? value
+        : undefined;
+}
 function compileEditorSceneCamera(camera) {
     const compiled = structuredClone(camera);
     delete compiled.inspectorLanguage;