@webspatial/core-sdk 1.7.0 → 2.0.0

package/src/scene-polyfill.ts

@@ -1,10 +1,8 @@
 import { FocusScene } from './JSBCommand'
 import { openSpatialSceneSync } from './spatial-host'
-import { SpatialScene } from './SpatialScene'
 import {
   SpatialSceneCreationOptions,
   SpatialSceneType,
-  SpatialSceneState,
   isValidSceneUnit,
   isValidSpatialSceneType,
   isValidWorldScalingType,
@@ -74,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()
@@ -109,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
   }
@@ -125,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)
@@ -158,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
       }
@@ -194,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)
         }
       }
@@ -570,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-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)
+  })
+})

package/src/types/animation.ts

@@ -0,0 +1,224 @@
+import type { Vec3 } from './types'
+
+// ---- Timing function ----
+
+export type TimingFunction = 'linear' | 'easeIn' | 'easeOut' | 'easeInOut'
+
+// ---- Transform values ----
+
+/**
+ * Transform values used in animation callbacks (`onComplete`, `onCancel`).
+ * Rotation values are Euler angles in **degrees**, matching the input convention
+ * of `AnimationConfig` and the entity `rotation` prop.
+ */
+export interface TransformValues {
+  position?: Vec3
+  rotation?: Vec3
+  scale?: Vec3
+}
+
+// ---- Play state ----
+
+/**
+ * Represents the current state of an animation session as exposed by
+ * `api.playState`. The internal `delaying` state maps to `'running'`
+ * because from the developer's perspective the session is actively progressing.
+ */
+export type AnimationPlayState =
+  | 'idle'
+  | 'queued'
+  | 'running'
+  | 'paused'
+  | 'finished'
+
+// ---- Animation config ----
+
+/**
+ * Configuration for `useAnimation`.
+ *
+ * `to` is required and declares which transform fields are animated.
+ * `from` is optional; omitting it causes the native layer to snapshot
+ * the entity's current transform at playback time.
+ */
+export interface AnimationConfig {
+  /**
+   * Target transform values (required).
+   * Rotation values are Euler angles in degrees.
+   * Single-axis rotation > 180 deg may produce unexpected results (shortest-path SLERP).
+   */
+  to: TransformValues
+
+  /** Starting transform values. Omit to animate from the entity's current state. */
+  from?: TransformValues
+
+  /** Duration in seconds. Default: 0.3 */
+  duration?: number
+
+  /**
+   * Easing curve. Default: 'easeInOut'
+   * Only these four values are valid; other strings will throw at validation time.
+   */
+  timingFunction?: TimingFunction
+
+  /** Delay before playback starts, in seconds. Default: 0 */
+  delay?: number
+
+  /** Start automatically when the entity mounts. Default: true */
+  autoStart?: boolean
+
+  /**
+   * Loop behavior.
+   * - true: reset to `from` and replay (infinite reset loop)
+   * - { reverse: true }: alternate direction each cycle (infinite reverse loop)
+   * - undefined / false: play once
+   */
+  loop?: boolean | { reverse?: boolean }
+
+  /**
+   * Playback speed multiplier. Default: 1
+   * Values > 1 speed up; values between 0 and 1 slow down.
+   * Must be a positive finite number (> 0).
+   * Applied at session creation time and remains constant for the session.
+   * Maps to AnimationView.speed on the native (AVP) side.
+   */
+  playbackRate?: number
+
+  /** Called when the session is established successfully. */
+  onStart?: () => void
+
+  /** Called when a non-looping animation finishes naturally. */
+  onComplete?: (finalValues: TransformValues) => void
+
+  /** Called when playback is canceled via api.cancel(). Receives the restored transform. */
+  onCancel?: (currentValues: TransformValues) => void
+
+  /**
+   * Called when an asynchronous error occurs during a bridge or native operation.
+   * If not provided, the SDK logs the error via console.error.
+   */
+  onError?: (error: AnimationError) => void
+}
+
+// ---- Animation error ----
+
+export interface AnimationError {
+  /** The session that encountered the error. */
+  animationId: string
+  /** The command that failed. */
+  command: 'play' | 'pause' | 'resume' | 'cancel'
+  /** Optional machine-readable error code. */
+  code?: string
+  /** Human-readable failure reason. */
+  reason: string
+}
+
+// ---- Animation API (returned by useAnimation) ----
+
+export interface AnimationApi {
+  /** Start the animation, or continue it from paused progress. */
+  play(): void
+
+  /** Pause the animation at the current progress. */
+  pause(): void
+
+  /** Cancel the animation and restore `from`, or the start snapshot when `from` is omitted. */
+  cancel(): void
+
+  /** Whether the session is currently queued, delaying, or running (false while paused or idle). */
+  readonly isAnimating: boolean
+
+  /** Whether the animation is currently paused. */
+  readonly isPaused: boolean
+
+  /** Current session state. */
+  readonly playState: AnimationPlayState
+
+  /** Whether the most recent current session completed naturally. */
+  readonly finished: boolean
+}
+
+// ---- Animated props (opaque, passed to entity `animation` prop) ----
+
+/**
+ * Opaque object returned as the first tuple element of `useAnimation`.
+ * Pass it directly to the entity's `animation` prop.
+ * Application code should not read or modify its internal fields.
+ */
+export interface AnimatedProps {
+  /** @internal Unique identifier for this animation object. */
+  readonly __animationObjectId: string
+  /** @internal Transform fields targeted by this animation. */
+  readonly __animatedFields: readonly ('position' | 'rotation' | 'scale')[]
+  /** @internal Whether the animation currently has an alive session. */
+  readonly __animating: boolean
+}
+
+// ---- Cross-layer command / result ----
+
+/**
+ * Float4x4 is a 16-element column-major matrix stored in a Float64Array,
+ * matching `DOMMatrix.toFloat64Array()`.
+ */
+export type Float4x4 = Float64Array
+
+/**
+ * Unified command sent from React SDK -> Core SDK -> native.
+ */
+export interface AnimateTransformCommand {
+  /**
+   * Unique session identifier. A new `animationId` is generated for each
+   * `play` command; `pause`, `resume`, and `stop` reuse the session's id.
+   */
+  animationId: string
+  type: 'play' | 'pause' | 'resume' | 'cancel'
+  /** Required when type is 'play'; ignored otherwise. */
+  entityId?: string
+  toTransform?: Float4x4
+  fromTransform?: Float4x4
+  duration?: number
+  timingFunction?: TimingFunction
+  delay?: number
+  loop?: boolean | { reverse?: boolean }
+  /** Playback speed multiplier. Default: 1. Must be positive (> 0). Maps to AnimationView.speed on AVP. */
+  playbackRate?: number
+}
+
+/**
+ * Result returned by `SpatialEntity.animateTransform({ type: 'play' })`.
+ */
+export interface AnimateTransformResult {
+  animationId: string
+  /** Resolves when a non-looping animation completes naturally. */
+  finished: Promise<TransformValues>
+  /**
+   * Resolves when the animation is canceled and restored to `from`.
+   * After cancel, `finished` MUST remain pending (not rejected).
+   */
+  canceled: Promise<TransformValues>
+  /**
+   * Resolves when the animation fails due to a native or bridge error.
+   * Optional because older native runtimes may not emit the failed event.
+   */
+  failed?: Promise<AnimationError>
+}
+
+// ---- Internal animated props (cross-layer communication) ----
+
+/**
+ * @internal
+ * Extended interface for `AnimatedProps` used internally by the entity layer
+ * to bind/unbind animations and query suppressed transform fields.
+ * Application code should never use this interface directly.
+ */
+export interface AnimatedPropsInternal extends AnimatedProps {
+  /** Called by the entity layer when the entity instance becomes available. */
+  __bind: (
+    entity: import('../reality/entity/SpatialEntity').SpatialEntity,
+  ) => void
+  /** Called by the entity layer when the entity is destroyed or animation prop changes. */
+  __unbind: () => void
+  /** Returns the transform fields currently suppressed by an alive animation session. */
+  __getSuppressedFields: () =>
+    | readonly ('position' | 'rotation' | 'scale')[]
+    | null
+}

