@webspatial/core-sdk 1.4.0 → 1.6.0

package/dist/index.js

@@ -2,7 +2,7 @@
     (function(){
       if(typeof window === 'undefined') return;
       if(!window.__webspatialsdk__) window.__webspatialsdk__ = {}
-      window.__webspatialsdk__['core-sdk-version'] = "1.4.0"
+      window.__webspatialsdk__['core-sdk-version'] = "1.6.0"
   })()
     
 var __defProp = Object.defineProperty;
@@ -477,24 +477,24 @@ var init_SpatialWebEvent = __esm({
   }
 });
 
-// src/platform-adapter/xr/XRPlatform.ts
-var XRPlatform_exports = {};
-__export(XRPlatform_exports, {
-  XRPlatform: () => XRPlatform
+// src/platform-adapter/pico-os/PicoOSPlatform.ts
+var PicoOSPlatform_exports = {};
+__export(PicoOSPlatform_exports, {
+  PicoOSPlatform: () => PicoOSPlatform
 });
 function nextRequestId() {
   requestId = (requestId + 1) % MAX_ID;
   return `rId_${requestId}`;
 }
-var requestId, MAX_ID, XRPlatform;
-var init_XRPlatform = __esm({
-  "src/platform-adapter/xr/XRPlatform.ts"() {
+var requestId, MAX_ID, PicoOSPlatform;
+var init_PicoOSPlatform = __esm({
+  "src/platform-adapter/pico-os/PicoOSPlatform.ts"() {
     "use strict";
     init_CommandResultUtils();
     init_SpatialWebEvent();
     requestId = 0;
     MAX_ID = 1e5;
-    XRPlatform = class {
+    PicoOSPlatform = class {
       async callJSB(cmd, msg) {
         return new Promise((resolve, reject) => {
           try {
@@ -520,7 +520,7 @@ var init_XRPlatform = __esm({
               }
             }
           } catch (error) {
-            console.error(`XRPlatform cmd: ${cmd}, msg: ${msg} error: ${error}`);
+            console.error(`SwanPlatform cmd: ${cmd}, msg: ${msg} error: ${error}`);
             const { code, message } = error;
             resolve(CommandResultFailure(code, message));
           }
@@ -534,7 +534,6 @@ var init_XRPlatform = __esm({
             SpatialWebEvent.addEventReceiver(
               createdId,
               (result) => {
-                console.log("createdId", createdId, result.spatialId);
                 resolve(
                   CommandResultSuccess({
                     windowProxy,
@@ -546,13 +545,11 @@ var init_XRPlatform = __esm({
             );
             windowProxy = this.openWindow(
               command,
-              query,
+              "rid=" + createdId,
               target,
               features
             ).windowProxy;
-            windowProxy?.open(`about:blank?rid=${createdId}`, "_self");
           } catch (error) {
-            console.error(`open window error: ${error}`);
             const { code, message } = error;
             SpatialWebEvent.removeEventReceiver(createdId);
             resolve(CommandResultFailure(code, message));
@@ -767,8 +764,8 @@ function createPlatform() {
     const PuppeteerPlatform2 = (init_PuppeteerPlatform(), __toCommonJS(PuppeteerPlatform_exports)).PuppeteerPlatform;
     return new PuppeteerPlatform2();
   } else if (userAgent.includes("PicoWebApp") && isVersionGreater(webSpatialVersion, [0, 0, 1])) {
-    const XRPlatform2 = (init_XRPlatform(), __toCommonJS(XRPlatform_exports)).XRPlatform;
-    return new XRPlatform2();
+    const PicoOSPlatform2 = (init_PicoOSPlatform(), __toCommonJS(PicoOSPlatform_exports)).PicoOSPlatform;
+    return new PicoOSPlatform2();
   } else if (userAgent.includes("Android") || userAgent.includes("Linux")) {
     const AndroidPlatform2 = (init_AndroidPlatform(), __toCommonJS(AndroidPlatform_exports)).AndroidPlatform;
     return new AndroidPlatform2();
@@ -827,6 +824,16 @@ function composeSRT(position, rotation, scale) {
   m = m.scale(sx, sy, sz);
   return m;
 }
+function deepCloneJSON(value) {
+  const sc = globalThis.structuredClone;
+  if (typeof sc === "function") {
+    try {
+      return sc(value);
+    } catch {
+    }
+  }
+  return JSON.parse(JSON.stringify(value));
+}
 var init_utils = __esm({
   "src/utils.ts"() {
     "use strict";
@@ -834,7 +841,7 @@ var init_utils = __esm({
 });
 
 // src/JSBCommand.ts
-var platform, JSBCommand, UpdateEntityPropertiesCommand, UpdateEntityEventCommand, UpdateSpatialSceneProperties, UpdateSceneConfig, FocusScene, GetSpatialSceneState, SpatializedElementCommand, UpdateSpatialized2DElementProperties, UpdateSpatializedDynamic3DElementProperties, UpdateUnlitMaterialProperties, UpdateSpatializedElementTransform, UpdateSpatializedStatic3DElementProperties, AddSpatializedElementToSpatialized2DElement, AddSpatializedElementToSpatialScene, CreateSpatializedStatic3DElementCommand, CreateSpatializedDynamic3DElementCommand, CreateSpatialEntityCommand, CreateModelComponentCommand, CreateSpatialModelEntityCommand, CreateModelAssetCommand, CreateSpatialGeometryCommand, CreateSpatialUnlitMaterialCommand, AddComponentToEntityCommand, SetParentForEntityCommand, ConvertFromEntityToEntityCommand, ConvertFromEntityToSceneCommand, ConvertFromSceneToEntityCommand, ConvertCoordinateCommand, InspectCommand, DestroyCommand, CheckWebViewCanCreateCommand, WebSpatialProtocolCommand, createSpatialized2DElementCommand, createSpatialSceneCommand, CreateAttachmentEntityCommand, InitializeAttachmentCommand, UpdateAttachmentEntityCommand;
+var platform, JSBCommand, UpdateEntityPropertiesCommand, UpdateEntityEventCommand, UpdateSpatialSceneProperties, UpdateSceneConfig, FocusScene, GetSpatialSceneState, SpatializedElementCommand, UpdateSpatialized2DElementProperties, UpdateSpatializedDynamic3DElementProperties, UpdateUnlitMaterialProperties, UpdateSpatializedElementTransform, UpdateSpatializedStatic3DElementProperties, AddSpatializedElementToSpatialized2DElement, AddSpatializedElementToSpatialScene, CreateSpatializedStatic3DElementCommand, CreateSpatializedDynamic3DElementCommand, CreateSpatialEntityCommand, CreateModelComponentCommand, CreateSpatialModelEntityCommand, CreateModelAssetCommand, CreateSpatialGeometryCommand, CreateSpatialUnlitMaterialCommand, AddComponentToEntityCommand, RemoveComponentFromEntityCommand, SetMaterialsOnEntityCommand, SetParentForEntityCommand, ConvertFromEntityToEntityCommand, ConvertFromEntityToSceneCommand, ConvertFromSceneToEntityCommand, ConvertCoordinateCommand, InspectCommand, DestroyCommand, CheckWebViewCanCreateCommand, WebSpatialProtocolCommand, createSpatialized2DElementCommand, createSpatialSceneCommand, CreateAttachmentEntityCommand, InitializeAttachmentCommand, UpdateAttachmentEntityCommand;
 var init_JSBCommand = __esm({
   "src/JSBCommand.ts"() {
     "use strict";
@@ -1018,14 +1025,16 @@ var init_JSBCommand = __esm({
       }
     };
     CreateSpatializedStatic3DElementCommand = class extends JSBCommand {
-      constructor(modelURL) {
+      constructor(modelURL, sources) {
         super();
         this.modelURL = modelURL;
+        this.sources = sources;
         this.modelURL = modelURL;
+        this.sources = sources;
       }
       commandType = "CreateSpatializedStatic3DElement";
       getParams() {
-        return { modelURL: this.modelURL };
+        return { modelURL: this.modelURL, sources: this.sources };
       }
     };
     CreateSpatializedDynamic3DElementCommand = class extends JSBCommand {
@@ -1111,6 +1120,34 @@ var init_JSBCommand = __esm({
       }
       commandType = "AddComponentToEntity";
     };
+    RemoveComponentFromEntityCommand = class extends JSBCommand {
+      constructor(entity, comp) {
+        super();
+        this.entity = entity;
+        this.comp = comp;
+      }
+      getParams() {
+        return {
+          entityId: this.entity.id,
+          componentId: this.comp.id
+        };
+      }
+      commandType = "RemoveComponentFromEntity";
+    };
+    SetMaterialsOnEntityCommand = class extends JSBCommand {
+      constructor(entityId, materials) {
+        super();
+        this.entityId = entityId;
+        this.materials = materials;
+      }
+      getParams() {
+        return {
+          entityId: this.entityId,
+          materialIds: this.materials.map((m) => m.id)
+        };
+      }
+      commandType = "SetMaterialsOnEntity";
+    };
     SetParentForEntityCommand = class extends JSBCommand {
       // childId, parentId
       constructor(childId, parentId) {
@@ -1529,6 +1566,69 @@ var CubeInfo = class {
   }
 };
 
+// src/scene-polyfill.ts
+init_utils();
+
+// src/physicalMetrics.ts
+var physicalMetrics_exports = {};
+__export(physicalMetrics_exports, {
+  getValue: () => getValue,
+  physicalToPoint: () => physicalToPoint,
+  pointToPhysical: () => pointToPhysical,
+  subscribe: () => subscribe
+});
+init_SpatialWebEvent();
+var snapshot = {
+  meterToPtUnscaled: 1360,
+  meterToPtScaled: 1360
+};
+function getWorldScalingCompensation(options) {
+  return options?.worldScalingCompensation ?? "scaled";
+}
+function pointToPhysical(point, options) {
+  updateValue();
+  const compensation = getWorldScalingCompensation(options);
+  if (compensation === "unscaled") {
+    return point / snapshot.meterToPtUnscaled;
+  }
+  return point / snapshot.meterToPtScaled;
+}
+function physicalToPoint(physical, options) {
+  updateValue();
+  const compensation = getWorldScalingCompensation(options);
+  if (compensation === "unscaled") {
+    return physical * snapshot.meterToPtUnscaled;
+  }
+  return physical * snapshot.meterToPtScaled;
+}
+function updateValue() {
+  if (typeof window === "undefined") return;
+  const src = window.__webspatialsdk__?.physicalMetrics;
+  if (!src) return;
+  const next = {
+    meterToPtScaled: src.meterToPtScaled ?? snapshot.meterToPtScaled,
+    meterToPtUnscaled: src.meterToPtUnscaled ?? snapshot.meterToPtUnscaled
+  };
+  if (next.meterToPtScaled !== snapshot.meterToPtScaled || next.meterToPtUnscaled !== snapshot.meterToPtUnscaled) {
+    snapshot = next;
+  }
+}
+function getValue() {
+  updateValue();
+  return snapshot;
+}
+function subscribe(cb) {
+  if (typeof window === "undefined") return () => {
+  };
+  const handler = () => {
+    cb();
+  };
+  SpatialWebEvent.addEventReceiver("window", handler);
+  return () => {
+    SpatialWebEvent.removeEventReceiver("window");
+  };
+}
+
 // src/scene-polyfill.ts
 var defaultSceneConfig = {
   defaultSize: {
@@ -1538,15 +1638,47 @@ var defaultSceneConfig = {
 };
 var defaultSceneConfigVolume = {
   defaultSize: {
-    width: 0.94,
-    height: 0.94,
-    depth: 0.94
+    width: "0.94m",
+    height: "0.94m",
+    depth: "0.94m"
   }
 };
+var xr_window_defaults = {
+  ...defaultSceneConfig
+};
+var xr_volume_defaults = {
+  ...defaultSceneConfigVolume
+};
 var INTERNAL_SCHEMA_PREFIX = "webspatial://";
+function deepMergePlain(base, over) {
+  if (!over) return { ...base || {} };
+  const out = { ...base || {} };
+  for (const k of Object.keys(over)) {
+    const bv = out[k];
+    const ov = over[k];
+    if (ov && typeof ov === "object" && !Array.isArray(ov) && bv && typeof bv === "object" && !Array.isArray(bv)) {
+      out[k] = deepMergePlain(bv, ov);
+    } else {
+      out[k] = ov;
+    }
+  }
+  return out;
+}
+function normalizeXRDefaultsToSceneOptions(src) {
+  const out = { ...src || {} };
+  const ds = src.defaultSize !== void 0 ? src.defaultSize : src.default_size;
+  if (ds !== void 0) {
+    out.defaultSize = ds;
+  }
+  if ("default_size" in out) {
+    delete out.default_size;
+  }
+  return out;
+}
 var SceneManager = class _SceneManager {
   originalOpen;
   static instance;
+  manifestReady = null;
   static getInstance() {
     if (!_SceneManager.instance) {
       _SceneManager.instance = new _SceneManager();
@@ -1554,15 +1686,23 @@ var SceneManager = class _SceneManager {
     return _SceneManager.instance;
   }
   init(window2) {
+    this.manifestReady = this.setupManifest();
     this.originalOpen = window2.open.bind(window2);
     window2.open = this.open;
   }
+  // Stores the latest formatted config used by the platform (per scene name).
+  // This object contains normalized values and is safe for internal consumption.
   configMap = {};
-  // name=>config
+  // Stores the raw callback return value (per scene name) to feed into the next initScene call as `pre`.
+  // We keep this unformatted so developers receive exactly what they last returned.
+  callbackReturnMap = {};
   getConfig(name) {
     if (name === void 0 || !this.configMap[name]) return void 0;
     return this.configMap[name];
   }
+  waitManifest() {
+    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)
@@ -1581,8 +1721,47 @@ var SceneManager = class _SceneManager {
       return raw;
     }
   }
+  async setupManifest() {
+    const manifest = await this.getPWAManifest();
+    try {
+      const xr = manifest?.xr_spatial_scene;
+      if (!xr || typeof xr !== "object") return;
+      const { overrides, ...topLevel } = xr;
+      const windowRaw = deepMergePlain(topLevel, overrides?.window_scene);
+      const volumeRaw = deepMergePlain(topLevel, overrides?.volume_scene);
+      const windowNext = normalizeXRDefaultsToSceneOptions(windowRaw);
+      const volumeNext = normalizeXRDefaultsToSceneOptions(volumeRaw);
+      if (windowNext && Object.keys(windowNext).length > 0) {
+        xr_window_defaults = windowNext;
+      }
+      if (volumeNext && Object.keys(volumeNext).length > 0) {
+        xr_volume_defaults = volumeNext;
+      }
+    } catch (error) {
+      console.warn(
+        "SceneManager.setupManifest failed; using built-in defaults.",
+        error?.message || error
+      );
+    }
+  }
   open = (url, target, features) => {
     if (url?.startsWith(INTERNAL_SCHEMA_PREFIX)) {
+      if (url.includes("createSpatialized2DElement") || url.includes("createAttachment")) {
+        const token = (
+          //@ts-ignore
+          (window.webSpatial || window.__webspatialShell__)?.genToken?.()
+        );
+        if (token) {
+          const command = url.includes("createAttachment") ? "createAttachment" : "createSpatialized2DElement";
+          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 final = new URL(finalURL);
+          if (rid) final.searchParams.set("rid", rid);
+          return this.originalOpen(final.toString(), target, features);
+        }
+      }
       return this.originalOpen(url, target, features);
     }
     url = this.ensureAbsoluteUrl(url);
@@ -1590,7 +1769,12 @@ var SceneManager = class _SceneManager {
       const newWindow = this.originalOpen(url, target, features);
       return newWindow;
     }
-    const cfg = target ? this.getConfig(target) : void 0;
+    let cfg = target ? this.getConfig(target) : void 0;
+    if (cfg === void 0) {
+      const preFormatted = deepCloneJSON(getSceneDefaultConfig("window"));
+      const [ans] = formatSceneConfig(preFormatted, "window");
+      cfg = { ...ans, type: "window" };
+    }
     const cmd = new createSpatialSceneCommand(url, cfg, target, features);
     const result = cmd.executeSync();
     const id = result.data?.id;
@@ -1602,23 +1786,116 @@ var SceneManager = class _SceneManager {
   };
   initScene(name, callback, options) {
     const sceneType = options?.type ?? "window";
-    const defaultConfig = getSceneDefaultConfig(sceneType);
-    const rawReturnVal = callback({ ...defaultConfig });
-    const [formattedConfig, errors] = formatSceneConfig(rawReturnVal, sceneType);
+    const defaultConfigRaw = getSceneDefaultConfig(sceneType);
+    const previousOrDefault = this.callbackReturnMap[name] ?? (() => {
+      const cloned = deepCloneJSON(defaultConfigRaw);
+      return cloned;
+    })();
+    const rawReturnVal = callback(previousOrDefault);
+    const sanitizedReturnVal = sanitizeSceneOptionsUnits(
+      deepCloneJSON(rawReturnVal)
+    );
+    const clonedForFormat = deepCloneJSON(sanitizedReturnVal);
+    const baseDefaults = deepCloneJSON(getSceneDefaultConfig(sceneType));
+    const mergedForFormat = deepMergePlain(baseDefaults, clonedForFormat);
+    const [formattedConfig, errors] = formatSceneConfig(
+      mergedForFormat,
+      sceneType
+    );
     if (errors.length > 0) {
       console.warn(`initScene ${name} with errors: ${errors.join(", ")}`);
     }
+    this.callbackReturnMap[name] = sanitizedReturnVal;
     this.configMap[name] = {
       ...formattedConfig,
       type: sceneType
     };
   }
+  /**
+   * Resolve and load a PWA manifest as JSON:
+   * 1) Determine href:
+   *    - Prefer explicit manifestUrl if provided;
+   *    - Fallback to <link rel="manifest">, preferring the raw attribute over computed href.
+   * 2) Normalize href to absolute using ensureAbsoluteUrl (respects <base href>).
+   * 3) Handle data URLs inline:
+   *    - data:...;base64,... → atob then JSON.parse
+   *    - data:...,... → decodeURIComponent then JSON.parse
+   * 4) Fetch with credentials same-origin first; if that fails (e.g., CORS), attempt unauthenticated fetch.
+   * 5) Parse as JSON; if response body is text, parse the text as JSON.
+   */
+  async getPWAManifest(manifestUrl) {
+    let href = manifestUrl;
+    if (!href) {
+      const el = document.querySelector(
+        'link[rel="manifest"]'
+      );
+      href = el?.getAttribute("href") || el?.href;
+    }
+    if (!href) return;
+    href = this.ensureAbsoluteUrl(href);
+    if (!href) return;
+    if (href.startsWith("data:")) {
+      try {
+        const comma = href.indexOf(",");
+        if (comma < 0) return;
+        const meta = href.slice(5, comma);
+        const data = href.slice(comma + 1);
+        const isBase64 = /;base64/i.test(meta);
+        const decoded = isBase64 ? atob(data) : decodeURIComponent(data);
+        return JSON.parse(decoded);
+      } catch {
+        return;
+      }
+    }
+    try {
+      const res = await fetch(href, { credentials: "same-origin" });
+      if (!res.ok) throw new Error(String(res.status));
+      try {
+        return await res.json();
+      } catch {
+        const t = await res.text();
+        return JSON.parse(t);
+      }
+    } catch {
+      try {
+        const res = await fetch(href);
+        if (!res.ok) return;
+        try {
+          return await res.json();
+        } catch {
+          const t = await res.text();
+          return JSON.parse(t);
+        }
+      } catch {
+        return;
+      }
+    }
+  }
 };
+function sanitizeSceneOptionsUnits(val) {
+  if (val?.defaultSize) {
+    const keys = ["width", "height", "depth"];
+    for (const k of keys) {
+      if (k in val.defaultSize && !isValidSceneUnit(val.defaultSize[k])) {
+        delete val.defaultSize[k];
+      }
+    }
+  }
+  if (val?.resizability) {
+    const keys = ["minWidth", "minHeight", "maxWidth", "maxHeight"];
+    for (const k of keys) {
+      if (k in val.resizability && !isValidSceneUnit(val.resizability[k])) {
+        delete val.resizability[k];
+      }
+    }
+  }
+  return val;
+}
 function pxToMeter(px) {
-  return px / 1360;
+  return pointToPhysical(px);
 }
 function meterToPx(meter) {
-  return meter * 1360;
+  return physicalToPoint(meter);
 }
 function formatToNumber(str, targetUnit, defaultUnit) {
   if (typeof str === "number") {
@@ -1668,11 +1945,10 @@ function formatSceneConfig(config, sceneType) {
         config.defaultSize[k] = formatToNumber(
           config.defaultSize[k],
           isWindow ? "px" : "m",
-          isWindow ? "px" : "m"
+          "px"
         );
       } else {
-        ;
-        config.defaultSize[k] = defaultSceneConfig2.defaultSize[k];
+        delete config.defaultSize[k];
         errors.push(`defaultSize.${k}`);
       }
     }
@@ -1686,11 +1962,10 @@ function formatSceneConfig(config, sceneType) {
         config.resizability[k] = formatToNumber(
           config.resizability[k],
           "px",
-          isWindow ? "px" : "m"
+          "px"
         );
       } else {
-        ;
-        config.resizability[k] = void 0;
+        delete config.resizability[k];
         errors.push(`resizability.${k}`);
       }
     }
@@ -1754,7 +2029,7 @@ function handleATag(event) {
   }
 }
 function getSceneDefaultConfig(sceneType) {
-  return sceneType === "window" ? defaultSceneConfig : defaultSceneConfigVolume;
+  return sceneType === "window" ? xr_window_defaults || defaultSceneConfig : xr_volume_defaults || defaultSceneConfigVolume;
 }
 async function injectScenePolyfill() {
   if (!window.opener) return;
@@ -1768,13 +2043,14 @@ async function injectScenePolyfill() {
     }
   }
   onContentLoaded(async () => {
-    let provideDefaultSceneConfig = getSceneDefaultConfig(
-      window.xrCurrentSceneType ?? "window"
-    );
-    let cfg = provideDefaultSceneConfig;
+    await SceneManager.getInstance().waitManifest();
+    const sceneType = window.xrCurrentSceneType ?? "window";
+    const rawDefault = getSceneDefaultConfig(sceneType);
+    const pre = deepCloneJSON(rawDefault);
+    let cfg = pre;
     if (typeof window.xrCurrentSceneDefaults === "function") {
       try {
-        cfg = await window.xrCurrentSceneDefaults?.(provideDefaultSceneConfig);
+        cfg = await window.xrCurrentSceneDefaults?.(pre);
       } catch (error) {
         console.error(error);
       }
@@ -1784,17 +2060,18 @@ async function injectScenePolyfill() {
         resolve(null);
       }, 1e3);
     });
-    const sceneType = window.xrCurrentSceneType ?? "window";
-    const [formattedConfig, errors] = formatSceneConfig(cfg, sceneType);
+    const mergedCfg = deepMergePlain(deepCloneJSON(rawDefault), cfg);
+    const [formattedConfig, errors] = formatSceneConfig(mergedCfg, sceneType);
     if (errors.length > 0) {
       console.warn(
         `window.xrCurrentSceneDefaults with errors: ${errors.join(", ")}`
       );
     }
-    await SpatialScene.getInstance().updateSceneCreationConfig({
+    const finalCfg = {
       ...formattedConfig,
       type: sceneType
-    });
+    };
+    await SpatialScene.getInstance().updateSceneCreationConfig(finalCfg);
   });
 }
 function injectSceneHook() {
@@ -2045,10 +2322,12 @@ var SpatializedStatic3DElement = class extends SpatializedElement {
    * Registers the element to receive spatial events.
    * @param id Unique identifier for this element
    * @param modelURL URL of the 3D model
+   * @param sources Optional fallback model sources
    */
-  constructor(id, modelURL) {
+  constructor(id, modelURL, sources) {
     super(id);
     this.modelURL = modelURL;
+    this.sources = sources;
   }
   /**
    * Promise resolver for the ready state.
@@ -2060,6 +2339,17 @@ var SpatializedStatic3DElement = class extends SpatializedElement {
    * Used to reset the ready promise when the model URL changes.
    */
   modelURL;
+  /**
+   * Caches the last sources array to detect changes.
+   */
+  sources;
+  /**
+   * The model URL that was successfully loaded by the native runtime.
+   */
+  _currentSrc = "";
+  get currentSrc() {
+    return this._currentSrc;
+  }
   /**
    * Creates a new promise for tracking the ready state of the model.
    * @returns Promise that resolves when the model is loaded (true) or fails to load (false)
@@ -2082,17 +2372,100 @@ var SpatializedStatic3DElement = class extends SpatializedElement {
    * @returns Promise resolving when the update is complete
    */
   async updateProperties(properties) {
+    let needsReadyReset = false;
     if (properties.modelURL !== void 0) {
       if (this.modelURL !== properties.modelURL) {
         this.modelURL = properties.modelURL;
-        this.ready = this.createReadyPromise();
+        needsReadyReset = true;
       }
     }
+    if (properties.sources !== void 0) {
+      const prevJson = JSON.stringify(this.sources);
+      const nextJson = JSON.stringify(properties.sources);
+      if (prevJson !== nextJson) {
+        this.sources = properties.sources;
+        needsReadyReset = true;
+      }
+    }
+    if (needsReadyReset) {
+      this.ready = this.createReadyPromise();
+    }
+    if (properties.autoplay !== void 0) {
+      this._autoplay = properties.autoplay;
+    }
+    if (properties.loop !== void 0) {
+      this._loop = properties.loop;
+    }
+    if (properties.playbackRate !== void 0) {
+      this._playbackRate = properties.playbackRate;
+    }
     return new UpdateSpatializedStatic3DElementProperties(
       this,
       properties
     ).execute();
   }
+  /**
+   * Total animation duration in seconds, synced from native.
+   */
+  _duration = 0;
+  /**
+   * Returns the total animation duration in seconds.
+   */
+  get duration() {
+    return this._duration;
+  }
+  /**
+   * Playback speed multiplier.
+   */
+  _playbackRate = 1;
+  /**
+   * Returns the current playback rate.
+   */
+  get playbackRate() {
+    return this._playbackRate;
+  }
+  /**
+   * Sets the playback rate and sends it to native.
+   */
+  set playbackRate(value) {
+    this.updateProperties({ playbackRate: value });
+  }
+  /**
+   * Whether the animation is currently paused.
+   */
+  _paused = true;
+  /**
+   * Returns whether the animation is currently paused.
+   */
+  get paused() {
+    return this._paused;
+  }
+  /**
+   * Callback for animation state changes.
+   */
+  _onAnimationStateChangeCallback;
+  /**
+   * Sets the callback for animation state changes.
+   */
+  set onAnimationStateChangeCallback(callback) {
+    this._onAnimationStateChangeCallback = callback;
+  }
+  /**
+   * Starts or resumes animation playback.
+   * @returns Promise resolving when the command is sent
+   */
+  async play() {
+    this._paused = false;
+    await this.updateProperties({ animationPaused: false });
+  }
+  /**
+   * Pauses animation playback.
+   * @returns Promise resolving when the command is sent
+   */
+  async pause() {
+    this._paused = true;
+    await this.updateProperties({ animationPaused: true });
+  }
   /**
    * Processes events received from the WebSpatial environment.
    * Handles model loading events in addition to base spatial events.
@@ -2100,15 +2473,40 @@ var SpatializedStatic3DElement = class extends SpatializedElement {
    */
   onReceiveEvent(data) {
     if (data.type === "modelloaded" /* modelloaded */) {
+      this._currentSrc = data.detail?.src ?? this.modelURL ?? "";
       this._onLoadCallback?.();
       this._readyResolve?.(true);
     } else if (data.type === "modelloadfailed" /* modelloadfailed */) {
       this._onLoadFailureCallback?.();
       this._readyResolve?.(false);
+    } else if (data.type === "animationstatechange" /* animationstatechange */) {
+      this._paused = data.detail.paused;
+      this._duration = data.detail.duration;
+      this._onAnimationStateChangeCallback?.(data.detail);
     } else {
       super.onReceiveEvent(data);
     }
   }
+  /**
+   * Whether the model should automatically play its first animation on load.
+   */
+  _autoplay = false;
+  /**
+   * Returns whether autoplay is enabled for this element.
+   */
+  get autoplay() {
+    return this._autoplay;
+  }
+  /**
+   * Whether the model animation should loop continuously.
+   */
+  _loop = false;
+  /**
+   * Returns whether loop is enabled for this element.
+   */
+  get loop() {
+    return this._loop;
+  }
   /**
    * Callback function for successful model loading.
    */
@@ -2182,15 +2580,16 @@ async function createSpatialized2DElement() {
     return new Spatialized2DElement(id, windowProxy);
   }
 }
-async function createSpatializedStatic3DElement(modelURL) {
+async function createSpatializedStatic3DElement(modelURL, sources) {
   const result = await new CreateSpatializedStatic3DElementCommand(
-    modelURL
+    modelURL,
+    sources
   ).execute();
   if (!result.success) {
     throw new Error("createSpatializedStatic3DElement failed");
   } else {
     const { id } = result.data;
-    return new SpatializedStatic3DElement(id, modelURL);
+    return new SpatializedStatic3DElement(id, modelURL, sources);
   }
 }
 async function createSpatializedDynamic3DElement() {
@@ -2270,6 +2669,9 @@ var SpatialEntity = class extends SpatialObject {
   async addComponent(component) {
     return new AddComponentToEntityCommand(this, component).execute();
   }
+  async removeComponent(component) {
+    return new RemoveComponentFromEntityCommand(this, component).execute();
+  }
   async setPosition(position) {
     return this.updateTransform({ position });
   }
@@ -2422,6 +2824,7 @@ var SpatialEntity = class extends SpatialObject {
 };
 
 // src/reality/entity/SpatialModelEntity.ts
+init_JSBCommand();
 var SpatialModelEntity = class extends SpatialEntity {
   constructor(id, options, userData) {
     super(id, userData);
@@ -2429,6 +2832,9 @@ var SpatialModelEntity = class extends SpatialEntity {
     this.options = options;
     this.userData = userData;
   }
+  async setMaterials(materials) {
+    return new SetMaterialsOnEntityCommand(this.id, materials).execute();
+  }
 };
 
 // src/reality/component/SpatialComponent.ts
@@ -2631,8 +3037,8 @@ var SpatialSession = class {
    * @param modelURL Optional URL to the 3D model to load
    * @returns Promise resolving to a new SpatializedStatic3DElement instance
    */
-  createSpatializedStatic3DElement(modelURL) {
-    return createSpatializedStatic3DElement(modelURL);
+  createSpatializedStatic3DElement(modelURL, sources) {
+    return createSpatializedStatic3DElement(modelURL, sources);
   }
   /**
    * Initializes the spatial scene with custom configuration.
@@ -2767,7 +3173,7 @@ var Spatial = class {
    * @returns True if running in a spatial web environment, false otherwise
    */
   runInSpatialWeb() {
-    if (navigator.userAgent.indexOf("WebSpatial/") > 0) {
+    if (navigator.userAgent.indexOf("WebSpatial/") >= 0) {
       return true;
     }
     return false;
@@ -2811,70 +3217,10 @@ var Spatial = class {
    * @returns Client SDK version string in format "x.x.x"
    */
   getClientVersion() {
-    return "1.4.0";
+    return "1.6.0";
   }
 };
 
-// src/physicalMetrics.ts
-var physicalMetrics_exports = {};
-__export(physicalMetrics_exports, {
-  getValue: () => getValue,
-  physicalToPoint: () => physicalToPoint,
-  pointToPhysical: () => pointToPhysical,
-  subscribe: () => subscribe
-});
-init_SpatialWebEvent();
-var snapshot = {
-  meterToPtUnscaled: 1360,
-  meterToPtScaled: 1360
-};
-function getWorldScalingCompensation(options) {
-  return options?.worldScalingCompensation ?? "scaled";
-}
-function pointToPhysical(point, options) {
-  updateValue();
-  const compensation = getWorldScalingCompensation(options);
-  if (compensation === "unscaled") {
-    return point / snapshot.meterToPtUnscaled;
-  }
-  return point / snapshot.meterToPtScaled;
-}
-function physicalToPoint(physical, options) {
-  updateValue();
-  const compensation = getWorldScalingCompensation(options);
-  if (compensation === "unscaled") {
-    return physical * snapshot.meterToPtUnscaled;
-  }
-  return physical * snapshot.meterToPtScaled;
-}
-function updateValue() {
-  if (typeof window === "undefined") return;
-  const src = window.__webspatialsdk__?.physicalMetrics;
-  if (!src) return;
-  const next = {
-    meterToPtScaled: src.meterToPtScaled ?? snapshot.meterToPtScaled,
-    meterToPtUnscaled: src.meterToPtUnscaled ?? snapshot.meterToPtUnscaled
-  };
-  if (next.meterToPtScaled !== snapshot.meterToPtScaled || next.meterToPtUnscaled !== snapshot.meterToPtUnscaled) {
-    snapshot = next;
-  }
-}
-function getValue() {
-  updateValue();
-  return snapshot;
-}
-function subscribe(cb) {
-  if (typeof window === "undefined") return () => {
-  };
-  const handler = () => {
-    cb();
-  };
-  SpatialWebEvent.addEventReceiver("window", handler);
-  return () => {
-    SpatialWebEvent.removeEventReceiver("window");
-  };
-}
-
 // src/index.ts
 init_ssr_polyfill();