@livx.cc/appwrap 0.30.1 → 0.30.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livx.cc/appwrap",
-  "version": "0.30.1",
+  "version": "0.30.2",
   "description": "Wrap any PWA into a native app with native capabilities (appwrap runtime + @livx.cc/native-kit).",
   "license": "MIT",
   "author": "Elya Livshitz",

package/runtime/app/shell/custom-webview.android.ts

@@ -95,6 +95,12 @@ export class CustomWebView extends WebView {
     /* iOS-only */
   }
 
+  /** iOS-only post-native-surface recovery (see custom-webview.ios.ts). No-op on Android: dismissing a
+   * native screen returns through the normal activity resume, which already restores the WebView. */
+  recoverAfterNativeSurface(): void {
+    /* iOS-only */
+  }
+
   private installDocumentStartShim(wv: android.webkit.WebView): void {
     try {
       const wkt = androidx.webkit;

package/runtime/app/shell/custom-webview.ios.ts

@@ -113,6 +113,56 @@ export class CustomWebView extends WebView {
     );
   }
 
+  /** Call after dismissing ANY native surface presented over the WebView (StoreKit sheet, OAuth
+   * ASWebAuthenticationSession, SFSafariViewController, pickers, share, alerts). Such surfaces can
+   * leave the WebView frozen: a same-scene system sheet doesn't fire resumeEvent AND can orphan an
+   * interactive window above ours that swallows touches. We neutralise any stray window FIRST (so the
+   * wake re-attaches over a clean stack), then wake. Deferred so the dismissal animation finalizes the
+   * orphan window first. Idempotent + safe (no stray ⇒ no-op). No-op on Android. */
+  recoverAfterNativeSurface(): void {
+    setTimeout(() => {
+      try { this.neutralizeStrayWindows(); } catch (e) { /* best-effort */ }
+      this.wakeWebContent();
+    }, 350);
+  }
+
+  /** Remove any window sitting ABOVE our main app window (a leftover system-surface window that can
+   * intercept touches): disable interaction, hide, and detach from the scene. Re-key our main window.
+   * Main = lowest-level non-hidden window with a rootViewController. Logs before/after (debug). */
+  private neutralizeStrayWindows(): void {
+    const dbg = SHELL_CONFIG.debug;
+    const scenes = UIApplication.sharedApplication.connectedScenes.allObjects;
+    for (let i = 0; i < scenes.count; i++) {
+      const scene = scenes.objectAtIndex(i);
+      if (!scene.isKindOfClass(UIWindowScene.class())) continue;
+      const ws = scene as UIWindowScene;
+      const windows = ws.windows;
+      let main: UIWindow | null = null;
+      for (let j = 0; j < windows.count; j++) {
+        const w = windows.objectAtIndex(j);
+        if (w.hidden || !w.rootViewController) continue;
+        if (!main || w.windowLevel < main.windowLevel) main = w;
+      }
+      for (let j = 0; j < windows.count; j++) {
+        const w = windows.objectAtIndex(j);
+        if (main && w !== main && w.windowLevel > 0 && !w.hidden) {
+          if (dbg) appendWebLog(`[native:recover] stray win[${j}] lvl=${w.windowLevel} uie=${w.userInteractionEnabled} key=${w.keyWindow}`);
+          w.userInteractionEnabled = false;
+          w.hidden = true;
+          w.windowScene = null; // detach from the scene — strongest removal
+          if (dbg) appendWebLog(`[native:recover]  after set: hidden=${w.hidden} uie=${w.userInteractionEnabled} scene=${w.windowScene ? 'set' : 'nil'}`);
+        }
+      }
+      if (main) main.makeKeyAndVisible();
+      if (dbg) {
+        let s = '';
+        const after = ws.windows;
+        for (let k = 0; k < after.count; k++) { const w = after.objectAtIndex(k); s += ` [${k}]lvl${w.windowLevel}h${w.hidden}k${w.keyWindow}`; }
+        appendWebLog(`[native:recover] post mainKey=${main ? main.keyWindow : '?'} windows:${s}`);
+      }
+    }
+  }
+
   createNativeView(): WKWebView {
     const config = WKWebViewConfiguration.new();
     config.allowsInlineMediaPlayback = true;

package/runtime/app/shell/custom-webview.ts

@@ -20,4 +20,11 @@ export class CustomWebView extends WebView {
   wakeWebContent(): void {
     /* overridden per-platform */
   }
+
+  /** Call after dismissing ANY native surface presented over the WebView (StoreKit sheet, OAuth,
+   * SFSafariViewController, pickers, share, alerts). iOS: neutralises an orphaned touch-stealing
+   * window the surface may leave + wakes the renderer (see custom-webview.ios.ts). No-op on Android. */
+  recoverAfterNativeSurface(): void {
+    /* overridden per-platform */
+  }
 }

package/runtime/app/shell/handlers-billing.ts

@@ -5,8 +5,7 @@ import { SHELL_CONFIG } from './config';
 
 // @objc Swift shim (AppwrapManageSubscriptions.swift, billing nativeSrc) — no NS types; bridges
 // StoreKit 2's Swift-async showManageSubscriptions(in:) to a completion the ObjC bridge can call.
-// completion(errorMessage, diagnostic): diagnostic is a post-dismiss window-hierarchy dump (DEBUG).
-declare const AppwrapManageSubscriptions: { present(completion: (message: string | null, diagnostic: string | null) => void): void };
+declare const AppwrapManageSubscriptions: { present(completion: (message: string | null) => void): void };
 
 /**
  * In-app purchases — iOS StoreKit 1 (SKPaymentQueue). StoreKit 2 (Product/Transaction)
@@ -217,14 +216,12 @@ export function registerBillingHandlers(): void {
   // deep-link path above is untouched. Rejects on iOS <15, no scene, or a StoreKit error.
   bridge.register('billing.manageSubscriptionsSheet', () => {
     return new Promise<void>((resolve, reject) => {
-      AppwrapManageSubscriptions.present((message: string | null, diagnostic: string | null) => {
-        if (SHELL_CONFIG.debug) appwrapNativeLog(`[native:lifecycle] manageSubscriptionsSheet done err=${message ?? 'none'}\n${diagnostic ?? '(no diag)'}`);
-        // The StoreKit sheet presents/dismisses WITHOUT the app scene leaving foregroundActive, so iOS
-        // never fires resumeEvent → the WebView's normal foreground wake (wakeWebContent) doesn't run.
-        // Drive it explicitly here (the only callback that fires) to un-throttle/repaint the WebView.
-        // (The native shim separately neutralises the orphaned StoreKit tracking-window that otherwise
-        // floats above our window and swallows touches — together they clear the post-sheet freeze.)
-        bridge.getWebView()?.wakeWebContent();
+      AppwrapManageSubscriptions.present((message: string | null) => {
+        if (SHELL_CONFIG.debug) appwrapNativeLog(`[native:lifecycle] manageSubscriptionsSheet done err=${message ?? 'none'}`);
+        // The sheet dismisses WITHOUT the app scene leaving foregroundActive → no resumeEvent, and it
+        // orphans a touch-stealing window above ours. Recover from this completion (the only callback
+        // that fires). Shared across all native surfaces; see CustomWebView.recoverAfterNativeSurface.
+        bridge.getWebView()?.recoverAfterNativeSurface();
         if (message) reject(err('NATIVE_ERROR', message));
         else resolve();
       });

package/runtime/app/shell/handlers-extended.ts

@@ -57,6 +57,8 @@ class PhotoPickerDelegate extends NSObject implements PHPickerViewControllerDele
   }
   pickerDidFinishPicking(picker: PHPickerViewController, results: NSArray<PHPickerResult>): void {
     picker.dismissViewControllerAnimatedCompletion(true, null);
+    // Recover the WebView after the picker dismisses (orphaned-window / renderer-throttle guard).
+    bridge.getWebView()?.recoverAfterNativeSurface();
     const result = results.count > 0 ? results.objectAtIndex(0) : null;
     if (!result) return this.onResult?.({ picked: false });
     result.itemProvider.loadObjectOfClassCompletionHandler(UIImage.class(), (img: UIImage) => {

package/runtime/app/shell/handlers-oauth.ts

@@ -51,6 +51,9 @@ export function registerOAuthHandlers(): void {
             (callbackURL: NSURL, error: NSError) => {
               activeSession = null;
               activeProvider = null;
+              // ASWebAuthenticationSession can leave the WebView frozen on dismiss the same way the
+              // StoreKit sheet does (orphaned tracking window / no resume) — recover from its completion.
+              bridge.getWebView()?.recoverAfterNativeSurface();
               if (error) {
                 // ASWebAuthenticationSessionErrorCodeCanceledLogin === 1 (user dismissed the sheet).
                 const code = error.code === 1 ? 'CANCELLED' : 'NATIVE_ERROR';

package/runtime/app/shell/handlers-system.ts

@@ -5,6 +5,20 @@ declare const androidx: any; // no NS types: androidx
 
 const err = (code: string, message: string) => Object.assign(new Error(message), { code });
 
+// SFSafariViewController is a same-app presented surface — on "Done" it can leave the WebView frozen
+// (orphaned tracking window / throttled renderer), so recover from its didFinish. Strong-ref the
+// delegate while the browser is up (ARC would otherwise free it). Mirrors the OAuth delegate pattern.
+let activeSafariDelegate: NSObject | null = null;
+@NativeClass()
+class SafariDelegate extends NSObject implements SFSafariViewControllerDelegate {
+  static ObjCProtocols = [SFSafariViewControllerDelegate];
+  static new(): SafariDelegate { return <SafariDelegate>super.new(); }
+  safariViewControllerDidFinish(_controller: SFSafariViewController): void {
+    activeSafariDelegate = null;
+    bridge.getWebView()?.recoverAfterNativeSurface();
+  }
+}
+
 /** Running on a simulator/emulator? (mirrors env.ts detection; kept local to avoid a cross-import). */
 function detectEmulator(): boolean {
   if (isIOS) {
@@ -190,6 +204,8 @@ export function registerSystemHandlers(): void {
       Utils.dispatchToMainThread(() => {
         const vc = SFSafariViewController.alloc().initWithURL(NSURL.URLWithString(target));
         if (toolbarColor) vc.preferredControlTintColor = new Color(String(toolbarColor)).ios;
+        activeSafariDelegate = SafariDelegate.new();
+        vc.delegate = activeSafariDelegate as SFSafariViewControllerDelegate;
         Utils.ios.getRootViewController().presentViewControllerAnimatedCompletion(vc, true, null);
       });
     } else if (isAndroid) {

package/runtime/app/shell/handlers.ts

@@ -88,6 +88,9 @@ export function registerHandlers(): void {
       if (controller.popoverPresentationController) {
         controller.popoverPresentationController.sourceView = rootVC.view;
       }
+      // Recover the WebView on dismiss — a presented sheet can orphan a touch-stealing window / leave
+      // the renderer throttled (see CustomWebView.recoverAfterNativeSurface).
+      controller.completionWithItemsHandler = () => { bridge.getWebView()?.recoverAfterNativeSurface(); };
       rootVC.presentViewControllerAnimatedCompletion(controller, true, null);
     } else if (isAndroid) {
       const intent = new android.content.Intent(android.content.Intent.ACTION_SEND);

package/runtime/modules-native/billing/App_Resources/iOS/src/AppwrapManageSubscriptions.swift

@@ -5,87 +5,36 @@ import UIKit
 // StoreKit 2's `AppStore.showManageSubscriptions(in:)` is Swift-only + async, so it can't be reached
 // from the ObjC bridge NativeScript uses. This @objc wrapper bridges the async call to a completion
 // callback (NativeScript can't await Swift async) and runs it on the main actor against the active
-// foreground UIWindowScene. Shipped via the billing module's nativeSrc → compiled into the app target
-// only when `billing` is active. iOS 15+ (StoreKit 2); the JS layer guards the deep-link fallback.
+// foreground UIWindowScene. Shipped via the billing module's nativeSrc → compiled only when `billing`
+// is active. iOS 15+ (StoreKit 2); the JS layer guards the deep-link fallback.
 //
-// THE FREEZE IT FIXES: showManageSubscriptions(in:) presents/dismisses WITHOUT the app scene ever
-// leaving foregroundActive (verified: zero app-lifecycle events fire across present→dismiss), so (a)
-// the OS never fires a resume the WebView could wake on, and (b) the dismissal leaves an orphaned
-// interactive UITrackingElementWindow at windowLevel 1 ABOVE our app window that swallows every touch —
-// the app underneath stays alive but unresponsive ("frozen for minutes" until iOS reaps the window).
-// We recover explicitly from THIS completion (the only thing that fires): after letting the dismissal
-// settle, neutralise any stray above-our-main window (uie=false + hide) and re-key our window. The JS
-// layer additionally drives the WebView's own resume (wakeWebContent) since no native resume arrives.
+// NOTE: this sheet presents/dismisses WITHOUT the app scene leaving foregroundActive, so iOS fires no
+// resumeEvent and leaves an orphaned interactive tracking-window above ours that swallows touches. The
+// JS handler recovers from THIS completion via `CustomWebView.recoverAfterNativeSurface()` (shared with
+// every other native surface) — so this shim only needs to present + report success/failure.
 @objc(AppwrapManageSubscriptions)
 public final class AppwrapManageSubscriptions: NSObject {
-  // completion(error, diagnostic): error nil on success / message on failure; diagnostic is a
-  // before/after window-hierarchy dump (DEBUG aid) the JS layer logs to the file sink. Always on main.
-  @objc public static func present(_ completion: @escaping (String?, String?) -> Void) {
+  // completion(nil) on success; completion(message) on failure. Always invoked on the main thread so
+  // the NS JS continuation (which then drives the WebView recovery) resumes on the UI thread.
+  @objc public static func present(_ completion: @escaping (String?) -> Void) {
     guard #available(iOS 15.0, *) else {
-      completion("StoreKit 2 manage-subscriptions sheet requires iOS 15+", nil)
+      completion("StoreKit 2 manage-subscriptions sheet requires iOS 15+")
       return
     }
     Task { @MainActor in
       guard let scene = AppwrapManageSubscriptions.activeWindowScene() else {
-        completion("No active UIWindowScene to present the subscriptions sheet", nil)
+        completion("No active UIWindowScene to present the subscriptions sheet")
         return
       }
-      var err: String? = nil
       do {
         try await AppStore.showManageSubscriptions(in: scene)
+        completion(nil)
       } catch {
-        err = error.localizedDescription
+        completion(error.localizedDescription)
       }
-      let before = AppwrapManageSubscriptions.dump(scene, tag: "BEFORE")
-      // The await can return before the dismissal animation finishes finalizing the orphan tracking
-      // window — settle first, then neutralise it (hiding at completion-time was too early to stick).
-      try? await Task.sleep(nanoseconds: 350_000_000)
-      let after = AppwrapManageSubscriptions.recover(scene)
-      completion(err, before + "\n" + after)
     }
   }
 
-  // Read-only dump of the scene's windows (+ presented-VC chain, key/interaction flags) for diagnosis.
-  @available(iOS 15.0, *)
-  @MainActor private static func dump(_ scene: UIWindowScene, tag: String) -> String {
-    var lines: [String] = ["\(tag): windows=\(scene.windows.count) keyWin=\(scene.keyWindow.map { ptr($0) } ?? "nil")"]
-    for (i, w) in scene.windows.enumerated() {
-      var presented: [String] = []
-      var vc = w.rootViewController
-      while let p = vc?.presentedViewController { presented.append(String(describing: type(of: p))); vc = p }
-      lines.append("  [\(i)] \(ptr(w)) level=\(w.windowLevel.rawValue) key=\(w.isKeyWindow) hidden=\(w.isHidden) uie=\(w.isUserInteractionEnabled) root=\(w.rootViewController.map { String(describing: type(of: $0)) } ?? "nil") presented=\(presented.isEmpty ? "none" : presented.joined(separator: ">"))")
-    }
-    return lines.joined(separator: "\n")
-  }
-
-  // Neutralise any window sitting ABOVE our main app window (touch-stealer), dismiss a lingering
-  // presented controller, and re-assert our main window as key. Returns the post-recovery dump.
-  @available(iOS 15.0, *)
-  @MainActor private static func recover(_ scene: UIWindowScene) -> String {
-    var lines: [String] = []
-    let main = scene.windows
-      .filter { !$0.isHidden && $0.rootViewController != nil }
-      .min { $0.windowLevel.rawValue < $1.windowLevel.rawValue }
-    for (i, w) in scene.windows.enumerated() {
-      if let presented = w.rootViewController?.presentedViewController {
-        presented.dismiss(animated: false)
-        lines.append("  recover: dismissed \(String(describing: type(of: presented))) on win[\(i)]")
-      }
-      if let m = main, w !== m, w.windowLevel.rawValue >= m.windowLevel.rawValue, w.windowLevel.rawValue > 0 {
-        // Pass touches THROUGH to our app window below, and take it out of the hierarchy.
-        w.isUserInteractionEnabled = false
-        w.isHidden = true
-        lines.append("  recover: neutralised win[\(i)] level=\(w.windowLevel.rawValue) root=\(w.rootViewController.map { String(describing: type(of: $0)) } ?? "nil")")
-      }
-    }
-    if let m = main { m.makeKeyAndVisible(); lines.append("  recover: re-keyed main") }
-    return AppwrapManageSubscriptions.dump(scene, tag: "AFTER-RECOVER") + "\n" + lines.joined(separator: "\n")
-  }
-
-  @MainActor private static func ptr(_ w: UIWindow) -> String {
-    return "UIWindow<\(UInt(bitPattern: ObjectIdentifier(w).hashValue) & 0xffffff)>"
-  }
-
   // The foreground-active window scene (the one allowed to present UI). Falls back to any connected
   // window scene so a not-yet-foreground launch still finds a presenter.
   @MainActor private static func activeWindowScene() -> UIWindowScene? {