@livx.cc/appwrap 0.28.0 → 0.28.2

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

@@ -18,23 +18,55 @@ import { appwrapNativeLog } from './native-log';
 const appendWebLog = appwrapNativeLog;
 
 /** Parse a #rrggbb config color into a UIColor (for the WebView background). */
-function uiColorFromHex(hex?: string): any {
+function uiColorFromHex(hex?: string): UIColor | null {
   const m = /^#?([0-9a-fA-F]{6})$/.exec((hex ?? '').trim());
   if (!m) return null;
   const n = parseInt(m[1], 16);
   return UIColor.colorWithRedGreenBlueAlpha(((n >> 16) & 255) / 255, ((n >> 8) & 255) / 255, (n & 255) / 255, 1);
 }
 
+/** WKScriptMessageHandler for the `appwrap` channel — forwards JSON envelopes to the owning view. */
+@NativeClass()
+class AppwrapScriptHandler extends NSObject implements WKScriptMessageHandler {
+  static ObjCProtocols = [WKScriptMessageHandler];
+  owner!: WeakRef<CustomWebView>;
+  static new(): AppwrapScriptHandler {
+    return <AppwrapScriptHandler>super.new();
+  }
+  userContentControllerDidReceiveScriptMessage(_controller: WKUserContentController, message: WKScriptMessage): void {
+    const view = this.owner.get ? this.owner.get() : (this.owner as { deref(): CustomWebView }).deref();
+    const body = message.body;
+    // Envelopes always travel as JSON strings (protocol v1)
+    if (view?.onAppwrapMessage && typeof body === 'string') {
+      view.onAppwrapMessage(body);
+    }
+  }
+}
+
+/** WKScriptMessageHandler for the `appwrapLog` channel — debug console-forwarding to the file sink. */
+@NativeClass()
+class AppwrapLogHandler extends NSObject implements WKScriptMessageHandler {
+  static ObjCProtocols = [WKScriptMessageHandler];
+  static new(): AppwrapLogHandler {
+    return <AppwrapLogHandler>super.new();
+  }
+  userContentControllerDidReceiveScriptMessage(_c: WKUserContentController, message: WKScriptMessage): void {
+    // Write to the file sink — NS console.log / NSLog don't surface to devicectl/idevicesyslog
+    // on a device build, but a file in the app container is reliably pullable.
+    if (typeof message.body === 'string') appendWebLog(message.body);
+  }
+}
+
 export class CustomWebView extends WebView {
   /** Set by the bridge before load; receives raw envelope JSON. */
   onAppwrapMessage: ((json: string) => void) | null = null;
-  private _scriptHandler: any; // retained — WKUserContentController holds it weakly
-  private _logHandler: any; // retained — debug console-forwarding handler
-  private _schemeHandler: any;
+  private _scriptHandler!: AppwrapScriptHandler; // retained — WKUserContentController holds it weakly
+  private _logHandler!: AppwrapLogHandler; // retained — debug console-forwarding handler
+  private _schemeHandler!: WKURLSchemeHandler;
   // NOT `_uiDelegate`: the base NativeScript WebView uses that exact field name, and
   // TS `private` is compile-time only — sharing it let super.initNativeView() overwrite
   // our media-capture delegate with NS's, so getUserMedia re-prompted every call.
-  private _appwrapUiDelegate: any; // retained — WKWebView holds uiDelegate weakly
+  private _appwrapUiDelegate!: WKUIDelegate; // retained — WKWebView holds uiDelegate weakly
 
   /** No-op on iOS: WKWebView suspends rAF/timers itself when the app leaves the foreground.
    * Kept for parity with the Android impl (wired to suspend/resume in main-page). */
@@ -67,39 +99,14 @@ export class CustomWebView extends WebView {
     }
 
     const owner = new WeakRef<CustomWebView>(this);
-    const HandlerClass = (NSObject as any).extend(
-      {
-        userContentControllerDidReceiveScriptMessage(
-          _controller: WKUserContentController,
-          message: WKScriptMessage
-        ): void {
-          const view = owner.get ? owner.get() : (owner as any).deref();
-          const body = message.body;
-          // Envelopes always travel as JSON strings (protocol v1)
-          if (view?.onAppwrapMessage && typeof body === 'string') {
-            view.onAppwrapMessage(body);
-          }
-        },
-      },
-      { protocols: [WKScriptMessageHandler] }
-    );
-    this._scriptHandler = HandlerClass.new();
+    this._scriptHandler = AppwrapScriptHandler.new();
+    this._scriptHandler.owner = owner;
     config.userContentController.addScriptMessageHandlerName(this._scriptHandler, 'appwrap');
 
     // Debug console-forwarding: web console/errors → NSLog (via NS console.log) → device console,
     // so `appwrap logs ios` can stream them headlessly. Only wired in debug mode.
     if (SHELL_CONFIG.debug) {
-      const LogClass = (NSObject as any).extend(
-        {
-          userContentControllerDidReceiveScriptMessage(_c: WKUserContentController, message: WKScriptMessage): void {
-            // Write to the file sink — NS console.log / NSLog don't surface to devicectl/idevicesyslog
-            // on a device build, but a file in the app container is reliably pullable.
-            if (typeof message.body === 'string') appendWebLog(message.body);
-          },
-        },
-        { protocols: [WKScriptMessageHandler] }
-      );
-      this._logHandler = LogClass.new();
+      this._logHandler = AppwrapLogHandler.new();
       config.userContentController.addScriptMessageHandlerName(this._logHandler, 'appwrapLog');
       appendWebLog('[native] log handler registered'); // boot marker: proves the file sink works
     }
@@ -124,13 +131,13 @@ export class CustomWebView extends WebView {
     // Edge-swipe to go back/forward in WebView history — the iOS native gesture
     // users expect. SPAs that own their own history still get it for free.
     webView.allowsBackForwardNavigationGestures = true;
-    if ((webView.configuration as any).dataDetectorTypes !== undefined) {
-      (webView.configuration as any).dataDetectorTypes = 0; // WKDataDetectorTypeNone
+    if (webView.configuration.dataDetectorTypes !== undefined) {
+      webView.configuration.dataDetectorTypes = 0; // WKDataDetectorTypeNone (WKDataDetectorTypes.None)
     }
 
     // Observability (debug mode only): make the WebView debuggable via Safari Web Inspector
     // (Develop → <device> → Para) — full console + network. iOS 16.4+ (guarded). Off in store builds.
-    if (SHELL_CONFIG.debug && webView.respondsToSelector('setInspectable:')) (webView as any).inspectable = true;
+    if (SHELL_CONFIG.debug && webView.respondsToSelector('setInspectable:')) webView.inspectable = true;
 
     this._appwrapUiDelegate = createUiDelegate();
     webView.UIDelegate = this._appwrapUiDelegate;
@@ -147,9 +154,9 @@ export class CustomWebView extends WebView {
     const wk = this.nativeViewProtected as WKWebView;
     if (wk && this._appwrapUiDelegate) wk.UIDelegate = this._appwrapUiDelegate;
     // Lightweight self-check surfaced via debug.webviewInfo (support diagnostics).
-    (global as any).__appwrapWebviewDiag =
+    (global as { __appwrapWebviewDiag?: string }).__appwrapWebviewDiag =
       `delegateIsMine=${!!wk && wk.UIDelegate === this._appwrapUiDelegate} ` +
-      `respondsToMedia=${!!wk && !!wk.UIDelegate && !!(wk.UIDelegate as any).respondsToSelector?.('webView:requestMediaCapturePermissionForOrigin:initiatedByFrame:type:decisionHandler:')}`;
+      `respondsToMedia=${!!wk && !!wk.UIDelegate && !!wk.UIDelegate.respondsToSelector?.('webView:requestMediaCapturePermissionForOrigin:initiatedByFrame:type:decisionHandler:')}`;
   }
 }
 
@@ -163,41 +170,42 @@ export class CustomWebView extends WebView {
  *      request body, so POSTs proxy fine.
  *  - else                      → 404 (or SPA fallback when there's no backend).
  */
-function createAppSchemeHandler(): any {
+function createAppSchemeHandler(): WKURLSchemeHandler {
   const wwwPath = nsPath.join(knownFolders.currentApp().path, 'www');
 
-  const serveFile = (task: any, url: any, filePath: string, ext: string): void => {
+  const serveFile = (task: WKURLSchemeTask, url: NSURL, filePath: string, ext: string): void => {
     const data = NSData.dataWithContentsOfFile(filePath);
     const mime = mimeFor(ext, filePath);
     const response = NSHTTPURLResponse.alloc().initWithURLStatusCodeHTTPVersionHeaderFields(
       url, 200, 'HTTP/1.1',
+      // NS auto-marshals this JS object into NSDictionary<string,string>
       {
         'Content-Type': `${mime}; charset=utf-8`,
         'Content-Length': String(data?.length ?? 0),
         'Access-Control-Allow-Origin': '*',
         'Cache-Control': 'no-cache',
-      } as any
+      } as unknown as NSDictionary<string, string>
     );
     task.didReceiveResponse(response);
     if (data) task.didReceiveData(data);
     task.didFinish();
   };
 
-  const proxyToBackend = (task: any, url: any, rel: string): void => {
+  const proxyToBackend = (task: WKURLSchemeTask, url: NSURL, rel: string): void => {
     const backend = SHELL_CONFIG.backendOrigin.replace(/\/+$/, '');
     const query = url.query ? `?${url.query}` : '';
     const req = NSMutableURLRequest.requestWithURL(NSURL.URLWithString(`${backend}/${rel}${query}`));
     req.HTTPMethod = String(task.request.HTTPMethod ?? 'GET');
     const hdrs = task.request.allHTTPHeaderFields;
     if (hdrs) req.allHTTPHeaderFields = hdrs;
-    req.setValueForHTTPHeaderField(null as any, 'Host'); // let URLSession set Host from the target URL
+    req.setValueForHTTPHeaderField(null as unknown as string, 'Host'); // let URLSession set Host from the target URL
     // WKURLSchemeHandler delivers a POST/PUT body via HTTPBodyStream (not HTTPBody) — read it.
-    let body = task.request.HTTPBody;
+    let body: NSData = task.request.HTTPBody;
     if (!body && task.request.HTTPBodyStream) {
       const stream = task.request.HTTPBodyStream;
       const acc = NSMutableData.alloc().init();
       const cap = 16384;
-      const buf = (global as any).interop.alloc(cap);
+      const buf = interop.alloc(cap);
       stream.open();
       while (stream.hasBytesAvailable) {
         const n = stream.readMaxLength(buf, cap);
@@ -211,11 +219,11 @@ function createAppSchemeHandler(): any {
 
     const dataTask = NSURLSession.sharedSession.dataTaskWithRequestCompletionHandler(
       req,
-      (data: any, resp: any, error: any) => {
+      (data: NSData, resp: NSURLResponse, error: NSError) => {
         try {
           if (error || !resp) {
             const r = NSHTTPURLResponse.alloc().initWithURLStatusCodeHTTPVersionHeaderFields(
-              url, 502, 'HTTP/1.1', { 'Content-Length': '0' } as any
+              url, 502, 'HTTP/1.1', { 'Content-Length': '0' } as unknown as NSDictionary<string, string>
             );
             task.didReceiveResponse(r);
             task.didFinish();
@@ -223,10 +231,12 @@ function createAppSchemeHandler(): any {
           }
           // Re-emit under the app:// URL (same-origin). Strip Content-Encoding (URLSession already
           // decoded the body) and recompute length; keep the upstream Content-Type + status.
-          const ct = resp.valueForHTTPHeaderField?.('Content-Type') ?? 'application/octet-stream';
+          // resp is NSHTTPURLResponse at runtime (HTTP request) — cast for the HTTP-only members.
+          const httpResp = resp as NSHTTPURLResponse;
+          const ct = httpResp.valueForHTTPHeaderField?.('Content-Type') ?? 'application/octet-stream';
           const out = NSHTTPURLResponse.alloc().initWithURLStatusCodeHTTPVersionHeaderFields(
-            url, resp.statusCode ?? 200, 'HTTP/1.1',
-            { 'Content-Type': ct, 'Content-Length': String(data?.length ?? 0), 'Cache-Control': 'no-cache' } as any
+            url, httpResp.statusCode ?? 200, 'HTTP/1.1',
+            { 'Content-Type': ct, 'Content-Length': String(data?.length ?? 0), 'Cache-Control': 'no-cache' } as unknown as NSDictionary<string, string>
           );
           task.didReceiveResponse(out);
           if (data) task.didReceiveData(data);
@@ -239,36 +249,38 @@ function createAppSchemeHandler(): any {
     dataTask.resume();
   };
 
-  const HandlerClass = (NSObject as any).extend(
-    {
-      webViewStartURLSchemeTask(_webView: WKWebView, task: any): void {
-        const url = task.request.URL;
-        let rel = decodeURIComponent(String(url.path ?? '/')).replace(/^\/+/, '');
-        if (!rel) rel = SHELL_CONFIG.entry;
-        const filePath = nsPath.join(wwwPath, rel);
-        const ext = rel.includes('.') ? rel.split('.').pop()!.toLowerCase() : '';
+  @NativeClass()
+  class AppSchemeHandler extends NSObject implements WKURLSchemeHandler {
+    static ObjCProtocols = [WKURLSchemeHandler];
+    static new(): AppSchemeHandler {
+      return <AppSchemeHandler>super.new();
+    }
+    webViewStartURLSchemeTask(_webView: WKWebView, task: WKURLSchemeTask): void {
+      const url = task.request.URL;
+      let rel = decodeURIComponent(String(url.path ?? '/')).replace(/^\/+/, '');
+      if (!rel) rel = SHELL_CONFIG.entry;
+      const filePath = nsPath.join(wwwPath, rel);
+      const ext = rel.includes('.') ? rel.split('.').pop()!.toLowerCase() : '';
 
-        if (File.exists(filePath)) { serveFile(task, url, filePath, ext); return; }
+      if (File.exists(filePath)) { serveFile(task, url, filePath, ext); return; }
 
-        const method = String(task.request.HTTPMethod ?? 'GET').toUpperCase();
-        const accept = task.request.valueForHTTPHeaderField?.('Accept') ?? '';
-        const isNavigation = method === 'GET' && accept.indexOf('text/html') >= 0;
+      const method = String(task.request.HTTPMethod ?? 'GET').toUpperCase();
+      const accept = task.request.valueForHTTPHeaderField?.('Accept') ?? '';
+      const isNavigation = method === 'GET' && accept.indexOf('text/html') >= 0;
 
-        if (isNavigation && !ext) { serveFile(task, url, nsPath.join(wwwPath, SHELL_CONFIG.entry), 'html'); return; }
-        if (SHELL_CONFIG.backendOrigin) { proxyToBackend(task, url, rel); return; }
-        if (!ext) { serveFile(task, url, nsPath.join(wwwPath, SHELL_CONFIG.entry), 'html'); return; }
+      if (isNavigation && !ext) { serveFile(task, url, nsPath.join(wwwPath, SHELL_CONFIG.entry), 'html'); return; }
+      if (SHELL_CONFIG.backendOrigin) { proxyToBackend(task, url, rel); return; }
+      if (!ext) { serveFile(task, url, nsPath.join(wwwPath, SHELL_CONFIG.entry), 'html'); return; }
 
-        const resp = NSHTTPURLResponse.alloc().initWithURLStatusCodeHTTPVersionHeaderFields(
-          url, 404, 'HTTP/1.1', { 'Content-Length': '0' } as any
-        );
-        task.didReceiveResponse(resp);
-        task.didFinish();
-      },
-      webViewStopURLSchemeTask(_webView: WKWebView, _task: any): void {
-        // single-shot responses; in-flight proxy completions are guarded by try/catch.
-      },
-    },
-    { protocols: [WKURLSchemeHandler] }
-  );
-  return HandlerClass.new();
+      const resp = NSHTTPURLResponse.alloc().initWithURLStatusCodeHTTPVersionHeaderFields(
+        url, 404, 'HTTP/1.1', { 'Content-Length': '0' } as unknown as NSDictionary<string, string>
+      );
+      task.didReceiveResponse(resp);
+      task.didFinish();
+    }
+    webViewStopURLSchemeTask(_webView: WKWebView, _task: WKURLSchemeTask): void {
+      // single-shot responses; in-flight proxy completions are guarded by try/catch.
+    }
+  }
+  return AppSchemeHandler.new();
 }

package/runtime/app/shell/devmenu.ts

@@ -19,7 +19,7 @@ export function startDevMenu(): void {
 
 // ── shake detection (total acceleration magnitude in g incl. gravity, debounced) ──
 const SHAKE_G = 1.8; // spike vs. ~1g rest
-let shakeMm: any = null; // hold a ref so CoreMotion isn't GC'd
+let shakeMm: CMMotionManager | null = null; // hold a ref so CoreMotion isn't GC'd
 let firstSpikeAt = 0;
 let spikes = 0;
 let lastMenuAt = 0;
@@ -68,7 +68,7 @@ function startAndroidShake(): void {
   const G = 9.80665;
   const listener = new android.hardware.SensorEventListener({
     onAccuracyChanged() {},
-    onSensorChanged(e: any) {
+    onSensorChanged(e: android.hardware.SensorEvent) {
       const v = e.values;
       onAccelMagnitude(Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]) / G);
     },

package/runtime/app/shell/env.ts

@@ -1,7 +1,5 @@
 import { Application, isAndroid } from '@nativescript/core';
 
-declare const android: any, NSProcessInfo: any, UIAccessibilityIsReduceMotionEnabled: any;
-
 /**
  * Runtime environment hints the page can't reliably detect itself, surfaced natively so a PWA can
  * scale its rendering down inside the shell. Injected at document-start as `window.__APPWRAP__` (see
@@ -36,7 +34,7 @@ export function envGlobalsJs(): string {
 function androidIsEmulator(): boolean {
   try {
     const B = android.os.Build;
-    const has = (v: any, s: string) => String(v || '').toLowerCase().includes(s);
+    const has = (v: string, s: string) => String(v || '').toLowerCase().includes(s);
     return (
       has(B.FINGERPRINT, 'generic') || has(B.FINGERPRINT, 'emulator') || has(B.FINGERPRINT, 'unknown') ||
       has(B.MODEL, 'google_sdk') || has(B.MODEL, 'emulator') || has(B.MODEL, 'android sdk built for') ||

package/runtime/app/shell/events.ts

@@ -1,4 +1,5 @@
 import { Application, Connectivity, isAndroid } from '@nativescript/core';
+import type { AndroidActivityNewIntentEventData, OrientationChangedEventData } from '@nativescript/core';
 import { bridge } from './bridge';
 import { connectivityStatus } from './handlers-extended';
 
@@ -74,7 +75,7 @@ export function onPwaHandshake(): void {
 export function startEventForwarding(): void {
   Application.on(Application.suspendEvent, () => bridge.emit('app.pause'));
   Application.on(Application.resumeEvent, () => bridge.emit('app.resume'));
-  Application.on(Application.orientationChangedEvent, (args: any) =>
+  Application.on(Application.orientationChangedEvent, (args: OrientationChangedEventData) =>
     bridge.emit('screen.orientation.change', args?.newValue === 'landscape' ? 'landscape' : 'portrait')
   );
 
@@ -86,7 +87,7 @@ export function startEventForwarding(): void {
 /** Intents: launch intent (cold start) + onNewIntent (warm, singleTask). Carries both VIEW deep links
  * and FCM notification-tap extras. */
 function wireAndroidDeepLinks(): void {
-  const emitFromIntent = (intent: any) => {
+  const emitFromIntent = (intent: android.content.Intent | null | undefined) => {
     try {
       const data = intent?.getData?.();
       if (data) onDeepLink(String(data.toString()));
@@ -102,7 +103,7 @@ function wireAndroidDeepLinks(): void {
     }
   };
 
-  Application.android.on(Application.android.activityNewIntentEvent as any, (args: any) =>
+  Application.android.on(Application.android.activityNewIntentEvent, (args: AndroidActivityNewIntentEventData) =>
     emitFromIntent(args.intent)
   );
   emitFromIntent(Application.android.startActivity?.getIntent?.());
@@ -111,7 +112,7 @@ function wireAndroidDeepLinks(): void {
 /** A tapped FCM notification re-launches the activity with the message's data payload as string
  * extras, alongside FCM's own `google.*`/`gcm.*`/`from`/`collapse_key` bookkeeping keys. Detect via
  * those markers; return the app's data keys only. Null when this isn't an FCM-originated intent. */
-function readFcmTapExtras(intent: any): { data: Record<string, string> } | null {
+function readFcmTapExtras(intent: android.content.Intent | null | undefined): { data: Record<string, string> } | null {
   try {
     const extras = intent?.getExtras?.();
     if (!extras || (!extras.containsKey('google.message_id') && !extras.containsKey('from'))) return null;

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

@@ -2,7 +2,8 @@ import { Application, Utils } from '@nativescript/core';
 import { bridge } from './bridge';
 import { requestPermissions, startActivityForResult, uriToDataUrl, bitmapToDataUrl } from './android-helpers';
 
-declare const android: any, java: any, androidx: any;
+// no NS types: android-32 typings omit ContactsContract/MediaStore column + ACTION_PICK_IMAGES constants this file reads
+declare const android: any, androidx: any;
 
 const err = (code: string, message: string) => Object.assign(new Error(message), { code });
 
@@ -125,18 +126,21 @@ export function registerAndroidHandlers(): void {
   // ── geolocation (LocationManager) ──────────────────────────────────
   const GEO_PERMS = ['android.permission.ACCESS_FINE_LOCATION', 'android.permission.ACCESS_COARSE_LOCATION'];
   const locationManager = () => context().getSystemService(android.content.Context.LOCATION_SERVICE);
-  const toPosition = (loc: any) => ({
+  const toPosition = (loc: android.location.Location) => ({
     lat: loc.getLatitude(), lng: loc.getLongitude(), accuracy: loc.getAccuracy(),
   });
-  const makeListener = (onLocation: (loc: any) => void) =>
+  const makeListener = (onLocation: (loc: android.location.Location) => void) =>
     new android.location.LocationListener({
-      // Both overloads dispatch here — newer Android may deliver a List<Location>
-      onLocationChanged(loc: any) {
+      // Both overloads dispatch here — newer Android may deliver a List<Location>.
+      onLocationChanged(arg: android.location.Location | java.util.List<android.location.Location>) {
+        // interop: runtime duck-typing across the two Java overloads; TS can't narrow Java types here
+        let loc: any = arg;
         if (loc && typeof loc.getLatitude !== 'function' && typeof loc.size === 'function') {
           loc = loc.size() > 0 ? loc.get(loc.size() - 1) : null;
         }
         if (loc) onLocation(loc);
       },
+      onFlushComplete() {},
       onStatusChanged() {}, onProviderEnabled() {}, onProviderDisabled() {},
     });
 
@@ -148,7 +152,7 @@ export function registerAndroidHandlers(): void {
         ?? lm.getLastKnownLocation(android.location.LocationManager.NETWORK_PROVIDER);
       if (last) return resolve(toPosition(last));
 
-      let listener: any = null;
+      let listener: android.location.LocationListener | null = null;
       const timer = setTimeout(() => {
         if (listener) lm.removeUpdates(listener);
         reject(err('TIMEOUT', 'location timeout'));
@@ -165,7 +169,7 @@ export function registerAndroidHandlers(): void {
     });
   });
 
-  let geoWatchListener: any = null;
+  let geoWatchListener: android.location.LocationListener | null = null;
   bridge.register('geo.watch.start', async () => {
     if (geoWatchListener) return; // already streaming
     if (!(await requestPermissions(GEO_PERMS))) throw err('DENIED', 'location permission denied');
@@ -249,7 +253,7 @@ export function registerAndroidHandlers(): void {
 
   // ── motion (SensorManager: accelerometer + gyroscope) ──────────────
   const sensorManager = () => context().getSystemService(android.content.Context.SENSOR_SERVICE);
-  let motionListener: any = null;
+  let motionListener: android.hardware.SensorEventListener | null = null;
   const lastMotion = { ax: 0, ay: 0, az: 0, rx: 0, ry: 0, rz: 0 };
 
   bridge.register('motion.start', () => {
@@ -261,7 +265,7 @@ export function registerAndroidHandlers(): void {
     let last = 0;
     motionListener = new android.hardware.SensorEventListener({
       onAccuracyChanged() {},
-      onSensorChanged(event: any) {
+      onSensorChanged(event: android.hardware.SensorEvent) {
         const v = event.values;
         if (event.sensor.getType() === android.hardware.Sensor.TYPE_ACCELEROMETER) {
           // Android accelerometer already reports m/s² incl. gravity — kit contract matches.
@@ -296,7 +300,7 @@ export function registerAndroidHandlers(): void {
     if (resultCode !== android.app.Activity.RESULT_OK || !result?.getData()) return { picked: false };
 
     const cr = context().getContentResolver();
-    const column = (uri: any, col: string, sel: string | null, args: string[] | null): string[] => {
+    const column = (uri: android.net.Uri, col: string, sel: string | null, args: string[] | null): string[] => {
       const out: string[] = [];
       const cursor = cr.query(uri, [col], sel, args, null);
       if (cursor) {
@@ -327,7 +331,7 @@ export function registerAndroidHandlers(): void {
     }
     const CC = android.provider.ContactsContract;
     const cr = context().getContentResolver();
-    const column = (uri: any, col: string, sel: string | null, args: string[] | null): string[] => {
+    const column = (uri: android.net.Uri, col: string, sel: string | null, args: string[] | null): string[] => {
       const out: string[] = [];
       const cursor = cr.query(uri, [col], sel, args, null);
       if (cursor) {
@@ -415,7 +419,7 @@ export function registerAndroidHandlers(): void {
     dir.mkdirs();
     const uris = new java.util.ArrayList();
     const mimes = new java.util.HashSet();
-    (files ?? []).forEach((f: any, i: number) => {
+    (files ?? []).forEach((f: { name: string; mimeType: string; base64: string }, i: number) => {
       const bytes = android.util.Base64.decode(f.base64, android.util.Base64.DEFAULT);
       const out = new java.io.File(dir, i + '-' + (f.name || 'file')); // index-prefix: avoid same-name collisions
       const fos = new java.io.FileOutputStream(out);

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

@@ -3,16 +3,15 @@ import { bridge } from './bridge';
 import { SHELL_CONFIG } from './config';
 import { setPendingBackgroundTaskId } from './background-context';
 import { CustomWebView } from './custom-webview';
+// Android-only WorkManager Worker (@JavaProxy + `extends androidx.work.Worker`). Kept in a `.android.ts`
+// file so it's NEVER evaluated on iOS — a top-level Android native class in a shared module dereferences
+// `@JavaProxy`/`androidx` at module load, which are undefined on iOS → the whole ES module graph fails to
+// instantiate → hard launch crash. iOS resolves the `.ios.ts` stub; registerAndroid() is the only user.
+import { AppwrapBackgroundWorker } from './background-worker';
 
-// ── BackgroundTasks (iOS) — NS auto-links the framework via metadata when these are referenced.
-// Not in the default @nativescript/types-ios set, so declared `any` (repo idiom; see handlers-speech).
-declare const BGTaskScheduler: any;
-declare const BGAppRefreshTaskRequest: any;
-declare const BGProcessingTaskRequest: any;
-declare const NSDate: any;
-declare const android: any;
-declare const androidx: any;
-declare const java: any;
+// BackgroundTasks (iOS), NSDate, and the `android`/`java` namespaces resolve from the full SDK
+// (@nativescript/types-ios + types-android) — no declares needed.
+declare const androidx: any; // no NS types: androidx (not in types-android)
 
 const err = (code: string, message: string) => Object.assign(new Error(message), { code });
 
@@ -64,7 +63,7 @@ const pendingRuns = new Map<string, PendingRun>();
 /** Build an offscreen WebView, attach the bridge, and load the app so its handshake reports `id`. The
  * returned promise resolves when the JS handler calls `backgroundTask.finish` (or `abort()` fires).
  * REUSES `CustomWebView` (scheme handler + bridge injection) — no duplicated transport. */
-function runHeadless(id: string): Promise<boolean> {
+export function runHeadless(id: string): Promise<boolean> {
   return new Promise<boolean>((resolve) => {
     setPendingBackgroundTaskId(id); // the next handshake reports this wake id
     const webView = new CustomWebView();
@@ -115,7 +114,7 @@ function loadAppInto(webView: CustomWebView, id: string, attempt = 0): void {
 
 /** Resolve an in-flight headless run (called by `backgroundTask.finish`, the safety abort, or a load
  * failure). Tears the offscreen WebView's bridge attachment down. Idempotent. */
-function finishRun(id: string, success: boolean): void {
+export function finishRun(id: string, success: boolean): void {
   const run = pendingRuns.get(id);
   if (!run) return;
   pendingRuns.delete(id);
@@ -154,18 +153,22 @@ function registerIos(): void {
  * else a lighter app-refresh request. `minIntervalMs` → earliestBeginDate floor. */
 function submitIosRequest(id: string, p: any): void {
   const needsProcessing = !!p?.requiresNetwork || !!p?.requiresCharging;
-  const req = needsProcessing
-    ? BGProcessingTaskRequest.alloc().initWithIdentifier(id)
-    : BGAppRefreshTaskRequest.alloc().initWithIdentifier(id);
+  let req: BGProcessingTaskRequest | BGAppRefreshTaskRequest;
   if (needsProcessing) {
-    req.requiresNetworkConnectivity = !!p?.requiresNetwork;
-    req.requiresExternalPower = !!p?.requiresCharging;
+    const proc = BGProcessingTaskRequest.alloc().initWithIdentifier(id);
+    proc.requiresNetworkConnectivity = !!p?.requiresNetwork;
+    proc.requiresExternalPower = !!p?.requiresCharging;
+    req = proc;
+  } else {
+    req = BGAppRefreshTaskRequest.alloc().initWithIdentifier(id);
   }
   if (p?.minIntervalMs) {
-    req.earliestBeginDate = NSDate.dateWithTimeIntervalSinceNow(Number(p.minIntervalMs) / 1000);
+    // earliestBeginDate is a JS Date (NS marshals it to NSDate) — `now + interval`.
+    req.earliestBeginDate = new Date(Date.now() + Number(p.minIntervalMs));
   }
   // submitTaskRequestError throws via the out-error; NS surfaces it as a thrown JS error.
-  BGTaskScheduler.sharedScheduler.submitTaskRequestError(req, null);
+  // (out-error param omitted — NS marshals the ObjC error into a thrown JS exception.)
+  BGTaskScheduler.sharedScheduler.submitTaskRequestError(req);
 }
 
 /**
@@ -176,27 +179,40 @@ function submitIosRequest(id: string, p: any): void {
  */
 export function registerBackgroundTaskLaunchHandlers(): void {
   if (!isIOS) return;
+  // This runs INSIDE applicationDidFinishLaunchingWithOptions, so ANY throw here crashes app launch.
+  // Guard hard: a background-task convenience must NEVER take down boot. If BGTaskScheduler is
+  // unavailable (framework not resolved) or a registration throws (Apple's strict rules), log and
+  // continue WITHOUT background wakes rather than crash. Each id is isolated so one bad id can't stop
+  // the rest. (`typeof` is a safe undefined-check — no ReferenceError on an absent native global.)
+  if (typeof BGTaskScheduler === 'undefined' || !BGTaskScheduler) {
+    console.log('[backgroundTask] BGTaskScheduler unavailable — skipping launch-handler registration');
+    return;
+  }
   for (const id of permittedIosIds()) {
-    // The launch handler runs on the queue we pass (null = a default background queue). It receives the
-    // BGTask; we drive the JS handler, then complete + reschedule.
-    BGTaskScheduler.sharedScheduler.registerForTaskWithIdentifierUsingQueueLaunchHandler(
-      id,
-      null,
-      (task: any) => {
-        // The OS budget is nearly spent → abort the run (the kit also self-aborts at ~25s). Reporting
-        // failure lets the OS learn the task overran.
-        task.expirationHandler = () => finishRun(id, false);
-        runHeadless(id)
-          .then((success) => {
-            try { submitIosRequest(id, {}); } catch { /* a failed resubmit shouldn't crash the wake */ }
-            task.setTaskCompletedWithSuccess(success);
-          })
-          .catch(() => {
-            try { submitIosRequest(id, {}); } catch { /* noop */ }
-            task.setTaskCompletedWithSuccess(false);
-          });
-      }
-    );
+    try {
+      // The launch handler runs on the queue we pass (null = a default background queue). It receives the
+      // BGTask; we drive the JS handler, then complete + reschedule.
+      BGTaskScheduler.sharedScheduler.registerForTaskWithIdentifierUsingQueueLaunchHandler(
+        id,
+        null as any, // interop: pass nil queue → OS default background queue (param is non-optional)
+        (task: BGTask) => {
+          // The OS budget is nearly spent → abort the run (the kit also self-aborts at ~25s). Reporting
+          // failure lets the OS learn the task overran.
+          task.expirationHandler = () => finishRun(id, false);
+          runHeadless(id)
+            .then((success) => {
+              try { submitIosRequest(id, {}); } catch { /* a failed resubmit shouldn't crash the wake */ }
+              task.setTaskCompletedWithSuccess(success);
+            })
+            .catch(() => {
+              try { submitIosRequest(id, {}); } catch { /* noop */ }
+              task.setTaskCompletedWithSuccess(false);
+            });
+        }
+      );
+    } catch (e: any) {
+      console.log(`[backgroundTask] launch-handler registration failed for '${id}': ${e?.message ?? e}`);
+    }
   }
 }
 
@@ -211,7 +227,7 @@ function registerAndroid(): void {
     // WorkManager periodic floor is 15 min; clamp a smaller hint up so enqueue doesn't reject it.
     const ms = Math.max(15 * 60_000, Number(p?.minIntervalMs ?? 15 * 60_000));
     const builder = new androidx.work.PeriodicWorkRequest.Builder(
-      AppwrapBackgroundWorker.class,
+      (AppwrapBackgroundWorker as any).class,
       ms, java.util.concurrent.TimeUnit.MILLISECONDS
     );
     // The id rides as input data → the Worker reads it to drive the matching JS handler.
@@ -238,42 +254,5 @@ function registerAndroid(): void {
   });
 }
 
-/**
- * WorkManager headless Worker — created by WorkManager on a background launch. `doWork()` posts to the
- * MAIN looper (the WebView must be built + driven on the UI thread), runs the headless WebView loop for
- * the input task id, and blocks the worker thread on a `CountDownLatch` until `backgroundTask.finish`
- * (or a timeout). Returns success/failure; WorkManager handles periodic rescheduling.
- *
- * ⚠ DEVICE-UNVERIFIED — compiles only (see the file header).
- */
-@NativeClass()
-@JavaProxy('cc.livx.appwrap.AppwrapBackgroundWorker')
-export class AppwrapBackgroundWorker extends androidx.work.Worker {
-  constructor(context: any, params: any) {
-    super(context, params);
-  }
-
-  doWork(): any {
-    const id = this.getInputData().getString('appwrap.taskId') ?? '';
-    if (!id) return androidx.work.ListenableWorker.Result.failure();
-
-    const latch = new java.util.concurrent.CountDownLatch(1);
-    const result = { success: false };
-    Utils.dispatchToMainThread(() => {
-      runHeadless(id)
-        .then((ok: boolean) => { result.success = ok; latch.countDown(); })
-        .catch(() => { latch.countDown(); });
-    });
-    // Block the worker thread (bounded — below the WorkManager 10-min ceiling) until the JS handler
-    // finishes. A timeout returns failure so WorkManager retries on its schedule.
-    const completed = latch.await(9, java.util.concurrent.TimeUnit.MINUTES);
-    if (!completed) finishRun(id, false);
-    return completed && result.success
-      ? androidx.work.ListenableWorker.Result.success()
-      : androidx.work.ListenableWorker.Result.failure();
-  }
-}
-
-// Reference the Worker class so the bundler/NS metadata retains the JavaProxy (mirrors how the FCM
-// service is kept alive via its import side-effect). Without a reference the class can be tree-shaken.
-void AppwrapBackgroundWorker;
+// The WorkManager headless Worker (@JavaProxy `AppwrapBackgroundWorker`) lives in
+// `background-worker.android.ts` — see the import at the top of this file for WHY it can't be here.