@livx.cc/appwrap 0.26.0 → 0.28.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livx.cc/appwrap",
-  "version": "0.26.0",
+  "version": "0.28.0",
   "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_Resources/Android/src/main/AndroidManifest.xml

@@ -19,6 +19,9 @@
 	<!-- appwrap:permissions -->
 	<!-- /appwrap:permissions -->
 
+	<!-- appwrap:queries -->
+	<!-- /appwrap:queries -->
+
 	<application
 		android:name="com.tns.NativeScriptApplication"
 		android:allowBackup="true"

package/runtime/app/app.ts

@@ -1,8 +1,9 @@
 import { Application, isIOS } from '@nativescript/core';
-import { onDeepLink } from './shell/events';
+import { onDeepLink, onShortcut } from './shell/events';
 import { iosOrientationMask } from './shell/orientation';
 import { installForegroundNotificationDelegate } from './shell/handlers-extended';
 import { onApnsToken, onApnsError, onRemoteMessage } from './shell/handlers-push';
+import { registerBackgroundLaunchHandlers } from './shell/background-bootstrap.generated';
 
 /** APNs device token (NSData) → lowercase hex string the push backend expects. */
 function apnsTokenToHex(deviceToken: NSData): string {
@@ -20,10 +21,26 @@ if (isIOS) {
       applicationDidFinishLaunchingWithOptions(_app: UIApplication, launchOptions: NSDictionary<string, any>) {
         // Set the notification delegate NOW so a cold-launch tap's deep link is delivered.
         installForegroundNotificationDelegate();
+        // BGTaskScheduler launch handlers MUST be registered here (Apple's rule) — no-op unless the
+        // backgroundTask module is active (the CLI wires the generated bootstrap to the real impl).
+        registerBackgroundLaunchHandlers();
         const url = launchOptions?.objectForKey(UIApplicationLaunchOptionsURLKey);
         if (url) onDeepLink(url.absoluteString ?? String(url));
+        // Cold-launch from a home-screen quick action — Apple delivers it ONLY here in launchOptions
+        // (performActionForShortcutItem is NOT called for the launch action). Buffered until handshake.
+        const shortcut = launchOptions?.objectForKey(UIApplicationLaunchOptionsShortcutItemKey);
+        if (shortcut) onShortcut(String(shortcut.type));
         return true;
       },
+      // Warm activation of a quick action (app already running/backgrounded).
+      applicationPerformActionForShortcutItemCompletionHandler(
+        _app: UIApplication,
+        shortcutItem: UIApplicationShortcutItem,
+        completionHandler: (done: boolean) => void
+      ) {
+        onShortcut(String(shortcutItem.type));
+        completionHandler(true);
+      },
       applicationOpenURLOptions(_app: UIApplication, url: NSURL, _options: NSDictionary<string, any>) {
         console.log('AppWrap: openURL', url.absoluteString);
         onDeepLink(url.absoluteString);

package/runtime/app/shell/background-bootstrap.generated.ts

@@ -0,0 +1,8 @@
+/**
+ * Generated by `appwrap init`/`sync`. iOS BGTaskScheduler launch handlers MUST be registered at
+ * `applicationDidFinishLaunchingWithOptions` (Apple's rule) — too early for the page-load handler
+ * barrel. The AppDelegate calls {@link registerBackgroundLaunchHandlers} from didFinishLaunching; the
+ * CLI rewrites this to import the real implementation ONLY when the `backgroundTask` module is active
+ * (so a build without it never references BGTaskScheduler). Default = no-op. Do not edit.
+ */
+export function registerBackgroundLaunchHandlers(): void {}

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

@@ -0,0 +1,20 @@
+/**
+ * Background-launch context seam — a tiny always-bundled module so the (always-on) `app.handshake`
+ * handler can report a wake id WITHOUT importing the strippable `handlers-background` file (which only
+ * lands when the `backgroundTask` module is active). The headless runner sets the id before loading
+ * the offscreen WebView; the handshake reads it ONCE (so a foreground handshake later in the same
+ * process never re-reports a stale wake). No NativeScript globals → also unit-testable.
+ */
+let pendingBackgroundTaskId: string | null = null;
+
+/** Set by the headless background runner before it loads the offscreen WebView for `id`. */
+export function setPendingBackgroundTaskId(id: string | null): void {
+  pendingBackgroundTaskId = id;
+}
+
+/** Read-and-clear the pending wake id (called by the handshake handler). */
+export function consumePendingBackgroundTaskId(): string | null {
+  const id = pendingBackgroundTaskId;
+  pendingBackgroundTaskId = null;
+  return id;
+}

package/runtime/app/shell/capabilities.manifest.ts

@@ -76,10 +76,13 @@ export const MODULES: ModuleManifest[] = [
   { name: 'device', core: true, group: 'extended', capabilities: { device: 'native' } },
   { name: 'clipboard', core: true, group: 'extended', capabilities: { clipboard: 'native' } },
   { name: 'network', core: true, group: 'extended', capabilities: { network: 'native' } },
-  { name: 'screen', core: true, group: 'extended', capabilities: { screen: 'native', dialogs: 'native', orientation: 'native', keyboard: 'native' } },
+  // privacyScreen: hide content in the app-switcher / block screenshots — permission-free, cheap → core.
+  { name: 'screen', core: true, group: 'extended', capabilities: { screen: 'native', dialogs: 'native', orientation: 'native', keyboard: 'native', privacyScreen: { ios: true, android: true } } },
   // badge: app-icon badge via the always-bundled notifications.setBadge handler — iOS sets the
   // springboard badge; Android is an honest no-op (launchers own badges) → ios:true / android:false.
-  { name: 'app', core: true, group: 'system', capabilities: { app: 'native', browser: 'native', badge: { ios: true, android: false } } },
+  // app.canOpenUrl rides the always-native `app` cap (no new key). shortcuts: home-screen quick
+  // actions — iOS UIApplicationShortcutItem / Android dynamic shortcuts (API 25+).
+  { name: 'app', core: true, group: 'system', capabilities: { app: 'native', browser: 'native', badge: { ios: true, android: false }, shortcuts: { ios: true, android: true } } },
 
   // ── opt-in: permission / dependency / weight-bearing ───────────────────
   // POST_NOTIFICATIONS / VIBRATE / USE_BIOMETRIC etc. are in the template's baseline manifest already.
@@ -246,11 +249,27 @@ export const MODULES: ModuleManifest[] = [
     },
     nativeSrc: 'health',
   },
+
+  // ── backgroundTask — headless background execution (HEADLESS JS HANDLER) — opt-in, STRIPPABLE ──
+  // The OS wakes the app (possibly cold, no visible WebView) for a permitted task id; the shell builds
+  // an OFFSCREEN WebView, loads the app conveying the id (the handshake reports it), awaits the JS
+  // handler's `backgroundTask.finish`, then completes + reschedules the OS task. iOS: BGTaskScheduler
+  // (BGAppRefreshTaskRequest / BGProcessingTaskRequest) — NO gradle dep, but Info.plist MUST declare
+  // the permitted identifiers (`appwrap.json.backgroundTasks`, stamped by the CLI) + the fetch/processing
+  // background modes. Android: WorkManager periodic work (the work-runtime dep rides via this module),
+  // self-initialized by its androidx startup provider — nothing mandatory to stamp.
+  // DEVICE-UNVERIFIED: the native background-wake path (offscreen WebView under BGTask / WorkManager)
+  // compiles only; it has NOT been run on a device. See handlers-background.ts.
+  {
+    name: 'backgroundTask', group: 'backgroundTask',
+    capabilities: { backgroundTask: { ios: true, android: true } },
+    android: { gradleDeps: ['androidx.work:work-runtime:2.9.1'] },
+  },
 ];
 
 /** Opt-in registration groups that own their own NS handler file (strippable when inactive). Core
  * groups (core/extended/parity/system/media/billing) are always bundled; only these are CLI-gated. */
-export const OPTIONAL_GROUPS = ['health', 'oauth', 'reviews', 'scanner', 'speech'] as const;
+export const OPTIONAL_GROUPS = ['health', 'oauth', 'reviews', 'scanner', 'speech', 'backgroundTask'] as const;
 
 /** Resolve the active capability map for the handshake from a set of active capability names. */
 export function buildCapabilityMap(

package/runtime/app/shell/events.ts

@@ -4,6 +4,7 @@ import { connectivityStatus } from './handlers-extended';
 
 let pendingDeepLink: string | null = null;
 let pendingPushTap: { data: Record<string, string> } | null = null;
+let pendingShortcut: string | null = null;
 // True only once the PWA's JS has handshaked — i.e. the WebView is actually
 // running our bundle and about to subscribe. Native page-load is too early:
 // a deeplink.open emitted then lands in a WebView with no listener and is lost
@@ -27,6 +28,15 @@ export function onDeepLink(url: string): void {
   else pendingDeepLink = url; // buffer until the PWA handshakes
 }
 
+/** A home-screen shortcut was activated (iOS performActionForShortcutItem / cold-start launchOptions;
+ * Android the launch intent's `appwrap_shortcut` extra). Buffered until the handshake like deep links
+ * (cold-start: a shortcut that launched the app would otherwise land in a WebView with no listener). */
+export function onShortcut(id: string): void {
+  if (!id) return;
+  if (pwaReady) bridge.emit('app.shortcut', { id });
+  else pendingShortcut = id;
+}
+
 /** Android: a tray notification (FCM) was tapped → re-launched the activity with the data payload as
  * intent extras. Buffered until handshake like deep links (cold-start-from-notification). iOS routes
  * taps via the AppDelegate (handlers-push onRemoteMessage). */
@@ -53,6 +63,11 @@ export function onPwaHandshake(): void {
     pendingPushTap = null;
     setTimeout(() => bridge.emit('push.tap', payload), 500);
   }
+  if (pendingShortcut) {
+    const id = pendingShortcut;
+    pendingShortcut = null;
+    setTimeout(() => bridge.emit('app.shortcut', { id }), 500);
+  }
 }
 
 /** Wire lifecycle + connectivity event forwarding (the PWA subscribes to these). */
@@ -77,6 +92,11 @@ function wireAndroidDeepLinks(): void {
       if (data) onDeepLink(String(data.toString()));
       const tap = readFcmTapExtras(intent);
       if (tap) onPushTap(tap);
+      const shortcutId = intent?.getStringExtra?.('appwrap_shortcut');
+      if (shortcutId) {
+        onShortcut(String(shortcutId));
+        intent.removeExtra?.('appwrap_shortcut'); // consume — don't re-fire on the next relayout read
+      }
     } catch (e) {
       console.warn('AppWrap: intent read failed', e);
     }

package/runtime/app/shell/fcm-firebase.d.ts

@@ -2,7 +2,8 @@
  * Minimal ambient declarations for the Firebase Messaging Android classes the FCM service extends.
  * The full classes are provided at runtime by the `firebase-messaging` AAR (added by the CLI only
  * when push is wired) — the NativeScript Android runtime marshals them. Declare-merges into the
- * `com` namespace from @nativescript/types-android. Mirrors ios-frameworks.d.ts.
+ * `com` namespace from @nativescript/types-android. (iOS SDK frameworks are typed via the
+ * @nativescript/types-ios references in references.d.ts.)
  */
 declare namespace com.google.firebase.messaging {
   class RemoteMessage {

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

@@ -0,0 +1,279 @@
+import { Application, Utils, isAndroid, isIOS } from '@nativescript/core';
+import { bridge } from './bridge';
+import { SHELL_CONFIG } from './config';
+import { setPendingBackgroundTaskId } from './background-context';
+import { CustomWebView } from './custom-webview';
+
+// ── 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;
+
+const err = (code: string, message: string) => Object.assign(new Error(message), { code });
+
+/**
+ * Headless background execution with a HEADLESS JS HANDLER contract.
+ *
+ * Bridge methods (called from the app's foreground OR the offscreen background WebView):
+ *  - `backgroundTask.schedule` → ask the OS to (re)schedule a wake for an id.
+ *  - `backgroundTask.cancel`   → drop a scheduled wake.
+ *  - `backgroundTask.finish`   → the JS handler is done → complete the OS task + reschedule.
+ *
+ * Headless runner (the OS-wake path): {@link registerBackgroundTaskLaunchHandlers} (iOS, called from
+ * the AppDelegate at didFinishLaunching) registers a BGTask launch handler per PERMITTED id. On fire
+ * it stamps the wake id ({@link setPendingBackgroundTaskId}), builds an OFFSCREEN WebView (reusing
+ * `CustomWebView` → same scheme handler + bridge wiring as the visible one), loads the app so the
+ * handshake reports the id, and awaits `backgroundTask.finish`. Android runs the same loop inside a
+ * `WorkManager` Worker (see {@link AppwrapBackgroundWorker}).
+ *
+ * ⚠ DEVICE-UNVERIFIED: the native background-wake path (offscreen WebView under BGTask / WorkManager)
+ * COMPILES ONLY — it has NOT been run on a device this session. The any-typed FFI hides selector
+ * typos and the cold-launch headless-WebView lifecycle is the genuinely device-gated unknown. The
+ * bridge contract (schedule/cancel/finish ⇄ kit) and the dispatch logic are unit-tested in the kit.
+ */
+export function registerBackgroundTaskHandlers(): void {
+  if (isIOS) registerIos();
+  else if (isAndroid) registerAndroid();
+}
+
+/** Permitted task ids (iOS BGTaskSchedulerPermittedIdentifiers / the app's declared set). Read from
+ * the stamped Info.plist on iOS; on Android any id WorkManager enqueues is valid. */
+function permittedIosIds(): string[] {
+  try {
+    const arr = NSBundle.mainBundle.objectForInfoDictionaryKey('BGTaskSchedulerPermittedIdentifiers');
+    const out: string[] = [];
+    const n = arr?.count ?? 0;
+    for (let i = 0; i < n; i++) out.push(String(arr.objectAtIndex(i)));
+    return out;
+  } catch {
+    return [];
+  }
+}
+
+// ── shared headless-run plumbing ────────────────────────────────────────────
+// One offscreen WebView per in-flight task id, kept alive (ARC/GC + the bridge attach) until the JS
+// handler reports finish. The `finish` handler resolves the matching pending run.
+interface PendingRun { resolve: (success: boolean) => void; webView: CustomWebView | null; }
+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> {
+  return new Promise<boolean>((resolve) => {
+    setPendingBackgroundTaskId(id); // the next handshake reports this wake id
+    const webView = new CustomWebView();
+    pendingRuns.set(id, { resolve, webView });
+    // Detach the bridge from whatever (visible) WebView it held, attach the offscreen one so this run's
+    // invokes (incl. backgroundTask.finish) route here. A cold background launch has no visible view.
+    bridge.attach(webView);
+    Utils.dispatchToMainThread(() => {
+      try {
+        loadAppInto(webView, id);
+      } catch (e) {
+        finishRun(id, false); // load failed → report failure, let the OS reschedule
+      }
+    });
+  });
+}
+
+// An offscreen WebView's native peer (`.ios`/`.android`) is created lazily; off the visual tree it may
+// never materialize (the device-gated cold-launch risk). Bound the poll so we can't spin forever —
+// ~2s (40 × 50ms), then give up and let the OS reschedule rather than leak a timer / drain battery.
+const LOAD_PEER_MAX_ATTEMPTS = 40;
+
+/** Point an (offscreen) WebView at the app entry — mirrors main-page.loadBundle's loader branches so
+ * the same www/app:// / server URL serves the background run. Retries until the native peer exists,
+ * bounded by {@link LOAD_PEER_MAX_ATTEMPTS} → finish(false) on exhaustion. */
+function loadAppInto(webView: CustomWebView, id: string, attempt = 0): void {
+  const retry = (peerMissing: boolean): boolean => {
+    if (!peerMissing) return false;
+    if (attempt >= LOAD_PEER_MAX_ATTEMPTS) { finishRun(id, false); return true; }
+    setTimeout(() => loadAppInto(webView, id, attempt + 1), 50);
+    return true;
+  };
+  if (isIOS) {
+    const wk = webView.ios as WKWebView;
+    if (retry(!wk)) return;
+    if (SHELL_CONFIG.loader === 'server' && SHELL_CONFIG.serverUrl) {
+      wk.loadRequest(NSURLRequest.requestWithURL(NSURL.URLWithString(SHELL_CONFIG.serverUrl)));
+    } else {
+      wk.loadRequest(NSURLRequest.requestWithURL(NSURL.URLWithString(`app://local/${SHELL_CONFIG.entry}`)));
+    }
+  } else {
+    if (retry(!webView.android)) return;
+    webView.src = SHELL_CONFIG.loader === 'server' && SHELL_CONFIG.serverUrl
+      ? SHELL_CONFIG.serverUrl
+      : `https://appwrap.local/${SHELL_CONFIG.entry}`;
+  }
+}
+
+/** 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 {
+  const run = pendingRuns.get(id);
+  if (!run) return;
+  pendingRuns.delete(id);
+  try { if (bridge.getWebView() === run.webView) bridge.detach(); } catch { /* noop */ }
+  run.resolve(success);
+}
+
+// ── iOS ─────────────────────────────────────────────────────────────────────
+function registerIos(): void {
+  const scheduler = () => BGTaskScheduler.sharedScheduler;
+
+  // schedule: app-refresh by default; processing when it needs network/charging (iOS routes those via
+  // BGProcessingTaskRequest, which exposes requiresNetworkConnectivity / requiresExternalPower).
+  bridge.register('backgroundTask.schedule', (p: any) => {
+    const id = String(p?.id ?? '');
+    if (!id) throw err('NATIVE_ERROR', 'backgroundTask.schedule: missing id');
+    submitIosRequest(id, p);
+  });
+
+  bridge.register('backgroundTask.cancel', (p: any) => {
+    const id = String(p?.id ?? '');
+    if (id) scheduler().cancelTaskRequestWithIdentifier(id);
+  });
+
+  // finish: the JS handler is done → resolve the headless run, which (in the launch handler) completes
+  // the BGTask + resubmits the next request. Also reschedule here so a finish from the FOREGROUND
+  // (manual handler run) keeps the OS wake alive.
+  bridge.register('backgroundTask.finish', (p: any) => {
+    const id = String(p?.id ?? '');
+    const success = p?.success !== false;
+    if (id) finishRun(id, success);
+  });
+}
+
+/** Submit a BGTaskScheduler request for `id`. Processing request when network/charging constrained,
+ * 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);
+  if (needsProcessing) {
+    req.requiresNetworkConnectivity = !!p?.requiresNetwork;
+    req.requiresExternalPower = !!p?.requiresCharging;
+  }
+  if (p?.minIntervalMs) {
+    req.earliestBeginDate = NSDate.dateWithTimeIntervalSinceNow(Number(p.minIntervalMs) / 1000);
+  }
+  // submitTaskRequestError throws via the out-error; NS surfaces it as a thrown JS error.
+  BGTaskScheduler.sharedScheduler.submitTaskRequestError(req, null);
+}
+
+/**
+ * Register a BGTask LAUNCH handler per permitted id — MUST run at `applicationDidFinishLaunchingWith
+ * Options` (Apple's rule), so the AppDelegate calls this (see the generated background bootstrap). On
+ * fire: stamp the wake id, set the task's expirationHandler to abort the run, run the headless WebView
+ * loop, then `setTaskCompleted(success:)` + resubmit the next request. @internal (called from app.ts).
+ */
+export function registerBackgroundTaskLaunchHandlers(): void {
+  if (!isIOS) 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);
+          });
+      }
+    );
+  }
+}
+
+// ── Android (WorkManager) ────────────────────────────────────────────────────
+function registerAndroid(): void {
+  const ctx = () => Utils.android.getApplicationContext();
+  const WM = () => androidx.work.WorkManager.getInstance(ctx());
+
+  bridge.register('backgroundTask.schedule', (p: any) => {
+    const id = String(p?.id ?? '');
+    if (!id) throw err('NATIVE_ERROR', 'backgroundTask.schedule: missing id');
+    // 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,
+      ms, java.util.concurrent.TimeUnit.MILLISECONDS
+    );
+    // The id rides as input data → the Worker reads it to drive the matching JS handler.
+    builder.setInputData(
+      new androidx.work.Data.Builder().putString('appwrap.taskId', id).build()
+    );
+    const constraints = new androidx.work.Constraints.Builder();
+    if (p?.requiresNetwork) constraints.setRequiredNetworkType(androidx.work.NetworkType.CONNECTED);
+    if (p?.requiresCharging) constraints.setRequiresCharging(true);
+    builder.setConstraints(constraints.build());
+    WM().enqueueUniquePeriodicWork(id, androidx.work.ExistingPeriodicWorkPolicy.UPDATE, builder.build());
+  });
+
+  bridge.register('backgroundTask.cancel', (p: any) => {
+    const id = String(p?.id ?? '');
+    if (id) WM().cancelUniqueWork(id);
+  });
+
+  // finish: resolve the run → the Worker's CountDownLatch releases → doWork returns success/failure.
+  // WorkManager reschedules periodic work itself (no resubmit needed, unlike iOS BGTask).
+  bridge.register('backgroundTask.finish', (p: any) => {
+    const id = String(p?.id ?? '');
+    finishRun(id, p?.success !== false);
+  });
+}
+
+/**
+ * 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;

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

@@ -166,18 +166,6 @@ export function registerPushHandlers(): void {
     if (isAndroid) return androidDeleteToken();
   });
 
-  // Dev/demo: ask the backend to push THIS device on demand. Goes native (NS Http) → no app:// CORS
-  // wall. Requires push.registrationUrl + a registered token; the backend honors `test:true`.
-  bridge.register('push.sendTest', () => {
-    const url = SHELL_CONFIG.pushRegistrationUrl;
-    if (!url) return Promise.reject(Object.assign(new Error('push.registrationUrl not configured'), { code: 'UNSUPPORTED' }));
-    if (!cachedToken) return Promise.reject(Object.assign(new Error('no device token yet — register first'), { code: 'NOT_READY' }));
-    return Http.request({
-      url, method: 'POST', headers: { 'Content-Type': 'application/json' },
-      content: JSON.stringify({ token: cachedToken, platform: isIOS ? 'ios' : 'android', test: true }),
-    }).then((res) => ({ status: res.statusCode }));
-  });
-
   // Debug: auto-acquire + log the FCM token at boot so it's readable HEADLESSLY (adb logcat / appwrap
   // logs) without a UI tap — the dev loop needs the token to send a test push. Android only (iOS push
   // is off on personal teams); no-op when push isn't configured for this platform.

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

@@ -1,7 +1,8 @@
 import { Application, Utils, isAndroid, isIOS } from '@nativescript/core';
 import { bridge } from './bridge';
 
-// SKStoreReviewController is declared globally in ios-frameworks.d.ts. `com` is the Android namespace.
+// SKStoreReviewController comes from the StoreKit typings referenced in references.d.ts. `com` is the
+// Android namespace.
 declare const com: any;
 
 /**

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

@@ -119,6 +119,70 @@ export function registerSystemHandlers(): void {
 
   bridge.register('app.environment', () => appEnvironment());
 
+  // Probe whether the OS can open a URL. Custom schemes need declaring up-front (iOS
+  // LSApplicationQueriesSchemes via appwrap.json.queryUrlSchemes; Android <queries> via
+  // queryPackages) — common schemes (http/https/tel/mailto/sms) resolve without declaration.
+  bridge.register('app.canOpenUrl', ({ url }: { url: string }) => {
+    const target = String(url ?? '');
+    if (!target) return false;
+    if (isIOS) {
+      const nsUrl = NSURL.URLWithString(target);
+      return !!nsUrl && UIApplication.sharedApplication.canOpenURL(nsUrl);
+    }
+    if (isAndroid) {
+      const pm = Utils.android.getApplicationContext().getPackageManager();
+      const intent = new android.content.Intent(
+        android.content.Intent.ACTION_VIEW,
+        android.net.Uri.parse(target)
+      );
+      return pm.resolveActivity(intent, 0) != null;
+    }
+    return false;
+  });
+
+  // Home-screen long-press quick actions. iOS: UIApplication.shortcutItems. Android: dynamic
+  // ShortcutManager shortcuts (API 25+; no-op below) whose launch intent carries appwrap_shortcut=<id>.
+  bridge.register('app.setShortcuts', ({ items }: { items: Array<{ id: string; title: string; subtitle?: string }> }) => {
+    const list = (items ?? []).filter((i) => i && i.id && i.title);
+    if (isIOS) {
+      Utils.dispatchToMainThread(() => {
+        const arr = NSMutableArray.alloc().init();
+        for (const i of list) {
+          const item = UIApplicationShortcutItem.alloc().initWithTypeLocalizedTitleLocalizedSubtitleIconUserInfo(
+            String(i.id), String(i.title), i.subtitle ? String(i.subtitle) : null, null, null
+          );
+          arr.addObject(item);
+        }
+        UIApplication.sharedApplication.shortcutItems = arr as any;
+      });
+    } else if (isAndroid) {
+      if (android.os.Build.VERSION.SDK_INT < 25) return; // ShortcutManager is API 25+
+      const ctx = Utils.android.getApplicationContext();
+      const sm = ctx.getSystemService(android.content.Context.SHORTCUT_SERVICE); // API 25+ string const
+      if (!sm) return;
+      const launchClass = (Application.android.foregroundActivity ?? Application.android.startActivity)?.getClass();
+      const shortcuts = new java.util.ArrayList();
+      for (const i of list) {
+        const intent = new android.content.Intent(android.content.Intent.ACTION_VIEW);
+        if (launchClass) intent.setClassName(ctx, launchClass.getName());
+        intent.putExtra('appwrap_shortcut', String(i.id));
+        intent.addFlags(android.content.Intent.FLAG_ACTIVITY_NEW_TASK | android.content.Intent.FLAG_ACTIVITY_CLEAR_TOP);
+        const b = new android.content.pm.ShortcutInfo.Builder(ctx, String(i.id))
+          .setShortLabel(String(i.title))
+          .setLongLabel(String(i.subtitle ?? i.title))
+          .setIntent(intent);
+        shortcuts.add(b.build());
+      }
+      sm.setDynamicShortcuts(shortcuts);
+    }
+  });
+
+  // Privacy screen — hide content in the app-switcher / block screenshots. iOS: cover the key window
+  // with a blur while inactive/backgrounded (wired via the app lifecycle below). Android: FLAG_SECURE.
+  bridge.register('screen.setPrivacy', ({ enabled }: { enabled: boolean }) => {
+    setPrivacyScreen(!!enabled);
+  });
+
   bridge.register('browser.open', ({ url, toolbarColor }: { url: string; toolbarColor?: string }) => {
     const target = String(url ?? '');
     if (!target) throw err('NATIVE_ERROR', 'browser.open: empty url');
@@ -139,3 +203,60 @@ export function registerSystemHandlers(): void {
     }
   });
 }
+
+// ── privacy screen ────────────────────────────────────────────────────
+// iOS keeps the enabled flag + lazily wires the lifecycle hooks once. The cover MUST go on at
+// `willResignActive` — that fires BEFORE the app-switcher snapshot, whereas NS's suspendEvent
+// (≈ didEnterBackground) fires AFTER it, so suspendEvent alone would leak the first snapshot. We
+// observe the raw UIApplicationWillResignActiveNotification for the cover, removing it on
+// becomeActive. Android flips FLAG_SECURE immediately (also blocks screenshots).
+let privacyEnabled = false;
+let privacyCover: UIView | null = null;
+let privacyLifecycleWired = false;
+
+function setPrivacyScreen(enabled: boolean): void {
+  privacyEnabled = enabled;
+  if (isIOS) {
+    wireIosPrivacyLifecycle();
+    if (!enabled) Utils.dispatchToMainThread(removeIosPrivacyCover); // disabling mid-foreground
+  } else if (isAndroid) {
+    Utils.dispatchToMainThread(() => {
+      const activity = Application.android.foregroundActivity ?? Application.android.startActivity;
+      const FLAG_SECURE = android.view.WindowManager.LayoutParams.FLAG_SECURE;
+      const window = activity?.getWindow();
+      if (!window) return;
+      if (enabled) window.setFlags(FLAG_SECURE, FLAG_SECURE);
+      else window.clearFlags(FLAG_SECURE);
+    });
+  }
+}
+
+function wireIosPrivacyLifecycle(): void {
+  if (privacyLifecycleWired) return;
+  privacyLifecycleWired = true;
+  const center = NSNotificationCenter.defaultCenter;
+  // willResignActive → cover BEFORE the OS captures the app-switcher snapshot (the critical timing).
+  center.addObserverForNameObjectQueueUsingBlock(
+    UIApplicationWillResignActiveNotification, null, null, () => { if (privacyEnabled) addIosPrivacyCover(); }
+  );
+  // didBecomeActive → reveal again once the user returns.
+  center.addObserverForNameObjectQueueUsingBlock(
+    UIApplicationDidBecomeActiveNotification, null, null, () => removeIosPrivacyCover()
+  );
+}
+
+function addIosPrivacyCover(): void {
+  const window = UIApplication.sharedApplication.keyWindow;
+  if (!window || privacyCover) return;
+  const effect = UIBlurEffect.effectWithStyle(UIBlurEffectStyle.SystemMaterial);
+  const blur = UIVisualEffectView.alloc().initWithEffect(effect);
+  blur.frame = window.bounds;
+  blur.autoresizingMask = UIViewAutoresizing.FlexibleWidth | UIViewAutoresizing.FlexibleHeight;
+  window.addSubview(blur);
+  privacyCover = blur;
+}
+
+function removeIosPrivacyCover(): void {
+  privacyCover?.removeFromSuperview();
+  privacyCover = null;
+}

package/runtime/app/shell/handlers.ts

@@ -7,6 +7,7 @@ import { showBanner, dismissBanner } from './banner';
 import { setStatusBarStyle } from './status-bar';
 import { buildCapabilityMap } from './capabilities.manifest';
 import { ACTIVE_MODULE_NAMES } from './active-modules.generated';
+import { consumePendingBackgroundTaskId } from './background-context';
 
 /** Build identifier for the native shell bundle — bump per deploy to spot stale bundles. */
 export const SHELL_BUILD = 'updates-devmenu-3';
