@webspatial/core-sdk 1.7.0 → 2.0.0

package/dist/motion/compute/validate.js

@@ -0,0 +1,103 @@
+import { SPATIALIZED_MOTION_PROPERTIES } from "../../types/motion/spatializedMotion";
+import { normalizeMotionConfig } from "./normalize";
+const ALLOWED_PROPERTIES = new Set(
+  SPATIALIZED_MOTION_PROPERTIES
+);
+const FORBIDDEN_PREFIXES = [
+  "width",
+  "height",
+  "back",
+  "backOffset",
+  "depth"
+];
+function validateSpatializedMotionConfig(config) {
+  if (config.tracks !== void 0) {
+    throw new Error("[SpatializedMotion] tracks authoring is internal");
+  }
+  const normalized = normalizeMotionConfig(config);
+  validateNormalizedMotionConfig(normalized);
+}
+function validateNormalizedMotionConfig(config) {
+  const { duration, tracks } = config;
+  if (typeof duration !== "number" || !Number.isFinite(duration) || duration <= 0) {
+    throw new Error("[SpatializedMotion] duration must be a finite number > 0");
+  }
+  if (!Array.isArray(tracks) || tracks.length === 0) {
+    throw new Error("[SpatializedMotion] tracks must be a non-empty array");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const track of tracks) {
+    validateTrack(track, duration, seen);
+  }
+  if (config.delay !== void 0) {
+    const d = config.delay;
+    if (typeof d !== "number" || !Number.isFinite(d) || d < 0) {
+      throw new Error("[SpatializedMotion] delay must be >= 0 and finite");
+    }
+  }
+  if (config.playbackRate !== void 0) {
+    const r = config.playbackRate;
+    if (typeof r !== "number" || !Number.isFinite(r) || r <= 0) {
+      throw new Error("[SpatializedMotion] playbackRate must be > 0 and finite");
+    }
+  }
+}
+function validateTrack(track, duration, seen) {
+  const prop = track.property;
+  for (const forbidden of FORBIDDEN_PREFIXES) {
+    if (prop === forbidden || prop.startsWith(`${forbidden}.`)) {
+      throw new Error(
+        `[SpatializedMotion] property "${prop}" is not animatable`
+      );
+    }
+  }
+  if (!ALLOWED_PROPERTIES.has(track.property)) {
+    throw new Error(`[SpatializedMotion] unknown property "${prop}"`);
+  }
+  if (seen.has(prop)) {
+    throw new Error(`[SpatializedMotion] duplicate track for "${prop}"`);
+  }
+  seen.add(prop);
+  const kf = track.keyframes;
+  if (!Array.isArray(kf) || kf.length < 2) {
+    throw new Error(
+      `[SpatializedMotion] track "${prop}" needs at least 2 keyframes`
+    );
+  }
+  let prevAt = -Infinity;
+  for (const frame of kf) {
+    if (typeof frame.at !== "number" || !Number.isFinite(frame.at)) {
+      throw new Error(
+        `[SpatializedMotion] keyframe.at must be finite for "${prop}"`
+      );
+    }
+    if (frame.at < 0 || frame.at > duration) {
+      throw new Error(
+        `[SpatializedMotion] keyframe.at must be within [0, duration] for "${prop}"`
+      );
+    }
+    if (frame.at <= prevAt) {
+      throw new Error(
+        `[SpatializedMotion] keyframe times must be strictly increasing for "${prop}"`
+      );
+    }
+    prevAt = frame.at;
+    validateScalar(frame.value, track.property);
+  }
+}
+function validateScalar(value, property) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`[SpatializedMotion] invalid value for ${property}`);
+  }
+  if (property === "opacity" && (value < 0 || value > 1)) {
+    throw new Error("[SpatializedMotion] opacity must be in [0, 1]");
+  }
+  if (property.startsWith("transform.scale.") && value < 0) {
+    throw new Error("[SpatializedMotion] scale must be >= 0");
+  }
+}
+export {
+  validateNormalizedMotionConfig,
+  validateSpatializedMotionConfig
+};
+//# sourceMappingURL=validate.js.map