package/src/types/global.ts

@@ -1,15 +1,8 @@
 import type { PhysicalMetricsValueShape } from '../physicalMetrics'
-import type { SpatialSceneCreationOptions, SpatialSceneType } from './types'
-
 declare global {
   const __WEBSPATIAL_CORE_SDK_VERSION__: string
 
   interface Window {
-    xrCurrentSceneType: SpatialSceneType
-    xrCurrentSceneDefaults: (
-      defaultConfig: SpatialSceneCreationOptions,
-    ) => Promise<SpatialSceneCreationOptions>
-
     // Location for webspatial custom functions
     __WebSpatialData: {
       androidNativeMessage: Function
@@ -35,11 +28,11 @@ declare global {
     WebSpatailNativeVersion: string
 
     __webspatialsdk__?: {
-      XR_ENV?: string
       'natvie-version'?: string
       'react-sdk-version'?: string
       'core-sdk-version'?: string
       physicalMetrics?: PhysicalMetricsValueShape
+      pageEpoch?: string | number
     }
 
     /** Present when `supports('xrInnerDepth')` is true; otherwise `undefined`. */

package/src/types/motion/index.ts

@@ -0,0 +1,10 @@
+export * from './spatializedVisual'
+export * from './spatializedPlayback'
+export type {
+  SpatializedMotionKind,
+  SpatializedMotionSegmentConfig,
+  SpatializedMotionTimelineConfig,
+  SpatializedMotionConfig,
+  SpatializedMotionPlayState,
+  SpatializedPlaybackApi,
+} from './spatializedMotion'