@fps-games/engine 0.0.1-beta.5 → 0.0.1-beta.9

package/dist/scene-artifact-validation.js

@@ -0,0 +1,1352 @@
+import { FPS_RUNTIME_LIGHT_COMPONENT_SCHEMA_VERSION, createFpsRuntimeLightSnapshot, normalizeFpsRuntimeLightDirection, } from './lighting.js';
+import { normalizeSceneMaterialShaderId } from './material-profile.js';
+import { assertEditorShadowSettingsContract } from './rendering/shadow-validation.js';
+import { assertEditorSceneStaticShadowArtifactContract } from './static-shadow-artifact.js';
+export const PLAYABLE_EDITOR_SCENE_COMPILER_ID = '@fps-games/editor.playable-sdk.scene-compiler';
+const PLAYABLE_EDITOR_LEGACY_UNVERSIONED_LIGHT_COMPILER_VERSION = '2';
+const LEGACY_LIGHT_DIRECTION_UNIT_TOLERANCE = 0.0001;
+const PLAYABLE_EDITOR_RUNTIME_SCENE_RULES = {
+    nodeKinds: ['group', 'instance', 'transform', 'primitive', 'image'],
+    primitiveShapes: ['cube', 'sphere', 'plane', 'capsule'],
+    transformTypes: ['plain', 'light', 'camera', 'groundDecal'],
+    assetTypes: ['glb', 'texture'],
+    materialScopes: ['sharedAsset', 'nodeMaterial'],
+    materialModes: ['shared', 'instance'],
+    materialShaderIds: ['fps.builtin.pbr', 'fps.builtin.standard'],
+    materialAssetSystemPresets: ['default-pbr', 'default-standard'],
+    runtimeV3: {
+        assetFields: [
+            'id', 'guid', 'type', 'url', 'external', 'warmupCount', 'singleton',
+            'materialMode', 'defaults', 'materialSlots',
+        ],
+        materialSlotFields: [
+            'slotId', 'label', 'sourceSurfaces',
+        ],
+        materialSlotSourceSurfaceFields: [
+            'ownerNodePath', 'nodeIndex', 'nodeIndexPath', 'meshIndex', 'primitiveIndex',
+            'sourceMaterialIndex', 'sourceMeshName',
+        ],
+    },
+    hierarchy: {
+        parentTargets: ['root', 'sceneNode'],
+    },
+    runtimeOnlyTokens: ['/@fs', 'assetUrl', 'sourceAssetUrl', 'sourceAssetPath'],
+};
+const NODE_KINDS = new Set(PLAYABLE_EDITOR_RUNTIME_SCENE_RULES.nodeKinds);
+const PRIMITIVE_SHAPES = new Set(PLAYABLE_EDITOR_RUNTIME_SCENE_RULES.primitiveShapes);
+const ASSET_TYPES = new Set(PLAYABLE_EDITOR_RUNTIME_SCENE_RULES.assetTypes);
+const MATERIAL_MODES = new Set(PLAYABLE_EDITOR_RUNTIME_SCENE_RULES.materialModes);
+const MATERIAL_SCOPES = new Set(PLAYABLE_EDITOR_RUNTIME_SCENE_RULES.materialScopes);
+const MATERIAL_ASSET_SYSTEM_PRESETS = new Set(PLAYABLE_EDITOR_RUNTIME_SCENE_RULES.materialAssetSystemPresets);
+const TRANSFORM_TYPES = new Set(PLAYABLE_EDITOR_RUNTIME_SCENE_RULES.transformTypes);
+const HIERARCHY_PARENT_TARGETS = new Set(PLAYABLE_EDITOR_RUNTIME_SCENE_RULES.hierarchy.parentTargets);
+const RUNTIME_ONLY_TOKENS = PLAYABLE_EDITOR_RUNTIME_SCENE_RULES.runtimeOnlyTokens;
+const RUNTIME_V3_ASSET_FIELDS = new Set(PLAYABLE_EDITOR_RUNTIME_SCENE_RULES.runtimeV3.assetFields);
+const RUNTIME_V3_MATERIAL_SLOT_FIELDS = new Set(PLAYABLE_EDITOR_RUNTIME_SCENE_RULES.runtimeV3.materialSlotFields);
+const RUNTIME_V3_MATERIAL_SLOT_SOURCE_SURFACE_FIELDS = new Set(PLAYABLE_EDITOR_RUNTIME_SCENE_RULES.runtimeV3.materialSlotSourceSurfaceFields);
+function collectPlayableEditorRuntimeSceneValidationErrors(sceneConfig, options = {}) {
+    const { allowOrphanSharedMaterials = true, allowOrphanNodeMaterials = true, strictAssetIds = [], strictNodeIds = [], maxErrors = 50, } = options;
+    const errorLimit = Number.isInteger(maxErrors) && maxErrors > 0 ? maxErrors : 50;
+    const errors = [];
+    const strictAssets = new Set(strictAssetIds);
+    const strictNodes = new Set(strictNodeIds);
+    const add = (path, message) => {
+        if (errors.length < errorLimit)
+            errors.push({ path, message });
+    };
+    if (!isRecord(sceneConfig)) {
+        add('$', 'scene json must be an object');
+        return errors;
+    }
+    const schemaVersion = sceneConfig.schemaVersion;
+    if (schemaVersion !== 2 && schemaVersion !== 3)
+        add('$.schemaVersion', 'schemaVersion must be 2 or 3');
+    validateGeneratedFrom(sceneConfig.meta?.generatedFrom, '$.meta.generatedFrom', add);
+    const allowLegacyUnversionedLights = isLegacyUnversionedLightArtifact(sceneConfig);
+    const scene = sceneConfig.scene;
+    if (!isRecord(scene)) {
+        add('$.scene', 'scene must be an object');
+        return errors;
+    }
+    if (!nonEmptyString(scene.rootId))
+        add('$.scene.rootId', 'rootId must be a non-empty string');
+    if (!Array.isArray(scene.assets))
+        add('$.scene.assets', 'assets must be an array');
+    if (!Array.isArray(scene.nodes))
+        add('$.scene.nodes', 'nodes must be an array');
+    if (!Array.isArray(scene.materialAssets))
+        add('$.scene.materialAssets', 'materialAssets must be an array');
+    if (!Array.isArray(scene.materials))
+        add('$.scene.materials', 'materials must be an array');
+    if (!Array.isArray(scene.textures))
+        add('$.scene.textures', 'textures must be an array');
+    if (errors.length > 0)
+        return errors;
+    if (sceneConfig.staticShadows != null) {
+        captureSchemaError(() => assertEditorSceneStaticShadowArtifactContract(sceneConfig.staticShadows, '$.staticShadows'), '$.staticShadows', add);
+    }
+    const assetIds = new Set();
+    const assetTypesById = new Map();
+    const materialSlotIdsByAssetId = new Map();
+    const materialAssetIds = new Set();
+    const nodeIds = new Set([scene.rootId]);
+    const nodesById = new Map();
+    const nodeKinds = new Map();
+    const markerNodeIds = new Set();
+    scene.assets.forEach((asset, index) => {
+        const path = `$.scene.assets[${index}]`;
+        if (!isRecord(asset)) {
+            add(path, 'asset must be an object');
+            return;
+        }
+        if (!nonEmptyString(asset.id))
+            add(`${path}.id`, 'asset.id must be a non-empty string');
+        else if (assetIds.has(asset.id))
+            add(`${path}.id`, `duplicate asset id: ${asset.id}`);
+        else {
+            assetIds.add(asset.id);
+            assetTypesById.set(asset.id, asset.type);
+        }
+        if (!ASSET_TYPES.has(asset.type))
+            add(`${path}.type`, 'asset.type must be glb or texture');
+        if (asset.guid != null && !nonEmptyString(asset.guid))
+            add(`${path}.guid`, 'asset.guid must be a non-empty string when present');
+        if (asset.url != null && !nonEmptyString(asset.url))
+            add(`${path}.url`, 'url must be a non-empty string when present');
+        if (asset.external != null && !isRecord(asset.external))
+            add(`${path}.external`, 'external must be an object when present');
+        if (asset.warmupCount != null && (!Number.isInteger(asset.warmupCount) || asset.warmupCount < 0)) {
+            add(`${path}.warmupCount`, 'warmupCount must be a non-negative integer when present');
+        }
+        if (asset.singleton != null && typeof asset.singleton !== 'boolean') {
+            add(`${path}.singleton`, 'singleton must be a boolean when present');
+        }
+        if (asset.materialMode != null && !MATERIAL_MODES.has(asset.materialMode)) {
+            add(`${path}.materialMode`, 'materialMode must be shared or instance');
+        }
+        validateAssetDefaults(asset.defaults, `${path}.defaults`, add);
+        if (schemaVersion === 3) {
+            for (const field of Object.keys(asset)) {
+                if (!RUNTIME_V3_ASSET_FIELDS.has(field)) {
+                    add(`${path}.${field}`, `runtime schema v3 asset field is not allowed: ${field}`);
+                }
+            }
+        }
+        else {
+            if (asset.displayName != null && !nonEmptyString(asset.displayName))
+                add(`${path}.displayName`, 'displayName must be a non-empty string when present');
+            if (asset.category != null && !nonEmptyString(asset.category))
+                add(`${path}.category`, 'category must be a non-empty string when present');
+            if (asset.metadata != null && !isRecord(asset.metadata))
+                add(`${path}.metadata`, 'metadata must be an object when present');
+        }
+        const materialSlots = schemaVersion === 3
+            ? asset.materialSlots
+            : isRecord(asset.metadata) ? asset.metadata.materialSlots : undefined;
+        const materialSlotsPath = schemaVersion === 3 ? `${path}.materialSlots` : `${path}.metadata.materialSlots`;
+        const slotIds = new Set();
+        if (materialSlots != null) {
+            if (!Array.isArray(materialSlots))
+                add(materialSlotsPath, 'materialSlots must be an array when present');
+            else
+                materialSlots.forEach((rawSlot, slotIndex) => {
+                    const slotPath = `${materialSlotsPath}[${slotIndex}]`;
+                    if (!isRecord(rawSlot) || !nonEmptyString(rawSlot.slotId)) {
+                        add(slotPath, schemaVersion === 3
+                            ? 'material slot must contain a stable slotId'
+                            : 'material slot must contain stable slotId and ownerNodePath');
+                        return;
+                    }
+                    if (schemaVersion !== 3 && !nonEmptyString(rawSlot.ownerNodePath)) {
+                        add(slotPath, 'material slot must contain stable slotId and ownerNodePath');
+                        return;
+                    }
+                    if (slotIds.has(rawSlot.slotId))
+                        add(`${slotPath}.slotId`, `duplicate material slot id: ${rawSlot.slotId}`);
+                    else
+                        slotIds.add(rawSlot.slotId);
+                    if (schemaVersion === 3)
+                        validateRuntimeV3MaterialSlot(rawSlot, slotPath, add);
+                });
+        }
+        if (nonEmptyString(asset.id))
+            materialSlotIdsByAssetId.set(asset.id, slotIds);
+        if (strictAssets.has(asset.id))
+            assertNoRuntimeOnlyFields(asset, path, add);
+    });
+    scene.nodes.forEach((node, index) => {
+        const path = `$.scene.nodes[${index}]`;
+        if (!isRecord(node)) {
+            add(path, 'node must be an object');
+            return;
+        }
+        if (nonEmptyString(node.id))
+            nodesById.set(node.id, node);
+        if (!nonEmptyString(node.id))
+            add(`${path}.id`, 'node.id must be a non-empty string');
+        else if (nodeIds.has(node.id))
+            add(`${path}.id`, `duplicate node id: ${node.id}`);
+        else {
+            nodeIds.add(node.id);
+            if (typeof node.kind === 'string')
+                nodeKinds.set(node.id, node.kind);
+            if (node.kind === 'transform' && Object.prototype.hasOwnProperty.call(node, 'marker')) {
+                markerNodeIds.add(node.id);
+            }
+        }
+        if (!NODE_KINDS.has(node.kind))
+            add(`${path}.kind`, 'node.kind must be group, instance, transform, primitive, or image');
+    });
+    const materialAssets = scene.materialAssets;
+    materialAssets.forEach((materialAsset, index) => {
+        const path = `$.scene.materialAssets[${index}]`;
+        if (!isRecord(materialAsset)) {
+            add(path, 'material asset must be an object');
+            return;
+        }
+        if (!nonEmptyString(materialAsset.id))
+            add(`${path}.id`, 'material asset id must be a non-empty string');
+        else if (materialAssetIds.has(materialAsset.id))
+            add(`${path}.id`, `duplicate material asset id: ${materialAsset.id}`);
+        else
+            materialAssetIds.add(materialAsset.id);
+        if (materialAsset.name != null && !nonEmptyString(materialAsset.name)) {
+            add(`${path}.name`, 'material asset name must be a non-empty string when present');
+        }
+        if (materialAsset.guid != null && !nonEmptyString(materialAsset.guid))
+            add(`${path}.guid`, 'material asset guid must be a non-empty string when present');
+        if (Object.prototype.hasOwnProperty.call(materialAsset, 'materialKind')) {
+            add(`${path}.materialKind`, 'materialKind is not supported; use shaderId');
+        }
+        if (Object.prototype.hasOwnProperty.call(materialAsset, 'profile')) {
+            add(`${path}.profile`, 'profile is not supported; use properties');
+        }
+        if (!normalizeSceneMaterialShaderId(materialAsset.shaderId)) {
+            add(`${path}.shaderId`, 'shaderId must be fps.builtin.pbr or fps.builtin.standard');
+        }
+        validateArtistMaterialProfile(materialAsset.properties, `${path}.properties`, add);
+        for (const field of Object.keys(materialAsset)) {
+            if (!['id', 'guid', 'name', 'shaderId', 'properties', 'system', 'origin'].includes(field)) {
+                add(`${path}.${field}`, `material asset field is not allowed: ${field}`);
+            }
+        }
+        validateMaterialAssetSystem(materialAsset.system, `${path}.system`, add);
+        validateMaterialAssetOrigin(materialAsset.origin, `${path}.origin`, add);
+        validateMaterialAssetSystemKindConsistency(materialAsset, path, add);
+    });
+    scene.nodes.forEach((node, index) => {
+        if (!isRecord(node))
+            return;
+        const path = `$.scene.nodes[${index}]`;
+        const hasExplicitParent = Object.prototype.hasOwnProperty.call(node, 'parentId');
+        if (hasExplicitParent && !nonEmptyString(node.parentId)) {
+            add(`${path}.parentId`, 'parentId must be a non-empty string when present');
+        }
+        const parentId = hasExplicitParent ? node.parentId : scene.rootId;
+        if (nonEmptyString(parentId)) {
+            validateNodeParentTarget(parentId, scene.rootId, nodeIds, `${path}.parentId`, add);
+        }
+        if (nonEmptyString(node.id)) {
+            validateNodeParentCycle(node.id, scene.rootId, nodesById, `${path}.parentId`, add);
+        }
+        validateRuntimeSourceBinding(node.source, `${path}.source`, add);
+        validateTransform(node.transform, `${path}.transform`, add);
+        validateNodeRendering(node.rendering, `${path}.rendering`, add);
+        if (node.shadow != null) {
+            captureSchemaError(() => assertEditorShadowSettingsContract(node.shadow, `${path}.shadow`), `${path}.shadow`, add);
+        }
+        if (Object.prototype.hasOwnProperty.call(node, 'shadowMode')) {
+            add(`${path}.shadowMode`, 'deprecated field; use shadow.mode');
+        }
+        let instanceAssetId = null;
+        if (node.kind === 'instance') {
+            if (!isRecord(node.instance))
+                add(`${path}.instance`, 'instance node must contain instance object');
+            else if (!assetIds.has(node.instance.assetId)) {
+                add(`${path}.instance.assetId`, `assetId must reference scene.assets: ${node.instance.assetId}`);
+            }
+            else if (assetTypesById.get(node.instance.assetId) !== 'glb') {
+                add(`${path}.instance.assetId`, 'instance.assetId must reference a glb asset');
+            }
+            else {
+                instanceAssetId = nonEmptyString(node.instance.assetId) ? node.instance.assetId : null;
+            }
+        }
+        if (node.kind === 'primitive') {
+            if (!isRecord(node.primitive))
+                add(`${path}.primitive`, 'primitive node must contain primitive object');
+            else if (!PRIMITIVE_SHAPES.has(node.primitive.shape)) {
+                add(`${path}.primitive.shape`, 'primitive.shape must be cube, sphere, plane, or capsule');
+            }
+        }
+        if (node.kind === 'image') {
+            if (!isRecord(node.image))
+                add(`${path}.image`, 'image node must contain image object');
+            else {
+                if (!assetIds.has(node.image.assetId)) {
+                    add(`${path}.image.assetId`, `assetId must reference scene.assets: ${node.image.assetId}`);
+                }
+                else if (assetTypesById.get(node.image.assetId) !== 'texture') {
+                    add(`${path}.image.assetId`, 'image.assetId must reference a texture asset');
+                }
+                if (!isRecord(node.image.size))
+                    add(`${path}.image.size`, 'image.size must be an object');
+                else {
+                    if (!positiveFinite(node.image.size.width))
+                        add(`${path}.image.size.width`, 'image.size.width must be positive');
+                    if (!positiveFinite(node.image.size.height))
+                        add(`${path}.image.size.height`, 'image.size.height must be positive');
+                }
+            }
+        }
+        if (node.kind === 'transform' && node.transformType != null && !TRANSFORM_TYPES.has(node.transformType)) {
+            add(`${path}.transformType`, 'transformType must be plain, light, camera, or groundDecal');
+        }
+        const isGroundDecalTransform = node.kind === 'transform' && node.transformType === 'groundDecal';
+        if (isGroundDecalTransform) {
+            validateGroundDecal(node.groundDecal, `${path}.groundDecal`, add);
+        }
+        else if (Object.prototype.hasOwnProperty.call(node, 'groundDecal')) {
+            add(`${path}.groundDecal`, 'groundDecal is only allowed on transform nodes with transformType groundDecal');
+        }
+        if (node.kind === 'transform') {
+            validateCameraRig(node.camera, `${path}.camera`, add);
+            validateSceneLight(node.light, `${path}.light`, add, allowLegacyUnversionedLights);
+        }
+        if (Object.prototype.hasOwnProperty.call(node, 'marker')) {
+            if (node.kind !== 'transform')
+                add(`${path}.marker`, 'marker is only allowed on transform nodes');
+            else {
+                validateSceneMarker(node.marker, `${path}.marker`, add);
+                validateSceneMarkerReferences(node.marker, node.id, nodeIds, markerNodeIds, `${path}.marker`, add);
+            }
+        }
+        if (node.kind === 'instance' || node.kind === 'transform' || node.kind === 'primitive' || node.kind === 'image') {
+            validateNodeVisualOverrides(node.overrides, `${path}.overrides`, materialAssetIds, instanceAssetId ? materialSlotIdsByAssetId.get(instanceAssetId) : undefined, schemaVersion === 3 ? 'materialSlots' : 'metadata.materialSlots', add);
+        }
+        if (strictNodes.has(node.id))
+            assertNoRuntimeOnlyFields(node, path, add);
+    });
+    scene.materials.forEach((material, index) => {
+        const path = `$.scene.materials[${index}]`;
+        if (!isRecord(material)) {
+            add(path, 'material must be an object');
+            return;
+        }
+        if (!nonEmptyString(material.id))
+            add(`${path}.id`, 'material.id must be a non-empty string');
+        if (material.scope != null && !MATERIAL_SCOPES.has(material.scope)) {
+            add(`${path}.scope`, 'material scope must be sharedAsset or nodeMaterial');
+        }
+        if (material.scope === 'sharedAsset' && (!nonEmptyString(material.assetId) || !assetIds.has(material.assetId)) && !allowOrphanSharedMaterials) {
+            add(`${path}.assetId`, `shared material assetId must reference scene.assets: ${material.assetId}`);
+        }
+        if (material.scope === 'nodeMaterial') {
+            if ((!nonEmptyString(material.nodeId) || !nodeIds.has(material.nodeId)) && !allowOrphanNodeMaterials) {
+                add(`${path}.nodeId`, `node material nodeId must reference scene.nodes: ${material.nodeId}`);
+            }
+            else if (nonEmptyString(material.nodeId) && nodeIds.has(material.nodeId)) {
+                const nodeKind = nodeKinds.get(material.nodeId);
+                if (nodeKind !== 'instance' && nodeKind !== 'transform' && nodeKind !== 'primitive') {
+                    add(`${path}.nodeId`, `node material nodeId must reference an instance, transform, or primitive node: ${material.nodeId}`);
+                }
+            }
+        }
+        if (!nonEmptyString(material.materialName))
+            add(`${path}.materialName`, 'materialName must be a non-empty string');
+        if (!isRecord(material.properties))
+            add(`${path}.properties`, 'properties must be an object');
+        else
+            validateMaterialProperties(material.properties, `${path}.properties`, add);
+    });
+    return errors;
+}
+export function validatePlayableEditorRuntimeSceneConfig(value, options = {}) {
+    const errors = collectPlayableEditorRuntimeSceneValidationErrors(value, options);
+    return {
+        ok: errors.length === 0,
+        errors,
+    };
+}
+function captureSchemaError(operation, fallbackPath, add) {
+    try {
+        operation();
+    }
+    catch (error) {
+        const path = typeof error?.path === 'string'
+            ? error.path
+            : fallbackPath;
+        const code = typeof error?.code === 'string'
+            ? error.code
+            : 'schema.invalidValue';
+        add(path, code);
+    }
+}
+function validateNodeVisualOverrides(overrides, path, materialAssetIds, materialSlotIds, materialSlotSource, add) {
+    if (overrides == null)
+        return;
+    if (!isRecord(overrides)) {
+        add(path, 'overrides must be an object when present');
+        return;
+    }
+    validateNodeMaterialBinding(overrides.materialBinding, `${path}.materialBinding`, materialAssetIds, add);
+    validateNodeMaterialBindingMap(overrides.materialSlotBindings, `${path}.materialSlotBindings`, 'slotId', materialAssetIds, materialSlotIds, materialSlotSource, add);
+    if (Object.prototype.hasOwnProperty.call(overrides, 'childMaterialBindings')) {
+        add(`${path}.childMaterialBindings`, 'deprecated field; use materialSlotBindings keyed by slotId');
+    }
+    if (Object.prototype.hasOwnProperty.call(overrides, 'childMaterials')) {
+        add(`${path}.childMaterials`, 'deprecated field; use materialSlotBindings keyed by slotId');
+    }
+}
+function validateNodeMaterialBindingMap(bindings, path, keyName, materialAssetIds, allowedKeys, materialSlotSource, add) {
+    if (bindings == null)
+        return;
+    if (!isRecord(bindings)) {
+        add(path, 'material binding map must be an object when present');
+        return;
+    }
+    for (const [key, binding] of Object.entries(bindings)) {
+        const bindingPath = `${path}.${key}`;
+        if (!nonEmptyString(key))
+            add(bindingPath, `${keyName} must be a non-empty string`);
+        if (!allowedKeys) {
+            add(bindingPath, `${keyName} requires an instance asset with ${materialSlotSource}`);
+        }
+        else if (!allowedKeys.has(key)) {
+            add(bindingPath, `${keyName} must reference asset ${materialSlotSource}`);
+        }
+        if (binding == null)
+            add(bindingPath, 'material binding must be an object');
+        else
+            validateNodeMaterialBinding(binding, bindingPath, materialAssetIds, add);
+    }
+}
+function validateNodeMaterialBinding(binding, path, materialAssetIds, add) {
+    if (binding == null)
+        return;
+    if (!isRecord(binding)) {
+        add(path, 'material binding must be an object when present');
+        return;
+    }
+    if (binding.materialAssetId != null) {
+        if (!nonEmptyString(binding.materialAssetId)) {
+            add(`${path}.materialAssetId`, 'materialAssetId must be non-empty when present');
+        }
+        else if (!materialAssetIds.has(binding.materialAssetId)) {
+            add(`${path}.materialAssetId`, `materialAssetId must reference scene.materialAssets: ${binding.materialAssetId}`);
+        }
+    }
+    if (binding.override != null)
+        validateArtistMaterialProfile(binding.override, `${path}.override`, add);
+}
+function validateArtistMaterialProfile(profile, path, add) {
+    if (!isRecord(profile)) {
+        add(path, 'material asset profile must be an object');
+        return;
+    }
+    if (profile.lightingModel != null && profile.lightingModel !== 'lit' && profile.lightingModel !== 'unlit') {
+        add(`${path}.lightingModel`, 'lightingModel must be lit or unlit');
+    }
+    if (profile.baseColor != null) {
+        if (!isRecord(profile.baseColor))
+            add(`${path}.baseColor`, 'baseColor must be an object');
+        else {
+            validateColor(profile.baseColor.color, `${path}.baseColor.color`, add);
+            validateMaterialTextureRef(profile.baseColor.texture, `${path}.baseColor.texture`, add);
+            for (const key of ['brightness', 'saturation', 'contrast', 'hue']) {
+                if (profile.baseColor[key] != null && !isFiniteNumber(profile.baseColor[key]))
+                    add(`${path}.baseColor.${key}`, `${key} must be a finite number`);
+            }
+        }
+    }
+    for (const key of ['metallic', 'roughness']) {
+        if (profile[key] != null && !isFiniteNumber(profile[key]))
+            add(`${path}.${key}`, `${key} must be a finite number`);
+    }
+    if (profile.normal != null) {
+        if (!isRecord(profile.normal))
+            add(`${path}.normal`, 'normal must be an object');
+        else {
+            validateMaterialTextureRef(profile.normal.texture, `${path}.normal.texture`, add);
+            if (profile.normal.strength != null && !isFiniteNumber(profile.normal.strength))
+                add(`${path}.normal.strength`, 'normal strength must be a finite number');
+        }
+    }
+    if (profile.metallicRoughness != null) {
+        if (!isRecord(profile.metallicRoughness))
+            add(`${path}.metallicRoughness`, 'metallicRoughness must be an object');
+        else
+            validateMaterialTextureRef(profile.metallicRoughness.texture, `${path}.metallicRoughness.texture`, add);
+    }
+    if (profile.occlusion != null) {
+        if (!isRecord(profile.occlusion))
+            add(`${path}.occlusion`, 'occlusion must be an object');
+        else {
+            validateMaterialTextureRef(profile.occlusion.texture, `${path}.occlusion.texture`, add);
+            if (profile.occlusion.strength != null && !isFiniteNumber(profile.occlusion.strength))
+                add(`${path}.occlusion.strength`, 'occlusion strength must be a finite number');
+        }
+    }
+    if (profile.emission != null) {
+        if (!isRecord(profile.emission))
+            add(`${path}.emission`, 'emission must be an object');
+        else {
+            validateColor(profile.emission.color, `${path}.emission.color`, add);
+            if (profile.emission.intensity != null && !isFiniteNumber(profile.emission.intensity))
+                add(`${path}.emission.intensity`, 'emission intensity must be a finite number');
+            validateMaterialTextureRef(profile.emission.texture, `${path}.emission.texture`, add);
+            validateMaterialTextureRef(profile.emission.maskTexture, `${path}.emission.maskTexture`, add);
+        }
+    }
+    if (profile.alpha != null) {
+        if (!isRecord(profile.alpha))
+            add(`${path}.alpha`, 'alpha must be an object');
+        else {
+            if (profile.alpha.mode != null
+                && profile.alpha.mode !== 'opaque'
+                && profile.alpha.mode !== 'mask'
+                && profile.alpha.mode !== 'blend') {
+                add(`${path}.alpha.mode`, 'alpha mode must be opaque, mask, or blend');
+            }
+            if (profile.alpha.opacity != null && !isFiniteNumber(profile.alpha.opacity))
+                add(`${path}.alpha.opacity`, 'alpha opacity must be a finite number');
+            if (profile.alpha.cutoff != null && !isFiniteNumber(profile.alpha.cutoff))
+                add(`${path}.alpha.cutoff`, 'alpha cutoff must be a finite number');
+            validateMaterialTextureRef(profile.alpha.texture, `${path}.alpha.texture`, add);
+        }
+    }
+}
+function validateMaterialTextureRef(texture, path, add) {
+    if (texture == null)
+        return;
+    if (!isRecord(texture)) {
+        add(path, 'texture ref must be an object');
+        return;
+    }
+    if (texture.url != null && !nonEmptyString(texture.url))
+        add(`${path}.url`, 'texture url must be non-empty when present');
+    if (texture.textureAssetId != null && !nonEmptyString(texture.textureAssetId))
+        add(`${path}.textureAssetId`, 'textureAssetId must be non-empty when present');
+}
+function validateMaterialAssetSystem(system, path, add) {
+    if (system == null)
+        return;
+    if (!isRecord(system)) {
+        add(path, 'material asset system must be an object');
+        return;
+    }
+    if (system.readonly != null && typeof system.readonly !== 'boolean')
+        add(`${path}.readonly`, 'readonly must be boolean');
+    if (system.preset != null && !MATERIAL_ASSET_SYSTEM_PRESETS.has(system.preset)) {
+        add(`${path}.preset`, 'preset must be default-pbr or default-standard');
+    }
+}
+function validateMaterialAssetOrigin(origin, path, add) {
+    if (origin == null)
+        return;
+    if (!isRecord(origin)) {
+        add(path, 'material asset origin must be an object');
+        return;
+    }
+    if (origin.type !== 'imported' && origin.type !== 'created' && origin.type !== 'duplicated' && origin.type !== 'preset') {
+        add(`${path}.type`, 'origin type must be imported, created, duplicated, or preset');
+    }
+    if (origin.sourceAssetGuid != null && !nonEmptyString(origin.sourceAssetGuid))
+        add(`${path}.sourceAssetGuid`, 'sourceAssetGuid must be non-empty when present');
+    if (origin.sourceAssetId != null && !nonEmptyString(origin.sourceAssetId))
+        add(`${path}.sourceAssetId`, 'sourceAssetId must be non-empty when present');
+    if (origin.sourceSlotId != null && !nonEmptyString(origin.sourceSlotId))
+        add(`${path}.sourceSlotId`, 'sourceSlotId must be non-empty when present');
+    if (origin.sourceMaterialIndex != null && !Number.isInteger(origin.sourceMaterialIndex))
+        add(`${path}.sourceMaterialIndex`, 'sourceMaterialIndex must be an integer when present');
+    if (origin.sourceMaterialName != null && !nonEmptyString(origin.sourceMaterialName))
+        add(`${path}.sourceMaterialName`, 'sourceMaterialName must be non-empty when present');
+    if (origin.sourceMaterialAssetId != null && !nonEmptyString(origin.sourceMaterialAssetId))
+        add(`${path}.sourceMaterialAssetId`, 'sourceMaterialAssetId must be non-empty when present');
+}
+function validateMaterialAssetSystemKindConsistency(materialAsset, path, add) {
+    const preset = isRecord(materialAsset.system) ? materialAsset.system.preset : undefined;
+    if (preset === 'default-pbr' && materialAsset.shaderId !== 'fps.builtin.pbr') {
+        add(`${path}.shaderId`, 'default-pbr material assets must use shaderId fps.builtin.pbr');
+    }
+    if (preset === 'default-standard' && materialAsset.shaderId !== 'fps.builtin.standard') {
+        add(`${path}.shaderId`, 'default-standard material assets must use shaderId fps.builtin.standard');
+    }
+}
+function validateNodeParentTarget(parentId, rootId, nodeIds, path, add) {
+    if (parentId === rootId) {
+        if (!HIERARCHY_PARENT_TARGETS.has('root')) {
+            add(path, `parentId must point to scene node: ${parentId}`);
+        }
+        return;
+    }
+    if (HIERARCHY_PARENT_TARGETS.has('sceneNode') && nodeIds.has(parentId))
+        return;
+    const targetDescription = HIERARCHY_PARENT_TARGETS.has('root') && HIERARCHY_PARENT_TARGETS.has('sceneNode')
+        ? 'root or scene node'
+        : HIERARCHY_PARENT_TARGETS.has('sceneNode')
+            ? 'scene node'
+            : 'root';
+    add(path, `parentId must point to ${targetDescription}: ${parentId}`);
+}
+function validateNodeParentCycle(nodeId, rootId, nodesById, path, add) {
+    if (!nonEmptyString(rootId))
+        return;
+    const visited = new Set([nodeId]);
+    let cursorId = nonEmptyString(nodesById.get(nodeId)?.parentId)
+        ? nodesById.get(nodeId)?.parentId
+        : rootId;
+    while (nonEmptyString(cursorId) && cursorId !== rootId) {
+        if (visited.has(cursorId)) {
+            add(path, `parentId creates a node cycle involving ${nodeId}`);
+            return;
+        }
+        visited.add(cursorId);
+        const cursor = nodesById.get(cursorId);
+        if (!cursor)
+            return;
+        cursorId = nonEmptyString(cursor.parentId) ? cursor.parentId : rootId;
+    }
+}
+function validateRuntimeV3MaterialSlot(slot, path, add) {
+    for (const field of Object.keys(slot)) {
+        if (!RUNTIME_V3_MATERIAL_SLOT_FIELDS.has(field)) {
+            add(`${path}.${field}`, `runtime schema v3 material slot field is not allowed: ${field}`);
+        }
+    }
+    if (slot.label != null && !nonEmptyString(slot.label)) {
+        add(`${path}.label`, 'label must be a non-empty string when present');
+    }
+    if (!Array.isArray(slot.sourceSurfaces) || slot.sourceSurfaces.length === 0) {
+        add(`${path}.sourceSurfaces`, 'sourceSurfaces must be a non-empty array');
+        return;
+    }
+    for (let surfaceIndex = 0; surfaceIndex < slot.sourceSurfaces.length; surfaceIndex += 1) {
+        const surfacePath = `${path}.sourceSurfaces[${surfaceIndex}]`;
+        const surface = slot.sourceSurfaces[surfaceIndex];
+        if (!isRecord(surface)) {
+            add(surfacePath, 'source surface must be an object');
+            continue;
+        }
+        for (const field of Object.keys(surface)) {
+            if (!RUNTIME_V3_MATERIAL_SLOT_SOURCE_SURFACE_FIELDS.has(field)) {
+                add(`${surfacePath}.${field}`, `runtime schema v3 material slot source surface field is not allowed: ${field}`);
+            }
+        }
+        if (!nonEmptyString(surface.ownerNodePath)) {
+            add(`${surfacePath}.ownerNodePath`, 'ownerNodePath must be a non-empty string');
+        }
+        for (const key of ['meshIndex', 'primitiveIndex']) {
+            if (!Number.isInteger(surface[key]) || surface[key] < 0) {
+                add(`${surfacePath}.${key}`, `${key} must be a non-negative integer`);
+            }
+        }
+        for (const key of ['nodeIndex', 'sourceMaterialIndex']) {
+            if (surface[key] != null && (!Number.isInteger(surface[key]) || surface[key] < 0)) {
+                add(`${surfacePath}.${key}`, `${key} must be a non-negative integer when present`);
+            }
+        }
+        if (surface.nodeIndexPath != null && (!Array.isArray(surface.nodeIndexPath)
+            || surface.nodeIndexPath.some((value) => !Number.isInteger(value) || value < 0))) {
+            add(`${surfacePath}.nodeIndexPath`, 'nodeIndexPath must contain non-negative integers');
+        }
+        if (!nonEmptyString(surface.sourceMeshName)) {
+            add(`${surfacePath}.sourceMeshName`, 'sourceMeshName is required');
+        }
+    }
+}
+function validateAssetDefaults(defaults, path, add) {
+    if (defaults == null)
+        return;
+    if (!isRecord(defaults)) {
+        add(path, 'defaults must be an object');
+        return;
+    }
+    validateTransform(defaults.transform, `${path}.transform`, add);
+    validateOutline(defaults.outline, `${path}.outline`, add);
+    if (defaults.childOutlines != null) {
+        if (!isRecord(defaults.childOutlines)) {
+            add(`${path}.childOutlines`, 'childOutlines must be an object');
+        }
+        else {
+            for (const [key, outline] of Object.entries(defaults.childOutlines)) {
+                validateOutline(outline, `${path}.childOutlines.${key}`, add);
+            }
+        }
+    }
+}
+function validateGeneratedFrom(generatedFrom, path, add) {
+    if (generatedFrom == null)
+        return;
+    if (!isRecord(generatedFrom)) {
+        add(path, 'generatedFrom must be an object when present');
+        return;
+    }
+    validateAuthoringSourceRef(generatedFrom, path, add);
+    if (!nonEmptyString(generatedFrom.compilerId))
+        add(`${path}.compilerId`, 'compilerId must be a non-empty string');
+    if (!nonEmptyString(generatedFrom.compilerVersion))
+        add(`${path}.compilerVersion`, 'compilerVersion must be a non-empty string');
+    if (!nonEmptyString(generatedFrom.compiledAt))
+        add(`${path}.compiledAt`, 'compiledAt must be a non-empty string');
+}
+function validateRuntimeSourceBinding(source, path, add) {
+    if (source == null)
+        return;
+    if (!isRecord(source)) {
+        add(path, 'source must be an object when present');
+        return;
+    }
+    validateAuthoringSourceRef(source, path, add);
+    if (source.objectGuid != null && !nonEmptyString(source.objectGuid))
+        add(`${path}.objectGuid`, 'objectGuid must be a non-empty string when present');
+    if (source.objectId != null && !nonEmptyString(source.objectId))
+        add(`${path}.objectId`, 'objectId must be a non-empty string when present');
+    if (source.component != null && !nonEmptyString(source.component))
+        add(`${path}.component`, 'component must be a non-empty string when present');
+    if (source.propertyPath != null && !nonEmptyString(source.propertyPath))
+        add(`${path}.propertyPath`, 'propertyPath must be a non-empty string when present');
+}
+function validateAuthoringSourceRef(source, path, add) {
+    if (!nonEmptyString(source.sourceId))
+        add(`${path}.sourceId`, 'sourceId must be a non-empty string');
+    if (!nonEmptyString(source.sourceType))
+        add(`${path}.sourceType`, 'sourceType must be a non-empty string');
+    if (source.revision != null && (typeof source.revision !== 'number' || !Number.isFinite(source.revision))) {
+        add(`${path}.revision`, 'revision must be a finite number when present');
+    }
+}
+export function assertPlayableEditorRuntimeSceneConfig(value, options) {
+    const result = validatePlayableEditorRuntimeSceneConfig(value, options);
+    if (result.ok)
+        return;
+    const error = new Error(`scene_json_schema_failed:\n${JSON.stringify(result.errors, null, 2)}`);
+    Object.assign(error, {
+        code: 'scene_json_schema_failed',
+        diagnostics: result.errors,
+    });
+    throw error;
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function validateTransform(transform, path, add) {
+    if (transform == null)
+        return;
+    if (!isRecord(transform)) {
+        add(path, 'transform must be an object');
+        return;
+    }
+    validateVec3(transform.position, `${path}.position`, add);
+    validateVec3(transform.rotation, `${path}.rotation`, add);
+    validateVec3(transform.rotationDeg, `${path}.rotationDeg`, add);
+    if (typeof transform.scale === 'number') {
+        if (!Number.isFinite(transform.scale))
+            add(`${path}.scale`, 'scale number must be finite');
+    }
+    else {
+        validateVec3(transform.scale, `${path}.scale`, add);
+    }
+}
+function validateSceneMarker(value, path, add) {
+    if (!isRecord(value)) {
+        add(path, 'marker must be an object');
+        return;
+    }
+    validateAllowedFields(value, [
+        'schemaVersion', 'label', 'type', 'kind', 'tags', 'note', 'color',
+        'target', 'semanticFrame', 'geometry', 'metadata',
+    ], path, add);
+    if (value.schemaVersion !== 1)
+        add(`${path}.schemaVersion`, 'marker.schemaVersion must be 1');
+    if (!nonEmptyString(value.label))
+        add(`${path}.label`, 'marker.label must be a non-empty string');
+    if (!nonEmptyString(value.type))
+        add(`${path}.type`, 'marker.type must be a non-empty string');
+    if (value.kind != null && !nonEmptyString(value.kind))
+        add(`${path}.kind`, 'marker.kind must be a non-empty string when present');
+    if (value.tags != null) {
+        if (!Array.isArray(value.tags))
+            add(`${path}.tags`, 'marker.tags must be an array when present');
+        else
+            value.tags.forEach((entry, index) => {
+                if (typeof entry !== 'string')
+                    add(`${path}.tags[${index}]`, 'marker tag must be a string');
+            });
+    }
+    if (value.note != null && typeof value.note !== 'string')
+        add(`${path}.note`, 'marker.note must be a string when present');
+    if (value.color != null)
+        validateMarkerColor(value.color, `${path}.color`, add);
+    if (value.target != null)
+        validateSceneMarkerTarget(value.target, `${path}.target`, add);
+    if (value.semanticFrame != null)
+        validateSceneMarkerFrame(value.semanticFrame, `${path}.semanticFrame`, add);
+    validateSceneMarkerGeometry(value.geometry, `${path}.geometry`, add);
+    if (value.metadata != null && !isRecord(value.metadata))
+        add(`${path}.metadata`, 'marker.metadata must be an object when present');
+}
+function validateSceneMarkerReferences(value, markerNodeId, nodeIds, markerNodeIds, path, add) {
+    if (!isRecord(value))
+        return;
+    const targets = [];
+    if (value.target != null)
+        targets.push({ value: value.target, path: `${path}.target` });
+    if (isRecord(value.geometry) && value.geometry.target != null) {
+        targets.push({ value: value.geometry.target, path: `${path}.geometry.target` });
+    }
+    for (const entry of targets) {
+        if (!isRecord(entry.value))
+            continue;
+        if (entry.value.kind !== 'scene-object' && entry.value.kind !== 'marker') {
+            add(`${entry.path}.kind`, 'runtime marker target kind must be scene-object or marker');
+        }
+        if (nonEmptyString(entry.value.id)) {
+            if (entry.value.id === markerNodeId) {
+                add(`${entry.path}.id`, 'runtime marker target must not reference its marker node');
+            }
+            else if (!nodeIds.has(entry.value.id)) {
+                add(`${entry.path}.id`, `runtime marker target must reference scene.nodes: ${entry.value.id}`);
+            }
+            else if (entry.value.kind === 'marker' && !markerNodeIds.has(entry.value.id)) {
+                add(`${entry.path}.id`, `runtime marker target must reference a marker node: ${entry.value.id}`);
+            }
+            else if (entry.value.kind === 'scene-object' && markerNodeIds.has(entry.value.id)) {
+                add(`${entry.path}.id`, `runtime scene-object target must not reference a marker node: ${entry.value.id}`);
+            }
+        }
+    }
+}
+function validateSceneMarkerTarget(value, path, add) {
+    if (!isRecord(value)) {
+        add(path, 'marker target must be an object');
+        return;
+    }
+    validateAllowedFields(value, ['kind', 'id', 'label', 'path', 'metadata'], path, add);
+    if (!nonEmptyString(value.kind))
+        add(`${path}.kind`, 'marker target kind must be a non-empty string');
+    if (!nonEmptyString(value.id))
+        add(`${path}.id`, 'marker target id must be a non-empty string');
+    for (const key of ['label', 'path']) {
+        if (value[key] != null && typeof value[key] !== 'string')
+            add(`${path}.${key}`, `marker target ${key} must be a string when present`);
+    }
+    if (value.metadata != null && !isRecord(value.metadata))
+        add(`${path}.metadata`, 'marker target metadata must be an object when present');
+}
+function validateSceneMarkerFrame(value, path, add) {
+    if (!isRecord(value)) {
+        add(path, 'marker semanticFrame must be an object');
+        return;
+    }
+    validateAllowedFields(value, ['origin', 'forward', 'right', 'up', 'label', 'description'], path, add);
+    if (!isRecord(value.origin))
+        add(`${path}.origin`, 'marker semanticFrame.origin must be a vector object');
+    else
+        validateVec3(value.origin, `${path}.origin`, add);
+    for (const key of ['forward', 'right', 'up']) {
+        if (value[key] != null)
+            validateVec3(value[key], `${path}.${key}`, add);
+    }
+    for (const key of ['label', 'description']) {
+        if (value[key] != null && typeof value[key] !== 'string')
+            add(`${path}.${key}`, `marker semanticFrame ${key} must be a string when present`);
+    }
+}
+function validateSceneMarkerGeometry(value, path, add) {
+    if (!isRecord(value)) {
+        add(path, 'marker.geometry must be an object');
+        return;
+    }
+    if (value.kind === 'box') {
+        validateAllowedFields(value, ['kind'], path, add);
+        return;
+    }
+    if (value.kind === 'point') {
+        validateAllowedFields(value, ['kind', 'coordinateSpace', 'position', 'offset', 'target'], path, add);
+        if (value.coordinateSpace != null && value.coordinateSpace !== 'world' && value.coordinateSpace !== 'local') {
+            add(`${path}.coordinateSpace`, 'point marker coordinateSpace must be world or local');
+        }
+        if (value.position != null)
+            validateVec3(value.position, `${path}.position`, add);
+        if (value.offset != null)
+            validateVec3(value.offset, `${path}.offset`, add);
+        if (value.target != null)
+            validateSceneMarkerTarget(value.target, `${path}.target`, add);
+        return;
+    }
+    if (value.kind === 'object-bounds') {
+        validateAllowedFields(value, ['kind', 'target'], path, add);
+        validateSceneMarkerTarget(value.target, `${path}.target`, add);
+        return;
+    }
+    if (value.kind === 'polyhedron') {
+        validateAllowedFields(value, ['kind', 'coordinateSpace', 'vertices', 'faces'], path, add);
+        if (value.coordinateSpace != null && value.coordinateSpace !== 'world') {
+            add(`${path}.coordinateSpace`, 'polyhedron marker coordinateSpace must be world');
+        }
+        if (!Array.isArray(value.vertices))
+            add(`${path}.vertices`, 'polyhedron marker vertices must be an array');
+        else
+            value.vertices.forEach((entry, index) => {
+                const vertexPath = `${path}.vertices[${index}]`;
+                if (!isRecord(entry))
+                    add(vertexPath, 'polyhedron marker vertex must be a vector object');
+                else
+                    validateVec3(entry, vertexPath, add);
+            });
+        if (value.faces != null) {
+            if (!Array.isArray(value.faces))
+                add(`${path}.faces`, 'polyhedron marker faces must be an array when present');
+            else
+                value.faces.forEach((face, faceIndex) => {
+                    if (!Array.isArray(face))
+                        add(`${path}.faces[${faceIndex}]`, 'polyhedron marker face must be an array');
+                    else
+                        face.forEach((entry, index) => {
+                            if (!Number.isInteger(entry) || entry < 0)
+                                add(`${path}.faces[${faceIndex}][${index}]`, 'polyhedron marker index must be a non-negative integer');
+                        });
+                });
+        }
+        return;
+    }
+    add(`${path}.kind`, 'marker.geometry.kind must be box, point, object-bounds, or polyhedron');
+}
+function validateMarkerColor(value, path, add) {
+    if (!isRecord(value)) {
+        add(path, 'marker color must be an object');
+        return;
+    }
+    validateAllowedFields(value, ['r', 'g', 'b'], path, add);
+    for (const key of ['r', 'g', 'b']) {
+        if (!isUnitRangeNumber(value[key]))
+            add(`${path}.${key}`, 'marker color component must be between 0 and 1');
+    }
+}
+function validateAllowedFields(value, allowed, path, add) {
+    const allowedFields = new Set(allowed);
+    for (const key of Object.keys(value)) {
+        if (!allowedFields.has(key))
+            add(`${path}.${key}`, `field is not allowed: ${key}`);
+    }
+}
+function validateVec3(value, path, add) {
+    if (value == null)
+        return;
+    if (!isRecord(value)) {
+        add(path, 'value must be a vector object');
+        return;
+    }
+    for (const axis of ['x', 'y', 'z']) {
+        if (typeof value[axis] !== 'number' || !Number.isFinite(value[axis])) {
+            add(`${path}.${axis}`, 'vector component must be a finite number');
+        }
+    }
+}
+function validateVec2(value, path, add) {
+    if (value == null)
+        return;
+    if (!isRecord(value)) {
+        add(path, 'value must be a vector object');
+        return;
+    }
+    for (const axis of ['x', 'y']) {
+        if (typeof value[axis] !== 'number' || !Number.isFinite(value[axis])) {
+            add(`${path}.${axis}`, 'vector component must be a finite number');
+        }
+    }
+}
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function isPositiveFiniteNumber(value) {
+    return isFiniteNumber(value) && value > 0;
+}
+function isUnitRangeNumber(value) {
+    return isFiniteNumber(value) && value >= 0 && value <= 1;
+}
+function validateColor(value, path, add) {
+    if (value == null)
+        return;
+    if (!isRecord(value)) {
+        add(path, 'color must be an object');
+        return;
+    }
+    for (const key of ['r', 'g', 'b']) {
+        if (typeof value[key] !== 'number' || !Number.isFinite(value[key])) {
+            add(`${path}.${key}`, 'color component must be a finite number');
+        }
+    }
+}
+function validateCameraRig(value, path, add) {
+    if (value == null)
+        return;
+    if (!isRecord(value)) {
+        add(path, 'camera must be an object');
+        return;
+    }
+    if (value.projection != null && value.projection !== 'orthographic' && value.projection !== 'perspective') {
+        add(`${path}.projection`, 'camera projection must be orthographic or perspective');
+    }
+    for (const key of ['alpha', 'beta']) {
+        if (value[key] != null && !isFiniteNumber(value[key])) {
+            add(`${path}.${key}`, 'camera property must be a finite number when present');
+        }
+    }
+    for (const key of ['radius', 'orthoSize']) {
+        if (value[key] != null && !isPositiveFiniteNumber(value[key])) {
+            add(`${path}.${key}`, 'camera property must be a positive finite number when present');
+        }
+    }
+    if (value.fov != null && !isPositiveFiniteNumber(value.fov))
+        add(`${path}.fov`, 'camera fov must be a positive finite number');
+    validateVec3(value.targetOffset, `${path}.targetOffset`, add);
+    validateVec2(value.targetScreenOffset, `${path}.targetScreenOffset`, add);
+    for (const key of ['minZ', 'maxZ', 'lowerRadiusLimit', 'upperRadiusLimit']) {
+        if (value[key] != null && !isPositiveFiniteNumber(value[key])) {
+            add(`${path}.${key}`, 'camera property must be a positive finite number');
+        }
+    }
+    for (const key of ['lowerBetaLimit', 'upperBetaLimit']) {
+        if (value[key] != null && !isFiniteNumber(value[key])) {
+            add(`${path}.${key}`, 'camera property must be a finite number');
+        }
+    }
+    if (value.inertia != null && !isUnitRangeNumber(value.inertia)) {
+        add(`${path}.inertia`, 'camera inertia must be between 0 and 1');
+    }
+    if (isPositiveFiniteNumber(value.minZ) && isPositiveFiniteNumber(value.maxZ) && value.maxZ <= value.minZ) {
+        add(`${path}.maxZ`, 'camera maxZ must be greater than minZ');
+    }
+    if (isFiniteNumber(value.lowerBetaLimit) && isFiniteNumber(value.upperBetaLimit) && value.upperBetaLimit < value.lowerBetaLimit) {
+        add(`${path}.upperBetaLimit`, 'camera upperBetaLimit must be greater than or equal to lowerBetaLimit');
+    }
+    if (isPositiveFiniteNumber(value.lowerRadiusLimit) && isPositiveFiniteNumber(value.upperRadiusLimit) && value.upperRadiusLimit < value.lowerRadiusLimit) {
+        add(`${path}.upperRadiusLimit`, 'camera upperRadiusLimit must be greater than or equal to lowerRadiusLimit');
+    }
+}
+function isLegacyUnversionedLightArtifact(sceneConfig) {
+    const generatedFrom = sceneConfig.meta?.generatedFrom;
+    return isRecord(generatedFrom)
+        && generatedFrom.compilerId === PLAYABLE_EDITOR_SCENE_COMPILER_ID
+        && generatedFrom.compilerVersion === PLAYABLE_EDITOR_LEGACY_UNVERSIONED_LIGHT_COMPILER_VERSION;
+}
+function validateSceneLight(value, path, add, allowLegacyUnversionedLight = false) {
+    if (value == null)
+        return;
+    const validationValue = allowLegacyUnversionedLight
+        && isRecord(value)
+        && !Object.prototype.hasOwnProperty.call(value, 'schemaVersion')
+        ? createLegacyUnversionedLightValidationView(value, path)
+        : value;
+    try {
+        createFpsRuntimeLightSnapshot(validationValue, path);
+    }
+    catch (error) {
+        const failure = error;
+        add(typeof failure.path === 'string' ? failure.path : path, typeof failure.reason === 'string'
+            ? failure.reason
+            : typeof failure.message === 'string'
+                ? failure.message
+                : 'light does not satisfy the Engine Runtime Light contract');
+    }
+}
+function createLegacyUnversionedLightValidationView(value, path) {
+    const validationValue = {
+        ...value,
+        schemaVersion: FPS_RUNTIME_LIGHT_COMPONENT_SCHEMA_VERSION,
+    };
+    if (value.type !== 'directional' || !isRecord(value.direction))
+        return validationValue;
+    const { x, y, z } = value.direction;
+    if (![x, y, z].every(component => typeof component === 'number' && Number.isFinite(component))) {
+        return validationValue;
+    }
+    const length = Math.hypot(x, y, z);
+    if (length <= 0 || Math.abs(length - 1) > LEGACY_LIGHT_DIRECTION_UNIT_TOLERANCE) {
+        return validationValue;
+    }
+    return {
+        ...validationValue,
+        direction: normalizeFpsRuntimeLightDirection(value.direction, `${path}.direction`),
+    };
+}
+function validateOutline(value, path, add) {
+    if (value == null)
+        return;
+    if (!isRecord(value)) {
+        add(path, 'outline must be an object');
+        return;
+    }
+    if (value.renderOutline != null && typeof value.renderOutline !== 'boolean')
+        add(`${path}.renderOutline`, 'renderOutline must be boolean');
+    if (value.outlineWidth != null && (typeof value.outlineWidth !== 'number' || !Number.isFinite(value.outlineWidth))) {
+        add(`${path}.outlineWidth`, 'outlineWidth must be a finite number');
+    }
+    validateColor(value.outlineColor, `${path}.outlineColor`, add);
+}
+function validateGroundDecal(value, path, add) {
+    if (value == null) {
+        add(path, 'groundDecal is required when transformType is groundDecal');
+        return;
+    }
+    if (!isRecord(value)) {
+        add(path, 'groundDecal must be an object');
+        return;
+    }
+    validateGroundDecalUi(value, path, add);
+}
+function validateGroundDecalUi(value, path, add) {
+    if (!nonEmptyString(value.uiKind))
+        add(`${path}.uiKind`, 'groundDecal UI kind must be non-empty');
+    if (!isRecord(value.size)) {
+        add(`${path}.size`, 'groundDecal.size must be an object');
+    }
+    else {
+        for (const key of ['width', 'depth']) {
+            if (typeof value.size[key] !== 'number' || !Number.isFinite(value.size[key]) || value.size[key] <= 0) {
+                add(`${path}.size.${key}`, 'groundDecal size must be a positive finite number');
+            }
+        }
+    }
+    if (value.aspectSourceLayerId != null && !nonEmptyString(value.aspectSourceLayerId)) {
+        add(`${path}.aspectSourceLayerId`, 'aspectSourceLayerId must be non-empty when present');
+    }
+    if (value.lockAspectToBorder != null && typeof value.lockAspectToBorder !== 'boolean') {
+        add(`${path}.lockAspectToBorder`, 'lockAspectToBorder must be boolean when present');
+    }
+    if (value.editorPreviewActive != null) {
+        add(`${path}.editorPreviewActive`, 'editorPreviewActive is editor-only and must not appear in runtime scene data');
+    }
+    validateGroundDecalUiMask(value.mask, `${path}.mask`, add);
+    validateGroundDecalUiRendering(value.rendering, `${path}.rendering`, add);
+    if (!Array.isArray(value.layers)) {
+        add(`${path}.layers`, 'groundDecal UI layers must be an array');
+        return;
+    }
+    value.layers.forEach((layer, index) => validateGroundDecalUiLayer(layer, `${path}.layers[${index}]`, add));
+    validateGroundDecalUiLayerIds(value.layers, `${path}.layers`, add);
+}
+function validateGroundDecalUiMask(value, path, add) {
+    if (value == null)
+        return;
+    if (!isRecord(value)) {
+        add(path, 'groundDecal UI mask must be an object');
+        return;
+    }
+    if (value.enabled != null && typeof value.enabled !== 'boolean')
+        add(`${path}.enabled`, 'mask.enabled must be boolean');
+    if (value.source != null && value.source !== 'roundedRect' && value.source !== 'borderAlpha' && value.source !== 'texture') {
+        add(`${path}.source`, 'mask.source must be roundedRect, borderAlpha, or texture');
+    }
+    if (value.textureId != null && !nonEmptyString(value.textureId))
+        add(`${path}.textureId`, 'mask.textureId must be non-empty when present');
+    for (const key of ['cornerRadius', 'padding']) {
+        if (value[key] != null && (typeof value[key] !== 'number' || !Number.isFinite(value[key]) || value[key] < 0)) {
+            add(`${path}.${key}`, `${key} must be a non-negative finite number`);
+        }
+    }
+}
+function validateGroundDecalUiRendering(value, path, add) {
+    if (value == null)
+        return;
+    if (!isRecord(value)) {
+        add(path, 'groundDecal UI rendering must be an object');
+        return;
+    }
+    for (const key of ['textureWidth', 'textureHeight']) {
+        if (value[key] != null && (!Number.isInteger(value[key]) || value[key] <= 0)) {
+            add(`${path}.${key}`, `${key} must be a positive integer`);
+        }
+    }
+    for (const key of ['alphaIndex', 'diffuseTextureLevel', 'emissiveTextureLevel']) {
+        if (value[key] != null && (typeof value[key] !== 'number' || !Number.isFinite(value[key]))) {
+            add(`${path}.${key}`, `${key} must be a finite number`);
+        }
+    }
+}
+function validateGroundDecalUiLayer(value, path, add) {
+    if (!isRecord(value)) {
+        add(path, 'groundDecal UI layer must be an object');
+        return;
+    }
+    if (!nonEmptyString(value.id))
+        add(`${path}.id`, 'layer.id must be non-empty');
+    if (!nonEmptyString(value.role))
+        add(`${path}.role`, 'layer.role must be non-empty');
+    if (value.editorPreviewPercent != null) {
+        add(`${path}.editorPreviewPercent`, 'editorPreviewPercent is editor-only and must not appear in runtime scene data');
+    }
+    if (value.enabled != null && typeof value.enabled !== 'boolean')
+        add(`${path}.enabled`, 'layer.enabled must be boolean');
+    if (typeof value.zOrder !== 'number' || !Number.isFinite(value.zOrder))
+        add(`${path}.zOrder`, 'layer.zOrder must be a finite number');
+    if (value.opacity != null && (typeof value.opacity !== 'number' || !Number.isFinite(value.opacity)))
+        add(`${path}.opacity`, 'layer.opacity must be finite');
+    if (value.rotationDeg != null
+        && (typeof value.rotationDeg !== 'number'
+            || !Number.isFinite(value.rotationDeg)
+            || value.rotationDeg <= -180
+            || value.rotationDeg > 180)) {
+        add(`${path}.rotationDeg`, 'layer.rotationDeg must be in the range (-180, 180]');
+    }
+    validateGroundDecalUiRect(value.rect, `${path}.rect`, add);
+    if (value.kind === 'texture') {
+        if (value.textureId != null && !nonEmptyString(value.textureId))
+            add(`${path}.textureId`, 'texture layer textureId must be non-empty when present');
+        if (value.imageFit != null && value.imageFit !== 'contain' && value.imageFit !== 'stretch') {
+            add(`${path}.imageFit`, 'texture layer imageFit must be contain or stretch');
+        }
+        validateGroundDecalUiColor(value.tint, `${path}.tint`, add);
+    }
+    else if (value.kind === 'textureProgress') {
+        if (value.textureId != null && !nonEmptyString(value.textureId))
+            add(`${path}.textureId`, 'texture progress layer textureId must be non-empty when present');
+        if (value.imageFit != null && value.imageFit !== 'contain' && value.imageFit !== 'stretch') {
+            add(`${path}.imageFit`, 'texture progress layer imageFit must be contain or stretch');
+        }
+        if (typeof value.value !== 'number' || !Number.isFinite(value.value) || value.value < 0 || value.value > 1) {
+            add(`${path}.value`, 'texture progress value must be between 0 and 1');
+        }
+        if (value.direction != null && !['leftToRight', 'rightToLeft', 'bottomToTop', 'topToBottom'].includes(String(value.direction))) {
+            add(`${path}.direction`, 'texture progress direction is invalid');
+        }
+        validateGroundDecalUiColor(value.tint, `${path}.tint`, add);
+    }
+    else if (value.kind === 'color') {
+        validateGroundDecalUiColor(value.color, `${path}.color`, add);
+    }
+    else if (value.kind === 'progress') {
+        if (typeof value.value !== 'number' || !Number.isFinite(value.value) || value.value < 0 || value.value > 1) {
+            add(`${path}.value`, 'progress value must be between 0 and 1');
+        }
+        if (value.direction != null && !['leftToRight', 'rightToLeft', 'bottomToTop', 'topToBottom'].includes(String(value.direction))) {
+            add(`${path}.direction`, 'progress direction is invalid');
+        }
+        validateGroundDecalUiColor(value.color, `${path}.color`, add);
+    }
+    else if (value.kind === 'text') {
+        validateGroundDecalUiText(value.text, `${path}.text`, add);
+    }
+    else {
+        add(`${path}.kind`, 'layer.kind must be texture, textureProgress, color, progress, or text');
+    }
+}
+function validateGroundDecalUiLayerIds(layers, path, add) {
+    const seen = new Map();
+    layers.forEach((layer, index) => {
+        if (!isRecord(layer) || !nonEmptyString(layer.id))
+            return;
+        const previousIndex = seen.get(layer.id);
+        if (previousIndex != null) {
+            add(`${path}[${index}].id`, `layer.id must be unique; duplicate of layers[${previousIndex}]`);
+            return;
+        }
+        seen.set(layer.id, index);
+    });
+}
+function validateGroundDecalUiRect(value, path, add) {
+    if (!isRecord(value)) {
+        add(path, 'layer.rect must be an object');
+        return;
+    }
+    for (const key of ['x', 'z', 'width', 'depth']) {
+        if (typeof value[key] !== 'number' || !Number.isFinite(value[key]))
+            add(`${path}.${key}`, `rect.${key} must be a finite number`);
+    }
+    for (const key of ['width', 'depth']) {
+        if (typeof value[key] === 'number' && value[key] <= 0)
+            add(`${path}.${key}`, `rect.${key} must be positive`);
+    }
+}
+function validateGroundDecalUiText(value, path, add) {
+    if (!isRecord(value)) {
+        add(path, 'text layer text must be an object');
+        return;
+    }
+    if (typeof value.value !== 'string')
+        add(`${path}.value`, 'text.value must be a string');
+    if (value.fontFamily != null && typeof value.fontFamily !== 'string')
+        add(`${path}.fontFamily`, 'fontFamily must be a string');
+    if (value.fontSize != null && (typeof value.fontSize !== 'number' || !Number.isFinite(value.fontSize) || value.fontSize <= 0)) {
+        add(`${path}.fontSize`, 'fontSize must be a positive finite number');
+    }
+    if (value.fontWeight != null && typeof value.fontWeight !== 'string')
+        add(`${path}.fontWeight`, 'fontWeight must be a string');
+    validateGroundDecalUiColor(value.color, `${path}.color`, add);
+    validateGroundDecalUiColor(value.strokeColor, `${path}.strokeColor`, add);
+    if (value.strokeWidth != null && (typeof value.strokeWidth !== 'number' || !Number.isFinite(value.strokeWidth) || value.strokeWidth < 0)) {
+        add(`${path}.strokeWidth`, 'strokeWidth must be a non-negative finite number');
+    }
+}
+function validateGroundDecalUiColor(value, path, add) {
+    if (value == null)
+        return;
+    if (!isRecord(value)) {
+        add(path, 'color must be an object');
+        return;
+    }
+    for (const key of ['r', 'g', 'b']) {
+        if (typeof value[key] !== 'number' || !Number.isFinite(value[key]))
+            add(`${path}.${key}`, `color.${key} must be finite`);
+    }
+    if (value.a != null && (typeof value.a !== 'number' || !Number.isFinite(value.a)))
+        add(`${path}.a`, 'color.a must be finite');
+}
+function validateNodeRendering(value, path, add) {
+    if (value == null)
+        return;
+    if (!isRecord(value)) {
+        add(path, 'rendering must be an object');
+        return;
+    }
+    if (value.renderingGroupId != null
+        && value.renderingGroupId !== 0
+        && value.renderingGroupId !== 1
+        && value.renderingGroupId !== 2
+        && value.renderingGroupId !== 3) {
+        add(`${path}.renderingGroupId`, 'renderingGroupId must be 0, 1, 2, or 3');
+    }
+    if (value.alphaIndex != null && (typeof value.alphaIndex !== 'number' || !Number.isFinite(value.alphaIndex))) {
+        add(`${path}.alphaIndex`, 'alphaIndex must be a finite number');
+    }
+}
+function positiveFinite(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0;
+}
+function validateMaterialProperties(value, path, add) {
+    for (const [key, child] of Object.entries(value)) {
+        const childPath = `${path}.${key}`;
+        if (['albedoColor', 'diffuseColor', 'emissiveColor', 'outlineColor'].includes(key))
+            validateColor(child, childPath, add);
+        if (['metallic', 'roughness', 'contrast', 'brightness', 'saturation', 'hue', 'colorDensity', 'alpha', 'alphaCutOff', 'transparencyMode'].includes(key)) {
+            if (typeof child !== 'number' || !Number.isFinite(child))
+                add(childPath, `${key} must be a finite number`);
+        }
+        if (key === 'backFaceCulling' && typeof child !== 'boolean')
+            add(childPath, 'backFaceCulling must be boolean');
+        if (['albedoTexture', 'normalTexture', 'metallicTexture'].includes(key)) {
+            if (!isRecord(child))
+                add(childPath, `${key} must be an object`);
+            else if (child.url != null && !nonEmptyString(child.url))
+                add(`${childPath}.url`, 'texture url must be non-empty when present');
+        }
+        if (['pbr', 'standard'].includes(key)) {
+            if (!isRecord(child))
+                add(childPath, `${key} must be an object`);
+            else
+                validateMaterialProperties(child, childPath, add);
+        }
+    }
+}
+function assertNoRuntimeOnlyFields(value, path, add) {
+    const serialized = JSON.stringify(value);
+    const found = RUNTIME_ONLY_TOKENS.filter((token) => serialized.includes(token));
+    if (found.length > 0)
+        add(path, `contains runtime-only asset fields: ${found.join(', ')}`);
+}
+//# sourceMappingURL=scene-artifact-validation.js.map