package/dist/motion/compute/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/motion/compute/validate.ts"],"sourcesContent":["import { SPATIALIZED_MOTION_PROPERTIES } from '../../types/motion/spatializedMotion'\nimport type {\n  NormalizedSpatializedMotionConfig,\n  SpatializedMotionProperty,\n  SpatializedMotionConfig,\n  SpatializedMotionTrack,\n} from '../../types/motion/spatializedMotion'\nimport { normalizeMotionConfig } from './normalize'\nconst ALLOWED_PROPERTIES = new Set<SpatializedMotionProperty>(\n  SPATIALIZED_MOTION_PROPERTIES,\n)\n\nconst FORBIDDEN_PREFIXES = [\n  'width',\n  'height',\n  'back',\n  'backOffset',\n  'depth',\n] as const\n\n/**\n * Validates any supported motion config shape before playback or serialization.\n *\n * @param config Motion config in any supported input shape.\n */\nexport function validateSpatializedMotionConfig(\n  config: SpatializedMotionConfig,\n): void {\n  if (config.tracks !== undefined) {\n    throw new Error('[SpatializedMotion] tracks authoring is internal')\n  }\n  const normalized = normalizeMotionConfig(config)\n  validateNormalizedMotionConfig(normalized)\n}\n\n/**\n * Validates the canonical track-based motion config form.\n *\n * @param config Canonical motion config to validate.\n */\nexport function validateNormalizedMotionConfig(\n  config: NormalizedSpatializedMotionConfig,\n): void {\n  const { duration, tracks } = config\n\n  if (\n    typeof duration !== 'number' ||\n    !Number.isFinite(duration) ||\n    duration <= 0\n  ) {\n    throw new Error('[SpatializedMotion] duration must be a finite number > 0')\n  }\n\n  if (!Array.isArray(tracks) || tracks.length === 0) {\n    throw new Error('[SpatializedMotion] tracks must be a non-empty array')\n  }\n\n  const seen = new Set<string>()\n  for (const track of tracks) {\n    validateTrack(track, duration, seen)\n  }\n\n  if (config.delay !== undefined) {\n    const d = config.delay\n    if (typeof d !== 'number' || !Number.isFinite(d) || d < 0) {\n      throw new Error('[SpatializedMotion] delay must be >= 0 and finite')\n    }\n  }\n\n  if (config.playbackRate !== undefined) {\n    const r = config.playbackRate\n    if (typeof r !== 'number' || !Number.isFinite(r) || r <= 0) {\n      throw new Error('[SpatializedMotion] playbackRate must be > 0 and finite')\n    }\n  }\n}\n\n/**\n * Validates a single track against property and keyframe invariants.\n *\n * @param track Motion track to validate.\n * @param duration Parent motion duration.\n * @param seen Track-property set used to detect duplicates.\n */\nfunction validateTrack(\n  track: SpatializedMotionTrack,\n  duration: number,\n  seen: Set<string>,\n): void {\n  const prop = track.property as string\n  for (const forbidden of FORBIDDEN_PREFIXES) {\n    if (prop === forbidden || prop.startsWith(`${forbidden}.`)) {\n      throw new Error(\n        `[SpatializedMotion] property \"${prop}\" is not animatable`,\n      )\n    }\n  }\n\n  if (!ALLOWED_PROPERTIES.has(track.property)) {\n    throw new Error(`[SpatializedMotion] unknown property \"${prop}\"`)\n  }\n\n  if (seen.has(prop)) {\n    throw new Error(`[SpatializedMotion] duplicate track for \"${prop}\"`)\n  }\n  seen.add(prop)\n\n  const kf = track.keyframes\n  if (!Array.isArray(kf) || kf.length < 2) {\n    throw new Error(\n      `[SpatializedMotion] track \"${prop}\" needs at least 2 keyframes`,\n    )\n  }\n\n  let prevAt = -Infinity\n  for (const frame of kf) {\n    if (typeof frame.at !== 'number' || !Number.isFinite(frame.at)) {\n      throw new Error(\n        `[SpatializedMotion] keyframe.at must be finite for \"${prop}\"`,\n      )\n    }\n    if (frame.at < 0 || frame.at > duration) {\n      throw new Error(\n        `[SpatializedMotion] keyframe.at must be within [0, duration] for \"${prop}\"`,\n      )\n    }\n    if (frame.at <= prevAt) {\n      throw new Error(\n        `[SpatializedMotion] keyframe times must be strictly increasing for \"${prop}\"`,\n      )\n    }\n    prevAt = frame.at\n    validateScalar(frame.value, track.property)\n  }\n}\n\n/**\n * Validates a numeric sample for a specific motion property.\n *\n * @param value Numeric sample value to validate.\n * @param property Motion property the value belongs to.\n */\nfunction validateScalar(\n  value: number,\n  property: SpatializedMotionProperty,\n): void {\n  if (typeof value !== 'number' || !Number.isFinite(value)) {\n    throw new Error(`[SpatializedMotion] invalid value for ${property}`)\n  }\n  if (property === 'opacity' && (value < 0 || value > 1)) {\n    throw new Error('[SpatializedMotion] opacity must be in [0, 1]')\n  }\n  if (property.startsWith('transform.scale.') && value < 0) {\n    throw new Error('[SpatializedMotion] scale must be >= 0')\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/motion/index.d.ts

@@ -0,0 +1,8 @@
+export { b0 as AnimationObject, b1 as AnimationObjectCallbacks, b2 as AnimationObjectCreateOptions } from '../spatializedElementMotion-_0XWPQCE.js';
+export { validateSpatializedMotionConfig } from './compute/validate.js';
+import '../types/motion/spatializedVisual.js';
+import '../types/motion/spatializedPlayback.js';
+import '../types/global.js';
+import '../physicalMetrics-W5uZ5xKb.js';
+import '../SpatialObject.js';
+import '../reality/component/SpatialComponent.js';

package/dist/motion/index.js

@@ -0,0 +1,6 @@
+export * from "./AnimationObject";
+import { validateSpatializedMotionConfig } from "./compute/validate";
+export {
+  validateSpatializedMotionConfig
+};
+//# sourceMappingURL=index.js.map

package/dist/motion/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/motion/index.ts"],"sourcesContent":["export * from './AnimationObject'\nexport { validateSpatializedMotionConfig } from './compute/validate'\n"],"mappings":"AAAA,cAAc;AACd,SAAS,uCAAuC;","names":[]}

package/dist/motion/native/serializeMotionTimeline.d.ts

@@ -0,0 +1,12 @@
+import { a$ as NormalizedSpatializedMotionConfig, aO as SpatializedMotionTimeline } from '../../spatializedElementMotion-_0XWPQCE.js';
+import '../../types/motion/spatializedVisual.js';
+import '../../types/motion/spatializedPlayback.js';
+import '../../types/global.js';
+import '../../physicalMetrics-W5uZ5xKb.js';
+import '../../SpatialObject.js';
+import '../../reality/component/SpatialComponent.js';
+
+/** Full timeline payload for native. */
+declare function motionConfigToNativeTimeline(config: NormalizedSpatializedMotionConfig): SpatializedMotionTimeline;
+
+export { motionConfigToNativeTimeline };

package/dist/motion/native/serializeMotionTimeline.js

@@ -0,0 +1,21 @@
+function motionConfigToNativeTimeline(config) {
+  return {
+    duration: config.duration,
+    delay: config.delay,
+    playbackRate: config.playbackRate,
+    loop: config.loop,
+    tracks: config.tracks.map((track) => ({
+      property: track.property,
+      keyframes: track.keyframes.map((k) => ({
+        at: k.at,
+        value: k.value,
+        ...k.timingFunction !== void 0 ? { timingFunction: k.timingFunction } : {}
+      })),
+      timingFunction: track.timingFunction ?? config.timingFunction ?? "linear"
+    }))
+  };
+}
+export {
+  motionConfigToNativeTimeline
+};
+//# sourceMappingURL=serializeMotionTimeline.js.map

package/dist/motion/native/serializeMotionTimeline.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/motion/native/serializeMotionTimeline.ts"],"sourcesContent":["import type {\n  NormalizedSpatializedMotionConfig,\n  SpatializedMotionTimeline,\n} from '../../types/motion/spatializedMotion'\n\n/** Full timeline payload for native. */\nexport function motionConfigToNativeTimeline(\n  config: NormalizedSpatializedMotionConfig,\n): SpatializedMotionTimeline {\n  return {\n    duration: config.duration,\n    delay: config.delay,\n    playbackRate: config.playbackRate,\n    loop: config.loop,\n    tracks: config.tracks.map(track => ({\n      property: track.property,\n      keyframes: track.keyframes.map(k => ({\n        at: k.at,\n        value: k.value,\n        ...(k.timingFunction !== undefined\n          ? { timingFunction: k.timingFunction }\n          : {}),\n      })),\n      timingFunction: track.timingFunction ?? config.timingFunction ?? 'linear',\n    })),\n  }\n}\n"],"mappings":"AAMO,SAAS,6BACd,QAC2B;AAC3B,SAAO;AAAA,IACL,UAAU,OAAO;AAAA,IACjB,OAAO,OAAO;AAAA,IACd,cAAc,OAAO;AAAA,IACrB,MAAM,OAAO;AAAA,IACb,QAAQ,OAAO,OAAO,IAAI,YAAU;AAAA,MAClC,UAAU,MAAM;AAAA,MAChB,WAAW,MAAM,UAAU,IAAI,QAAM;AAAA,QACnC,IAAI,EAAE;AAAA,QACN,OAAO,EAAE;AAAA,QACT,GAAI,EAAE,mBAAmB,SACrB,EAAE,gBAAgB,EAAE,eAAe,IACnC,CAAC;AAAA,MACP,EAAE;AAAA,MACF,gBAAgB,MAAM,kBAAkB,OAAO,kBAAkB;AAAA,IACnE,EAAE;AAAA,EACJ;AACF;","names":[]}

package/dist/physicalMetrics-W5uZ5xKb.d.ts

@@ -0,0 +1,48 @@
+type PhysicalMetricsValueShape = {
+    meterToPtUnscaled: number;
+    meterToPtScaled: number;
+};
+type WorldScalingCompensation = 'unscaled' | 'scaled';
+type ConvertOption = {
+    worldScalingCompensation: WorldScalingCompensation;
+};
+/**
+ * Converts scene points (pt) to physical meters (m).
+ *
+ * @param point Points value to convert.
+ * @param options Optional conversion options to select world scaling compensation.
+ * @returns Physical length in meters.
+ */
+declare function pointToPhysical(point: number, options?: ConvertOption): number;
+/**
+ * Converts physical meters (m) to scene points (pt).
+ *
+ * @param physical Physical length in meters to convert.
+ * @param options Optional conversion options to select world scaling compensation.
+ * @returns Points length in the scene.
+ */
+declare function physicalToPoint(physical: number, options?: ConvertOption): number;
+/**
+ * Returns the current physical metrics used for conversions.
+ *
+ * @returns The current metrics snapshot `{ meterToPtUnscaled, meterToPtScaled }`.
+ */
+declare function getValue(): PhysicalMetricsValueShape;
+/**
+ * Subscribes to physical metrics changes.
+ *
+ * @param cb Callback invoked when metrics update is detected.
+ * @returns Unsubscribe function to remove the listener.
+ */
+declare function subscribe(cb: () => void): () => void;
+
+type physicalMetrics_PhysicalMetricsValueShape = PhysicalMetricsValueShape;
+declare const physicalMetrics_getValue: typeof getValue;
+declare const physicalMetrics_physicalToPoint: typeof physicalToPoint;
+declare const physicalMetrics_pointToPhysical: typeof pointToPhysical;
+declare const physicalMetrics_subscribe: typeof subscribe;
+declare namespace physicalMetrics {
+  export { type physicalMetrics_PhysicalMetricsValueShape as PhysicalMetricsValueShape, physicalMetrics_getValue as getValue, physicalMetrics_physicalToPoint as physicalToPoint, physicalMetrics_pointToPhysical as pointToPhysical, physicalMetrics_subscribe as subscribe };
+}
+
+export { type PhysicalMetricsValueShape as P, physicalToPoint as a, pointToPhysical as b, getValue as g, physicalMetrics as p, subscribe as s };

package/dist/physicalMetrics.d.ts

@@ -0,0 +1 @@
+export { P as PhysicalMetricsValueShape, g as getValue, a as physicalToPoint, b as pointToPhysical, s as subscribe } from './physicalMetrics-W5uZ5xKb.js';

package/dist/physicalMetrics.js

@@ -0,0 +1,58 @@
+import { SpatialWebEvent } from "./SpatialWebEvent";
+let 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");
+  };
+}
+export {
+  getValue,
+  physicalToPoint,
+  pointToPhysical,
+  subscribe
+};
+//# sourceMappingURL=physicalMetrics.js.map

