@thelacanians/vue-native-runtime 0.4.15 → 0.6.0

package/dist/index.js

@@ -65,6 +65,7 @@ function createCommentNode(_text) {
 }
 
 // src/bridge.ts
+var bridgeGlobals = globalThis;
 var _NativeBridgeImpl = class _NativeBridgeImpl {
   constructor() {
     /** Pending operations waiting to be flushed to native */
@@ -106,7 +107,7 @@ var _NativeBridgeImpl = class _NativeBridgeImpl {
     const ops = this.pendingOps;
     this.pendingOps = [];
     const json = JSON.stringify(ops);
-    const flushFn = globalThis.__VN_flushOperations;
+    const flushFn = bridgeGlobals.__VN_flushOperations;
     if (typeof flushFn === "function") {
       try {
         flushFn(json);
@@ -283,6 +284,8 @@ var _NativeBridgeImpl = class _NativeBridgeImpl {
    * a crash or unregistered module), the Promise rejects with a clear error instead
    * of hanging forever.
    */
+  // Native module results are intentionally dynamic; callers often narrow them
+  // ad hoc based on the module contract rather than a shared generated type.
   invokeNativeModule(moduleName, methodName, args = [], timeoutMs = 3e4) {
     return new Promise((resolve, reject) => {
       const callbackId = this.nextCallbackId;
@@ -310,7 +313,11 @@ var _NativeBridgeImpl = class _NativeBridgeImpl {
           }
         }
       }
-      this.pendingCallbacks.set(callbackId, { resolve, reject, timeoutId });
+      this.pendingCallbacks.set(callbackId, {
+        resolve: (result) => resolve(result),
+        reject: (error) => reject(error),
+        timeoutId
+      });
       this.enqueue("invokeNativeModule", [moduleName, methodName, args, callbackId]);
     });
   }
@@ -342,6 +349,28 @@ var _NativeBridgeImpl = class _NativeBridgeImpl {
       pending.resolve(result);
     }
   }
+  /**
+   * Create teleport markers in native.
+   * Used for Teleport component to render content outside parent hierarchy.
+   */
+  createTeleport(parentId, startId, endId) {
+    this.enqueue("createTeleport", [parentId, startId, endId]);
+  }
+  /**
+   * Remove teleport markers from native.
+   * Cleans up teleport containers and markers.
+   */
+  removeTeleport(parentId, startId, endId) {
+    this.enqueue("removeTeleport", [parentId, startId, endId]);
+  }
+  /**
+   * Move a node to a teleport target.
+   * @param target - Teleport target name ('modal', 'root', etc.)
+   * @param nodeId - Node ID to teleport
+   */
+  teleportTo(target, nodeId) {
+    this.enqueue("teleportTo", [target, nodeId]);
+  }
   // ---------------------------------------------------------------------------
   // Global push events
   // ---------------------------------------------------------------------------
@@ -362,7 +391,7 @@ var _NativeBridgeImpl = class _NativeBridgeImpl {
    * Called from Swift via globalThis.__VN_handleGlobalEvent when a push event fires.
    */
   handleGlobalEvent(eventName, payloadJSON) {
-    let payload;
+    let payload = {};
     try {
       payload = JSON.parse(payloadJSON);
     } catch {
@@ -370,9 +399,9 @@ var _NativeBridgeImpl = class _NativeBridgeImpl {
     }
     const handlers = this.globalEventHandlers.get(eventName);
     if (handlers) {
-      handlers.forEach((h29) => {
+      handlers.forEach((h33) => {
         try {
-          h29(payload);
+          h33(payload);
         } catch (err) {
           console.error(`[VueNative] Error in global event handler "${eventName}":`, err);
         }
@@ -402,15 +431,14 @@ _NativeBridgeImpl.MAX_CALLBACK_ID = 2147483647;
 /** Maximum number of pending callbacks before evicting the oldest */
 _NativeBridgeImpl.MAX_PENDING_CALLBACKS = 1e3;
 var NativeBridgeImpl = _NativeBridgeImpl;
-if (typeof globalThis.__DEV__ === "undefined") {
-  ;
-  globalThis.__DEV__ = true;
+if (typeof bridgeGlobals.__DEV__ === "undefined") {
+  bridgeGlobals.__DEV__ = true;
 }
 var NativeBridge = new NativeBridgeImpl();
-globalThis.__VN_handleEvent = NativeBridge.handleNativeEvent.bind(NativeBridge);
-globalThis.__VN_resolveCallback = NativeBridge.resolveCallback.bind(NativeBridge);
-globalThis.__VN_handleGlobalEvent = NativeBridge.handleGlobalEvent.bind(NativeBridge);
-globalThis.__VN_teardown = () => {
+bridgeGlobals.__VN_handleEvent = NativeBridge.handleNativeEvent.bind(NativeBridge);
+bridgeGlobals.__VN_resolveCallback = NativeBridge.resolveCallback.bind(NativeBridge);
+bridgeGlobals.__VN_handleGlobalEvent = NativeBridge.handleGlobalEvent.bind(NativeBridge);
+bridgeGlobals.__VN_teardown = () => {
   NativeBridge.reset();
   resetNodeId();
 };
@@ -419,10 +447,13 @@ globalThis.__VN_teardown = () => {
 function toEventName(key) {
   return key.slice(2).toLowerCase();
 }
+function isEventHandler(value) {
+  return typeof value === "function";
+}
 function patchStyle(nodeId, prevStyle, nextStyle) {
   try {
-    const prev = prevStyle || {};
-    const next = nextStyle || {};
+    const prev = typeof prevStyle === "object" && prevStyle !== null ? prevStyle : {};
+    const next = typeof nextStyle === "object" && nextStyle !== null ? nextStyle : {};
     const changes = {};
     let hasChanges = false;
     for (const key in next) {
@@ -500,7 +531,7 @@ var nodeOps = {
         if (prevValue) {
           NativeBridge.removeEventListener(el.id, eventName);
         }
-        if (nextValue) {
+        if (isEventHandler(nextValue)) {
           NativeBridge.addEventListener(el.id, eventName, nextValue);
         }
         return;
@@ -594,6 +625,25 @@ var nodeOps = {
     const idx = parent.children.indexOf(node);
     if (idx === -1 || idx >= parent.children.length - 1) return null;
     return parent.children[idx + 1];
+  },
+  /**
+   * Insert static content (for Teleport).
+   * Creates teleport boundary markers.
+   */
+  insertStaticContent(content, parent, anchor, _namespace, _start, _end) {
+    const startNode = createNativeNode("__TELEPORT_START__");
+    const endNode = createNativeNode("__TELEPORT_END__");
+    if (anchor) {
+      const idx = parent.children.indexOf(anchor);
+      if (idx !== -1) {
+        parent.children.splice(idx, 0, startNode);
+        parent.children.splice(idx + 1, 0, endNode);
+      }
+    } else {
+      parent.children.push(startNode, endNode);
+    }
+    NativeBridge.createTeleport(parent.id, startNode.id, endNode.id);
+    return [startNode, endNode];
   }
 };
 function findNextNonComment(parent, anchor) {
@@ -682,6 +732,16 @@ var VButton = defineComponent3({
 
 // src/components/VInput.ts
 import { defineComponent as defineComponent4, h as h4, ref } from "@vue/runtime-core";
+function extractText(payload) {
+  if (typeof payload === "string") {
+    return payload;
+  }
+  if (typeof payload === "object" && payload !== null && "text" in payload) {
+    const text = payload.text;
+    return typeof text === "string" ? text : "";
+  }
+  return "";
+}
 var VInput = defineComponent4({
   name: "VInput",
   props: {
@@ -729,13 +789,11 @@ var VInput = defineComponent4({
     };
     const onCompositionend = (payload) => {
       isComposing.value = false;
-      const text = typeof payload === "string" ? payload : payload?.text ?? "";
-      emit("update:modelValue", text);
+      emit("update:modelValue", extractText(payload));
     };
     const onChangetext = (payload) => {
       if (isComposing.value) return;
-      const text = typeof payload === "string" ? payload : payload?.text ?? "";
-      emit("update:modelValue", text);
+      emit("update:modelValue", extractText(payload));
     };
     const onFocus = (payload) => {
       emit("focus", payload);
@@ -795,7 +853,8 @@ var VSwitch = defineComponent5({
   emits: ["update:modelValue", "change"],
   setup(props, { emit }) {
     const onChange = (payload) => {
-      const value = typeof payload === "boolean" ? payload : !!(payload?.value ?? payload);
+      const nextValue = typeof payload === "object" && payload !== null && "value" in payload ? payload.value : payload;
+      const value = typeof nextValue === "boolean" ? nextValue : Boolean(nextValue);
       emit("update:modelValue", value);
       emit("change", value);
     };
@@ -959,9 +1018,9 @@ var VImage = defineComponent8({
       loading.value = false;
       emit("load");
     };
-    const onError = (e) => {
+    const onError = (event) => {
       loading.value = false;
-      emit("error", e);
+      emit("error", event);
     };
     expose({ loading });
     return () => h8(
@@ -1035,6 +1094,20 @@ var VSlider = defineComponent11({
 
 // src/components/VList.ts
 import { defineComponent as defineComponent12, h as h12 } from "@vue/runtime-core";
+
+// src/composables/usePlatform.ts
+function usePlatform() {
+  const platform = typeof __PLATFORM__ !== "undefined" ? __PLATFORM__ : "ios";
+  const isIOS = platform === "ios";
+  const isAndroid = platform === "android";
+  const isMacOS = platform === "macos";
+  const isApple = isIOS || isMacOS;
+  const isDesktop = isMacOS;
+  const isMobile = isIOS || isAndroid;
+  return { platform, isIOS, isAndroid, isMacOS, isApple, isDesktop, isMobile };
+}
+
+// src/components/VList.ts
 var VList = defineComponent12({
   name: "VList",
   props: {
@@ -1075,13 +1148,27 @@ var VList = defineComponent12({
   },
   emits: ["scroll", "endReached"],
   setup(props, { slots, emit }) {
+    const { isAndroid } = usePlatform();
     let lastScrollEmit = 0;
+    let endReachedFired = false;
     const onScroll = (e) => {
       const now = Date.now();
       if (now - lastScrollEmit >= 16) {
         lastScrollEmit = now;
         emit("scroll", e);
       }
+      if (props.horizontal && !isAndroid) {
+        const contentWidth = e.contentWidth ?? 0;
+        const layoutWidth = e.layoutWidth ?? 0;
+        const distanceFromEnd = contentWidth - layoutWidth - (e.x ?? 0);
+        const threshold = layoutWidth * 0.2;
+        if (contentWidth > layoutWidth && distanceFromEnd < threshold && !endReachedFired) {
+          endReachedFired = true;
+          emit("endReached");
+        } else if (distanceFromEnd >= threshold) {
+          endReachedFired = false;
+        }
+      }
     };
     return () => {
       const items = props.data ?? [];
@@ -1127,6 +1214,31 @@ var VList = defineComponent12({
           h12("VView", { key: "__footer__", style: { flexShrink: 0 } }, slots.footer())
         );
       }
+      if (props.horizontal && !isAndroid) {
+        return h12(
+          "VScrollView",
+          {
+            style: props.style,
+            horizontal: true,
+            showsVerticalScrollIndicator: false,
+            showsHorizontalScrollIndicator: props.showsScrollIndicator,
+            bounces: props.bounces,
+            onScroll
+          },
+          [
+            h12(
+              "VView",
+              {
+                style: {
+                  flexDirection: "row",
+                  alignItems: "stretch"
+                }
+              },
+              children
+            )
+          ]
+        );
+      }
       return h12(
         "VList",
         {
@@ -1230,9 +1342,9 @@ var VAlertDialog = defineComponent14({
         title: props.title,
         message: props.message,
         buttons: resolvedButtons,
-        onConfirm: (e) => emit("confirm", e),
+        onConfirm: (event) => emit("confirm", event),
         onCancel: () => emit("cancel"),
-        onAction: (e) => emit("action", e)
+        onAction: (event) => emit("action", event)
       });
     };
   }
@@ -1281,9 +1393,9 @@ var VWebView = defineComponent16({
       source: sanitizedSource.value,
       style: props.style,
       javaScriptEnabled: props.javaScriptEnabled,
-      onLoad: (e) => emit("load", e),
-      onError: (e) => emit("error", e),
-      onMessage: (e) => emit("message", e)
+      onLoad: (event) => emit("load", event),
+      onError: (event) => emit("error", event),
+      onMessage: (event) => emit("message", event)
     });
   }
 });
@@ -1592,7 +1704,8 @@ var VCheckbox = defineComponent24({
   emits: ["update:modelValue", "change"],
   setup(props, { emit }) {
     const onChange = (payload) => {
-      const value = typeof payload === "boolean" ? payload : !!(payload?.value ?? payload);
+      const nextValue = typeof payload === "object" && payload !== null && "value" in payload ? payload.value : payload;
+      const value = typeof nextValue === "boolean" ? nextValue : Boolean(nextValue);
       emit("update:modelValue", value);
       emit("change", value);
     };
@@ -1612,6 +1725,10 @@ var VCheckbox = defineComponent24({
 
 // src/components/VRadio.ts
 import { defineComponent as defineComponent25, h as h25 } from "@vue/runtime-core";
+function extractRadioValue(payload) {
+  const nextValue = typeof payload === "object" && payload !== null && "value" in payload ? payload.value : payload;
+  return typeof nextValue === "string" ? nextValue : void 0;
+}
 var VRadio = defineComponent25({
   name: "VRadio",
   props: {
@@ -1634,7 +1751,7 @@ var VRadio = defineComponent25({
   emits: ["update:modelValue", "change"],
   setup(props, { emit }) {
     const onChange = (payload) => {
-      const value = payload?.value ?? payload;
+      const value = extractRadioValue(payload);
       emit("update:modelValue", value);
       emit("change", value);
     };
@@ -1652,6 +1769,10 @@ var VRadio = defineComponent25({
 
 // src/components/VDropdown.ts
 import { defineComponent as defineComponent26, h as h26 } from "@vue/runtime-core";
+function extractDropdownValue(payload) {
+  const nextValue = typeof payload === "object" && payload !== null && "value" in payload ? payload.value : payload;
+  return typeof nextValue === "string" ? nextValue : void 0;
+}
 var VDropdown = defineComponent26({
   name: "VDropdown",
   props: {
@@ -1678,7 +1799,7 @@ var VDropdown = defineComponent26({
   emits: ["update:modelValue", "change"],
   setup(props, { emit }) {
     const onChange = (payload) => {
-      const value = payload?.value ?? payload;
+      const value = extractDropdownValue(payload);
       emit("update:modelValue", value);
       emit("change", value);
     };
@@ -1720,18 +1841,28 @@ var VVideo = defineComponent27({
   setup(props, { emit }) {
     return () => h27("VVideo", {
       ...props,
-      onReady: (e) => emit("ready", e),
+      onReady: (event) => emit("ready", event),
       onPlay: () => emit("play"),
       onPause: () => emit("pause"),
       onEnd: () => emit("end"),
-      onError: (e) => emit("error", e),
-      onProgress: (e) => emit("progress", e)
+      onError: (event) => emit("error", event),
+      onProgress: (event) => emit("progress", event)
     });
   }
 });
 
 // src/components/VFlatList.ts
 import { defineComponent as defineComponent28, h as h28, ref as ref5, computed as computed2 } from "@vue/runtime-core";
+function getDefaultItemKey(item, index) {
+  if (typeof item === "object" && item !== null) {
+    const keyedItem = item;
+    return keyedItem.id ?? keyedItem.key ?? index;
+  }
+  return index;
+}
+function resolveFlexValue(style) {
+  return typeof style?.flex === "number" ? style.flex : 1;
+}
 var VFlatList = defineComponent28({
   name: "VFlatList",
   props: {
@@ -1751,7 +1882,7 @@ var VFlatList = defineComponent28({
     /** Extract a unique key from each item. Defaults to item.id, item.key, or index. */
     keyExtractor: {
       type: Function,
-      default: (item, index) => item?.id ?? item?.key ?? index
+      default: getDefaultItemKey
     },
     /** Fixed height for each item in points. Required for virtualization math. */
     itemHeight: {
@@ -1871,7 +2002,7 @@ var VFlatList = defineComponent28({
         return h28(
           "VScrollView",
           {
-            style: { ...props.style, flex: props.style?.flex ?? 1 },
+            style: { ...props.style, flex: resolveFlexValue(props.style) },
             showsVerticalScrollIndicator: props.showsScrollIndicator,
             bounces: props.bounces
           },
@@ -1892,7 +2023,7 @@ var VFlatList = defineComponent28({
       return h28(
         "VScrollView",
         {
-          style: { ...props.style, flex: props.style?.flex ?? 1 },
+          style: { ...props.style, flex: resolveFlexValue(props.style) },
           showsVerticalScrollIndicator: props.showsScrollIndicator,
           bounces: props.bounces,
           onScroll
@@ -1903,28 +2034,794 @@ var VFlatList = defineComponent28({
   }
 });
 
-// src/directives/vShow.ts
-var vShow = {
-  beforeMount(el, { value }) {
-    try {
-      NativeBridge.updateProp(el.id, "hidden", !value);
-    } catch (err) {
-      console.error("[VueNative] v-show beforeMount error:", err);
+// src/components/VTabBar.ts
+import { defineComponent as defineComponent29, h as h29, ref as ref6, watch as watch4 } from "@vue/runtime-core";
+var VTabBar = defineComponent29({
+  name: "VTabBar",
+  props: {
+    /** Array of tab configurations */
+    tabs: {
+      type: Array,
+      required: true
+    },
+    /** Currently active tab ID */
+    activeTab: {
+      type: String,
+      required: true
+    },
+    /** Position: 'top' | 'bottom' */
+    position: {
+      type: String,
+      default: "bottom"
     }
   },
-  updated(el, { value, oldValue }) {
-    if (value === oldValue) return;
-    try {
-      NativeBridge.updateProp(el.id, "hidden", !value);
-    } catch (err) {
-      console.error("[VueNative] v-show updated error:", err);
+  emits: ["change"],
+  setup(props, { emit }) {
+    const activeTab = ref6(props.activeTab);
+    watch4(() => props.activeTab, (newVal) => {
+      activeTab.value = newVal;
+    });
+    const switchTab = (tabId) => {
+      activeTab.value = tabId;
+      emit("change", tabId);
+    };
+    return () => h29(VView, {
+      style: {
+        position: "absolute",
+        [props.position]: 0,
+        left: 0,
+        right: 0,
+        backgroundColor: "#fff",
+        borderTopWidth: 1,
+        borderTopColor: "#e0e0e0",
+        flexDirection: "row",
+        height: 60
+      }
+    }, () => props.tabs.map((tab) => {
+      const isActive = activeTab.value === tab.id;
+      return h29(VPressable, {
+        key: tab.id,
+        style: {
+          flex: 1,
+          justifyContent: "center",
+          alignItems: "center"
+        },
+        onPress: () => switchTab(tab.id),
+        accessibilityLabel: tab.label,
+        accessibilityRole: "tab",
+        accessibilityState: { selected: isActive }
+      }, () => [
+        tab.icon ? h29(VText, { style: { fontSize: 24, marginBottom: 4 } }, () => tab.icon) : null,
+        h29(VText, {
+          style: {
+            fontSize: 12,
+            fontWeight: isActive ? "600" : "400",
+            color: isActive ? "#007AFF" : "#8E8E93"
+          }
+        }, () => tab.label),
+        tab.badge ? h29(VView, {
+          style: {
+            position: "absolute",
+            top: 8,
+            right: "25%",
+            backgroundColor: "#FF3B30",
+            borderRadius: 10,
+            minWidth: 20,
+            height: 20,
+            justifyContent: "center",
+            alignItems: "center"
+          }
+        }, () => h29(VText, {
+          style: {
+            color: "#fff",
+            fontSize: 12,
+            fontWeight: "600",
+            paddingHorizontal: 6
+          }
+        }, () => String(tab.badge))) : null
+      ]);
+    }));
+  }
+});
+
+// src/components/VDrawer.ts
+import { defineComponent as defineComponent30, h as h30, inject, provide, ref as ref7, watch as watch5 } from "@vue/runtime-core";
+var drawerContextKey = /* @__PURE__ */ Symbol("VDrawerContext");
+var VDrawer = defineComponent30({
+  name: "VDrawer",
+  props: {
+    /** Whether the drawer is open */
+    open: {
+      type: Boolean,
+      default: false
+    },
+    /** Drawer position: 'left' | 'right' */
+    position: {
+      type: String,
+      default: "left"
+    },
+    /** Drawer width */
+    width: {
+      type: Number,
+      default: 280
+    },
+    /** Close on item press */
+    closeOnPress: {
+      type: Boolean,
+      default: true
+    }
+  },
+  emits: ["update:open", "close"],
+  setup(props, { attrs, slots, emit }) {
+    const isOpen = ref7(props.open);
+    watch5(() => props.open, (value) => {
+      isOpen.value = value;
+    });
+    const closeDrawer = () => {
+      isOpen.value = false;
+      emit("update:open", false);
+      emit("close");
+    };
+    provide(drawerContextKey, {
+      close: closeDrawer,
+      shouldCloseOnPress: () => props.closeOnPress
+    });
+    return () => {
+      if (!isOpen.value && !slots.default) {
+        return null;
+      }
+      const overlayStyle = {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        right: 0,
+        bottom: 0,
+        backgroundColor: "rgba(0, 0, 0, 0.5)",
+        opacity: isOpen.value ? 1 : 0,
+        zIndex: 999
+      };
+      const drawerStyle = {
+        position: "absolute",
+        top: 0,
+        [props.position]: 0,
+        width: props.width,
+        height: "100%",
+        backgroundColor: "#fff",
+        transform: [
+          { translateX: isOpen.value ? 0 : props.position === "left" ? -props.width : props.width }
+        ],
+        zIndex: 1e3
+      };
+      const drawerProps = {
+        ...attrs,
+        style: {
+          ...drawerStyle,
+          ...attrs.style && typeof attrs.style === "object" && !Array.isArray(attrs.style) ? attrs.style : {}
+        }
+      };
+      const drawerChildren = [];
+      if (slots.header) {
+        drawerChildren.push(...slots.header());
+      }
+      if (slots.default) {
+        drawerChildren.push(...slots.default({ close: closeDrawer }) ?? []);
+      }
+      return [
+        // Overlay
+        isOpen.value ? h30(VPressable, {
+          style: overlayStyle,
+          onPress: closeDrawer,
+          accessibilityLabel: "Close menu"
+        }) : null,
+        // Drawer
+        h30(VView, drawerProps, () => drawerChildren)
+      ];
+    };
+  }
+});
+var VDrawerItem = defineComponent30({
+  name: "VDrawerItem",
+  props: {
+    /** Icon (emoji or icon name) */
+    icon: {
+      type: String,
+      default: ""
+    },
+    /** Label text */
+    label: {
+      type: String,
+      required: true
+    },
+    /** Badge count */
+    badge: {
+      type: [Number, String],
+      default: null
+    },
+    /** Disabled state */
+    disabled: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ["press"],
+  setup(props, { slots, emit }) {
+    const drawer = inject(drawerContextKey, null);
+    const handlePress = () => {
+      if (props.disabled) return;
+      emit("press");
+      if (drawer?.shouldCloseOnPress()) {
+        drawer.close();
+      }
+    };
+    return () => h30(VPressable, {
+      style: {
+        flexDirection: "row",
+        alignItems: "center",
+        padding: 16,
+        borderBottomWidth: 1,
+        borderBottomColor: "#f0f0f0",
+        opacity: props.disabled ? 0.5 : 1
+      },
+      onPress: handlePress,
+      disabled: props.disabled,
+      accessibilityLabel: props.label,
+      accessibilityRole: "menuitem",
+      accessibilityState: { disabled: props.disabled }
+    }, () => {
+      const children = [];
+      if (props.icon) {
+        children.push(
+          h30(VText, {
+            style: {
+              fontSize: 24,
+              marginRight: 16,
+              width: 32,
+              textAlign: "center"
+            }
+          }, () => props.icon)
+        );
+      }
+      children.push(
+        h30(VText, {
+          style: {
+            flex: 1,
+            fontSize: 16,
+            color: props.disabled ? "#999" : "#333"
+          }
+        }, () => props.label)
+      );
+      if (props.badge) {
+        children.push(
+          h30(VView, {
+            style: {
+              backgroundColor: "#007AFF",
+              borderRadius: 12,
+              minWidth: 24,
+              height: 24,
+              justifyContent: "center",
+              alignItems: "center",
+              paddingHorizontal: 8
+            }
+          }, () => h30(VText, {
+            style: {
+              color: "#fff",
+              fontSize: 12,
+              fontWeight: "600"
+            }
+          }, () => String(props.badge)))
+        );
+      }
+      if (slots.default) {
+        children.push(...slots.default() ?? []);
+      }
+      return children;
+    });
+  }
+});
+var VDrawerSection = defineComponent30({
+  name: "VDrawerSection",
+  props: {
+    /** Section title */
+    title: {
+      type: String,
+      default: ""
+    }
+  },
+  setup(props, { slots }) {
+    return () => h30(VView, {
+      style: {
+        paddingVertical: 8,
+        paddingHorizontal: 16,
+        backgroundColor: "#f9f9f9",
+        borderBottomWidth: 1,
+        borderBottomColor: "#e0e0e0"
+      }
+    }, () => {
+      const children = [];
+      if (props.title) {
+        children.push(
+          h30(VText, {
+            style: {
+              fontSize: 13,
+              fontWeight: "600",
+              color: "#666",
+              textTransform: "uppercase",
+              letterSpacing: 0.5
+            }
+          }, () => props.title)
+        );
+      }
+      if (slots.default) {
+        children.push(...slots.default() ?? []);
+      }
+      return children;
+    });
+  }
+});
+VDrawer.Item = VDrawerItem;
+VDrawer.Section = VDrawerSection;
+
+// src/components/VTransition.ts
+import { defineComponent as defineComponent31, h as h31, ref as ref8 } from "@vue/runtime-core";
+
+// src/composables/useAnimation.ts
+var Easing = {
+  linear: "linear",
+  ease: "ease",
+  easeIn: "easeIn",
+  easeOut: "easeOut",
+  easeInOut: "easeInOut"
+};
+function hasViewId(value) {
+  return typeof value === "object" && value !== null && "id" in value && typeof value.id === "number";
+}
+function isAnimationRef(target) {
+  return typeof target === "object" && target !== null && "value" in target;
+}
+function resolveViewId(target) {
+  if (typeof target === "number") return target;
+  if (isAnimationRef(target)) {
+    const val = target.value;
+    if (hasViewId(val)) return val.id;
+    throw new Error("[VueNative] Animation target ref has no .value.id \u2014 is the ref attached to a component?");
+  }
+  if (hasViewId(target)) return target.id;
+  throw new Error("[VueNative] Invalid animation target. Pass a number, template ref, or NativeNode.");
+}
+function useAnimation() {
+  function timing(target, toStyles, config = {}) {
+    return NativeBridge.invokeNativeModule("Animation", "timing", [resolveViewId(target), toStyles, config]);
+  }
+  function spring(target, toStyles, config = {}) {
+    return NativeBridge.invokeNativeModule("Animation", "spring", [resolveViewId(target), toStyles, config]);
+  }
+  function keyframe(target, steps, config = {}) {
+    return NativeBridge.invokeNativeModule("Animation", "keyframe", [resolveViewId(target), steps, config]);
+  }
+  function sequence(animations) {
+    return NativeBridge.invokeNativeModule("Animation", "sequence", [animations]);
+  }
+  function parallel(animations) {
+    return NativeBridge.invokeNativeModule("Animation", "parallel", [animations]);
+  }
+  function fadeOut(target, duration = 300) {
+    return timing(target, { opacity: 0 }, { duration });
+  }
+  function fadeIn(target, duration = 300) {
+    return timing(target, { opacity: 1 }, { duration });
+  }
+  function slideInFromRight(target, duration = 300) {
+    return timing(target, { translateX: 0 }, { duration, easing: "easeOut" });
+  }
+  function slideOutToRight(target, duration = 300) {
+    return timing(target, { translateX: 400 }, { duration, easing: "easeIn" });
+  }
+  function resolveId(target) {
+    return resolveViewId(target);
+  }
+  return {
+    timing,
+    spring,
+    keyframe,
+    sequence,
+    parallel,
+    fadeIn,
+    fadeOut,
+    slideInFromRight,
+    slideOutToRight,
+    resolveId,
+    Easing
+  };
+}
+
+// src/components/VTransition.ts
+var DefaultDuration = 300;
+function resolveAnimationTarget(el) {
+  if (!el) return void 0;
+  if (typeof el === "number") return el;
+  if (typeof el === "object" && "id" in el) return el.id;
+  return void 0;
+}
+var VTransition = defineComponent31({
+  name: "VTransition",
+  props: {
+    name: { type: String, default: "" },
+    appear: { type: Boolean, default: false },
+    persist: { type: Boolean, default: false },
+    mode: { type: String, default: "default" },
+    css: { type: Boolean, default: true },
+    type: { type: String, default: "transition" },
+    enterClass: { type: String, default: "" },
+    leaveClass: { type: String, default: "" },
+    enterActiveClass: { type: String, default: "" },
+    leaveActiveClass: { type: String, default: "" },
+    enterToClass: { type: String, default: "" },
+    leaveToClass: { type: String, default: "" },
+    enterFromClass: { type: String, default: "" },
+    leaveFromClass: { type: String, default: "" },
+    appearClass: { type: String, default: "" },
+    appearActiveClass: { type: String, default: "" },
+    appearToClass: { type: String, default: "" },
+    duration: [Number, Object]
+  },
+  setup(transitionProps, { slots, expose }) {
+    const { timing } = useAnimation();
+    const isAppearing = ref8(false);
+    const isLeaving = ref8(false);
+    const hasEntered = ref8(!transitionProps.appear);
+    function getElementFromVNode(vnode) {
+      try {
+        const el = vnode.el;
+        if (!el) return void 0;
+        return resolveAnimationTarget(el);
+      } catch {
+        return void 0;
+      }
+    }
+    async function doEnter(el) {
+      const viewId = getElementFromVNode(el);
+      if (!viewId) return;
+      isAppearing.value = true;
+      const enterDuration = typeof transitionProps.duration === "object" ? transitionProps.duration.enter ?? DefaultDuration : transitionProps.duration ?? DefaultDuration;
+      const enterStyles = { opacity: 1 };
+      try {
+        await timing(viewId, { opacity: 0 }, { duration: 0 });
+        await timing(viewId, enterStyles, { duration: enterDuration, easing: "easeOut" });
+        isAppearing.value = false;
+        hasEntered.value = true;
+      } catch (e) {
+        console.warn("[VueNative Transition] enter animation failed:", e);
+        isAppearing.value = false;
+        hasEntered.value = true;
+      }
+    }
+    async function doLeave(el) {
+      const viewId = getElementFromVNode(el);
+      if (!viewId) return;
+      isLeaving.value = true;
+      const leaveDuration = typeof transitionProps.duration === "object" ? transitionProps.duration.leave ?? DefaultDuration : transitionProps.duration ?? DefaultDuration;
+      try {
+        await timing(viewId, { opacity: 0 }, { duration: leaveDuration, easing: "easeIn" });
+      } catch (e) {
+        console.warn("[VueNative Transition] leave animation failed:", e);
+      } finally {
+        isLeaving.value = false;
+      }
+    }
+    function onEnter(_el, done) {
+      if (!hasEntered.value || transitionProps.appear) {
+        doEnter(_el).then(() => done());
+      } else {
+        done();
+      }
+    }
+    function onLeave(el, done) {
+      doLeave(el).then(() => done());
+    }
+    function onAfterEnter() {
     }
+    function onAfterLeave() {
+    }
+    function onEnterCancelled() {
+      isAppearing.value = false;
+    }
+    function onLeaveCancelled() {
+      isLeaving.value = false;
+    }
+    function onAppear(el, done) {
+      isAppearing.value = true;
+      doEnter(el).then(() => done());
+    }
+    function onAfterAppear() {
+      isAppearing.value = false;
+    }
+    expose({
+      onEnter,
+      onLeave,
+      onAfterEnter,
+      onAfterLeave,
+      onEnterCancelled,
+      onLeaveCancelled,
+      onAppear,
+      onAfterAppear,
+      isAppearing,
+      isLeaving,
+      hasEntered
+    });
+    return () => {
+      const children = slots.default?.() ?? [];
+      const hasDefault = children.length > 0;
+      if (!hasDefault) {
+        return h31("", {}, []);
+      }
+      let finalChildren = children;
+      if (transitionProps.mode === "out-in") {
+        if (isLeaving.value) {
+          finalChildren = [children[children.length - 1]];
+        } else if (!hasEntered.value) {
+          finalChildren = [];
+        }
+      }
+      if (transitionProps.mode === "in-out") {
+        if (isAppearing.value && children.length > 1) {
+          finalChildren = [children[0]];
+        }
+      }
+      return h31("Transition", {
+        name: transitionProps.name || "v",
+        appear: transitionProps.appear,
+        persist: transitionProps.persist || transitionProps.name === "persist",
+        css: transitionProps.css,
+        type: transitionProps.type,
+        onEnter,
+        onLeave,
+        onAfterEnter,
+        onAfterLeave,
+        onEnterCancelled,
+        onLeaveCancelled,
+        onAppear,
+        onAfterAppear
+      }, () => finalChildren);
+    };
   }
+});
+var VTransitionGroup = defineComponent31({
+  name: "VTransitionGroup",
+  props: {
+    tag: { type: String, default: void 0 },
+    name: { type: String, default: "v" },
+    appear: { type: Boolean, default: false },
+    persist: { type: Boolean, default: false },
+    moveClass: { type: String, default: "" },
+    duration: { type: Number, default: void 0 }
+  },
+  setup(groupProps, { slots, expose }) {
+    const { timing } = useAnimation();
+    function onMove(_el) {
+    }
+    function onEnter(el, done) {
+      const viewId = resolveAnimationTarget(el);
+      if (!viewId) {
+        done();
+        return;
+      }
+      timing(viewId, { opacity: 1 }, { duration: groupProps.duration ?? 300, easing: "easeOut" }).then(() => done()).catch(() => done());
+    }
+    function onLeave(el, done) {
+      const viewId = resolveAnimationTarget(el);
+      if (!viewId) {
+        done();
+        return;
+      }
+      timing(viewId, { opacity: 0 }, { duration: groupProps.duration ?? 300, easing: "easeIn" }).then(() => done()).catch(() => done());
+    }
+    expose({
+      onEnter,
+      onLeave,
+      onMove
+    });
+    return () => {
+      const children = slots.default?.() ?? [];
+      return h31("TransitionGroup", {
+        tag: groupProps.tag,
+        name: groupProps.name,
+        appear: groupProps.appear,
+        persist: groupProps.persist,
+        moveClass: groupProps.moveClass,
+        onEnter,
+        onLeave,
+        onMove
+      }, () => children);
+    };
+  }
+});
+
+// src/components/KeepAlive.ts
+import {
+  defineComponent as defineComponent32,
+  onUnmounted as onUnmounted3,
+  watch as watch6
+} from "@vue/runtime-core";
+function matches(pattern, name) {
+  if (!pattern) return false;
+  if (typeof pattern === "string") {
+    return pattern === name;
+  }
+  if (pattern instanceof RegExp) {
+    return pattern.test(name);
+  }
+  if (Array.isArray(pattern)) {
+    return pattern.includes(name);
+  }
+  return false;
+}
+function getComponentName(vnode) {
+  const component = vnode.type;
+  if (typeof component === "object" && component !== null && "name" in component) {
+    return component.name;
+  }
+  if (typeof component === "function") {
+    return component.name;
+  }
+  return void 0;
+}
+var KeepAlive = defineComponent32({
+  name: "KeepAlive",
+  props: {
+    include: [String, RegExp, Array],
+    exclude: [String, RegExp, Array],
+    max: [Number, String]
+  },
+  setup(props, { slots }) {
+    const cache = /* @__PURE__ */ new Map();
+    const keys = /* @__PURE__ */ new Set();
+    const maxCacheSize = typeof props.max === "string" ? parseInt(props.max, 10) : props.max;
+    function pruneCache(filter) {
+      cache.forEach((_, key) => {
+        if (!filter(key)) {
+          cache.delete(key);
+          keys.delete(key);
+        }
+      });
+    }
+    function pruneCacheEntry(key) {
+      cache.delete(key);
+      keys.delete(key);
+    }
+    watch6(
+      () => [props.include, props.exclude],
+      () => {
+        if (!props.include && !props.exclude) return;
+        pruneCache((name) => {
+          if (props.include && !matches(props.include, name)) return false;
+          if (props.exclude && matches(props.exclude, name)) return false;
+          return true;
+        });
+      }
+    );
+    onUnmounted3(() => {
+      cache.clear();
+      keys.clear();
+    });
+    return () => {
+      const children = slots.default?.() ?? [];
+      if (!children.length) return children;
+      const vnode = children[0];
+      const name = getComponentName(vnode) ?? String(vnode.type);
+      const key = name;
+      if (props.include && !matches(props.include, name)) {
+        return vnode;
+      }
+      if (props.exclude && matches(props.exclude, name)) {
+        return vnode;
+      }
+      const cached = cache.get(key);
+      if (cached) {
+        keys.delete(key);
+        keys.add(key);
+        return cached.vnode;
+      }
+      if (maxCacheSize && cache.size >= maxCacheSize) {
+        const firstKey = keys.values().next().value;
+        if (firstKey) {
+          pruneCacheEntry(firstKey);
+        }
+      }
+      cache.set(key, { vnode, key });
+      keys.add(key);
+      return vnode;
+    };
+  }
+});
+KeepAlive.isKeepAlive = true;
+
+// src/components/VSuspense.ts
+import {
+  defineComponent as defineComponent33,
+  h as h32,
+  ref as ref9,
+  onMounted,
+  shallowRef,
+  watch as watch7,
+  provide as provide2,
+  inject as inject2
+} from "@vue/runtime-core";
+var suspenseContextKey = /* @__PURE__ */ Symbol("suspense");
+var VSuspense = defineComponent33({
+  name: "Suspense",
+  props: {
+    timeout: { type: Number, default: 3e4 }
+  },
+  setup(_props, { slots }) {
+    const hasError = ref9(false);
+    const error = shallowRef(null);
+    const pendingCount = ref9(0);
+    const context = {
+      hasError,
+      error,
+      pendingCount,
+      resolve: () => {
+        pendingCount.value--;
+      },
+      reject: (err) => {
+        hasError.value = true;
+        error.value = err;
+      }
+    };
+    provide2(suspenseContextKey, context);
+    return () => {
+      if (hasError.value) {
+        return slots.fallback?.({ error: error.value }) ?? null;
+      }
+      const defaultSlots = slots.default?.() ?? [];
+      return defaultSlots;
+    };
+  }
+});
+
+// src/components/index.ts
+var builtInComponents = {
+  VView,
+  VText,
+  VButton,
+  VInput,
+  VSwitch,
+  VActivityIndicator,
+  VScrollView,
+  VImage,
+  VKeyboardAvoiding,
+  VSafeArea,
+  VSlider,
+  VList,
+  VModal,
+  VAlertDialog,
+  VStatusBar,
+  VWebView,
+  VProgressBar,
+  VPicker,
+  VSegmentedControl,
+  VActionSheet,
+  VRefreshControl,
+  VPressable,
+  VSectionList,
+  VCheckbox,
+  VRadio,
+  VDropdown,
+  VVideo,
+  VFlatList,
+  VTabBar,
+  VDrawer,
+  VDrawerItem,
+  VDrawerSection,
+  VTransition,
+  VTransitionGroup,
+  KeepAlive,
+  VSuspense
 };
 
 // src/errorBoundary.ts
-import { defineComponent as defineComponent29, ref as ref6, watch as watch4, onErrorCaptured } from "@vue/runtime-core";
-var ErrorBoundary = defineComponent29({
+import { defineComponent as defineComponent34, ref as ref10, watch as watch8, onErrorCaptured } from "@vue/runtime-core";
+var ErrorBoundary = defineComponent34({
   name: "ErrorBoundary",
   props: {
     onError: Function,
@@ -1934,8 +2831,8 @@ var ErrorBoundary = defineComponent29({
     }
   },
   setup(props, { slots }) {
-    const error = ref6(null);
-    const errorInfo = ref6("");
+    const error = ref10(null);
+    const errorInfo = ref10("");
     onErrorCaptured((err, _instance, info) => {
       const normalizedError = err instanceof Error ? err : new Error(String(err));
       error.value = normalizedError;
@@ -1949,7 +2846,7 @@ var ErrorBoundary = defineComponent29({
       error.value = null;
       errorInfo.value = "";
     }
-    watch4(
+    watch8(
       () => props.resetKeys,
       () => {
         if (error.value) {
@@ -2085,11 +2982,78 @@ function createStyleSheet(styles) {
   }
   const result = {};
   for (const key in styles) {
-    result[key] = Object.freeze({ ...styles[key] });
+    const styleKey = key;
+    result[styleKey] = Object.freeze({ ...styles[styleKey] });
   }
   return Object.freeze(result);
 }
 
+// src/directives/vShow.ts
+var vShow = {
+  beforeMount(el, { value }) {
+    try {
+      NativeBridge.updateProp(el.id, "hidden", !value);
+    } catch (err) {
+      console.error("[VueNative] v-show beforeMount error:", err);
+    }
+  },
+  updated(el, { value, oldValue }) {
+    if (value === oldValue) return;
+    try {
+      NativeBridge.updateProp(el.id, "hidden", !value);
+    } catch (err) {
+      console.error("[VueNative] v-show updated error:", err);
+    }
+  }
+};
+
+// src/directives/vModel.ts
+function getModelValue(event) {
+  const modelEvent = event;
+  return modelEvent?.value ?? modelEvent?.target?.value ?? event;
+}
+var vModel = {
+  beforeMount(el, binding, vnode) {
+    const { value, modifiers } = binding;
+    const { lazy, number, trim } = modifiers || {};
+    NativeBridge.updateProp(el.id, "value", value);
+    const assign = vnode.dirs?.[0]?.value;
+    if (typeof assign !== "function") {
+      console.warn(
+        "[VueNative] v-model directive requires the vnode to have an assign function. This usually happens when using v-model on native elements rendered by Vue, not custom components with modelValue props."
+      );
+      return;
+    }
+    const eventName = lazy ? "change" : "input";
+    NativeBridge.addEventListener(el.id, eventName, (event) => {
+      let newValue = getModelValue(event);
+      if (trim && typeof newValue === "string") {
+        newValue = newValue.trim();
+      }
+      if (number) {
+        newValue = Number(newValue);
+      }
+      assign(newValue);
+    });
+  },
+  updated(el, { value, oldValue, modifiers }, vnode) {
+    if (value === oldValue) return;
+    const _assign = vnode.dirs?.[0]?.value;
+    let newValue = value;
+    if (modifiers?.trim && typeof value === "string") {
+      newValue = value.trim();
+    }
+    if (modifiers?.number) {
+      newValue = Number(value);
+    }
+    NativeBridge.updateProp(el.id, "value", newValue);
+  },
+  beforeUnmount(el, _binding, _vnode) {
+    NativeBridge.removeEventListener(el.id, "input");
+    NativeBridge.removeEventListener(el.id, "change");
+  }
+};
+
 // src/composables/useHaptics.ts
 function useHaptics() {
   function vibrate(style = "medium") {
@@ -2143,9 +3107,9 @@ function useAsyncStorage() {
 }
 
 // src/composables/useClipboard.ts
-import { ref as ref7 } from "@vue/runtime-core";
+import { ref as ref11 } from "@vue/runtime-core";
 function useClipboard() {
-  const content = ref7("");
+  const content = ref11("");
   function copy(text) {
     return NativeBridge.invokeNativeModule("Clipboard", "copy", [text]).then(() => void 0);
   }
@@ -2159,16 +3123,16 @@ function useClipboard() {
 }
 
 // src/composables/useDeviceInfo.ts
-import { ref as ref8, onMounted } from "@vue/runtime-core";
+import { ref as ref12, onMounted as onMounted2 } from "@vue/runtime-core";
 function useDeviceInfo() {
-  const model = ref8("");
-  const systemVersion = ref8("");
-  const systemName = ref8("");
-  const name = ref8("");
-  const screenWidth = ref8(0);
-  const screenHeight = ref8(0);
-  const scale = ref8(1);
-  const isLoaded = ref8(false);
+  const model = ref12("");
+  const systemVersion = ref12("");
+  const systemName = ref12("");
+  const name = ref12("");
+  const screenWidth = ref12(0);
+  const screenHeight = ref12(0);
+  const scale = ref12(1);
+  const isLoaded = ref12(false);
   async function fetchInfo() {
     const info = await NativeBridge.invokeNativeModule("DeviceInfo", "getInfo", []);
     model.value = info.model ?? "";
@@ -2180,7 +3144,7 @@ function useDeviceInfo() {
     scale.value = info.scale ?? 1;
     isLoaded.value = true;
   }
-  onMounted(() => {
+  onMounted2(() => {
     fetchInfo();
   });
   return {
@@ -2197,10 +3161,10 @@ function useDeviceInfo() {
 }
 
 // src/composables/useKeyboard.ts
-import { ref as ref9 } from "@vue/runtime-core";
+import { ref as ref13 } from "@vue/runtime-core";
 function useKeyboard() {
-  const isVisible = ref9(false);
-  const height = ref9(0);
+  const isVisible = ref13(false);
+  const height = ref13(0);
   function dismiss() {
     return NativeBridge.invokeNativeModule("Keyboard", "dismiss", []).then(() => void 0);
   }
@@ -2213,75 +3177,11 @@ function useKeyboard() {
   return { isVisible, height, dismiss, getHeight };
 }
 
-// src/composables/useAnimation.ts
-var Easing = {
-  linear: "linear",
-  ease: "ease",
-  easeIn: "easeIn",
-  easeOut: "easeOut",
-  easeInOut: "easeInOut"
-};
-function resolveViewId(target) {
-  if (typeof target === "number") return target;
-  if (target && typeof target === "object" && "value" in target) {
-    const val = target.value;
-    if (val && typeof val.id === "number") return val.id;
-    throw new Error("[VueNative] Animation target ref has no .value.id \u2014 is the ref attached to a component?");
-  }
-  if (target && typeof target.id === "number") return target.id;
-  throw new Error("[VueNative] Invalid animation target. Pass a number, template ref, or NativeNode.");
-}
-function useAnimation() {
-  function timing(target, toStyles, config = {}) {
-    return NativeBridge.invokeNativeModule("Animation", "timing", [resolveViewId(target), toStyles, config]);
-  }
-  function spring(target, toStyles, config = {}) {
-    return NativeBridge.invokeNativeModule("Animation", "spring", [resolveViewId(target), toStyles, config]);
-  }
-  function keyframe(target, steps, config = {}) {
-    return NativeBridge.invokeNativeModule("Animation", "keyframe", [resolveViewId(target), steps, config]);
-  }
-  function sequence(animations) {
-    return NativeBridge.invokeNativeModule("Animation", "sequence", [animations]);
-  }
-  function parallel(animations) {
-    return NativeBridge.invokeNativeModule("Animation", "parallel", [animations]);
-  }
-  function fadeOut(target, duration = 300) {
-    return timing(target, { opacity: 0 }, { duration });
-  }
-  function fadeIn(target, duration = 300) {
-    return timing(target, { opacity: 1 }, { duration });
-  }
-  function slideInFromRight(target, duration = 300) {
-    return timing(target, { translateX: 0 }, { duration, easing: "easeOut" });
-  }
-  function slideOutToRight(target, duration = 300) {
-    return timing(target, { translateX: 400 }, { duration, easing: "easeIn" });
-  }
-  function resolveId(target) {
-    return resolveViewId(target);
-  }
-  return {
-    timing,
-    spring,
-    keyframe,
-    sequence,
-    parallel,
-    fadeIn,
-    fadeOut,
-    slideInFromRight,
-    slideOutToRight,
-    resolveId,
-    Easing
-  };
-}
-
 // src/composables/useNetwork.ts
-import { ref as ref10, onUnmounted as onUnmounted3 } from "@vue/runtime-core";
+import { ref as ref14, onUnmounted as onUnmounted4 } from "@vue/runtime-core";
 function useNetwork() {
-  const isConnected = ref10(true);
-  const connectionType = ref10("unknown");
+  const isConnected = ref14(true);
+  const connectionType = ref14("unknown");
   let lastEventTime = 0;
   const unsubscribe = NativeBridge.onGlobalEvent("network:change", (payload) => {
     lastEventTime = Date.now();
@@ -2296,14 +3196,14 @@ function useNetwork() {
     }
   }).catch(() => {
   });
-  onUnmounted3(unsubscribe);
+  onUnmounted4(unsubscribe);
   return { isConnected, connectionType };
 }
 
 // src/composables/useAppState.ts
-import { ref as ref11, onUnmounted as onUnmounted4 } from "@vue/runtime-core";
+import { ref as ref15, onUnmounted as onUnmounted5 } from "@vue/runtime-core";
 function useAppState() {
-  const state = ref11("active");
+  const state = ref15("active");
   NativeBridge.invokeNativeModule("AppState", "getState").then((s) => {
     state.value = s;
   }).catch(() => {
@@ -2311,7 +3211,7 @@ function useAppState() {
   const unsubscribe = NativeBridge.onGlobalEvent("appState:change", (payload) => {
     state.value = payload.state;
   });
-  onUnmounted4(unsubscribe);
+  onUnmounted5(unsubscribe);
   return { state };
 }
 
@@ -2346,10 +3246,10 @@ function usePermissions() {
 }
 
 // src/composables/useGeolocation.ts
-import { ref as ref12, onUnmounted as onUnmounted5 } from "@vue/runtime-core";
+import { ref as ref16, onUnmounted as onUnmounted6 } from "@vue/runtime-core";
 function useGeolocation() {
-  const coords = ref12(null);
-  const error = ref12(null);
+  const coords = ref16(null);
+  const error = ref16(null);
   let watchId = null;
   async function getCurrentPosition() {
     try {
@@ -2374,7 +3274,7 @@ function useGeolocation() {
       const unsubscribeError = NativeBridge.onGlobalEvent("location:error", (payload) => {
         error.value = payload.message;
       });
-      onUnmounted5(() => {
+      onUnmounted6(() => {
         unsubscribe();
         unsubscribeError();
         if (watchId !== null) clearWatch(watchId);
@@ -2394,7 +3294,7 @@ function useGeolocation() {
 }
 
 // src/composables/useCamera.ts
-import { onUnmounted as onUnmounted6 } from "@vue/runtime-core";
+import { onUnmounted as onUnmounted7 } from "@vue/runtime-core";
 function useCamera() {
   const qrCleanups = [];
   async function launchCamera(options = {}) {
@@ -2417,7 +3317,7 @@ function useCamera() {
     qrCleanups.push(unsubscribe);
     return unsubscribe;
   }
-  onUnmounted6(() => {
+  onUnmounted7(() => {
     NativeBridge.invokeNativeModule("Camera", "stopQRScan").catch(() => {
     });
     qrCleanups.forEach((fn) => fn());
@@ -2427,10 +3327,10 @@ function useCamera() {
 }
 
 // src/composables/useNotifications.ts
-import { ref as ref13, onUnmounted as onUnmounted7 } from "@vue/runtime-core";
+import { ref as ref17, onUnmounted as onUnmounted8 } from "@vue/runtime-core";
 function useNotifications() {
-  const isGranted = ref13(false);
-  const pushToken = ref13(null);
+  const isGranted = ref17(false);
+  const pushToken = ref17(null);
   async function requestPermission() {
     const granted = await NativeBridge.invokeNativeModule("Notifications", "requestPermission");
     isGranted.value = granted;
@@ -2450,7 +3350,7 @@ function useNotifications() {
   }
   function onNotification(handler) {
     const unsubscribe = NativeBridge.onGlobalEvent("notification:received", handler);
-    onUnmounted7(unsubscribe);
+    onUnmounted8(unsubscribe);
     return unsubscribe;
   }
   async function registerForPush() {
@@ -2464,12 +3364,12 @@ function useNotifications() {
       pushToken.value = payload.token;
       handler(payload.token);
     });
-    onUnmounted7(unsubscribe);
+    onUnmounted8(unsubscribe);
     return unsubscribe;
   }
   function onPushReceived(handler) {
     const unsubscribe = NativeBridge.onGlobalEvent("push:received", handler);
-    onUnmounted7(unsubscribe);
+    onUnmounted8(unsubscribe);
     return unsubscribe;
   }
   return {
@@ -2505,7 +3405,10 @@ function useBiometry() {
 }
 
 // src/composables/useHttp.ts
-import { ref as ref14, onUnmounted as onUnmounted8 } from "@vue/runtime-core";
+import { ref as ref18, onUnmounted as onUnmounted9 } from "@vue/runtime-core";
+function isQueryRequestOptions(value) {
+  return "params" in value || "headers" in value;
+}
 function useHttp(config = {}) {
   if (config.pins && Object.keys(config.pins).length > 0) {
     const configurePins = globalThis.__VN_configurePins;
@@ -2515,10 +3418,10 @@ function useHttp(config = {}) {
       NativeBridge.invokeNativeModule("Http", "configurePins", [config.pins]);
     }
   }
-  const loading = ref14(false);
-  const error = ref14(null);
+  const loading = ref18(false);
+  const error = ref18(null);
   let isMounted = true;
-  onUnmounted8(() => {
+  onUnmounted9(() => {
     isMounted = false;
   });
   const BODY_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
@@ -2604,30 +3507,24 @@ function useHttp(config = {}) {
     loading,
     error,
     get: (url, options) => {
-      if (options && !("params" in options) && !("headers" in options)) {
-        return request("GET", url, { headers: options });
-      }
-      const opts = options;
-      return request("GET", buildUrl(url, opts?.params), { headers: opts?.headers });
+      const normalizedOptions = options ? isQueryRequestOptions(options) ? options : { headers: options } : void 0;
+      return request("GET", buildUrl(url, normalizedOptions?.params), { headers: normalizedOptions?.headers });
     },
     post: (url, body, headers) => request("POST", url, { body, headers }),
     put: (url, body, headers) => request("PUT", url, { body, headers }),
     patch: (url, body, headers) => request("PATCH", url, { body, headers }),
     delete: (url, options) => {
-      if (options && !("params" in options) && !("headers" in options)) {
-        return request("DELETE", url, { headers: options });
-      }
-      const opts = options;
-      return request("DELETE", buildUrl(url, opts?.params), { headers: opts?.headers });
+      const normalizedOptions = options ? isQueryRequestOptions(options) ? options : { headers: options } : void 0;
+      return request("DELETE", buildUrl(url, normalizedOptions?.params), { headers: normalizedOptions?.headers });
     }
   };
 }
 
 // src/composables/useColorScheme.ts
-import { ref as ref15, onUnmounted as onUnmounted9 } from "@vue/runtime-core";
+import { ref as ref19, onUnmounted as onUnmounted10 } from "@vue/runtime-core";
 function useColorScheme() {
-  const colorScheme = ref15("light");
-  const isDark = ref15(false);
+  const colorScheme = ref19("light");
+  const isDark = ref19(false);
   const unsubscribe = NativeBridge.onGlobalEvent(
     "colorScheme:change",
     (payload) => {
@@ -2635,15 +3532,15 @@ function useColorScheme() {
       isDark.value = payload.colorScheme === "dark";
     }
   );
-  onUnmounted9(unsubscribe);
+  onUnmounted10(unsubscribe);
   return { colorScheme, isDark };
 }
 
 // src/composables/useBackHandler.ts
-import { onMounted as onMounted2, onUnmounted as onUnmounted10 } from "@vue/runtime-core";
+import { onMounted as onMounted3, onUnmounted as onUnmounted11 } from "@vue/runtime-core";
 function useBackHandler(handler) {
   let unsubscribe = null;
-  onMounted2(() => {
+  onMounted3(() => {
     unsubscribe = NativeBridge.onGlobalEvent("hardware:backPress", () => {
       const handled = handler();
       if (!handled) {
@@ -2652,7 +3549,7 @@ function useBackHandler(handler) {
       }
     });
   });
-  onUnmounted10(() => {
+  onUnmounted11(() => {
     unsubscribe?.();
     unsubscribe = null;
   });
@@ -2676,11 +3573,11 @@ function useSecureStorage() {
 }
 
 // src/composables/useI18n.ts
-import { ref as ref16, onMounted as onMounted3 } from "@vue/runtime-core";
+import { ref as ref20, onMounted as onMounted4 } from "@vue/runtime-core";
 function useI18n() {
-  const isRTL = ref16(false);
-  const locale = ref16("en");
-  onMounted3(async () => {
+  const isRTL = ref20(false);
+  const locale = ref20("en");
+  onMounted4(async () => {
     try {
       const info = await NativeBridge.invokeNativeModule("DeviceInfo", "getDeviceInfo", []);
       locale.value = info?.locale || "en";
@@ -2691,21 +3588,13 @@ function useI18n() {
   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 ref17, onMounted as onMounted4, onUnmounted as onUnmounted11 } from "@vue/runtime-core";
+import { ref as ref21, onMounted as onMounted5, onUnmounted as onUnmounted12 } from "@vue/runtime-core";
 function useDimensions() {
-  const width = ref17(0);
-  const height = ref17(0);
-  const scale = ref17(1);
-  onMounted4(async () => {
+  const width = ref21(0);
+  const height = ref21(0);
+  const scale = ref21(1);
+  onMounted5(async () => {
     try {
       const info = await NativeBridge.invokeNativeModule("DeviceInfo", "getInfo", []);
       width.value = info?.screenWidth || 0;
@@ -2719,12 +3608,12 @@ function useDimensions() {
     if (payload.height != null) height.value = payload.height;
     if (payload.scale != null) scale.value = payload.scale;
   });
-  onUnmounted11(cleanup);
+  onUnmounted12(cleanup);
   return { width, height, scale };
 }
 
 // src/composables/useWebSocket.ts
-import { ref as ref18, onUnmounted as onUnmounted12 } from "@vue/runtime-core";
+import { ref as ref22, onUnmounted as onUnmounted13 } from "@vue/runtime-core";
 var connectionCounter = 0;
 function useWebSocket(url, options = {}) {
   const {
@@ -2734,9 +3623,9 @@ function useWebSocket(url, options = {}) {
     reconnectInterval = 1e3
   } = options;
   const connectionId = `ws_${++connectionCounter}_${Date.now()}`;
-  const status = ref18("CLOSED");
-  const lastMessage = ref18(null);
-  const error = ref18(null);
+  const status = ref22("CLOSED");
+  const lastMessage = ref22(null);
+  const error = ref22(null);
   let reconnectAttempts = 0;
   let reconnectTimer = null;
   const MAX_PENDING_MESSAGES = 100;
@@ -2821,7 +3710,7 @@ function useWebSocket(url, options = {}) {
   if (autoConnect) {
     open();
   }
-  onUnmounted12(() => {
+  onUnmounted13(() => {
     if (reconnectTimer) {
       clearTimeout(reconnectTimer);
     }
@@ -2890,12 +3779,12 @@ function useFileSystem() {
 }
 
 // src/composables/useSensors.ts
-import { ref as ref19, onUnmounted as onUnmounted13 } from "@vue/runtime-core";
+import { ref as ref23, onUnmounted as onUnmounted14 } from "@vue/runtime-core";
 function useAccelerometer(options = {}) {
-  const x = ref19(0);
-  const y = ref19(0);
-  const z = ref19(0);
-  const isAvailable = ref19(false);
+  const x = ref23(0);
+  const y = ref23(0);
+  const z = ref23(0);
+  const isAvailable = ref23(false);
   let running = false;
   let unsubscribe = null;
   NativeBridge.invokeNativeModule("Sensors", "isAvailable", ["accelerometer"]).then((result) => {
@@ -2923,16 +3812,16 @@ function useAccelerometer(options = {}) {
     NativeBridge.invokeNativeModule("Sensors", "stopAccelerometer").catch(() => {
     });
   }
-  onUnmounted13(() => {
+  onUnmounted14(() => {
     stop();
   });
   return { x, y, z, isAvailable, start, stop };
 }
 function useGyroscope(options = {}) {
-  const x = ref19(0);
-  const y = ref19(0);
-  const z = ref19(0);
-  const isAvailable = ref19(false);
+  const x = ref23(0);
+  const y = ref23(0);
+  const z = ref23(0);
+  const isAvailable = ref23(false);
   let running = false;
   let unsubscribe = null;
   NativeBridge.invokeNativeModule("Sensors", "isAvailable", ["gyroscope"]).then((result) => {
@@ -2960,20 +3849,31 @@ function useGyroscope(options = {}) {
     NativeBridge.invokeNativeModule("Sensors", "stopGyroscope").catch(() => {
     });
   }
-  onUnmounted13(() => {
+  onUnmounted14(() => {
     stop();
   });
   return { x, y, z, isAvailable, start, stop };
 }
 
 // src/composables/useAudio.ts
-import { ref as ref20, onUnmounted as onUnmounted14 } from "@vue/runtime-core";
+import { ref as ref24, onUnmounted as onUnmounted15 } from "@vue/runtime-core";
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+function getNumberProp(record, key) {
+  const value = record?.[key];
+  return typeof value === "number" ? value : void 0;
+}
+function getStringProp(record, key) {
+  const value = record?.[key];
+  return typeof value === "string" ? value : void 0;
+}
 function useAudio() {
-  const duration = ref20(0);
-  const position = ref20(0);
-  const isPlaying = ref20(false);
-  const isRecording = ref20(false);
-  const error = ref20(null);
+  const duration = ref24(0);
+  const position = ref24(0);
+  const isPlaying = ref24(false);
+  const isRecording = ref24(false);
+  const error = ref24(null);
   const unsubProgress = NativeBridge.onGlobalEvent("audio:progress", (payload) => {
     position.value = payload.currentTime ?? 0;
     duration.value = payload.duration ?? 0;
@@ -2986,7 +3886,7 @@ function useAudio() {
     error.value = payload.message ?? "Unknown audio error";
     isPlaying.value = false;
   });
-  onUnmounted14(() => {
+  onUnmounted15(() => {
     unsubProgress();
     unsubComplete();
     unsubError();
@@ -2999,9 +3899,10 @@ function useAudio() {
   });
   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;
+    const result = asRecord(await NativeBridge.invokeNativeModule("Audio", "play", [uri, options]));
+    const audioDuration = getNumberProp(result, "duration");
+    if (audioDuration !== void 0) {
+      duration.value = audioDuration;
     }
     isPlaying.value = true;
   }
@@ -3027,14 +3928,17 @@ function useAudio() {
   }
   async function startRecording(options = {}) {
     error.value = null;
-    const result = await NativeBridge.invokeNativeModule("Audio", "startRecording", [options]);
+    const result = asRecord(await NativeBridge.invokeNativeModule("Audio", "startRecording", [options]));
     isRecording.value = true;
-    return result?.uri ?? "";
+    return getStringProp(result, "uri") ?? "";
   }
   async function stopRecording() {
-    const result = await NativeBridge.invokeNativeModule("Audio", "stopRecording", []);
+    const result = asRecord(await NativeBridge.invokeNativeModule("Audio", "stopRecording", []));
     isRecording.value = false;
-    return { uri: result?.uri ?? "", duration: result?.duration ?? 0 };
+    return {
+      uri: getStringProp(result, "uri") ?? "",
+      duration: getNumberProp(result, "duration") ?? 0
+    };
   }
   async function pauseRecording() {
     await NativeBridge.invokeNativeModule("Audio", "pauseRecording", []);
@@ -3065,9 +3969,9 @@ function useAudio() {
 }
 
 // src/composables/useDatabase.ts
-import { ref as ref21, onUnmounted as onUnmounted15 } from "@vue/runtime-core";
+import { ref as ref25, onUnmounted as onUnmounted16 } from "@vue/runtime-core";
 function useDatabase(name = "default") {
-  const isOpen = ref21(false);
+  const isOpen = ref25(false);
   let opened = false;
   async function ensureOpen() {
     if (opened) return;
@@ -3109,7 +4013,7 @@ function useDatabase(name = "default") {
     opened = false;
     isOpen.value = false;
   }
-  onUnmounted15(() => {
+  onUnmounted16(() => {
     if (opened) {
       NativeBridge.invokeNativeModule("Database", "close", [name]).catch(() => {
       });
@@ -3121,12 +4025,12 @@ function useDatabase(name = "default") {
 }
 
 // src/composables/usePerformance.ts
-import { ref as ref22, onUnmounted as onUnmounted16 } from "@vue/runtime-core";
+import { ref as ref26, onUnmounted as onUnmounted17 } from "@vue/runtime-core";
 function usePerformance() {
-  const isProfiling = ref22(false);
-  const fps = ref22(0);
-  const memoryMB = ref22(0);
-  const bridgeOps = ref22(0);
+  const isProfiling = ref26(false);
+  const fps = ref26(0);
+  const memoryMB = ref26(0);
+  const bridgeOps = ref26(0);
   let unsubscribe = null;
   function handleMetrics(payload) {
     fps.value = payload.fps ?? 0;
@@ -3151,7 +4055,7 @@ function usePerformance() {
   async function getMetrics() {
     return NativeBridge.invokeNativeModule("Performance", "getMetrics", []);
   }
-  onUnmounted16(() => {
+  onUnmounted17(() => {
     if (isProfiling.value) {
       NativeBridge.invokeNativeModule("Performance", "stopProfiling", []).catch(() => {
       });
@@ -3174,10 +4078,10 @@ function usePerformance() {
 }
 
 // src/composables/useSharedElementTransition.ts
-import { ref as ref23, onUnmounted as onUnmounted17 } from "@vue/runtime-core";
+import { ref as ref27, onUnmounted as onUnmounted18 } from "@vue/runtime-core";
 var sharedElementRegistry = /* @__PURE__ */ new Map();
 function useSharedElementTransition(elementId) {
-  const viewId = ref23(null);
+  const viewId = ref27(null);
   function register(nativeViewId) {
     viewId.value = nativeViewId;
     sharedElementRegistry.set(elementId, nativeViewId);
@@ -3186,7 +4090,7 @@ function useSharedElementTransition(elementId) {
     viewId.value = null;
     sharedElementRegistry.delete(elementId);
   }
-  onUnmounted17(() => {
+  onUnmounted18(() => {
     unregister();
   });
   return {
@@ -3210,11 +4114,19 @@ function clearSharedElementRegistry() {
 }
 
 // src/composables/useIAP.ts
-import { ref as ref24, onUnmounted as onUnmounted18 } from "@vue/runtime-core";
+import { ref as ref28, onUnmounted as onUnmounted19 } from "@vue/runtime-core";
+function getErrorMessage(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "object" && error !== null && "message" in error) {
+    const message = error.message;
+    if (typeof message === "string") return message;
+  }
+  return String(error);
+}
 function useIAP() {
-  const products = ref24([]);
-  const isReady = ref24(false);
-  const error = ref24(null);
+  const products = ref28([]);
+  const isReady = ref28(false);
+  const error = ref28(null);
   const cleanups = [];
   const unsubscribe = NativeBridge.onGlobalEvent("iap:transactionUpdate", (payload) => {
     if (payload.state === "failed" && payload.error) {
@@ -3225,7 +4137,7 @@ function useIAP() {
   NativeBridge.invokeNativeModule("IAP", "initialize").then(() => {
     isReady.value = true;
   }).catch((err) => {
-    error.value = String(err);
+    error.value = getErrorMessage(err);
   });
   async function getProducts(skus) {
     error.value = null;
@@ -3235,7 +4147,7 @@ function useIAP() {
       products.value = productList;
       return productList;
     } catch (err) {
-      error.value = String(err);
+      error.value = getErrorMessage(err);
       return [];
     }
   }
@@ -3244,7 +4156,7 @@ function useIAP() {
     try {
       return await NativeBridge.invokeNativeModule("IAP", "purchase", [sku]);
     } catch (err) {
-      error.value = String(err);
+      error.value = getErrorMessage(err);
       return null;
     }
   }
@@ -3253,7 +4165,7 @@ function useIAP() {
     try {
       return await NativeBridge.invokeNativeModule("IAP", "restorePurchases");
     } catch (err) {
-      error.value = String(err);
+      error.value = getErrorMessage(err);
       return [];
     }
   }
@@ -3262,7 +4174,7 @@ function useIAP() {
     try {
       return await NativeBridge.invokeNativeModule("IAP", "getActiveSubscriptions");
     } catch (err) {
-      error.value = String(err);
+      error.value = getErrorMessage(err);
       return [];
     }
   }
@@ -3271,7 +4183,7 @@ function useIAP() {
     cleanups.push(unsub);
     return unsub;
   }
-  onUnmounted18(() => {
+  onUnmounted19(() => {
     cleanups.forEach((fn) => fn());
     cleanups.length = 0;
   });
@@ -3288,11 +4200,32 @@ function useIAP() {
 }
 
 // src/composables/useAppleSignIn.ts
-import { ref as ref25, onUnmounted as onUnmounted19 } from "@vue/runtime-core";
+import { ref as ref29, onUnmounted as onUnmounted20 } from "@vue/runtime-core";
+function getErrorMessage2(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "object" && error !== null && "message" in error) {
+    const message = error.message;
+    if (typeof message === "string") return message;
+  }
+  return String(error);
+}
+function normalizeSocialUser(value, provider) {
+  if (typeof value !== "object" || value === null) return null;
+  const payload = value;
+  if (typeof payload.userId !== "string") return null;
+  return {
+    userId: payload.userId,
+    email: typeof payload.email === "string" ? payload.email : void 0,
+    fullName: typeof payload.fullName === "string" ? payload.fullName : void 0,
+    identityToken: typeof payload.identityToken === "string" ? payload.identityToken : void 0,
+    authorizationCode: typeof payload.authorizationCode === "string" ? payload.authorizationCode : void 0,
+    provider
+  };
+}
 function useAppleSignIn() {
-  const user = ref25(null);
-  const isAuthenticated = ref25(false);
-  const error = ref25(null);
+  const user = ref29(null);
+  const isAuthenticated = ref29(false);
+  const error = ref29(null);
   const cleanups = [];
   const unsubscribe = NativeBridge.onGlobalEvent("auth:appleCredentialRevoked", () => {
     user.value = null;
@@ -3300,8 +4233,9 @@ function useAppleSignIn() {
   });
   cleanups.push(unsubscribe);
   NativeBridge.invokeNativeModule("SocialAuth", "getCurrentUser", ["apple"]).then((result) => {
-    if (result && result.userId) {
-      user.value = { ...result, provider: "apple" };
+    const currentUser = normalizeSocialUser(result, "apple");
+    if (currentUser) {
+      user.value = currentUser;
       isAuthenticated.value = true;
     }
   }).catch(() => {
@@ -3310,12 +4244,15 @@ function useAppleSignIn() {
     error.value = null;
     try {
       const result = await NativeBridge.invokeNativeModule("SocialAuth", "signInWithApple");
-      const socialUser = { ...result, provider: "apple" };
+      const socialUser = normalizeSocialUser(result, "apple");
+      if (!socialUser) {
+        throw new Error("Invalid Apple Sign In response.");
+      }
       user.value = socialUser;
       isAuthenticated.value = true;
       return { success: true, user: socialUser };
     } catch (err) {
-      const message = String(err);
+      const message = getErrorMessage2(err);
       error.value = message;
       return { success: false, error: message };
     }
@@ -3327,10 +4264,10 @@ function useAppleSignIn() {
       user.value = null;
       isAuthenticated.value = false;
     } catch (err) {
-      error.value = String(err);
+      error.value = getErrorMessage2(err);
     }
   }
-  onUnmounted19(() => {
+  onUnmounted20(() => {
     cleanups.forEach((fn) => fn());
     cleanups.length = 0;
   });
@@ -3338,15 +4275,37 @@ function useAppleSignIn() {
 }
 
 // src/composables/useGoogleSignIn.ts
-import { ref as ref26, onUnmounted as onUnmounted20 } from "@vue/runtime-core";
+import { ref as ref30, onUnmounted as onUnmounted21 } from "@vue/runtime-core";
+function getErrorMessage3(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "object" && error !== null && "message" in error) {
+    const message = error.message;
+    if (typeof message === "string") return message;
+  }
+  return String(error);
+}
+function normalizeSocialUser2(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const payload = value;
+  if (typeof payload.userId !== "string") return null;
+  return {
+    userId: payload.userId,
+    email: typeof payload.email === "string" ? payload.email : void 0,
+    fullName: typeof payload.fullName === "string" ? payload.fullName : void 0,
+    identityToken: typeof payload.identityToken === "string" ? payload.identityToken : void 0,
+    authorizationCode: typeof payload.authorizationCode === "string" ? payload.authorizationCode : void 0,
+    provider: "google"
+  };
+}
 function useGoogleSignIn(clientId) {
-  const user = ref26(null);
-  const isAuthenticated = ref26(false);
-  const error = ref26(null);
+  const user = ref30(null);
+  const isAuthenticated = ref30(false);
+  const error = ref30(null);
   const cleanups = [];
   NativeBridge.invokeNativeModule("SocialAuth", "getCurrentUser", ["google"]).then((result) => {
-    if (result && result.userId) {
-      user.value = { ...result, provider: "google" };
+    const currentUser = normalizeSocialUser2(result);
+    if (currentUser) {
+      user.value = currentUser;
       isAuthenticated.value = true;
     }
   }).catch(() => {
@@ -3355,12 +4314,15 @@ function useGoogleSignIn(clientId) {
     error.value = null;
     try {
       const result = await NativeBridge.invokeNativeModule("SocialAuth", "signInWithGoogle", [clientId]);
-      const socialUser = { ...result, provider: "google" };
+      const socialUser = normalizeSocialUser2(result);
+      if (!socialUser) {
+        throw new Error("Invalid Google Sign In response.");
+      }
       user.value = socialUser;
       isAuthenticated.value = true;
       return { success: true, user: socialUser };
     } catch (err) {
-      const message = String(err);
+      const message = getErrorMessage3(err);
       error.value = message;
       return { success: false, error: message };
     }
@@ -3372,10 +4334,10 @@ function useGoogleSignIn(clientId) {
       user.value = null;
       isAuthenticated.value = false;
     } catch (err) {
-      error.value = String(err);
+      error.value = getErrorMessage3(err);
     }
   }
-  onUnmounted20(() => {
+  onUnmounted21(() => {
     cleanups.forEach((fn) => fn());
     cleanups.length = 0;
   });
@@ -3383,17 +4345,17 @@ function useGoogleSignIn(clientId) {
 }
 
 // src/composables/useBackgroundTask.ts
-import { ref as ref27, onUnmounted as onUnmounted21 } from "@vue/runtime-core";
+import { ref as ref31, onUnmounted as onUnmounted22 } from "@vue/runtime-core";
 function useBackgroundTask() {
   const taskHandlers = /* @__PURE__ */ new Map();
-  const defaultHandler = ref27(null);
+  const defaultHandler = ref31(null);
   const unsubscribe = NativeBridge.onGlobalEvent("background:taskExecute", (payload) => {
     const handler = taskHandlers.get(payload.taskId) || defaultHandler.value;
     if (handler) {
       handler(payload.taskId);
     }
   });
-  onUnmounted21(unsubscribe);
+  onUnmounted22(unsubscribe);
   function registerTask(taskId) {
     return NativeBridge.invokeNativeModule("BackgroundTask", "registerTask", [taskId]).then(() => void 0);
   }
@@ -3432,20 +4394,28 @@ function useBackgroundTask() {
 }
 
 // src/composables/useOTAUpdate.ts
-import { ref as ref28, onUnmounted as onUnmounted22 } from "@vue/runtime-core";
+import { ref as ref32, onUnmounted as onUnmounted23 } from "@vue/runtime-core";
+function getErrorMessage4(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "object" && error !== null && "message" in error) {
+    const message = error.message;
+    if (typeof message === "string") return message;
+  }
+  return String(error);
+}
 function useOTAUpdate(serverUrl) {
-  const currentVersion = ref28("embedded");
-  const availableVersion = ref28(null);
-  const downloadProgress = ref28(0);
-  const isChecking = ref28(false);
-  const isDownloading = ref28(false);
-  const status = ref28("idle");
-  const error = ref28(null);
+  const currentVersion = ref32("embedded");
+  const availableVersion = ref32(null);
+  const downloadProgress = ref32(0);
+  const isChecking = ref32(false);
+  const isDownloading = ref32(false);
+  const status = ref32("idle");
+  const error = ref32(null);
   let lastUpdateInfo = null;
   const unsubscribe = NativeBridge.onGlobalEvent("ota:downloadProgress", (payload) => {
     downloadProgress.value = payload.progress;
   });
-  onUnmounted22(unsubscribe);
+  onUnmounted23(unsubscribe);
   NativeBridge.invokeNativeModule("OTA", "getCurrentVersion", []).then((info) => {
     currentVersion.value = info.version;
   }).catch(() => {
@@ -3465,7 +4435,7 @@ function useOTAUpdate(serverUrl) {
       status.value = info.updateAvailable ? "idle" : "idle";
       return info;
     } catch (err) {
-      error.value = err?.message || String(err);
+      error.value = getErrorMessage4(err);
       status.value = "error";
       throw err;
     } finally {
@@ -3491,7 +4461,7 @@ function useOTAUpdate(serverUrl) {
     } catch (err) {
       await NativeBridge.invokeNativeModule("OTA", "cleanupPartialDownload", []).catch(() => {
       });
-      error.value = err?.message || String(err);
+      error.value = getErrorMessage4(err);
       status.value = "error";
       throw err;
     } finally {
@@ -3507,7 +4477,7 @@ function useOTAUpdate(serverUrl) {
       await NativeBridge.invokeNativeModule("OTA", "verifyBundle", []);
     } catch (err) {
       status.value = "error";
-      error.value = "Bundle verification failed: " + (err?.message || String(err));
+      error.value = "Bundle verification failed: " + getErrorMessage4(err);
       throw err;
     }
     try {
@@ -3517,7 +4487,7 @@ function useOTAUpdate(serverUrl) {
       availableVersion.value = null;
       status.value = "idle";
     } catch (err) {
-      error.value = err?.message || String(err);
+      error.value = getErrorMessage4(err);
       status.value = "error";
       throw err;
     }
@@ -3530,7 +4500,7 @@ function useOTAUpdate(serverUrl) {
       currentVersion.value = info.version;
       status.value = "idle";
     } catch (err) {
-      error.value = err?.message || String(err);
+      error.value = getErrorMessage4(err);
       status.value = "error";
       throw err;
     }
@@ -3557,13 +4527,21 @@ function useOTAUpdate(serverUrl) {
 }
 
 // src/composables/useBluetooth.ts
-import { ref as ref29, onUnmounted as onUnmounted23 } from "@vue/runtime-core";
+import { ref as ref33, onUnmounted as onUnmounted24 } from "@vue/runtime-core";
+function getErrorMessage5(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "object" && error !== null && "message" in error) {
+    const message = error.message;
+    if (typeof message === "string") return message;
+  }
+  return String(error);
+}
 function useBluetooth() {
-  const devices = ref29([]);
-  const connectedDevice = ref29(null);
-  const isScanning = ref29(false);
-  const isAvailable = ref29(false);
-  const error = ref29(null);
+  const devices = ref33([]);
+  const connectedDevice = ref33(null);
+  const isScanning = ref33(false);
+  const isAvailable = ref33(false);
+  const error = ref33(null);
   const cleanups = [];
   NativeBridge.invokeNativeModule("Bluetooth", "getState").then((state) => {
     isAvailable.value = state === "poweredOn";
@@ -3602,7 +4580,7 @@ function useBluetooth() {
     try {
       await NativeBridge.invokeNativeModule("Bluetooth", "startScan", [serviceUUIDs]);
     } catch (e) {
-      error.value = e?.message || String(e);
+      error.value = getErrorMessage5(e);
       isScanning.value = false;
     }
   }
@@ -3642,7 +4620,7 @@ function useBluetooth() {
       ]);
     };
   }
-  onUnmounted23(() => {
+  onUnmounted24(() => {
     if (isScanning.value) {
       NativeBridge.invokeNativeModule("Bluetooth", "stopScan").catch(() => {
       });
@@ -3667,17 +4645,25 @@ function useBluetooth() {
 }
 
 // src/composables/useCalendar.ts
-import { ref as ref30 } from "@vue/runtime-core";
+import { ref as ref34 } from "@vue/runtime-core";
+function getErrorMessage6(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "object" && error !== null && "message" in error) {
+    const message = error.message;
+    if (typeof message === "string") return message;
+  }
+  return String(error);
+}
 function useCalendar() {
-  const hasAccess = ref30(false);
-  const error = ref30(null);
+  const hasAccess = ref34(false);
+  const error = ref34(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);
+      error.value = getErrorMessage6(e);
       return false;
     }
   }
@@ -3703,17 +4689,25 @@ function useCalendar() {
 }
 
 // src/composables/useContacts.ts
-import { ref as ref31 } from "@vue/runtime-core";
+import { ref as ref35 } from "@vue/runtime-core";
+function getErrorMessage7(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "object" && error !== null && "message" in error) {
+    const message = error.message;
+    if (typeof message === "string") return message;
+  }
+  return String(error);
+}
 function useContacts() {
-  const hasAccess = ref31(false);
-  const error = ref31(null);
+  const hasAccess = ref35(false);
+  const error = ref35(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);
+      error.value = getErrorMessage7(e);
       return false;
     }
   }
@@ -3732,17 +4726,449 @@ function useContacts() {
   return { requestAccess, getContacts, getContact, createContact, deleteContact, hasAccess, error };
 }
 
+// src/composables/useWindow.ts
+function useWindow() {
+  const { isMacOS } = usePlatform();
+  async function setTitle(title) {
+    if (!isMacOS) return;
+    await NativeBridge.invokeNativeModule("Window", "setTitle", [title]);
+  }
+  async function setSize(width, height) {
+    if (!isMacOS) return;
+    await NativeBridge.invokeNativeModule("Window", "setSize", [width, height]);
+  }
+  async function center() {
+    if (!isMacOS) return;
+    await NativeBridge.invokeNativeModule("Window", "center", []);
+  }
+  async function minimize() {
+    if (!isMacOS) return;
+    await NativeBridge.invokeNativeModule("Window", "minimize", []);
+  }
+  async function toggleFullScreen() {
+    if (!isMacOS) return;
+    await NativeBridge.invokeNativeModule("Window", "toggleFullScreen", []);
+  }
+  async function close() {
+    if (!isMacOS) return;
+    await NativeBridge.invokeNativeModule("Window", "close", []);
+  }
+  async function getInfo() {
+    if (!isMacOS) return null;
+    return await NativeBridge.invokeNativeModule("Window", "getInfo", []);
+  }
+  return { setTitle, setSize, center, minimize, toggleFullScreen, close, getInfo };
+}
+
+// src/composables/useMenu.ts
+function useMenu() {
+  const { isMacOS } = usePlatform();
+  async function setAppMenu(sections) {
+    if (!isMacOS) return;
+    await NativeBridge.invokeNativeModule("Menu", "setAppMenu", [sections]);
+  }
+  async function showContextMenu(items) {
+    if (!isMacOS) return;
+    await NativeBridge.invokeNativeModule("Menu", "showContextMenu", [items]);
+  }
+  function onMenuItemClick(callback) {
+    if (!isMacOS) return () => {
+    };
+    return NativeBridge.onGlobalEvent("menu:itemClick", (payload) => {
+      callback(payload.id ?? "", payload.title ?? "");
+    });
+  }
+  return { setAppMenu, showContextMenu, onMenuItemClick };
+}
+
+// src/composables/useFileDialog.ts
+function useFileDialog() {
+  const { isMacOS } = usePlatform();
+  async function openFile(options) {
+    if (!isMacOS) return null;
+    return await NativeBridge.invokeNativeModule("FileDialog", "openFile", [options || {}]);
+  }
+  async function openDirectory(options) {
+    if (!isMacOS) return null;
+    return await NativeBridge.invokeNativeModule("FileDialog", "openDirectory", [options || {}]);
+  }
+  async function saveFile(options) {
+    if (!isMacOS) return null;
+    return await NativeBridge.invokeNativeModule("FileDialog", "saveFile", [options || {}]);
+  }
+  return { openFile, openDirectory, saveFile };
+}
+
+// src/composables/useDragDrop.ts
+import { ref as ref36, readonly } from "@vue/runtime-core";
+function useDragDrop() {
+  const { isMacOS } = usePlatform();
+  const isDragging = ref36(false);
+  async function enableDropZone() {
+    if (!isMacOS) return;
+    await NativeBridge.invokeNativeModule("DragDrop", "enableDropZone", []);
+  }
+  function onDrop(callback) {
+    if (!isMacOS) return () => {
+    };
+    return NativeBridge.onGlobalEvent("dragdrop:drop", (payload) => {
+      const files = Array.isArray(payload.files) ? payload.files.filter((file) => typeof file === "string") : [];
+      callback(files);
+    });
+  }
+  function onDragEnter(callback) {
+    if (!isMacOS) return () => {
+    };
+    return NativeBridge.onGlobalEvent("dragdrop:enter", () => {
+      isDragging.value = true;
+      callback();
+    });
+  }
+  function onDragLeave(callback) {
+    if (!isMacOS) return () => {
+    };
+    return NativeBridge.onGlobalEvent("dragdrop:leave", () => {
+      isDragging.value = false;
+      callback();
+    });
+  }
+  return { enableDropZone, onDrop, onDragEnter, onDragLeave, isDragging: readonly(isDragging) };
+}
+
+// src/composables/useTeleport.ts
+function useTeleport(target) {
+  const teleport = (node) => {
+    NativeBridge.teleportTo(target, node.id);
+  };
+  return { teleport };
+}
+
+// src/composables/useGesture.ts
+import { ref as ref37, onUnmounted as onUnmounted25 } from "@vue/runtime-core";
+function hasViewId2(value) {
+  return typeof value === "object" && value !== null && "id" in value && typeof value.id === "number";
+}
+function isGestureRef(target) {
+  return typeof target === "object" && target !== null && "value" in target;
+}
+function resolveViewId2(target) {
+  if (typeof target === "number") return target;
+  if (isGestureRef(target)) {
+    const val = target.value;
+    if (hasViewId2(val)) return val.id;
+    throw new Error("[useGesture] Target ref has no .value.id \u2014 is the ref attached to a component?");
+  }
+  if (hasViewId2(target)) return target.id;
+  throw new Error("[useGesture] Invalid target. Pass a number, template ref, or NativeNode.");
+}
+var GestureManager = class {
+  constructor() {
+    this.nodeId = null;
+    this.handlers = /* @__PURE__ */ new Map();
+    this.disposables = [];
+  }
+  attach(target) {
+    this.nodeId = resolveViewId2(target);
+  }
+  on(event, callback, config) {
+    if (!this.nodeId) {
+      console.warn("[useGesture] Cannot add listener: not attached to a view. Call attach() first or use a ref.");
+      return () => {
+      };
+    }
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(event).add(callback);
+    NativeBridge.addEventListener(this.nodeId, event, (payload) => {
+      if (config?.enabled === false) return;
+      callback(payload);
+    });
+    const dispose = () => {
+      this.handlers.get(event)?.delete(callback);
+      if (this.nodeId) {
+        NativeBridge.removeEventListener(this.nodeId, event);
+      }
+    };
+    this.disposables.push(dispose);
+    return dispose;
+  }
+  detach() {
+    for (const dispose of this.disposables) {
+      dispose();
+    }
+    this.disposables = [];
+    this.handlers.clear();
+    this.nodeId = null;
+  }
+};
+function useGesture(target, options = {}) {
+  const pan = ref37(null);
+  const pinch = ref37(null);
+  const rotate = ref37(null);
+  const swipeLeft = ref37(null);
+  const swipeRight = ref37(null);
+  const swipeUp = ref37(null);
+  const swipeDown = ref37(null);
+  const press = ref37(null);
+  const longPress = ref37(null);
+  const doubleTap = ref37(null);
+  const forceTouch = ref37(null);
+  const hover = ref37(null);
+  const gestureState = ref37(null);
+  const activeGesture = ref37(null);
+  const isGesturing = ref37(false);
+  const manager = new GestureManager();
+  const cleanupFns = [];
+  function attach(t) {
+    manager.attach(t);
+    setupListeners();
+  }
+  function detach() {
+    for (const fn of cleanupFns) fn();
+    cleanupFns.length = 0;
+    manager.detach();
+    pan.value = null;
+    pinch.value = null;
+    rotate.value = null;
+    swipeLeft.value = null;
+    swipeRight.value = null;
+    swipeUp.value = null;
+    swipeDown.value = null;
+    press.value = null;
+    longPress.value = null;
+    doubleTap.value = null;
+    forceTouch.value = null;
+    hover.value = null;
+    gestureState.value = null;
+    activeGesture.value = null;
+    isGesturing.value = false;
+  }
+  function normalizeConfig(opt) {
+    return typeof opt === "boolean" ? { enabled: opt } : opt ?? {};
+  }
+  function on(event, callback) {
+    return manager.on(event, callback);
+  }
+  function setupListeners() {
+    if (options.pan) {
+      const cfg = normalizeConfig(options.pan);
+      const dispose = manager.on("pan", (state) => {
+        pan.value = state;
+        gestureState.value = state;
+        activeGesture.value = "pan";
+        isGesturing.value = state.state === "began" || state.state === "changed";
+      }, cfg);
+      cleanupFns.push(dispose);
+    }
+    if (options.pinch) {
+      const cfg = normalizeConfig(options.pinch);
+      const dispose = manager.on("pinch", (state) => {
+        pinch.value = state;
+        gestureState.value = state;
+        activeGesture.value = "pinch";
+        isGesturing.value = state.state === "began" || state.state === "changed";
+      }, cfg);
+      cleanupFns.push(dispose);
+    }
+    if (options.rotate) {
+      const cfg = normalizeConfig(options.rotate);
+      const dispose = manager.on("rotate", (state) => {
+        rotate.value = state;
+        gestureState.value = state;
+        activeGesture.value = "rotate";
+        isGesturing.value = state.state === "began" || state.state === "changed";
+      }, cfg);
+      cleanupFns.push(dispose);
+    }
+    if (options.swipeLeft) {
+      const cfg = normalizeConfig(options.swipeLeft);
+      const dispose = manager.on("swipeLeft", (state) => {
+        swipeLeft.value = state;
+        gestureState.value = state;
+        activeGesture.value = "swipeLeft";
+        isGesturing.value = false;
+      }, cfg);
+      cleanupFns.push(dispose);
+    }
+    if (options.swipeRight) {
+      const cfg = normalizeConfig(options.swipeRight);
+      const dispose = manager.on("swipeRight", (state) => {
+        swipeRight.value = state;
+        gestureState.value = state;
+        activeGesture.value = "swipeRight";
+        isGesturing.value = false;
+      }, cfg);
+      cleanupFns.push(dispose);
+    }
+    if (options.swipeUp) {
+      const cfg = normalizeConfig(options.swipeUp);
+      const dispose = manager.on("swipeUp", (state) => {
+        swipeUp.value = state;
+        gestureState.value = state;
+        activeGesture.value = "swipeUp";
+        isGesturing.value = false;
+      }, cfg);
+      cleanupFns.push(dispose);
+    }
+    if (options.swipeDown) {
+      const cfg = normalizeConfig(options.swipeDown);
+      const dispose = manager.on("swipeDown", (state) => {
+        swipeDown.value = state;
+        gestureState.value = state;
+        activeGesture.value = "swipeDown";
+        isGesturing.value = false;
+      }, cfg);
+      cleanupFns.push(dispose);
+    }
+    if (options.press) {
+      const cfg = normalizeConfig(options.press);
+      const dispose = manager.on("press", (state) => {
+        press.value = state;
+        gestureState.value = state;
+        activeGesture.value = "press";
+        isGesturing.value = false;
+      }, cfg);
+      cleanupFns.push(dispose);
+    }
+    if (options.longPress) {
+      const cfg = normalizeConfig(options.longPress);
+      const dispose = manager.on("longPress", (state) => {
+        longPress.value = state;
+        gestureState.value = state;
+        activeGesture.value = "longPress";
+        isGesturing.value = false;
+      }, cfg);
+      cleanupFns.push(dispose);
+    }
+    if (options.doubleTap) {
+      const cfg = normalizeConfig(options.doubleTap);
+      const dispose = manager.on("doubleTap", (state) => {
+        doubleTap.value = state;
+        gestureState.value = state;
+        activeGesture.value = "doubleTap";
+        isGesturing.value = false;
+      }, cfg);
+      cleanupFns.push(dispose);
+    }
+    if (options.forceTouch) {
+      const cfg = normalizeConfig(options.forceTouch);
+      const dispose = manager.on("forceTouch", (state) => {
+        forceTouch.value = state;
+        gestureState.value = state;
+        activeGesture.value = "forceTouch";
+        isGesturing.value = state.stage > 0;
+      }, cfg);
+      cleanupFns.push(dispose);
+    }
+    if (options.hover) {
+      const cfg = normalizeConfig(options.hover);
+      const dispose = manager.on("hover", (state) => {
+        hover.value = state;
+        gestureState.value = state;
+        activeGesture.value = "hover";
+        isGesturing.value = state.state !== "exited";
+      }, cfg);
+      cleanupFns.push(dispose);
+    }
+  }
+  onUnmounted25(() => {
+    detach();
+  });
+  if (target !== void 0) {
+    attach(target);
+  }
+  return {
+    pan,
+    pinch,
+    rotate,
+    swipeLeft,
+    swipeRight,
+    swipeUp,
+    swipeDown,
+    press,
+    longPress,
+    doubleTap,
+    forceTouch,
+    hover,
+    gestureState,
+    activeGesture,
+    isGesturing,
+    attach,
+    detach,
+    on
+  };
+}
+function useComposedGestures(target, options = {}) {
+  const pan = ref37(null);
+  const pinch = ref37(null);
+  const rotate = ref37(null);
+  const gestureState = ref37(null);
+  const activeGesture = ref37(null);
+  const isGesturing = ref37(false);
+  const isPinchingAndRotating = ref37(false);
+  const isPanningAndPinching = ref37(false);
+  const manager = new GestureManager();
+  manager.attach(target);
+  const panConfig = typeof options.pan === "object" ? options.pan : {};
+  const pinchConfig = typeof options.pinch === "object" ? options.pinch : {};
+  const rotateConfig = typeof options.rotate === "object" ? options.rotate : {};
+  const cleanupFns = [];
+  if (options.pan !== false) {
+    cleanupFns.push(manager.on("pan", (state) => {
+      pan.value = state;
+      gestureState.value = state;
+      activeGesture.value = "pan";
+      isGesturing.value = state.state === "began" || state.state === "changed";
+      isPanningAndPinching.value = pinch.value !== null && (state.state === "began" || state.state === "changed");
+    }, panConfig));
+  }
+  if (options.pinch !== false) {
+    cleanupFns.push(manager.on("pinch", (state) => {
+      pinch.value = state;
+      gestureState.value = state;
+      activeGesture.value = "pinch";
+      isGesturing.value = state.state === "began" || state.state === "changed";
+      isPinchingAndRotating.value = rotate.value !== null && (state.state === "began" || state.state === "changed");
+      isPanningAndPinching.value = pan.value !== null && (state.state === "began" || state.state === "changed");
+    }, pinchConfig));
+  }
+  if (options.rotate !== false) {
+    cleanupFns.push(manager.on("rotate", (state) => {
+      rotate.value = state;
+      gestureState.value = state;
+      activeGesture.value = "rotate";
+      isGesturing.value = state.state === "began" || state.state === "changed";
+      isPinchingAndRotating.value = pinch.value !== null && (state.state === "began" || state.state === "changed");
+    }, rotateConfig));
+  }
+  onUnmounted25(() => {
+    for (const fn of cleanupFns) fn();
+    manager.detach();
+  });
+  return {
+    pan,
+    pinch,
+    rotate,
+    gestureState,
+    activeGesture,
+    isGesturing,
+    isPinchingAndRotating,
+    isPanningAndPinching
+  };
+}
+
 // src/theme.ts
 import {
-  inject,
-  provide,
+  inject as inject3,
+  provide as provide3,
   computed as computed3,
-  defineComponent as defineComponent30,
-  ref as ref32
+  defineComponent as defineComponent35,
+  ref as ref38
 } from "@vue/runtime-core";
 function createTheme(definition) {
   const key = /* @__PURE__ */ Symbol("vue-native-theme");
-  const ThemeProvider = defineComponent30({
+  const ThemeProvider = defineComponent35({
     name: "ThemeProvider",
     props: {
       initialColorScheme: {
@@ -3751,7 +5177,7 @@ function createTheme(definition) {
       }
     },
     setup(props, { slots }) {
-      const colorScheme = ref32(props.initialColorScheme);
+      const colorScheme = ref38(props.initialColorScheme);
       const theme = computed3(() => {
         return colorScheme.value === "dark" ? definition.dark : definition.light;
       });
@@ -3765,12 +5191,12 @@ function createTheme(definition) {
           colorScheme.value = scheme;
         }
       };
-      provide(key, ctx);
+      provide3(key, ctx);
       return () => slots.default?.();
     }
   });
   function useTheme() {
-    const ctx = inject(key);
+    const ctx = inject3(key);
     if (!ctx) {
       throw new Error(
         "[Vue Native] useTheme() was called outside of a <ThemeProvider>. Wrap your app root with <ThemeProvider> to provide theme context."
@@ -3787,37 +5213,13 @@ function createDynamicStyleSheet(theme, factory) {
 // src/index.ts
 function createApp(rootComponent, rootProps) {
   const app = baseCreateApp(rootComponent, rootProps);
-  app.component("VView", VView);
-  app.component("VText", VText);
-  app.component("VButton", VButton);
-  app.component("VInput", VInput);
-  app.component("VSwitch", VSwitch);
-  app.component("VActivityIndicator", VActivityIndicator);
-  app.component("VScrollView", VScrollView);
-  app.component("VImage", VImage);
-  app.component("VKeyboardAvoiding", VKeyboardAvoiding);
-  app.component("VSafeArea", VSafeArea);
-  app.component("VSlider", VSlider);
-  app.component("VList", VList);
-  app.component("VModal", VModal);
-  app.component("VAlertDialog", VAlertDialog);
-  app.component("VStatusBar", VStatusBar);
-  app.component("VWebView", VWebView);
-  app.component("VProgressBar", VProgressBar);
-  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("VFlatList", VFlatList);
+  for (const [name, component] of Object.entries(builtInComponents)) {
+    app.component(name, component);
+  }
+  app.component("VDrawer.Item", VDrawerItem);
+  app.component("VDrawer.Section", VDrawerSection);
   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));
     const componentName = instance?.$options?.name || instance?.$.type?.name || "Anonymous";
@@ -3858,6 +5260,9 @@ export {
   VAlertDialog,
   VButton,
   VCheckbox,
+  VDrawer,
+  VDrawerItem,
+  VDrawerSection,
   VDropdown,
   VFlatList,
   VImage,
@@ -3877,10 +5282,12 @@ export {
   VSlider,
   VStatusBar,
   VSwitch,
+  VTabBar,
   VText,
   VVideo,
   VView,
   VWebView,
+  builtInComponents,
   clearSharedElementRegistry,
   createApp,
   createCommentNode,
@@ -3908,12 +5315,16 @@ export {
   useCamera,
   useClipboard,
   useColorScheme,
+  useComposedGestures,
   useContacts,
   useDatabase,
   useDeviceInfo,
   useDimensions,
+  useDragDrop,
+  useFileDialog,
   useFileSystem,
   useGeolocation,
+  useGesture,
   useGoogleSignIn,
   useGyroscope,
   useHaptics,
@@ -3922,6 +5333,7 @@ export {
   useIAP,
   useKeyboard,
   useLinking,
+  useMenu,
   useNetwork,
   useNotifications,
   useOTAUpdate,
@@ -3931,7 +5343,10 @@ export {
   useSecureStorage,
   useShare,
   useSharedElementTransition,
+  useTeleport,
   useWebSocket,
+  useWindow,
+  vModel,
   vShow,
   validStyleProperties
 };