@h-ai/capacitor 0.1.0-alpha.67 → 0.1.0-alpha.69

package/dist/index.js

@@ -8,6 +8,7 @@ var en_US_default = {
   capacitor_initFailed: "Capacitor initialization failed",
   capacitor_initInProgress: "Capacitor initialization is already in progress",
   capacitor_notAvailable: "Capacitor is not available in this environment",
+  capacitor_secureStorageClearFailed: "Could not fully clear sign-in credentials from secure storage; retry signing out",
   capacitor_preferencesGetFailed: "Failed to read from Capacitor Preferences",
   capacitor_preferencesSetFailed: "Failed to write to Capacitor Preferences",
   capacitor_preferencesRemoveFailed: "Failed to remove from Capacitor Preferences",
@@ -17,7 +18,29 @@ var en_US_default = {
   capacitor_pushListenFailed: "Failed to listen for push notifications",
   capacitor_cameraFailed: "Failed to access camera",
   capacitor_statusBarFailed: "Failed to configure status bar",
-  capacitor_notInitialized: "Capacitor module is not initialized"
+  capacitor_notInitialized: "Capacitor module is not initialized",
+  capacitor_pushCancelled: "The push operation was cancelled, timed out or the module was closed",
+  capacitor_pushCleanupFailed: "Push listeners could not be fully removed; retry cleanup or close the module"
+};
+
+// messages/ja-JP.json
+var ja_JP_default = {
+  capacitor_initFailed: "Capacitor\u306E\u521D\u671F\u5316\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  capacitor_initInProgress: "Capacitor\u306E\u521D\u671F\u5316\u306F\u65E2\u306B\u5B9F\u884C\u4E2D\u3067\u3059",
+  capacitor_notAvailable: "\u3053\u306E\u74B0\u5883\u3067\u306FCapacitor\u3092\u5229\u7528\u3067\u304D\u307E\u305B\u3093",
+  capacitor_secureStorageClearFailed: "\u5B89\u5168\u306A\u30B9\u30C8\u30EC\u30FC\u30B8\u306E\u30ED\u30B0\u30A4\u30F3\u8A8D\u8A3C\u60C5\u5831\u3092\u5B8C\u5168\u306B\u524A\u9664\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u30ED\u30B0\u30A2\u30A6\u30C8\u3092\u518D\u8A66\u884C\u3057\u3066\u304F\u3060\u3055\u3044",
+  capacitor_preferencesGetFailed: "Capacitor Preferences\u304B\u3089\u306E\u8AAD\u307F\u53D6\u308A\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  capacitor_preferencesSetFailed: "Capacitor Preferences\u3078\u306E\u66F8\u304D\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  capacitor_preferencesRemoveFailed: "Capacitor Preferences\u304B\u3089\u306E\u524A\u9664\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  capacitor_deviceInfoFailed: "\u30C7\u30D0\u30A4\u30B9\u60C5\u5831\u306E\u53D6\u5F97\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  capacitor_appVersionFailed: "\u30A2\u30D7\u30EA\u306E\u30D0\u30FC\u30B8\u30E7\u30F3\u306E\u53D6\u5F97\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  capacitor_pushRegisterFailed: "\u30D7\u30C3\u30B7\u30E5\u901A\u77E5\u306E\u767B\u9332\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  capacitor_pushListenFailed: "\u30D7\u30C3\u30B7\u30E5\u901A\u77E5\u306E\u53D7\u4FE1\u8A2D\u5B9A\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  capacitor_cameraFailed: "\u30AB\u30E1\u30E9\u3078\u306E\u30A2\u30AF\u30BB\u30B9\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  capacitor_statusBarFailed: "\u30B9\u30C6\u30FC\u30BF\u30B9\u30D0\u30FC\u306E\u8A2D\u5B9A\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  capacitor_notInitialized: "Capacitor\u30E2\u30B8\u30E5\u30FC\u30EB\u304C\u521D\u671F\u5316\u3055\u308C\u3066\u3044\u307E\u305B\u3093",
+  capacitor_pushCancelled: "\u30D7\u30C3\u30B7\u30E5\u64CD\u4F5C\u304C\u30AD\u30E3\u30F3\u30BB\u30EB\u3055\u308C\u305F\u304B\u3001\u30BF\u30A4\u30E0\u30A2\u30A6\u30C8\u3057\u305F\u304B\u3001\u30E2\u30B8\u30E5\u30FC\u30EB\u304C\u7D42\u4E86\u3057\u307E\u3057\u305F",
+  capacitor_pushCleanupFailed: "\u30D7\u30C3\u30B7\u30E5\u30EA\u30B9\u30CA\u30FC\u3092\u5B8C\u5168\u306B\u524A\u9664\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u30AF\u30EA\u30FC\u30F3\u30A2\u30C3\u30D7\u3092\u518D\u8A66\u884C\u3059\u308B\u304B\u3001\u30E2\u30B8\u30E5\u30FC\u30EB\u3092\u7D42\u4E86\u3057\u3066\u304F\u3060\u3055\u3044"
 };
 
 // messages/zh-CN.json
@@ -25,6 +48,7 @@ var zh_CN_default = {
   capacitor_initFailed: "Capacitor \u521D\u59CB\u5316\u5931\u8D25",
   capacitor_initInProgress: "Capacitor \u6B63\u5728\u521D\u59CB\u5316\u4E2D",
   capacitor_notAvailable: "\u5F53\u524D\u73AF\u5883\u4E0D\u652F\u6301 Capacitor",
+  capacitor_secureStorageClearFailed: "\u672A\u80FD\u5B8C\u5168\u6E05\u9664\u5B89\u5168\u5B58\u50A8\u4E2D\u7684\u767B\u5F55\u51ED\u636E\uFF0C\u8BF7\u91CD\u8BD5\u9000\u51FA",
   capacitor_preferencesGetFailed: "\u8BFB\u53D6 Capacitor Preferences \u5931\u8D25",
   capacitor_preferencesSetFailed: "\u5199\u5165 Capacitor Preferences \u5931\u8D25",
   capacitor_preferencesRemoveFailed: "\u5220\u9664 Capacitor Preferences \u5931\u8D25",
@@ -34,13 +58,16 @@ var zh_CN_default = {
   capacitor_pushListenFailed: "\u76D1\u542C\u63A8\u9001\u901A\u77E5\u5931\u8D25",
   capacitor_cameraFailed: "\u8BBF\u95EE\u76F8\u673A\u5931\u8D25",
   capacitor_statusBarFailed: "\u914D\u7F6E\u72B6\u6001\u680F\u5931\u8D25",
-  capacitor_notInitialized: "Capacitor \u6A21\u5757\u672A\u521D\u59CB\u5316"
+  capacitor_notInitialized: "Capacitor \u6A21\u5757\u672A\u521D\u59CB\u5316",
+  capacitor_pushCancelled: "\u63A8\u9001\u64CD\u4F5C\u5DF2\u53D6\u6D88\u3001\u8D85\u65F6\u6216\u6A21\u5757\u5DF2\u5173\u95ED",
+  capacitor_pushCleanupFailed: "\u63A8\u9001\u76D1\u542C\u5668\u672A\u5B8C\u5168\u79FB\u9664\uFF0C\u8BF7\u91CD\u8BD5\u6E05\u7406\u6216\u5173\u95ED\u6A21\u5757"
 };
 
 // src/capacitor-i18n.ts
 var capacitorM = core.i18n.createMessageGetter({
   "zh-CN": zh_CN_default,
-  "en-US": en_US_default
+  "en-US": en_US_default,
+  "ja-JP": ja_JP_default
 });
 var CapacitorErrorInfo = {
   INIT_FAILED: "001:500",
@@ -54,6 +81,7 @@ var CapacitorErrorInfo = {
   APP_VERSION_FAILED: "021:500",
   PUSH_REGISTER_FAILED: "030:500",
   PUSH_LISTEN_FAILED: "031:500",
+  PUSH_CLEANUP_FAILED: "032:500",
   CAMERA_FAILED: "040:500",
   STATUS_BAR_FAILED: "050:500"
 };
@@ -138,113 +166,181 @@ async function getAppVersion() {
   }
 }
 var logger = core.logger.child({ module: "capacitor", scope: "push" });
-async function registerPush() {
-  try {
-    const { PushNotifications } = await import('@capacitor/push-notifications');
-    const permResult = await PushNotifications.requestPermissions();
-    if (permResult.receive !== "granted") {
-      return err(
-        HaiCapacitorError.PUSH_REGISTER_FAILED,
-        capacitorM("capacitor_pushRegisterFailed")
-      );
+var activeScopes = /* @__PURE__ */ new Set();
+function createPushScope(options) {
+  let scope;
+  const controller = new AbortController();
+  const handles = /* @__PURE__ */ new Set();
+  const removals = /* @__PURE__ */ new Map();
+  let pending = 0;
+  let closing;
+  let timer;
+  const cancelled = () => new Error(capacitorM("capacitor_pushCancelled"));
+  function releaseIfComplete() {
+    if (controller.signal.aborted && pending === 0 && handles.size === 0)
+      activeScopes.delete(scope);
+  }
+  function remove(handle) {
+    const current = removals.get(handle);
+    if (current)
+      return current;
+    const removal = Promise.resolve().then(() => handle.remove()).then(() => {
+      handles.delete(handle);
+    }).finally(() => {
+      removals.delete(handle);
+      releaseIfComplete();
+    });
+    removals.set(handle, removal);
+    return removal;
+  }
+  function finishSetup() {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
     }
-    const REGISTER_TIMEOUT_MS = 3e4;
-    const token = await new Promise((resolve, reject) => {
-      let settled = false;
-      let listeners = [];
-      let timer;
-      async function cleanup() {
-        if (timer) {
-          clearTimeout(timer);
-        }
-        const removeResults = await Promise.allSettled(listeners.map((listener) => listener.remove()));
-        const rejectedCount = removeResults.filter((result) => result.status === "rejected").length;
-        if (rejectedCount > 0) {
-          logger.warn("Failed to remove push registration listeners", { rejectedCount });
+  }
+  function dispose() {
+    controller.abort();
+    finishSetup();
+    options?.signal?.removeEventListener("abort", onAbort);
+    if (closing)
+      return closing;
+    closing = Promise.allSettled([...handles].map(remove)).then((results) => {
+      releaseIfComplete();
+      if (results.some((result) => result.status === "rejected"))
+        throw new Error(capacitorM("capacitor_pushCleanupFailed"));
+    }).finally(() => {
+      closing = void 0;
+    });
+    return closing;
+  }
+  function onAbort() {
+    void dispose().catch(() => logger.warn("Push listener cleanup failed; retry cleanup or capacitor.close"));
+  }
+  scope = {
+    signal: controller.signal,
+    assertOpen() {
+      if (controller.signal.aborted)
+        throw cancelled();
+    },
+    async attach(add) {
+      scope.assertOpen();
+      pending++;
+      try {
+        const handle = await add();
+        handles.add(handle);
+        if (controller.signal.aborted) {
+          await remove(handle);
+          throw cancelled();
         }
+      } finally {
+        pending--;
+        releaseIfComplete();
       }
-      function settleWith(handler, value) {
-        if (settled)
-          return;
-        settled = true;
-        void cleanup().finally(() => {
-          handler(value);
-        });
+    },
+    async wait(operation) {
+      scope.assertOpen();
+      let interrupt;
+      const aborted = new Promise((_, reject) => {
+        interrupt = () => reject(cancelled());
+        controller.signal.addEventListener("abort", interrupt, { once: true });
+      });
+      try {
+        return await Promise.race([Promise.resolve().then(operation), aborted]);
+      } finally {
+        if (interrupt)
+          controller.signal.removeEventListener("abort", interrupt);
       }
-      timer = setTimeout(() => {
-        settleWith(reject, new Error("Push registration timed out"));
-      }, REGISTER_TIMEOUT_MS);
-      void Promise.all([
-        PushNotifications.addListener("registration", (t) => {
-          settleWith(resolve, t.value);
-        }),
-        PushNotifications.addListener("registrationError", (error) => {
-          settleWith(reject, error instanceof Error ? error : new Error(String(error)));
-        })
-      ]).then(async (attachedListeners) => {
-        listeners = attachedListeners;
-        if (settled)
-          return;
-        await PushNotifications.register();
-      }).catch((error) => {
-        settleWith(reject, error instanceof Error ? error : new Error(String(error)));
+    },
+    finishSetup,
+    dispose
+  };
+  activeScopes.add(scope);
+  timer = setTimeout(onAbort, 3e4);
+  options?.signal?.addEventListener("abort", onAbort, { once: true });
+  if (options?.signal?.aborted)
+    onAbort();
+  return scope;
+}
+async function loadPushPlugin() {
+  const { Capacitor } = await import('@capacitor/core');
+  if (!Capacitor.isNativePlatform())
+    throw new Error(capacitorM("capacitor_notAvailable"));
+  return (await import('@capacitor/push-notifications')).PushNotifications;
+}
+async function closePushListeners() {
+  const results = await Promise.allSettled([...activeScopes].map((scope) => scope.dispose()));
+  return results.some((result) => result.status === "rejected") ? err(HaiCapacitorError.PUSH_CLEANUP_FAILED, capacitorM("capacitor_pushCleanupFailed")) : ok(void 0);
+}
+async function registerPush(options) {
+  const scope = createPushScope(options);
+  try {
+    const token = await scope.wait(async () => {
+      const push = await loadPushPlugin();
+      scope.assertOpen();
+      const permission = await push.requestPermissions();
+      scope.assertOpen();
+      if (permission.receive !== "granted")
+        throw new Error(capacitorM("capacitor_pushRegisterFailed"));
+      let resolveToken;
+      let rejectToken;
+      const tokenResult = new Promise((resolve, reject) => {
+        resolveToken = resolve;
+        rejectToken = reject;
       });
+      const setup = async () => {
+        await scope.attach(() => push.addListener("registration", (result) => {
+          if (!scope.signal.aborted)
+            resolveToken(result.value);
+        }));
+        await scope.attach(() => push.addListener("registrationError", () => {
+          if (!scope.signal.aborted)
+            rejectToken(new Error(capacitorM("capacitor_pushRegisterFailed")));
+        }));
+        scope.assertOpen();
+        await push.register();
+      };
+      return (await Promise.all([setup(), tokenResult]))[1];
     });
+    await scope.dispose();
     return ok({ token });
   } catch (cause) {
-    return err(
-      HaiCapacitorError.PUSH_REGISTER_FAILED,
-      capacitorM("capacitor_pushRegisterFailed"),
-      cause
-    );
+    await scope.dispose().catch(() => logger.warn("Push registration cleanup failed; retry capacitor.close"));
+    return err(HaiCapacitorError.PUSH_REGISTER_FAILED, capacitorM("capacitor_pushRegisterFailed"), cause);
   }
 }
-async function listenPush(callbacks) {
+async function listenPush(callbacks, options) {
+  const scope = createPushScope(options);
   try {
-    const { PushNotifications } = await import('@capacitor/push-notifications');
-    const listeners = [];
-    if (callbacks.onReceived) {
-      const listener = await PushNotifications.addListener(
-        "pushNotificationReceived",
-        (notification) => {
-          callbacks.onReceived?.({
-            id: notification.id,
-            title: notification.title,
-            body: notification.body,
-            data: notification.data
-          });
-        }
-      );
-      listeners.push(listener);
-    }
-    if (callbacks.onActionPerformed) {
-      const listener = await PushNotifications.addListener(
-        "pushNotificationActionPerformed",
-        (action) => {
-          callbacks.onActionPerformed?.({
-            id: action.notification.id,
-            title: action.notification.title,
-            body: action.notification.body,
-            data: action.notification.data
-          });
-        }
-      );
-      listeners.push(listener);
-    }
-    const cleanup = async () => {
-      const removeResults = await Promise.allSettled(listeners.map((listener) => listener.remove()));
-      const rejectedCount = removeResults.filter((result) => result.status === "rejected").length;
-      if (rejectedCount > 0) {
-        logger.warn("Failed to remove push listeners", { rejectedCount });
+    await scope.wait(async () => {
+      const push = await loadPushPlugin();
+      scope.assertOpen();
+      if (callbacks.onReceived) {
+        await scope.attach(() => push.addListener("pushNotificationReceived", (notification) => {
+          if (!scope.signal.aborted)
+            callbacks.onReceived?.({ id: notification.id, title: notification.title, body: notification.body, data: notification.data });
+        }));
+      }
+      if (callbacks.onActionPerformed) {
+        await scope.attach(() => push.addListener("pushNotificationActionPerformed", (action) => {
+          if (!scope.signal.aborted)
+            callbacks.onActionPerformed?.({ id: action.notification.id, title: action.notification.title, body: action.notification.body, data: action.notification.data });
+        }));
+      }
+    });
+    scope.assertOpen();
+    scope.finishSetup();
+    return ok(async () => {
+      try {
+        await scope.dispose();
+        return ok(void 0);
+      } catch (cause) {
+        return err(HaiCapacitorError.PUSH_CLEANUP_FAILED, capacitorM("capacitor_pushCleanupFailed"), cause);
       }
-    };
-    return ok(cleanup);
+    });
   } catch (cause) {
-    return err(
-      HaiCapacitorError.PUSH_LISTEN_FAILED,
-      capacitorM("capacitor_pushListenFailed"),
-      cause
-    );
+    await scope.dispose().catch(() => logger.warn("Push setup cleanup failed; retry capacitor.close"));
+    return err(HaiCapacitorError.PUSH_LISTEN_FAILED, capacitorM("capacitor_pushListenFailed"), cause);
   }
 }
 async function configureStatusBar(config) {
@@ -299,95 +395,74 @@ async function hideStatusBar() {
     );
   }
 }
-var logger2 = core.logger.child({ module: "capacitor", scope: "token-storage" });
 var PREF_ACCESS_TOKEN = "hai_access_token";
 var PREF_REFRESH_TOKEN = "hai_refresh_token";
-var secureStoragePromise = null;
-var secureStorageWarningLogged = false;
-function logSecureStorageUnavailable(reason, error) {
-  if (secureStorageWarningLogged)
-    return;
-  secureStorageWarningLogged = true;
-  logger2.warn("Capacitor secure token storage unavailable; token persistence is disabled", {
-    reason,
-    error
-  });
-}
 async function loadSecureStoragePlugin() {
-  if (!secureStoragePromise) {
-    secureStoragePromise = (async () => {
-      try {
-        const { Capacitor } = await import('@capacitor/core');
-        if (!Capacitor.isNativePlatform()) {
-          logSecureStorageUnavailable("non-native-platform");
-          return null;
-        }
-        const { SecureStorage } = await import('@aparajita/capacitor-secure-storage');
-        return SecureStorage;
-      } catch (error) {
-        logSecureStorageUnavailable("plugin-load-failed", error);
-        return null;
-      }
-    })();
-  }
-  return secureStoragePromise;
+  const { Capacitor } = await import('@capacitor/core');
+  if (!Capacitor.isNativePlatform())
+    throw new Error(capacitorM("capacitor_notAvailable"));
+  const { SecureStorage } = await import('@aparajita/capacitor-secure-storage');
+  return SecureStorage;
 }
 function createCapacitorTokenStorage() {
+  let credentialGeneration = 0;
+  let accessBlocked = false;
+  let refreshBlocked = false;
+  function blockCredentials() {
+    credentialGeneration++;
+    accessBlocked = true;
+    refreshBlocked = true;
+  }
+  async function writeToken(key, token) {
+    const writeGeneration = credentialGeneration;
+    try {
+      const storage = await loadSecureStoragePlugin();
+      await storage.setItem(key, token);
+      if (writeGeneration === credentialGeneration) {
+        if (key === PREF_ACCESS_TOKEN)
+          accessBlocked = false;
+        else
+          refreshBlocked = false;
+      }
+    } catch (error) {
+      if (writeGeneration === credentialGeneration)
+        blockCredentials();
+      throw error;
+    }
+  }
   return {
     async getAccessToken() {
-      try {
-        const storage = await loadSecureStoragePlugin();
-        if (!storage)
-          return null;
-        return await storage.getItem(PREF_ACCESS_TOKEN);
-      } catch (error) {
-        logger2.error("Failed to get access token from secure storage", { error });
+      const readGeneration = credentialGeneration;
+      const storage = await loadSecureStoragePlugin();
+      if (accessBlocked)
         return null;
-      }
+      const token = await storage.getItem(PREF_ACCESS_TOKEN);
+      return accessBlocked || readGeneration !== credentialGeneration ? null : token;
     },
     async getRefreshToken() {
-      try {
-        const storage = await loadSecureStoragePlugin();
-        if (!storage)
-          return null;
-        return await storage.getItem(PREF_REFRESH_TOKEN);
-      } catch (error) {
-        logger2.error("Failed to get refresh token from secure storage", { error });
+      const readGeneration = credentialGeneration;
+      const storage = await loadSecureStoragePlugin();
+      if (refreshBlocked)
         return null;
-      }
+      const token = await storage.getItem(PREF_REFRESH_TOKEN);
+      return refreshBlocked || readGeneration !== credentialGeneration ? null : token;
     },
     async setAccessToken(token) {
-      try {
-        const storage = await loadSecureStoragePlugin();
-        if (!storage)
-          return;
-        await storage.setItem(PREF_ACCESS_TOKEN, token);
-      } catch (error) {
-        logger2.error("Failed to set access token in secure storage", { error });
-      }
+      await writeToken(PREF_ACCESS_TOKEN, token);
     },
     async setRefreshToken(token) {
-      try {
-        const storage = await loadSecureStoragePlugin();
-        if (!storage)
-          return;
-        await storage.setItem(PREF_REFRESH_TOKEN, token);
-      } catch (error) {
-        logger2.error("Failed to set refresh token in secure storage", { error });
-      }
+      await writeToken(PREF_REFRESH_TOKEN, token);
     },
     async clear() {
-      try {
-        const storage = await loadSecureStoragePlugin();
-        if (!storage)
-          return;
-        await Promise.all([
-          storage.removeItem(PREF_ACCESS_TOKEN),
-          storage.removeItem(PREF_REFRESH_TOKEN)
-        ]);
-      } catch (error) {
-        logger2.error("Failed to clear tokens from secure storage", { error });
-      }
+      blockCredentials();
+      const storage = await loadSecureStoragePlugin();
+      const results = await Promise.allSettled([
+        storage.removeItem(PREF_ACCESS_TOKEN),
+        storage.removeItem(PREF_REFRESH_TOKEN)
+      ]);
+      const errors = results.filter((result) => result.status === "rejected").map((result) => result.reason);
+      if (errors.length > 0)
+        throw new AggregateError(errors, capacitorM("capacitor_secureStorageClearFailed"));
     }
   };
 }
@@ -429,7 +504,7 @@ async function safeRemovePreference(key) {
 }
 
 // src/capacitor-main.ts
-var logger3 = core.logger.child({ module: "capacitor", scope: "main" });
+var logger2 = core.logger.child({ module: "capacitor", scope: "main" });
 var initialized = false;
 var initInProgress = false;
 var cachedPlatform = null;
@@ -473,7 +548,7 @@ function isCapacitorAvailable() {
 var capacitor = {
   async init() {
     if (initInProgress) {
-      logger3.warn("Capacitor init already in progress, skipping concurrent call");
+      logger2.warn("Capacitor init already in progress, skipping concurrent call");
       return err(
         HaiCapacitorError.INIT_IN_PROGRESS,
         capacitorM("capacitor_initInProgress")
@@ -482,12 +557,17 @@ var capacitor = {
     initInProgress = true;
     try {
       if (initialized) {
-        logger3.warn("Capacitor module is already initialized, reinitializing");
-        await capacitor.close();
+        logger2.warn("Capacitor module is already initialized, reinitializing");
+        const closed = await capacitor.close();
+        if (!closed.success)
+          return closed;
       }
-      logger3.info("Initializing capacitor module");
+      const cleaned = await closePushListeners();
+      if (!cleaned.success)
+        return cleaned;
+      logger2.info("Initializing capacitor module");
       if (!isCapacitorAvailable()) {
-        logger3.error("Capacitor is not available in current environment");
+        logger2.error("Capacitor is not available in current environment");
         return err(
           HaiCapacitorError.NOT_AVAILABLE,
           capacitorM("capacitor_notAvailable")
@@ -496,7 +576,7 @@ var capacitor = {
       const { Capacitor } = await import('@capacitor/core');
       const platform = Capacitor.getPlatform();
       if (!platform) {
-        logger3.error("Capacitor initialization failed, platform not detected");
+        logger2.error("Capacitor initialization failed, platform not detected");
         return err(
           HaiCapacitorError.INIT_FAILED,
           capacitorM("capacitor_initFailed")
@@ -504,10 +584,10 @@ var capacitor = {
       }
       cachedPlatform = platform;
       initialized = true;
-      logger3.info("Capacitor module initialized", { platform });
+      logger2.info("Capacitor module initialized", { platform });
       return ok(void 0);
     } catch (cause) {
-      logger3.error("Capacitor module initialization failed", { error: cause });
+      logger2.error("Capacitor module initialization failed", { error: cause });
       return err(
         HaiCapacitorError.INIT_FAILED,
         capacitorM("capacitor_initFailed"),
@@ -518,14 +598,14 @@ var capacitor = {
     }
   },
   async close() {
-    if (!initialized) {
-      logger3.info("Capacitor module is already closed, skipping");
-      return;
-    }
-    logger3.info("Closing capacitor module");
+    logger2.info("Closing capacitor module");
     initialized = false;
     cachedPlatform = null;
-    logger3.info("Capacitor module closed");
+    const cleaned = await closePushListeners();
+    if (!cleaned.success)
+      return cleaned;
+    logger2.info("Capacitor module closed");
+    return ok(void 0);
   },
   getPlatform() {
     if (cachedPlatform) {