@webspatial/core-sdk 1.6.1 → 2.0.0

package/src/scene-polyfill.request-metadata.test.ts

@@ -0,0 +1,39 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+describe('scene polyfill request metadata forwarding', () => {
+  afterEach(() => {
+    vi.restoreAllMocks()
+    vi.resetModules()
+    delete (window as any).webSpatial
+    delete (window as any).__webspatialShell__
+  })
+
+  it.each(['createSpatialized2DElement', 'createAttachment'])(
+    'forwards rid and wsepoch for %s without introducing extra request fields',
+    async command => {
+      ;(window as any).webSpatial = {
+        genToken: vi.fn(() => 'token-123'),
+      }
+      const originalOpen = vi.fn(() => null)
+      vi.spyOn(window, 'open').mockImplementation(originalOpen)
+
+      const { hijackWindowOpen } = await import('./scene-polyfill')
+      hijackWindowOpen(window)
+
+      window.open(`webspatial://${command}?rid=req_1&wsepoch=9`, '_blank')
+
+      expect(originalOpen).toHaveBeenCalled()
+      const redirectedUrl = (originalOpen.mock.calls as unknown[][])[0]?.[0]
+      expect(typeof redirectedUrl).toBe('string')
+      const redirected = new URL(String(redirectedUrl))
+      if (redirected.protocol === 'webspatial:') {
+        expect(redirected.host).toBe(command)
+      } else {
+        expect(redirected.searchParams.get('command')).toBe(command)
+      }
+      expect(redirected.searchParams.get('rid')).toBe('req_1')
+      expect(redirected.searchParams.get('wsepoch')).toBe('9')
+      expect(redirected.searchParams.get('wsrid')).toBeNull()
+    },
+  )
+})

package/src/scene-polyfill.test.ts