package/dist/physicalMetrics.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/physicalMetrics.ts"],"sourcesContent":["import { SpatialWebEvent } from './SpatialWebEvent'\nexport type PhysicalMetricsValueShape = {\n  meterToPtUnscaled: number\n  meterToPtScaled: number\n}\n\ntype WorldScalingCompensation = 'unscaled' | 'scaled'\n\ntype ConvertOption = { worldScalingCompensation: WorldScalingCompensation }\n\n// Fallback calibration: 1 meter ≈ 1360 pt for both scaled and unscaled modes.\n// This baseline ensures pointToPhysical(1360) === 1 and physicalToPoint(1) === 1360\n// until native physical metrics are injected into window.__webspatialsdk__.physicalMetrics\n// and a 'WebSpatialPhysicalMetricsUpdate' event updates the snapshot at runtime.\nlet snapshot: PhysicalMetricsValueShape = {\n  meterToPtUnscaled: 1360,\n  meterToPtScaled: 1360,\n}\n\nfunction getWorldScalingCompensation(options?: ConvertOption) {\n  return options?.worldScalingCompensation ?? 'scaled' // default to scaled\n}\n\n/**\n * Converts scene points (pt) to physical meters (m).\n *\n * @param point Points value to convert.\n * @param options Optional conversion options to select world scaling compensation.\n * @returns Physical length in meters.\n */\nexport function pointToPhysical(point: number, options?: ConvertOption) {\n  updateValue()\n  const compensation = getWorldScalingCompensation(options)\n  if (compensation === 'unscaled') {\n    return point / snapshot.meterToPtUnscaled\n  }\n  return point / snapshot.meterToPtScaled\n}\n\n/**\n * Converts physical meters (m) to scene points (pt).\n *\n * @param physical Physical length in meters to convert.\n * @param options Optional conversion options to select world scaling compensation.\n * @returns Points length in the scene.\n */\nexport function physicalToPoint(physical: number, options?: ConvertOption) {\n  updateValue()\n  const compensation = getWorldScalingCompensation(options)\n  if (compensation === 'unscaled') {\n    return physical * snapshot.meterToPtUnscaled\n  }\n  return physical * snapshot.meterToPtScaled\n}\n\nfunction updateValue() {\n  // ssr protected\n  if (typeof window === 'undefined') return\n  const src = window.__webspatialsdk__?.physicalMetrics\n  if (!src) return\n  const next = {\n    meterToPtScaled: src.meterToPtScaled ?? snapshot.meterToPtScaled,\n    meterToPtUnscaled: src.meterToPtUnscaled ?? snapshot.meterToPtUnscaled,\n  }\n  // only update if there is a change\n  if (\n    next.meterToPtScaled !== snapshot.meterToPtScaled ||\n    next.meterToPtUnscaled !== snapshot.meterToPtUnscaled\n  ) {\n    snapshot = next\n  }\n}\n\n/**\n * Returns the current physical metrics used for conversions.\n *\n * @returns The current metrics snapshot `{ meterToPtUnscaled, meterToPtScaled }`.\n */\nexport function getValue(): PhysicalMetricsValueShape {\n  updateValue()\n  return snapshot\n}\n\n/**\n * Subscribes to physical metrics changes.\n *\n * @param cb Callback invoked when metrics update is detected.\n * @returns Unsubscribe function to remove the listener.\n */\nexport function subscribe(cb: () => void) {\n  // ssr protected\n  if (typeof window === 'undefined') return () => {}\n  const handler = () => {\n    cb()\n  }\n  // receive metrics update from native via SpatialWebEvent, id: \"window\"\n  SpatialWebEvent.addEventReceiver('window', handler)\n  return () => {\n    SpatialWebEvent.removeEventReceiver('window')\n  }\n}\n"],"mappings":"AAAA,SAAS,uBAAuB;AAchC,IAAI,WAAsC;AAAA,EACxC,mBAAmB;AAAA,EACnB,iBAAiB;AACnB;AAEA,SAAS,4BAA4B,SAAyB;AAC5D,SAAO,SAAS,4BAA4B;AAC9C;AASO,SAAS,gBAAgB,OAAe,SAAyB;AACtE,cAAY;AACZ,QAAM,eAAe,4BAA4B,OAAO;AACxD,MAAI,iBAAiB,YAAY;AAC/B,WAAO,QAAQ,SAAS;AAAA,EAC1B;AACA,SAAO,QAAQ,SAAS;AAC1B;AASO,SAAS,gBAAgB,UAAkB,SAAyB;AACzE,cAAY;AACZ,QAAM,eAAe,4BAA4B,OAAO;AACxD,MAAI,iBAAiB,YAAY;AAC/B,WAAO,WAAW,SAAS;AAAA,EAC7B;AACA,SAAO,WAAW,SAAS;AAC7B;AAEA,SAAS,cAAc;AAErB,MAAI,OAAO,WAAW,YAAa;AACnC,QAAM,MAAM,OAAO,mBAAmB;AACtC,MAAI,CAAC,IAAK;AACV,QAAM,OAAO;AAAA,IACX,iBAAiB,IAAI,mBAAmB,SAAS;AAAA,IACjD,mBAAmB,IAAI,qBAAqB,SAAS;AAAA,EACvD;AAEA,MACE,KAAK,oBAAoB,SAAS,mBAClC,KAAK,sBAAsB,SAAS,mBACpC;AACA,eAAW;AAAA,EACb;AACF;AAOO,SAAS,WAAsC;AACpD,cAAY;AACZ,SAAO;AACT;AAQO,SAAS,UAAU,IAAgB;AAExC,MAAI,OAAO,WAAW,YAAa,QAAO,MAAM;AAAA,EAAC;AACjD,QAAM,UAAU,MAAM;AACpB,OAAG;AAAA,EACL;AAEA,kBAAgB,iBAAiB,UAAU,OAAO;AAClD,SAAO,MAAM;AACX,oBAAgB,oBAAoB,QAAQ;AAAA,EAC9C;AACF;","names":[]}

