@olo-studio/studio-mcp 0.0.0-stage → 1.0.1

package/src/renderer.js

@@ -0,0 +1,622 @@
+/**
+ * Headless Chrome / Playwright deterministic video renderer and GLB inspector.
+ * Calls `window.OloStudioBridge.exportSceneBuffer` against local static `public/` or `https://www.olomni.com/studio`.
+ */
+import fs from 'node:fs'
+import fsp from 'node:fs/promises'
+import http from 'node:http'
+import os from 'node:os'
+import path from 'node:path'
+import { execFile } from 'node:child_process'
+import { createRequire } from 'node:module'
+import { promisify } from 'node:util'
+import JSZip from 'jszip'
+import { compileSceneSpec, findPublicStudioDir, generateSrt, parseBatchInput } from './compiler.js'
+
+const execFileAsync = promisify(execFile)
+
+export const VALID_FORMATS = ['mp4', 'webm', 'webm_alpha', 'alpha', 'chroma']
+export const VALID_FPS = [24, 30, 60]
+export const VALID_QUALITIES = ['fast', 'social', 'studio']
+
+export function validateRenderFormat(rawFormat) {
+  const fmt = String(rawFormat || 'mp4').trim().toLowerCase()
+  if (!VALID_FORMATS.includes(fmt)) {
+    throw new Error(`Unsupported render format "${fmt}". Supported formats: ${VALID_FORMATS.join(', ')}`)
+  }
+  return fmt
+}
+
+export function validateRenderFps(rawFps) {
+  if (rawFps === undefined || rawFps === null || rawFps === '') return 30
+  const fps = Number(rawFps)
+  if (!VALID_FPS.includes(fps)) {
+    throw new Error(`Unsupported fps "${rawFps}". Supported fps: ${VALID_FPS.join(', ')}`)
+  }
+  return fps
+}
+
+export function validateRenderQuality(rawQuality) {
+  const quality = String(rawQuality || 'social').trim().toLowerCase()
+  if (!VALID_QUALITIES.includes(quality)) {
+    throw new Error(`Unsupported render quality "${quality}". Supported qualities: ${VALID_QUALITIES.join(', ')}`)
+  }
+  return quality
+}
+
+const MIME_TYPES = {
+  '.html': 'text/html; charset=utf-8',
+  '.js': 'application/javascript; charset=utf-8',
+  '.mjs': 'application/javascript; charset=utf-8',
+  '.css': 'text/css; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.webp': 'image/webp',
+  '.svg': 'image/svg+xml',
+  '.glb': 'model/gltf-binary',
+  '.gltf': 'model/gltf+json',
+  '.woff2': 'font/woff2',
+  '.wasm': 'application/wasm',
+  '.mp3': 'audio/mpeg',
+  '.wav': 'audio/wav',
+}
+
+export function findChromeExecutable(overridePath) {
+  const candidates = [
+    overridePath,
+    process.env.OLO_CHROME_PATH,
+    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    '/Applications/Chromium.app/Contents/MacOS/Chromium',
+    '/usr/bin/google-chrome',
+    '/usr/bin/chromium',
+    '/usr/bin/chromium-browser',
+  ].filter(Boolean)
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate
+    }
+  }
+  return null
+}
+
+async function loadPlaywright() {
+  try {
+    return await import('playwright')
+  } catch {
+    // Try resolving from cwd (e.g., monorepo root devDependencies)
+    try {
+      const req = createRequire(path.join(process.cwd(), 'package.json'))
+      return req('playwright')
+    } catch {
+      try {
+        return await import('playwright-core')
+      } catch {
+        throw new Error(
+          'Playwright is required for headless video rendering. Install `playwright` in your workspace or set OLO_STUDIO_URL.',
+        )
+      }
+    }
+  }
+}
+
+export function startStaticServer(rootDir) {
+  return new Promise((resolve, reject) => {
+    const resolvedRoot = path.resolve(rootDir)
+    const server = http.createServer((req, res) => {
+      const urlPath = (req.url || '/').split('?')[0]
+      let relPath = decodeURIComponent(urlPath).replace(/^\/+/, '')
+      if (!relPath || relPath.endsWith('/')) relPath += 'index.html'
+      const absPath = path.resolve(resolvedRoot, relPath)
+
+      if (!absPath.startsWith(resolvedRoot)) {
+        res.writeHead(403)
+        res.end('Forbidden')
+        return
+      }
+
+      fs.stat(absPath, (err, stat) => {
+        if (err || !stat.isFile()) {
+          // Fallback to /studio/index.html if requesting /studio
+          const indexFallback = path.join(absPath, 'index.html')
+          if (fs.existsSync(indexFallback)) {
+            const data = fs.readFileSync(indexFallback)
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' })
+            res.end(data)
+            return
+          }
+          res.writeHead(404)
+          res.end('Not Found')
+          return
+        }
+
+        const ext = path.extname(absPath).toLowerCase()
+        res.writeHead(200, {
+          'Content-Type': MIME_TYPES[ext] || 'application/octet-stream',
+          'Cache-Control': 'no-cache',
+        })
+        fs.createReadStream(absPath).pipe(res)
+      })
+    })
+
+    server.on('error', reject)
+    server.listen(0, '127.0.0.1', () => {
+      const addr = server.address()
+      resolve({
+        server,
+        port: addr.port,
+        baseUrl: `http://127.0.0.1:${addr.port}`,
+        close: () => new Promise((resClose) => server.close(() => resClose())),
+      })
+    })
+  })
+}
+
+export function resolveDefaultAngleBackend() {
+  if (process.env.OLO_CHROME_ANGLE) return process.env.OLO_CHROME_ANGLE
+  if (process.platform === 'darwin') return 'metal'
+  if (process.platform === 'win32') return 'd3d11'
+  if (process.platform === 'linux') return 'vulkan'
+  return 'swiftshader'
+}
+
+async function launchStudioAttempt(chromium, chromePath, targetUrl, angleBackend, opts) {
+  const browser = await chromium.launch({
+    headless: true,
+    ...(chromePath ? { executablePath: chromePath } : {}),
+    args: [
+      '--use-gl=angle',
+      `--use-angle=${angleBackend}`,
+      '--enable-webgl',
+      '--ignore-gpu-blocklist',
+      '--autoplay-policy=no-user-gesture-required',
+      '--no-sandbox',
+    ],
+  })
+
+  try {
+    const context = await browser.newContext({
+      viewport: { width: 1280, height: 900 },
+    })
+    const page = await context.newPage()
+
+    await page.goto(targetUrl, {
+      waitUntil: 'domcontentloaded',
+      timeout: opts.timeoutMs || 30000,
+    })
+
+    await page.waitForFunction(
+      () => Boolean(window.OloStudioBridge && window.OloStudioBridge.ready === true),
+      null,
+      { timeout: opts.timeoutMs || 25000 },
+    )
+
+    const waitModelPromise = page.evaluate(async () => {
+      if (window.OloStudioBridge && typeof window.OloStudioBridge.waitForModelReady === 'function') {
+        await window.OloStudioBridge.waitForModelReady(12000)
+      }
+    })
+    if (angleBackend === 'swiftshader') {
+      await waitModelPromise.catch(() => {})
+    } else {
+      await waitModelPromise
+    }
+
+    return { browser, context, page, angleBackend }
+  } catch (err) {
+    await browser.close().catch(() => {})
+    throw err
+  }
+}
+
+async function openStudioSession(opts = {}) {
+  const { chromium } = await loadPlaywright()
+  const chromePath = findChromeExecutable(opts.chromePath)
+
+  let staticSrv = null
+  let targetUrl = opts.studioUrl || process.env.OLO_STUDIO_URL || ''
+
+  if (!targetUrl) {
+    const publicDir = findPublicStudioDir(opts.publicDir)
+    if (publicDir) {
+      staticSrv = await startStaticServer(publicDir)
+      targetUrl = `${staticSrv.baseUrl}/studio/index.html`
+    } else {
+      console.error(
+        '[olo-studio-mcp] Warning: local public/studio directory not found; falling back to https://www.olomni.com/studio',
+      )
+      targetUrl = 'https://www.olomni.com/studio'
+    }
+  }
+
+  const primaryAngle = resolveDefaultAngleBackend()
+  try {
+    const attempt = await launchStudioAttempt(chromium, chromePath, targetUrl, primaryAngle, opts)
+    return { ...attempt, staticSrv, targetUrl, chromePath }
+  } catch (primaryErr) {
+    if (primaryAngle === 'swiftshader') {
+      if (staticSrv) await staticSrv.close().catch(() => {})
+      throw primaryErr
+    }
+    try {
+      const fallback = await launchStudioAttempt(chromium, chromePath, targetUrl, 'swiftshader', opts)
+      return { ...fallback, staticSrv, targetUrl, chromePath }
+    } catch (fallbackErr) {
+      if (staticSrv) await staticSrv.close().catch(() => {})
+      throw fallbackErr
+    }
+  }
+}
+
+async function synthesizeOfflineSpeechWavBase64(compiled) {
+  if (!compiled || !Array.isArray(compiled.beats)) return ''
+  const spoken = compiled.beats.map((b) => String((b && b.text) || '').trim()).filter(Boolean).join('. ')
+  if (!spoken) return ''
+  const isSpanish = /[áéíóúñ¿¡]|\b(hola|para|con|tu|marca|video|soy|listo|crear|desde)\b/i.test(spoken)
+  const tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'olo-tts-'))
+  const wavPath = path.join(tmpDir, 'speech.wav')
+  try {
+    if (process.platform === 'darwin') {
+      const voiceName = isSpanish ? 'Paulina' : 'Samantha'
+      const aiffPath = path.join(tmpDir, 'speech.aiff')
+      await execFileAsync('/usr/bin/say', ['-v', voiceName, '-o', aiffPath, spoken], { timeout: 15000 })
+      await execFileAsync('/usr/bin/afconvert', ['-f', 'WAVE', '-d', 'LEI16@48000', '-c', '1', aiffPath, wavPath], { timeout: 15000 })
+    } else if (process.platform === 'win32') {
+      const psScript = [
+        'Add-Type -AssemblyName System.Speech',
+        '$s = New-Object System.Speech.Synthesis.SpeechSynthesizer',
+        '$s.SetOutputToWaveFile($env:OLO_TTS_WAV)',
+        '$s.Speak($env:OLO_TTS_TEXT)',
+        '$s.Dispose()',
+      ].join('; ')
+      await execFileAsync(
+        'powershell.exe',
+        ['-NoProfile', '-NonInteractive', '-Command', psScript],
+        {
+          timeout: 15000,
+          env: { ...process.env, OLO_TTS_TEXT: spoken, OLO_TTS_WAV: wavPath },
+        },
+      )
+    } else if (process.platform === 'linux') {
+      const lang = isSpanish ? 'es' : 'en'
+      let synthesized = false
+      for (const bin of ['espeak-ng', 'espeak']) {
+        try {
+          await execFileAsync(bin, ['-v', lang, '-w', wavPath, spoken], { timeout: 15000 })
+          synthesized = true
+          break
+        } catch {
+          // try next available TTS binary
+        }
+      }
+      if (!synthesized) return ''
+    } else {
+      return ''
+    }
+    const wavBuf = await fsp.readFile(wavPath)
+    return wavBuf.toString('base64')
+  } catch {
+    return ''
+  } finally {
+    await fsp.rm(tmpDir, { recursive: true, force: true }).catch(() => {})
+  }
+}
+
+async function loadGlbOnPage(page, { glbPath, glbUrl } = {}) {
+  if (glbPath) {
+    const absGlb = path.resolve(glbPath)
+    const buf = await fsp.readFile(absGlb)
+    const b64 = buf.toString('base64')
+    await page.evaluate(
+      async ({ base64, fileName }) => {
+        const bin = atob(base64)
+        const bytes = new Uint8Array(bin.length)
+        for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i)
+        await window.OloStudioBridge.loadGlbFromArrayBuffer(bytes.buffer, fileName)
+      },
+      { base64: b64, fileName: path.basename(absGlb) },
+    )
+  } else if (glbUrl) {
+    await page.evaluate(async (url) => {
+      await window.OloStudioBridge.loadGlbFromUrl(url)
+    }, glbUrl)
+  }
+}
+
+async function renderOnPage(page, opts) {
+  const compileInput = opts.sceneSpec
+    ? {
+        ...opts.sceneSpec,
+        ...(opts.voice !== undefined ? { voice: opts.voice } : {}),
+        ...(opts.voiceId !== undefined ? { voiceId: opts.voiceId } : {}),
+        ...(opts.captions !== undefined ? { captions: opts.captions } : {}),
+        ...(opts.pipPath !== undefined ? { pipPath: opts.pipPath } : {}),
+        ...(opts.pipUrl !== undefined ? { pipUrl: opts.pipUrl } : {}),
+      }
+    : opts
+  const compiled = compileSceneSpec(compileInput)
+  const format = validateRenderFormat(opts.format)
+  const requestedFps = validateRenderFps(opts.fps ?? compiled.fps)
+  const requestedQuality = validateRenderQuality(opts.quality ?? compiled.quality)
+  const scenePayload = { ...compiled, fps: requestedFps, quality: requestedQuality }
+  const resolvedApiKey = opts.apiKey || process.env.OLO_STUDIO_API_KEY
+  if (resolvedApiKey) {
+    scenePayload.apiKey = resolvedApiKey
+  }
+  if (!scenePayload.customAudioWavBase64 && scenePayload.voice !== 'synth') {
+    const wavB64 = await synthesizeOfflineSpeechWavBase64(scenePayload)
+    if (wavB64) {
+      if (resolvedApiKey) {
+        scenePayload.fallbackAudioWavBase64 = wavB64
+      } else {
+        scenePayload.customAudioWavBase64 = wavB64
+      }
+    }
+  }
+
+  await loadGlbOnPage(page, opts)
+
+  const exportResult = await page.evaluate(
+    async ({ scene, fmt }) => {
+      const res = await window.OloStudioBridge.exportSceneBuffer(scene, fmt)
+      let base64 = ''
+      if (typeof FileReader !== 'undefined') {
+        base64 = await new Promise((resolve, reject) => {
+          const reader = new FileReader()
+          reader.onload = () => {
+            const dataUrl = String(reader.result || '')
+            const marker = 'base64,'
+            const idx = dataUrl.indexOf(marker)
+            resolve(idx >= 0 ? dataUrl.slice(idx + marker.length) : dataUrl)
+          }
+          reader.onerror = () => reject(reader.error || new Error('FileReader failed'))
+          reader.readAsDataURL(new Blob([res.arrayBuffer]))
+        })
+      } else {
+        const u8 = new Uint8Array(res.arrayBuffer)
+        const CHUNK = 0x8000
+        const parts = []
+        for (let i = 0; i < u8.length; i += CHUNK) {
+          parts.push(String.fromCharCode.apply(null, u8.subarray(i, i + CHUNK)))
+        }
+        base64 = btoa(parts.join(''))
+      }
+      return {
+        base64,
+        mimeType: res.mimeType,
+        ext: res.ext,
+        durationSec: res.durationSec,
+        watermarked: res.watermarked,
+        beats: Array.isArray(res.beats) ? res.beats : null,
+      }
+    },
+    { scene: scenePayload, fmt: format },
+  )
+
+  const buffer = Buffer.from(exportResult.base64, 'base64')
+  const outPath = path.resolve(opts.outputPath || `olo-render-${compiled.sceneHash}.${exportResult.ext || 'mp4'}`)
+  await fsp.mkdir(path.dirname(outPath), { recursive: true })
+  await fsp.writeFile(outPath, buffer)
+
+  let srtPath = null
+  if (opts.srt !== false) {
+    const srtContent = generateSrt({
+      ...compiled,
+      beats: exportResult.beats || compiled.beats,
+    })
+    if (srtContent) {
+      const outputBase = outPath.slice(0, outPath.length - path.extname(outPath).length)
+      srtPath = `${outputBase}.srt`
+      await fsp.writeFile(srtPath, srtContent, 'utf8')
+    }
+  }
+
+  return {
+    ok: true,
+    outputPath: outPath,
+    srtPath,
+    bytes: buffer.byteLength,
+    mimeType: exportResult.mimeType,
+    ext: exportResult.ext,
+    durationSec: exportResult.durationSec,
+    watermarked: exportResult.watermarked,
+    sceneHash: compiled.sceneHash,
+    title: compiled.title,
+  }
+}
+
+export async function renderVideoWithBrowser(opts = {}) {
+  validateRenderFormat(opts.format)
+  if (opts.fps !== undefined) validateRenderFps(opts.fps)
+  if (opts.quality !== undefined) validateRenderQuality(opts.quality)
+  const session = await openStudioSession(opts)
+  try {
+    const res = await renderOnPage(session.page, opts)
+    return {
+      ...res,
+      studioUrl: session.targetUrl,
+      chromePath: session.chromePath || 'playwright-chromium',
+    }
+  } finally {
+    await session.browser.close().catch(() => {})
+    if (session.staticSrv) await session.staticSrv.close().catch(() => {})
+  }
+}
+
+export async function renderBatchWithBrowser(opts = {}) {
+  const format = validateRenderFormat(opts.format)
+  const batchFps = opts.fps !== undefined ? validateRenderFps(opts.fps) : undefined
+  const batchQuality = opts.quality !== undefined ? validateRenderQuality(opts.quality) : undefined
+  const usedDirectVariants = Array.isArray(opts.variants) && opts.variants.length > 0
+  let variants = usedDirectVariants ? opts.variants : []
+
+  if (variants.length === 0) {
+    let csvContent = opts.csv
+    if (!csvContent && opts.csvPath) {
+      csvContent = await fsp.readFile(path.resolve(opts.csvPath), 'utf8')
+    }
+    const batchDefaults = {
+      ...(opts.voice !== undefined ? { voice: opts.voice } : {}),
+      ...(opts.voiceId !== undefined ? { voiceId: opts.voiceId } : {}),
+      ...(opts.captions !== undefined ? { captions: opts.captions } : {}),
+      ...(opts.pipPath !== undefined ? { pipPath: opts.pipPath } : {}),
+      ...(opts.pipUrl !== undefined ? { pipUrl: opts.pipUrl } : {}),
+    }
+    variants = parseBatchInput({ specs: opts.specs, csv: csvContent, defaults: batchDefaults })
+  }
+
+  if (variants.length === 0) {
+    throw new Error('variants array must be non-empty')
+  }
+
+  const outputDir = path.resolve(opts.outputDir || './olo-batch-renders')
+  const ext = format.includes('webm') || format === 'alpha' ? 'webm' : 'mp4'
+
+  const session = await openStudioSession(opts)
+  const results = []
+  try {
+    const hasBatchGlb = Boolean(opts.glbPath || opts.glbUrl)
+    const hasVariantGlbOverride = variants.some((v) => Boolean(v.glbPath || v.glbUrl))
+    const hoistSharedGlb = hasBatchGlb && !hasVariantGlbOverride
+    if (hoistSharedGlb) {
+      await loadGlbOnPage(session.page, { glbPath: opts.glbPath, glbUrl: opts.glbUrl })
+    }
+
+    let activeGlbKey = hoistSharedGlb
+      ? (opts.glbPath ? `path:${path.resolve(opts.glbPath)}` : `url:${opts.glbUrl}`)
+      : null
+
+    for (const variant of variants) {
+      const outPath = path.join(outputDir, `${variant.outputName}.${ext}`)
+      const effectiveGlbPath = variant.glbPath || (!variant.glbUrl ? opts.glbPath : undefined)
+      const effectiveGlbUrl = variant.glbUrl || (!variant.glbPath ? opts.glbUrl : undefined)
+      const effectiveGlbKey = effectiveGlbPath
+        ? `path:${path.resolve(effectiveGlbPath)}`
+        : effectiveGlbUrl
+          ? `url:${effectiveGlbUrl}`
+          : null
+      const needsGlbLoad = Boolean(effectiveGlbKey && effectiveGlbKey !== activeGlbKey)
+      if (needsGlbLoad) {
+        activeGlbKey = effectiveGlbKey
+      }
+
+      const rendered = await renderOnPage(session.page, {
+        sceneSpec: variant.sceneSpec,
+        format,
+        fps: variant.fps ?? batchFps,
+        quality: variant.quality ?? batchQuality,
+        srt: opts.srt,
+        outputPath: outPath,
+        apiKey: variant.apiKey || opts.apiKey,
+        ...(usedDirectVariants
+          ? {
+              voice: variant.voice ?? (variant.sceneSpec?.voice === undefined ? opts.voice : undefined),
+              voiceId: variant.voiceId ?? (variant.sceneSpec?.voiceId === undefined ? opts.voiceId : undefined),
+              captions: variant.captions ?? (variant.sceneSpec?.captions === undefined ? opts.captions : undefined),
+              pipPath: variant.pipPath ?? (!variant.sceneSpec?.pipMeta ? opts.pipPath : undefined),
+              pipUrl: variant.pipUrl ?? (!variant.sceneSpec?.pipMeta ? opts.pipUrl : undefined),
+            }
+          : {}),
+        ...(needsGlbLoad ? { glbUrl: effectiveGlbUrl, glbPath: effectiveGlbPath } : {}),
+      })
+      results.push({
+        index: variant.index,
+        outputName: variant.outputName,
+        ...rendered,
+      })
+    }
+
+    await fsp.mkdir(outputDir, { recursive: true })
+    const manifestPath = path.join(outputDir, 'manifest.json')
+    const manifest = {
+      ok: true,
+      format,
+      count: results.length,
+      studioUrl: session.targetUrl,
+      generatedAt: new Date().toISOString(),
+      results,
+    }
+    await fsp.writeFile(manifestPath, JSON.stringify(manifest, null, 2), 'utf8')
+
+    let zipPath = null
+    if (opts.zip !== false) {
+      const zip = new JSZip()
+      zip.file('manifest.json', await fsp.readFile(manifestPath))
+      for (const item of results) {
+        if (item.outputPath && fs.existsSync(item.outputPath)) {
+          zip.file(path.basename(item.outputPath), await fsp.readFile(item.outputPath))
+        }
+        if (item.srtPath && fs.existsSync(item.srtPath)) {
+          zip.file(path.basename(item.srtPath), await fsp.readFile(item.srtPath))
+        }
+      }
+      zipPath = path.join(outputDir, 'batch.zip')
+      const zipBuffer = await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' })
+      await fsp.writeFile(zipPath, zipBuffer)
+    }
+
+    return {
+      ok: true,
+      count: results.length,
+      outputDir,
+      manifestPath,
+      zipPath,
+      studioUrl: session.targetUrl,
+      results,
+    }
+  } finally {
+    await session.browser.close().catch(() => {})
+    if (session.staticSrv) await session.staticSrv.close().catch(() => {})
+  }
+}
+
+export async function inspectGlb(source) {
+  if (!source || typeof source !== 'string') {
+    throw new Error('GLB file path or https:// URL is required.')
+  }
+
+  let buffer
+  if (/^https?:\/\//i.test(source)) {
+    const res = await fetch(source, { signal: AbortSignal.timeout(15000) })
+    if (!res.ok) throw new Error(`Failed to fetch GLB (${res.status})`)
+    buffer = Buffer.from(await res.arrayBuffer())
+  } else {
+    buffer = await fsp.readFile(path.resolve(source))
+  }
+
+  if (buffer.byteLength < 20) {
+    throw new Error('File too small to be a valid GLB binary.')
+  }
+
+  const magic = buffer.readUInt32LE(0)
+  if (magic !== 0x46546c67) {
+    throw new Error(`Invalid GLB magic header: 0x${magic.toString(16)}`)
+  }
+
+  const version = buffer.readUInt32LE(4)
+  const totalLength = buffer.readUInt32LE(8)
+  const chunkLength = buffer.readUInt32LE(12)
+  const chunkType = buffer.readUInt32LE(16)
+
+  if (chunkType !== 0x4e4f534a) {
+    throw new Error('First GLB chunk is not JSON.')
+  }
+
+  const jsonStr = buffer.subarray(20, 20 + chunkLength).toString('utf8').replace(/\0+$/, '')
+  const gltf = JSON.parse(jsonStr)
+
+  return {
+    ok: true,
+    source,
+    version,
+    byteLength: totalLength,
+    generator: gltf.asset?.generator || null,
+    scenes: Array.isArray(gltf.scenes) ? gltf.scenes.length : 0,
+    nodes: Array.isArray(gltf.nodes) ? gltf.nodes.length : 0,
+    meshes: Array.isArray(gltf.meshes) ? gltf.meshes.map((m) => m.name || 'unnamed') : [],
+    animations: Array.isArray(gltf.animations) ? gltf.animations.map((a) => a.name || 'unnamed') : [],
+    materials: Array.isArray(gltf.materials) ? gltf.materials.map((m) => m.name || 'unnamed') : [],
+  }
+}