@thelacanians/vue-native-runtime 0.4.14 → 0.6.0

package/dist/index.js

@@ -8,16 +8,25 @@ import { createRenderer } from "@vue/runtime-core";
 import { markRaw } from "@vue/reactivity";
 var nextNodeId = 1;
 var MAX_NODE_ID = 2147483647;
+var activeNodeIds = /* @__PURE__ */ new Set();
 function resetNodeId() {
   nextNodeId = 1;
+  activeNodeIds.clear();
+}
+function releaseNodeId(id) {
+  activeNodeIds.delete(id);
 }
 function getNextNodeId() {
   const id = nextNodeId;
   if (nextNodeId >= MAX_NODE_ID) {
     nextNodeId = 1;
+    while (activeNodeIds.has(nextNodeId) && nextNodeId < MAX_NODE_ID) {
+      nextNodeId++;
+    }
   } else {
     nextNodeId++;
   }
+  activeNodeIds.add(id);
   return id;
 }
 function createNativeNode(type) {
@@ -56,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 */
@@ -97,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);
@@ -177,6 +187,16 @@ var _NativeBridgeImpl = class _NativeBridgeImpl {
   updateStyle(nodeId, key, value) {
     this.enqueue("updateStyle", [nodeId, { [key]: value }]);
   }
+  /**
+   * Update multiple style properties on a native view in a single bridge op.
+   * Swift/Kotlin handler: handleUpdateStyle(args: [nodeId, { key1: val1, key2: val2, ... }])
+   *
+   * More efficient than calling updateStyle() per property — sends one op
+   * instead of N ops, reducing JSON overhead and bridge dispatch.
+   */
+  updateStyles(nodeId, styles) {
+    this.enqueue("updateStyle", [nodeId, styles]);
+  }
   // ---------------------------------------------------------------------------
   // Tree mutations
   // ---------------------------------------------------------------------------
@@ -264,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;
@@ -291,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]);
     });
   }
@@ -323,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
   // ---------------------------------------------------------------------------