package/dist/platform-adapter/CommandResultUtils.d.ts

@@ -0,0 +1,12 @@
+import { aK as CommandResult } from '../spatializedElementMotion-_0XWPQCE.js';
+import '../types/motion/spatializedVisual.js';
+import '../types/motion/spatializedPlayback.js';
+import '../types/global.js';
+import '../physicalMetrics-W5uZ5xKb.js';
+import '../SpatialObject.js';
+import '../reality/component/SpatialComponent.js';
+
+declare function CommandResultSuccess<TData>(data: TData): CommandResult<TData>;
+declare function CommandResultFailure(errorCode: string, errorMessage?: string): CommandResult<undefined>;
+
+export { CommandResultFailure, CommandResultSuccess };

package/dist/platform-adapter/CommandResultUtils.js

@@ -0,0 +1,21 @@
+function CommandResultSuccess(data) {
+  return {
+    success: true,
+    data,
+    errorCode: "",
+    errorMessage: ""
+  };
+}
+function CommandResultFailure(errorCode, errorMessage = "") {
+  return {
+    success: false,
+    data: void 0,
+    errorCode,
+    errorMessage
+  };
+}
+export {
+  CommandResultFailure,
+  CommandResultSuccess
+};
+//# sourceMappingURL=CommandResultUtils.js.map