@@ -27,12 +28,17 @@ export function registerHandlers(): void {
     // kit degrades gracefully. Push is special — gated by per-platform build config, not the manifest.
     const capabilities = buildCapabilityMap(new Set(ACTIVE_MODULE_NAMES), isIOS ? 'ios' : 'android') as Record<string, 'native' | 'none'>;
     capabilities.push = (isIOS ? SHELL_CONFIG.pushIos : SHELL_CONFIG.pushAndroid) ? 'native' : 'none';
+    // Background launch: the headless runner (handlers-background) set the wake id before loading this
+    // (offscreen) WebView. Report it so `kit.backgroundTask` dispatches the registered handler. Consumed
+    // (read-once) so a later foreground handshake in the same process never re-reports a stale wake.
+    const backgroundTaskId = consumePendingBackgroundTaskId();
     return {
       protocol: 1,
       platform: isIOS ? 'ios' : 'android',
       app: { id: SHELL_CONFIG.appId, name: SHELL_CONFIG.name, version: SHELL_CONFIG.version, build: SHELL_BUILD, loader: SHELL_CONFIG.loader },
       debug: { lastNotifTap: safeJson(ApplicationSettings.getString('kit:__notifTap', '')) },
       capabilities,
+      ...(backgroundTaskId ? { backgroundTaskId } : {}),
     };
   });
 

