@webspatial/core-sdk 1.5.0 → 1.6.1

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.5.0"
+      window.__webspatialsdk__['core-sdk-version'] = "1.6.1"
   })()
     
 var __defProp = Object.defineProperty;
@@ -824,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";
@@ -1015,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 {
@@ -1554,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: {
@@ -1563,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();
@@ -1579,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)
@@ -1606,14 +1721,41 @@ 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")) {
-        const token = window.webSpatial?.genToken?.();
+      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=createSpatialized2DElement`;
+          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);
@@ -1627,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;
@@ -1639,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") {
@@ -1705,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}`);
       }
     }
@@ -1723,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}`);
       }
     }
@@ -1761,15 +1999,14 @@ function hijackWindowOpen(window2) {
 function hijackWindowATag(openedWindow) {
   openedWindow.document.onclick = function(e) {
     let element = e.target;
-    let found = false;
-    while (!found) {
-      if (element && element.tagName == "A") {
-        if (handleATag(e)) {
+    while (element) {
+      if (element.tagName == "A") {
+        if (handleATag(e, element)) {
           return false;
         }
         return true;
       }
-      if (element && element.parentElement) {
+      if (element.parentElement) {
         element = element.parentElement;
       } else {
         break;
@@ -1777,21 +2014,18 @@ function hijackWindowATag(openedWindow) {
     }
   };
 }
-function handleATag(event) {
-  const targetElement = event.target;
-  if (targetElement.tagName === "A") {
-    const link = targetElement;
-    const target = link.target;
-    const url = link.href;
-    if (target && target !== "_self") {
-      event.preventDefault();
-      window.open(url, target);
-      return true;
-    }
+function handleATag(event, link) {
+  if (event.defaultPrevented) return false;
+  const target = link.target;
+  const url = link.href;
+  if (target && target !== "_self") {
+    event.preventDefault();
+    window.open(url, target);
+    return true;
   }
 }
 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;
@@ -1805,13 +2039,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);
       }
@@ -1821,17 +2056,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() {
@@ -2082,10 +2318,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.
@@ -2097,6 +2335,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)
@@ -2119,17 +2368,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.
@@ -2137,15 +2469,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.
    */
@@ -2219,15 +2576,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() {
@@ -2675,8 +3033,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.
@@ -2811,7 +3169,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;
@@ -2855,70 +3213,10 @@ var Spatial = class {
    * @returns Client SDK version string in format "x.x.x"
    */
   getClientVersion() {
-    return "1.5.0";
+    return "1.6.1";
   }
 };
 
-// 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();