package/dist/platform-adapter/CommandResultUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/platform-adapter/CommandResultUtils.ts"],"sourcesContent":["import { CommandResult } from './interface'\n\nexport function CommandResultSuccess<TData>(data: TData): CommandResult<TData> {\n  return {\n    success: true,\n    data,\n    errorCode: '',\n    errorMessage: '',\n  }\n}\n\nexport function CommandResultFailure(\n  errorCode: string,\n  errorMessage = '',\n): CommandResult<undefined> {\n  return {\n    success: false,\n    data: undefined,\n    errorCode,\n    errorMessage,\n  }\n}\n"],"mappings":"AAEO,SAAS,qBAA4B,MAAmC;AAC7E,SAAO;AAAA,IACL,SAAS;AAAA,IACT;AAAA,IACA,WAAW;AAAA,IACX,cAAc;AAAA,EAChB;AACF;AAEO,SAAS,qBACd,WACA,eAAe,IACW;AAC1B,SAAO;AAAA,IACL,SAAS;AAAA,IACT,MAAM;AAAA,IACN;AAAA,IACA;AAAA,EACF;AACF;","names":[]}

package/dist/platform-adapter/createPlatformSync.d.ts

@@ -0,0 +1,16 @@
+import { aY as PlatformAbility } from '../spatializedElementMotion-_0XWPQCE.js';
+import '../types/motion/spatializedVisual.js';
+import '../types/motion/spatializedPlayback.js';
+import '../types/global.js';
+import '../physicalMetrics-W5uZ5xKb.js';
+import '../SpatialObject.js';
+import '../reality/component/SpatialComponent.js';
+
+/**
+ * Construct the JSB platform synchronously (static imports).
+ * Used by getPlatformSync (e.g. scene-polyfill openSpatialSceneSync) and kept
+ * consistent with async createPlatform so paths share one implementation.
+ */
+declare function createPlatformSync(): PlatformAbility;
+
+export { createPlatformSync };