package/runtime/references.d.ts

@@ -1,2 +1,17 @@
 /// <reference path="./node_modules/@nativescript/types-ios/index.d.ts" />
 /// <reference path="./node_modules/@nativescript/types-android/lib/android-32.d.ts" />
+
+// Opt-in iOS framework typings the shell's native handlers use. @nativescript/types-ios ships the FULL
+// SDK but its default index references only a curated subset (for IDE/compile speed); reference the
+// extras here so handlers get real types + autocomplete instead of `any`. (NativeScript-documented:
+// blog.nativescript.org/where-did-my-types-go) Path arch ('objc-x86_64') is where they were generated;
+// the API surface is arch-independent for type-checking.
+/// <reference path="./node_modules/@nativescript/types-ios/lib/ios/objc-x86_64/objc!Contacts.d.ts" />
+/// <reference path="./node_modules/@nativescript/types-ios/lib/ios/objc-x86_64/objc!ContactsUI.d.ts" />
+/// <reference path="./node_modules/@nativescript/types-ios/lib/ios/objc-x86_64/objc!HealthKit.d.ts" />
+/// <reference path="./node_modules/@nativescript/types-ios/lib/ios/objc-x86_64/objc!EventKit.d.ts" />
+/// <reference path="./node_modules/@nativescript/types-ios/lib/ios/objc-x86_64/objc!CoreMotion.d.ts" />
+/// <reference path="./node_modules/@nativescript/types-ios/lib/ios/objc-x86_64/objc!StoreKit.d.ts" />
+/// <reference path="./node_modules/@nativescript/types-ios/lib/ios/objc-x86_64/objc!LocalAuthentication.d.ts" />
+/// <reference path="./node_modules/@nativescript/types-ios/lib/ios/objc-x86_64/objc!PhotosUI.d.ts" />
+/// <reference path="./node_modules/@nativescript/types-ios/lib/ios/objc-x86_64/objc!CoreLocation.d.ts" />

