@flighthq/keyboard 0.1.0

package/README.md

@@ -0,0 +1,105 @@
+# @flighthq/keyboard
+
+On-screen (soft) keyboard visibility, height, and frame over a swappable web/native backend.
+
+`keyboard` is an **event** cell in the platform-integration suite. A `SoftKeyboard` is a plain entity of signals; you allocate it with `createSoftKeyboard()`, start delivery with `attachSoftKeyboard()`, and release it with `disposeSoftKeyboard()`. Snapshot reads (`getSoftKeyboardInfo`, `getSoftKeyboardHeight`) and the control functions (`showSoftKeyboard`, `hideSoftKeyboard`, resize-mode / accessory-bar / scroll-assist / style) are free functions that delegate to the active `SoftKeyboardBackend`. A web/DOM backend is lazily available, so every function works on the web; a native host (Electron, Tauri, Capacitor, a C/C++ shell) replaces it via `setSoftKeyboardBackend`.
+
+Per-field input traits (input type, return-key label, auto-capitalize/correct, spell-check) are **not** here — they associate with a focused field and belong to `@flighthq/textinput`; this package owns the _global_ keyboard. Safe-area insets are owned by `@flighthq/device`.
+
+## Functions
+
+| Function | Purpose |
+| --- | --- |
+| `attachSoftKeyboard(keyboard)` | Start delivering backend changes to the entity's signals. Idempotent — a prior subscription is torn down first. |
+| `createSoftKeyboard()` | Allocate a `SoftKeyboard` with inert signals. |
+| `createSoftKeyboardInfo()` | Allocate a zeroed `SoftKeyboardInfo` to pass as `out`. |
+| `createSoftKeyboardTransition()` | Allocate a zeroed `SoftKeyboardTransition` (`durationSeconds: 0`, `height: 0`). |
+| `createWebSoftKeyboardBackend()` | Build the default web backend. |
+| `detachSoftKeyboard(keyboard)` | Stop delivery and forget the subscription. Safe when not attached. |
+| `disposeSoftKeyboard(keyboard)` | Detach the subscription so the entity is GC-eligible. |
+| `getSoftKeyboardBackend()` | Return the active backend, lazily creating the web default. There is always a backend. |
+| `getSoftKeyboardHeight()` | Return the current keyboard height in CSS pixels (`0` when hidden), no allocation. |
+| `getSoftKeyboardInfo(out)` | Fill `out` with the current keyboard snapshot and return it. |
+| `getSoftKeyboardResizeMode()` | Return the backend resize mode, or `SoftKeyboardResizeNoneKind` when unsupported. |
+| `hideSoftKeyboard()` | Request dismissal. No-op on web unless the Chromium VirtualKeyboard API is available. |
+| `isSoftKeyboardAccessoryBarVisible()` | Whether the iOS accessory bar is visible. `false` when unsupported. |
+| `isSoftKeyboardScrollAssistEnabled()` | Whether scroll-assist is enabled. `false` when unsupported. |
+| `setSoftKeyboardAccessoryBarVisible(visible)` | Show/hide the iOS accessory bar. No-op when unsupported. |
+| `setSoftKeyboardBackend(backend)` | Install a native host backend; pass `null` to fall back to the web default. |
+| `setSoftKeyboardResizeMode(mode)` | Set how the viewport reacts to the keyboard. No-op when unsupported. |
+| `setSoftKeyboardScrollAssistEnabled(enabled)` | Enable/disable scroll-assist. No-op when unsupported. |
+| `setSoftKeyboardStyle(style)` | Set the keyboard's light/dark appearance. No-op when unsupported. |
+| `showSoftKeyboard()` | Request presentation. No-op on web unless the Chromium VirtualKeyboard API is available. |
+
+## Signals
+
+`attachSoftKeyboard` drives nine signals on a `SoftKeyboard`. The **will** signals fire before the animation begins and carry a `SoftKeyboardTransition` (timing + target height); the **did** signals fire after it settles and carry the settled height. The simple-path aliases (`onShow` / `onHide` / `onResize`) fire alongside their did-phase counterparts.
+
+| Signal         | Phase | Payload                  | Fires on                                                   |
+| -------------- | ----- | ------------------------ | ---------------------------------------------------------- |
+| `onWillShow`   | will  | `SoftKeyboardTransition` | keyboard about to appear (hidden → visible)                |
+| `onWillHide`   | will  | `SoftKeyboardTransition` | keyboard about to disappear (visible → hidden)             |
+| `onWillResize` | will  | `SoftKeyboardTransition` | height about to change while staying visible               |
+| `onDidShow`    | did   | `height: number`         | keyboard finished appearing                                |
+| `onDidHide`    | did   | _(none)_                 | keyboard finished disappearing                             |
+| `onDidResize`  | did   | `height: number`         | keyboard settled at a new height (fires on every did edge) |
+| `onShow`       | did   | `height: number`         | alias firing with `onDidShow`                              |
+| `onHide`       | did   | _(none)_                 | alias firing with `onDidHide`                              |
+| `onResize`     | did   | `height: number`         | alias firing with `onDidResize`                            |
+
+The web default reports only the settled **did** phase (`durationSeconds: 0`); a native host that knows its animation timing emits the **will** phase first, so an app can animate in lockstep with the slide.
+
+## `SoftKeyboardInfo` fields
+
+| Field     | Type      | Unit                      | Hidden value |
+| --------- | --------- | ------------------------- | ------------ |
+| `visible` | `boolean` | —                         | `false`      |
+| `height`  | `number`  | CSS pixels                | `0`          |
+| `x`       | `number`  | CSS pixels (frame origin) | `0`          |
+| `y`       | `number`  | CSS pixels (frame origin) | `0`          |
+| `width`   | `number`  | CSS pixels (frame width)  | `0`          |
+
+The web backend prefers the Chromium VirtualKeyboard API's `boundingRect` for a precise frame; it otherwise infers `height` from the `window.visualViewport` shrink relative to `window.innerHeight`, reporting `y` as the viewport height and `width` as `window.innerWidth`. Where neither is present (no `window`, no `visualViewport`, no `navigator.virtualKeyboard`) it degrades to a hidden snapshot.
+
+## Resize-mode / style matrix
+
+These are optional backend capabilities. Each kind is an **open** string contract — a native host may register its own vendor-prefixed value (`'acme.custom'`).
+
+| Concern | Kind constants | Web default |
+| --- | --- | --- |
+| Resize mode | `SoftKeyboardResizeNoneKind` (`'None'`), `SoftKeyboardResizeBodyKind` (`'Body'`) | unsupported — `getSoftKeyboardResizeMode()` returns `None`, `setSoftKeyboardResizeMode` is a no-op |
+| Style | `SoftKeyboardStyleDefaultKind` (`'Default'`), `SoftKeyboardStyleDarkKind` (`'Dark'`) | unsupported — `setSoftKeyboardStyle` is a no-op |
+| Accessory bar (iOS) | — | unsupported — query returns `false`, setter is a no-op |
+| Scroll-assist | — | unsupported — query returns `false`, setter is a no-op |
+
+## Keyboard-aware layout recipe
+
+Animate your content in sync with the keyboard slide by listening on the **will** phase and using the transition's `durationSeconds` and target `height`. Fall back to the **did** phase for backends (the web default) that report only the settled state.
+
+```ts
+import { attachSoftKeyboard, createSoftKeyboard, disposeSoftKeyboard } from '@flighthq/keyboard';
+import { connectSignal } from '@flighthq/signals';
+
+const keyboard = createSoftKeyboard();
+
+// Will phase: a native host that knows its timing lets you start the matching animation early.
+connectSignal(keyboard.onWillShow, (transition) => {
+  // transition.height is the settled keyboard height; transition.durationSeconds is the slide time.
+  animateContentInset(transition.height, transition.durationSeconds);
+});
+connectSignal(keyboard.onWillHide, (transition) => {
+  animateContentInset(0, transition.durationSeconds);
+});
+
+// Did phase / web fallback: snap to the settled height (durationSeconds is 0 here).
+connectSignal(keyboard.onDidResize, (height) => {
+  animateContentInset(height, 0);
+});
+
+attachSoftKeyboard(keyboard);
+
+// Later, when the surface is torn down:
+disposeSoftKeyboard(keyboard);
+```
+
+`durationSeconds` is `0` on the web default, so an app that wants a uniform feel can supply its own duration there and reserve the reported duration for native hosts that emit the will phase. Easing the animation is left to the app (or a future `@flighthq/easing` extension of this recipe); this package reports timing and geometry only.

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './keyboard';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './keyboard';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/dist/keyboard.d.ts