package/dist/platform-adapter/createPlatformSync.js

@@ -0,0 +1,30 @@
+import { resolveJsbAdapterPlatform } from "../runtime/jsbAdapterPlatform";
+import { isSSREnv } from "../isSSREnv";
+import { PicoOSPlatform } from "./pico-os/PicoOSPlatform";
+import { PuppeteerPlatform } from "./puppeteer/PuppeteerPlatform";
+import { VisionOSPlatform } from "./vision-os/VisionOSPlatform";
+const SSR_PLATFORM_ERROR = "WebSpatial platform APIs (JSB / openSpatialScene) cannot run during SSR or without window. Use @webspatial/react-sdk default entry with facades, or CSR-gate spatial UI on the client.";
+function assertNever(_) {
+  throw new Error("Unhandled jsb adapter platform kind");
+}
+function createPlatformSync() {
+  if (isSSREnv()) {
+    throw new Error(SSR_PLATFORM_ERROR);
+  }
+  const userAgent = window.navigator.userAgent;
+  const kind = resolveJsbAdapterPlatform(userAgent);
+  switch (kind) {
+    case "puppeteer":
+      return new PuppeteerPlatform();
+    case "picoos":
+      return new PicoOSPlatform();
+    case "visionos":
+      return new VisionOSPlatform();
+    default:
+      return assertNever(kind);
+  }
+}
+export {
+  createPlatformSync
+};
+//# sourceMappingURL=createPlatformSync.js.map

package/dist/platform-adapter/createPlatformSync.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/platform-adapter/createPlatformSync.ts"],"sourcesContent":["import { resolveJsbAdapterPlatform } from '../runtime/jsbAdapterPlatform'\nimport { isSSREnv } from '../isSSREnv'\nimport { PlatformAbility } from './interface'\nimport { PicoOSPlatform } from './pico-os/PicoOSPlatform'\nimport { PuppeteerPlatform } from './puppeteer/PuppeteerPlatform'\nimport { VisionOSPlatform } from './vision-os/VisionOSPlatform'\n\nconst SSR_PLATFORM_ERROR =\n  'WebSpatial platform APIs (JSB / openSpatialScene) cannot run during SSR or without window. Use @webspatial/react-sdk default entry with facades, or CSR-gate spatial UI on the client.'\n\nfunction assertNever(_: never): never {\n  throw new Error('Unhandled jsb adapter platform kind')\n}\n\n/**\n * Construct the JSB platform synchronously (static imports).\n * Used by getPlatformSync (e.g. scene-polyfill openSpatialSceneSync) and kept\n * consistent with async createPlatform so paths share one implementation.\n */\nexport function createPlatformSync(): PlatformAbility {\n  if (isSSREnv()) {\n    throw new Error(SSR_PLATFORM_ERROR)\n  }\n  const userAgent = window.navigator.userAgent\n  const kind = resolveJsbAdapterPlatform(userAgent)\n  switch (kind) {\n    case 'puppeteer':\n      return new PuppeteerPlatform()\n    case 'picoos':\n      return new PicoOSPlatform()\n    case 'visionos':\n      return new VisionOSPlatform()\n    default:\n      return assertNever(kind)\n  }\n}\n"],"mappings":"AAAA,SAAS,iCAAiC;AAC1C,SAAS,gBAAgB;AAEzB,SAAS,sBAAsB;AAC/B,SAAS,yBAAyB;AAClC,SAAS,wBAAwB;AAEjC,MAAM,qBACJ;AAEF,SAAS,YAAY,GAAiB;AACpC,QAAM,IAAI,MAAM,qCAAqC;AACvD;AAOO,SAAS,qBAAsC;AACpD,MAAI,SAAS,GAAG;AACd,UAAM,IAAI,MAAM,kBAAkB;AAAA,EACpC;AACA,QAAM,YAAY,OAAO,UAAU;AACnC,QAAM,OAAO,0BAA0B,SAAS;AAChD,UAAQ,MAAM;AAAA,IACZ,KAAK;AACH,aAAO,IAAI,kBAAkB;AAAA,IAC/B,KAAK;AACH,aAAO,IAAI,eAAe;AAAA,IAC5B,KAAK;AACH,aAAO,IAAI,iBAAiB;AAAA,IAC9B;AACE,aAAO,YAAY,IAAI;AAAA,EAC3B;AACF;","names":[]}