@@ -265,93 +265,51 @@ describe('test formatSceneConfig in volume', () => {
 
 vi.mock('./JSBCommand', () => {
   return {
-    GetSpatialSceneState: vi.fn().mockImplementation(() => ({
-      execute: vi.fn().mockResolvedValue({ data: { name: 'pending' } }),
-    })),
-    UpdateSceneConfig: vi.fn().mockImplementation(() => ({
-      execute: vi.fn().mockResolvedValue(undefined),
-    })),
-    UpdateSpatialSceneProperties: vi.fn().mockImplementation(() => ({
-      execute: vi.fn().mockResolvedValue(undefined),
-    })),
-    AddSpatializedElementToSpatialScene: vi.fn().mockImplementation(() => ({
-      execute: vi.fn().mockResolvedValue(undefined),
-    })),
+    GetSpatialSceneState: vi.fn().mockImplementation(function () {
+      return {
+        execute: vi.fn().mockResolvedValue({ data: { name: 'pending' } }),
+      }
+    }),
+    UpdateSceneConfig: vi.fn().mockImplementation(function () {
+      return {
+        execute: vi.fn().mockResolvedValue(undefined),
+      }
+    }),
+    UpdateSpatialSceneProperties: vi.fn().mockImplementation(function () {
+      return {
+        execute: vi.fn().mockResolvedValue(undefined),
+      }
+    }),
+    AddSpatializedElementToSpatialScene: vi
+      .fn()
+      .mockImplementation(function () {
+        return {
+          execute: vi.fn().mockResolvedValue(undefined),
+        }
+      }),
   }
 })
 
-describe('injectScenePolyfill should call xrCurrentSceneDefaults and update scene config', () => {
+describe('removed scene window globals', () => {
   beforeEach(() => {
     ;(window as any).opener = {}
   })
 
-  it('with no type', async () => {
-    vi.useFakeTimers()
-
-    const mockFn = vi
-      .fn()
-      .mockResolvedValue({ defaultSize: { width: 800, height: 600 } })
-    window.xrCurrentSceneDefaults = mockFn
-
-    injectSceneHook()
-
-    document.dispatchEvent(new Event('DOMContentLoaded'))
-
-    await vi.runAllTimersAsync()
-
-    expect(mockFn).toHaveBeenCalledWith(
-      expect.objectContaining({ defaultSize: { width: 1280, height: 720 } }),
-    )
-
-    // verify UpdateSceneConfig.execute
-    const { UpdateSceneConfig } = await import('./JSBCommand')
-    expect(UpdateSceneConfig).toHaveBeenCalledWith({
-      type: 'window',
-      defaultSize: { width: 800, height: 600 },
-    })
+  it('does not type removed window scene globals', () => {
+    // @ts-expect-error removed undocumented scene global
+    void window.xrCurrentSceneDefaults
+    // @ts-expect-error removed undocumented scene global
+    void window.xrCurrentSceneType
   })
 
-  it('with window type', async () => {
+  it('does not use opened-page globals to override pending scene config', async () => {
     vi.useFakeTimers()
 
     const mockFn = vi
       .fn()
       .mockResolvedValue({ defaultSize: { width: 800, height: 600 } })
-    window.xrCurrentSceneDefaults = mockFn
-    window.xrCurrentSceneType = 'window'
-
-    injectSceneHook()
-
-    document.dispatchEvent(new Event('DOMContentLoaded'))
-
-    await vi.runAllTimersAsync()
-
-    expect(mockFn).toHaveBeenCalledWith(
-      expect.objectContaining({ defaultSize: { width: 1280, height: 720 } }),
-    )
-
-    // verify UpdateSceneConfig.execute
-    const { UpdateSceneConfig } = await import('./JSBCommand')
-    expect(UpdateSceneConfig).toHaveBeenCalledWith({
-      type: 'window',
-      defaultSize: { width: 800, height: 600 },
-    })
-  })
-
-  it('with volume type', async () => {
-    vi.useFakeTimers()
-
-    const mockFn = vi.fn().mockResolvedValue({
-      defaultSize: { width: 1, height: 1, depth: 1 },
-      resizability: {
-        minWidth: 0.5,
-        minHeight: 1,
-        maxWidth: 0.5,
-        maxHeight: 1,
-      },
-    })
-    window.xrCurrentSceneDefaults = mockFn
-    window.xrCurrentSceneType = 'volume'
+    ;(window as any).xrCurrentSceneDefaults = mockFn
+    ;(window as any).xrCurrentSceneType = 'volume'
 
     injectSceneHook()
 
@@ -359,28 +317,9 @@ describe('injectScenePolyfill should call xrCurrentSceneDefaults and update scen
 
     await vi.runAllTimersAsync()
 
-    expect(mockFn).toHaveBeenCalledWith(
-      expect.objectContaining({
-        defaultSize: { width: '0.94m', height: '0.94m', depth: '0.94m' },
-      }),
-    )
-
-    // verify UpdateSceneConfig.execute
     const { UpdateSceneConfig } = await import('./JSBCommand')
-    expect(UpdateSceneConfig).toHaveBeenCalledWith({
-      type: 'volume',
-      defaultSize: {
-        width: pointToPhysical(1),
-        height: pointToPhysical(1),
-        depth: pointToPhysical(1),
-      },
-      resizability: {
-        minWidth: 0.5,
-        minHeight: 1,
-        maxWidth: 0.5,
-        maxHeight: 1,
-      },
-    })
+    expect(mockFn).not.toHaveBeenCalled()
+    expect(UpdateSceneConfig).not.toHaveBeenCalled()
   })
 })
 

package/src/scene-polyfill.ts

@@ -1,9 +1,8 @@
-import { createSpatialSceneCommand, FocusScene } from './JSBCommand'
-import { SpatialScene } from './SpatialScene'
+import { FocusScene } from './JSBCommand'
+import { openSpatialSceneSync } from './spatial-host'
 import {
   SpatialSceneCreationOptions,
   SpatialSceneType,
-  SpatialSceneState,
   isValidSceneUnit,
   isValidSpatialSceneType,
   isValidWorldScalingType,
@@ -73,33 +72,93 @@ function deepMergePlain<
   return out
 }
 
+/**
+ * Pick a value from a manifest-like object where both snake_case and camelCase may exist.
+ *
+ * Rule: if both keys exist on the same object, snake_case wins.
+ */
+function preferSnake<T>(
+  src: Record<string, any> | undefined,
+  snakeKey: string,
+  camelKey: string,
+): T | undefined {
+  if (!src) return undefined
+  if (src[snakeKey] !== undefined) return src[snakeKey] as T
+  if (src[camelKey] !== undefined) return src[camelKey] as T
+  return undefined
+}
+
+/**
+ * Normalize resizability keys from manifest input into the runtime camelCase shape.
+ *
+ * Accepts both:
+ * - camelCase: minWidth/minHeight/maxWidth/maxHeight
+ * - snake_case: min_width/min_height/max_width/max_height
+ *
+ * Rule: if both exist on the same object, snake_case wins.
+ */
+function normalizeResizability(
+  src: Record<string, any> | undefined,
+): SpatialSceneCreationOptions['resizability'] | undefined {
+  if (!src || typeof src !== 'object' || Array.isArray(src)) return undefined
+  const out: any = {}
+  const minWidth = preferSnake<any>(src, 'min_width', 'minWidth')
+  if (minWidth !== undefined) out.minWidth = minWidth
+  const minHeight = preferSnake<any>(src, 'min_height', 'minHeight')
+  if (minHeight !== undefined) out.minHeight = minHeight
+  const maxWidth = preferSnake<any>(src, 'max_width', 'maxWidth')
+  if (maxWidth !== undefined) out.maxWidth = maxWidth
+  const maxHeight = preferSnake<any>(src, 'max_height', 'maxHeight')
+  if (maxHeight !== undefined) out.maxHeight = maxHeight
+  return Object.keys(out).length > 0 ? out : undefined
+}
+
 /**
  * Normalize XRSpatialSceneDefaults (manifest shape) into SpatialSceneCreationOptions (runtime shape).
- * - Only remap default_size -> defaultSize when present.
- * - Leaves other keys (resizability, worldScaling, etc.) unchanged.
- * - Units are left as-is; downstream formatting is handled by formatSceneConfig.
+ *
+ * - Remaps supported snake_case aliases into camelCase keys.
+ * - Keeps output camelCase-only (snake_case keys are treated as input aliases).
+ * - Units are not formatted here; downstream formatting is handled by formatSceneConfig.
+ *
+ * Rule: if both snake_case and camelCase are present on the same object, snake_case wins.
  */
 function normalizeXRDefaultsToSceneOptions(
   src: XRSpatialSceneDefaults | Record<string, any>,
 ): SpatialSceneCreationOptions {
-  const out: any = { ...(src || {}) }
-  const ds =
-    (src as any).defaultSize !== undefined
-      ? (src as any).defaultSize
-      : (src as any).default_size
-  if (ds !== undefined) {
-    out.defaultSize = ds
-  }
-  if ('default_size' in out) {
-    delete out.default_size
-  }
+  const input: any = src || {}
+  const out: any = {}
+
+  const ds = preferSnake<any>(input, 'default_size', 'defaultSize')
+  if (ds !== undefined) out.defaultSize = ds
+
+  const res = input.resizability
+  const normalizedRes = normalizeResizability(res)
+  if (normalizedRes) out.resizability = normalizedRes
+
+  const worldScaling = preferSnake<any>(input, 'world_scaling', 'worldScaling')
+  if (worldScaling !== undefined) out.worldScaling = worldScaling
+
+  const worldAlignment = preferSnake<any>(
+    input,
+    'world_alignment',
+    'worldAlignment',
+  )
+  if (worldAlignment !== undefined) out.worldAlignment = worldAlignment
+
+  const baseplateVisibility = preferSnake<any>(
+    input,
+    'baseplate_visibility',
+    'baseplateVisibility',
+  )
+  if (baseplateVisibility !== undefined)
+    out.baseplateVisibility = baseplateVisibility
+
   return out
 }
 
 class SceneManager {
   private originalOpen: any
   private static instance: SceneManager
-  private manifestReady: Promise<void> | null = null
   static getInstance() {
     if (!SceneManager.instance) {
       SceneManager.instance = new SceneManager()
@@ -108,7 +167,9 @@ class SceneManager {
   }
 
   init(window: WindowProxy) {
-    this.manifestReady = this.setupManifest()
+    // Load manifest defaults in the background; scene creation reads the
+    // resolved xr_window_defaults / xr_volume_defaults once available.
+    void this.setupManifest()
     this.originalOpen = window.open.bind(window)
     ;(window as any).open = this.open
   }
@@ -124,10 +185,6 @@ class SceneManager {
     return this.configMap[name]
   }
 
-  waitManifest(): Promise<void> {
-    return this.manifestReady ?? Promise.resolve()
-  }
-
   // Ensure URL is absolute; only convert when a relative path is provided
   // - Keep external and special schemes untouched (http, https, data, blob, about, file, mailto, etc.)
   // - Handle protocol-relative URLs (//example.com/path)
@@ -157,12 +214,41 @@ class SceneManager {
       const xr = manifest?.xr_spatial_scene
       if (!xr || typeof xr !== 'object') return
       const { overrides, ...topLevel } = xr as XRSpatialSceneConfig
-      // Merge top-level defaults with per-scene overrides.
-      const windowRaw = deepMergePlain(topLevel, overrides?.window_scene)
-      const volumeRaw = deepMergePlain(topLevel, overrides?.volume_scene)
-      const windowNext = normalizeXRDefaultsToSceneOptions(windowRaw)
 
-      const volumeNext = normalizeXRDefaultsToSceneOptions(volumeRaw)
+      // Normalize top-level defaults and per-type overrides separately, then deep-merge.
+      // - Ensures overrides keep higher priority than top-level defaults.
+      // - Ensures snake_case vs camelCase resolution is applied within the same object only.
+      // - This affects only manifest-resolved defaults; initScene callback chaining remains unchanged
+      //   because callbackReturnMap stores the raw callback return values.
+      const normalizedTopLevel = normalizeXRDefaultsToSceneOptions(
+        topLevel as any,
+      )
+      const overrideObj: any = overrides as any
+      const windowOverrideSrc = preferSnake<any>(
+        overrideObj,
+        'window_scene',
+        'windowScene',
+      )
+      const volumeOverrideSrc = preferSnake<any>(
+        overrideObj,
+        'volume_scene',
+        'volumeScene',
+      )
+      const normalizedWindowOverride = windowOverrideSrc
+        ? normalizeXRDefaultsToSceneOptions(windowOverrideSrc)
+        : undefined
+      const normalizedVolumeOverride = volumeOverrideSrc
+        ? normalizeXRDefaultsToSceneOptions(volumeOverrideSrc)
+        : undefined
+
+      const windowNext = deepMergePlain(
+        normalizedTopLevel,
+        normalizedWindowOverride,
+      )
+      const volumeNext = deepMergePlain(
+        normalizedTopLevel,
+        normalizedVolumeOverride,
+      )
       if (windowNext && Object.keys(windowNext).length > 0) {
         xr_window_defaults = windowNext
       }
@@ -193,9 +279,12 @@ class SceneManager {
           const host = window.location.host
           const protocol = window.location.protocol
           const finalURL = `${protocol}//${host}/${token}/?command=${command}`
-          const rid = new URL(url).searchParams.get('rid')
+          const sourceParams = new URL(url).searchParams
           const final = new URL(finalURL)
-          if (rid) final.searchParams.set('rid', rid)
+          for (const key of ['rid', 'wsepoch']) {
+            const value = sourceParams.get(key)
+            if (value) final.searchParams.set(key, value)
+          }
           return this.originalOpen(final.toString(), target, features)
         }
       }
@@ -221,8 +310,12 @@ class SceneManager {
       cfg = { ...ans, type: 'window' }
     }
 
-    const cmd = new createSpatialSceneCommand(url!, cfg, target, features)
-    const result = cmd.executeSync()
+    const result = openSpatialSceneSync(
+      url!,
+      cfg as SpatialSceneCreationOptionsInternal,
+      target,
+      features,
+    )
 
     const id = result.data?.id
 
@@ -429,8 +522,6 @@ export function formatSceneConfig(
   // defaultSize should format into px if window
   // defaultSize should format into m if volume
 
-  const defaultSceneConfig = getSceneDefaultConfig(sceneType)
-
   const errors: string[] = []
 
   const isWindow = sceneType === 'window'
@@ -567,65 +658,7 @@ function getSceneDefaultConfig(sceneType: SpatialSceneType) {
     : xr_volume_defaults || defaultSceneConfigVolume
 }
 
-async function injectScenePolyfill() {
-  if (!window.opener) return
-
-  const state = await SpatialScene.getInstance().getState()
-
-  // only run this in pending state
-  if (state !== SpatialSceneState.pending) return
-
-  function onContentLoaded(callback: any) {
-    if (
-      document.readyState === 'interactive' ||
-      document.readyState === 'complete'
-    ) {
-      callback()
-    } else {
-      document.addEventListener('DOMContentLoaded', callback)
-    }
-  }
-
-  onContentLoaded(async () => {
-    await SceneManager.getInstance().waitManifest()
-    const sceneType = window.xrCurrentSceneType ?? 'window'
-    const rawDefault = getSceneDefaultConfig(sceneType)
-    // Provide a formatted 'pre' to the callback for consistent units and types.
-    const pre = deepCloneJSON(rawDefault)
-
-    let cfg = pre
-    if (typeof window.xrCurrentSceneDefaults === 'function') {
-      try {
-        cfg = await window.xrCurrentSceneDefaults?.(pre)
-      } catch (error) {
-        console.error(error)
-      }
-    }
-    // fixme: this duration is too short so that hide and show is at racing, so add a little delay to avoid
-    await new Promise((resolve, reject) => {
-      setTimeout(() => {
-        resolve(null)
-      }, 1000)
-    })
-
-    // Merge callback return with base defaults to ensure missing fields are filled.
-    const mergedCfg = deepMergePlain(deepCloneJSON(rawDefault), cfg)
-    const [formattedConfig, errors] = formatSceneConfig(mergedCfg, sceneType)
-    if (errors.length > 0) {
-      console.warn(
-        `window.xrCurrentSceneDefaults with errors: ${errors.join(', ')}`,
-      )
-    }
-    const finalCfg = {
-      ...formattedConfig,
-      type: sceneType,
-    }
-    await SpatialScene.getInstance().updateSceneCreationConfig(finalCfg)
-  })
-}
-
 export function injectSceneHook() {
   hijackWindowOpen(window)
   hijackWindowATag(window)
-  injectScenePolyfill()
 }

package/src/spatial-host.ts

@@ -0,0 +1,25 @@
+import type { WebSpatialProtocolResult } from './platform-adapter/interface'
+import { getPlatform, getPlatformSync } from './platform-runtime'
+import type { SpatialSceneCreationOptionsInternal } from './types/internal'
+import type { AttachmentEntityOptions } from './types/types'
+
+export async function createNativeSpatialDiv(): Promise<WebSpatialProtocolResult> {
+  const platform = await getPlatform()
+  return platform.createNativeSpatialDiv()
+}
+
+export async function createNativeAttachment(
+  options: AttachmentEntityOptions,
+): Promise<WebSpatialProtocolResult> {
+  const platform = await getPlatform()
+  return platform.createNativeAttachment(options)
+}
+
+export function openSpatialSceneSync(
+  url: string,
+  config: SpatialSceneCreationOptionsInternal | undefined,
+  target?: string,
+  features?: string,
+): WebSpatialProtocolResult {
+  return getPlatformSync().openSpatialSceneSync(url, config, target, features)
+}

package/src/spatial-window-polyfill.ts

@@ -78,10 +78,20 @@ function hijackDocumentElementStyle() {
   const rawDocumentStyle = document.documentElement.style
   const styleProxy = new Proxy(rawDocumentStyle, {
     set: function (target, key, value) {
-      const ret = Reflect.set(target, key, value)
+      let ret: boolean
 
       if (key === SpatialGlobalCustomVars.backgroundMaterial) {
-        setCurrentWindowStyle(value)
+        target.setProperty(
+          SpatialGlobalCustomVars.backgroundMaterial,
+          String(value),
+        )
+        ret = true
+      } else {
+        ret = Reflect.set(target, key, value)
+      }
+
+      if (key === SpatialGlobalCustomVars.backgroundMaterial) {
+        setCurrentWindowStyle(String(value))
       }
 
       if (
@@ -106,6 +116,12 @@ function hijackDocumentElementStyle() {
       return ret
     },
     get: function (target, prop: string) {
+      if (prop === SpatialGlobalCustomVars.backgroundMaterial) {
+        return target.getPropertyValue(
+          SpatialGlobalCustomVars.backgroundMaterial,
+        )
+      }
+
       if (typeof target[prop as keyof CSSStyleDeclaration] === 'function') {
         return function (this: any, ...args: any[]) {
           if (prop === 'setProperty') {

package/src/transform-roundtrip.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, test } from 'vitest'
+import { composeSRT, decomposeSRT } from './utils'
+
+function approxEqual(a: number, b: number, eps = 1e-6) {
+  return Math.abs(a - b) < eps
+}
+
+describe('composeSRT / decomposeSRT round-trip', () => {
+  test('identity transform round-trips', () => {
+    const pos = { x: 0, y: 0, z: 0 }
+    const rot = { x: 0, y: 0, z: 0 }
+    const scl = { x: 1, y: 1, z: 1 }
+
+    const matrix = composeSRT(pos, rot, scl)
+    const arr = Array.from(matrix.toFloat64Array())
+    const result = decomposeSRT(arr)
+
+    expect(approxEqual(result.position!.x, 0)).toBe(true)
+    expect(approxEqual(result.position!.y, 0)).toBe(true)
+    expect(approxEqual(result.position!.z, 0)).toBe(true)
+    expect(approxEqual(result.scale!.x, 1)).toBe(true)
+    expect(approxEqual(result.scale!.y, 1)).toBe(true)
+    expect(approxEqual(result.scale!.z, 1)).toBe(true)
+    expect(approxEqual(result.rotation!.x, 0)).toBe(true)
+    expect(approxEqual(result.rotation!.y, 0)).toBe(true)
+    expect(approxEqual(result.rotation!.z, 0)).toBe(true)
+  })
+
+  test('translation-only round-trips', () => {
+    const pos = { x: 3, y: -5, z: 10 }
+    const rot = { x: 0, y: 0, z: 0 }
+    const scl = { x: 1, y: 1, z: 1 }
+
+    const matrix = composeSRT(pos, rot, scl)
+    const arr = Array.from(matrix.toFloat64Array())
+    const result = decomposeSRT(arr)
+
+    expect(approxEqual(result.position!.x, 3)).toBe(true)
+    expect(approxEqual(result.position!.y, -5)).toBe(true)
+    expect(approxEqual(result.position!.z, 10)).toBe(true)
+  })
+
+  test('scale-only round-trips', () => {
+    const pos = { x: 0, y: 0, z: 0 }
+    const rot = { x: 0, y: 0, z: 0 }
+    const scl = { x: 2, y: 0.5, z: 3 }
+
+    const matrix = composeSRT(pos, rot, scl)
+    const arr = Array.from(matrix.toFloat64Array())
+    const result = decomposeSRT(arr)
+
+    expect(approxEqual(result.scale!.x, 2)).toBe(true)
+    expect(approxEqual(result.scale!.y, 0.5)).toBe(true)
+    expect(approxEqual(result.scale!.z, 3)).toBe(true)
+  })
+
+  test('rotation-only round-trips (45 deg Y)', () => {
+    const pos = { x: 0, y: 0, z: 0 }
+    const rot = { x: 0, y: 45, z: 0 }
+    const scl = { x: 1, y: 1, z: 1 }
+
+    const matrix = composeSRT(pos, rot, scl)
+    const arr = Array.from(matrix.toFloat64Array())
+    const result = decomposeSRT(arr)
+
+    expect(approxEqual(result.rotation!.x, 0)).toBe(true)
+    expect(approxEqual(result.rotation!.y, 45)).toBe(true)
+    expect(approxEqual(result.rotation!.z, 0)).toBe(true)
+  })
+
+  test('combined SRT round-trips', () => {
+    const pos = { x: 1, y: 2, z: 3 }
+    const rot = { x: 30, y: 45, z: 60 }
+    const scl = { x: 2, y: 3, z: 0.5 }
+
+    const matrix = composeSRT(pos, rot, scl)
+    const arr = Array.from(matrix.toFloat64Array())
+    const result = decomposeSRT(arr)
+
+    expect(approxEqual(result.position!.x, 1)).toBe(true)
+    expect(approxEqual(result.position!.y, 2)).toBe(true)
+    expect(approxEqual(result.position!.z, 3)).toBe(true)
+    expect(approxEqual(result.scale!.x, 2, 1e-4)).toBe(true)
+    expect(approxEqual(result.scale!.y, 3, 1e-4)).toBe(true)
+    expect(approxEqual(result.scale!.z, 0.5, 1e-4)).toBe(true)
+    expect(approxEqual(result.rotation!.x, 30, 0.1)).toBe(true)
+    expect(approxEqual(result.rotation!.y, 45, 0.1)).toBe(true)
+    expect(approxEqual(result.rotation!.z, 60, 0.1)).toBe(true)
+  })
+})