@aippy/runtime 0.2.3-dev.1 → 0.2.4-dev.3

package/dist/audio/index.d.ts

@@ -8,6 +8,7 @@
  */
 export { patchAudioContext } from './patchAudioContext';
 export type { AudioContextPatchOptions, AutoPauseOptions, MediaElementType, PatchedAudioContext, } from './types';
-export { createHiddenMediaElement, createHiddenVideoElement, isIOSDevice, isMediaStreamAudioSupported, } from './utils';
+export { createHiddenMediaElement, createHiddenVideoElement, isMediaStreamAudioSupported, } from './utils';
 export { useAudioContext } from './useAudioContext';
 export type { UseAudioContextOptions, UseAudioContextReturn } from './useAudioContext';
+export { isIOSDevice } from './utils';

package/dist/audio/index.js

@@ -1,4 +1,4 @@
-import { c as i, a as t, i as d, b as o, p as s, u as n } from "../useAudioContext-BKgy28A1.js";
+import { c as i, a as t, b as d, i as o, p as s, u as n } from "../useAudioContext-CNQQSTab.js";
 export {
   i as createHiddenMediaElement,
   t as createHiddenVideoElement,

package/dist/core/index.d.ts

@@ -2,3 +2,4 @@ export * from './types';
 export * from './config';
 export * from './errors';
 export * from './version';
+export * from './runtime';

package/dist/core/index.js

@@ -1,45 +1,49 @@
-import { A as f, E as v, c as _ } from "../errors-CDEBaBxB.js";
-const o = {
+import { a as d, A as f, C as u, E as A, R as _, b as m, c as R } from "../runtime-DOnodF_1.js";
+const s = {
   mode: "development",
   debug: !1,
   apiBaseUrl: void 0,
   headers: {}
 };
-function r() {
+function o() {
   const e = {};
   return typeof process < "u" && process.env && (process.env.NODE_ENV && (e.mode = process.env.NODE_ENV), process.env.AIPPY_DEBUG && (e.debug = process.env.AIPPY_DEBUG === "true"), process.env.AIPPY_API_BASE_URL && (e.apiBaseUrl = process.env.AIPPY_API_BASE_URL)), e;
 }
-function a(e) {
-  const n = r();
+function c(e) {
+  const n = o();
   return {
-    ...o,
+    ...s,
     ...n,
     ...e,
     headers: {
-      ...o.headers,
+      ...s.headers,
       ...n.headers,
       ...e?.headers
     }
   };
 }
-const s = "0.2.3-dev.1", t = {
-  version: s
-}, i = t.version, c = "@aippy/runtime";
+const r = "0.2.4-dev.3", i = {
+  version: r
+}, a = i.version, t = "@aippy/runtime";
 function p() {
   return {
-    name: c,
-    version: i,
+    name: t,
+    version: a,
     buildTime: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
 export {
+  d as AippyRuntime,
   f as AippyRuntimeError,
-  o as DEFAULT_CONFIG,
-  v as ERROR_CODES,
-  c as SDK_NAME,
-  i as VERSION,
-  _ as createError,
-  r as getConfigFromEnv,
+  u as Cancellable,
+  s as DEFAULT_CONFIG,
+  A as ERROR_CODES,
+  _ as ReceiveChannel,
+  t as SDK_NAME,
+  a as VERSION,
+  m as aippyRuntime,
+  R as createError,
+  o as getConfigFromEnv,
   p as getVersionInfo,
-  a as mergeConfig
+  c as mergeConfig
 };

package/dist/core/runtime.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Aippy Runtime - Unified runtime for native bridge communication
+ */
+/**
+ * Cancellable class - For managing subscriptions
+ */
+export declare class Cancellable {
+    private cancelFn?;
+    private cancelled;
+    constructor(cancelFn?: (() => void) | undefined);
+    cancel(): void;
+    get isCancelled(): boolean;
+}
+/**
+ * ReceiveChannel - Manages message receiving and subscription
+ */
+export declare class ReceiveChannel {
+    private emitter;
+    /**
+     * Emit a message to subscribers
+     */
+    emit(message: {
+        endpoint: string;
+        payload: any;
+    }): void;
+    /**
+     * Subscribe to messages on a specific endpoint
+     */
+    subscribe(endpoint: string, callback: (payload: any) => void): Cancellable;
+    /**
+     * Subscribe to a single message (auto-unsubscribe after first message)
+     */
+    once(endpoint: string, callback: (payload: any) => void): Cancellable;
+}
+/**
+ * AippyRuntime - Main runtime class for native bridge communication
+ */
+export declare class AippyRuntime {
+    receiveChannel: ReceiveChannel;
+    private seq;
+    /**
+     * Receive message from native layer
+     * Called by native code via: window.aippyRuntime.receiveMessage(message)
+     */
+    receiveMessage(message: {
+        endpoint: string;
+        payload: any;
+    }): Promise<void>;
+    /**
+     * Create a subscription to native events
+     * @param handler - WebKit message handler (e.g., deviceMotionHandler)
+     * @param subscribePayload - Subscription parameters (e.g., { type: "motion" })
+     * @param callback - Callback to handle received data
+     * @returns Cancellable subscription
+     */
+    createSubscription(handler: any, subscribePayload: any, callback: (data: any) => void): Cancellable;
+    /**
+     * Make a subscription message with unique endpoint
+     */
+    private makeSubscriptionMessage;
+    /**
+     * Add motion listener (convenience method)
+     * @param callback - Callback to handle motion data
+     * @returns Cleanup function
+     */
+    addMotionListener(callback: (data: any) => void): () => void;
+}
+/**
+ * Global runtime instance - Singleton pattern
+ */
+export declare const aippyRuntime: AippyRuntime;

package/dist/device/index.js

@@ -1,10 +1,10 @@
-var h = Object.defineProperty;
-var p = (n, e, t) => e in n ? h(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
-var m = (n, e, t) => p(n, typeof e != "symbol" ? e + "" : e, t);
-import { c as a } from "../errors-CDEBaBxB.js";
-class g {
+var v = Object.defineProperty;
+var f = (c, t, e) => t in c ? v(c, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : c[t] = e;
+var p = (c, t, e) => f(c, typeof t != "symbol" ? t + "" : t, e);
+import { c as a, b as E } from "../runtime-DOnodF_1.js";
+class P {
   constructor() {
-    m(this, "stream", null);
+    p(this, "stream", null);
   }
   /**
    * Check if camera is supported
@@ -15,21 +15,21 @@ class g {
   /**
    * Get camera stream
    */
-  async getStream(e = {}) {
+  async getStream(t = {}) {
     if (!this.isSupported())
       throw a("Camera API is not supported", "NOT_SUPPORTED");
     try {
-      const t = {
+      const e = {
         video: {
-          width: e.width,
-          height: e.height,
-          facingMode: e.facingMode || "environment"
+          width: t.width,
+          height: t.height,
+          facingMode: t.facingMode || "environment"
         }
       };
-      return this.stream = await navigator.mediaDevices.getUserMedia(t), this.stream;
-    } catch (t) {
+      return this.stream = await navigator.mediaDevices.getUserMedia(e), this.stream;
+    } catch (e) {
       throw a(
-        `Failed to access camera: ${t instanceof Error ? t.message : "Unknown error"}`,
+        `Failed to access camera: ${e instanceof Error ? e.message : "Unknown error"}`,
         "PERMISSION_DENIED"
       );
     }
@@ -37,30 +37,30 @@ class g {
   /**
    * Capture photo from stream
    */
-  async capturePhoto(e = {}) {
+  async capturePhoto(t = {}) {
     if (!this.stream)
       throw a("No camera stream available", "NOT_SUPPORTED");
     try {
-      const t = document.createElement("video");
-      t.srcObject = this.stream, t.play();
-      const o = document.createElement("canvas"), i = o.getContext("2d");
-      if (!i)
+      const e = document.createElement("video");
+      e.srcObject = this.stream, e.play();
+      const i = document.createElement("canvas"), o = i.getContext("2d");
+      if (!o)
         throw a("Failed to get canvas context", "UNKNOWN_ERROR");
-      o.width = e.width || t.videoWidth, o.height = e.height || t.videoHeight, i.drawImage(t, 0, 0, o.width, o.height);
-      const r = e.format || "jpeg", c = e.quality === "high" ? 0.9 : e.quality === "medium" ? 0.7 : 0.5, s = await new Promise((u, w) => {
-        o.toBlob((l) => {
-          l ? u(l) : w(new Error("Failed to create blob"));
-        }, `image/${r}`, c);
-      }), d = o.toDataURL(`image/${r}`, c);
+      i.width = t.width || e.videoWidth, i.height = t.height || e.videoHeight, o.drawImage(e, 0, 0, i.width, i.height);
+      const n = t.format || "jpeg", d = t.quality === "high" ? 0.9 : t.quality === "medium" ? 0.7 : 0.5, r = await new Promise((l, u) => {
+        i.toBlob((w) => {
+          w ? l(w) : u(new Error("Failed to create blob"));
+        }, `image/${n}`, d);
+      }), s = i.toDataURL(`image/${n}`, d);
       return {
-        blob: s,
-        dataUrl: d,
-        width: o.width,
-        height: o.height
+        blob: r,
+        dataUrl: s,
+        width: i.width,
+        height: i.height
       };
-    } catch (t) {
+    } catch (e) {
       throw a(
-        `Failed to capture photo: ${t instanceof Error ? t.message : "Unknown error"}`,
+        `Failed to capture photo: ${e instanceof Error ? e.message : "Unknown error"}`,
         "UNKNOWN_ERROR"
       );
     }
@@ -69,11 +69,11 @@ class g {
    * Stop camera stream
    */
   stopStream() {
-    this.stream && (this.stream.getTracks().forEach((e) => e.stop()), this.stream = null);
+    this.stream && (this.stream.getTracks().forEach((t) => t.stop()), this.stream = null);
   }
 }
-const f = new g();
-class v {
+const D = new P();
+class O {
   /**
    * Check if geolocation is supported
    */
@@ -83,99 +83,230 @@ class v {
   /**
    * Get current position
    */
-  async getCurrentPosition(e = {}) {
+  async getCurrentPosition(t = {}) {
     if (!this.isSupported())
       throw a("Geolocation API is not supported", "NOT_SUPPORTED");
-    return new Promise((t, o) => {
-      const i = {
-        enableHighAccuracy: e.enableHighAccuracy ?? !0,
-        timeout: e.timeout ?? 1e4,
-        maximumAge: e.maximumAge ?? 6e4
+    return new Promise((e, i) => {
+      const o = {
+        enableHighAccuracy: t.enableHighAccuracy ?? !0,
+        timeout: t.timeout ?? 1e4,
+        maximumAge: t.maximumAge ?? 6e4
       };
       navigator.geolocation.getCurrentPosition(
-        (r) => {
-          const c = {
-            latitude: r.coords.latitude,
-            longitude: r.coords.longitude,
-            accuracy: r.coords.accuracy,
-            altitude: r.coords.altitude ?? void 0,
-            altitudeAccuracy: r.coords.altitudeAccuracy ?? void 0,
-            heading: r.coords.heading ?? void 0,
-            speed: r.coords.speed ?? void 0,
-            timestamp: r.timestamp
+        (n) => {
+          const d = {
+            latitude: n.coords.latitude,
+            longitude: n.coords.longitude,
+            accuracy: n.coords.accuracy,
+            altitude: n.coords.altitude ?? void 0,
+            altitudeAccuracy: n.coords.altitudeAccuracy ?? void 0,
+            heading: n.coords.heading ?? void 0,
+            speed: n.coords.speed ?? void 0,
+            timestamp: n.timestamp
           };
-          t(c);
+          e(d);
         },
-        (r) => {
-          let c = "UNKNOWN_ERROR", s = "Unknown geolocation error";
-          switch (r.code) {
-            case r.PERMISSION_DENIED:
-              c = "PERMISSION_DENIED", s = "Geolocation permission denied";
+        (n) => {
+          let d = "UNKNOWN_ERROR", r = "Unknown geolocation error";
+          switch (n.code) {
+            case n.PERMISSION_DENIED:
+              d = "PERMISSION_DENIED", r = "Geolocation permission denied";
               break;
-            case r.POSITION_UNAVAILABLE:
-              s = "Position unavailable";
+            case n.POSITION_UNAVAILABLE:
+              r = "Position unavailable";
               break;
-            case r.TIMEOUT:
-              s = "Geolocation timeout";
+            case n.TIMEOUT:
+              r = "Geolocation timeout";
               break;
           }
-          o(a(s, c));
+          i(a(r, d));
         },
-        i
+        o
       );
     });
   }
   /**
    * Watch position changes
    */
-  watchPosition(e, t = {}) {
+  watchPosition(t, e = {}) {
     if (!this.isSupported())
       throw a("Geolocation API is not supported", "NOT_SUPPORTED");
-    const o = {
-      enableHighAccuracy: t.enableHighAccuracy ?? !0,
-      timeout: t.timeout ?? 1e4,
-      maximumAge: t.maximumAge ?? 6e4
+    const i = {
+      enableHighAccuracy: e.enableHighAccuracy ?? !0,
+      timeout: e.timeout ?? 1e4,
+      maximumAge: e.maximumAge ?? 6e4
     };
     return navigator.geolocation.watchPosition(
-      (i) => {
-        const r = {
-          latitude: i.coords.latitude,
-          longitude: i.coords.longitude,
-          accuracy: i.coords.accuracy,
-          altitude: i.coords.altitude ?? void 0,
-          altitudeAccuracy: i.coords.altitudeAccuracy ?? void 0,
-          heading: i.coords.heading ?? void 0,
-          speed: i.coords.speed ?? void 0,
-          timestamp: i.timestamp
+      (o) => {
+        const n = {
+          latitude: o.coords.latitude,
+          longitude: o.coords.longitude,
+          accuracy: o.coords.accuracy,
+          altitude: o.coords.altitude ?? void 0,
+          altitudeAccuracy: o.coords.altitudeAccuracy ?? void 0,
+          heading: o.coords.heading ?? void 0,
+          speed: o.coords.speed ?? void 0,
+          timestamp: o.timestamp
         };
-        e(r);
+        t(n);
       },
-      (i) => {
-        console.error("Geolocation watch error:", i);
+      (o) => {
+        console.error("Geolocation watch error:", o);
       },
-      o
+      i
     );
   }
   /**
    * Clear position watch
    */
-  clearWatch(e) {
-    navigator.geolocation.clearWatch(e);
+  clearWatch(t) {
+    navigator.geolocation.clearWatch(t);
   }
 }
-const N = new v();
-class E {
+const A = new O();
+function m() {
+  return "DeviceMotionEvent" in window;
+}
+function h() {
+  return "DeviceOrientationEvent" in window;
+}
+function g() {
+  return typeof window < "u" && !!window.webkit?.messageHandlers?.deviceMotionHandler;
+}
+async function y() {
+  if (g())
+    return !0;
+  if (!m())
+    return !1;
+  if (typeof DeviceMotionEvent < "u" && typeof DeviceMotionEvent.requestPermission == "function")
+    try {
+      return await DeviceMotionEvent.requestPermission() === "granted";
+    } catch {
+      return !1;
+    }
+  return !0;
+}
+function R(c) {
+  return E.addMotionListener((e) => {
+    const i = {
+      gravity: {
+        x: e.gravity?.x ?? 0,
+        y: e.gravity?.y ?? 0,
+        z: e.gravity?.z ?? 0
+      },
+      acceleration: {
+        x: e.acceleration?.x ?? 0,
+        y: e.acceleration?.y ?? 0,
+        z: e.acceleration?.z ?? 0
+      },
+      accelerationIncludingGravity: {
+        x: (e.gravity?.x ?? 0) + (e.acceleration?.x ?? 0),
+        y: (e.gravity?.y ?? 0) + (e.acceleration?.y ?? 0),
+        z: (e.gravity?.z ?? 0) + (e.acceleration?.z ?? 0)
+      },
+      rotation: {
+        alpha: e.rotation?.alpha ?? 0,
+        beta: e.rotation?.beta ?? 0,
+        gamma: e.rotation?.gamma ?? 0
+      },
+      timestamp: Date.now()
+    };
+    c(i);
+  });
+}
+function N(c, t = !0) {
+  if (!m())
+    throw a("Device motion API is not supported", "NOT_SUPPORTED");
+  let e = !1, i = null;
+  const o = (r) => {
+    if (!e) return;
+    const s = {
+      gravity: {
+        x: r.acceleration?.x ?? 0,
+        y: r.acceleration?.y ?? 0,
+        z: r.acceleration?.z ?? 0
+      },
+      acceleration: {
+        x: r.acceleration?.x ?? 0,
+        y: r.acceleration?.y ?? 0,
+        z: r.acceleration?.z ?? 0
+      },
+      accelerationIncludingGravity: {
+        x: r.accelerationIncludingGravity?.x ?? 0,
+        y: r.accelerationIncludingGravity?.y ?? 0,
+        z: r.accelerationIncludingGravity?.z ?? 0
+      },
+      rotation: {
+        alpha: r.rotationRate?.alpha ?? 0,
+        beta: r.rotationRate?.beta ?? 0,
+        gamma: r.rotationRate?.gamma ?? 0
+      },
+      timestamp: Date.now()
+    };
+    if (r.acceleration) {
+      const l = r.accelerationIncludingGravity, u = r.acceleration;
+      s.gravity = {
+        x: (l?.x ?? 0) - (u?.x ?? 0),
+        y: (l?.y ?? 0) - (u?.y ?? 0),
+        z: (l?.z ?? 0) - (u?.z ?? 0)
+      };
+    } else {
+      const l = r.accelerationIncludingGravity, u = 9.8;
+      s.gravity = {
+        x: (l?.x ?? 0) / u,
+        y: (l?.y ?? 0) / u,
+        z: (l?.z ?? 0) / u
+      };
+    }
+    c(s);
+  }, n = async () => {
+    t && !await y() || (e = !0, window.addEventListener("devicemotion", o));
+  };
+  return (async () => {
+    if (typeof DeviceMotionEvent < "u" && typeof DeviceMotionEvent.requestPermission == "function" && t) {
+      const s = async () => {
+        i = null, await n();
+      };
+      window.addEventListener("click", s, { once: !0 }), window.addEventListener("touchstart", s, { once: !0 }), i = () => {
+        window.removeEventListener("click", s), window.removeEventListener("touchstart", s);
+      };
+    } else
+      await n();
+  })(), () => {
+    e = !1, window.removeEventListener("devicemotion", o), i && (i(), i = null);
+  };
+}
+function x(c, t = !0) {
+  return g() ? R(c) : N(c, t);
+}
+function L(c) {
+  if (!h())
+    throw a("Device orientation API is not supported", "NOT_SUPPORTED");
+  const t = (e) => {
+    const i = {
+      alpha: e.alpha ?? 0,
+      beta: e.beta ?? 0,
+      gamma: e.gamma ?? 0,
+      timestamp: Date.now()
+    };
+    c(i);
+  };
+  return window.addEventListener("deviceorientation", t), () => {
+    window.removeEventListener("deviceorientation", t);
+  };
+}
+class S {
   /**
    * Check if device orientation is supported
    */
   isOrientationSupported() {
-    return "DeviceOrientationEvent" in window;
+    return h();
   }
   /**
    * Check if device motion is supported
    */
   isMotionSupported() {
-    return "DeviceMotionEvent" in window;
+    return m();
   }
   /**
    * Get device orientation data
@@ -183,36 +314,37 @@ class E {
   async getOrientation() {
     if (!this.isOrientationSupported())
       throw a("Device orientation API is not supported", "NOT_SUPPORTED");
-    return new Promise((e, t) => {
-      const o = (i) => {
-        window.removeEventListener("deviceorientation", o), e({
-          x: i.alpha ?? 0,
-          y: i.beta ?? 0,
-          z: i.gamma ?? 0,
+    return new Promise((t, e) => {
+      const i = (o) => {
+        window.removeEventListener("deviceorientation", i), t({
+          x: o.alpha ?? 0,
+          y: o.beta ?? 0,
+          z: o.gamma ?? 0,
           timestamp: Date.now()
         });
       };
-      window.addEventListener("deviceorientation", o), setTimeout(() => {
-        window.removeEventListener("deviceorientation", o), t(a("Device orientation timeout", "UNKNOWN_ERROR"));
+      window.addEventListener("deviceorientation", i), setTimeout(() => {
+        window.removeEventListener("deviceorientation", i), e(a("Device orientation timeout", "UNKNOWN_ERROR"));
       }, 5e3);
     });
   }
   /**
    * Watch device orientation changes
+   * @deprecated Use watchOrientation() function instead
    */
-  watchOrientation(e) {
+  watchOrientation(t) {
     if (!this.isOrientationSupported())
       throw a("Device orientation API is not supported", "NOT_SUPPORTED");
-    const t = (o) => {
-      e({
-        x: o.alpha ?? 0,
-        y: o.beta ?? 0,
-        z: o.gamma ?? 0,
+    const e = (i) => {
+      t({
+        x: i.alpha ?? 0,
+        y: i.beta ?? 0,
+        z: i.gamma ?? 0,
         timestamp: Date.now()
       });
     };
-    return window.addEventListener("deviceorientation", t), () => {
-      window.removeEventListener("deviceorientation", t);
+    return window.addEventListener("deviceorientation", e), () => {
+      window.removeEventListener("deviceorientation", e);
     };
   }
   /**
@@ -221,53 +353,48 @@ class E {
   async getMotion() {
     if (!this.isMotionSupported())
       throw a("Device motion API is not supported", "NOT_SUPPORTED");
-    return new Promise((e, t) => {
-      const o = (i) => {
-        window.removeEventListener("devicemotion", o), e({
-          x: i.acceleration?.x ?? 0,
-          y: i.acceleration?.y ?? 0,
-          z: i.acceleration?.z ?? 0,
+    return new Promise((t, e) => {
+      const i = (o) => {
+        window.removeEventListener("devicemotion", i), t({
+          x: o.acceleration?.x ?? 0,
+          y: o.acceleration?.y ?? 0,
+          z: o.acceleration?.z ?? 0,
           timestamp: Date.now()
         });
       };
-      window.addEventListener("devicemotion", o), setTimeout(() => {
-        window.removeEventListener("devicemotion", o), t(a("Device motion timeout", "UNKNOWN_ERROR"));
+      window.addEventListener("devicemotion", i), setTimeout(() => {
+        window.removeEventListener("devicemotion", i), e(a("Device motion timeout", "UNKNOWN_ERROR"));
       }, 5e3);
     });
   }
   /**
    * Watch device motion changes
+   * @deprecated Use watchMotion() function instead
    */
-  watchMotion(e) {
+  watchMotion(t) {
     if (!this.isMotionSupported())
       throw a("Device motion API is not supported", "NOT_SUPPORTED");
-    const t = (o) => {
-      e({
-        x: o.acceleration?.x ?? 0,
-        y: o.acceleration?.y ?? 0,
-        z: o.acceleration?.z ?? 0,
+    const e = (i) => {
+      t({
+        x: i.acceleration?.x ?? 0,
+        y: i.acceleration?.y ?? 0,
+        z: i.acceleration?.z ?? 0,
         timestamp: Date.now()
       });
     };
-    return window.addEventListener("devicemotion", t), () => {
-      window.removeEventListener("devicemotion", t);
+    return window.addEventListener("devicemotion", e), () => {
+      window.removeEventListener("devicemotion", e);
     };
   }
   /**
    * Request permission for motion sensors (iOS 13+)
    */
   async requestPermission() {
-    if (!this.isMotionSupported())
-      return !1;
-    try {
-      return (await navigator.permissions?.query({ name: "accelerometer" }))?.state === "granted";
-    } catch {
-      return !1;
-    }
+    return y();
   }
 }
-const R = new E();
-class O {
+const M = new S();
+class I {
   /**
    * Check if file system access is supported
    */
@@ -283,28 +410,28 @@ class O {
   /**
    * Open file picker (modern API)
    */
-  async openFilePicker(e = {}) {
+  async openFilePicker(t = {}) {
     if (!this.isSupported())
       throw a("File System Access API is not supported", "NOT_SUPPORTED");
     try {
-      const t = {
-        types: e.accept ? [{
+      const e = {
+        types: t.accept ? [{
           description: "Files",
           accept: Object.fromEntries(
-            e.accept.map((r) => [r, [r]])
+            t.accept.map((n) => [n, [n]])
           )
         }] : void 0,
-        multiple: e.multiple ?? !1
-      }, o = await window.showOpenFilePicker(t), i = await Promise.all(
-        o.map(async (r) => r.getFile())
+        multiple: t.multiple ?? !1
+      }, i = await window.showOpenFilePicker(e), o = await Promise.all(
+        i.map(async (n) => n.getFile())
       );
       return {
-        files: i,
-        paths: i.map((r) => r.name)
+        files: o,
+        paths: o.map((n) => n.name)
       };
-    } catch (t) {
-      throw t instanceof Error && t.name === "AbortError" ? a("File picker was cancelled", "PERMISSION_DENIED") : a(
-        `Failed to open file picker: ${t instanceof Error ? t.message : "Unknown error"}`,
+    } catch (e) {
+      throw e instanceof Error && e.name === "AbortError" ? a("File picker was cancelled", "PERMISSION_DENIED") : a(
+        `Failed to open file picker: ${e instanceof Error ? e.message : "Unknown error"}`,
         "PERMISSION_DENIED"
       );
     }
@@ -312,38 +439,38 @@ class O {
   /**
    * Open file picker (legacy fallback)
    */
-  async openFilePickerLegacy(e = {}) {
+  async openFilePickerLegacy(t = {}) {
     if (!this.isLegacySupported())
       throw a("File input is not supported", "NOT_SUPPORTED");
-    return new Promise((t, o) => {
-      const i = document.createElement("input");
-      i.type = "file", i.multiple = e.multiple ?? !1, i.accept = e.accept?.join(",") ?? "", i.onchange = (r) => {
-        const c = r.target, s = Array.from(c.files || []);
-        t({
-          files: s,
-          paths: s.map((d) => d.name)
+    return new Promise((e, i) => {
+      const o = document.createElement("input");
+      o.type = "file", o.multiple = t.multiple ?? !1, o.accept = t.accept?.join(",") ?? "", o.onchange = (n) => {
+        const d = n.target, r = Array.from(d.files || []);
+        e({
+          files: r,
+          paths: r.map((s) => s.name)
         });
-      }, i.oncancel = () => {
-        o(a("File picker was cancelled", "PERMISSION_DENIED"));
-      }, i.click();
+      }, o.oncancel = () => {
+        i(a("File picker was cancelled", "PERMISSION_DENIED"));
+      }, o.click();
     });
   }
   /**
    * Open file picker with fallback
    */
-  async openFile(e = {}) {
-    return this.isSupported() ? await this.openFilePicker(e) : await this.openFilePickerLegacy(e);
+  async openFile(t = {}) {
+    return this.isSupported() ? await this.openFilePicker(t) : await this.openFilePickerLegacy(t);
   }
   /**
    * Save file
    */
-  async saveFile(e, t) {
+  async saveFile(t, e) {
     try {
-      const o = URL.createObjectURL(e), i = document.createElement("a");
-      i.href = o, i.download = t, document.body.appendChild(i), i.click(), document.body.removeChild(i), URL.revokeObjectURL(o);
-    } catch (o) {
+      const i = URL.createObjectURL(t), o = document.createElement("a");
+      o.href = i, o.download = e, document.body.appendChild(o), o.click(), document.body.removeChild(o), URL.revokeObjectURL(i);
+    } catch (i) {
       throw a(
-        `Failed to save file: ${o instanceof Error ? o.message : "Unknown error"}`,
+        `Failed to save file: ${i instanceof Error ? i.message : "Unknown error"}`,
         "UNKNOWN_ERROR"
       );
     }
@@ -351,45 +478,51 @@ class O {
   /**
    * Read file as text
    */
-  async readAsText(e) {
-    return new Promise((t, o) => {
-      const i = new FileReader();
-      i.onload = () => t(i.result), i.onerror = () => o(a("Failed to read file", "UNKNOWN_ERROR")), i.readAsText(e);
+  async readAsText(t) {
+    return new Promise((e, i) => {
+      const o = new FileReader();
+      o.onload = () => e(o.result), o.onerror = () => i(a("Failed to read file", "UNKNOWN_ERROR")), o.readAsText(t);
     });
   }
   /**
    * Read file as data URL
    */
-  async readAsDataURL(e) {
-    return new Promise((t, o) => {
-      const i = new FileReader();
-      i.onload = () => t(i.result), i.onerror = () => o(a("Failed to read file", "UNKNOWN_ERROR")), i.readAsDataURL(e);
+  async readAsDataURL(t) {
+    return new Promise((e, i) => {
+      const o = new FileReader();
+      o.onload = () => e(o.result), o.onerror = () => i(a("Failed to read file", "UNKNOWN_ERROR")), o.readAsDataURL(t);
     });
   }
 }
-const S = new O();
-function D(n) {
-  return new Promise((e) => {
+const T = new I();
+function k(c) {
+  return new Promise((t) => {
     if ("vibrate" in navigator)
-      navigator.vibrate(n), e();
+      navigator.vibrate(c), t();
     else if (window.webkit && window.webkit.messageHandlers && window.webkit.messageHandlers.aippyListener) {
-      const t = {
+      const e = {
         command: "navigator.vibrate",
-        parameters: n
+        parameters: c
       };
-      window.webkit.messageHandlers.aippyListener.postMessage(t), e();
+      window.webkit.messageHandlers.aippyListener.postMessage(e), t();
     } else
-      console.warn("Vibration not supported in this environment"), e();
+      console.warn("Vibration not supported in this environment"), t();
   });
 }
 export {
-  g as CameraAPI,
-  O as FileSystemAPI,
-  v as GeolocationAPI,
-  E as SensorsAPI,
-  f as camera,
-  S as fileSystem,
-  N as geolocation,
-  R as sensors,
-  D as vibrate
+  P as CameraAPI,
+  I as FileSystemAPI,
+  O as GeolocationAPI,
+  S as SensorsAPI,
+  D as camera,
+  T as fileSystem,
+  A as geolocation,
+  g as hasNativeBridge,
+  m as isMotionSupported,
+  h as isOrientationSupported,
+  y as requestMotionPermission,
+  M as sensors,
+  k as vibrate,
+  x as watchMotion,
+  L as watchOrientation
 };

package/dist/device/sensors.d.ts

@@ -1,6 +1,39 @@
-import { SensorData } from './types';
+import { SensorData, MotionData, OrientationData } from './types';
 /**
- * Device sensors functionality wrapper
+ * Check if device motion is supported
+ */
+export declare function isMotionSupported(): boolean;
+/**
+ * Check if device orientation is supported
+ */
+export declare function isOrientationSupported(): boolean;
+/**
+ * Check if native bridge is available
+ */
+export declare function hasNativeBridge(): boolean;
+/**
+ * Request permission for motion sensors (iOS 13+)
+ * @returns Promise<boolean> - true if permission granted
+ */
+export declare function requestMotionPermission(): Promise<boolean>;
+/**
+ * Watch device motion changes with full motion data
+ * Automatically uses native bridge if available, otherwise falls back to Web API
+ *
+ * @param callback - Function to call with motion data
+ * @param autoRequestPermission - Automatically request permission on iOS (default: true, only for Web API)
+ * @returns Cleanup function to stop watching
+ */
+export declare function watchMotion(callback: (data: MotionData) => void, autoRequestPermission?: boolean): () => void;
+/**
+ * Watch device orientation changes
+ * @param callback - Function to call with orientation data
+ * @returns Cleanup function to stop watching
+ */
+export declare function watchOrientation(callback: (data: OrientationData) => void): () => void;
+/**
+ * Legacy SensorsAPI class for backward compatibility
+ * @deprecated Use watchMotion() and watchOrientation() functions instead
  */
 export declare class SensorsAPI {
     /**
@@ -17,6 +50,7 @@ export declare class SensorsAPI {
     getOrientation(): Promise<SensorData>;
     /**
      * Watch device orientation changes
+     * @deprecated Use watchOrientation() function instead
      */
     watchOrientation(callback: (data: SensorData) => void): () => void;
     /**
@@ -25,6 +59,7 @@ export declare class SensorsAPI {
     getMotion(): Promise<SensorData>;
     /**
      * Watch device motion changes
+     * @deprecated Use watchMotion() function instead
      */
     watchMotion(callback: (data: SensorData) => void): () => void;
     /**
@@ -33,6 +68,7 @@ export declare class SensorsAPI {
     requestPermission(): Promise<boolean>;
 }
 /**
- * Sensors API instance
+ * Sensors API instance (for backward compatibility)
+ * @deprecated Use watchMotion() and watchOrientation() functions instead
  */
 export declare const sensors: SensorsAPI;

package/dist/device/types.d.ts

@@ -58,6 +58,44 @@ export interface SensorData {
     /** Timestamp */
     timestamp: number;
 }
+export interface MotionData {
+    /** Gravity vector (normalized, -1 to 1) */
+    gravity: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Linear acceleration (m/s²) */
+    acceleration: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Acceleration including gravity (m/s²) */
+    accelerationIncludingGravity: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Rotation rate (deg/s) */
+    rotation: {
+        alpha: number;
+        beta: number;
+        gamma: number;
+    };
+    /** Timestamp */
+    timestamp: number;
+}
+export interface OrientationData {
+    /** Rotation around Z axis (0-360°) */
+    alpha: number;
+    /** Rotation around X axis (-180 to 180°) */
+    beta: number;
+    /** Rotation around Y axis (-90 to 90°) */
+    gamma: number;
+    /** Timestamp */
+    timestamp: number;
+}
 export interface FileSystemOptions {
     /** File types to accept */
     accept?: string[];

package/dist/index/index.js

@@ -1,44 +1,54 @@
-import { DEFAULT_CONFIG as r, SDK_NAME as a, VERSION as t, getConfigFromEnv as s, getVersionInfo as i, mergeConfig as n } from "../core/index.js";
-import { A as m, E as c, c as f } from "../errors-CDEBaBxB.js";
-import { CameraAPI as A, FileSystemAPI as E, GeolocationAPI as S, SensorsAPI as l, camera as u, fileSystem as x, geolocation as I, sensors as P, vibrate as C } from "../device/index.js";
-import { c as R, a as y, P as D, b as M, p as O, d as b } from "../pwa-8DGmPqLV.js";
-import { a as F, b as w } from "../useTweaks-QxMRmg7i.js";
-import { c as T, a as V, i as _, b as k, p as G, u as H } from "../useAudioContext-BKgy28A1.js";
-import { reportScore as h, sendEvent as K, updateScore as L } from "../leaderboard/index.js";
+import { DEFAULT_CONFIG as o, SDK_NAME as r, VERSION as t, getConfigFromEnv as i, getVersionInfo as s, mergeConfig as n } from "../core/index.js";
+import { a as m, A as c, C as d, E as f, R as u, b as l, c as A } from "../runtime-DOnodF_1.js";
+import { CameraAPI as E, FileSystemAPI as C, GeolocationAPI as R, SensorsAPI as x, camera as P, fileSystem as I, geolocation as M, hasNativeBridge as g, isMotionSupported as y, isOrientationSupported as O, requestMotionPermission as b, sensors as v, vibrate as h, watchMotion as w, watchOrientation as D } from "../device/index.js";
+import { c as N, a as T, P as V, b as _, p as k, d as G } from "../pwa-8DGmPqLV.js";
+import { a as U, b as q } from "../useTweaks-QxMRmg7i.js";
+import { c as K, a as L, b as W, i as j, p as z, u as J } from "../useAudioContext-CNQQSTab.js";
+import { reportScore as X, sendEvent as Y, updateScore as Z } from "../leaderboard/index.js";
 export {
-  m as AippyRuntimeError,
-  A as CameraAPI,
-  r as DEFAULT_CONFIG,
-  c as ERROR_CODES,
-  E as FileSystemAPI,
-  S as GeolocationAPI,
-  R as PWAUtils,
-  y as PerformanceMonitor,
-  D as PlatformDetector,
-  a as SDK_NAME,
-  l as SensorsAPI,
+  m as AippyRuntime,
+  c as AippyRuntimeError,
+  E as CameraAPI,
+  d as Cancellable,
+  o as DEFAULT_CONFIG,
+  f as ERROR_CODES,
+  C as FileSystemAPI,
+  R as GeolocationAPI,
+  N as PWAUtils,
+  T as PerformanceMonitor,
+  V as PlatformDetector,
+  u as ReceiveChannel,
+  r as SDK_NAME,
+  x as SensorsAPI,
   t as VERSION,
-  F as aippyTweaks,
-  w as aippyTweaksRuntime,
-  u as camera,
-  f as createError,
-  T as createHiddenMediaElement,
-  V as createHiddenVideoElement,
-  x as fileSystem,
-  I as geolocation,
-  s as getConfigFromEnv,
-  i as getVersionInfo,
-  _ as isIOSDevice,
-  k as isMediaStreamAudioSupported,
+  l as aippyRuntime,
+  U as aippyTweaks,
+  q as aippyTweaksRuntime,
+  P as camera,
+  A as createError,
+  K as createHiddenMediaElement,
+  L as createHiddenVideoElement,
+  I as fileSystem,
+  M as geolocation,
+  i as getConfigFromEnv,
+  s as getVersionInfo,
+  g as hasNativeBridge,
+  W as isIOSDevice,
+  j as isMediaStreamAudioSupported,
+  y as isMotionSupported,
+  O as isOrientationSupported,
   n as mergeConfig,
-  G as patchAudioContext,
-  M as performanceMonitor,
-  O as platform,
-  b as pwa,
-  h as reportScore,
-  K as sendEvent,
-  P as sensors,
-  L as updateScore,
-  H as useAudioContext,
-  C as vibrate
+  z as patchAudioContext,
+  _ as performanceMonitor,
+  k as platform,
+  G as pwa,
+  X as reportScore,
+  b as requestMotionPermission,
+  Y as sendEvent,
+  v as sensors,
+  Z as updateScore,
+  J as useAudioContext,
+  h as vibrate,
+  w as watchMotion,
+  D as watchOrientation
 };

package/dist/runtime-DOnodF_1.js

@@ -0,0 +1,165 @@
+var l = Object.defineProperty;
+var p = (i, e, t) => e in i ? l(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
+var r = (i, e, t) => p(i, typeof e != "symbol" ? e + "" : e, t);
+class u extends Error {
+  constructor(t, s = "AIPPY_ERROR", n) {
+    super(t);
+    r(this, "code");
+    r(this, "context");
+    this.name = "AippyRuntimeError", this.code = s, this.context = n;
+  }
+}
+const R = {
+  NOT_SUPPORTED: "NOT_SUPPORTED",
+  PERMISSION_DENIED: "PERMISSION_DENIED",
+  INVALID_CONFIG: "INVALID_CONFIG",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  UNKNOWN_ERROR: "UNKNOWN_ERROR"
+};
+function O(i, e = "UNKNOWN_ERROR", t) {
+  return new u(i, R[e], t);
+}
+class o {
+  constructor(e) {
+    r(this, "cancelled", !1);
+    this.cancelFn = e;
+  }
+  cancel() {
+    this.cancelled || (this.cancelled = !0, this.cancelFn?.());
+  }
+  get isCancelled() {
+    return this.cancelled;
+  }
+}
+class d {
+  constructor() {
+    r(this, "listeners", /* @__PURE__ */ new Map());
+  }
+  addEventListener(e, t) {
+    this.listeners.has(e) || this.listeners.set(e, []), this.listeners.get(e).push(t);
+  }
+  removeEventListener(e, t) {
+    const s = this.listeners.get(e);
+    if (s) {
+      const n = s.indexOf(t);
+      n > -1 && s.splice(n, 1);
+    }
+  }
+  emit(e, t) {
+    const s = this.listeners.get(e);
+    s && s.forEach((n) => n(t));
+  }
+}
+class h {
+  constructor() {
+    r(this, "emitter", new d());
+  }
+  /**
+   * Emit a message to subscribers
+   */
+  emit(e) {
+    this.emitter.emit(e.endpoint, e.payload);
+  }
+  /**
+   * Subscribe to messages on a specific endpoint
+   */
+  subscribe(e, t) {
+    const s = (n) => {
+      t(n);
+    };
+    return this.emitter.addEventListener(e, s), new o(() => {
+      this.emitter.removeEventListener(e, s);
+    });
+  }
+  /**
+   * Subscribe to a single message (auto-unsubscribe after first message)
+   */
+  once(e, t) {
+    const s = this.subscribe(e, (n) => {
+      s.cancel(), t(n);
+    });
+    return s;
+  }
+}
+class E {
+  constructor() {
+    r(this, "receiveChannel", new h());
+    r(this, "seq", 0);
+  }
+  /**
+   * Receive message from native layer
+   * Called by native code via: window.aippyRuntime.receiveMessage(message)
+   */
+  receiveMessage(e) {
+    return this.receiveChannel.emit(e), Promise.resolve();
+  }
+  /**
+   * Create a subscription to native events
+   * @param handler - WebKit message handler (e.g., deviceMotionHandler)
+   * @param subscribePayload - Subscription parameters (e.g., { type: "motion" })
+   * @param callback - Callback to handle received data
+   * @returns Cancellable subscription
+   */
+  createSubscription(e, t, s) {
+    const n = this.makeSubscriptionMessage(t), a = this.receiveChannel.subscribe(n.endpoint, (c) => {
+      c.error === void 0 && s(c);
+    });
+    try {
+      e.postMessage(n);
+    } catch {
+    }
+    return new o(() => {
+      a.cancel();
+      try {
+        e.postMessage({
+          endpoint: n.endpoint,
+          payload: "unsubscribe"
+        });
+      } catch {
+      }
+    });
+  }
+  /**
+   * Make a subscription message with unique endpoint
+   */
+  makeSubscriptionMessage(e) {
+    return {
+      endpoint: (this.seq++).toString(),
+      payload: {
+        subscribe: e
+      }
+    };
+  }
+  /**
+   * Add motion listener (convenience method)
+   * @param callback - Callback to handle motion data
+   * @returns Cleanup function
+   */
+  addMotionListener(e) {
+    const t = window.webkit?.messageHandlers?.deviceMotionHandler;
+    if (!t)
+      return () => {
+      };
+    const s = this.createSubscription(
+      t,
+      { type: "motion" },
+      (n) => {
+        n.motion && e(n.motion);
+      }
+    );
+    return () => {
+      s.cancel();
+    };
+  }
+}
+const m = new E();
+typeof window < "u" && (window.aippyRuntime = m);
+export {
+  u as A,
+  o as C,
+  R as E,
+  h as R,
+  E as a,
+  m as b,
+  O as c
+};

package/dist/{useAudioContext-BKgy28A1.js → useAudioContext-CNQQSTab.js}

@@ -215,9 +215,9 @@ function O(e = {}) {
 }
 export {
   C as a,
-  P as b,
+  E as b,
   v as c,
-  E as i,
+  P as i,
   S as p,
   O as u
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aippy/runtime",
-  "version": "0.2.3-dev.1",
+  "version": "0.2.4-dev.3",
   "description": "Aippy Runtime SDK - Runtime SDK for Aippy projects",
   "private": false,
   "type": "module",

package/dist/errors-CDEBaBxB.js

@@ -1,26 +0,0 @@
-var e = Object.defineProperty;
-var o = (E, R, N) => R in E ? e(E, R, { enumerable: !0, configurable: !0, writable: !0, value: N }) : E[R] = N;
-var O = (E, R, N) => o(E, typeof R != "symbol" ? R + "" : R, N);
-class I extends Error {
-  constructor(N, r = "AIPPY_ERROR", t) {
-    super(N);
-    O(this, "code");
-    O(this, "context");
-    this.name = "AippyRuntimeError", this.code = r, this.context = t;
-  }
-}
-const _ = {
-  NOT_SUPPORTED: "NOT_SUPPORTED",
-  PERMISSION_DENIED: "PERMISSION_DENIED",
-  INVALID_CONFIG: "INVALID_CONFIG",
-  NETWORK_ERROR: "NETWORK_ERROR",
-  UNKNOWN_ERROR: "UNKNOWN_ERROR"
-};
-function s(E, R = "UNKNOWN_ERROR", N) {
-  return new I(E, _[R], N);
-}
-export {
-  I as A,
-  _ as E,
-  s as c
-};