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

package/node_modules/@fps-games/editor-playable-sdk/dist/asset-database/metadata.js

@@ -0,0 +1,782 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export async function resolvePlayableEditorAssetMetadata(input) {
+    const metadata = {
+        ...(input.existingMetadata ?? {}),
+        ...(input.payloadMetadata ?? {}),
+    };
+    const assetAnalysis = await resolvePlayableEditorAssetAnalysis(input);
+    if (assetAnalysis)
+        metadata.assetAnalysis = assetAnalysis;
+    else
+        delete metadata.assetAnalysis;
+    if (input.kind === 'texture' || input.kind === 'image') {
+        const textureCapabilities = createPlayableEditorTextureAssetCapabilities(input.sourcePath, metadata);
+        if (textureCapabilities) {
+            metadata.textureUsage = textureCapabilities.usage;
+            metadata.capabilities = {
+                ...(isRecord(metadata.capabilities) ? metadata.capabilities : {}),
+                materialTexture: textureCapabilities.materialTexture,
+                environmentTexture: textureCapabilities.environmentTexture,
+            };
+        }
+        return Object.keys(metadata).length > 0 ? metadata : null;
+    }
+    if (input.kind !== 'model')
+        return Object.keys(metadata).length > 0 ? metadata : null;
+    const materialSlots = await extractPlayableEditorGltfMaterialSlots(input.sourcePath, {
+        assetGuid: input.guid,
+        assetId: input.assetId,
+        cwd: input.cwd,
+        assetsDir: input.assetsDir,
+        existingMaterialSlots: metadata.materialSlots,
+    });
+    if (materialSlots.length === 0) {
+        delete metadata.materialSlots;
+    }
+    else {
+        metadata.materialSlots = materialSlots;
+    }
+    return Object.keys(metadata).length > 0 ? metadata : null;
+}
+export async function resolvePlayableEditorAssetAnalysis(input) {
+    if (input.kind === 'model') {
+        return resolvePlayableEditorGltfAssetAnalysis(input.sourcePath);
+    }
+    if (input.kind === 'texture' || input.kind === 'image') {
+        return resolvePlayableEditorImageAssetAnalysis(input.sourcePath);
+    }
+    return null;
+}
+export async function extractPlayableEditorGltfMaterialSlots(sourcePath, context = {}) {
+    try {
+        const gltf = await readGltfJson(sourcePath);
+        return collectGltfMaterialSlots(gltf, {
+            ...context,
+            sourcePath,
+        });
+    }
+    catch {
+        return [];
+    }
+}
+async function readGltfJson(sourcePath) {
+    const extension = path.extname(sourcePath).toLowerCase();
+    if (extension === '.gltf') {
+        return JSON.parse(await fs.readFile(sourcePath, 'utf8'));
+    }
+    if (extension !== '.glb')
+        return null;
+    const bytes = await fs.readFile(sourcePath);
+    if (bytes.length < 20 || bytes.toString('utf8', 0, 4) !== 'glTF')
+        return null;
+    const version = bytes.readUInt32LE(4);
+    if (version !== 2)
+        return null;
+    const declaredLength = bytes.readUInt32LE(8);
+    if (declaredLength > bytes.length)
+        return null;
+    let offset = 12;
+    while (offset + 8 <= bytes.length) {
+        const chunkLength = bytes.readUInt32LE(offset);
+        const chunkType = bytes.readUInt32LE(offset + 4);
+        offset += 8;
+        if (offset + chunkLength > bytes.length)
+            return null;
+        if (chunkType === 0x4e4f534a) {
+            const jsonText = bytes.toString('utf8', offset, offset + chunkLength).replace(/\0+$/g, '');
+            return JSON.parse(jsonText);
+        }
+        offset += chunkLength;
+    }
+    return null;
+}
+async function resolvePlayableEditorGltfAssetAnalysis(sourcePath) {
+    try {
+        const gltf = await readGltfJson(sourcePath);
+        if (!gltf || typeof gltf !== 'object')
+            return null;
+        const scenes = Array.isArray(gltf.scenes) ? gltf.scenes : [];
+        const nodes = Array.isArray(gltf.nodes) ? gltf.nodes : [];
+        const meshes = Array.isArray(gltf.meshes) ? gltf.meshes : [];
+        const materials = Array.isArray(gltf.materials) ? gltf.materials : [];
+        const textures = Array.isArray(gltf.textures) ? gltf.textures : [];
+        const images = Array.isArray(gltf.images) ? gltf.images : [];
+        const animations = Array.isArray(gltf.animations) ? gltf.animations : [];
+        const skins = Array.isArray(gltf.skins) ? gltf.skins : [];
+        const primitiveCount = meshes.reduce((count, mesh) => (count + (Array.isArray(mesh?.primitives) ? mesh.primitives.length : 0)), 0);
+        const complexity = resolveAssetComplexity({
+            nodeCount: nodes.length,
+            meshCount: meshes.length,
+            primitiveCount,
+            materialCount: materials.length,
+            textureCount: textures.length,
+            imageCount: images.length,
+        });
+        const diagnostics = createGltfAssetAnalysisDiagnostics({
+            nodeCount: nodes.length,
+            meshCount: meshes.length,
+            primitiveCount,
+            materialCount: materials.length,
+            textureCount: textures.length,
+            imageCount: images.length,
+            animationCount: animations.length,
+            skinCount: skins.length,
+            complexity,
+        });
+        const analysis = {
+            kind: 'gltf',
+            format: path.extname(sourcePath).toLowerCase() === '.gltf' ? 'gltf' : 'glb',
+            summary: `${nodes.length} nodes, ${meshes.length} meshes, ${primitiveCount} primitives, ${materials.length} materials`,
+            complexity,
+            sceneCount: scenes.length,
+            nodeCount: nodes.length,
+            meshCount: meshes.length,
+            primitiveCount,
+            materialCount: materials.length,
+            textureCount: textures.length,
+            imageCount: images.length,
+            animationCount: animations.length,
+            skinCount: skins.length,
+            meshes: createGltfMeshAnalysisSummaries(meshes, materials),
+            materials: createGltfMaterialAnalysisSummaries(gltf),
+            diagnostics,
+        };
+        return analysis;
+    }
+    catch {
+        return null;
+    }
+}
+async function resolvePlayableEditorImageAssetAnalysis(sourcePath) {
+    try {
+        const bytes = await fs.readFile(sourcePath);
+        const extension = path.extname(sourcePath).toLowerCase();
+        const image = extension === '.png'
+            ? readPngImageAnalysis(bytes)
+            : extension === '.jpg' || extension === '.jpeg'
+                ? readJpegImageAnalysis(bytes)
+                : extension === '.webp'
+                    ? readWebpImageAnalysis(bytes)
+                    : null;
+        if (!image)
+            return null;
+        const diagnostics = createImageAssetAnalysisDiagnostics(image);
+        return {
+            kind: 'image',
+            format: image.format,
+            summary: `${image.width}x${image.height} ${image.mime}`,
+            complexity: image.estimatedPixels >= 4096 * 4096 ? 'high' : image.estimatedPixels >= 2048 * 2048 ? 'medium' : 'low',
+            width: image.width,
+            height: image.height,
+            mime: image.mime,
+            bitDepth: image.bitDepth,
+            hasAlpha: image.hasAlpha,
+            estimatedPixels: image.estimatedPixels,
+            diagnostics,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function createGltfMeshAnalysisSummaries(meshes, materials) {
+    return meshes.slice(0, 50).map((mesh, meshIndex) => {
+        const primitives = Array.isArray(mesh?.primitives) ? mesh.primitives : [];
+        const materialIndices = [...new Set(primitives
+                .map((primitive) => Number.isInteger(primitive?.material) ? primitive.material : -1)
+                .filter((materialIndex) => materialIndex >= 0))];
+        return {
+            meshIndex,
+            ...(typeof mesh?.name === 'string' && mesh.name.trim() ? { name: mesh.name.trim() } : {}),
+            primitiveCount: primitives.length,
+            ...(materialIndices.length > 0 ? { materialIndices } : {}),
+            ...(materialIndices.length > 0
+                ? {
+                    materialNames: materialIndices
+                        .map((materialIndex) => {
+                        const material = materials[materialIndex];
+                        return typeof material?.name === 'string' ? material.name.trim() : '';
+                    })
+                        .filter(Boolean),
+                }
+                : {}),
+        };
+    });
+}
+function createGltfMaterialAnalysisSummaries(gltf) {
+    const materials = Array.isArray(gltf?.materials) ? gltf.materials : [];
+    return materials.slice(0, 50).map((material, sourceMaterialIndex) => {
+        const pbr = material?.pbrMetallicRoughness && typeof material.pbrMetallicRoughness === 'object'
+            ? material.pbrMetallicRoughness
+            : {};
+        const textureSlots = readGltfMaterialTextureSlots(material, pbr);
+        return {
+            sourceMaterialIndex,
+            ...(typeof material?.name === 'string' && material.name.trim() ? { materialName: material.name.trim() } : {}),
+            ...(Array.isArray(pbr.baseColorFactor) ? { baseColorFactor: pbr.baseColorFactor.slice(0, 4) } : {}),
+            metallicFactor: Number.isFinite(pbr.metallicFactor) ? pbr.metallicFactor : 1,
+            roughnessFactor: Number.isFinite(pbr.roughnessFactor) ? pbr.roughnessFactor : 1,
+            alphaMode: normalizeGltfAlphaMode(material?.alphaMode) ?? 'opaque',
+            ...(Number.isFinite(material?.alphaCutoff) ? { alphaCutoff: material.alphaCutoff } : {}),
+            ...(textureSlots.length > 0 ? { textureSlots } : {}),
+        };
+    });
+}
+function readGltfMaterialTextureSlots(material, pbr) {
+    const slots = [];
+    pushGltfTextureSlot(slots, 'baseColor', pbr?.baseColorTexture);
+    pushGltfTextureSlot(slots, 'metallicRoughness', pbr?.metallicRoughnessTexture);
+    pushGltfTextureSlot(slots, 'normal', material?.normalTexture);
+    pushGltfTextureSlot(slots, 'occlusion', material?.occlusionTexture);
+    pushGltfTextureSlot(slots, 'emissive', material?.emissiveTexture);
+    return slots;
+}
+function pushGltfTextureSlot(slots, slot, textureInfo) {
+    if (!isRecord(textureInfo) || !Number.isInteger(textureInfo.index))
+        return;
+    slots.push({
+        slot,
+        textureIndex: textureInfo.index,
+        ...(Number.isFinite(textureInfo.texCoord) ? { texCoord: textureInfo.texCoord } : {}),
+    });
+}
+function resolveAssetComplexity(input) {
+    if (input.nodeCount >= 300
+        || input.meshCount >= 250
+        || input.primitiveCount >= 300
+        || input.materialCount >= 200
+        || input.textureCount >= 80
+        || input.imageCount >= 80)
+        return 'high';
+    if (input.nodeCount >= 100
+        || input.meshCount >= 80
+        || input.primitiveCount >= 100
+        || input.materialCount >= 50
+        || input.textureCount >= 24
+        || input.imageCount >= 24)
+        return 'medium';
+    return 'low';
+}
+function createGltfAssetAnalysisDiagnostics(input) {
+    const diagnostics = [];
+    if (input.complexity === 'high') {
+        diagnostics.push({
+            severity: 'warning',
+            source: 'asset',
+            code: 'asset.analysis.highComplexity',
+            message: 'GLTF asset is structurally complex; agent should place and inspect it before duplicating or using dense shadows.',
+            details: {
+                nodeCount: input.nodeCount,
+                meshCount: input.meshCount,
+                primitiveCount: input.primitiveCount,
+                materialCount: input.materialCount,
+                textureCount: input.textureCount,
+                imageCount: input.imageCount,
+            },
+        });
+    }
+    if (input.animationCount > 0 || input.skinCount > 0) {
+        diagnostics.push({
+            severity: 'info',
+            source: 'asset',
+            code: 'asset.analysis.riggedOrAnimated',
+            message: 'GLTF asset contains animation or skin data.',
+            details: {
+                animationCount: input.animationCount,
+                skinCount: input.skinCount,
+            },
+        });
+    }
+    return diagnostics;
+}
+function readPngImageAnalysis(bytes) {
+    if (bytes.length < 33)
+        return null;
+    if (bytes[0] !== 0x89
+        || bytes.toString('ascii', 1, 4) !== 'PNG'
+        || bytes[4] !== 0x0d
+        || bytes[5] !== 0x0a
+        || bytes[6] !== 0x1a
+        || bytes[7] !== 0x0a)
+        return null;
+    const chunkType = bytes.toString('ascii', 12, 16);
+    if (chunkType !== 'IHDR')
+        return null;
+    const width = bytes.readUInt32BE(16);
+    const height = bytes.readUInt32BE(20);
+    const bitDepth = bytes[24];
+    const colorType = bytes[25];
+    return {
+        format: 'png',
+        mime: 'image/png',
+        width,
+        height,
+        bitDepth,
+        hasAlpha: colorType === 4 || colorType === 6,
+        estimatedPixels: width * height,
+    };
+}
+function readJpegImageAnalysis(bytes) {
+    if (bytes.length < 4 || bytes[0] !== 0xff || bytes[1] !== 0xd8)
+        return null;
+    let offset = 2;
+    while (offset + 9 < bytes.length) {
+        if (bytes[offset] !== 0xff) {
+            offset += 1;
+            continue;
+        }
+        const marker = bytes[offset + 1];
+        const length = bytes.readUInt16BE(offset + 2);
+        if (length < 2)
+            return null;
+        const isStartOfFrame = (marker >= 0xc0
+            && marker <= 0xcf
+            && ![0xc4, 0xc8, 0xcc].includes(marker));
+        if (isStartOfFrame && offset + 8 < bytes.length) {
+            const bitDepth = bytes[offset + 4];
+            const height = bytes.readUInt16BE(offset + 5);
+            const width = bytes.readUInt16BE(offset + 7);
+            return {
+                format: 'jpeg',
+                mime: 'image/jpeg',
+                width,
+                height,
+                bitDepth,
+                hasAlpha: false,
+                estimatedPixels: width * height,
+            };
+        }
+        offset += 2 + length;
+    }
+    return null;
+}
+function readWebpImageAnalysis(bytes) {
+    if (bytes.length < 30 || bytes.toString('ascii', 0, 4) !== 'RIFF' || bytes.toString('ascii', 8, 12) !== 'WEBP')
+        return null;
+    const chunkType = bytes.toString('ascii', 12, 16);
+    if (chunkType === 'VP8X' && bytes.length >= 30) {
+        const flags = bytes[20];
+        const width = readUInt24LE(bytes, 24) + 1;
+        const height = readUInt24LE(bytes, 27) + 1;
+        return {
+            format: 'webp',
+            mime: 'image/webp',
+            width,
+            height,
+            hasAlpha: (flags & 0x10) !== 0,
+            estimatedPixels: width * height,
+        };
+    }
+    if (chunkType === 'VP8 ' && bytes.length >= 30) {
+        const width = bytes.readUInt16LE(26) & 0x3fff;
+        const height = bytes.readUInt16LE(28) & 0x3fff;
+        return {
+            format: 'webp',
+            mime: 'image/webp',
+            width,
+            height,
+            hasAlpha: false,
+            estimatedPixels: width * height,
+        };
+    }
+    if (chunkType === 'VP8L' && bytes.length >= 25 && bytes[20] === 0x2f) {
+        const bits = bytes.readUInt32LE(21);
+        const width = (bits & 0x3fff) + 1;
+        const height = ((bits >> 14) & 0x3fff) + 1;
+        return {
+            format: 'webp',
+            mime: 'image/webp',
+            width,
+            height,
+            hasAlpha: true,
+            estimatedPixels: width * height,
+        };
+    }
+    return null;
+}
+function readUInt24LE(bytes, offset) {
+    return bytes[offset] | (bytes[offset + 1] << 8) | (bytes[offset + 2] << 16);
+}
+function createImageAssetAnalysisDiagnostics(input) {
+    const diagnostics = [];
+    if (input.estimatedPixels >= 4096 * 4096) {
+        diagnostics.push({
+            severity: 'warning',
+            source: 'asset',
+            code: 'asset.analysis.largeImage',
+            message: 'Image asset is large; agent should inspect texture usage before assigning it broadly.',
+            details: {
+                width: input.width,
+                height: input.height,
+                estimatedPixels: input.estimatedPixels,
+            },
+        });
+    }
+    return diagnostics;
+}
+function collectGltfMaterialSlots(gltf, context = {}) {
+    if (!gltf || typeof gltf !== 'object')
+        return [];
+    const nodes = Array.isArray(gltf.nodes) ? gltf.nodes : [];
+    const meshes = Array.isArray(gltf.meshes) ? gltf.meshes : [];
+    const materials = Array.isArray(gltf.materials) ? gltf.materials : [];
+    const sourceMaterialProfiles = collectGltfSourceMaterialProfiles(gltf, context);
+    const sceneIndexes = collectGltfSceneRootNodeIndexes(gltf);
+    const parentByNode = buildGltfParentIndex(nodes);
+    const rootSet = new Set(sceneIndexes);
+    const previousSlotIdByOwnerPath = createPreviousMaterialSlotIdMap(context.existingMaterialSlots);
+    const currentOwnerPathCounts = countGltfMaterialSlotOwnerPaths(nodes, meshes, parentByNode, rootSet);
+    const slots = [];
+    for (let nodeIndex = 0; nodeIndex < nodes.length; nodeIndex += 1) {
+        const node = nodes[nodeIndex];
+        const meshIndex = Number.isInteger(node?.mesh) ? node.mesh : -1;
+        if (meshIndex < 0 || meshIndex >= meshes.length)
+            continue;
+        const ownerNodePath = buildGltfOwnerNodePath(nodes, parentByNode, rootSet, nodeIndex);
+        if (!ownerNodePath)
+            continue;
+        const mesh = meshes[meshIndex];
+        const materialRefs = readGltfNodeMeshMaterialRefs(mesh, materials);
+        const sourceMaterialIndex = materialRefs.indices[0] ?? -1;
+        const materialName = materialRefs.names[0] ?? null;
+        const reusablePreviousSlotId = currentOwnerPathCounts.get(ownerNodePath) === 1
+            ? previousSlotIdByOwnerPath.get(ownerNodePath)
+            : null;
+        const slotId = reusablePreviousSlotId
+            ?? createGltfMaterialSlotId({
+                assetGuid: context.assetGuid,
+                assetId: context.assetId,
+                nodeIndex,
+                meshIndex,
+            });
+        slots.push({
+            slotId,
+            ownerNodePath,
+            label: readGltfNodeMeshLabel(node, mesh, ownerNodePath),
+            nodeIndex,
+            meshIndex,
+            ...(sourceMaterialIndex >= 0 ? { sourceMaterialIndex } : {}),
+            ...(materialRefs.indices.length > 0 ? { sourceMaterialIndices: materialRefs.indices } : {}),
+            ...(materialName ? { materialName } : {}),
+            ...(materialRefs.names.length > 0 ? { materialNames: materialRefs.names } : {}),
+            ...pickGltfSlotSourceMaterialProfiles(sourceMaterialProfiles, materialRefs.indices),
+        });
+    }
+    return slots.sort((left, right) => String(left.ownerNodePath).localeCompare(String(right.ownerNodePath)));
+}
+function collectGltfSourceMaterialProfiles(gltf, context = {}) {
+    const materials = Array.isArray(gltf?.materials) ? gltf.materials : [];
+    const profiles = [];
+    for (let sourceMaterialIndex = 0; sourceMaterialIndex < materials.length; sourceMaterialIndex += 1) {
+        const sourceProfile = readGltfSourceMaterialProfile(gltf, sourceMaterialIndex, context);
+        if (sourceProfile)
+            profiles.push(sourceProfile);
+    }
+    return profiles;
+}
+function pickGltfSlotSourceMaterialProfiles(sourceProfiles, sourceMaterialIndices) {
+    if (!sourceMaterialIndices.length || !sourceProfiles.length)
+        return {};
+    const profileByIndex = new Map(sourceProfiles.map(profile => [profile.sourceMaterialIndex, profile]));
+    const sourceMaterialProfiles = sourceMaterialIndices
+        .map(sourceMaterialIndex => profileByIndex.get(sourceMaterialIndex))
+        .filter(Boolean);
+    return sourceMaterialProfiles.length > 0 ? { sourceMaterialProfiles } : {};
+}
+function readGltfSourceMaterialProfile(gltf, sourceMaterialIndex, context = {}) {
+    const material = Array.isArray(gltf?.materials) ? gltf.materials[sourceMaterialIndex] : null;
+    if (!material || typeof material !== 'object')
+        return null;
+    const profile = {};
+    const textureHints = [];
+    const pbr = material.pbrMetallicRoughness && typeof material.pbrMetallicRoughness === 'object'
+        ? material.pbrMetallicRoughness
+        : {};
+    const baseColor = {};
+    const baseColorFactor = Array.isArray(pbr.baseColorFactor) ? pbr.baseColorFactor : null;
+    const baseColorRgb = readGltfRgbFactor(baseColorFactor);
+    if (baseColorRgb)
+        baseColor.color = baseColorRgb;
+    const baseColorTextureRef = applyGltfTextureRef(gltf, pbr.baseColorTexture, context, 'baseColor.texture', baseColor, 'texture', textureHints);
+    if (Object.keys(baseColor).length > 0)
+        profile.baseColor = {
+            ...baseColor,
+            brightness: 1,
+            saturation: 1,
+            contrast: 1,
+            hue: 0,
+        };
+    const normal = {};
+    applyGltfTextureRef(gltf, material.normalTexture, context, 'normal.texture', normal, 'texture', textureHints);
+    if (Number.isFinite(material.normalTexture?.scale))
+        normal.strength = material.normalTexture.scale;
+    else if (normal.texture)
+        normal.strength = 1;
+    if (Object.keys(normal).length > 0)
+        profile.normal = normal;
+    profile.metallic = Number.isFinite(pbr.metallicFactor) ? pbr.metallicFactor : 1;
+    profile.roughness = Number.isFinite(pbr.roughnessFactor) ? pbr.roughnessFactor : 1;
+    const metallicRoughness = {};
+    applyGltfTextureRef(gltf, pbr.metallicRoughnessTexture, context, 'metallicRoughness.texture', metallicRoughness, 'texture', textureHints);
+    if (Object.keys(metallicRoughness).length > 0)
+        profile.metallicRoughness = metallicRoughness;
+    const occlusion = {};
+    applyGltfTextureRef(gltf, material.occlusionTexture, context, 'occlusion.texture', occlusion, 'texture', textureHints);
+    if (Number.isFinite(material.occlusionTexture?.strength))
+        occlusion.strength = material.occlusionTexture.strength;
+    else if (occlusion.texture)
+        occlusion.strength = 1;
+    if (Object.keys(occlusion).length > 0)
+        profile.occlusion = occlusion;
+    const emission = {};
+    const emissiveColor = readGltfRgbFactor(Array.isArray(material.emissiveFactor) ? material.emissiveFactor : null);
+    const hasEmissionColor = emissiveColor && (emissiveColor.r !== 0 || emissiveColor.g !== 0 || emissiveColor.b !== 0);
+    if (hasEmissionColor)
+        emission.color = emissiveColor;
+    applyGltfTextureRef(gltf, material.emissiveTexture, context, 'emission.texture', emission, 'texture', textureHints);
+    if (hasEmissionColor)
+        emission.intensity = 1;
+    if (Object.keys(emission).length > 0)
+        profile.emission = emission;
+    const alpha = {};
+    const alphaMode = normalizeGltfAlphaMode(material.alphaMode);
+    if (alphaMode)
+        alpha.mode = alphaMode;
+    if (alphaMode === 'mask' || alphaMode === 'blend') {
+        if (baseColorFactor && Number.isFinite(baseColorFactor[3]) && baseColorFactor[3] !== 1)
+            alpha.opacity = baseColorFactor[3];
+        if (Number.isFinite(material.alphaCutoff))
+            alpha.cutoff = material.alphaCutoff;
+        else if (alphaMode === 'mask')
+            alpha.cutoff = 0.5;
+        if (baseColorTextureRef.texture) {
+            alpha.texture = structuredClone(baseColorTextureRef.texture);
+        }
+        else if (baseColorTextureRef.hint) {
+            textureHints.push({
+                ...baseColorTextureRef.hint,
+                profilePath: 'alpha.texture',
+            });
+        }
+    }
+    if (Object.keys(alpha).length > 0)
+        profile.alpha = alpha;
+    if (Object.keys(profile).length === 0 && textureHints.length === 0)
+        return null;
+    const materialName = typeof material.name === 'string' && material.name.trim() ? material.name.trim() : '';
+    return {
+        sourceMaterialIndex,
+        ...(materialName ? { materialName } : {}),
+        ...(Object.keys(profile).length > 0 ? { profile } : {}),
+        ...(textureHints.length > 0 ? { textureHints } : {}),
+    };
+}
+function readGltfRgbFactor(value) {
+    if (!Array.isArray(value) || value.length < 3)
+        return null;
+    const [r, g, b] = value;
+    return Number.isFinite(r) && Number.isFinite(g) && Number.isFinite(b) ? { r, g, b } : null;
+}
+function normalizeGltfAlphaMode(value) {
+    if (value === 'MASK')
+        return 'mask';
+    if (value === 'BLEND')
+        return 'blend';
+    if (value === 'OPAQUE')
+        return 'opaque';
+    return null;
+}
+function applyGltfTextureRef(gltf, textureInfo, context, profilePath, target, targetProperty, textureHints) {
+    const result = resolveGltfTextureRef(gltf, textureInfo, context, profilePath);
+    if (result.texture)
+        target[targetProperty] = result.texture;
+    if (result.hint)
+        textureHints.push(result.hint);
+    return result;
+}
+function resolveGltfTextureRef(gltf, textureInfo, context, profilePath) {
+    const textureRecord = isRecord(textureInfo) ? textureInfo : {};
+    const textureIndex = Number.isInteger(textureRecord.index) ? textureRecord.index : -1;
+    if (textureIndex < 0)
+        return {};
+    const textures = Array.isArray(gltf?.textures) ? gltf.textures : [];
+    const images = Array.isArray(gltf?.images) ? gltf.images : [];
+    const texture = textures[textureIndex];
+    const imageIndex = Number.isInteger(texture?.source) ? texture.source : -1;
+    const image = imageIndex >= 0 ? images[imageIndex] : null;
+    const uri = typeof image?.uri === 'string' ? image.uri.trim() : '';
+    const baseHint = {
+        profilePath,
+        textureIndex,
+        ...(imageIndex >= 0 ? { imageIndex } : {}),
+        ...(uri ? { uri } : {}),
+        ...(Number.isInteger(image?.bufferView) ? { bufferView: image.bufferView } : {}),
+        ...(typeof image?.mimeType === 'string' && image.mimeType.trim() ? { mimeType: image.mimeType.trim() } : {}),
+    };
+    if (image?.bufferView != null)
+        return { hint: { ...baseHint, reason: 'embedded-texture' } };
+    if (!uri)
+        return { hint: { ...baseHint, reason: 'missing-image-uri' } };
+    if (/^data:/i.test(uri))
+        return { hint: { ...baseHint, reason: 'embedded-texture' } };
+    if (/^https?:\/\//i.test(uri) || uri.startsWith('/'))
+        return { texture: { url: uri } };
+    let decodedUri = uri;
+    try {
+        decodedUri = decodeURIComponent(uri);
+    }
+    catch {
+        return { hint: { ...baseHint, reason: 'unresolved-external-texture' } };
+    }
+    const sourceDir = path.dirname(String(context.sourcePath ?? ''));
+    const absolutePath = path.resolve(sourceDir, decodedUri);
+    const assetsDir = context.assetsDir ? path.resolve(context.assetsDir) : '';
+    const cwd = context.cwd ? path.resolve(context.cwd) : '';
+    const relativeToAssets = assetsDir ? path.relative(assetsDir, absolutePath) : '../';
+    if (assetsDir && cwd && relativeToAssets && !relativeToAssets.startsWith('..') && !path.isAbsolute(relativeToAssets)) {
+        const relativeToCwd = path.relative(cwd, absolutePath).split(path.sep).join('/');
+        return { texture: { url: `/${relativeToCwd}` } };
+    }
+    return { hint: { ...baseHint, reason: 'unresolved-external-texture' } };
+}
+function countGltfMaterialSlotOwnerPaths(nodes, meshes, parentByNode, rootSet) {
+    const counts = new Map();
+    for (let nodeIndex = 0; nodeIndex < nodes.length; nodeIndex += 1) {
+        const meshIndex = Number.isInteger(nodes[nodeIndex]?.mesh) ? nodes[nodeIndex].mesh : -1;
+        if (meshIndex < 0 || meshIndex >= meshes.length)
+            continue;
+        const ownerNodePath = buildGltfOwnerNodePath(nodes, parentByNode, rootSet, nodeIndex);
+        if (!ownerNodePath)
+            continue;
+        counts.set(ownerNodePath, (counts.get(ownerNodePath) ?? 0) + 1);
+    }
+    return counts;
+}
+function createPreviousMaterialSlotIdMap(rawSlots) {
+    const result = new Map();
+    if (!Array.isArray(rawSlots))
+        return result;
+    const ownerPathCounts = new Map();
+    for (const rawSlot of rawSlots) {
+        if (!isRecord(rawSlot))
+            continue;
+        const ownerNodePath = typeof rawSlot.ownerNodePath === 'string'
+            ? rawSlot.ownerNodePath.trim().replace(/^\/+|\/+$/g, '')
+            : '';
+        if (ownerNodePath)
+            ownerPathCounts.set(ownerNodePath, (ownerPathCounts.get(ownerNodePath) ?? 0) + 1);
+    }
+    for (const rawSlot of rawSlots) {
+        if (!isRecord(rawSlot))
+            continue;
+        const ownerNodePath = typeof rawSlot.ownerNodePath === 'string'
+            ? rawSlot.ownerNodePath.trim().replace(/^\/+|\/+$/g, '')
+            : '';
+        const slotId = typeof rawSlot.slotId === 'string' ? rawSlot.slotId.trim() : '';
+        if (ownerNodePath && slotId && ownerPathCounts.get(ownerNodePath) === 1)
+            result.set(ownerNodePath, slotId);
+    }
+    return result;
+}
+function createGltfMaterialSlotId(input) {
+    const seed = `${input.assetGuid || input.assetId || 'asset'}:${input.nodeIndex}:${input.meshIndex}`;
+    return `slot_${stableHashToken(seed)}`;
+}
+function createPlayableEditorTextureAssetCapabilities(sourcePath, metadata) {
+    if (metadata.textureUsage === 'environment' || metadata.usage === 'environment') {
+        return { usage: 'environment', materialTexture: false, environmentTexture: true };
+    }
+    if (isRecord(metadata.capabilities) && metadata.capabilities.environmentTexture === true) {
+        return { usage: 'environment', materialTexture: false, environmentTexture: true };
+    }
+    const extension = path.extname(sourcePath).toLowerCase();
+    if (['.env', '.hdr', '.dds', '.ktx', '.ktx2'].includes(extension)) {
+        return { usage: 'environment', materialTexture: false, environmentTexture: true };
+    }
+    if (['.png', '.jpg', '.jpeg', '.webp'].includes(extension)) {
+        return { usage: 'material', materialTexture: true, environmentTexture: false };
+    }
+    return null;
+}
+function collectGltfSceneRootNodeIndexes(gltf) {
+    const scenes = Array.isArray(gltf.scenes) ? gltf.scenes : [];
+    const sceneIndex = Number.isInteger(gltf.scene) ? gltf.scene : 0;
+    const scene = scenes[sceneIndex] ?? scenes[0];
+    return Array.isArray(scene?.nodes) ? scene.nodes.filter(Number.isInteger) : [];
+}
+function buildGltfParentIndex(nodes) {
+    const parentByNode = new Map();
+    for (let parentIndex = 0; parentIndex < nodes.length; parentIndex += 1) {
+        const children = Array.isArray(nodes[parentIndex]?.children) ? nodes[parentIndex].children : [];
+        for (const childIndex of children) {
+            if (Number.isInteger(childIndex) && !parentByNode.has(childIndex)) {
+                parentByNode.set(childIndex, parentIndex);
+            }
+        }
+    }
+    return parentByNode;
+}
+function buildGltfOwnerNodePath(nodes, parentByNode, rootSet, nodeIndex) {
+    const segments = [];
+    let currentIndex = nodeIndex;
+    const visited = new Set();
+    while (Number.isInteger(currentIndex) && currentIndex >= 0 && currentIndex < nodes.length) {
+        if (visited.has(currentIndex))
+            return '';
+        visited.add(currentIndex);
+        segments.push(stableGltfNodeSegment(nodes[currentIndex], currentIndex));
+        const parentIndex = parentByNode.get(currentIndex);
+        if (typeof parentIndex !== 'number' || !Number.isInteger(parentIndex))
+            break;
+        currentIndex = parentIndex;
+    }
+    segments.reverse();
+    if (segments.length > 1 && rootSet.has(currentIndex))
+        segments.shift();
+    return segments.filter(Boolean).join('/');
+}
+function stableGltfNodeSegment(node, index) {
+    const name = isRecord(node) && typeof node.name === 'string' ? node.name.trim() : '';
+    return name || `node_${index}`;
+}
+function readGltfNodeMeshLabel(node, mesh, ownerNodePath) {
+    const nodeName = isRecord(node) && typeof node.name === 'string' ? node.name.trim() : '';
+    const meshName = isRecord(mesh) && typeof mesh.name === 'string' ? mesh.name.trim() : '';
+    return nodeName || meshName || ownerNodePath.split('/').filter(Boolean).pop() || ownerNodePath;
+}
+function readGltfNodeMeshMaterialRefs(mesh, materials) {
+    const meshRecord = isRecord(mesh) ? mesh : {};
+    const primitives = Array.isArray(meshRecord.primitives) ? meshRecord.primitives : [];
+    const indices = [];
+    const seen = new Set();
+    for (const primitive of primitives) {
+        const materialIndex = Number.isInteger(primitive?.material) ? primitive.material : -1;
+        if (materialIndex >= 0 && !seen.has(materialIndex)) {
+            seen.add(materialIndex);
+            indices.push(materialIndex);
+        }
+    }
+    return {
+        indices,
+        names: indices
+            .map((materialIndex) => {
+            const material = materials[materialIndex];
+            return typeof material?.name === 'string' ? material.name.trim() : '';
+        })
+            .filter(Boolean),
+    };
+}
+function isRecord(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+function stableHashToken(value) {
+    const text = String(value ?? '');
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < text.length; index += 1) {
+        hash ^= text.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0');
+}
+//# sourceMappingURL=metadata.js.map