package/src/cli.ts

@@ -25,6 +25,8 @@ import {
   iosOrientations,
   mergeManifest,
   stampAndroidOrientation,
+  stampAndroidQueries,
+  stampPlistBackgroundTasks,
   stampPlistOrientations,
 } from './derive';
 
@@ -175,6 +177,7 @@ const OPTIONAL_GROUP_HANDLERS: Record<string, { file: string; fn: string }> = {
   reviews: { file: './handlers-reviews', fn: 'registerReviewsHandlers' },
   scanner: { file: './handlers-scanner', fn: 'registerScannerHandlers' },
   speech: { file: './handlers-speech', fn: 'registerSpeechHandlers' },
+  backgroundTask: { file: './handlers-background', fn: 'registerBackgroundTaskHandlers' },
 };
 
 /** Generate the two composition artifacts in the wrapper: the active capability list (drives the
@@ -195,6 +198,18 @@ function generateModuleArtifacts(outDir: string, req: NativeReqs): void {
     `/** Generated by \`appwrap\` — only the active strippable modules are imported. Do not edit. */\n` +
       `${imports}${imports ? '\n' : ''}\nexport function registerOptionalHandlers(): void {\n${calls}\n}\n`
   );
+
+  // iOS BGTaskScheduler launch handlers must register at didFinishLaunching (the AppDelegate calls
+  // registerBackgroundLaunchHandlers) — too early for the page-load barrel. Wire the real impl ONLY
+  // when backgroundTask is active, so a build without it never references BGTaskScheduler. No-op default.
+  const bgActive = req.activeOptionalGroups.includes('backgroundTask');
+  writeFileSync(
+    join(shell, 'background-bootstrap.generated.ts'),
+    `/** Generated by \`appwrap\` — wires the iOS BGTask launch handlers only when backgroundTask is active. Do not edit. */\n` +
+      (bgActive
+        ? `export { registerBackgroundTaskLaunchHandlers as registerBackgroundLaunchHandlers } from './handlers-background';\n`
+        : `export function registerBackgroundLaunchHandlers(): void {}\n`)
+  );
 }
 
 /** Stamp the active modules' gradle dependencies into Android app.gradle. Idempotent marker block. */
@@ -398,6 +413,12 @@ function stampIOSDisplayName(outDir: string, cfg: AppwrapConfig, req: NativeReqs
   // arrays (iPhone + ~ipad). Skipped when unset → keep the template's free-rotation default.
   if (cfg.orientation) src = stampPlistOrientations(src, iosOrientations(cfg.orientation));
 
+  // Headless background tasks (backgroundTask module): stamp BGTaskSchedulerPermittedIdentifiers +
+  // fetch/processing background modes from `backgroundTasks`. Idempotent both ways — passing []/undefined
+  // strips the block — so it no-ops (and cleans up) when the module is inactive or the field is absent.
+  const bgActive = req.activeOptionalGroups.includes('backgroundTask');
+  src = stampPlistBackgroundTasks(src, bgActive ? cfg.backgroundTasks : undefined);
+
   // Permission usage strings + URL scheme + export-compliance — idempotent: strip stamped block, re-add
   src = src.replace(/\s*<!-- appwrap:begin -->[\s\S]*?<!-- appwrap:end -->/g, '');
   const extras: string[] = [];
@@ -412,6 +433,12 @@ function stampIOSDisplayName(outDir: string, cfg: AppwrapConfig, req: NativeReqs
       `  <key>CFBundleURLTypes</key>\n  <array>\n    <dict>\n      <key>CFBundleTypeRole</key>\n      <string>Editor</string>\n      <key>CFBundleURLName</key>\n      <string>${cfg.id}</string>\n      <key>CFBundleURLSchemes</key>\n      <array>\n        <string>${cfg.urlScheme}</string>\n      </array>\n    </dict>\n  </array>`
     );
   }
+  // Schemes kit.app.canOpenUrl() may probe → LSApplicationQueriesSchemes (iOS 9+ requires declaration
+  // for custom schemes). No-op when absent.
+  if (cfg.queryUrlSchemes?.length) {
+    const items = cfg.queryUrlSchemes.map((s) => `    <string>${s}</string>`).join('\n');
+    extras.push(`  <key>LSApplicationQueriesSchemes</key>\n  <array>\n${items}\n  </array>`);
+  }
   if (extras.length) {
     src = src.replace(
       /<\/dict>\s*<\/plist>\s*$/,
@@ -644,6 +671,10 @@ function stampAndroidAppName(outDir: string, cfg: AppwrapConfig, req: NativeReqs
       /<!-- appwrap:application -->[\s\S]*?<!-- \/appwrap:application -->/,
       `<!-- appwrap:application -->\n\t\t${req.androidManifestApp.join('\n\t\t')}\n\t\t<!-- /appwrap:application -->`
     );
+    // <queries> for kit.app.canOpenUrl() visibility probes (API 30+) — idempotent marker. queryPackages
+    // → explicit <package>; queryUrlSchemes → a VIEW <intent> per scheme (symmetric with iOS's
+    // LSApplicationQueriesSchemes). See stampAndroidQueries.
+    src = stampAndroidQueries(src, cfg.queryPackages, cfg.queryUrlSchemes);
     writeFileSync(manifest, src);
   }
 }

package/src/config.ts

@@ -43,6 +43,19 @@ export interface AppwrapConfig {
   pwaDist: string;
   /** Custom URL scheme for deep links (e.g. "hellowrap" → hellowrap://...). */
   urlScheme?: string;
+  /** Custom URL schemes `kit.app.canOpenUrl()` may probe (e.g. `['whatsapp', 'tg']`) — covers BOTH
+   * platforms with a single declaration. Since iOS 9 / Android API 30+ a probe of an undeclared custom
+   * scheme returns false for privacy. These stamp into iOS Info.plist `LSApplicationQueriesSchemes` AND
+   * Android `<queries>` as a VIEW `<intent>` per scheme — so scheme-based `canOpenUrl` is symmetric
+   * without hand-mapping each scheme to a package. Common schemes (http/https/tel/mailto/sms) need no
+   * declaration on either platform. No-op when absent. */
+  queryUrlSchemes?: string[];
+  /** Android-only explicit package visibility for `kit.app.canOpenUrl()` (e.g. `['com.whatsapp']`) —
+   * for probing a specific package directly. Under API 30+ package visibility, `resolveActivity`
+   * returns null for undeclared packages — these stamp into AndroidManifest `<queries>` as
+   * `<package android:name="..."/>`. For scheme probes prefer `queryUrlSchemes` (cross-platform).
+   * No-op when absent. */
+  queryPackages?: string[];
   /** App icon source (≥512px square png). Defaults to the largest icon in the PWA manifest. */
   icon?: string;
   /** Loader: 'app' (default — app:// scheme, ES modules OK), 'file' (debug fallback), or 'server'
@@ -120,6 +133,13 @@ export interface AppwrapConfig {
    * (the per-app `permissions{}` map only OVERRIDES the default usage copy). When ABSENT, every
    * capability is active and permissions come solely from `permissions{}` (pre-modules behavior). */
   modules?: string[];
+  /** Permitted headless background-task identifiers (for the `backgroundTask` module). iOS REQUIRES
+   * these declared at build time — they stamp into Info.plist `BGTaskSchedulerPermittedIdentifiers`
+   * (without them `BGTaskScheduler.register` throws) plus `fetch`+`processing` into UIBackgroundModes.
+   * Android self-initializes WorkManager via its androidx startup provider — nothing to stamp. The
+   * same ids are what `kit.backgroundTask.register(id, …)` / `.schedule({id})` use. No-op when absent
+   * or the module is inactive. */
+  backgroundTasks?: string[];
   /** Remote push (APNs/FCM). Off unless set — gating matters: an `aps-environment` entitlement on a
    * team that can't hold the Push capability (e.g. a personal team) BREAKS code signing, and the
    * handshake should honestly report `push: 'none'` on an un-provisioned build. The kit returns a raw

package/src/derive.ts

@@ -97,3 +97,70 @@ export function stampAndroidOrientation(src: string, value: string): string {
     return stripped.replace(/(android:name="[^"]*")/, `$1\n\t\t\tandroid:screenOrientation="${value}"`);
   });
 }
+
+/**
+ * Rewrite the `<!-- appwrap:queries -->…<!-- /appwrap:queries -->` block in an AndroidManifest string
+ * for `kit.app.canOpenUrl()` visibility probes (API 30+). Both child kinds live in ONE `<queries>`:
+ *  - each `queryPackages` entry → explicit `<package android:name="…"/>` (Android-only package probe);
+ *  - each `queryUrlSchemes` entry → a VIEW `<intent>` on that scheme, so a custom-scheme probe is
+ *    symmetric with iOS's `LSApplicationQueriesSchemes` (no hand-mapping scheme→package needed).
+ * Pure + idempotent: always rewrites the marker block, so a re-sync never duplicates. No-op (empty
+ * block) when both lists are absent.
+ */
+/**
+ * Stamp (or strip) the headless background-task wiring in an Info.plist string for the `backgroundTask`
+ * module: `BGTaskSchedulerPermittedIdentifiers` (the permitted ids — iOS requires them declared at
+ * build time or `BGTaskScheduler.register` throws) AND the `fetch`+`processing` `UIBackgroundModes`
+ * (BGAppRefreshTask needs `fetch`, BGProcessingTask needs `processing`). Pure + idempotent: rewrites an
+ * `appwrap:bgtask` marker block (added before `</dict>`), and MERGES the two modes into any existing
+ * `UIBackgroundModes` array (a second `<key>` would be invalid plist — same hazard as push's
+ * `remote-notification`). `ids` empty/undefined → strips the block + removes the two modes it added.
+ */
+export function stampPlistBackgroundTasks(src: string, ids: string[] | undefined): string {
+  // 1) Always rewrite the marker block (permitted identifiers). Strip first → idempotent.
+  src = src.replace(/\s*<!-- appwrap:bgtask -->[\s\S]*?<!-- \/appwrap:bgtask -->/g, '');
+  const list = (ids ?? []).filter(Boolean);
+  if (list.length) {
+    const items = list.map((s) => `    <string>${s}</string>`).join('\n');
+    const block =
+      `  <!-- appwrap:bgtask -->\n` +
+      `  <key>BGTaskSchedulerPermittedIdentifiers</key>\n  <array>\n${items}\n  </array>\n` +
+      `  <!-- /appwrap:bgtask -->`;
+    src = src.replace(/<\/dict>\s*<\/plist>\s*$/, `${block}\n</dict>\n</plist>\n`);
+  }
+
+  // 2) Merge/remove the fetch + processing background modes (separate from the marker — they live in
+  //    the shared UIBackgroundModes array, which may also hold audio/remote-notification).
+  const modes = ['fetch', 'processing'];
+  const bgArray = /(<key>UIBackgroundModes<\/key>\s*<array>)([\s\S]*?)(<\/array>)/;
+  if (list.length) {
+    const need = modes.filter((m) => !new RegExp(`<string>${m}</string>`).test(src));
+    if (need.length) {
+      const inject = need.map((m) => `\t<string>${m}</string>`).join('\n');
+      src = bgArray.test(src)
+        ? src.replace(bgArray, (_m, open, inner, close) => `${open}${inner}${inject}\n\t${close}`)
+        : src.replace(
+            /<\/dict>\s*<\/plist>\s*$/,
+            `  <key>UIBackgroundModes</key>\n  <array>\n${need.map((m) => `    <string>${m}</string>`).join('\n')}\n  </array>\n</dict>\n</plist>\n`
+          );
+    }
+  } else {
+    for (const m of modes) src = src.replace(new RegExp(`\\s*<string>${m}</string>`), '');
+  }
+  return src;
+}
+
+export function stampAndroidQueries(src: string, queryPackages?: string[], queryUrlSchemes?: string[]): string {
+  const children = [
+    ...(queryPackages ?? []).map((p) => `\t\t<package android:name="${p}"/>`),
+    ...(queryUrlSchemes ?? []).map(
+      (s) => `\t\t<intent><action android:name="android.intent.action.VIEW"/><data android:scheme="${s}"/></intent>`
+    ),
+  ];
+  return src.replace(
+    /<!-- appwrap:queries -->[\s\S]*?<!-- \/appwrap:queries -->/,
+    children.length
+      ? `<!-- appwrap:queries -->\n\t<queries>\n${children.join('\n')}\n\t</queries>\n\t<!-- /appwrap:queries -->`
+      : `<!-- appwrap:queries -->\n\t<!-- /appwrap:queries -->`
+  );
+}

package/runtime/app/shell/ios-frameworks.d.ts

@@ -1,44 +0,0 @@
-/**
- * Ambient declarations for iOS frameworks not covered by the default
- * @nativescript/types-ios reference set (LocalAuthentication, CoreLocation,
- * PhotosUI). Marshalled at runtime by the NativeScript iOS runtime regardless.
- */
-declare const LAContext: any;
-declare const LAPolicy: any;
-declare const LABiometryType: any;
-declare const CLLocationManager: any;
-declare const CLAuthorizationStatus: any;
-declare const CLLocationManagerDelegate: any;
-declare const kCLLocationAccuracyHundredMeters: number;
-declare type CLLocation = any;
-declare type CLLocationManager = any;
-declare const PHPickerConfiguration: any;
-declare const PHPickerViewController: any;
-declare const PHPickerViewControllerDelegate: any;
-declare type PHPickerResult = any;
-declare type PHPickerViewController = any;
-// StoreKit / CoreMotion / ContactsUI / EventKit (parity handlers)
-declare const SKStoreReviewController: any;
-declare const CMMotionManager: any;
-declare const CMPedometer: any;
-// HealthKit (health/steps module)
-declare const HKHealthStore: any;
-declare const HKObjectType: any;
-declare const HKQuery: any;
-declare const HKStatisticsQuery: any;
-declare const HKStatisticsOptions: any;
-declare const HKUnit: any;
-declare const CNContactPickerViewController: any;
-declare const CNContactPickerDelegate: any;
-// Contacts framework (contacts.getAll bulk read — CNContactStore, vs the ContactsUI picker above)
-declare const CNContactStore: any;
-declare const CNEntityType: any;
-declare const CNContactFetchRequest: any;
-declare const CNContactGivenNameKey: any;
-declare const CNContactFamilyNameKey: any;
-declare const CNContactPhoneNumbersKey: any;
-declare const CNContactEmailAddressesKey: any;
-declare const EKEventStore: any;
-declare const EKEvent: any;
-declare const EKSpan: any;
-declare const EKEntityType: any;