@@ -0,0 +1,22 @@
+import type { SoftKeyboard, SoftKeyboardBackend, SoftKeyboardInfo, SoftKeyboardResizeMode, SoftKeyboardStyleKind, SoftKeyboardTransition } from '@flighthq/types';
+export declare function attachSoftKeyboard(keyboard: SoftKeyboard): void;
+export declare function createSoftKeyboard(): SoftKeyboard;
+export declare function createSoftKeyboardInfo(): SoftKeyboardInfo;
+export declare function createSoftKeyboardTransition(): SoftKeyboardTransition;
+export declare function createWebSoftKeyboardBackend(): SoftKeyboardBackend;
+export declare function detachSoftKeyboard(keyboard: SoftKeyboard): void;
+export declare function disposeSoftKeyboard(keyboard: SoftKeyboard): void;
+export declare function getSoftKeyboardBackend(): SoftKeyboardBackend;
+export declare function getSoftKeyboardHeight(): number;
+export declare function getSoftKeyboardInfo(out: SoftKeyboardInfo): SoftKeyboardInfo;
+export declare function getSoftKeyboardResizeMode(): SoftKeyboardResizeMode;
+export declare function hideSoftKeyboard(): void;
+export declare function isSoftKeyboardAccessoryBarVisible(): boolean;
+export declare function isSoftKeyboardScrollAssistEnabled(): boolean;
+export declare function setSoftKeyboardAccessoryBarVisible(visible: boolean): void;
+export declare function setSoftKeyboardBackend(backend: SoftKeyboardBackend | null): void;
+export declare function setSoftKeyboardResizeMode(mode: SoftKeyboardResizeMode): void;
+export declare function setSoftKeyboardScrollAssistEnabled(enabled: boolean): void;
+export declare function setSoftKeyboardStyle(style: SoftKeyboardStyleKind): void;
+export declare function showSoftKeyboard(): void;
+//# sourceMappingURL=keyboard.d.ts.map

package/dist/keyboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard.d.ts","sourceRoot":"","sources":["../src/keyboard.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,YAAY,EACZ,mBAAmB,EACnB,gBAAgB,EAEhB,sBAAsB,EACtB,qBAAqB,EACrB,sBAAsB,EACvB,MAAM,iBAAiB,CAAC;AAQzB,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAkC/D;AAGD,wBAAgB,kBAAkB,IAAI,YAAY,CAYjD;AAGD,wBAAgB,sBAAsB,IAAI,gBAAgB,CAEzD;AAGD,wBAAgB,4BAA4B,IAAI,sBAAsB,CAErE;AAQD,wBAAgB,4BAA4B,IAAI,mBAAmB,CAkDlE;AAGD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAM/D;AAID,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAEhE;AAGD,wBAAgB,sBAAsB,IAAI,mBAAmB,CAG5D;AAGD,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C;AAGD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,gBAAgB,GAAG,gBAAgB,CAE3E;AAID,wBAAgB,yBAAyB,IAAI,sBAAsB,CAGlE;AAID,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC;AAID,wBAAgB,iCAAiC,IAAI,OAAO,CAE3D;AAGD,wBAAgB,iCAAiC,IAAI,OAAO,CAE3D;AAID,wBAAgB,kCAAkC,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAEzE;AAGD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,GAAG,IAAI,CAEhF;AAID,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,sBAAsB,GAAG,IAAI,CAE5E;AAID,wBAAgB,kCAAkC,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAEzE;AAID,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,qBAAqB,GAAG,IAAI,CAEvE;AAID,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC"}

package/dist/keyboard.js