package/dist/platform-adapter/index.d.ts

@@ -0,0 +1,12 @@
+export { createPlatformSync } from './createPlatformSync.js';
+import { aY as PlatformAbility } from '../spatializedElementMotion-_0XWPQCE.js';
+import '../types/motion/spatializedVisual.js';
+import '../types/motion/spatializedPlayback.js';
+import '../types/global.js';
+import '../physicalMetrics-W5uZ5xKb.js';
+import '../SpatialObject.js';
+import '../reality/component/SpatialComponent.js';
+
+declare function createPlatform(): Promise<PlatformAbility>;
+
+export { createPlatform };

package/dist/platform-adapter/index.js

@@ -0,0 +1,10 @@
+import { createPlatformSync } from "./createPlatformSync";
+import { createPlatformSync as createPlatformSync2 } from "./createPlatformSync";
+async function createPlatform() {
+  return createPlatformSync2();
+}
+export {
+  createPlatform,
+  createPlatformSync
+};
+//# sourceMappingURL=index.js.map

package/dist/platform-adapter/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/platform-adapter/index.ts"],"sourcesContent":["export { createPlatformSync } from './createPlatformSync'\nimport { createPlatformSync } from './createPlatformSync'\nimport type { PlatformAbility } from './interface'\n\nexport async function createPlatform(): Promise<PlatformAbility> {\n  return createPlatformSync()\n}\n"],"mappings":"AAAA,SAAS,0BAA0B;AACnC,SAAS,sBAAAA,2BAA0B;AAGnC,eAAsB,iBAA2C;AAC/D,SAAOA,oBAAmB;AAC5B;","names":["createPlatformSync"]}

package/dist/platform-adapter/interface.d.ts

@@ -0,0 +1,7 @@
+export { aK as CommandResult, aY as PlatformAbility, aZ as WebSpatialProtocolResult } from '../spatializedElementMotion-_0XWPQCE.js';
+import '../types/motion/spatializedVisual.js';
+import '../types/motion/spatializedPlayback.js';
+import '../types/global.js';
+import '../physicalMetrics-W5uZ5xKb.js';
+import '../SpatialObject.js';
+import '../reality/component/SpatialComponent.js';

package/dist/platform-adapter/interface.js

@@ -0,0 +1 @@
+//# sourceMappingURL=interface.js.map

package/dist/platform-adapter/interface.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/platform-adapter/pico-os/PicoOSPlatform.d.ts

@@ -0,0 +1,25 @@
+import { aY as PlatformAbility, aK as CommandResult, aQ as SpatialSceneCreationOptionsInternal, aZ as WebSpatialProtocolResult, h as AttachmentEntityOptions } from '../../spatializedElementMotion-_0XWPQCE.js';
+import '../../types/motion/spatializedVisual.js';
+import '../../types/motion/spatializedPlayback.js';
+import '../../types/global.js';
+import '../../physicalMetrics-W5uZ5xKb.js';
+import '../../SpatialObject.js';
+import '../../reality/component/SpatialComponent.js';
+
+declare class PicoOSPlatform implements PlatformAbility {
+    callJSB(cmd: string, msg: string): Promise<CommandResult>;
+    openSpatialSceneSync(url: string, config: SpatialSceneCreationOptionsInternal | undefined, target?: string, features?: string): WebSpatialProtocolResult;
+    createNativeSpatialDiv(): Promise<WebSpatialProtocolResult>;
+    createNativeAttachment(_options?: AttachmentEntityOptions): Promise<WebSpatialProtocolResult>;
+    /**
+     * Async path for createNativeSpatialDiv / createNativeAttachment: open webspatial URL
+     * with rid= correlation (Pico OS 6).
+     */
+    private waitForRidProtocolAsync;
+    private openWindow;
+    private parseBridgeResponse;
+    private toCommandResult;
+    private parseJSBError;
+}
+
+export { PicoOSPlatform };

package/dist/platform-adapter/pico-os/PicoOSPlatform.js