@@ -343,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 {
@@ -351,9 +399,9 @@ var _NativeBridgeImpl = class _NativeBridgeImpl {
     }
     const handlers = this.globalEventHandlers.get(eventName);
     if (handlers) {
-      handlers.forEach((h28) => {
+      handlers.forEach((h33) => {
         try {
-          h28(payload);
+          h33(payload);
         } catch (err) {
           console.error(`[VueNative] Error in global event handler "${eventName}":`, err);
         }
@@ -370,6 +418,9 @@ var _NativeBridgeImpl = class _NativeBridgeImpl {
     this.pendingOps = [];
     this.flushScheduled = false;
     this.eventHandlers.clear();
+    for (const pending of this.pendingCallbacks.values()) {
+      clearTimeout(pending.timeoutId);
+    }
     this.pendingCallbacks.clear();
     this.nextCallbackId = 1;
     this.globalEventHandlers.clear();
@@ -380,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();
 };
@@ -397,20 +447,30 @@ 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) {
       if (next[key] !== prev[key]) {
-        NativeBridge.updateStyle(nodeId, key, next[key]);
+        changes[key] = next[key];
+        hasChanges = true;
       }
     }
     for (const key in prev) {
       if (!(key in next)) {
-        NativeBridge.updateStyle(nodeId, key, null);
+        changes[key] = null;
+        hasChanges = true;
       }
     }
+    if (hasChanges) {
+      NativeBridge.updateStyles(nodeId, changes);
+    }
   } catch (err) {
     console.error(`[VueNative] Error patching style on node ${nodeId}:`, err);
   }
@@ -471,7 +531,7 @@ var nodeOps = {
         if (prevValue) {
           NativeBridge.removeEventListener(el.id, eventName);
         }
-        if (nextValue) {
+        if (isEventHandler(nextValue)) {
           NativeBridge.addEventListener(el.id, eventName, nextValue);
         }
         return;
@@ -547,6 +607,7 @@ var nodeOps = {
       } catch (err) {
         console.error(`[VueNative] Error removing node ${child.id}:`, err);
       }
+      releaseNodeId(child.id);
     }
   },
   /**
@@ -564,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) {
@@ -652,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: {
@@ -699,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);
@@ -765,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);
     };
@@ -929,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(
@@ -1005,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: {
@@ -1045,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 ?? [];
@@ -1097,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",
         {
@@ -1200,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)
       });
     };
   }
@@ -1251,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)
     });
   }
 });
@@ -1562,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);
     };
@@ -1582,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: {
@@ -1604,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);
     };
@@ -1622,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: {
@@ -1648,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);
     };
@@ -1690,85 +1841,1042 @@ 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/directives/vShow.ts
-var vShow = {
-  beforeMount(el, { value }) {
-    NativeBridge.updateProp(el.id, "hidden", !value);
+// 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: {
+    /** Array of data items to render. */
+    data: {
+      type: Array,
+      required: true
+    },
+    /**
+     * Render function for each item. Receives { item, index } and returns a VNode.
+     * If not provided, the `#item` slot is used instead.
+     */
+    renderItem: {
+      type: Function,
+      default: void 0
+    },
+    /** Extract a unique key from each item. Defaults to item.id, item.key, or index. */
+    keyExtractor: {
+      type: Function,
+      default: getDefaultItemKey
+    },
+    /** Fixed height for each item in points. Required for virtualization math. */
+    itemHeight: {
+      type: Number,
+      required: true
+    },
+    /**
+     * Number of viewport-heights to render above and below the visible area.
+     * Higher values reduce blank flashes during fast scrolling but use more memory.
+     * Default: 3 (3 viewports above + 3 below = 7 total viewports of items).
+     */
+    windowSize: {
+      type: Number,
+      default: 3
+    },
+    /** Style for the outer scroll container. */
+    style: {
+      type: Object,
+      default: () => ({})
+    },
+    /** Show vertical scroll indicator. Default: true */
+    showsScrollIndicator: {
+      type: Boolean,
+      default: true
+    },
+    /** Enable bounce at scroll boundaries. Default: true */
+    bounces: {
+      type: Boolean,
+      default: true
+    },
+    /** Height of the header slot in points. Used to offset items below the header. */
+    headerHeight: {
+      type: Number,
+      default: 0
+    },
+    /**
+     * How far from the end (in viewport fractions) to trigger endReached.
+     * Default: 0.5 (trigger when within 50% of a viewport from the bottom).
+     */
+    endReachedThreshold: {
+      type: Number,
+      default: 0.5
+    }
   },
-  updated(el, { value, oldValue }) {
-    if (value === oldValue) return;
-    NativeBridge.updateProp(el.id, "hidden", !value);
+  emits: ["scroll", "endReached"],
+  setup(props, { slots, emit }) {
+    const scrollOffset = ref5(0);
+    const viewportHeight = ref5(0);
+    let endReachedFired = false;
+    const hasHeader = computed2(() => !!slots.header);
+    const totalHeight = computed2(() => {
+      const itemsHeight = (props.data?.length ?? 0) * props.itemHeight;
+      return itemsHeight + (hasHeader.value ? props.headerHeight : 0);
+    });
+    const visibleRange = computed2(() => {
+      const vh = viewportHeight.value || props.itemHeight * 20;
+      const buffer = vh * props.windowSize;
+      const startPx = Math.max(0, scrollOffset.value - buffer);
+      const endPx = scrollOffset.value + vh + buffer;
+      const startIdx = Math.floor(startPx / props.itemHeight);
+      const endIdx = Math.min(
+        Math.ceil(endPx / props.itemHeight),
+        props.data?.length ?? 0
+      );
+      return { start: startIdx, end: endIdx };
+    });
+    function onScroll(event) {
+      scrollOffset.value = event.y ?? 0;
+      if (event.layoutHeight && event.layoutHeight > 0) {
+        viewportHeight.value = event.layoutHeight;
+      }
+      emit("scroll", event);
+      const contentLength = totalHeight.value;
+      const offset = scrollOffset.value;
+      const vh = viewportHeight.value || props.itemHeight * 20;
+      const distanceFromEnd = contentLength - vh - offset;
+      const threshold = vh * props.endReachedThreshold;
+      if (distanceFromEnd < threshold && !endReachedFired) {
+        endReachedFired = true;
+        emit("endReached");
+      } else if (distanceFromEnd >= threshold) {
+        endReachedFired = false;
+      }
+    }
+    return () => {
+      const items = props.data ?? [];
+      const { start, end } = visibleRange.value;
+      const children = [];
+      for (let i = start; i < end; i++) {
+        const item = items[i];
+        if (item === void 0) continue;
+        const key = props.keyExtractor(item, i);
+        const itemContent = props.renderItem ? [props.renderItem({ item, index: i })] : slots.item?.({ item, index: i }) ?? [];
+        children.push(
+          h28(
+            "VView",
+            {
+              key,
+              style: {
+                position: "absolute",
+                top: (hasHeader.value ? props.headerHeight : 0) + i * props.itemHeight,
+                left: 0,
+                right: 0,
+                height: props.itemHeight
+              }
+            },
+            itemContent
+          )
+        );
+      }
+      if (slots.header) {
+        children.unshift(
+          h28("VView", { key: "__vfl_header__", style: { position: "absolute", top: 0, left: 0, right: 0 } }, slots.header())
+        );
+      }
+      if (items.length === 0 && slots.empty) {
+        return h28(
+          "VScrollView",
+          {
+            style: { ...props.style, flex: resolveFlexValue(props.style) },
+            showsVerticalScrollIndicator: props.showsScrollIndicator,
+            bounces: props.bounces
+          },
+          [h28("VView", { style: { flex: 1 } }, slots.empty())]
+        );
+      }
+      const innerContainer = h28(
+        "VView",
+        {
+          key: "__vfl_container__",
+          style: {
+            height: totalHeight.value,
+            width: "100%"
+          }
+        },
+        children
+      );
+      return h28(
+        "VScrollView",
+        {
+          style: { ...props.style, flex: resolveFlexValue(props.style) },
+          showsVerticalScrollIndicator: props.showsScrollIndicator,
+          bounces: props.bounces,
+          onScroll
+        },
+        [innerContainer]
+      );
+    };
   }
-};
+});
 
-// src/errorBoundary.ts
-import { defineComponent as defineComponent28, ref as ref5, watch as watch4, onErrorCaptured } from "@vue/runtime-core";
-var ErrorBoundary = defineComponent28({
-  name: "ErrorBoundary",
+// 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: {
-    onError: Function,
-    resetKeys: {
+    /** Array of tab configurations */
+    tabs: {
       type: Array,
-      default: () => []
+      required: true
+    },
+    /** Currently active tab ID */
+    activeTab: {
+      type: String,
+      required: true
+    },
+    /** Position: 'top' | 'bottom' */
+    position: {
+      type: String,
+      default: "bottom"
     }
   },
-  setup(props, { slots }) {
-    const error = ref5(null);
-    const errorInfo = ref5("");
-    onErrorCaptured((err, _instance, info) => {
-      const normalizedError = err instanceof Error ? err : new Error(String(err));
-      error.value = normalizedError;
-      errorInfo.value = info;
-      if (props.onError) {
-        props.onError(normalizedError, info);
-      }
-      return false;
+  emits: ["change"],
+  setup(props, { emit }) {
+    const activeTab = ref6(props.activeTab);
+    watch4(() => props.activeTab, (newVal) => {
+      activeTab.value = newVal;
     });
-    function reset() {
-      error.value = null;
-      errorInfo.value = "";
+    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
     }
-    watch4(
-      () => props.resetKeys,
-      () => {
-        if (error.value) {
-          reset();
-        }
-      },
-      { deep: 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 (error.value && slots.fallback) {
-        return slots.fallback({ error: error.value, errorInfo: errorInfo.value, reset });
+      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 slots.default?.();
     };
+    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/index.ts
-export * from "@vue/runtime-core";
+// src/components/VTransition.ts
+import { defineComponent as defineComponent31, h as h31, ref as ref8 } from "@vue/runtime-core";
 
-// src/stylesheet.ts
-var validStyleProperties = /* @__PURE__ */ new Set([
-  // Layout (Yoga / Flexbox)
-  "flex",
-  "flexDirection",
-  "flexWrap",
-  "flexGrow",
-  "flexShrink",
-  "flexBasis",
-  "justifyContent",
+// 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 defineComponent34, ref as ref10, watch as watch8, onErrorCaptured } from "@vue/runtime-core";
+var ErrorBoundary = defineComponent34({
+  name: "ErrorBoundary",
+  props: {
+    onError: Function,
+    resetKeys: {
+      type: Array,
+      default: () => []
+    }
+  },
+  setup(props, { slots }) {
+    const error = ref10(null);
+    const errorInfo = ref10("");
+    onErrorCaptured((err, _instance, info) => {
+      const normalizedError = err instanceof Error ? err : new Error(String(err));
+      error.value = normalizedError;
+      errorInfo.value = info;
+      if (props.onError) {
+        props.onError(normalizedError, info);
+      }
+      return false;
+    });
+    function reset() {
+      error.value = null;
+      errorInfo.value = "";
+    }
+    watch8(
+      () => props.resetKeys,
+      () => {
+        if (error.value) {
+          reset();
+        }
+      },
+      { deep: true }
+    );
+    return () => {
+      if (error.value && slots.fallback) {
+        return slots.fallback({ error: error.value, errorInfo: errorInfo.value, reset });
+      }
+      return slots.default?.();
+    };
+  }
+});
+
+// src/index.ts
+export * from "@vue/runtime-core";
+
+// src/stylesheet.ts
+var validStyleProperties = /* @__PURE__ */ new Set([
+  // Layout (Yoga / Flexbox)
+  "flex",
+  "flexDirection",
+  "flexWrap",
+  "flexGrow",
+  "flexShrink",
+  "flexBasis",
+  "justifyContent",
   "alignItems",
   "alignSelf",
   "alignContent",
@@ -1874,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") {
@@ -1932,9 +3107,9 @@ function useAsyncStorage() {
 }
 
 // src/composables/useClipboard.ts
-import { ref as ref6 } from "@vue/runtime-core";
+import { ref as ref11 } from "@vue/runtime-core";
 function useClipboard() {
-  const content = ref6("");
+  const content = ref11("");
   function copy(text) {
     return NativeBridge.invokeNativeModule("Clipboard", "copy", [text]).then(() => void 0);
   }
@@ -1948,16 +3123,16 @@ function useClipboard() {
 }
 
 // src/composables/useDeviceInfo.ts
-import { ref as ref7, onMounted } from "@vue/runtime-core";
+import { ref as ref12, onMounted as onMounted2 } from "@vue/runtime-core";
 function useDeviceInfo() {
-  const model = ref7("");
-  const systemVersion = ref7("");
-  const systemName = ref7("");
-  const name = ref7("");
-  const screenWidth = ref7(0);
-  const screenHeight = ref7(0);
-  const scale = ref7(1);
-  const isLoaded = ref7(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 ?? "";
@@ -1969,7 +3144,7 @@ function useDeviceInfo() {
     scale.value = info.scale ?? 1;
     isLoaded.value = true;
   }
-  onMounted(() => {
+  onMounted2(() => {
     fetchInfo();
   });
   return {
@@ -1986,10 +3161,10 @@ function useDeviceInfo() {
 }
 
 // src/composables/useKeyboard.ts
-import { ref as ref8 } from "@vue/runtime-core";
+import { ref as ref13 } from "@vue/runtime-core";
 function useKeyboard() {
-  const isVisible = ref8(false);
-  const height = ref8(0);
+  const isVisible = ref13(false);
+  const height = ref13(0);
   function dismiss() {
     return NativeBridge.invokeNativeModule("Keyboard", "dismiss", []).then(() => void 0);
   }
@@ -2002,61 +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 useAnimation() {
-  function timing(viewId, toStyles, config = {}) {
-    return NativeBridge.invokeNativeModule("Animation", "timing", [viewId, toStyles, config]);
-  }
-  function spring(viewId, toStyles, config = {}) {
-    return NativeBridge.invokeNativeModule("Animation", "spring", [viewId, toStyles, config]);
-  }
-  function keyframe(viewId, steps, config = {}) {
-    return NativeBridge.invokeNativeModule("Animation", "keyframe", [viewId, steps, config]);
-  }
-  function sequence(animations) {
-    return NativeBridge.invokeNativeModule("Animation", "sequence", [animations]);
-  }
-  function parallel(animations) {
-    return NativeBridge.invokeNativeModule("Animation", "parallel", [animations]);
-  }
-  function fadeOut(viewId, duration = 300) {
-    return timing(viewId, { opacity: 0 }, { duration });
-  }
-  function fadeIn(viewId, duration = 300) {
-    return timing(viewId, { opacity: 1 }, { duration });
-  }
-  function slideInFromRight(viewId, duration = 300) {
-    return timing(viewId, { translateX: 0 }, { duration, easing: "easeOut" });
-  }
-  function slideOutToRight(viewId, duration = 300) {
-    return timing(viewId, { translateX: 400 }, { duration, easing: "easeIn" });
-  }
-  return {
-    timing,
-    spring,
-    keyframe,
-    sequence,
-    parallel,
-    fadeIn,
-    fadeOut,
-    slideInFromRight,
-    slideOutToRight,
-    Easing
-  };
-}
-
 // src/composables/useNetwork.ts
-import { ref as ref9, onUnmounted as onUnmounted3 } from "@vue/runtime-core";
+import { ref as ref14, onUnmounted as onUnmounted4 } from "@vue/runtime-core";
 function useNetwork() {
-  const isConnected = ref9(true);
-  const connectionType = ref9("unknown");
+  const isConnected = ref14(true);
+  const connectionType = ref14("unknown");
   let lastEventTime = 0;
   const unsubscribe = NativeBridge.onGlobalEvent("network:change", (payload) => {
     lastEventTime = Date.now();
@@ -2071,14 +3196,14 @@ function useNetwork() {
     }
   }).catch(() => {
   });
-  onUnmounted3(unsubscribe);
+  onUnmounted4(unsubscribe);
   return { isConnected, connectionType };
 }
 
 // src/composables/useAppState.ts
-import { ref as ref10, onUnmounted as onUnmounted4 } from "@vue/runtime-core";
+import { ref as ref15, onUnmounted as onUnmounted5 } from "@vue/runtime-core";
 function useAppState() {
-  const state = ref10("active");
+  const state = ref15("active");
   NativeBridge.invokeNativeModule("AppState", "getState").then((s) => {
     state.value = s;
   }).catch(() => {
@@ -2086,7 +3211,7 @@ function useAppState() {
   const unsubscribe = NativeBridge.onGlobalEvent("appState:change", (payload) => {
     state.value = payload.state;
   });
-  onUnmounted4(unsubscribe);
+  onUnmounted5(unsubscribe);
   return { state };
 }
 
@@ -2121,10 +3246,10 @@ function usePermissions() {
 }
 
 // src/composables/useGeolocation.ts
-import { ref as ref11, onUnmounted as onUnmounted5 } from "@vue/runtime-core";
+import { ref as ref16, onUnmounted as onUnmounted6 } from "@vue/runtime-core";
 function useGeolocation() {
-  const coords = ref11(null);
-  const error = ref11(null);
+  const coords = ref16(null);
+  const error = ref16(null);
   let watchId = null;
   async function getCurrentPosition() {
     try {
@@ -2149,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);
@@ -2169,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 = {}) {
@@ -2192,7 +3317,7 @@ function useCamera() {
     qrCleanups.push(unsubscribe);
     return unsubscribe;
   }
-  onUnmounted6(() => {
+  onUnmounted7(() => {
     NativeBridge.invokeNativeModule("Camera", "stopQRScan").catch(() => {
     });
     qrCleanups.forEach((fn) => fn());
@@ -2202,10 +3327,10 @@ function useCamera() {
 }
 
 // src/composables/useNotifications.ts
-import { ref as ref12, onUnmounted as onUnmounted7 } from "@vue/runtime-core";
+import { ref as ref17, onUnmounted as onUnmounted8 } from "@vue/runtime-core";
 function useNotifications() {
-  const isGranted = ref12(false);
-  const pushToken = ref12(null);
+  const isGranted = ref17(false);
+  const pushToken = ref17(null);
   async function requestPermission() {
     const granted = await NativeBridge.invokeNativeModule("Notifications", "requestPermission");
     isGranted.value = granted;
@@ -2225,7 +3350,7 @@ function useNotifications() {
   }
   function onNotification(handler) {
     const unsubscribe = NativeBridge.onGlobalEvent("notification:received", handler);
-    onUnmounted7(unsubscribe);
+    onUnmounted8(unsubscribe);
     return unsubscribe;
   }
   async function registerForPush() {
@@ -2239,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 {
@@ -2280,7 +3405,10 @@ function useBiometry() {
 }
 
 // src/composables/useHttp.ts
-import { ref as ref13, 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;
@@ -2290,39 +3418,70 @@ function useHttp(config = {}) {
       NativeBridge.invokeNativeModule("Http", "configurePins", [config.pins]);
     }
   }
-  const loading = ref13(false);
-  const error = ref13(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"]);
+  function parseResponseHeaders(response) {
+    const result = {};
+    if (!response.headers) return result;
+    try {
+      if (typeof response.headers.forEach === "function") {
+        response.headers.forEach((value, key) => {
+          result[key] = value;
+        });
+      } else if (typeof response.headers.entries === "function") {
+        for (const [key, value] of response.headers.entries()) {
+          result[key] = value;
+        }
+      }
+    } catch {
+    }
+    return result;
+  }
   async function request(method, url, options = {}) {
     const fullUrl = config.baseURL ? `${config.baseURL}${url}` : url;
     loading.value = true;
     error.value = null;
+    let controller;
+    let timeoutId;
+    if (config.timeout && config.timeout > 0 && typeof AbortController !== "undefined") {
+      controller = new AbortController();
+      timeoutId = setTimeout(() => controller.abort(), config.timeout);
+    }
     try {
+      const upperMethod = method.toUpperCase();
       const mergedHeaders = {
-        "Content-Type": "application/json",
         ...config.headers ?? {},
         ...options.headers ?? {}
       };
+      if (BODY_METHODS.has(upperMethod) && !mergedHeaders["Content-Type"]) {
+        mergedHeaders["Content-Type"] = "application/json";
+      }
       const fetchOptions = {
-        method: method.toUpperCase(),
+        method: upperMethod,
         headers: mergedHeaders
       };
+      if (controller) {
+        fetchOptions.signal = controller.signal;
+      }
       if (options.body !== void 0) {
         fetchOptions.body = JSON.stringify(options.body);
       }
       const response = await fetch(fullUrl, fetchOptions);
       const data = await response.json();
+      const responseHeaders = parseResponseHeaders(response);
       if (!isMounted) {
-        return { data, status: response.status, ok: response.ok, headers: {} };
+        return { data, status: response.status, ok: response.ok, headers: responseHeaders };
       }
       return {
         data,
         status: response.status,
         ok: response.ok,
-        headers: {}
+        headers: responseHeaders
       };
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
@@ -2331,6 +3490,9 @@ function useHttp(config = {}) {
       }
       throw e;
     } finally {
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+      }
       if (isMounted) {
         loading.value = false;
       }
@@ -2345,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 ref14, onUnmounted as onUnmounted9 } from "@vue/runtime-core";
+import { ref as ref19, onUnmounted as onUnmounted10 } from "@vue/runtime-core";
 function useColorScheme() {
-  const colorScheme = ref14("light");
-  const isDark = ref14(false);
+  const colorScheme = ref19("light");
+  const isDark = ref19(false);
   const unsubscribe = NativeBridge.onGlobalEvent(
     "colorScheme:change",
     (payload) => {
@@ -2376,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) {
@@ -2393,7 +3549,7 @@ function useBackHandler(handler) {
       }
     });
   });
-  onUnmounted10(() => {
+  onUnmounted11(() => {
     unsubscribe?.();
     unsubscribe = null;
   });
@@ -2417,11 +3573,11 @@ function useSecureStorage() {
 }
 
 // src/composables/useI18n.ts
-import { ref as ref15, onMounted as onMounted3 } from "@vue/runtime-core";
+import { ref as ref20, onMounted as onMounted4 } from "@vue/runtime-core";
 function useI18n() {
-  const isRTL = ref15(false);
-  const locale = ref15("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";
@@ -2432,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 ref16, 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 = ref16(0);
-  const height = ref16(0);
-  const scale = ref16(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;
@@ -2460,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 ref17, 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 {
@@ -2475,9 +3623,9 @@ function useWebSocket(url, options = {}) {
     reconnectInterval = 1e3
   } = options;
   const connectionId = `ws_${++connectionCounter}_${Date.now()}`;
-  const status = ref17("CLOSED");
-  const lastMessage = ref17(null);
-  const error = ref17(null);
+  const status = ref22("CLOSED");
+  const lastMessage = ref22(null);
+  const error = ref22(null);
   let reconnectAttempts = 0;
   let reconnectTimer = null;
   const MAX_PENDING_MESSAGES = 100;
@@ -2562,7 +3710,7 @@ function useWebSocket(url, options = {}) {
   if (autoConnect) {
     open();
   }
-  onUnmounted12(() => {
+  onUnmounted13(() => {
     if (reconnectTimer) {
       clearTimeout(reconnectTimer);
     }
@@ -2631,12 +3779,12 @@ function useFileSystem() {
 }
 
 // src/composables/useSensors.ts
-import { ref as ref18, onUnmounted as onUnmounted13 } from "@vue/runtime-core";
+import { ref as ref23, onUnmounted as onUnmounted14 } from "@vue/runtime-core";
 function useAccelerometer(options = {}) {
-  const x = ref18(0);
-  const y = ref18(0);
-  const z = ref18(0);
-  const isAvailable = ref18(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) => {
@@ -2664,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 = ref18(0);
-  const y = ref18(0);
-  const z = ref18(0);
-  const isAvailable = ref18(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) => {
@@ -2701,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 ref19, 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 = ref19(0);
-  const position = ref19(0);
-  const isPlaying = ref19(false);
-  const isRecording = ref19(false);
-  const error = ref19(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;
@@ -2727,7 +3886,7 @@ function useAudio() {
     error.value = payload.message ?? "Unknown audio error";
     isPlaying.value = false;
   });
-  onUnmounted14(() => {
+  onUnmounted15(() => {
     unsubProgress();
     unsubComplete();
     unsubError();
@@ -2740,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;
   }
@@ -2768,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", []);
@@ -2806,9 +3969,9 @@ function useAudio() {
 }
 
 // src/composables/useDatabase.ts
-import { ref as ref20, onUnmounted as onUnmounted15 } from "@vue/runtime-core";
+import { ref as ref25, onUnmounted as onUnmounted16 } from "@vue/runtime-core";
 function useDatabase(name = "default") {
-  const isOpen = ref20(false);
+  const isOpen = ref25(false);
   let opened = false;
   async function ensureOpen() {
     if (opened) return;
@@ -2850,7 +4013,7 @@ function useDatabase(name = "default") {
     opened = false;
     isOpen.value = false;
   }
-  onUnmounted15(() => {
+  onUnmounted16(() => {
     if (opened) {
       NativeBridge.invokeNativeModule("Database", "close", [name]).catch(() => {
       });
@@ -2862,12 +4025,12 @@ function useDatabase(name = "default") {
 }
 
 // src/composables/usePerformance.ts
-import { ref as ref21, onUnmounted as onUnmounted16 } from "@vue/runtime-core";
+import { ref as ref26, onUnmounted as onUnmounted17 } from "@vue/runtime-core";
 function usePerformance() {
-  const isProfiling = ref21(false);
-  const fps = ref21(0);
-  const memoryMB = ref21(0);
-  const bridgeOps = ref21(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;
@@ -2892,7 +4055,7 @@ function usePerformance() {
   async function getMetrics() {
     return NativeBridge.invokeNativeModule("Performance", "getMetrics", []);
   }
-  onUnmounted16(() => {
+  onUnmounted17(() => {
     if (isProfiling.value) {
       NativeBridge.invokeNativeModule("Performance", "stopProfiling", []).catch(() => {
       });
@@ -2915,10 +4078,10 @@ function usePerformance() {
 }
 
 // src/composables/useSharedElementTransition.ts
-import { ref as ref22, 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 = ref22(null);
+  const viewId = ref27(null);
   function register(nativeViewId) {
     viewId.value = nativeViewId;
     sharedElementRegistry.set(elementId, nativeViewId);
@@ -2927,7 +4090,7 @@ function useSharedElementTransition(elementId) {
     viewId.value = null;
     sharedElementRegistry.delete(elementId);
   }
-  onUnmounted17(() => {
+  onUnmounted18(() => {
     unregister();
   });
   return {
@@ -2951,11 +4114,19 @@ function clearSharedElementRegistry() {
 }
 
 // src/composables/useIAP.ts
-import { ref as ref23, 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 = ref23([]);
-  const isReady = ref23(false);
-  const error = ref23(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) {
@@ -2966,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;
@@ -2976,7 +4147,7 @@ function useIAP() {
       products.value = productList;
       return productList;
     } catch (err) {
-      error.value = String(err);
+      error.value = getErrorMessage(err);
       return [];
     }
   }
@@ -2985,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;
     }
   }
@@ -2994,7 +4165,7 @@ function useIAP() {
     try {
       return await NativeBridge.invokeNativeModule("IAP", "restorePurchases");
     } catch (err) {
-      error.value = String(err);
+      error.value = getErrorMessage(err);
       return [];
     }
   }
@@ -3003,7 +4174,7 @@ function useIAP() {
     try {
       return await NativeBridge.invokeNativeModule("IAP", "getActiveSubscriptions");
     } catch (err) {
-      error.value = String(err);
+      error.value = getErrorMessage(err);
       return [];
     }
   }
@@ -3012,7 +4183,7 @@ function useIAP() {
     cleanups.push(unsub);
     return unsub;
   }
-  onUnmounted18(() => {
+  onUnmounted19(() => {
     cleanups.forEach((fn) => fn());
     cleanups.length = 0;
   });
@@ -3029,11 +4200,32 @@ function useIAP() {
 }
 
 // src/composables/useAppleSignIn.ts
-import { ref as ref24, 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 = ref24(null);
-  const isAuthenticated = ref24(false);
-  const error = ref24(null);
+  const user = ref29(null);
+  const isAuthenticated = ref29(false);
+  const error = ref29(null);
   const cleanups = [];
   const unsubscribe = NativeBridge.onGlobalEvent("auth:appleCredentialRevoked", () => {
     user.value = null;
@@ -3041,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(() => {
@@ -3051,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 };
     }
@@ -3068,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;
   });
@@ -3079,15 +4275,37 @@ function useAppleSignIn() {
 }
 
 // src/composables/useGoogleSignIn.ts
-import { ref as ref25, 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 = ref25(null);
-  const isAuthenticated = ref25(false);
-  const error = ref25(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(() => {
@@ -3096,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 };
     }
@@ -3113,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;
   });
@@ -3124,17 +4345,17 @@ function useGoogleSignIn(clientId) {
 }
 
 // src/composables/useBackgroundTask.ts
-import { ref as ref26, 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 = ref26(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);
   }
@@ -3173,20 +4394,28 @@ function useBackgroundTask() {
 }
 
 // src/composables/useOTAUpdate.ts
-import { ref as ref27, 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 = ref27("embedded");
-  const availableVersion = ref27(null);
-  const downloadProgress = ref27(0);
-  const isChecking = ref27(false);
-  const isDownloading = ref27(false);
-  const status = ref27("idle");
-  const error = ref27(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(() => {
@@ -3206,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 {
@@ -3232,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 {
@@ -3248,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 {
@@ -3258,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;
     }
@@ -3271,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;
     }
@@ -3298,13 +4527,21 @@ function useOTAUpdate(serverUrl) {
 }
 
 // src/composables/useBluetooth.ts
-import { ref as ref28, 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 = ref28([]);
-  const connectedDevice = ref28(null);
-  const isScanning = ref28(false);
-  const isAvailable = ref28(false);
-  const error = ref28(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";
@@ -3343,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;
     }
   }
@@ -3383,7 +4620,7 @@ function useBluetooth() {
       ]);
     };
   }
-  onUnmounted23(() => {
+  onUnmounted24(() => {
     if (isScanning.value) {
       NativeBridge.invokeNativeModule("Bluetooth", "stopScan").catch(() => {
       });
@@ -3408,17 +4645,25 @@ function useBluetooth() {
 }
 
 // src/composables/useCalendar.ts
-import { ref as ref29 } 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 = ref29(false);
-  const error = ref29(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;
     }
   }
@@ -3444,17 +4689,25 @@ function useCalendar() {
 }
 
 // src/composables/useContacts.ts
-import { ref as ref30 } 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 = ref30(false);
-  const error = ref30(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;
     }
   }
@@ -3473,39 +4726,500 @@ 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 as inject3,
+  provide as provide3,
+  computed as computed3,
+  defineComponent as defineComponent35,
+  ref as ref38
+} from "@vue/runtime-core";
+function createTheme(definition) {
+  const key = /* @__PURE__ */ Symbol("vue-native-theme");
+  const ThemeProvider = defineComponent35({
+    name: "ThemeProvider",
+    props: {
+      initialColorScheme: {
+        type: String,
+        default: "light"
+      }
+    },
+    setup(props, { slots }) {
+      const colorScheme = ref38(props.initialColorScheme);
+      const theme = computed3(() => {
+        return colorScheme.value === "dark" ? definition.dark : definition.light;
+      });
+      const ctx = {
+        theme,
+        colorScheme,
+        toggleColorScheme: () => {
+          colorScheme.value = colorScheme.value === "light" ? "dark" : "light";
+        },
+        setColorScheme: (scheme) => {
+          colorScheme.value = scheme;
+        }
+      };
+      provide3(key, ctx);
+      return () => slots.default?.();
+    }
+  });
+  function useTheme() {
+    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."
+      );
+    }
+    return ctx;
+  }
+  return { ThemeProvider, useTheme };
+}
+function createDynamicStyleSheet(theme, factory) {
+  return computed3(() => createStyleSheet(factory(theme.value)));
+}
+
 // 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);
+  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";
@@ -3546,7 +5260,11 @@ export {
   VAlertDialog,
   VButton,
   VCheckbox,
+  VDrawer,
+  VDrawerItem,
+  VDrawerSection,
   VDropdown,
+  VFlatList,
   VImage,
   VInput,
   VKeyboardAvoiding,
@@ -3564,16 +5282,20 @@ export {
   VSlider,
   VStatusBar,
   VSwitch,
+  VTabBar,
   VText,
   VVideo,
   VView,
   VWebView,
+  builtInComponents,
   clearSharedElementRegistry,
   createApp,
   createCommentNode,
+  createDynamicStyleSheet,
   createNativeNode,
   createStyleSheet,
   createTextNode,
+  createTheme,
   getRegisteredSharedElements,
   getSharedElementViewId,
   measureViewFrame,
@@ -3593,12 +5315,16 @@ export {
   useCamera,
   useClipboard,
   useColorScheme,
+  useComposedGestures,
   useContacts,
   useDatabase,
   useDeviceInfo,
   useDimensions,
+  useDragDrop,
+  useFileDialog,
   useFileSystem,
   useGeolocation,
+  useGesture,
   useGoogleSignIn,
   useGyroscope,
   useHaptics,
@@ -3607,6 +5333,7 @@ export {
   useIAP,
   useKeyboard,
   useLinking,
+  useMenu,
   useNetwork,
   useNotifications,
   useOTAUpdate,
@@ -3616,7 +5343,10 @@ export {
   useSecureStorage,
   useShare,
   useSharedElementTransition,
+  useTeleport,
   useWebSocket,
+  useWindow,
+  vModel,
   vShow,
   validStyleProperties
 };