@@ -0,0 +1,232 @@
+import { createSignal, emitSignal } from '@flighthq/signals';
+import { SoftKeyboardResizeNoneKind } from '@flighthq/types';
+// Begins delivering on-screen keyboard changes to `keyboard`'s signals by subscribing to the active
+// backend. On each change it reads fresh info, emits will/did signal pairs (with onShow/onHide/onResize
+// aliases firing alongside the did-phase edge), and tracks visibility-edge transitions for
+// onWillShow/onWillHide and onDidShow/onDidHide pairs. Idempotent: a prior subscription is torn
+// down first. Pair with detachSoftKeyboard/disposeSoftKeyboard.
+export function attachSoftKeyboard(keyboard) {
+    detachSoftKeyboard(keyboard);
+    const backend = getSoftKeyboardBackend();
+    let wasVisible = backend.getInfo(_scratch).visible;
+    const unsubscribe = backend.subscribe((phase, transition) => {
+        const prevVisible = wasVisible;
+        const info = backend.getInfo(_scratch);
+        const nowVisible = info.visible;
+        if (phase === 'will') {
+            // Will-phase: emit will-signals before animation begins.
+            if (nowVisible && !prevVisible) {
+                emitSignal(keyboard.onWillShow, transition);
+            }
+            else if (!nowVisible && prevVisible) {
+                emitSignal(keyboard.onWillHide, transition);
+            }
+            else {
+                emitSignal(keyboard.onWillResize, transition);
+            }
+        }
+        else {
+            // Did-phase: emit did-signals (and simple-path aliases) after animation ends.
+            emitSignal(keyboard.onDidResize, info.height);
+            emitSignal(keyboard.onResize, info.height);
+            if (nowVisible !== prevVisible) {
+                wasVisible = nowVisible;
+                if (nowVisible) {
+                    emitSignal(keyboard.onDidShow, info.height);
+                    emitSignal(keyboard.onShow, info.height);
+                }
+                else {
+                    emitSignal(keyboard.onDidHide);
+                    emitSignal(keyboard.onHide);
+                }
+            }
+        }
+    });
+    _subscriptions.set(keyboard, unsubscribe);
+}
+// Allocates a SoftKeyboard event entity with inert signals; call attachSoftKeyboard to start delivery.
+export function createSoftKeyboard() {
+    return {
+        onShow: createSignal(),
+        onHide: createSignal(),
+        onResize: createSignal(),
+        onWillShow: createSignal(),
+        onWillHide: createSignal(),
+        onWillResize: createSignal(),
+        onDidShow: createSignal(),
+        onDidHide: createSignal(),
+        onDidResize: createSignal(),
+    };
+}
+// Allocates a zeroed SoftKeyboardInfo, suitable as the `out` for getSoftKeyboardInfo.
+export function createSoftKeyboardInfo() {
+    return { visible: false, height: 0, x: 0, y: 0, width: 0 };
+}
+// Allocates a zeroed SoftKeyboardTransition with durationSeconds 0 and height 0.
+export function createSoftKeyboardTransition() {
+    return { durationSeconds: 0, height: 0 };
+}
+// Builds the default web backend over window.visualViewport, inferring keyboard height from the
+// viewport shrink relative to window.innerHeight. Also uses the Chromium VirtualKeyboard API
+// (navigator.virtualKeyboard) when available: geometry comes from geometrychange, and
+// showSoftKeyboard/hideSoftKeyboard become real operations instead of no-ops.
+// Degrades to height 0 and a no-op subscription where the API is absent. All did-phase only
+// (durationSeconds: 0); native backends may emit will-phase with timing.
+export function createWebSoftKeyboardBackend() {
+    return {
+        getInfo(out) {
+            const geo = getWebKeyboardGeometry();
+            out.height = geo.height;
+            out.visible = geo.height > 0;
+            out.x = geo.x;
+            out.y = geo.y;
+            out.width = geo.width;
+            return out;
+        },
+        subscribe(listener) {
+            if (typeof window === 'undefined')
+                return () => { };
+            // transition.height stays 0 on web: this backend fires the 'did' phase only, where consumers
+            // read the settled geometry from getInfo(); the will-phase target height that transition.height
+            // is meant to carry is animation metadata the web viewport APIs never expose. Native hosts that
+            // emit a real 'will' phase must populate transition.height with the incoming keyboard height.
+            const transition = { durationSeconds: 0, height: 0 };
+            const fire = () => listener('did', transition);
+            // Use Chromium VirtualKeyboard API when available for geometry.
+            const virtualKeyboard = getVirtualKeyboard();
+            if (virtualKeyboard !== null) {
+                virtualKeyboard.addEventListener('geometrychange', fire);
+                return () => virtualKeyboard.removeEventListener('geometrychange', fire);
+            }
+            // Fall back to visualViewport resize/scroll.
+            const viewport = window.visualViewport;
+            if (viewport === undefined || viewport === null)
+                return () => { };
+            viewport.addEventListener('resize', fire);
+            viewport.addEventListener('scroll', fire);
+            return () => {
+                viewport.removeEventListener('resize', fire);
+                viewport.removeEventListener('scroll', fire);
+            };
+        },
+        show() {
+            const vk = getVirtualKeyboard();
+            if (vk !== null) {
+                vk.show();
+            }
+            // No-op on web without VirtualKeyboard API; the soft keyboard only opens when a field is focused.
+        },
+        hide() {
+            const vk = getVirtualKeyboard();
+            if (vk !== null) {
+                vk.hide();
+            }
+            // No-op on web without VirtualKeyboard API.
+        },
+    };
+}
+// Stops delivery to `keyboard` and forgets its subscription. Safe to call when not attached.
+export function detachSoftKeyboard(keyboard) {
+    const unsubscribe = _subscriptions.get(keyboard);
+    if (unsubscribe !== undefined) {
+        unsubscribe();
+        _subscriptions.delete(keyboard);
+    }
+}
+// Releases `keyboard` for garbage collection by detaching its backend subscription. The signals
+// remain plain GC-managed memory afterward.
+export function disposeSoftKeyboard(keyboard) {
+    detachSoftKeyboard(keyboard);
+}
+// The active soft keyboard backend, or a lazily-created web default. There is always a backend.
+export function getSoftKeyboardBackend() {
+    if (_backend === null)
+        _backend = createWebSoftKeyboardBackend();
+    return _backend;
+}
+// Returns the current on-screen keyboard height in CSS pixels without allocating. 0 when hidden.
+export function getSoftKeyboardHeight() {
+    return getSoftKeyboardBackend().getInfo(_scratch).height;
+}
+// Fills `out` with the current on-screen keyboard snapshot and returns it.
+export function getSoftKeyboardInfo(out) {
+    return getSoftKeyboardBackend().getInfo(out);
+}
+// Returns the current keyboard resize mode. Delegates to the backend; returns
+// SoftKeyboardResizeNoneKind when the backend does not support resize-mode queries.
+export function getSoftKeyboardResizeMode() {
+    const backend = getSoftKeyboardBackend();
+    return backend.getResizeMode?.() ?? SoftKeyboardResizeNoneKind;
+}
+// Requests that the host dismiss the on-screen keyboard. A no-op on web unless the
+// navigator.virtualKeyboard API is available (Chromium with virtualKeyboard policy).
+export function hideSoftKeyboard() {
+    getSoftKeyboardBackend().hide();
+}
+// Returns whether the input accessory bar (iOS toolbar above the keyboard) is visible.
+// Returns false when the backend does not support this query.
+export function isSoftKeyboardAccessoryBarVisible() {
+    return getSoftKeyboardBackend().getAccessoryBarVisible?.() ?? false;
+}
+// Returns whether scroll-assist is enabled. Returns false when the backend does not support this.
+export function isSoftKeyboardScrollAssistEnabled() {
+    return getSoftKeyboardBackend().getScrollAssistEnabled?.() ?? false;
+}
+// Controls whether the iOS input accessory bar (the toolbar above the keyboard) is visible.
+// No-op when the backend does not support this.
+export function setSoftKeyboardAccessoryBarVisible(visible) {
+    getSoftKeyboardBackend().setAccessoryBarVisible?.(visible);
+}
+// Installs a native host soft keyboard backend; pass null to fall back to the web default.
+export function setSoftKeyboardBackend(backend) {
+    _backend = backend;
+}
+// Controls keyboard resize behavior — how the app viewport reacts when the keyboard appears.
+// No-op when the backend does not support resize-mode control.
+export function setSoftKeyboardResizeMode(mode) {
+    getSoftKeyboardBackend().setResizeMode?.(mode);
+}
+// Controls whether the keyboard scroll-assist feature is enabled (scrolls the focused field into
+// view when the keyboard appears). No-op when the backend does not support this.
+export function setSoftKeyboardScrollAssistEnabled(enabled) {
+    getSoftKeyboardBackend().setScrollAssistEnabled?.(enabled);
+}
+// Sets the visual style / appearance of the on-screen keyboard (iOS light/dark keyboard appearance).
+// No-op on web and on backends that do not support style control.
+export function setSoftKeyboardStyle(style) {
+    getSoftKeyboardBackend().setStyle?.(style);
+}
+// Requests that the host present the on-screen keyboard. A no-op on web unless the
+// navigator.virtualKeyboard API is available (Chromium with virtualKeyboard policy).
+export function showSoftKeyboard() {
+    getSoftKeyboardBackend().show();
+}
+let _backend = null;
+const _scratch = createSoftKeyboardInfo();
+const _subscriptions = new WeakMap();
+function getVirtualKeyboard() {
+    if (typeof navigator === 'undefined')
+        return null;
+    const nav = navigator;
+    return nav.virtualKeyboard ?? null;
+}
+function getWebKeyboardGeometry() {
+    if (typeof window === 'undefined')
+        return { height: 0, width: 0, x: 0, y: 0 };
+    // Prefer the Chromium VirtualKeyboard API for precise geometry.
+    const vk = getVirtualKeyboard();
+    if (vk !== null) {
+        const rect = vk.boundingRect;
+        return { height: rect.height, width: rect.width, x: rect.x, y: rect.y };
+    }
+    // Fall back to inferring height from visualViewport shrink.
+    const viewport = window.visualViewport;
+    if (viewport === undefined || viewport === null)
+        return { height: 0, width: 0, x: 0, y: 0 };
+    const shrink = window.innerHeight - viewport.height;
+    const height = shrink > 0 ? shrink : 0;
+    const width = height > 0 ? window.innerWidth : 0;
+    const y = height > 0 ? viewport.height : 0;
+    return { height, width, x: 0, y };
+}
+//# sourceMappingURL=keyboard.js.map