@@ -0,0 +1,168 @@
+import {
+  CommandResultFailure,
+  CommandResultSuccess
+} from "../CommandResultUtils";
+import { buildSpatialSceneQuery } from "../spatialSceneQuery";
+import { SpatialWebEvent } from "../../SpatialWebEvent";
+import {
+  buildSpatialRequestQuery,
+  createSpatialRequestId,
+  DEFAULT_SPATIAL_REQUEST_TIMEOUT_MS
+} from "../spatialRequestMetadata";
+let requestId = 0;
+const MAX_ID = 1e5;
+const DEFAULT_JSB_ERROR_CODE = "E_PICO_JSB";
+const DEFAULT_JSB_ERROR_MESSAGE = "Pico JSB execution failed";
+function nextRequestId() {
+  requestId = (requestId + 1) % MAX_ID;
+  return `rId_${requestId}`;
+}
+class PicoOSPlatform {
+  async callJSB(cmd, msg) {
+    return new Promise((resolve) => {
+      try {
+        const rId = nextRequestId();
+        SpatialWebEvent.addEventReceiver(rId, (result) => {
+          SpatialWebEvent.removeEventReceiver(rId);
+          resolve(this.toCommandResult(result));
+        });
+        const ans = window.webspatialBridge.postMessage(rId, cmd, msg);
+        if (ans !== "") {
+          SpatialWebEvent.removeEventReceiver(rId);
+          resolve(this.parseBridgeResponse(ans));
+        }
+      } catch (error) {
+        console.error(`SwanPlatform cmd: ${cmd}, msg: ${msg} error: ${error}`);
+        const { code, message } = this.parseJSBError(error);
+        resolve(CommandResultFailure(code, message));
+      }
+    });
+  }
+  openSpatialSceneSync(url, config, target, features) {
+    const query = buildSpatialSceneQuery(url, config);
+    const { spatialId: id = "", windowProxy } = this.openWindow(
+      "createSpatialScene",
+      query,
+      target,
+      features
+    );
+    return CommandResultSuccess({ windowProxy, id });
+  }
+  createNativeSpatialDiv() {
+    return this.waitForRidProtocolAsync("createSpatialized2DElement");
+  }
+  createNativeAttachment(_options) {
+    return this.waitForRidProtocolAsync("createAttachment");
+  }
+  /**
+   * Async path for createNativeSpatialDiv / createNativeAttachment: open webspatial URL
+   * with rid= correlation (Pico OS 6).
+   */
+  waitForRidProtocolAsync(command) {
+    return new Promise((resolve) => {
+      const createdId = createSpatialRequestId();
+      let settled = false;
+      let timeoutId;
+      let cleanupDocumentReadyListener;
+      const settle = (result) => {
+        if (settled) return;
+        settled = true;
+        if (timeoutId !== void 0) {
+          clearTimeout(timeoutId);
+        }
+        cleanupDocumentReadyListener?.();
+        cleanupDocumentReadyListener = void 0;
+        SpatialWebEvent.removeEventReceiver(createdId);
+        resolve(result);
+      };
+      try {
+        let windowProxy = null;
+        const settleWhenDocumentComplete = (spatialId) => {
+          const successResult = CommandResultSuccess({
+            windowProxy,
+            id: spatialId
+          });
+          const childDocument = windowProxy?.document;
+          if (!childDocument) {
+            settle(
+              CommandResultFailure(
+                "E_SPATIAL_DOCUMENT_UNAVAILABLE",
+                `${command} document is unavailable`
+              )
+            );
+            return;
+          }
+          if (childDocument.readyState === "complete") {
+            settle(successResult);
+            return;
+          }
+          const onReadyStateChange = () => {
+            if (childDocument.readyState !== "complete") return;
+            settle(successResult);
+          };
+          cleanupDocumentReadyListener = () => {
+            childDocument.removeEventListener(
+              "readystatechange",
+              onReadyStateChange
+            );
+          };
+          childDocument.addEventListener("readystatechange", onReadyStateChange);
+        };
+        timeoutId = setTimeout(() => {
+          settle(
+            CommandResultFailure(
+              "E_SPATIAL_REQUEST_TIMEOUT",
+              `${command} request timed out`
+            )
+          );
+        }, DEFAULT_SPATIAL_REQUEST_TIMEOUT_MS);
+        SpatialWebEvent.addEventReceiver(
+          createdId,
+          (result) => {
+            settleWhenDocumentComplete(result.spatialId);
+          }
+        );
+        windowProxy = this.openWindow(
+          command,
+          buildSpatialRequestQuery(createdId)
+        ).windowProxy;
+      } catch (error) {
+        const { code, message } = this.parseJSBError(error);
+        settle(CommandResultFailure(code, message));
+      }
+    });
+  }
+  openWindow(command, query, target, features) {
+    const url = query ? `webspatial://${command}?${query}` : `webspatial://${command}`;
+    const windowProxy = window.open(url, target, features);
+    return { spatialId: "", windowProxy };
+  }
+  parseBridgeResponse(ans) {
+    try {
+      const result = JSON.parse(ans);
+      return this.toCommandResult(result);
+    } catch {
+      return CommandResultFailure(
+        DEFAULT_JSB_ERROR_CODE,
+        "Invalid Pico JSB response payload"
+      );
+    }
+  }
+  toCommandResult(result) {
+    if (result.success) {
+      return CommandResultSuccess(result.data);
+    }
+    const { code, message } = this.parseJSBError(result.data);
+    return CommandResultFailure(code, message);
+  }
+  parseJSBError(error) {
+    return {
+      code: error?.code ?? DEFAULT_JSB_ERROR_CODE,
+      message: error?.message ?? (typeof error === "string" ? error : DEFAULT_JSB_ERROR_MESSAGE)
+    };
+  }
+}
+export {
+  PicoOSPlatform
+};
+//# sourceMappingURL=PicoOSPlatform.js.map