@thelacanians/vue-native-runtime 0.1.0 → 0.2.0

package/dist/index.js

@@ -43,7 +43,7 @@ function createTextNode(text) {
   };
   return markRaw(node);
 }
-function createCommentNode(text) {
+function createCommentNode(_text) {
   const node = {
     id: getNextNodeId(),
     type: "__COMMENT__",
@@ -332,9 +332,9 @@ var NativeBridgeImpl = class {
     }
     const handlers = this.globalEventHandlers.get(eventName);
     if (handlers) {
-      handlers.forEach((h21) => {
+      handlers.forEach((h28) => {
         try {
-          h21(payload);
+          h28(payload);
         } catch (err) {
           console.error(`[VueNative] Error in global event handler "${eventName}":`, err);
         }
@@ -545,7 +545,10 @@ var VView = defineComponent({
   props: {
     style: Object,
     testID: String,
-    accessibilityLabel: String
+    accessibilityLabel: String,
+    accessibilityRole: String,
+    accessibilityHint: String,
+    accessibilityState: Object
   },
   setup(props, { slots }) {
     return () => h("VView", { ...props }, slots.default?.());
@@ -563,7 +566,10 @@ var VText = defineComponent2({
       type: Boolean,
       default: false
     },
-    accessibilityRole: String
+    accessibilityLabel: String,
+    accessibilityRole: String,
+    accessibilityHint: String,
+    accessibilityState: Object
   },
   setup(props, { slots }) {
     return () => h2("VText", { ...props }, slots.default?.());
@@ -585,7 +591,11 @@ var VButton = defineComponent3({
       default: 0.7
     },
     onPress: Function,
-    onLongPress: Function
+    onLongPress: Function,
+    accessibilityLabel: String,
+    accessibilityRole: String,
+    accessibilityHint: String,
+    accessibilityState: Object
   },
   setup(props, { slots }) {
     return () => h3(
@@ -635,7 +645,11 @@ var VInput = defineComponent4({
       type: Boolean,
       default: false
     },
-    style: Object
+    style: Object,
+    accessibilityLabel: String,
+    accessibilityRole: String,
+    accessibilityHint: String,
+    accessibilityState: Object
   },
   emits: ["update:modelValue", "focus", "blur", "submit"],
   setup(props, { emit }) {
@@ -663,6 +677,10 @@ var VInput = defineComponent4({
       maxLength: props.maxLength,
       multiline: props.multiline,
       style: props.style,
+      accessibilityLabel: props.accessibilityLabel,
+      accessibilityRole: props.accessibilityRole,
+      accessibilityHint: props.accessibilityHint,
+      accessibilityState: props.accessibilityState,
       onChangetext,
       onFocus,
       onBlur,
@@ -686,7 +704,11 @@ var VSwitch = defineComponent5({
     },
     onTintColor: String,
     thumbTintColor: String,
-    style: Object
+    style: Object,
+    accessibilityLabel: String,
+    accessibilityRole: String,
+    accessibilityHint: String,
+    accessibilityState: Object
   },
   emits: ["update:modelValue", "change"],
   setup(props, { emit }) {
@@ -701,6 +723,10 @@ var VSwitch = defineComponent5({
       onTintColor: props.onTintColor,
       thumbTintColor: props.thumbTintColor,
       style: props.style,
+      accessibilityLabel: props.accessibilityLabel,
+      accessibilityRole: props.accessibilityRole,
+      accessibilityHint: props.accessibilityHint,
+      accessibilityState: props.accessibilityState,
       onChange
     });
   }
@@ -773,7 +799,11 @@ var VScrollView = defineComponent7({
       type: Boolean,
       default: false
     },
-    style: Object
+    style: Object,
+    accessibilityLabel: String,
+    accessibilityRole: String,
+    accessibilityHint: String,
+    accessibilityState: Object
   },
   emits: ["scroll", "refresh"],
   setup(props, { slots, emit }) {
@@ -795,6 +825,10 @@ var VScrollView = defineComponent7({
         contentContainerStyle: props.contentContainerStyle,
         refreshing: props.refreshing,
         style: props.style,
+        accessibilityLabel: props.accessibilityLabel,
+        accessibilityRole: props.accessibilityRole,
+        accessibilityHint: props.accessibilityHint,
+        accessibilityState: props.accessibilityState,
         onScroll,
         onRefresh
       },
@@ -815,7 +849,10 @@ var VImage = defineComponent8({
     },
     style: Object,
     testID: String,
-    accessibilityLabel: String
+    accessibilityLabel: String,
+    accessibilityRole: String,
+    accessibilityHint: String,
+    accessibilityState: Object
   },
   emits: ["load", "error"],
   setup(props, { emit }) {
@@ -863,7 +900,11 @@ var VSlider = defineComponent11({
     modelValue: { type: Number, default: 0 },
     min: { type: Number, default: 0 },
     max: { type: Number, default: 1 },
-    style: { type: Object, default: () => ({}) }
+    style: { type: Object, default: () => ({}) },
+    accessibilityLabel: String,
+    accessibilityRole: String,
+    accessibilityHint: String,
+    accessibilityState: Object
   },
   emits: ["update:modelValue", "change"],
   setup(props, { emit }) {
@@ -872,6 +913,10 @@ var VSlider = defineComponent11({
       value: props.modelValue,
       minimumValue: props.min,
       maximumValue: props.max,
+      accessibilityLabel: props.accessibilityLabel,
+      accessibilityRole: props.accessibilityRole,
+      accessibilityHint: props.accessibilityHint,
+      accessibilityState: props.accessibilityState,
       onChange: (val) => {
         emit("update:modelValue", val);
         emit("change", val);
@@ -1158,6 +1203,352 @@ var VActionSheet = defineComponent20({
   }
 });
 
+// src/components/VRefreshControl.ts
+import { defineComponent as defineComponent21, h as h21 } from "@vue/runtime-core";
+var VRefreshControl = defineComponent21({
+  name: "VRefreshControl",
+  props: {
+    refreshing: {
+      type: Boolean,
+      default: false
+    },
+    onRefresh: Function,
+    tintColor: String,
+    title: String,
+    style: Object
+  },
+  setup(props) {
+    return () => h21("VRefreshControl", {
+      refreshing: props.refreshing,
+      onRefresh: props.onRefresh,
+      tintColor: props.tintColor,
+      title: props.title
+    });
+  }
+});
+
+// src/components/VPressable.ts
+import { defineComponent as defineComponent22, h as h22 } from "@vue/runtime-core";
+var VPressable = defineComponent22({
+  name: "VPressable",
+  props: {
+    style: Object,
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    activeOpacity: {
+      type: Number,
+      default: 0.7
+    },
+    onPress: Function,
+    onPressIn: Function,
+    onPressOut: Function,
+    onLongPress: Function,
+    accessibilityLabel: String,
+    accessibilityRole: String,
+    accessibilityHint: String,
+    accessibilityState: Object
+  },
+  setup(props, { slots }) {
+    return () => h22(
+      "VPressable",
+      {
+        ...props,
+        onPress: props.disabled ? void 0 : props.onPress,
+        onPressIn: props.disabled ? void 0 : props.onPressIn,
+        onPressOut: props.disabled ? void 0 : props.onPressOut,
+        onLongPress: props.disabled ? void 0 : props.onLongPress
+      },
+      slots.default?.()
+    );
+  }
+});
+
+// src/components/VSectionList.ts
+import { defineComponent as defineComponent23, h as h23 } from "@vue/runtime-core";
+var VSectionList = defineComponent23({
+  name: "VSectionList",
+  props: {
+    /** Array of section objects, each with a title and data array */
+    sections: {
+      type: Array,
+      required: true
+    },
+    /** Extract a unique key from each item. Defaults to index as string. */
+    keyExtractor: {
+      type: Function,
+      default: (_item, index) => String(index)
+    },
+    /** Estimated height per row in points. Default: 44 */
+    estimatedItemHeight: {
+      type: Number,
+      default: 44
+    },
+    /** Whether section headers stick to the top when scrolling. Default: true */
+    stickySectionHeaders: {
+      type: Boolean,
+      default: true
+    },
+    /** Show vertical scroll indicator. Default: true */
+    showsScrollIndicator: {
+      type: Boolean,
+      default: true
+    },
+    /** Enable bounce at scroll boundaries. Default: true */
+    bounces: {
+      type: Boolean,
+      default: true
+    },
+    style: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  emits: ["scroll", "endReached"],
+  setup(props, { slots, emit }) {
+    return () => {
+      const sections = props.sections ?? [];
+      const children = [];
+      if (slots.header) {
+        children.push(
+          h23("VView", { key: "__header__", style: { flexShrink: 0 } }, slots.header())
+        );
+      }
+      const totalItems = sections.reduce((sum, s) => sum + (s.data?.length ?? 0), 0);
+      if (totalItems === 0 && slots.empty) {
+        children.push(
+          h23("VView", { key: "__empty__", style: { flexShrink: 0 } }, slots.empty())
+        );
+      }
+      for (let sectionIndex = 0; sectionIndex < sections.length; sectionIndex++) {
+        const section = sections[sectionIndex];
+        if (slots.sectionHeader) {
+          children.push(
+            h23(
+              "VView",
+              {
+                key: `__section_header_${sectionIndex}__`,
+                __sectionHeader: true,
+                style: { flexShrink: 0 }
+              },
+              slots.sectionHeader({ section, index: sectionIndex })
+            )
+          );
+        }
+        const items = section.data ?? [];
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+          const item = items[itemIndex];
+          children.push(
+            h23(
+              "VView",
+              {
+                key: `${sectionIndex}_${props.keyExtractor(item, itemIndex)}`,
+                style: { flexShrink: 0 }
+              },
+              slots.item?.({ item, index: itemIndex, section }) ?? []
+            )
+          );
+        }
+        if (slots.sectionFooter) {
+          children.push(
+            h23(
+              "VView",
+              {
+                key: `__section_footer_${sectionIndex}__`,
+                style: { flexShrink: 0 }
+              },
+              slots.sectionFooter({ section, index: sectionIndex })
+            )
+          );
+        }
+      }
+      if (slots.footer) {
+        children.push(
+          h23("VView", { key: "__footer__", style: { flexShrink: 0 } }, slots.footer())
+        );
+      }
+      return h23(
+        "VSectionList",
+        {
+          style: props.style,
+          estimatedItemHeight: props.estimatedItemHeight,
+          stickySectionHeaders: props.stickySectionHeaders,
+          showsScrollIndicator: props.showsScrollIndicator,
+          bounces: props.bounces,
+          onScroll: (e) => emit("scroll", e),
+          onEndReached: () => emit("endReached")
+        },
+        children
+      );
+    };
+  }
+});
+
+// src/components/VCheckbox.ts
+import { defineComponent as defineComponent24, h as h24 } from "@vue/runtime-core";
+var VCheckbox = defineComponent24({
+  name: "VCheckbox",
+  props: {
+    modelValue: {
+      type: Boolean,
+      default: false
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    label: {
+      type: String,
+      default: void 0
+    },
+    checkColor: String,
+    tintColor: String,
+    style: Object,
+    accessibilityLabel: String,
+    accessibilityHint: String
+  },
+  emits: ["update:modelValue", "change"],
+  setup(props, { emit }) {
+    const onChange = (payload) => {
+      const value = typeof payload === "boolean" ? payload : !!(payload?.value ?? payload);
+      emit("update:modelValue", value);
+      emit("change", value);
+    };
+    return () => h24("VCheckbox", {
+      value: props.modelValue,
+      disabled: props.disabled,
+      label: props.label,
+      checkColor: props.checkColor,
+      tintColor: props.tintColor,
+      style: props.style,
+      accessibilityLabel: props.accessibilityLabel,
+      accessibilityHint: props.accessibilityHint,
+      onChange
+    });
+  }
+});
+
+// src/components/VRadio.ts
+import { defineComponent as defineComponent25, h as h25 } from "@vue/runtime-core";
+var VRadio = defineComponent25({
+  name: "VRadio",
+  props: {
+    modelValue: {
+      type: String,
+      default: void 0
+    },
+    options: {
+      type: Array,
+      required: true
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    tintColor: String,
+    style: Object,
+    accessibilityLabel: String
+  },
+  emits: ["update:modelValue", "change"],
+  setup(props, { emit }) {
+    const onChange = (payload) => {
+      const value = payload?.value ?? payload;
+      emit("update:modelValue", value);
+      emit("change", value);
+    };
+    return () => h25("VRadio", {
+      selectedValue: props.modelValue,
+      options: props.options,
+      disabled: props.disabled,
+      tintColor: props.tintColor,
+      style: props.style,
+      accessibilityLabel: props.accessibilityLabel,
+      onChange
+    });
+  }
+});
+
+// src/components/VDropdown.ts
+import { defineComponent as defineComponent26, h as h26 } from "@vue/runtime-core";
+var VDropdown = defineComponent26({
+  name: "VDropdown",
+  props: {
+    modelValue: {
+      type: String,
+      default: void 0
+    },
+    options: {
+      type: Array,
+      required: true
+    },
+    placeholder: {
+      type: String,
+      default: "Select..."
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    tintColor: String,
+    style: Object,
+    accessibilityLabel: String
+  },
+  emits: ["update:modelValue", "change"],
+  setup(props, { emit }) {
+    const onChange = (payload) => {
+      const value = payload?.value ?? payload;
+      emit("update:modelValue", value);
+      emit("change", value);
+    };
+    return () => h26("VDropdown", {
+      selectedValue: props.modelValue,
+      options: props.options,
+      placeholder: props.placeholder,
+      disabled: props.disabled,
+      tintColor: props.tintColor,
+      style: props.style,
+      accessibilityLabel: props.accessibilityLabel,
+      onChange
+    });
+  }
+});
+
+// src/components/VVideo.ts
+import { defineComponent as defineComponent27, h as h27 } from "@vue/runtime-core";
+var VVideo = defineComponent27({
+  name: "VVideo",
+  props: {
+    source: Object,
+    autoplay: { type: Boolean, default: false },
+    loop: { type: Boolean, default: false },
+    muted: { type: Boolean, default: false },
+    paused: { type: Boolean, default: false },
+    controls: { type: Boolean, default: true },
+    volume: { type: Number, default: 1 },
+    resizeMode: {
+      type: String,
+      default: "cover"
+    },
+    poster: String,
+    style: Object,
+    testID: String,
+    accessibilityLabel: String
+  },
+  emits: ["ready", "play", "pause", "end", "error", "progress"],
+  setup(props, { emit }) {
+    return () => h27("VVideo", {
+      ...props,
+      onReady: (e) => emit("ready", e),
+      onPlay: () => emit("play"),
+      onPause: () => emit("pause"),
+      onEnd: () => emit("end"),
+      onError: (e) => emit("error", e),
+      onProgress: (e) => emit("progress", e)
+    });
+  }
+});
+
 // src/directives/vShow.ts
 var vShow = {
   beforeMount(el, { value }) {
@@ -1169,6 +1560,51 @@ var vShow = {
   }
 };
 
+// src/errorBoundary.ts
+import { defineComponent as defineComponent28, ref, watch, onErrorCaptured } from "@vue/runtime-core";
+var ErrorBoundary = defineComponent28({
+  name: "ErrorBoundary",
+  props: {
+    onError: Function,
+    resetKeys: {
+      type: Array,
+      default: () => []
+    }
+  },
+  setup(props, { slots }) {
+    const error = ref(null);
+    const errorInfo = ref("");
+    onErrorCaptured((err, _instance, info) => {
+      const normalizedError = err instanceof Error ? err : new Error(String(err));
+      error.value = normalizedError;
+      errorInfo.value = info;
+      if (props.onError) {
+        props.onError(normalizedError, info);
+      }
+      return false;
+    });
+    function reset() {
+      error.value = null;
+      errorInfo.value = "";
+    }
+    watch(
+      () => props.resetKeys,
+      () => {
+        if (error.value) {
+          reset();
+        }
+      },
+      { deep: true }
+    );
+    return () => {
+      if (error.value && slots.fallback) {
+        return slots.fallback({ error: error.value, errorInfo: errorInfo.value, reset });
+      }
+      return slots.default?.();
+    };
+  }
+});
+
 // src/index.ts
 export * from "@vue/runtime-core";
 
@@ -1213,6 +1649,7 @@ var validStyleProperties = /* @__PURE__ */ new Set([
   "gap",
   "rowGap",
   "columnGap",
+  "direction",
   "display",
   "overflow",
   "zIndex",
@@ -1260,7 +1697,15 @@ var validStyleProperties = /* @__PURE__ */ new Set([
   "resizeMode",
   "tintColor",
   // Transform
-  "transform"
+  "transform",
+  // Accessibility
+  "accessibilityLabel",
+  "accessibilityRole",
+  "accessibilityHint",
+  "accessibilityState",
+  "accessibilityValue",
+  "accessible",
+  "importantForAccessibility"
 ]);
 function createStyleSheet(styles) {
   const isDev = typeof __DEV__ !== "undefined" ? __DEV__ : true;
@@ -1318,9 +1763,9 @@ function useAsyncStorage() {
 }
 
 // src/composables/useClipboard.ts
-import { ref } from "@vue/runtime-core";
+import { ref as ref2 } from "@vue/runtime-core";
 function useClipboard() {
-  const content = ref("");
+  const content = ref2("");
   function copy(text) {
     return NativeBridge.invokeNativeModule("Clipboard", "copy", [text]).then(() => void 0);
   }
@@ -1334,16 +1779,16 @@ function useClipboard() {
 }
 
 // src/composables/useDeviceInfo.ts
-import { ref as ref2, onMounted } from "@vue/runtime-core";
+import { ref as ref3, onMounted } from "@vue/runtime-core";
 function useDeviceInfo() {
-  const model = ref2("");
-  const systemVersion = ref2("");
-  const systemName = ref2("");
-  const name = ref2("");
-  const screenWidth = ref2(0);
-  const screenHeight = ref2(0);
-  const scale = ref2(1);
-  const isLoaded = ref2(false);
+  const model = ref3("");
+  const systemVersion = ref3("");
+  const systemName = ref3("");
+  const name = ref3("");
+  const screenWidth = ref3(0);
+  const screenHeight = ref3(0);
+  const scale = ref3(1);
+  const isLoaded = ref3(false);
   async function fetchInfo() {
     const info = await NativeBridge.invokeNativeModule("DeviceInfo", "getInfo", []);
     model.value = info.model ?? "";
@@ -1372,10 +1817,10 @@ function useDeviceInfo() {
 }
 
 // src/composables/useKeyboard.ts
-import { ref as ref3 } from "@vue/runtime-core";
+import { ref as ref4 } from "@vue/runtime-core";
 function useKeyboard() {
-  const isVisible = ref3(false);
-  const height = ref3(0);
+  const isVisible = ref4(false);
+  const height = ref4(0);
   function dismiss() {
     return NativeBridge.invokeNativeModule("Keyboard", "dismiss", []).then(() => void 0);
   }
@@ -1439,10 +1884,10 @@ function useAnimation() {
 }
 
 // src/composables/useNetwork.ts
-import { ref as ref4, onUnmounted } from "@vue/runtime-core";
+import { ref as ref5, onUnmounted } from "@vue/runtime-core";
 function useNetwork() {
-  const isConnected = ref4(true);
-  const connectionType = ref4("unknown");
+  const isConnected = ref5(true);
+  const connectionType = ref5("unknown");
   NativeBridge.invokeNativeModule("Network", "getStatus").then((status) => {
     isConnected.value = status.isConnected;
     connectionType.value = status.connectionType;
@@ -1457,9 +1902,9 @@ function useNetwork() {
 }
 
 // src/composables/useAppState.ts
-import { ref as ref5, onUnmounted as onUnmounted2 } from "@vue/runtime-core";
+import { ref as ref6, onUnmounted as onUnmounted2 } from "@vue/runtime-core";
 function useAppState() {
-  const state = ref5("active");
+  const state = ref6("active");
   NativeBridge.invokeNativeModule("AppState", "getState").then((s) => {
     state.value = s;
   }).catch(() => {
@@ -1502,10 +1947,10 @@ function usePermissions() {
 }
 
 // src/composables/useGeolocation.ts
-import { ref as ref6, onUnmounted as onUnmounted3 } from "@vue/runtime-core";
+import { ref as ref7, onUnmounted as onUnmounted3 } from "@vue/runtime-core";
 function useGeolocation() {
-  const coords = ref6(null);
-  const error = ref6(null);
+  const coords = ref7(null);
+  const error = ref7(null);
   let watchId = null;
   async function getCurrentPosition() {
     const result = await NativeBridge.invokeNativeModule("Geolocation", "getCurrentPosition");
@@ -1532,20 +1977,43 @@ function useGeolocation() {
 }
 
 // src/composables/useCamera.ts
+import { onUnmounted as onUnmounted4 } from "@vue/runtime-core";
 function useCamera() {
+  const qrCleanups = [];
   async function launchCamera(options = {}) {
     return NativeBridge.invokeNativeModule("Camera", "launchCamera", [options]);
   }
   async function launchImageLibrary(options = {}) {
     return NativeBridge.invokeNativeModule("Camera", "launchImageLibrary", [options]);
   }
-  return { launchCamera, launchImageLibrary };
+  async function captureVideo(options = {}) {
+    return NativeBridge.invokeNativeModule("Camera", "captureVideo", [options]);
+  }
+  async function scanQRCode() {
+    return NativeBridge.invokeNativeModule("Camera", "scanQRCode");
+  }
+  async function stopQRScan() {
+    return NativeBridge.invokeNativeModule("Camera", "stopQRScan");
+  }
+  function onQRCodeDetected(callback) {
+    const unsubscribe = NativeBridge.onGlobalEvent("camera:qrDetected", callback);
+    qrCleanups.push(unsubscribe);
+    return unsubscribe;
+  }
+  onUnmounted4(() => {
+    NativeBridge.invokeNativeModule("Camera", "stopQRScan").catch(() => {
+    });
+    qrCleanups.forEach((fn) => fn());
+    qrCleanups.length = 0;
+  });
+  return { launchCamera, launchImageLibrary, captureVideo, scanQRCode, stopQRScan, onQRCodeDetected };
 }
 
 // src/composables/useNotifications.ts
-import { ref as ref7, onUnmounted as onUnmounted4 } from "@vue/runtime-core";
+import { ref as ref8, onUnmounted as onUnmounted5 } from "@vue/runtime-core";
 function useNotifications() {
-  const isGranted = ref7(false);
+  const isGranted = ref8(false);
+  const pushToken = ref8(null);
   async function requestPermission() {
     const granted = await NativeBridge.invokeNativeModule("Notifications", "requestPermission");
     isGranted.value = granted;
@@ -1565,10 +2033,44 @@ function useNotifications() {
   }
   function onNotification(handler) {
     const unsubscribe = NativeBridge.onGlobalEvent("notification:received", handler);
-    onUnmounted4(unsubscribe);
+    onUnmounted5(unsubscribe);
+    return unsubscribe;
+  }
+  async function registerForPush() {
+    await NativeBridge.invokeNativeModule("Notifications", "registerForPush");
+  }
+  async function getToken() {
+    return NativeBridge.invokeNativeModule("Notifications", "getToken");
+  }
+  function onPushToken(handler) {
+    const unsubscribe = NativeBridge.onGlobalEvent("push:token", (payload) => {
+      pushToken.value = payload.token;
+      handler(payload.token);
+    });
+    onUnmounted5(unsubscribe);
+    return unsubscribe;
+  }
+  function onPushReceived(handler) {
+    const unsubscribe = NativeBridge.onGlobalEvent("push:received", handler);
+    onUnmounted5(unsubscribe);
     return unsubscribe;
   }
-  return { isGranted, requestPermission, getPermissionStatus, scheduleLocal, cancel, cancelAll, onNotification };
+  return {
+    // Local
+    isGranted,
+    requestPermission,
+    getPermissionStatus,
+    scheduleLocal,
+    cancel,
+    cancelAll,
+    onNotification,
+    // Push
+    pushToken,
+    registerForPush,
+    getToken,
+    onPushToken,
+    onPushReceived
+  };
 }
 
 // src/composables/useBiometry.ts
@@ -1586,10 +2088,18 @@ function useBiometry() {
 }
 
 // src/composables/useHttp.ts
-import { ref as ref8 } from "@vue/runtime-core";
+import { ref as ref9 } from "@vue/runtime-core";
 function useHttp(config = {}) {
-  const loading = ref8(false);
-  const error = ref8(null);
+  if (config.pins && Object.keys(config.pins).length > 0) {
+    const configurePins = globalThis.__VN_configurePins;
+    if (typeof configurePins === "function") {
+      configurePins(JSON.stringify(config.pins));
+    } else {
+      NativeBridge.invokeNativeModule("Http", "configurePins", [config.pins]);
+    }
+  }
+  const loading = ref9(false);
+  const error = ref9(null);
   async function request(method, url, options = {}) {
     const fullUrl = config.baseURL ? `${config.baseURL}${url}` : url;
     loading.value = true;
@@ -1635,10 +2145,10 @@ function useHttp(config = {}) {
 }
 
 // src/composables/useColorScheme.ts
-import { ref as ref9, onUnmounted as onUnmounted5 } from "@vue/runtime-core";
+import { ref as ref10, onUnmounted as onUnmounted6 } from "@vue/runtime-core";
 function useColorScheme() {
-  const colorScheme = ref9("light");
-  const isDark = ref9(false);
+  const colorScheme = ref10("light");
+  const isDark = ref10(false);
   const unsubscribe = NativeBridge.onGlobalEvent(
     "colorScheme:change",
     (payload) => {
@@ -1646,12 +2156,12 @@ function useColorScheme() {
       isDark.value = payload.colorScheme === "dark";
     }
   );
-  onUnmounted5(unsubscribe);
+  onUnmounted6(unsubscribe);
   return { colorScheme, isDark };
 }
 
 // src/composables/useBackHandler.ts
-import { onMounted as onMounted2, onUnmounted as onUnmounted6 } from "@vue/runtime-core";
+import { onMounted as onMounted2, onUnmounted as onUnmounted7 } from "@vue/runtime-core";
 function useBackHandler(handler) {
   let unsubscribe = null;
   onMounted2(() => {
@@ -1659,12 +2169,1056 @@ function useBackHandler(handler) {
       handler();
     });
   });
-  onUnmounted6(() => {
+  onUnmounted7(() => {
     unsubscribe?.();
     unsubscribe = null;
   });
 }
 
+// src/composables/useSecureStorage.ts
+function useSecureStorage() {
+  function getItem(key) {
+    return NativeBridge.invokeNativeModule("SecureStorage", "get", [key]);
+  }
+  function setItem(key, value) {
+    return NativeBridge.invokeNativeModule("SecureStorage", "set", [key, value]).then(() => void 0);
+  }
+  function removeItem(key) {
+    return NativeBridge.invokeNativeModule("SecureStorage", "remove", [key]).then(() => void 0);
+  }
+  function clear() {
+    return NativeBridge.invokeNativeModule("SecureStorage", "clear", []).then(() => void 0);
+  }
+  return { getItem, setItem, removeItem, clear };
+}
+
+// src/composables/useI18n.ts
+import { ref as ref11, onMounted as onMounted3 } from "@vue/runtime-core";
+function useI18n() {
+  const isRTL = ref11(false);
+  const locale = ref11("en");
+  onMounted3(async () => {
+    try {
+      const info = await NativeBridge.invokeNativeModule("DeviceInfo", "getDeviceInfo", []);
+      locale.value = info?.locale || "en";
+      isRTL.value = ["ar", "he", "fa", "ur"].some((l) => locale.value.startsWith(l));
+    } catch {
+    }
+  });
+  return { isRTL, locale };
+}
+
+// src/composables/usePlatform.ts
+function usePlatform() {
+  const platform = typeof __PLATFORM__ !== "undefined" ? __PLATFORM__ : "ios";
+  const isIOS = platform === "ios";
+  const isAndroid = platform === "android";
+  return { platform, isIOS, isAndroid };
+}
+
+// src/composables/useDimensions.ts
+import { ref as ref12, onMounted as onMounted4, onUnmounted as onUnmounted8 } from "@vue/runtime-core";
+function useDimensions() {
+  const width = ref12(0);
+  const height = ref12(0);
+  const scale = ref12(1);
+  onMounted4(async () => {
+    try {
+      const info = await NativeBridge.invokeNativeModule("DeviceInfo", "getInfo", []);
+      width.value = info?.screenWidth || 0;
+      height.value = info?.screenHeight || 0;
+      scale.value = info?.scale || 1;
+    } catch {
+    }
+  });
+  const cleanup = NativeBridge.onGlobalEvent("dimensionsChange", (payload) => {
+    if (payload.width != null) width.value = payload.width;
+    if (payload.height != null) height.value = payload.height;
+    if (payload.scale != null) scale.value = payload.scale;
+  });
+  onUnmounted8(cleanup);
+  return { width, height, scale };
+}
+
+// src/composables/useWebSocket.ts
+import { ref as ref13, onUnmounted as onUnmounted9 } from "@vue/runtime-core";
+var connectionCounter = 0;
+function useWebSocket(url, options = {}) {
+  const {
+    autoConnect = true,
+    autoReconnect = false,
+    maxReconnectAttempts = 3,
+    reconnectInterval = 1e3
+  } = options;
+  const connectionId = `ws_${++connectionCounter}_${Date.now()}`;
+  const status = ref13("CLOSED");
+  const lastMessage = ref13(null);
+  const error = ref13(null);
+  let reconnectAttempts = 0;
+  let reconnectTimer = null;
+  const unsubscribers = [];
+  unsubscribers.push(
+    NativeBridge.onGlobalEvent("websocket:open", (payload) => {
+      if (payload.connectionId !== connectionId) return;
+      status.value = "OPEN";
+      error.value = null;
+      reconnectAttempts = 0;
+    })
+  );
+  unsubscribers.push(
+    NativeBridge.onGlobalEvent("websocket:message", (payload) => {
+      if (payload.connectionId !== connectionId) return;
+      lastMessage.value = payload.data;
+    })
+  );
+  unsubscribers.push(
+    NativeBridge.onGlobalEvent("websocket:close", (payload) => {
+      if (payload.connectionId !== connectionId) return;
+      status.value = "CLOSED";
+      if (autoReconnect && reconnectAttempts < maxReconnectAttempts && payload.code !== 1e3) {
+        reconnectAttempts++;
+        reconnectTimer = setTimeout(() => {
+          open();
+        }, reconnectInterval);
+      }
+    })
+  );
+  unsubscribers.push(
+    NativeBridge.onGlobalEvent("websocket:error", (payload) => {
+      if (payload.connectionId !== connectionId) return;
+      error.value = payload.message;
+    })
+  );
+  function open() {
+    if (status.value === "OPEN" || status.value === "CONNECTING") return;
+    status.value = "CONNECTING";
+    error.value = null;
+    NativeBridge.invokeNativeModule("WebSocket", "connect", [url, connectionId]).catch((err) => {
+      status.value = "CLOSED";
+      error.value = err.message;
+    });
+  }
+  function send(data) {
+    if (status.value !== "OPEN") return;
+    const message = typeof data === "string" ? data : JSON.stringify(data);
+    NativeBridge.invokeNativeModule("WebSocket", "send", [connectionId, message]).catch((err) => {
+      error.value = err.message;
+    });
+  }
+  function close(code, reason) {
+    if (status.value === "CLOSED" || status.value === "CLOSING") return;
+    status.value = "CLOSING";
+    if (reconnectTimer) {
+      clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+    reconnectAttempts = maxReconnectAttempts;
+    NativeBridge.invokeNativeModule("WebSocket", "close", [connectionId, code ?? 1e3, reason ?? ""]).catch(() => {
+      status.value = "CLOSED";
+    });
+  }
+  if (autoConnect) {
+    open();
+  }
+  onUnmounted9(() => {
+    if (reconnectTimer) {
+      clearTimeout(reconnectTimer);
+    }
+    if (status.value === "OPEN" || status.value === "CONNECTING") {
+      reconnectAttempts = maxReconnectAttempts;
+      NativeBridge.invokeNativeModule("WebSocket", "close", [connectionId, 1e3, ""]).catch(() => {
+      });
+    }
+    unsubscribers.forEach((unsub) => unsub());
+  });
+  return { status, lastMessage, error, send, close, open };
+}
+
+// src/composables/useFileSystem.ts
+function useFileSystem() {
+  function readFile(path, encoding) {
+    return NativeBridge.invokeNativeModule("FileSystem", "readFile", [path, encoding ?? "utf8"]);
+  }
+  function writeFile(path, content, encoding) {
+    return NativeBridge.invokeNativeModule("FileSystem", "writeFile", [path, content, encoding ?? "utf8"]).then(() => void 0);
+  }
+  function deleteFile(path) {
+    return NativeBridge.invokeNativeModule("FileSystem", "deleteFile", [path]).then(() => void 0);
+  }
+  function exists(path) {
+    return NativeBridge.invokeNativeModule("FileSystem", "exists", [path]);
+  }
+  function listDirectory(path) {
+    return NativeBridge.invokeNativeModule("FileSystem", "listDirectory", [path]);
+  }
+  function downloadFile(url, destPath) {
+    return NativeBridge.invokeNativeModule("FileSystem", "downloadFile", [url, destPath]);
+  }
+  function getDocumentsPath() {
+    return NativeBridge.invokeNativeModule("FileSystem", "getDocumentsPath", []);
+  }
+  function getCachesPath() {
+    return NativeBridge.invokeNativeModule("FileSystem", "getCachesPath", []);
+  }
+  function stat(path) {
+    return NativeBridge.invokeNativeModule("FileSystem", "stat", [path]);
+  }
+  function mkdir(path) {
+    return NativeBridge.invokeNativeModule("FileSystem", "mkdir", [path]).then(() => void 0);
+  }
+  function copyFile(srcPath, destPath) {
+    return NativeBridge.invokeNativeModule("FileSystem", "copyFile", [srcPath, destPath]).then(() => void 0);
+  }
+  function moveFile(srcPath, destPath) {
+    return NativeBridge.invokeNativeModule("FileSystem", "moveFile", [srcPath, destPath]).then(() => void 0);
+  }
+  return {
+    readFile,
+    writeFile,
+    deleteFile,
+    exists,
+    listDirectory,
+    downloadFile,
+    getDocumentsPath,
+    getCachesPath,
+    stat,
+    mkdir,
+    copyFile,
+    moveFile
+  };
+}
+
+// src/composables/useSensors.ts
+import { ref as ref14, onUnmounted as onUnmounted10 } from "@vue/runtime-core";
+function useAccelerometer(options = {}) {
+  const x = ref14(0);
+  const y = ref14(0);
+  const z = ref14(0);
+  const isAvailable = ref14(false);
+  let running = false;
+  let unsubscribe = null;
+  NativeBridge.invokeNativeModule("Sensors", "isAvailable", ["accelerometer"]).then((result) => {
+    isAvailable.value = result.available;
+  }).catch(() => {
+  });
+  function start() {
+    if (running) return;
+    running = true;
+    unsubscribe = NativeBridge.onGlobalEvent("sensor:accelerometer", (payload) => {
+      x.value = payload.x;
+      y.value = payload.y;
+      z.value = payload.z;
+    });
+    NativeBridge.invokeNativeModule("Sensors", "startAccelerometer", [
+      options.interval ?? 100
+    ]).catch(() => {
+    });
+  }
+  function stop() {
+    if (!running) return;
+    running = false;
+    unsubscribe?.();
+    unsubscribe = null;
+    NativeBridge.invokeNativeModule("Sensors", "stopAccelerometer").catch(() => {
+    });
+  }
+  onUnmounted10(() => {
+    stop();
+  });
+  return { x, y, z, isAvailable, start, stop };
+}
+function useGyroscope(options = {}) {
+  const x = ref14(0);
+  const y = ref14(0);
+  const z = ref14(0);
+  const isAvailable = ref14(false);
+  let running = false;
+  let unsubscribe = null;
+  NativeBridge.invokeNativeModule("Sensors", "isAvailable", ["gyroscope"]).then((result) => {
+    isAvailable.value = result.available;
+  }).catch(() => {
+  });
+  function start() {
+    if (running) return;
+    running = true;
+    unsubscribe = NativeBridge.onGlobalEvent("sensor:gyroscope", (payload) => {
+      x.value = payload.x;
+      y.value = payload.y;
+      z.value = payload.z;
+    });
+    NativeBridge.invokeNativeModule("Sensors", "startGyroscope", [
+      options.interval ?? 100
+    ]).catch(() => {
+    });
+  }
+  function stop() {
+    if (!running) return;
+    running = false;
+    unsubscribe?.();
+    unsubscribe = null;
+    NativeBridge.invokeNativeModule("Sensors", "stopGyroscope").catch(() => {
+    });
+  }
+  onUnmounted10(() => {
+    stop();
+  });
+  return { x, y, z, isAvailable, start, stop };
+}
+
+// src/composables/useAudio.ts
+import { ref as ref15, onUnmounted as onUnmounted11 } from "@vue/runtime-core";
+function useAudio() {
+  const duration = ref15(0);
+  const position = ref15(0);
+  const isPlaying = ref15(false);
+  const isRecording = ref15(false);
+  const error = ref15(null);
+  const unsubProgress = NativeBridge.onGlobalEvent("audio:progress", (payload) => {
+    position.value = payload.currentTime ?? 0;
+    duration.value = payload.duration ?? 0;
+  });
+  const unsubComplete = NativeBridge.onGlobalEvent("audio:complete", () => {
+    isPlaying.value = false;
+    position.value = 0;
+  });
+  const unsubError = NativeBridge.onGlobalEvent("audio:error", (payload) => {
+    error.value = payload.message ?? "Unknown audio error";
+    isPlaying.value = false;
+  });
+  onUnmounted11(() => {
+    unsubProgress();
+    unsubComplete();
+    unsubError();
+    NativeBridge.invokeNativeModule("Audio", "stop", []).catch(() => {
+    });
+    if (isRecording.value) {
+      NativeBridge.invokeNativeModule("Audio", "stopRecording", []).catch(() => {
+      });
+    }
+  });
+  async function play(uri, options = {}) {
+    error.value = null;
+    const result = await NativeBridge.invokeNativeModule("Audio", "play", [uri, options]);
+    if (result?.duration != null) {
+      duration.value = result.duration;
+    }
+    isPlaying.value = true;
+  }
+  async function pause() {
+    await NativeBridge.invokeNativeModule("Audio", "pause", []);
+    isPlaying.value = false;
+  }
+  async function resume() {
+    await NativeBridge.invokeNativeModule("Audio", "resume", []);
+    isPlaying.value = true;
+  }
+  async function stop() {
+    await NativeBridge.invokeNativeModule("Audio", "stop", []);
+    isPlaying.value = false;
+    position.value = 0;
+    duration.value = 0;
+  }
+  async function seek(positionSec) {
+    await NativeBridge.invokeNativeModule("Audio", "seek", [positionSec]);
+  }
+  async function setVolume(volume) {
+    await NativeBridge.invokeNativeModule("Audio", "setVolume", [volume]);
+  }
+  async function startRecording(options = {}) {
+    error.value = null;
+    const result = await NativeBridge.invokeNativeModule("Audio", "startRecording", [options]);
+    isRecording.value = true;
+    return result?.uri ?? "";
+  }
+  async function stopRecording() {
+    const result = await NativeBridge.invokeNativeModule("Audio", "stopRecording", []);
+    isRecording.value = false;
+    return { uri: result?.uri ?? "", duration: result?.duration ?? 0 };
+  }
+  async function pauseRecording() {
+    await NativeBridge.invokeNativeModule("Audio", "pauseRecording", []);
+  }
+  async function resumeRecording() {
+    await NativeBridge.invokeNativeModule("Audio", "resumeRecording", []);
+  }
+  return {
+    // Playback
+    play,
+    pause,
+    resume,
+    stop,
+    seek,
+    setVolume,
+    // Recording
+    startRecording,
+    stopRecording,
+    pauseRecording,
+    resumeRecording,
+    // Reactive state
+    duration,
+    position,
+    isPlaying,
+    isRecording,
+    error
+  };
+}
+
+// src/composables/useDatabase.ts
+import { ref as ref16, onUnmounted as onUnmounted12 } from "@vue/runtime-core";
+function useDatabase(name = "default") {
+  const isOpen = ref16(false);
+  let opened = false;
+  async function ensureOpen() {
+    if (opened) return;
+    await NativeBridge.invokeNativeModule("Database", "open", [name]);
+    opened = true;
+    isOpen.value = true;
+  }
+  async function execute(sql, params) {
+    await ensureOpen();
+    return NativeBridge.invokeNativeModule("Database", "execute", [name, sql, params ?? []]);
+  }
+  async function query(sql, params) {
+    await ensureOpen();
+    return NativeBridge.invokeNativeModule("Database", "query", [name, sql, params ?? []]);
+  }
+  async function transaction(callback) {
+    await ensureOpen();
+    const statements = [];
+    const ctx = {
+      execute: async (sql, params) => {
+        statements.push({ sql, params: params ?? [] });
+        return { rowsAffected: 0 };
+      },
+      query: async (sql, params) => {
+        if (statements.length > 0) {
+          await NativeBridge.invokeNativeModule("Database", "executeTransaction", [name, statements.splice(0)]);
+        }
+        return NativeBridge.invokeNativeModule("Database", "query", [name, sql, params ?? []]);
+      }
+    };
+    await callback(ctx);
+    if (statements.length > 0) {
+      await NativeBridge.invokeNativeModule("Database", "executeTransaction", [name, statements]);
+    }
+  }
+  async function close() {
+    if (!opened) return;
+    await NativeBridge.invokeNativeModule("Database", "close", [name]);
+    opened = false;
+    isOpen.value = false;
+  }
+  onUnmounted12(() => {
+    if (opened) {
+      NativeBridge.invokeNativeModule("Database", "close", [name]).catch(() => {
+      });
+      opened = false;
+      isOpen.value = false;
+    }
+  });
+  return { execute, query, transaction, close, isOpen };
+}
+
+// src/composables/usePerformance.ts
+import { ref as ref17, onUnmounted as onUnmounted13 } from "@vue/runtime-core";
+function usePerformance() {
+  const isProfiling = ref17(false);
+  const fps = ref17(0);
+  const memoryMB = ref17(0);
+  const bridgeOps = ref17(0);
+  let unsubscribe = null;
+  function handleMetrics(payload) {
+    fps.value = payload.fps ?? 0;
+    memoryMB.value = payload.memoryMB ?? 0;
+    bridgeOps.value = payload.bridgeOps ?? 0;
+  }
+  async function startProfiling() {
+    if (isProfiling.value) return;
+    unsubscribe = NativeBridge.onGlobalEvent("perf:metrics", handleMetrics);
+    await NativeBridge.invokeNativeModule("Performance", "startProfiling", []);
+    isProfiling.value = true;
+  }
+  async function stopProfiling() {
+    if (!isProfiling.value) return;
+    await NativeBridge.invokeNativeModule("Performance", "stopProfiling", []);
+    isProfiling.value = false;
+    if (unsubscribe) {
+      unsubscribe();
+      unsubscribe = null;
+    }
+  }
+  async function getMetrics() {
+    return NativeBridge.invokeNativeModule("Performance", "getMetrics", []);
+  }
+  onUnmounted13(() => {
+    if (isProfiling.value) {
+      NativeBridge.invokeNativeModule("Performance", "stopProfiling", []).catch(() => {
+      });
+      isProfiling.value = false;
+    }
+    if (unsubscribe) {
+      unsubscribe();
+      unsubscribe = null;
+    }
+  });
+  return {
+    startProfiling,
+    stopProfiling,
+    getMetrics,
+    isProfiling,
+    fps,
+    memoryMB,
+    bridgeOps
+  };
+}
+
+// src/composables/useSharedElementTransition.ts
+import { ref as ref18, onUnmounted as onUnmounted14 } from "@vue/runtime-core";
+var sharedElementRegistry = /* @__PURE__ */ new Map();
+function useSharedElementTransition(elementId) {
+  const viewId = ref18(null);
+  function register(nativeViewId) {
+    viewId.value = nativeViewId;
+    sharedElementRegistry.set(elementId, nativeViewId);
+  }
+  function unregister() {
+    viewId.value = null;
+    sharedElementRegistry.delete(elementId);
+  }
+  onUnmounted14(() => {
+    unregister();
+  });
+  return {
+    id: elementId,
+    viewId,
+    register,
+    unregister
+  };
+}
+async function measureViewFrame(nativeViewId) {
+  return NativeBridge.invokeNativeModule("Animation", "measureView", [nativeViewId]);
+}
+function getSharedElementViewId(elementId) {
+  return sharedElementRegistry.get(elementId);
+}
+function getRegisteredSharedElements() {
+  return Array.from(sharedElementRegistry.keys());
+}
+function clearSharedElementRegistry() {
+  sharedElementRegistry.clear();
+}
+
+// src/composables/useIAP.ts
+import { ref as ref19, onUnmounted as onUnmounted15 } from "@vue/runtime-core";
+function useIAP() {
+  const products = ref19([]);
+  const isReady = ref19(false);
+  const error = ref19(null);
+  const cleanups = [];
+  const unsubscribe = NativeBridge.onGlobalEvent("iap:transactionUpdate", (payload) => {
+    if (payload.state === "failed" && payload.error) {
+      error.value = payload.error;
+    }
+  });
+  cleanups.push(unsubscribe);
+  NativeBridge.invokeNativeModule("IAP", "initialize").then(() => {
+    isReady.value = true;
+  }).catch((err) => {
+    error.value = String(err);
+  });
+  async function getProducts(skus) {
+    error.value = null;
+    try {
+      const result = await NativeBridge.invokeNativeModule("IAP", "getProducts", [skus]);
+      const productList = result;
+      products.value = productList;
+      return productList;
+    } catch (err) {
+      error.value = String(err);
+      return [];
+    }
+  }
+  async function purchase(sku) {
+    error.value = null;
+    try {
+      return await NativeBridge.invokeNativeModule("IAP", "purchase", [sku]);
+    } catch (err) {
+      error.value = String(err);
+      return null;
+    }
+  }
+  async function restorePurchases() {
+    error.value = null;
+    try {
+      return await NativeBridge.invokeNativeModule("IAP", "restorePurchases");
+    } catch (err) {
+      error.value = String(err);
+      return [];
+    }
+  }
+  async function getActiveSubscriptions() {
+    error.value = null;
+    try {
+      return await NativeBridge.invokeNativeModule("IAP", "getActiveSubscriptions");
+    } catch (err) {
+      error.value = String(err);
+      return [];
+    }
+  }
+  function onTransactionUpdate(callback) {
+    const unsub = NativeBridge.onGlobalEvent("iap:transactionUpdate", callback);
+    cleanups.push(unsub);
+    return unsub;
+  }
+  onUnmounted15(() => {
+    cleanups.forEach((fn) => fn());
+    cleanups.length = 0;
+  });
+  return {
+    products,
+    isReady,
+    error,
+    getProducts,
+    purchase,
+    restorePurchases,
+    getActiveSubscriptions,
+    onTransactionUpdate
+  };
+}
+
+// src/composables/useAppleSignIn.ts
+import { ref as ref20, onUnmounted as onUnmounted16 } from "@vue/runtime-core";
+function useAppleSignIn() {
+  const user = ref20(null);
+  const isAuthenticated = ref20(false);
+  const error = ref20(null);
+  const cleanups = [];
+  const unsubscribe = NativeBridge.onGlobalEvent("auth:appleCredentialRevoked", () => {
+    user.value = null;
+    isAuthenticated.value = false;
+  });
+  cleanups.push(unsubscribe);
+  NativeBridge.invokeNativeModule("SocialAuth", "getCurrentUser", ["apple"]).then((result) => {
+    if (result && result.userId) {
+      user.value = { ...result, provider: "apple" };
+      isAuthenticated.value = true;
+    }
+  }).catch(() => {
+  });
+  async function signIn() {
+    error.value = null;
+    try {
+      const result = await NativeBridge.invokeNativeModule("SocialAuth", "signInWithApple");
+      const socialUser = { ...result, provider: "apple" };
+      user.value = socialUser;
+      isAuthenticated.value = true;
+      return { success: true, user: socialUser };
+    } catch (err) {
+      const message = String(err);
+      error.value = message;
+      return { success: false, error: message };
+    }
+  }
+  async function signOut() {
+    error.value = null;
+    try {
+      await NativeBridge.invokeNativeModule("SocialAuth", "signOut", ["apple"]);
+      user.value = null;
+      isAuthenticated.value = false;
+    } catch (err) {
+      error.value = String(err);
+    }
+  }
+  onUnmounted16(() => {
+    cleanups.forEach((fn) => fn());
+    cleanups.length = 0;
+  });
+  return { signIn, signOut, user, isAuthenticated, error };
+}
+
+// src/composables/useGoogleSignIn.ts
+import { ref as ref21, onUnmounted as onUnmounted17 } from "@vue/runtime-core";
+function useGoogleSignIn(clientId) {
+  const user = ref21(null);
+  const isAuthenticated = ref21(false);
+  const error = ref21(null);
+  const cleanups = [];
+  NativeBridge.invokeNativeModule("SocialAuth", "getCurrentUser", ["google"]).then((result) => {
+    if (result && result.userId) {
+      user.value = { ...result, provider: "google" };
+      isAuthenticated.value = true;
+    }
+  }).catch(() => {
+  });
+  async function signIn() {
+    error.value = null;
+    try {
+      const result = await NativeBridge.invokeNativeModule("SocialAuth", "signInWithGoogle", [clientId]);
+      const socialUser = { ...result, provider: "google" };
+      user.value = socialUser;
+      isAuthenticated.value = true;
+      return { success: true, user: socialUser };
+    } catch (err) {
+      const message = String(err);
+      error.value = message;
+      return { success: false, error: message };
+    }
+  }
+  async function signOut() {
+    error.value = null;
+    try {
+      await NativeBridge.invokeNativeModule("SocialAuth", "signOut", ["google"]);
+      user.value = null;
+      isAuthenticated.value = false;
+    } catch (err) {
+      error.value = String(err);
+    }
+  }
+  onUnmounted17(() => {
+    cleanups.forEach((fn) => fn());
+    cleanups.length = 0;
+  });
+  return { signIn, signOut, user, isAuthenticated, error };
+}
+
+// src/composables/useBackgroundTask.ts
+import { ref as ref22, onUnmounted as onUnmounted18 } from "@vue/runtime-core";
+function useBackgroundTask() {
+  const taskHandlers = /* @__PURE__ */ new Map();
+  const defaultHandler = ref22(null);
+  const unsubscribe = NativeBridge.onGlobalEvent("background:taskExecute", (payload) => {
+    const handler = taskHandlers.get(payload.taskId) || defaultHandler.value;
+    if (handler) {
+      handler(payload.taskId);
+    }
+  });
+  onUnmounted18(unsubscribe);
+  function registerTask(taskId) {
+    return NativeBridge.invokeNativeModule("BackgroundTask", "registerTask", [taskId]).then(() => void 0);
+  }
+  function scheduleTask(taskId, options = {}) {
+    const type = options.type ?? "refresh";
+    return NativeBridge.invokeNativeModule("BackgroundTask", "scheduleTask", [taskId, type, {
+      earliestBeginDate: options.earliestBeginDate,
+      requiresNetworkConnectivity: options.requiresNetworkConnectivity,
+      requiresExternalPower: options.requiresExternalPower,
+      interval: options.interval
+    }]).then(() => void 0);
+  }
+  function cancelTask(taskId) {
+    return NativeBridge.invokeNativeModule("BackgroundTask", "cancelTask", [taskId]).then(() => void 0);
+  }
+  function cancelAllTasks() {
+    return NativeBridge.invokeNativeModule("BackgroundTask", "cancelAllTasks", []).then(() => void 0);
+  }
+  function completeTask(taskId, success = true) {
+    return NativeBridge.invokeNativeModule("BackgroundTask", "completeTask", [taskId, success]).then(() => void 0);
+  }
+  function onTaskExecute(handler, taskId) {
+    if (taskId) {
+      taskHandlers.set(taskId, handler);
+      return () => {
+        taskHandlers.delete(taskId);
+      };
+    } else {
+      defaultHandler.value = handler;
+      return () => {
+        defaultHandler.value = null;
+      };
+    }
+  }
+  return { registerTask, scheduleTask, cancelTask, cancelAllTasks, completeTask, onTaskExecute };
+}
+
+// src/composables/useOTAUpdate.ts
+import { ref as ref23, onUnmounted as onUnmounted19 } from "@vue/runtime-core";
+function useOTAUpdate(serverUrl) {
+  const currentVersion = ref23("embedded");
+  const availableVersion = ref23(null);
+  const downloadProgress = ref23(0);
+  const isChecking = ref23(false);
+  const isDownloading = ref23(false);
+  const status = ref23("idle");
+  const error = ref23(null);
+  let lastUpdateInfo = null;
+  const unsubscribe = NativeBridge.onGlobalEvent("ota:downloadProgress", (payload) => {
+    downloadProgress.value = payload.progress;
+  });
+  onUnmounted19(unsubscribe);
+  NativeBridge.invokeNativeModule("OTA", "getCurrentVersion", []).then((info) => {
+    currentVersion.value = info.version;
+  }).catch(() => {
+  });
+  async function checkForUpdate() {
+    isChecking.value = true;
+    status.value = "checking";
+    error.value = null;
+    try {
+      const info = await NativeBridge.invokeNativeModule("OTA", "checkForUpdate", [serverUrl]);
+      lastUpdateInfo = info;
+      if (info.updateAvailable) {
+        availableVersion.value = info.version;
+      } else {
+        availableVersion.value = null;
+      }
+      status.value = info.updateAvailable ? "idle" : "idle";
+      return info;
+    } catch (err) {
+      error.value = err?.message || String(err);
+      status.value = "error";
+      throw err;
+    } finally {
+      isChecking.value = false;
+    }
+  }
+  async function downloadUpdate(url, hash) {
+    const downloadUrl = url || lastUpdateInfo?.downloadUrl;
+    const expectedHash = hash || lastUpdateInfo?.hash;
+    if (!downloadUrl) {
+      const msg = "No download URL. Call checkForUpdate() first or provide a URL.";
+      error.value = msg;
+      status.value = "error";
+      throw new Error(msg);
+    }
+    isDownloading.value = true;
+    downloadProgress.value = 0;
+    status.value = "downloading";
+    error.value = null;
+    try {
+      await NativeBridge.invokeNativeModule("OTA", "downloadUpdate", [downloadUrl, expectedHash || ""]);
+      status.value = "ready";
+    } catch (err) {
+      error.value = err?.message || String(err);
+      status.value = "error";
+      throw err;
+    } finally {
+      isDownloading.value = false;
+    }
+  }
+  async function applyUpdate() {
+    error.value = null;
+    try {
+      await NativeBridge.invokeNativeModule("OTA", "applyUpdate", []);
+      const info = await NativeBridge.invokeNativeModule("OTA", "getCurrentVersion", []);
+      currentVersion.value = info.version;
+      availableVersion.value = null;
+      status.value = "idle";
+    } catch (err) {
+      error.value = err?.message || String(err);
+      status.value = "error";
+      throw err;
+    }
+  }
+  async function rollback() {
+    error.value = null;
+    try {
+      await NativeBridge.invokeNativeModule("OTA", "rollback", []);
+      const info = await NativeBridge.invokeNativeModule("OTA", "getCurrentVersion", []);
+      currentVersion.value = info.version;
+      status.value = "idle";
+    } catch (err) {
+      error.value = err?.message || String(err);
+      status.value = "error";
+      throw err;
+    }
+  }
+  async function getCurrentVersion() {
+    const info = await NativeBridge.invokeNativeModule("OTA", "getCurrentVersion", []);
+    currentVersion.value = info.version;
+    return info;
+  }
+  return {
+    checkForUpdate,
+    downloadUpdate,
+    applyUpdate,
+    rollback,
+    getCurrentVersion,
+    currentVersion,
+    availableVersion,
+    downloadProgress,
+    isChecking,
+    isDownloading,
+    status,
+    error
+  };
+}
+
+// src/composables/useBluetooth.ts
+import { ref as ref24, onUnmounted as onUnmounted20 } from "@vue/runtime-core";
+function useBluetooth() {
+  const devices = ref24([]);
+  const connectedDevice = ref24(null);
+  const isScanning = ref24(false);
+  const isAvailable = ref24(false);
+  const error = ref24(null);
+  const cleanups = [];
+  NativeBridge.invokeNativeModule("Bluetooth", "getState").then((state) => {
+    isAvailable.value = state === "poweredOn";
+  }).catch(() => {
+    isAvailable.value = false;
+  });
+  const unsubState = NativeBridge.onGlobalEvent("ble:stateChanged", (payload) => {
+    isAvailable.value = payload.state === "poweredOn";
+  });
+  cleanups.push(unsubState);
+  const unsubFound = NativeBridge.onGlobalEvent("ble:deviceFound", (payload) => {
+    const existing = devices.value.findIndex((d) => d.id === payload.id);
+    if (existing >= 0) {
+      devices.value[existing] = payload;
+    } else {
+      devices.value = [...devices.value, payload];
+    }
+  });
+  cleanups.push(unsubFound);
+  const unsubConnected = NativeBridge.onGlobalEvent("ble:connected", (payload) => {
+    connectedDevice.value = payload;
+  });
+  cleanups.push(unsubConnected);
+  const unsubDisconnected = NativeBridge.onGlobalEvent("ble:disconnected", () => {
+    connectedDevice.value = null;
+  });
+  cleanups.push(unsubDisconnected);
+  const unsubError = NativeBridge.onGlobalEvent("ble:error", (payload) => {
+    error.value = payload.message;
+  });
+  cleanups.push(unsubError);
+  async function scan(serviceUUIDs) {
+    devices.value = [];
+    isScanning.value = true;
+    error.value = null;
+    try {
+      await NativeBridge.invokeNativeModule("Bluetooth", "startScan", [serviceUUIDs]);
+    } catch (e) {
+      error.value = e?.message || String(e);
+      isScanning.value = false;
+    }
+  }
+  async function stopScan() {
+    await NativeBridge.invokeNativeModule("Bluetooth", "stopScan");
+    isScanning.value = false;
+  }
+  async function connect(deviceId) {
+    error.value = null;
+    const result = await NativeBridge.invokeNativeModule("Bluetooth", "connect", [deviceId]);
+    return result;
+  }
+  async function disconnect(deviceId) {
+    await NativeBridge.invokeNativeModule("Bluetooth", "disconnect", [deviceId]);
+    connectedDevice.value = null;
+  }
+  async function read(deviceId, serviceUUID, charUUID) {
+    return NativeBridge.invokeNativeModule("Bluetooth", "readCharacteristic", [deviceId, serviceUUID, charUUID]);
+  }
+  async function write(deviceId, serviceUUID, charUUID, data) {
+    return NativeBridge.invokeNativeModule("Bluetooth", "writeCharacteristic", [deviceId, serviceUUID, charUUID, data]);
+  }
+  async function subscribe(deviceId, serviceUUID, charUUID, callback) {
+    await NativeBridge.invokeNativeModule("Bluetooth", "subscribeToCharacteristic", [deviceId, serviceUUID, charUUID]);
+    const unsubscribe = NativeBridge.onGlobalEvent("ble:characteristicChanged", (payload) => {
+      if (payload.deviceId === deviceId && payload.serviceUUID === serviceUUID && payload.characteristicUUID === charUUID) {
+        callback(payload);
+      }
+    });
+    cleanups.push(unsubscribe);
+    return async () => {
+      unsubscribe();
+      await NativeBridge.invokeNativeModule("Bluetooth", "unsubscribeFromCharacteristic", [
+        deviceId,
+        serviceUUID,
+        charUUID
+      ]);
+    };
+  }
+  onUnmounted20(() => {
+    if (isScanning.value) {
+      NativeBridge.invokeNativeModule("Bluetooth", "stopScan").catch(() => {
+      });
+    }
+    cleanups.forEach((fn) => fn());
+    cleanups.length = 0;
+  });
+  return {
+    scan,
+    stopScan,
+    connect,
+    disconnect,
+    read,
+    write,
+    subscribe,
+    devices,
+    connectedDevice,
+    isScanning,
+    isAvailable,
+    error
+  };
+}
+
+// src/composables/useCalendar.ts
+import { ref as ref25 } from "@vue/runtime-core";
+function useCalendar() {
+  const hasAccess = ref25(false);
+  const error = ref25(null);
+  async function requestAccess() {
+    try {
+      const result = await NativeBridge.invokeNativeModule("Calendar", "requestAccess");
+      hasAccess.value = result.granted;
+      return result.granted;
+    } catch (e) {
+      error.value = e?.message || String(e);
+      return false;
+    }
+  }
+  async function getEvents(startDate, endDate) {
+    return NativeBridge.invokeNativeModule("Calendar", "getEvents", [startDate, endDate]);
+  }
+  async function createEvent(options) {
+    return NativeBridge.invokeNativeModule("Calendar", "createEvent", [
+      options.title,
+      options.startDate,
+      options.endDate,
+      options.notes,
+      options.calendarId
+    ]);
+  }
+  async function deleteEvent(eventId) {
+    return NativeBridge.invokeNativeModule("Calendar", "deleteEvent", [eventId]);
+  }
+  async function getCalendars() {
+    return NativeBridge.invokeNativeModule("Calendar", "getCalendars");
+  }
+  return { requestAccess, getEvents, createEvent, deleteEvent, getCalendars, hasAccess, error };
+}
+
+// src/composables/useContacts.ts
+import { ref as ref26 } from "@vue/runtime-core";
+function useContacts() {
+  const hasAccess = ref26(false);
+  const error = ref26(null);
+  async function requestAccess() {
+    try {
+      const result = await NativeBridge.invokeNativeModule("Contacts", "requestAccess");
+      hasAccess.value = result.granted;
+      return result.granted;
+    } catch (e) {
+      error.value = e?.message || String(e);
+      return false;
+    }
+  }
+  async function getContacts(query) {
+    return NativeBridge.invokeNativeModule("Contacts", "getContacts", [query]);
+  }
+  async function getContact(id) {
+    return NativeBridge.invokeNativeModule("Contacts", "getContact", [id]);
+  }
+  async function createContact(data) {
+    return NativeBridge.invokeNativeModule("Contacts", "createContact", [data]);
+  }
+  async function deleteContact(id) {
+    return NativeBridge.invokeNativeModule("Contacts", "deleteContact", [id]);
+  }
+  return { requestAccess, getContacts, getContact, createContact, deleteContact, hasAccess, error };
+}
+
 // src/index.ts
 function createApp(rootComponent, rootProps) {
   const app = baseCreateApp(rootComponent, rootProps);
@@ -1688,6 +3242,15 @@ function createApp(rootComponent, rootProps) {
   app.component("VPicker", VPicker);
   app.component("VSegmentedControl", VSegmentedControl);
   app.component("VActionSheet", VActionSheet);
+  app.component("VRefreshControl", VRefreshControl);
+  app.component("VPressable", VPressable);
+  app.component("VSectionList", VSectionList);
+  app.component("VCheckbox", VCheckbox);
+  app.component("VRadio", VRadio);
+  app.component("VDropdown", VDropdown);
+  app.component("VVideo", VVideo);
+  app.component("ErrorBoundary", ErrorBoundary);
+  app.component("VErrorBoundary", ErrorBoundary);
   app.directive("show", vShow);
   app.config.errorHandler = (err, instance, info) => {
     const error = err instanceof Error ? err : new Error(String(err));
@@ -1705,7 +3268,7 @@ function createApp(rootComponent, rootProps) {
     }
   };
   if (typeof __DEV__ !== "undefined" && __DEV__) {
-    app.config.warnHandler = (msg, instance, trace) => {
+    app.config.warnHandler = (msg, instance, _trace) => {
       const componentName = instance?.$options?.name || instance?.$.type?.name || "Anonymous";
       console.warn(`[VueNative] Warning in ${componentName}: ${msg}`);
     };
@@ -1722,52 +3285,84 @@ function createApp(rootComponent, rootProps) {
   return app;
 }
 export {
+  ErrorBoundary,
   NativeBridge,
   VActionSheet,
   VActivityIndicator,
   VAlertDialog,
   VButton,
+  VCheckbox,
+  VDropdown,
   VImage,
   VInput,
   VKeyboardAvoiding,
   VList,
   VModal,
   VPicker,
+  VPressable,
   VProgressBar,
+  VRadio,
+  VRefreshControl,
   VSafeArea,
   VScrollView,
+  VSectionList,
   VSegmentedControl,
   VSlider,
   VStatusBar,
   VSwitch,
   VText,
+  VVideo,
   VView,
   VWebView,
+  clearSharedElementRegistry,
   createApp,
   createCommentNode,
   createNativeNode,
   createStyleSheet,
   createTextNode,
+  getRegisteredSharedElements,
+  getSharedElementViewId,
+  measureViewFrame,
   render,
   resetNodeId,
+  useAccelerometer,
   useAnimation,
   useAppState,
+  useAppleSignIn,
   useAsyncStorage,
+  useAudio,
   useBackHandler,
+  useBackgroundTask,
   useBiometry,
+  useBluetooth,
+  useCalendar,
   useCamera,
   useClipboard,
   useColorScheme,
+  useContacts,
+  useDatabase,
   useDeviceInfo,
+  useDimensions,
+  useFileSystem,
   useGeolocation,
+  useGoogleSignIn,
+  useGyroscope,
   useHaptics,
   useHttp,
+  useI18n,
+  useIAP,
   useKeyboard,
   useLinking,
   useNetwork,
   useNotifications,
+  useOTAUpdate,
+  usePerformance,
   usePermissions,
+  usePlatform,
+  useSecureStorage,
   useShare,
+  useSharedElementTransition,
+  useWebSocket,
   vShow,
   validStyleProperties
 };