@livx.cc/appwrap 0.61.6 → 0.61.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livx.cc/appwrap",
-  "version": "0.61.6",
+  "version": "0.61.8",
   "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/capabilities.manifest.ts

@@ -80,7 +80,14 @@ export const MANIFEST_SCHEMA_VERSION = 1;
 export const MODULES: ModuleManifest[] = [
   // ── core (always on, no permissions) ───────────────────────────────────
   { name: 'haptics', core: true, group: 'core', capabilities: { haptics: 'native' } },
-  { name: 'share', core: true, group: 'core', capabilities: { share: 'native', shareFiles: 'native' } },
+  // `shareFiles` hands a file to the OS sheet, and one of the activities the sheet offers for a
+  // photo or video is "Save Image"/"Save Video" — which WRITES to the camera roll. iOS omits that
+  // activity SILENTLY when the app carries no add-only photo-library usage string, so the sheet
+  // appears correct and simply lacks the one row the person was reaching for.
+  {
+    name: 'share', core: true, group: 'core', capabilities: { share: 'native', shareFiles: 'native' },
+    ios: { permissions: [{ key: 'NSPhotoLibraryAddUsageDescription', domain: 'photosAdd', defaultUsage: 'Save a photo or video you chose to your library.' }] },
+  },
   { name: 'storage', core: true, group: 'core', capabilities: { storage: 'native', secureStorage: 'native' } },
   // fs: app-sandbox file I/O (documents/data/cache) + system document picker. Core — every root is
   // inside the app sandbox and the picker returns user-chosen security-scoped URIs → zero perms.

package/runtime/app/shell/keyboard-frame.ts

@@ -0,0 +1,67 @@
+/**
+ * Pure iOS keyboard-frame decision (no NativeScript/UIKit globals — unit-testable).
+ *
+ * Decides how many points of the screen a keyboard notification's end frame covers, or why the
+ * event must NOT shrink the webview. A hidden keyboard must always end at full height, so any
+ * doubtful event resolves to "skip" — the hide pair (willHide/didHide) owns the restore.
+ */
+export type KeyboardEventTag = 'willShow' | 'didShow' | 'willChangeFrame';
+
+export interface KeyboardFrameInput {
+  tag: KeyboardEventTag;
+  /** willShow/didShow seen since the last willHide/didHide — the keyboard is (becoming) visible. */
+  inShowCycle: boolean;
+  /** UIKeyboardFrameEndUserInfoKey, in screen coordinates. Absent → nothing to apply. */
+  end?: { y: number };
+  /** Window height, or the SCREEN height when the webview is momentarily out of a window. */
+  containerHeight: number;
+}
+
+export interface KeyboardFrameDecision {
+  height: number;
+  skip?: 'no-frame' | 'off-screen' | 'out-of-cycle' | 'bogus';
+}
+
+export function resolveKeyboardHeight(input: KeyboardFrameInput): KeyboardFrameDecision {
+  const { tag, inShowCycle, end, containerHeight } = input;
+  if (!end || !(containerHeight > 0)) return { height: 0, skip: 'no-frame' };
+  // Overlap with the container, NOT the frame's height: iOS delivers keyboard-sized but off-screen
+  // end frames during dismissal — the frame height would shrink a keyboard-less screen.
+  const height = Math.max(0, Math.round(containerHeight - end.y));
+  if (height <= 0) return { height: 0, skip: 'off-screen' };
+  // willChangeFrame also fires OUTSIDE a show cycle (after didHide: iframe/dialog teardown, audio
+  // session / speech-recognition takeover) with an on-screen end frame. Applying it re-shrinks a
+  // keyboard-less screen and nothing restores it (field bug: half-screen empty band across screens).
+  // A keyboard that really appears always posts willShow or didShow (warm re-focus = didShow-only),
+  // which re-opens the cycle and lands the shrink.
+  if (tag === 'willChangeFrame' && !inShowCycle) return { height: 0, skip: 'out-of-cycle' };
+  // Bogus full-screen frames (origin.y≈0, seen during SMS-OTP autofill): a real software keyboard is
+  // never >85% of the screen; the real frame follows and self-heals.
+  if (height > containerHeight * 0.85) return { height, skip: 'bogus' };
+  return { height };
+}
+
+/**
+ * Stateful show-cycle gate around resolveKeyboardHeight: willShow/didShow open the cycle (a keyboard
+ * really appearing posts one of these), the hide pair closes it. Owns the flag so keyboard.ts can't
+ * forget to open or close it.
+ */
+export function createKeyboardShowCycle() {
+  let open = false;
+  return {
+    resolve(input: Omit<KeyboardFrameInput, 'inShowCycle'>): KeyboardFrameDecision {
+      if (input.tag === 'willChangeFrame') return resolveKeyboardHeight({ ...input, inShowCycle: open });
+      const decision = resolveKeyboardHeight({ ...input, inShowCycle: true });
+      // Only a show event with an on-screen keyboard opens the cycle: a skipped (off-screen/no-frame)
+      // didShow must not arm a following stray willChangeFrame. 'bogus' is a real keyboard mid-autofill
+      // whose true frame follows as willChangeFrame, so it opens.
+      if (!decision.skip || decision.skip === 'bogus') open = true;
+      // Known, unproven ordering: a late on-screen didShow AFTER didHide still opens + shrinks with no
+      // restoring hide to follow. Accepted until the device root cause is confirmed.
+      return decision;
+    },
+    close(): void {
+      open = false;
+    },
+  };
+}

package/runtime/app/shell/keyboard.ts

@@ -1,6 +1,7 @@
 import { Application, Utils, isAndroid, isIOS } from '@nativescript/core';
 import { bridge } from './bridge';
 import { SHELL_CONFIG } from './config';
+import { createKeyboardShowCycle, type KeyboardEventTag } from './keyboard-frame';
 import { appwrapNativeLog } from './native-log';
 
 declare const android: any;
@@ -19,6 +20,7 @@ declare const NSObject: any;
 declare const UIScrollViewDelegate: any;
 declare function CGPointMake(x: number, y: number): any;
 declare const UIColor: any;
+declare const UIScreen: any;
 
 let observersArmed = false;
 
@@ -76,6 +78,9 @@ function armIosKeyboardObservers(): void {
   // height → apply the configured extra lift to close the gap. Reset when the keyboard fully hides.
   let sawWillShow = false;
   let activeExtraLift = 0;
+  // willShow/didShow seen since the last willHide/didHide. Only a live show cycle may shrink via
+  // willChangeFrame — out-of-cycle frames re-shrank a keyboard-less screen (see keyboard-frame.ts).
+  const showCycle = createKeyboardShowCycle();
 
   const getWk = (): WKWebView | undefined => bridge.getWebView()?.ios as WKWebView | undefined;
 
@@ -110,7 +115,10 @@ function armIosKeyboardObservers(): void {
     const wv = bridge.getWebView();
     const wk = getWk();
     const win = wk?.window;
-    if (!wv || !wk || !win) {
+    // The RESTORE (margin 0) needs no window — only a shrink needs the safe-area inset. Waiting for a
+    // window on restore let a webview detached through a screen transition exhaust the retries and
+    // stay shrunk on the next screen.
+    if (!wv || !wk || (paddingBottom > 0 && !win)) {
       if (attempt < 20) pendingUpdate = setTimeout(() => Utils.dispatchToMainThread(() => updateFrame(attempt + 1)), 100);
       else if (SHELL_CONFIG.debug) appwrapNativeLog(`[native:keyboard] frame update gave up (webview detached), pad=${paddingBottom}`);
       return;
@@ -120,7 +128,7 @@ function armIosKeyboardObservers(): void {
     // which is what produced gaps, content under the status bar, and residual scroll state.
     // Subtract the bottom safe-area inset: NS layout already excludes it, and the keyboard COVERS
     // it — margining the full keyboard height double-counts those 34pt as a gap above the keyboard.
-    const safeBottom = win.safeAreaInsets?.bottom ?? 0;
+    const safeBottom = win?.safeAreaInsets?.bottom ?? 0;
     // On a WARM re-focus iOS 26 reports a keyboard TALLER than it draws (it reserves the ▲▼✓ accessory
     // row but doesn't draw it), leaving bare black native space between the shrunk webview and the
     // real keys. `activeExtraLift` (see onShow) is the configured extra lift on those warm shows and 0
@@ -147,33 +155,26 @@ function armIosKeyboardObservers(): void {
   // Re-focus does NOT re-fire willShow — capture-verified: a second tap arrives ONLY as
   // didShow/willChangeFrame. All three feed the same idempotent handler; whichever iOS sends, the
   // shrink lands. Height-0 frame events do nothing (hide is owned by the willHide/didHide pair).
-  const onShow = (tag: string, settleMs: number | null) => (note: any): void => {
+  const onShow = (tag: KeyboardEventTag, settleMs: number | null) => (note: any): void => {
     detachWebKitKeyboardHandling();
     if (tag === 'willShow') sawWillShow = true; // cold acquire → the accessory bar will be drawn
     // Warm re-focus (didShow/willChangeFrame with no willShow this cycle) → bar dropped → lift extra.
     activeExtraLift = sawWillShow ? 0 : (SHELL_CONFIG.iosKeyboardExtraLift ?? 82);
     const value = note?.userInfo?.objectForKey?.(UIKeyboardFrameEndUserInfoKey);
-    // Overlap with the window, NOT frame.size.height: iOS delivers keyboard-sized but off-screen
-    // end-frames during dismissal — size.height would shrink a keyboard-less screen.
-    let height = 0;
-    let winH = 0;
-    if (value) {
-      const end = value.CGRectValue;
-      const win = getWk()?.window;
-      winH = win ? win.bounds.size.height : 0;
-      height = winH ? Math.max(0, Math.round(winH - end.origin.y)) : Math.round(end.size.height);
-    }
-    if (SHELL_CONFIG.debug) appwrapNativeLog(`[native:keyboard] ${tag} height=${height}`);
+    const rect = value?.CGRectValue;
+    // Keyboard frames are in screen coordinates: a webview momentarily out of its window (screen
+    // transition) measures against the screen — never the raw frame height, which is keyboard-sized
+    // even for the off-screen end frames iOS posts during dismissal.
+    const win = getWk()?.window;
+    const containerHeight = win ? win.bounds.size.height : UIScreen.mainScreen.bounds.size.height;
+    const { height, skip } = showCycle.resolve({
+      tag,
+      end: rect ? { y: rect.origin.y } : undefined,
+      containerHeight,
+    });
+    if (SHELL_CONFIG.debug) appwrapNativeLog(`[native:keyboard] ${tag} height=${height}${skip ? ` skip=${skip}` : ''} (container=${Math.round(containerHeight)})`);
     resetScrollView();
-    if (height <= 0) return;
-    // Guard against bogus full-screen keyboard frames. iOS occasionally delivers a transitional frame
-    // with origin.y≈0 (seen during SMS-OTP autofill) → height ≈ the whole window → the resize would
-    // shrink the webview to a sliver (huge black gap). A real software keyboard is never >85% of the
-    // screen; ignore the event and wait for the real frame (which follows and self-heals).
-    if (winH && height > winH * 0.85) {
-      if (SHELL_CONFIG.debug) appwrapNativeLog(`[native:keyboard] ignore bogus height=${height} (win=${Math.round(winH)})`);
-      return;
-    }
+    if (skip) return;
     // Paint the webview/window backdrop the page color so the resize shows no white flash. (The
     // iOS-26 phantom keyboard-height gap is closed geometrically by the extra lift in updateFrame.)
     syncBackdropColor();
@@ -187,11 +188,13 @@ function armIosKeyboardObservers(): void {
   center.addObserverForNameObjectQueueUsingBlock(UIKeyboardDidShowNotification, null, null, onShow('didShow', 50));
   center.addObserverForNameObjectQueueUsingBlock(UIKeyboardWillHideNotification, null, null, () => {
     if (SHELL_CONFIG.debug) appwrapNativeLog('[native:keyboard] willHide → restore');
+    showCycle.close(); // dismissal's willChangeFrame must not re-shrink
     setKeyboardHeight(0, 10);
     resetScrollView();
     bridge.emit('keyboard.hide');
   });
   center.addObserverForNameObjectQueueUsingBlock(UIKeyboardDidHideNotification, null, null, () => {
+    showCycle.close();
     setKeyboardHeight(0, 10); // enforcement pass — a hidden keyboard must always end at full height
     resetScrollView();
     sawWillShow = false; // keyboard fully gone → next show re-decides cold (bar) vs warm (no bar)

package/runtime/tests/keyboard-frame.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, test } from 'bun:test';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { createKeyboardShowCycle, resolveKeyboardHeight } from '../app/shell/keyboard-frame';
+
+/**
+ * iOS keyboard avoidance must never leave the webview shrunk once the keyboard is gone.
+ * Field bug pinned: Blank's "Fan Reach" call dialog (input in a showModal <dialog> in a sandboxed
+ * iframe, then TTS + STT) left a half-screen empty band that persisted onto the home grid.
+ */
+const H = 844; // iPhone 13 Pro window height (pt)
+const KB = { y: H - 336 }; // on-screen keyboard end frame
+
+describe('resolveKeyboardHeight', () => {
+  test('cold show applies the on-screen overlap', () => {
+    expect(resolveKeyboardHeight({ tag: 'willShow', inShowCycle: true, end: KB, containerHeight: H })).toEqual({ height: 336 });
+  });
+
+  test('warm re-focus (didShow-only) still applies', () => {
+    expect(resolveKeyboardHeight({ tag: 'didShow', inShowCycle: true, end: KB, containerHeight: H }).height).toBe(336);
+    expect(resolveKeyboardHeight({ tag: 'didShow', inShowCycle: true, end: KB, containerHeight: H }).skip).toBeUndefined();
+  });
+
+  test('willChangeFrame inside a show cycle (keyboard resize) applies', () => {
+    const end = { y: H - 380 };
+    expect(resolveKeyboardHeight({ tag: 'willChangeFrame', inShowCycle: true, end, containerHeight: H })).toEqual({ height: 380 });
+  });
+
+  test('willChangeFrame AFTER didHide with an on-screen frame does not re-shrink', () => {
+    expect(resolveKeyboardHeight({ tag: 'willChangeFrame', inShowCycle: false, end: KB, containerHeight: H })).toEqual({ height: 0, skip: 'out-of-cycle' });
+  });
+
+  test('keyboard-sized off-screen dismissal frame is zero overlap', () => {
+    expect(resolveKeyboardHeight({ tag: 'willChangeFrame', inShowCycle: true, end: { y: H }, containerHeight: H }).skip).toBe('off-screen');
+  });
+
+  test('no container height never falls back to the raw frame height', () => {
+    expect(resolveKeyboardHeight({ tag: 'didShow', inShowCycle: true, end: { y: H }, containerHeight: 0 })).toEqual({ height: 0, skip: 'no-frame' });
+  });
+
+  test('bogus full-screen frame is skipped', () => {
+    expect(resolveKeyboardHeight({ tag: 'willShow', inShowCycle: true, end: { y: 0 }, containerHeight: H }).skip).toBe('bogus');
+  });
+});
+
+describe('createKeyboardShowCycle', () => {
+  const frame = (tag: 'willShow' | 'didShow' | 'willChangeFrame') => ({ tag, end: KB, containerHeight: H });
+
+  test('a fresh cycle ignores a stray willChangeFrame', () => {
+    expect(createKeyboardShowCycle().resolve(frame('willChangeFrame')).skip).toBe('out-of-cycle');
+  });
+
+  test('willShow opens the cycle so a following willChangeFrame resize applies', () => {
+    const cycle = createKeyboardShowCycle();
+    expect(cycle.resolve(frame('willShow'))).toEqual({ height: 336 });
+    expect(cycle.resolve(frame('willChangeFrame'))).toEqual({ height: 336 });
+  });
+
+  test('a skipped (off-screen / no-frame) didShow does not open the cycle for a stray willChangeFrame', () => {
+    const cycle = createKeyboardShowCycle();
+    expect(cycle.resolve({ tag: 'didShow', end: { y: H }, containerHeight: H }).skip).toBe('off-screen');
+    expect(cycle.resolve(frame('willChangeFrame')).skip).toBe('out-of-cycle');
+    expect(cycle.resolve({ tag: 'didShow', containerHeight: H }).skip).toBe('no-frame');
+    expect(cycle.resolve(frame('willChangeFrame')).skip).toBe('out-of-cycle');
+  });
+
+  test('a bogus (autofill full-screen) willShow still opens the cycle so the real frame lands', () => {
+    const cycle = createKeyboardShowCycle();
+    expect(cycle.resolve({ tag: 'willShow', end: { y: 0 }, containerHeight: H }).skip).toBe('bogus');
+    expect(cycle.resolve(frame('willChangeFrame'))).toEqual({ height: 336 });
+  });
+
+  test('warm re-focus (didShow-only) re-opens the cycle after a hide', () => {
+    const cycle = createKeyboardShowCycle();
+    cycle.resolve(frame('willShow'));
+    cycle.close();
+    expect(cycle.resolve(frame('willChangeFrame')).skip).toBe('out-of-cycle');
+    expect(cycle.resolve(frame('didShow'))).toEqual({ height: 336 });
+    expect(cycle.resolve(frame('willChangeFrame'))).toEqual({ height: 336 });
+  });
+});
+
+// Source-level wiring (keyboard.ts imports NativeScript and can't load under bun).
+const src = readFileSync(join(import.meta.dir, '..', 'app', 'shell', 'keyboard.ts'), 'utf8');
+describe('keyboard.ts wiring', () => {
+  test('onShow routes through the show-cycle gate', () => {
+    expect(src).toMatch(/showCycle\.resolve\(\{/);
+    expect(src).not.toMatch(/resolveKeyboardHeight\(/);
+  });
+  test('both hide notifications close the show cycle', () => {
+    const hides = src.split('UIKeyboardWillHideNotification, null, null')[1] ?? '';
+    expect((hides.match(/showCycle\.close\(\)/g) ?? []).length).toBe(2);
+  });
+  test('restore to full height does not wait for the webview to be in a window', () => {
+    expect(src).toMatch(/if \(!wv \|\| !wk \|\| \(paddingBottom > 0 && !win\)\)/);
+  });
+});