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

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,50 @@
-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, p as g } from "../runtime-DjBdOttl.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.11", a = {
+  version: r
+}, i = a.version, t = "@aippy/runtime";
 function p() {
   return {
-    name: c,
+    name: t,
     version: i,
     buildTime: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
 export {
+  d as AippyRuntime,
   f as AippyRuntimeError,
-  o as DEFAULT_CONFIG,
-  v as ERROR_CODES,
-  c as SDK_NAME,
+  u as Cancellable,
+  s as DEFAULT_CONFIG,
+  A as ERROR_CODES,
+  _ as ReceiveChannel,
+  t as SDK_NAME,
   i as VERSION,
-  _ as createError,
-  r as getConfigFromEnv,
+  m as aippyRuntime,
+  R as createError,
+  o as getConfigFromEnv,
   p as getVersionInfo,
-  a as mergeConfig
+  c as mergeConfig,
+  g as processMotionData
 };

package/dist/core/runtime.d.ts

@@ -0,0 +1,94 @@
+/**
+ * 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;
+    private motionListeners;
+    private noListenersWarned;
+    /**
+     * Unified native data receiver - Routes to specific handlers based on message type
+     * Called by native code via: window.aippyRuntime.receiveMessage(message)
+     *
+     * Supports two message formats:
+     * 1. Motion: { command: "navigator.motion", endpoint: "0", data: { motion: {...} } }
+     * 2. Tweaks: { "tweakKey": { value: ..., type: ... }, ... }
+     */
+    receiveMessage(message: any): Promise<void>;
+    /**
+     * Check if message is Motion format
+     * Motion: { command: "navigator.motion", endpoint: string, data: object }
+     */
+    private isMotionMessage;
+    /**
+     * Check if message is Tweaks format
+     * Tweaks: { "key": { value: any, type?: string, ... }, ... }
+     */
+    private isTweaksMessage;
+    /**
+     * Create a subscription to native events
+     * @param handler - WebKit message handler (e.g., aippyListener)
+     * @param subscribePayload - Subscription parameters (e.g., { command: "navigator.motion", type: "motion" })
+     * @param callback - Callback to handle received data
+     * @returns Cancellable subscription
+     */
+    createSubscription(handler: any, subscribePayload: any, callback: (data: any) => void): Cancellable;
+    /**
+     * Add motion listener (convenience method)
+     * @param callback - Callback to handle motion data
+     * @returns Cleanup function
+     */
+    addMotionListener(callback: (data: any) => void): () => void;
+    /**
+     * Broadcast motion data to all registered listeners
+     * Called by processMotionData when iOS sends data directly
+     * @param data - Motion data from iOS
+     */
+    broadcastMotionData(data: any): void;
+}
+/**
+ * Process Motion data from iOS native layer
+ * Called by native code via: window.processMotionData(data)
+ *
+ * @param data - Motion data in simplified format
+ * Expected format: { motion: { gravity: {x, y, z}, acceleration: {...}, rotation: {...} } }
+ */
+export declare function processMotionData(data: any): 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 O = Object.defineProperty;
+var S = (n, e, t) => e in n ? O(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var h = (n, e, t) => S(n, typeof e != "symbol" ? e + "" : e, t);
+import { c as s, b as A } from "../runtime-DjBdOttl.js";
+class N {
   constructor() {
-    m(this, "stream", null);
+    h(this, "stream", null);
   }
   /**
    * Check if camera is supported
@@ -17,7 +17,7 @@ class g {
    */
   async getStream(e = {}) {
     if (!this.isSupported())
-      throw a("Camera API is not supported", "NOT_SUPPORTED");
+      throw s("Camera API is not supported", "NOT_SUPPORTED");
     try {
       const t = {
         video: {
@@ -28,7 +28,7 @@ class g {
       };
       return this.stream = await navigator.mediaDevices.getUserMedia(t), this.stream;
     } catch (t) {
-      throw a(
+      throw s(
         `Failed to access camera: ${t instanceof Error ? t.message : "Unknown error"}`,
         "PERMISSION_DENIED"
       );
@@ -39,27 +39,27 @@ class g {
    */
   async capturePhoto(e = {}) {
     if (!this.stream)
-      throw a("No camera stream available", "NOT_SUPPORTED");
+      throw s("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)
-        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);
+      const i = document.createElement("canvas"), o = i.getContext("2d");
+      if (!o)
+        throw s("Failed to get canvas context", "UNKNOWN_ERROR");
+      i.width = e.width || t.videoWidth, i.height = e.height || t.videoHeight, o.drawImage(t, 0, 0, i.width, i.height);
+      const r = e.format || "jpeg", d = e.quality === "high" ? 0.9 : e.quality === "medium" ? 0.7 : 0.5, a = await new Promise((l, u) => {
+        i.toBlob((m) => {
+          m ? l(m) : u(new Error("Failed to create blob"));
+        }, `image/${r}`, d);
+      }), c = i.toDataURL(`image/${r}`, d);
       return {
-        blob: s,
-        dataUrl: d,
-        width: o.width,
-        height: o.height
+        blob: a,
+        dataUrl: c,
+        width: i.width,
+        height: i.height
       };
     } catch (t) {
-      throw a(
+      throw s(
         `Failed to capture photo: ${t instanceof Error ? t.message : "Unknown error"}`,
         "UNKNOWN_ERROR"
       );
@@ -72,8 +72,8 @@ class g {
     this.stream && (this.stream.getTracks().forEach((e) => e.stop()), this.stream = null);
   }
 }
-const f = new g();
-class v {
+const T = new N();
+class R {
   /**
    * Check if geolocation is supported
    */
@@ -85,16 +85,16 @@ class v {
    */
   async getCurrentPosition(e = {}) {
     if (!this.isSupported())
-      throw a("Geolocation API is not supported", "NOT_SUPPORTED");
-    return new Promise((t, o) => {
-      const i = {
+      throw s("Geolocation API is not supported", "NOT_SUPPORTED");
+    return new Promise((t, i) => {
+      const o = {
         enableHighAccuracy: e.enableHighAccuracy ?? !0,
         timeout: e.timeout ?? 1e4,
         maximumAge: e.maximumAge ?? 6e4
       };
       navigator.geolocation.getCurrentPosition(
         (r) => {
-          const c = {
+          const d = {
             latitude: r.coords.latitude,
             longitude: r.coords.longitude,
             accuracy: r.coords.accuracy,
@@ -104,24 +104,24 @@ class v {
             speed: r.coords.speed ?? void 0,
             timestamp: r.timestamp
           };
-          t(c);
+          t(d);
         },
         (r) => {
-          let c = "UNKNOWN_ERROR", s = "Unknown geolocation error";
+          let d = "UNKNOWN_ERROR", a = "Unknown geolocation error";
           switch (r.code) {
             case r.PERMISSION_DENIED:
-              c = "PERMISSION_DENIED", s = "Geolocation permission denied";
+              d = "PERMISSION_DENIED", a = "Geolocation permission denied";
               break;
             case r.POSITION_UNAVAILABLE:
-              s = "Position unavailable";
+              a = "Position unavailable";
               break;
             case r.TIMEOUT:
-              s = "Geolocation timeout";
+              a = "Geolocation timeout";
               break;
           }
-          o(a(s, c));
+          i(s(a, d));
         },
-        i
+        o
       );
     });
   }
@@ -130,30 +130,30 @@ class v {
    */
   watchPosition(e, t = {}) {
     if (!this.isSupported())
-      throw a("Geolocation API is not supported", "NOT_SUPPORTED");
-    const o = {
+      throw s("Geolocation API is not supported", "NOT_SUPPORTED");
+    const i = {
       enableHighAccuracy: t.enableHighAccuracy ?? !0,
       timeout: t.timeout ?? 1e4,
       maximumAge: t.maximumAge ?? 6e4
     };
     return navigator.geolocation.watchPosition(
-      (i) => {
+      (o) => {
         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
+          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);
       },
-      (i) => {
-        console.error("Geolocation watch error:", i);
+      (o) => {
+        console.error("Geolocation watch error:", o);
       },
-      o
+      i
     );
   }
   /**
@@ -163,51 +163,215 @@ class v {
     navigator.geolocation.clearWatch(e);
   }
 }
-const N = new v();
-class E {
+const x = new R();
+function w() {
+  return "DeviceMotionEvent" in window;
+}
+function v() {
+  return "DeviceOrientationEvent" in window;
+}
+function f() {
+  const n = typeof window < "u", e = n && !!window.webkit, t = e && !!window.webkit?.messageHandlers, i = t && !!window.webkit?.messageHandlers?.aippyListener;
+  return console.log("🔍 [Aippy Sensors] hasNativeBridge check:", {
+    hasWindow: n,
+    hasWebkit: e,
+    hasMessageHandlers: t,
+    hasAippyListener: i,
+    result: i
+  }), i;
+}
+function I() {
+  return typeof window < "u" && typeof window.orientation < "u" ? window.orientation : typeof window < "u" && window.screen?.orientation?.angle !== void 0 ? window.screen.orientation.angle : 0;
+}
+function y(n, e, t) {
+  switch (t) {
+    case 0:
+      return [n, e];
+    case 180:
+      return [-n, -e];
+    case 90:
+      return [-e, n];
+    case -90:
+      return [e, -n];
+    default:
+      return [n, e];
+  }
+}
+async function E() {
+  if (console.log("🔐 [Aippy Sensors] requestMotionPermission called"), f())
+    return console.log("✅ [Aippy Sensors] Native bridge available, skipping permission request"), !0;
+  if (!w())
+    return console.warn("❌ [Aippy Sensors] Device motion not supported"), !1;
+  const n = typeof DeviceMotionEvent < "u" && typeof DeviceMotionEvent.requestPermission == "function";
+  if (console.log("🔍 [Aippy Sensors] Permission API available:", n), n)
+    try {
+      console.log("🙏 [Aippy Sensors] Requesting device motion permission...");
+      const e = await DeviceMotionEvent.requestPermission();
+      return console.log("📋 [Aippy Sensors] Permission result:", e), e === "granted";
+    } catch (e) {
+      return console.warn("❌ [Aippy Sensors] Permission request failed:", e), !1;
+    }
+  return console.log("✅ [Aippy Sensors] No permission needed (granted by default)"), !0;
+}
+function b(n) {
+  console.log("🔧 [Aippy Sensors] watchMotionNative - Setting up native bridge listener");
+  const e = A.addMotionListener((t) => {
+    const i = I(), o = t.gravity?.x ?? 0, r = t.gravity?.y ?? 0, d = t.gravity?.z ?? 0, a = t.acceleration?.x ?? 0, c = t.acceleration?.y ?? 0, l = t.acceleration?.z ?? 0, [u, m] = y(o, r, i), [p, g] = y(a, c, i), P = {
+      gravity: {
+        x: u,
+        y: m,
+        z: d
+        // Z轴不受屏幕旋转影响
+      },
+      acceleration: {
+        x: p,
+        y: g,
+        z: l
+        // Z轴不受屏幕旋转影响
+      },
+      accelerationIncludingGravity: {
+        x: u + p,
+        y: m + g,
+        z: d + l
+      },
+      rotation: {
+        alpha: t.rotation?.alpha ?? 0,
+        beta: t.rotation?.beta ?? 0,
+        gamma: t.rotation?.gamma ?? 0
+      },
+      timestamp: Date.now()
+    };
+    n(P);
+  });
+  return console.log("✅ [Aippy Sensors] watchMotionNative - Listener setup complete"), e;
+}
+function D(n, e = !0) {
+  if (!w())
+    throw s("Device motion API is not supported", "NOT_SUPPORTED");
+  let t = !1, i = null;
+  const o = (a) => {
+    if (!t) return;
+    const c = {
+      gravity: {
+        x: a.acceleration?.x ?? 0,
+        y: a.acceleration?.y ?? 0,
+        z: a.acceleration?.z ?? 0
+      },
+      acceleration: {
+        x: a.acceleration?.x ?? 0,
+        y: a.acceleration?.y ?? 0,
+        z: a.acceleration?.z ?? 0
+      },
+      accelerationIncludingGravity: {
+        x: a.accelerationIncludingGravity?.x ?? 0,
+        y: a.accelerationIncludingGravity?.y ?? 0,
+        z: a.accelerationIncludingGravity?.z ?? 0
+      },
+      rotation: {
+        alpha: a.rotationRate?.alpha ?? 0,
+        beta: a.rotationRate?.beta ?? 0,
+        gamma: a.rotationRate?.gamma ?? 0
+      },
+      timestamp: Date.now()
+    };
+    if (a.acceleration) {
+      const l = a.accelerationIncludingGravity, u = a.acceleration;
+      c.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 = a.accelerationIncludingGravity, u = 9.8;
+      c.gravity = {
+        x: (l?.x ?? 0) / u,
+        y: (l?.y ?? 0) / u,
+        z: (l?.z ?? 0) / u
+      };
+    }
+    n(c);
+  }, r = async () => {
+    e && !await E() || (t = !0, window.addEventListener("devicemotion", o));
+  };
+  return (async () => {
+    if (typeof DeviceMotionEvent < "u" && typeof DeviceMotionEvent.requestPermission == "function" && e) {
+      const c = async () => {
+        i = null, await r();
+      };
+      window.addEventListener("click", c, { once: !0 }), window.addEventListener("touchstart", c, { once: !0 }), i = () => {
+        window.removeEventListener("click", c), window.removeEventListener("touchstart", c);
+      };
+    } else
+      await r();
+  })(), () => {
+    t = !1, window.removeEventListener("devicemotion", o), i && (i(), i = null);
+  };
+}
+function _(n, e = !0) {
+  const t = f();
+  return console.log(`🎯 [Aippy Sensors] watchMotion - Using ${t ? "NATIVE BRIDGE" : "WEB API"} mode`), t ? (console.log("📱 [Aippy Sensors] Starting native bridge motion listener"), b(n)) : (console.log("🌐 [Aippy Sensors] Starting Web API motion listener (may require permission)"), D(n, e));
+}
+function F(n) {
+  if (!v())
+    throw s("Device orientation API is not supported", "NOT_SUPPORTED");
+  const e = (t) => {
+    const i = {
+      alpha: t.alpha ?? 0,
+      beta: t.beta ?? 0,
+      gamma: t.gamma ?? 0,
+      timestamp: Date.now()
+    };
+    n(i);
+  };
+  return window.addEventListener("deviceorientation", e), () => {
+    window.removeEventListener("deviceorientation", e);
+  };
+}
+class U {
   /**
    * Check if device orientation is supported
    */
   isOrientationSupported() {
-    return "DeviceOrientationEvent" in window;
+    return v();
   }
   /**
    * Check if device motion is supported
    */
   isMotionSupported() {
-    return "DeviceMotionEvent" in window;
+    return w();
   }
   /**
    * Get device orientation data
    */
   async getOrientation() {
     if (!this.isOrientationSupported())
-      throw a("Device orientation API is not supported", "NOT_SUPPORTED");
+      throw s("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,
+      const i = (o) => {
+        window.removeEventListener("deviceorientation", i), e({
+          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), t(s("Device orientation timeout", "UNKNOWN_ERROR"));
       }, 5e3);
     });
   }
   /**
    * Watch device orientation changes
+   * @deprecated Use watchOrientation() function instead
    */
   watchOrientation(e) {
     if (!this.isOrientationSupported())
-      throw a("Device orientation API is not supported", "NOT_SUPPORTED");
-    const t = (o) => {
+      throw s("Device orientation API is not supported", "NOT_SUPPORTED");
+    const t = (i) => {
       e({
-        x: o.alpha ?? 0,
-        y: o.beta ?? 0,
-        z: o.gamma ?? 0,
+        x: i.alpha ?? 0,
+        y: i.beta ?? 0,
+        z: i.gamma ?? 0,
         timestamp: Date.now()
       });
     };
@@ -220,32 +384,33 @@ class E {
    */
   async getMotion() {
     if (!this.isMotionSupported())
-      throw a("Device motion API is not supported", "NOT_SUPPORTED");
+      throw s("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,
+      const i = (o) => {
+        window.removeEventListener("devicemotion", i), e({
+          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), t(s("Device motion timeout", "UNKNOWN_ERROR"));
       }, 5e3);
     });
   }
   /**
    * Watch device motion changes
+   * @deprecated Use watchMotion() function instead
    */
   watchMotion(e) {
     if (!this.isMotionSupported())
-      throw a("Device motion API is not supported", "NOT_SUPPORTED");
-    const t = (o) => {
+      throw s("Device motion API is not supported", "NOT_SUPPORTED");
+    const t = (i) => {
       e({
-        x: o.acceleration?.x ?? 0,
-        y: o.acceleration?.y ?? 0,
-        z: o.acceleration?.z ?? 0,
+        x: i.acceleration?.x ?? 0,
+        y: i.acceleration?.y ?? 0,
+        z: i.acceleration?.z ?? 0,
         timestamp: Date.now()
       });
     };
@@ -257,17 +422,11 @@ class 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 E();
   }
 }
-const R = new E();
-class O {
+const z = new U();
+class M {
   /**
    * Check if file system access is supported
    */
@@ -285,7 +444,7 @@ class O {
    */
   async openFilePicker(e = {}) {
     if (!this.isSupported())
-      throw a("File System Access API is not supported", "NOT_SUPPORTED");
+      throw s("File System Access API is not supported", "NOT_SUPPORTED");
     try {
       const t = {
         types: e.accept ? [{
@@ -295,15 +454,15 @@ class O {
           )
         }] : void 0,
         multiple: e.multiple ?? !1
-      }, o = await window.showOpenFilePicker(t), i = await Promise.all(
-        o.map(async (r) => r.getFile())
+      }, i = await window.showOpenFilePicker(t), o = await Promise.all(
+        i.map(async (r) => r.getFile())
       );
       return {
-        files: i,
-        paths: i.map((r) => r.name)
+        files: o,
+        paths: o.map((r) => r.name)
       };
     } catch (t) {
-      throw t instanceof Error && t.name === "AbortError" ? a("File picker was cancelled", "PERMISSION_DENIED") : a(
+      throw t instanceof Error && t.name === "AbortError" ? s("File picker was cancelled", "PERMISSION_DENIED") : s(
         `Failed to open file picker: ${t instanceof Error ? t.message : "Unknown error"}`,
         "PERMISSION_DENIED"
       );
@@ -314,18 +473,18 @@ class O {
    */
   async openFilePickerLegacy(e = {}) {
     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 || []);
+      throw s("File input is not supported", "NOT_SUPPORTED");
+    return new Promise((t, i) => {
+      const o = document.createElement("input");
+      o.type = "file", o.multiple = e.multiple ?? !1, o.accept = e.accept?.join(",") ?? "", o.onchange = (r) => {
+        const d = r.target, a = Array.from(d.files || []);
         t({
-          files: s,
-          paths: s.map((d) => d.name)
+          files: a,
+          paths: a.map((c) => c.name)
         });
-      }, i.oncancel = () => {
-        o(a("File picker was cancelled", "PERMISSION_DENIED"));
-      }, i.click();
+      }, o.oncancel = () => {
+        i(s("File picker was cancelled", "PERMISSION_DENIED"));
+      }, o.click();
     });
   }
   /**
@@ -339,11 +498,11 @@ class O {
    */
   async saveFile(e, t) {
     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) {
-      throw a(
-        `Failed to save file: ${o instanceof Error ? o.message : "Unknown error"}`,
+      const i = URL.createObjectURL(e), o = document.createElement("a");
+      o.href = i, o.download = t, document.body.appendChild(o), o.click(), document.body.removeChild(o), URL.revokeObjectURL(i);
+    } catch (i) {
+      throw s(
+        `Failed to save file: ${i instanceof Error ? i.message : "Unknown error"}`,
         "UNKNOWN_ERROR"
       );
     }
@@ -352,23 +511,23 @@ 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);
+    return new Promise((t, i) => {
+      const o = new FileReader();
+      o.onload = () => t(o.result), o.onerror = () => i(s("Failed to read file", "UNKNOWN_ERROR")), o.readAsText(e);
     });
   }
   /**
    * 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);
+    return new Promise((t, i) => {
+      const o = new FileReader();
+      o.onload = () => t(o.result), o.onerror = () => i(s("Failed to read file", "UNKNOWN_ERROR")), o.readAsDataURL(e);
     });
   }
 }
-const S = new O();
-function D(n) {
+const G = new M();
+function W(n) {
   return new Promise((e) => {
     if ("vibrate" in navigator)
       navigator.vibrate(n), e();
@@ -383,13 +542,19 @@ function D(n) {
   });
 }
 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
+  N as CameraAPI,
+  M as FileSystemAPI,
+  R as GeolocationAPI,
+  U as SensorsAPI,
+  T as camera,
+  G as fileSystem,
+  x as geolocation,
+  f as hasNativeBridge,
+  w as isMotionSupported,
+  v as isOrientationSupported,
+  E as requestMotionPermission,
+  z as sensors,
+  W as vibrate,
+  _ as watchMotion,
+  F 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,55 @@
-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 t, VERSION as r, 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, p as S } from "../runtime-DjBdOttl.js";
+import { CameraAPI as C, FileSystemAPI as R, GeolocationAPI as x, SensorsAPI as M, camera as P, fileSystem as I, geolocation as g, hasNativeBridge as y, isMotionSupported as O, isOrientationSupported as b, requestMotionPermission as v, sensors as D, vibrate as h, watchMotion as w, watchOrientation as F } from "../device/index.js";
+import { c as T, a as V, P as _, b as k, p as G, d as H } from "../pwa-8DGmPqLV.js";
+import { a as q, b as B } from "../useTweaks-QxMRmg7i.js";
+import { c as L, a as W, b as j, i as z, p as J, u as Q } from "../useAudioContext-CNQQSTab.js";
+import { reportScore as Y, sendEvent as Z, updateScore as $ } 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,
-  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,
+  m as AippyRuntime,
+  c as AippyRuntimeError,
+  C as CameraAPI,
+  d as Cancellable,
+  o as DEFAULT_CONFIG,
+  f as ERROR_CODES,
+  R as FileSystemAPI,
+  x as GeolocationAPI,
+  T as PWAUtils,
+  V as PerformanceMonitor,
+  _ as PlatformDetector,
+  u as ReceiveChannel,
+  t as SDK_NAME,
+  M as SensorsAPI,
+  r as VERSION,
+  l as aippyRuntime,
+  q as aippyTweaks,
+  B as aippyTweaksRuntime,
+  P as camera,
+  A as createError,
+  L as createHiddenMediaElement,
+  W as createHiddenVideoElement,
+  I as fileSystem,
+  g as geolocation,
+  i as getConfigFromEnv,
+  s as getVersionInfo,
+  y as hasNativeBridge,
+  j as isIOSDevice,
+  z as isMediaStreamAudioSupported,
+  O as isMotionSupported,
+  b 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
+  J as patchAudioContext,
+  k as performanceMonitor,
+  G as platform,
+  S as processMotionData,
+  H as pwa,
+  Y as reportScore,
+  v as requestMotionPermission,
+  Z as sendEvent,
+  D as sensors,
+  $ as updateScore,
+  Q as useAudioContext,
+  h as vibrate,
+  w as watchMotion,
+  F as watchOrientation
 };

package/dist/runtime-DjBdOttl.js

@@ -0,0 +1,243 @@
+var u = Object.defineProperty;
+var m = (o, e, n) => e in o ? u(o, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : o[e] = n;
+var r = (o, e, n) => m(o, typeof e != "symbol" ? e + "" : e, n);
+class d extends Error {
+  constructor(n, i = "AIPPY_ERROR", t) {
+    super(n);
+    r(this, "code");
+    r(this, "context");
+    this.name = "AippyRuntimeError", this.code = i, this.context = t;
+  }
+}
+const R = {
+  NOT_SUPPORTED: "NOT_SUPPORTED",
+  PERMISSION_DENIED: "PERMISSION_DENIED",
+  INVALID_CONFIG: "INVALID_CONFIG",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  UNKNOWN_ERROR: "UNKNOWN_ERROR"
+};
+function g(o, e = "UNKNOWN_ERROR", n) {
+  return new d(o, R[e], n);
+}
+class a {
+  constructor(e) {
+    r(this, "cancelled", !1);
+    this.cancelFn = e;
+  }
+  cancel() {
+    this.cancelled || (this.cancelled = !0, this.cancelFn?.());
+  }
+  get isCancelled() {
+    return this.cancelled;
+  }
+}
+class f {
+  constructor() {
+    r(this, "listeners", /* @__PURE__ */ new Map());
+  }
+  addEventListener(e, n) {
+    this.listeners.has(e) || this.listeners.set(e, []), this.listeners.get(e).push(n);
+  }
+  removeEventListener(e, n) {
+    const i = this.listeners.get(e);
+    if (i) {
+      const t = i.indexOf(n);
+      t > -1 && i.splice(t, 1);
+    }
+  }
+  emit(e, n) {
+    const i = this.listeners.get(e);
+    i && i.forEach((t) => t(n));
+  }
+}
+class y {
+  constructor() {
+    r(this, "emitter", new f());
+  }
+  /**
+   * Emit a message to subscribers
+   */
+  emit(e) {
+    this.emitter.emit(e.endpoint, e.payload);
+  }
+  /**
+   * Subscribe to messages on a specific endpoint
+   */
+  subscribe(e, n) {
+    const i = (t) => {
+      n(t);
+    };
+    return this.emitter.addEventListener(e, i), new a(() => {
+      this.emitter.removeEventListener(e, i);
+    });
+  }
+  /**
+   * Subscribe to a single message (auto-unsubscribe after first message)
+   */
+  once(e, n) {
+    const i = this.subscribe(e, (t) => {
+      i.cancel(), n(t);
+    });
+    return i;
+  }
+}
+class h {
+  constructor() {
+    r(this, "receiveChannel", new y());
+    r(this, "seq", 0);
+    r(this, "motionListeners", []);
+    r(this, "noListenersWarned", !1);
+  }
+  /**
+   * Unified native data receiver - Routes to specific handlers based on message type
+   * Called by native code via: window.aippyRuntime.receiveMessage(message)
+   * 
+   * Supports two message formats:
+   * 1. Motion: { command: "navigator.motion", endpoint: "0", data: { motion: {...} } }
+   * 2. Tweaks: { "tweakKey": { value: ..., type: ... }, ... }
+   */
+  receiveMessage(e) {
+    return console.log("📩 [Aippy Runtime] receiveMessage called with:", e), !e || typeof e != "object" ? (console.warn("⚠️ [Aippy Runtime] Invalid message type:", typeof e), Promise.resolve()) : this.isMotionMessage(e) ? (console.log("✅ [Aippy Runtime] Detected MOTION message format, emitting to receive channel"), this.receiveChannel.emit({
+      endpoint: e.endpoint,
+      payload: e.data
+    }), Promise.resolve()) : this.isTweaksMessage(e) ? (console.log("✅ [Aippy Runtime] Detected TWEAKS message format, calling processNativeData"), typeof window < "u" && window.processNativeData && window.processNativeData(e), Promise.resolve()) : (console.warn("⚠️ [Aippy Runtime] Unknown message format:", e), Promise.resolve());
+  }
+  /**
+   * Check if message is Motion format
+   * Motion: { command: "navigator.motion", endpoint: string, data: object }
+   */
+  isMotionMessage(e) {
+    return typeof e == "object" && "command" in e && e.command === "navigator.motion" && "endpoint" in e && typeof e.endpoint == "string" && "data" in e && typeof e.data == "object" && e.data !== null;
+  }
+  /**
+   * Check if message is Tweaks format
+   * Tweaks: { "key": { value: any, type?: string, ... }, ... }
+   */
+  isTweaksMessage(e) {
+    if (typeof e != "object" || e === null || "endpoint" in e || "payload" in e)
+      return !1;
+    const n = Object.keys(e);
+    return n.length === 0 ? !1 : n.some((t) => {
+      const c = e[t];
+      return typeof c == "object" && c !== null && "value" in c;
+    });
+  }
+  /**
+   * Create a subscription to native events
+   * @param handler - WebKit message handler (e.g., aippyListener)
+   * @param subscribePayload - Subscription parameters (e.g., { command: "navigator.motion", type: "motion" })
+   * @param callback - Callback to handle received data
+   * @returns Cancellable subscription
+   */
+  createSubscription(e, n, i) {
+    const t = (this.seq++).toString(), c = {
+      command: n.command,
+      parameters: {
+        type: n.type,
+        action: "subscribe",
+        endpoint: t
+      }
+    };
+    console.log("📨 [Aippy Runtime] Creating subscription with message:", JSON.stringify(c, null, 2));
+    const l = this.receiveChannel.subscribe(t, (s) => {
+      if (console.log(`📬 [Aippy Runtime] Received data on endpoint ${t}:`, s), s.error !== void 0) {
+        console.warn("⚠️ [Aippy Runtime] Received error, skipping:", s.error);
+        return;
+      }
+      i(s);
+    });
+    try {
+      console.log("📤 [Aippy Runtime] Sending postMessage to native iOS:", c), e.postMessage(c), console.log("✅ [Aippy Runtime] postMessage sent successfully");
+    } catch (s) {
+      console.error("❌ [Aippy Runtime] Failed to send postMessage:", s);
+    }
+    return new a(() => {
+      console.log(`🔌 [Aippy Runtime] Unsubscribing from endpoint ${t}`), l.cancel();
+      try {
+        const s = {
+          command: n.command,
+          parameters: {
+            type: n.type,
+            action: "unsubscribe",
+            endpoint: t
+          }
+        };
+        e.postMessage(s), console.log("✅ [Aippy Runtime] Unsubscribe message sent:", s);
+      } catch (s) {
+        console.error("❌ [Aippy Runtime] Failed to send unsubscribe message:", s);
+      }
+    });
+  }
+  /**
+   * Add motion listener (convenience method)
+   * @param callback - Callback to handle motion data
+   * @returns Cleanup function
+   */
+  addMotionListener(e) {
+    console.log("🎬 [Aippy Runtime] addMotionListener called"), this.motionListeners.push(e), console.log(`📝 [Aippy Runtime] Total motion listeners: ${this.motionListeners.length}`);
+    const n = window.webkit?.messageHandlers?.aippyListener;
+    if (!n)
+      return console.warn("⚠️ [Aippy Runtime] No webkit message handler found, using fallback mode"), () => {
+        const t = this.motionListeners.indexOf(e);
+        t > -1 && this.motionListeners.splice(t, 1);
+      };
+    console.log("✅ [Aippy Runtime] Webkit handler found, creating subscription");
+    const i = this.createSubscription(
+      n,
+      {
+        command: "navigator.motion",
+        type: "motion"
+      },
+      (t) => {
+        console.log("📥 [Aippy Runtime] Received motion data from native:", t), t.motion && e(t.motion);
+      }
+    );
+    return () => {
+      console.log("🧹 [Aippy Runtime] Cleaning up motion listener"), i.cancel();
+      const t = this.motionListeners.indexOf(e);
+      t > -1 && this.motionListeners.splice(t, 1);
+    };
+  }
+  /**
+   * Broadcast motion data to all registered listeners
+   * Called by processMotionData when iOS sends data directly
+   * @param data - Motion data from iOS
+   */
+  broadcastMotionData(e) {
+    if (this.motionListeners.length === 0) {
+      this.noListenersWarned || (console.warn("⚠️ [Aippy Runtime] No motion listeners to broadcast to"), this.noListenersWarned = !0);
+      return;
+    }
+    const n = e.motion || e;
+    this.motionListeners.forEach((i) => {
+      try {
+        i(n);
+      } catch (t) {
+        console.error("⚠️ [Aippy Runtime] Error in motion listener:", t);
+      }
+    });
+  }
+}
+function w(o) {
+  if (!o || typeof o != "object") {
+    console.warn("⚠️ [Aippy Runtime] Invalid motion data type:", typeof o);
+    return;
+  }
+  if (!("motion" in o) || typeof o.motion != "object") {
+    console.warn("⚠️ [Aippy Runtime] Motion data missing valid motion field");
+    return;
+  }
+  p.broadcastMotionData(o);
+}
+const p = new h();
+typeof window < "u" && (window.aippyRuntime = p, window.processMotionData = w);
+export {
+  d as A,
+  a as C,
+  R as E,
+  y as R,
+  h as a,
+  p as b,
+  g as c,
+  w as p
+};

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.11",
   "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
-};