package/dist/keyboard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard.js","sourceRoot":"","sources":["../src/keyboard.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@flighthq/keyboard",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**/*.test.ts",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts.map"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "test": "vitest run --config vitest.config.ts",
+    "test:watch": "vitest --watch --config vitest.config.ts",
+    "prepack": "npm run clean && npm run clean:dist && npm run build",
+    "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
+  },
+  "dependencies": {
+    "@flighthq/signals": "0.1.0",
+    "@flighthq/types": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  },
+  "description": "On-screen (soft) keyboard visibility, height, and show/hide/resize signals over a swappable web/native backend",
+  "sideEffects": false
+}

package/src/keyboard.test.ts

@@ -0,0 +1,918 @@
+import { cancelSignal, connectSignal } from '@flighthq/signals';
+import type {
+  SoftKeyboardBackend,
+  SoftKeyboardInfo,
+  SoftKeyboardPhase,
+  SoftKeyboardResizeMode,
+  SoftKeyboardTransition,
+} from '@flighthq/types';
+import {
+  SoftKeyboardResizeBodyKind,
+  SoftKeyboardResizeNoneKind,
+  SoftKeyboardStyleDarkKind,
+  SoftKeyboardStyleDefaultKind,
+} from '@flighthq/types';
+
+import {
+  attachSoftKeyboard,
+  createSoftKeyboard,
+  createSoftKeyboardInfo,
+  createSoftKeyboardTransition,
+  createWebSoftKeyboardBackend,
+  detachSoftKeyboard,
+  disposeSoftKeyboard,
+  getSoftKeyboardBackend,
+  getSoftKeyboardHeight,
+  getSoftKeyboardInfo,
+  getSoftKeyboardResizeMode,
+  hideSoftKeyboard,
+  isSoftKeyboardAccessoryBarVisible,
+  isSoftKeyboardScrollAssistEnabled,
+  setSoftKeyboardAccessoryBarVisible,
+  setSoftKeyboardBackend,
+  setSoftKeyboardResizeMode,
+  setSoftKeyboardScrollAssistEnabled,
+  setSoftKeyboardStyle,
+  showSoftKeyboard,
+} from './keyboard';
+
+type BackendListener = (phase: SoftKeyboardPhase, transition: Readonly<SoftKeyboardTransition>) => void;
+
+function fakeBackend(): SoftKeyboardBackend & {
+  visible: boolean;
+  height: number;
+  shown: boolean;
+  hidden: boolean;
+  resizeMode: string;
+  accessoryBarVisible: boolean;
+  scrollAssistEnabled: boolean;
+  style: string;
+  fire(phase?: SoftKeyboardPhase, durationSeconds?: number): void;
+} {
+  let listener: BackendListener | null = null;
+  return {
+    visible: false,
+    height: 0,
+    shown: false,
+    hidden: false,
+    resizeMode: SoftKeyboardResizeNoneKind,
+    accessoryBarVisible: false,
+    scrollAssistEnabled: false,
+    style: SoftKeyboardStyleDefaultKind,
+    getInfo(out) {
+      out.visible = this.visible;
+      out.height = this.height;
+      out.x = 0;
+      out.y = 0;
+      out.width = this.visible ? 375 : 0;
+      return out;
+    },
+    subscribe(l) {
+      listener = l;
+      return () => {
+        listener = null;
+      };
+    },
+    show() {
+      this.shown = true;
+    },
+    hide() {
+      this.hidden = true;
+    },
+    getResizeMode(): SoftKeyboardResizeMode {
+      return this.resizeMode as SoftKeyboardResizeMode;
+    },
+    setResizeMode(mode) {
+      this.resizeMode = mode;
+    },
+    setStyle(s) {
+      this.style = s;
+    },
+    getAccessoryBarVisible() {
+      return this.accessoryBarVisible;
+    },
+    setAccessoryBarVisible(v) {
+      this.accessoryBarVisible = v;
+    },
+    getScrollAssistEnabled() {
+      return this.scrollAssistEnabled;
+    },
+    setScrollAssistEnabled(v) {
+      this.scrollAssistEnabled = v;
+    },
+    fire(phase: SoftKeyboardPhase = 'did', durationSeconds = 0) {
+      listener?.call(null, phase, { durationSeconds, height: this.height });
+    },
+  };
+}
+
+type VirtualKeyboardStub = {
+  boundingRect: DOMRect;
+  addEventListener(type: string, fn: () => void): void;
+  removeEventListener(type: string, fn: () => void): void;
+  show(): void;
+  hide(): void;
+};
+
+// Overrides window.innerHeight / innerWidth for the duration of one test; callers restore via the
+// surrounding stubVisualViewport restore (window metrics reset on the next jsdom test anyway).
+function stubWindowMetrics(innerHeight: number, innerWidth: number): void {
+  Object.defineProperty(window, 'innerHeight', { value: innerHeight, configurable: true });
+  Object.defineProperty(window, 'innerWidth', { value: innerWidth, configurable: true });
+}
+
+// Installs (or clears, with null) window.visualViewport and returns a restore function.
+function stubVisualViewport(viewport: Readonly<VisualViewport> | { height: number } | null): () => void {
+  const had = Object.getOwnPropertyDescriptor(window, 'visualViewport');
+  Object.defineProperty(window, 'visualViewport', { value: viewport, configurable: true });
+  return () => {
+    if (had !== undefined) Object.defineProperty(window, 'visualViewport', had);
+    else Object.defineProperty(window, 'visualViewport', { value: undefined, configurable: true });
+  };
+}
+
+// Installs navigator.virtualKeyboard (the Chromium API) and returns a restore function.
+function stubVirtualKeyboard(vk: VirtualKeyboardStub): () => void {
+  const nav = navigator as Navigator & { virtualKeyboard?: VirtualKeyboardStub };
+  const had = nav.virtualKeyboard;
+  Object.defineProperty(nav, 'virtualKeyboard', { value: vk, configurable: true });
+  return () => {
+    if (had !== undefined) Object.defineProperty(nav, 'virtualKeyboard', { value: had, configurable: true });
+    else delete nav.virtualKeyboard;
+  };
+}
+
+afterEach(() => setSoftKeyboardBackend(null));
+
+describe('attachSoftKeyboard', () => {
+  it('emits onResize and onShow when the keyboard becomes visible (did phase)', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    const keyboard = createSoftKeyboard();
+    let resizes = 0;
+    let shows = 0;
+    connectSignal(keyboard.onResize, () => resizes++);
+    connectSignal(keyboard.onShow, () => shows++);
+    attachSoftKeyboard(keyboard);
+    backend.visible = true;
+    backend.height = 300;
+    backend.fire('did');
+    expect(resizes).toBe(1);
+    expect(shows).toBe(1);
+  });
+
+  it('emits onWillShow before the animation on will phase', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    const keyboard = createSoftKeyboard();
+    const willTransitions: Readonly<SoftKeyboardTransition>[] = [];
+    connectSignal(keyboard.onWillShow, (t) => willTransitions.push(t));
+    attachSoftKeyboard(keyboard);
+    backend.visible = true;
+    backend.height = 300;
+    backend.fire('will', 0.25);
+    expect(willTransitions).toHaveLength(1);
+    expect(willTransitions[0].durationSeconds).toBe(0.25);
+    expect(willTransitions[0].height).toBe(300);
+  });
+
+  it('emits onWillHide on will phase when transitioning hidden', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    const keyboard = createSoftKeyboard();
+    backend.visible = true;
+    backend.height = 300;
+    const willHides: Readonly<SoftKeyboardTransition>[] = [];
+    connectSignal(keyboard.onWillHide, (t) => willHides.push(t));
+    attachSoftKeyboard(keyboard);
+    // keyboard is currently visible, now hide
+    backend.visible = false;
+    backend.height = 0;
+    backend.fire('will', 0.3);
+    expect(willHides).toHaveLength(1);
+  });
+
+  it('emits onWillResize (not will show/hide) when visible stays the same', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    const keyboard = createSoftKeyboard();
+    backend.visible = true;
+    backend.height = 300;
+    const willResizes: Readonly<SoftKeyboardTransition>[] = [];
+    const willShows: Readonly<SoftKeyboardTransition>[] = [];
+    connectSignal(keyboard.onWillResize, (t) => willResizes.push(t));
+    connectSignal(keyboard.onWillShow, (t) => willShows.push(t));
+    attachSoftKeyboard(keyboard);
+    // stay visible but change height
+    backend.height = 350;
+    backend.fire('will', 0.1);
+    expect(willResizes).toHaveLength(1);
+    expect(willShows).toHaveLength(0);
+  });
+
+  it('emits did aliases alongside simple-path aliases', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    const keyboard = createSoftKeyboard();
+    let didShows = 0;
+    let onShows = 0;
+    connectSignal(keyboard.onDidShow, () => didShows++);
+    connectSignal(keyboard.onShow, () => onShows++);
+    attachSoftKeyboard(keyboard);
+    backend.visible = true;
+    backend.height = 300;
+    backend.fire('did');
+    expect(didShows).toBe(1);
+    expect(onShows).toBe(1);
+  });
+
+  it('emits onHide and onDidHide when keyboard hides', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    const keyboard = createSoftKeyboard();
+    backend.visible = true;
+    backend.height = 300;
+    let hides = 0;
+    let didHides = 0;
+    connectSignal(keyboard.onHide, () => hides++);
+    connectSignal(keyboard.onDidHide, () => didHides++);
+    attachSoftKeyboard(keyboard);
+    backend.visible = false;
+    backend.height = 0;
+    backend.fire('did');
+    expect(hides).toBe(1);
+    expect(didHides).toBe(1);
+  });
+
+  it('is idempotent: prior subscription torn down on re-attach', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    const keyboard = createSoftKeyboard();
+    let resizes = 0;
+    connectSignal(keyboard.onResize, () => resizes++);
+    attachSoftKeyboard(keyboard);
+    attachSoftKeyboard(keyboard);
+    backend.visible = true;
+    backend.height = 300;
+    backend.fire('did');
+    expect(resizes).toBe(1);
+  });
+
+  it('dispatches multiple listeners on a single did-show edge', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    const keyboard = createSoftKeyboard();
+    let a = 0;
+    let b = 0;
+    let c = 0;
+    connectSignal(keyboard.onDidShow, () => a++);
+    connectSignal(keyboard.onDidShow, () => b++);
+    connectSignal(keyboard.onDidShow, () => c++);
+    attachSoftKeyboard(keyboard);
+    backend.visible = true;
+    backend.height = 300;
+    backend.fire('did');
+    expect([a, b, c]).toEqual([1, 1, 1]);
+  });
+
+  it('honors listener priority on the onWillShow edge', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    const keyboard = createSoftKeyboard();
+    const order: string[] = [];
+    connectSignal(keyboard.onWillShow, () => order.push('low'), { priority: 0 });
+    connectSignal(keyboard.onWillShow, () => order.push('high'), { priority: 10 });
+    attachSoftKeyboard(keyboard);
+    backend.visible = true;
+    backend.height = 300;
+    backend.fire('will', 0.25);
+    expect(order).toEqual(['high', 'low']);
+  });
+
+  it('stops the onWillShow chain when an earlier listener cancels', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    const keyboard = createSoftKeyboard();
+    let reached = false;
+    connectSignal(keyboard.onWillShow, () => cancelSignal(keyboard.onWillShow), { priority: 10 });
+    connectSignal(keyboard.onWillShow, () => (reached = true), { priority: 0 });
+    attachSoftKeyboard(keyboard);
+    backend.visible = true;
+    backend.height = 300;
+    backend.fire('will', 0.25);
+    expect(reached).toBe(false);
+  });
+
+  it('keeps the will→did ordering across a full show transition', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    const keyboard = createSoftKeyboard();
+    const order: string[] = [];
+    connectSignal(keyboard.onWillShow, () => order.push('will'));
+    connectSignal(keyboard.onDidShow, () => order.push('did'));
+    attachSoftKeyboard(keyboard);
+    backend.visible = true;
+    backend.height = 300;
+    backend.fire('will', 0.25);
+    backend.fire('did');
+    expect(order).toEqual(['will', 'did']);
+  });
+
+  it('tracks visibility correctly across rapid show/hide bursts', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    const keyboard = createSoftKeyboard();
+    let shows = 0;
+    let hides = 0;
+    connectSignal(keyboard.onDidShow, () => shows++);
+    connectSignal(keyboard.onDidHide, () => hides++);
+    attachSoftKeyboard(keyboard);
+    for (let i = 0; i < 5; i++) {
+      backend.visible = true;
+      backend.height = 300;
+      backend.fire('did');
+      backend.visible = false;
+      backend.height = 0;
+      backend.fire('did');
+    }
+    expect(shows).toBe(5);
+    expect(hides).toBe(5);
+  });
+
+  it('does not re-emit show/hide edges when visibility is unchanged', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    const keyboard = createSoftKeyboard();
+    let shows = 0;
+    let resizes = 0;
+    connectSignal(keyboard.onDidShow, () => shows++);
+    connectSignal(keyboard.onDidResize, () => resizes++);
+    attachSoftKeyboard(keyboard);
+    backend.visible = true;
+    backend.height = 300;
+    backend.fire('did');
+    // stay visible across further did edges: no new show, but resize fires each time
+    backend.height = 320;
+    backend.fire('did');
+    backend.height = 340;
+    backend.fire('did');
+    expect(shows).toBe(1);
+    expect(resizes).toBe(3);
+  });
+
+  it('survives re-entrant detach from inside a listener', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    const keyboard = createSoftKeyboard();
+    let resizes = 0;
+    connectSignal(keyboard.onDidShow, () => detachSoftKeyboard(keyboard));
+    connectSignal(keyboard.onResize, () => resizes++);
+    attachSoftKeyboard(keyboard);
+    backend.visible = true;
+    backend.height = 300;
+    expect(() => backend.fire('did')).not.toThrow();
+    // detach during emit forgets the subscription; further fires deliver nothing
+    backend.fire('did');
+    expect(resizes).toBe(1);
+  });
+
+  it('survives re-entrant re-attach from inside a listener', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    const keyboard = createSoftKeyboard();
+    connectSignal(keyboard.onDidShow, () => attachSoftKeyboard(keyboard));
+    attachSoftKeyboard(keyboard);
+    backend.visible = true;
+    backend.height = 300;
+    expect(() => backend.fire('did')).not.toThrow();
+  });
+});
+
+describe('createSoftKeyboard', () => {
+  it('creates an entity with nine signals', () => {
+    const keyboard = createSoftKeyboard();
+    expect(keyboard.onShow).toBeDefined();
+    expect(keyboard.onHide).toBeDefined();
+    expect(keyboard.onResize).toBeDefined();
+    expect(keyboard.onWillShow).toBeDefined();
+    expect(keyboard.onWillHide).toBeDefined();
+    expect(keyboard.onWillResize).toBeDefined();
+    expect(keyboard.onDidShow).toBeDefined();
+    expect(keyboard.onDidHide).toBeDefined();
+    expect(keyboard.onDidResize).toBeDefined();
+  });
+});
+
+describe('createSoftKeyboardInfo', () => {
+  it('allocates a zeroed info including rect fields', () => {
+    expect(createSoftKeyboardInfo()).toEqual({ visible: false, height: 0, x: 0, y: 0, width: 0 });
+  });
+});
+
+describe('createSoftKeyboardTransition', () => {
+  it('allocates a zeroed transition', () => {
+    expect(createSoftKeyboardTransition()).toEqual({ durationSeconds: 0, height: 0 });
+  });
+});
+
+describe('createWebSoftKeyboardBackend', () => {
+  it('reads info without throwing', () => {
+    const out = createSoftKeyboardInfo();
+    expect(typeof createWebSoftKeyboardBackend().getInfo(out).visible).toBe('boolean');
+  });
+
+  it('returns rect fields with height 0 when no keyboard is present', () => {
+    const out = createSoftKeyboardInfo();
+    createWebSoftKeyboardBackend().getInfo(out);
+    expect(out.height).toBe(0);
+    expect(out.x).toBe(0);
+    expect(out.y).toBe(0);
+    expect(out.width).toBe(0);
+  });
+
+  it('subscribes and unsubscribes without throwing', () => {
+    const unsubscribe = createWebSoftKeyboardBackend().subscribe(() => {});
+    expect(() => unsubscribe()).not.toThrow();
+  });
+
+  it('show and hide are no-ops without throwing', () => {
+    const backend = createWebSoftKeyboardBackend();
+    expect(() => {
+      backend.show();
+      backend.hide();
+    }).not.toThrow();
+  });
+
+  it('infers height from a visualViewport shrink relative to window.innerHeight', () => {
+    const restore = stubVisualViewport({ height: 600 });
+    try {
+      stubWindowMetrics(900, 375);
+      const out = createSoftKeyboardInfo();
+      createWebSoftKeyboardBackend().getInfo(out);
+      expect(out.visible).toBe(true);
+      expect(out.height).toBe(300);
+      expect(out.width).toBe(375);
+      expect(out.y).toBe(600);
+    } finally {
+      restore();
+    }
+  });
+
+  it('reports no keyboard when the visualViewport has not shrunk', () => {
+    const restore = stubVisualViewport({ height: 900 });
+    try {
+      stubWindowMetrics(900, 375);
+      const out = createSoftKeyboardInfo();
+      createWebSoftKeyboardBackend().getInfo(out);
+      expect(out.visible).toBe(false);
+      expect(out.height).toBe(0);
+      expect(out.width).toBe(0);
+      expect(out.y).toBe(0);
+    } finally {
+      restore();
+    }
+  });
+
+  it('subscribes to visualViewport resize/scroll and fires a did transition', () => {
+    const events = new Map<string, () => void>();
+    const viewport = {
+      height: 600,
+      addEventListener(type: string, fn: () => void) {
+        events.set(type, fn);
+      },
+      removeEventListener(type: string) {
+        events.delete(type);
+      },
+    };
+    const restore = stubVisualViewport(viewport as unknown as VisualViewport);
+    try {
+      let phase: SoftKeyboardPhase | null = null;
+      const unsubscribe = createWebSoftKeyboardBackend().subscribe((p) => (phase = p));
+      expect(events.has('resize')).toBe(true);
+      expect(events.has('scroll')).toBe(true);
+      events.get('resize')!();
+      expect(phase).toBe('did');
+      unsubscribe();
+      expect(events.size).toBe(0);
+    } finally {
+      restore();
+    }
+  });
+
+  it('returns a no-op subscription when visualViewport is absent', () => {
+    const restore = stubVisualViewport(null);
+    try {
+      const unsubscribe = createWebSoftKeyboardBackend().subscribe(() => {});
+      expect(() => unsubscribe()).not.toThrow();
+    } finally {
+      restore();
+    }
+  });
+
+  it('prefers the VirtualKeyboard API for geometry when present', () => {
+    const restore = stubVirtualKeyboard({
+      boundingRect: { height: 280, width: 320, x: 5, y: 620 } as DOMRect,
+      addEventListener() {},
+      removeEventListener() {},
+      show() {},
+      hide() {},
+    });
+    try {
+      const out = createSoftKeyboardInfo();
+      createWebSoftKeyboardBackend().getInfo(out);
+      expect(out.height).toBe(280);
+      expect(out.width).toBe(320);
+      expect(out.x).toBe(5);
+      expect(out.y).toBe(620);
+      expect(out.visible).toBe(true);
+    } finally {
+      restore();
+    }
+  });
+
+  it('subscribes via the VirtualKeyboard geometrychange event when present', () => {
+    const events = new Map<string, () => void>();
+    const restore = stubVirtualKeyboard({
+      boundingRect: { height: 0, width: 0, x: 0, y: 0 } as DOMRect,
+      addEventListener(type: string, fn: () => void) {
+        events.set(type, fn);
+      },
+      removeEventListener(type: string) {
+        events.delete(type);
+      },
+      show() {},
+      hide() {},
+    });
+    try {
+      let phase: SoftKeyboardPhase | null = null;
+      const unsubscribe = createWebSoftKeyboardBackend().subscribe((p) => (phase = p));
+      expect(events.has('geometrychange')).toBe(true);
+      events.get('geometrychange')!();
+      expect(phase).toBe('did');
+      unsubscribe();
+      expect(events.has('geometrychange')).toBe(false);
+    } finally {
+      restore();
+    }
+  });
+
+  it('drives show/hide through the VirtualKeyboard API when present', () => {
+    let shown = false;
+    let hidden = false;
+    const restore = stubVirtualKeyboard({
+      boundingRect: { height: 0, width: 0, x: 0, y: 0 } as DOMRect,
+      addEventListener() {},
+      removeEventListener() {},
+      show() {
+        shown = true;
+      },
+      hide() {
+        hidden = true;
+      },
+    });
+    try {
+      const backend = createWebSoftKeyboardBackend();
+      backend.show();
+      backend.hide();
+      expect(shown).toBe(true);
+      expect(hidden).toBe(true);
+    } finally {
+      restore();
+    }
+  });
+});
+
+describe('detachSoftKeyboard', () => {
+  it('stops further delivery', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    const keyboard = createSoftKeyboard();
+    let resizes = 0;
+    connectSignal(keyboard.onResize, () => resizes++);
+    attachSoftKeyboard(keyboard);
+    detachSoftKeyboard(keyboard);
+    backend.fire();
+    expect(resizes).toBe(0);
+  });
+
+  it('is safe to call when not attached', () => {
+    const keyboard = createSoftKeyboard();
+    expect(() => detachSoftKeyboard(keyboard)).not.toThrow();
+  });
+
+  it('is safe to call twice', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    const keyboard = createSoftKeyboard();
+    attachSoftKeyboard(keyboard);
+    detachSoftKeyboard(keyboard);
+    expect(() => detachSoftKeyboard(keyboard)).not.toThrow();
+  });
+
+  it('re-attach after detach resumes delivery', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    const keyboard = createSoftKeyboard();
+    let resizes = 0;
+    connectSignal(keyboard.onResize, () => resizes++);
+    attachSoftKeyboard(keyboard);
+    detachSoftKeyboard(keyboard);
+    attachSoftKeyboard(keyboard);
+    backend.visible = true;
+    backend.height = 300;
+    backend.fire('did');
+    expect(resizes).toBe(1);
+  });
+});
+
+describe('disposeSoftKeyboard', () => {
+  it('detaches the subscription', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    const keyboard = createSoftKeyboard();
+    attachSoftKeyboard(keyboard);
+    expect(() => disposeSoftKeyboard(keyboard)).not.toThrow();
+  });
+
+  it('stops further delivery after dispose', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    const keyboard = createSoftKeyboard();
+    let resizes = 0;
+    connectSignal(keyboard.onResize, () => resizes++);
+    attachSoftKeyboard(keyboard);
+    disposeSoftKeyboard(keyboard);
+    backend.fire();
+    expect(resizes).toBe(0);
+  });
+
+  it('is safe to call when already detached', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    const keyboard = createSoftKeyboard();
+    attachSoftKeyboard(keyboard);
+    detachSoftKeyboard(keyboard);
+    expect(() => disposeSoftKeyboard(keyboard)).not.toThrow();
+  });
+
+  it('is safe to call twice', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    const keyboard = createSoftKeyboard();
+    attachSoftKeyboard(keyboard);
+    disposeSoftKeyboard(keyboard);
+    expect(() => disposeSoftKeyboard(keyboard)).not.toThrow();
+  });
+
+  it('is safe to call when never attached', () => {
+    const keyboard = createSoftKeyboard();
+    expect(() => disposeSoftKeyboard(keyboard)).not.toThrow();
+  });
+});
+
+describe('getSoftKeyboardBackend', () => {
+  it('falls back to a web backend', () => {
+    expect(getSoftKeyboardBackend()).not.toBeNull();
+  });
+});
+
+describe('getSoftKeyboardHeight', () => {
+  it('returns the current keyboard height without allocating', () => {
+    const backend = fakeBackend();
+    backend.visible = true;
+    backend.height = 320;
+    setSoftKeyboardBackend(backend);
+    expect(getSoftKeyboardHeight()).toBe(320);
+  });
+
+  it('returns 0 when keyboard is hidden', () => {
+    const backend = fakeBackend();
+    backend.visible = false;
+    backend.height = 0;
+    setSoftKeyboardBackend(backend);
+    expect(getSoftKeyboardHeight()).toBe(0);
+  });
+});
+
+describe('getSoftKeyboardInfo', () => {
+  it('fills the out parameter from the backend', () => {
+    const backend = fakeBackend();
+    backend.height = 250;
+    backend.visible = true;
+    setSoftKeyboardBackend(backend);
+    const out = createSoftKeyboardInfo();
+    expect(getSoftKeyboardInfo(out)).toBe(out);
+    expect(out.height).toBe(250);
+    expect(out.visible).toBe(true);
+  });
+
+  it('populates rect fields', () => {
+    const backend = fakeBackend();
+    backend.height = 250;
+    backend.visible = true;
+    setSoftKeyboardBackend(backend);
+    const out = createSoftKeyboardInfo();
+    getSoftKeyboardInfo(out);
+    expect(out.x).toBe(0);
+    expect(out.y).toBe(0);
+    expect(out.width).toBe(375);
+  });
+});
+
+describe('getSoftKeyboardResizeMode', () => {
+  it('delegates to backend getResizeMode', () => {
+    const backend = fakeBackend();
+    backend.resizeMode = SoftKeyboardResizeBodyKind;
+    setSoftKeyboardBackend(backend);
+    expect(getSoftKeyboardResizeMode()).toBe(SoftKeyboardResizeBodyKind);
+  });
+
+  it('returns SoftKeyboardResizeNoneKind when backend does not support it', () => {
+    const backend: SoftKeyboardBackend = {
+      getInfo(out) {
+        return out;
+      },
+      subscribe() {
+        return () => {};
+      },
+      show() {},
+      hide() {},
+    };
+    setSoftKeyboardBackend(backend);
+    expect(getSoftKeyboardResizeMode()).toBe(SoftKeyboardResizeNoneKind);
+  });
+});
+
+describe('hideSoftKeyboard', () => {
+  it('delegates to the backend hide', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    hideSoftKeyboard();
+    expect(backend.hidden).toBe(true);
+  });
+});
+
+describe('isSoftKeyboardAccessoryBarVisible', () => {
+  it('delegates to backend getAccessoryBarVisible', () => {
+    const backend = fakeBackend();
+    backend.accessoryBarVisible = true;
+    setSoftKeyboardBackend(backend);
+    expect(isSoftKeyboardAccessoryBarVisible()).toBe(true);
+  });
+
+  it('returns false when backend does not support it', () => {
+    const backend: SoftKeyboardBackend = {
+      getInfo(out) {
+        return out;
+      },
+      subscribe() {
+        return () => {};
+      },
+      show() {},
+      hide() {},
+    };
+    setSoftKeyboardBackend(backend);
+    expect(isSoftKeyboardAccessoryBarVisible()).toBe(false);
+  });
+});
+
+describe('isSoftKeyboardScrollAssistEnabled', () => {
+  it('delegates to backend getScrollAssistEnabled', () => {
+    const backend = fakeBackend();
+    backend.scrollAssistEnabled = true;
+    setSoftKeyboardBackend(backend);
+    expect(isSoftKeyboardScrollAssistEnabled()).toBe(true);
+  });
+
+  it('returns false when backend does not support it', () => {
+    const backend: SoftKeyboardBackend = {
+      getInfo(out) {
+        return out;
+      },
+      subscribe() {
+        return () => {};
+      },
+      show() {},
+      hide() {},
+    };
+    setSoftKeyboardBackend(backend);
+    expect(isSoftKeyboardScrollAssistEnabled()).toBe(false);
+  });
+});
+
+describe('setSoftKeyboardAccessoryBarVisible', () => {
+  it('delegates to backend setAccessoryBarVisible', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    setSoftKeyboardAccessoryBarVisible(true);
+    expect(backend.accessoryBarVisible).toBe(true);
+    setSoftKeyboardAccessoryBarVisible(false);
+    expect(backend.accessoryBarVisible).toBe(false);
+  });
+
+  it('is a no-op when backend does not support it', () => {
+    const backend: SoftKeyboardBackend = {
+      getInfo(out) {
+        return out;
+      },
+      subscribe() {
+        return () => {};
+      },
+      show() {},
+      hide() {},
+    };
+    setSoftKeyboardBackend(backend);
+    expect(() => setSoftKeyboardAccessoryBarVisible(true)).not.toThrow();
+  });
+});
+
+describe('setSoftKeyboardBackend', () => {
+  it('clears back to the web fallback when passed null', () => {
+    setSoftKeyboardBackend(fakeBackend());
+    setSoftKeyboardBackend(null);
+    expect(getSoftKeyboardBackend()).not.toBeNull();
+  });
+});
+
+describe('setSoftKeyboardResizeMode', () => {
+  it('delegates to backend setResizeMode', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    setSoftKeyboardResizeMode(SoftKeyboardResizeBodyKind);
+    expect(backend.resizeMode).toBe(SoftKeyboardResizeBodyKind);
+  });
+
+  it('is a no-op when backend does not support it', () => {
+    const backend: SoftKeyboardBackend = {
+      getInfo(out) {
+        return out;
+      },
+      subscribe() {
+        return () => {};
+      },
+      show() {},
+      hide() {},
+    };
+    setSoftKeyboardBackend(backend);
+    expect(() => setSoftKeyboardResizeMode(SoftKeyboardResizeBodyKind)).not.toThrow();
+  });
+});
+
+describe('setSoftKeyboardScrollAssistEnabled', () => {
+  it('delegates to backend setScrollAssistEnabled', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    setSoftKeyboardScrollAssistEnabled(true);
+    expect(backend.scrollAssistEnabled).toBe(true);
+    setSoftKeyboardScrollAssistEnabled(false);
+    expect(backend.scrollAssistEnabled).toBe(false);
+  });
+
+  it('is a no-op when backend does not support it', () => {
+    const backend: SoftKeyboardBackend = {
+      getInfo(out) {
+        return out;
+      },
+      subscribe() {
+        return () => {};
+      },
+      show() {},
+      hide() {},
+    };
+    setSoftKeyboardBackend(backend);
+    expect(() => setSoftKeyboardScrollAssistEnabled(true)).not.toThrow();
+  });
+});
+
+describe('setSoftKeyboardStyle', () => {
+  it('delegates to backend setStyle', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    setSoftKeyboardStyle(SoftKeyboardStyleDarkKind);
+    expect(backend.style).toBe(SoftKeyboardStyleDarkKind);
+  });
+
+  it('is a no-op when backend does not support it', () => {
+    const backend: SoftKeyboardBackend = {
+      getInfo(out) {
+        return out;
+      },
+      subscribe() {
+        return () => {};
+      },
+      show() {},
+      hide() {},
+    };
+    setSoftKeyboardBackend(backend);
+    expect(() => setSoftKeyboardStyle(SoftKeyboardStyleDarkKind)).not.toThrow();
+  });
+});
+
+describe('showSoftKeyboard', () => {
+  it('delegates to the backend show', () => {
+    const backend = fakeBackend();
+    setSoftKeyboardBackend(backend);
+    showSoftKeyboard();
+    expect(backend.shown).toBe(true);
+  });
+});