@swiftbrowser/native 0.17.7 → 0.17.8

package/src/runtime.ts

@@ -15,6 +15,7 @@
  * `mediaSession`, mediaSession.ts), `Image` (image.ts, on a bridge with `probeImage`) with the
  * bridge's `__sbImageProbed`, `Worker` (worker.ts) with the bridge's
  * `__sbWorkerMessage` and `__sbWorkerError`, `__sbOpenURL` (openURL.ts),
+ * `__sbNotificationPermission`, `__sbPushRegistered` and `__sbNotification` (notifications.ts),
  * and the bridge's callbacks `__sbTimerFired` and `__sbFetchResult`. In a
  * worker's own context (its bridge has
  * `workerPostMessage`), `self`, `postMessage`, `addEventListener` and
@@ -30,7 +31,14 @@ import { createImageGlobals } from './image';
 import { SimpleURL, SimpleURLSearchParams } from './url';
 import { installWorkerScope, NativeWorker } from './worker';
 import { createMediaSession, NativeMediaMetadata } from './mediaSession';
+import { createNotificationGlobals } from './notifications';
 import { receiveOpenURL } from './openURL';
+import { objectURL, SimpleBlob, SimpleFile, SimpleFormData } from './blob';
+import { setBodyRandomness } from './fetch';
+import { NativeWebSocket } from './webSocket';
+import { createSubtleCrypto } from './subtle';
+import { matchMedia } from './matchMedia';
+import { installHostRequests, receiveHostResponse } from './hostRequests';
 
 type AnyGlobal = Record<string, unknown>;
 
@@ -172,6 +180,35 @@ export function installRuntime(native: NativeBridge, target: AnyGlobal = globalT
   define('URL', SimpleURL);
   define('URLSearchParams', SimpleURLSearchParams);
 
+  // Bytes with a type, files and forms (blob.ts): what `fetch` uploads, and
+  // what a picked file or a built image is. `URL.createObjectURL` is a `data:` URL.
+  define('Blob', SimpleBlob);
+  define('File', SimpleFile);
+  define('FormData', SimpleFormData);
+  const urlStatics = target['URL'] as { createObjectURL?: unknown; revokeObjectURL?: unknown };
+  if (urlStatics && typeof urlStatics.createObjectURL !== 'function') {
+    urlStatics.createObjectURL = (blob: SimpleBlob) => objectURL(blob);
+    urlStatics.revokeObjectURL = () => {};
+  }
+  const random = (count: number): Uint8Array => base64Decode(native.randomBytes(count));
+  setBodyRandomness(random);
+
+  // WebSockets (webSocket.ts) over the host's `URLSessionWebSocketTask`.
+  if (native.wsOpen && native.wsSend && native.wsClose) {
+    NativeWebSocket.install({ wsOpen: native.wsOpen.bind(native), wsSend: native.wsSend.bind(native), wsClose: native.wsClose.bind(native) });
+    define('WebSocket', NativeWebSocket);
+    define('__sbWebSocketEvent', NativeWebSocket.receive);
+  }
+
+  // `matchMedia`: the color scheme the host sends (run.ts), nothing else.
+  define('matchMedia', matchMedia);
+
+  // Host requests (hostRequests.ts): the share sheet, the pickers, the pasteboard, a sign-in.
+  if (native.hostRequest && !native.workerPostMessage) {
+    installHostRequests({ hostRequest: native.hostRequest.bind(native) });
+    define('__sbHostResponse', receiveHostResponse);
+  }
+
   // `Image`, for code that loads a picture to learn its size (React's
   // `AsyncImage`): the host reads it through its image loader.
   if (native.probeImage && !native.workerPostMessage) {
@@ -186,6 +223,8 @@ export function installRuntime(native: NativeBridge, target: AnyGlobal = globalT
       new Uint8Array(array.buffer, array.byteOffset, array.byteLength).set(bytes.subarray(0, array.byteLength));
       return array;
     },
+    // Digests and HMAC on the host's CryptoKit (subtle.ts).
+    subtle: createSubtleCrypto(native),
     randomUUID: (): string => {
       const bytes = base64Decode(native.randomBytes(16));
       bytes[6] = (bytes[6]! & 0x0f) | 0x40;
@@ -216,15 +255,36 @@ export function installRuntime(native: NativeBridge, target: AnyGlobal = globalT
     onLine: true,
     platform: 'iOS',
     hardwareConcurrency: 1,
+    // A haptic for a vibration; the pattern's length does not matter.
+    vibrate: (pattern: number | number[]): boolean => {
+      if (!native.haptic) return false;
+      const length = Array.isArray(pattern) ? pattern.reduce((sum, ms) => sum + Number(ms), 0) : Number(pattern);
+      if (!(length > 0)) return true;
+      native.haptic(length >= 200 ? 'impact' : 'selection');
+      return true;
+    },
   };
   // What plays, for the lock screen and the media keys (mediaSession.ts); not in a worker.
   const mediaSession = native.mediaSession && !native.workerPostMessage ? createMediaSession(native) : null;
   if (mediaSession) navigator['mediaSession'] = mediaSession.session;
+  // Notifications (notifications.ts): the browser's `Notification` and the
+  // badge over UserNotifications, and the push registration; not in a worker.
+  const notifications = native.notificationShow && !native.workerPostMessage ? createNotificationGlobals(native) : null;
+  if (notifications) {
+    navigator['setAppBadge'] = notifications.setAppBadge;
+    navigator['clearAppBadge'] = notifications.clearAppBadge;
+  }
   define('navigator', navigator);
   if (mediaSession) {
     define('MediaMetadata', NativeMediaMetadata);
     define('__sbMediaSessionCommand', mediaSession.receive);
   }
+  if (notifications) {
+    define('Notification', notifications.Notification);
+    define('__sbNotificationPermission', notifications.__sbNotificationPermission);
+    define('__sbPushRegistered', notifications.__sbPushRegistered);
+    define('__sbNotification', notifications.__sbNotification);
+  }
 
   if (native.workerPostMessage) {
     installed.push(...installWorkerScope(native, target));

package/src/secureStorage.ts

@@ -0,0 +1,39 @@
+/**
+ * `secureStorage`: `localStorage`'s shape over the Keychain, for what must
+ * not sit in plain text (a session token). The host's `secureGet`,
+ * `secureSet` and `secureRemove` are generic-password items of the app's
+ * (`kSecAttrAccessibleAfterFirstUnlock`, so a background fetch can read
+ * them). In the page (the round trip, or a browser) there is no Keychain:
+ * the values go to `localStorage` under a prefix, as a web app keeps them.
+ */
+
+import { nativeBridge, type NativeBridge } from './bridge';
+
+export type SecureStorageBridge = Pick<NativeBridge, 'secureGet' | 'secureSet' | 'secureRemove'>;
+
+export interface SecureStorage {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+  removeItem(key: string): void;
+}
+
+const PREFIX = 'swiftbrowser.secure.';
+
+/** Secure storage over `native`, or over `localStorage` when the host has no Keychain. */
+export function createSecureStorage(native: SecureStorageBridge | undefined, fallback: () => Storage | undefined): SecureStorage {
+  if (native?.secureGet && native.secureSet && native.secureRemove) {
+    return {
+      getItem: (key) => native.secureGet!(String(key)),
+      setItem: (key, value) => native.secureSet!(String(key), String(value)),
+      removeItem: (key) => native.secureRemove!(String(key)),
+    };
+  }
+  return {
+    getItem: (key) => fallback()?.getItem(PREFIX + String(key)) ?? null,
+    setItem: (key, value) => fallback()?.setItem(PREFIX + String(key), String(value)),
+    removeItem: (key) => fallback()?.removeItem(PREFIX + String(key)),
+  };
+}
+
+/** The app's secure storage: the Keychain in the native app, `localStorage` in the page. */
+export const secureStorage: SecureStorage = createSecureStorage(nativeBridge(), () => (typeof localStorage === 'undefined' ? undefined : localStorage));

package/src/subtle.ts

@@ -0,0 +1,87 @@
+/**
+ * `crypto.subtle` for the native app, as far as apps use it for a PKCE
+ * challenge or a signature: `digest` (SHA-1, SHA-256, SHA-384, SHA-512) and
+ * HMAC keys with `importKey`, `sign` and `verify`, over the bridge's
+ * `digest` and `hmac` (CryptoKit on the Swift side). Both are synchronous
+ * there; the promises resolve at once.
+ */
+
+import type { NativeBridge } from './bridge';
+import { base64Decode, base64Encode } from './encoding';
+
+export type SubtleBridge = Pick<NativeBridge, 'digest' | 'hmac'>;
+
+type Algorithm = string | { name: string; hash?: string | { name: string } };
+
+interface HmacKey {
+  type: 'secret';
+  extractable: boolean;
+  algorithm: { name: 'HMAC'; hash: { name: string }; length: number };
+  usages: string[];
+  /** The key's bytes, kept here: the host signs with them each time. */
+  readonly bytes: Uint8Array;
+}
+
+const DIGESTS = new Set(['SHA-1', 'SHA-256', 'SHA-384', 'SHA-512']);
+
+function algorithmName(algorithm: Algorithm): string {
+  return (typeof algorithm === 'string' ? algorithm : algorithm.name).toUpperCase();
+}
+
+function hashName(algorithm: Algorithm): string {
+  if (typeof algorithm === 'string') return algorithm.toUpperCase();
+  const hash = algorithm.hash;
+  return (typeof hash === 'string' ? hash : hash?.name ?? '').toUpperCase();
+}
+
+function bytesOf(data: ArrayBuffer | ArrayBufferView): Uint8Array {
+  return data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+}
+
+function toBuffer(base64: string): ArrayBuffer {
+  const bytes = base64Decode(base64);
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer;
+}
+
+function notSupported(what: string): Error {
+  const error = new Error(`crypto.subtle: ${what} is not supported in the native app`);
+  error.name = 'NotSupportedError';
+  return error;
+}
+
+/** `crypto.subtle` over the bridge. */
+export function createSubtleCrypto(native: SubtleBridge) {
+  return {
+    async digest(algorithm: Algorithm, data: ArrayBuffer | ArrayBufferView): Promise<ArrayBuffer> {
+      const name = algorithmName(algorithm);
+      if (!DIGESTS.has(name)) throw notSupported(`the ${name} digest`);
+      const result = native.digest?.(name, base64Encode(bytesOf(data)));
+      if (!result) throw notSupported(`the ${name} digest`);
+      return toBuffer(result);
+    },
+
+    async importKey(format: string, keyData: ArrayBuffer | ArrayBufferView, algorithm: Algorithm, extractable: boolean, usages: string[]): Promise<HmacKey> {
+      if (format !== 'raw' || algorithmName(algorithm) !== 'HMAC') throw notSupported(`importing a ${format} ${algorithmName(algorithm)} key`);
+      const hash = hashName(algorithm);
+      if (!DIGESTS.has(hash)) throw notSupported(`HMAC with ${hash}`);
+      const bytes = bytesOf(keyData);
+      return { type: 'secret', extractable, algorithm: { name: 'HMAC', hash: { name: hash }, length: bytes.byteLength * 8 }, usages: [...usages], bytes };
+    },
+
+    async sign(algorithm: Algorithm, key: HmacKey, data: ArrayBuffer | ArrayBufferView): Promise<ArrayBuffer> {
+      if (algorithmName(algorithm) !== 'HMAC' || key.algorithm?.name !== 'HMAC') throw notSupported(`signing with ${algorithmName(algorithm)}`);
+      const result = native.hmac?.(key.algorithm.hash.name, base64Encode(key.bytes), base64Encode(bytesOf(data)));
+      if (!result) throw notSupported('HMAC');
+      return toBuffer(result);
+    },
+
+    async verify(algorithm: Algorithm, key: HmacKey, signature: ArrayBuffer | ArrayBufferView, data: ArrayBuffer | ArrayBufferView): Promise<boolean> {
+      const expected = new Uint8Array(await this.sign(algorithm, key, data));
+      const given = bytesOf(signature);
+      if (expected.byteLength !== given.byteLength) return false;
+      let difference = 0;
+      for (let i = 0; i < expected.byteLength; i += 1) difference |= expected[i]! ^ given[i]!;
+      return difference === 0;
+    },
+  };
+}

package/src/webSocket.ts

@@ -0,0 +1,175 @@
+/**
+ * `WebSocket` for the native app over the bridge's `wsOpen`, `wsSend` and
+ * `wsClose` (`URLSessionWebSocketTask` on the Swift side). What the socket
+ * receives arrives at `__sbWebSocketEvent(id, json)`: `{ type: "open",
+ * protocol }`, `{ type: "message", text }` or `{ type: "message", binary }`
+ * (base64), `{ type: "error", message }` and `{ type: "close", code, reason,
+ * wasClean }`. The browser's event model as apps use it: `onopen`,
+ * `onmessage`, `onerror`, `onclose`, `addEventListener`, `readyState`,
+ * `binaryType` (`blob` by default, or `arraybuffer`).
+ */
+
+import { SimpleBlob } from './blob';
+import type { NativeBridge } from './bridge';
+import { base64Decode, base64Encode } from './encoding';
+
+export interface WebSocketEventLike {
+  type: string;
+  target: NativeWebSocket;
+  data?: unknown;
+  code?: number;
+  reason?: string;
+  wasClean?: boolean;
+  message?: string;
+}
+
+type Handler = (event: WebSocketEventLike) => void;
+
+/** The bridge's event for socket `id`. */
+export interface NativeWebSocketEvent {
+  type: 'open' | 'message' | 'error' | 'close';
+  protocol?: string;
+  text?: string;
+  /** Base64. */
+  binary?: string;
+  message?: string;
+  code?: number;
+  reason?: string;
+  wasClean?: boolean;
+}
+
+export type WebSocketBridge = Required<Pick<NativeBridge, 'wsOpen' | 'wsSend' | 'wsClose'>>;
+
+const sockets = new Map<number, NativeWebSocket>();
+let nextId = 1;
+let bridge: WebSocketBridge | null = null;
+
+export class NativeWebSocket {
+  static readonly CONNECTING = 0;
+  static readonly OPEN = 1;
+  static readonly CLOSING = 2;
+  static readonly CLOSED = 3;
+  readonly CONNECTING = 0;
+  readonly OPEN = 1;
+  readonly CLOSING = 2;
+  readonly CLOSED = 3;
+
+  readonly url: string;
+  readyState = 0;
+  protocol = '';
+  extensions = '';
+  bufferedAmount = 0;
+  binaryType: 'blob' | 'arraybuffer' = 'blob';
+  onopen: Handler | null = null;
+  onmessage: Handler | null = null;
+  onerror: Handler | null = null;
+  onclose: Handler | null = null;
+
+  private readonly id: number;
+  private readonly listeners = new Map<string, Set<Handler>>();
+
+  constructor(url: string | { href: string }, protocols: string | string[] = []) {
+    if (!bridge) throw new TypeError('WebSocket: no native bridge');
+    const href = typeof url === 'string' ? url : url.href;
+    if (!/^wss?:\/\//i.test(href)) throw new SyntaxError(`WebSocket: the URL's scheme must be ws or wss: ${href}`);
+    this.url = href;
+    this.id = nextId++;
+    sockets.set(this.id, this);
+    bridge.wsOpen(this.id, href, typeof protocols === 'string' ? [protocols] : [...protocols]);
+  }
+
+  send(data: string | ArrayBuffer | ArrayBufferView | SimpleBlob): void {
+    if (this.readyState === NativeWebSocket.CONNECTING) throw new DOMExceptionLike('InvalidStateError', 'WebSocket: still connecting');
+    if (this.readyState !== NativeWebSocket.OPEN) return;
+    if (typeof data === 'string') {
+      bridge?.wsSend(this.id, JSON.stringify({ text: data }));
+      return;
+    }
+    const bytes = data instanceof SimpleBlob ? data.bytes() : data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    bridge?.wsSend(this.id, JSON.stringify({ binary: base64Encode(bytes) }));
+  }
+
+  close(code?: number, reason?: string): void {
+    if (code !== undefined && code !== 1000 && !(code >= 3000 && code <= 4999)) throw new DOMExceptionLike('InvalidAccessError', 'WebSocket: the close code must be 1000 or in 3000–4999');
+    if (this.readyState === NativeWebSocket.CLOSING || this.readyState === NativeWebSocket.CLOSED) return;
+    this.readyState = NativeWebSocket.CLOSING;
+    bridge?.wsClose(this.id, code ?? 1000, reason ?? '');
+  }
+
+  addEventListener(type: string, handler: Handler): void {
+    let set = this.listeners.get(type);
+    if (!set) {
+      set = new Set();
+      this.listeners.set(type, set);
+    }
+    set.add(handler);
+  }
+
+  removeEventListener(type: string, handler: Handler): void {
+    this.listeners.get(type)?.delete(handler);
+  }
+
+  dispatchEvent(event: WebSocketEventLike): boolean {
+    const own = { open: this.onopen, message: this.onmessage, error: this.onerror, close: this.onclose }[event.type];
+    own?.(event);
+    for (const handler of this.listeners.get(event.type) ?? []) handler(event);
+    return true;
+  }
+
+  /** The bridge's event for this socket. */
+  receive(event: NativeWebSocketEvent): void {
+    switch (event.type) {
+      case 'open':
+        if (this.readyState !== NativeWebSocket.CONNECTING) return;
+        this.readyState = NativeWebSocket.OPEN;
+        this.protocol = event.protocol ?? '';
+        this.dispatchEvent({ type: 'open', target: this });
+        return;
+      case 'message': {
+        if (this.readyState !== NativeWebSocket.OPEN) return;
+        let data: unknown = event.text ?? '';
+        if (event.binary !== undefined) {
+          const bytes = base64Decode(event.binary);
+          data = this.binaryType === 'arraybuffer' ? bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) : new SimpleBlob([bytes]);
+        }
+        this.dispatchEvent({ type: 'message', target: this, data });
+        return;
+      }
+      case 'error':
+        this.dispatchEvent({ type: 'error', target: this, message: event.message ?? '' });
+        return;
+      case 'close':
+        if (this.readyState === NativeWebSocket.CLOSED) return;
+        this.readyState = NativeWebSocket.CLOSED;
+        sockets.delete(this.id);
+        this.dispatchEvent({ type: 'close', target: this, code: event.code ?? 1006, reason: event.reason ?? '', wasClean: event.wasClean ?? false });
+        return;
+    }
+  }
+
+  /** The bridge's `__sbWebSocketEvent(id, json)`. */
+  static receive(id: number, json: string | NativeWebSocketEvent): void {
+    const socket = sockets.get(id);
+    if (!socket) return;
+    let event: NativeWebSocketEvent;
+    try {
+      event = typeof json === 'string' ? (JSON.parse(json) as NativeWebSocketEvent) : json;
+    } catch {
+      return;
+    }
+    socket.receive(event);
+  }
+
+  /** Points the sockets at the bridge (the runtime, once per install). */
+  static install(native: WebSocketBridge): void {
+    bridge = native;
+  }
+}
+
+/** A `DOMException` stand-in: an error with the browser's name. */
+class DOMExceptionLike extends Error {
+  constructor(name: string, message: string) {
+    super(message);
+    this.name = name;
+  }
+}

package/swift/Sources/SwiftBrowserNative/Host/HostBridge.swift

@@ -11,6 +11,9 @@ import AppKit
 #if canImport(FoundationBridge)
 import FoundationBridge // the shim's Foundation stand-ins (ShimAliases.swift)
 #endif
+#if canImport(CryptoKit)
+import CryptoKit
+#endif
 
 /// The native primitives `@swiftbrowser/native` builds the web globals from
 /// (packages/native/src/runtime.ts), installed on `__sbNative`:
@@ -29,6 +32,12 @@ import FoundationBridge // the shim's Foundation stand-ins (ShimAliases.swift)
 /// | `locale()` | the viewer's locale identifier |
 /// | `launchArguments()` | the process's arguments (`-screen list` from a scheme or `simctl launch`) |
 /// | `mediaSession(update)` | `navigator.mediaSession`: the lock screen's now-playing info and the remote commands the app handles, on MediaPlayer (NowPlayingBridge.swift); a command the viewer gives comes to `__sbMediaSessionCommand(json)` |
+/// | `notificationsReady()`, `notificationPermission(id, request)`, `notificationShow(json)`, `notificationClose(json)`, `setBadge(count)`, `pushRegister(id, key?)` | notifications on UserNotifications (NotificationBridge.swift): the permission answers `__sbNotificationPermission(id, state)`, a registration `__sbPushRegistered(id, result)`, and what the viewer opens or what arrives comes to `__sbNotification(json)` |
+/// | `wsOpen(id, url, protocols)`, `wsSend(id, json)`, `wsClose(id, code, reason)` | `WebSocket` on `URLSessionWebSocketTask` (WebSocketBridge.swift); what a socket receives comes to `__sbWebSocketEvent(id, json)` |
+/// | `digest(algorithm, base64)`, `hmac(algorithm, key, base64)` | `crypto.subtle` on CryptoKit, synchronously: the base64 digest or HMAC, or nothing when the algorithm is not one of SHA-1, SHA-256, SHA-384 and SHA-512 |
+/// | `haptic(kind)` | `navigator.vibrate`: a feedback generator's `impact`, `selection`, `success`, `warning` or `error` |
+/// | `hostRequest(id, kind, json)` | the web renderer's `share`, `pickFiles`, `clipboard`, `pickColor` and `webAuth` requests, answered with the system's share sheet, pickers, pasteboard and sign-in session (HostRequestBridge.swift); the answer comes to `__sbHostResponse(id, result)` |
+/// | `secureGet(key)`, `secureSet(key, value)`, `secureRemove(key)` | `secureStorage` over the Keychain (SecureStorage.swift) |
 /// | `workerStart(id, name, engine)`, `workerPost(id, text)`, `workerTerminate(id)` | workers (JavaScriptCore only): a `JSContext` on a thread (`"context"`, WorkerHost.swift) or a hidden web view with WebKit's JIT (`"webview"`, WebViewWorkerHost.swift); their messages come to `__sbWorkerMessage(id, text)`, their errors to `__sbWorkerError(id, message)` |
 ///
 /// Everything JavaScript-facing runs on the main thread; work that is not
@@ -46,6 +55,11 @@ final class HostBridge {
     #if canImport(MediaPlayer)
     private var nowPlaying: NowPlayingBridge?
     #endif
+    #if canImport(UserNotifications)
+    private var notifications: NotificationBridge?
+    #endif
+    private var webSockets: WebSocketBridge?
+    private var hostRequests: HostRequestBridge?
     /// Keys of `localStorage` live under this prefix in `UserDefaults`.
     static let storagePrefix = "swiftbrowser.storage."
 
@@ -59,6 +73,7 @@ final class HostBridge {
     func invalidate() {
         for timer in timers.values { timer.invalidate() }
         timers.removeAll()
+        webSockets?.invalidate()
         #if canImport(JavaScriptCore)
         for worker in workers.values { worker.terminate() }
         workers.removeAll()
@@ -206,6 +221,93 @@ final class HostBridge {
         }
         #endif
 
+        #if canImport(UserNotifications)
+        host.install("notificationsReady") { [weak self] _ in
+            self?.notificationBridge.listen()
+            return nil
+        }
+        host.install("notificationPermission") { [weak self] arguments in
+            guard let self, let id = arguments[safe: 0]?.int else { return nil }
+            notificationBridge.permission(id: id, request: arguments[safe: 1]?.bool ?? false)
+            return nil
+        }
+        host.install("notificationShow") { [weak self] arguments in
+            guard let self, let json = arguments.first?.string else { return .string("notification: expected a JSON string") }
+            return notificationBridge.show(json).map(JSONValue.string)
+        }
+        host.install("notificationClose") { [weak self] arguments in
+            guard let self, let json = arguments.first?.string else { return nil }
+            notificationBridge.close(json)
+            return nil
+        }
+        host.install("setBadge") { [weak self] arguments in
+            guard let self, let count = arguments.first?.int else { return nil }
+            notificationBridge.setBadge(count)
+            return nil
+        }
+        host.install("pushRegister") { [weak self] arguments in
+            guard let self, let id = arguments[safe: 0]?.int else { return nil }
+            notificationBridge.registerForPush(id: id, applicationServerKey: arguments[safe: 1]?.string)
+            return nil
+        }
+        #endif
+
+        host.install("wsOpen") { [weak self] arguments in
+            guard let self, let id = arguments[safe: 0]?.int, let url = arguments[safe: 1]?.string else { return nil }
+            let protocols = arguments[safe: 2]?.array?.compactMap(\.string) ?? []
+            webSocketBridge.open(id: id, url: url, protocols: protocols)
+            return nil
+        }
+        host.install("wsSend") { [weak self] arguments in
+            guard let self, let id = arguments[safe: 0]?.int, let json = arguments[safe: 1]?.string else { return nil }
+            webSocketBridge.send(id: id, json: json)
+            return nil
+        }
+        host.install("wsClose") { [weak self] arguments in
+            guard let self, let id = arguments[safe: 0]?.int else { return nil }
+            webSocketBridge.close(id: id, code: arguments[safe: 1]?.int ?? 1000, reason: arguments[safe: 2]?.string ?? "")
+            return nil
+        }
+
+        host.install("digest") { arguments in
+            guard let algorithm = arguments[safe: 0]?.string, let encoded = arguments[safe: 1]?.string, let data = Data(base64Encoded: encoded) else { return nil }
+            return Self.digest(algorithm, data).map { .string($0.base64EncodedString()) }
+        }
+        host.install("hmac") { arguments in
+            guard let algorithm = arguments[safe: 0]?.string, let key = arguments[safe: 1]?.string, let encoded = arguments[safe: 2]?.string,
+                  let keyData = Data(base64Encoded: key), let data = Data(base64Encoded: encoded) else { return nil }
+            return Self.hmac(algorithm, key: keyData, data).map { .string($0.base64EncodedString()) }
+        }
+
+        host.install("haptic") { arguments in
+            Self.haptic(arguments.first?.string ?? "impact")
+            return nil
+        }
+
+        host.install("hostRequest") { [weak self] arguments in
+            guard let self, let id = arguments[safe: 0]?.int, let kind = arguments[safe: 1]?.string else { return nil }
+            if hostRequests == nil {
+                hostRequests = HostRequestBridge { [weak self] id, result in self?.callIn("__sbHostResponse", [.number(Double(id)), .string(result.json)]) }
+            }
+            hostRequests?.perform(id: id, kind: kind, json: arguments[safe: 2]?.string ?? "{}")
+            return nil
+        }
+
+        host.install("secureGet") { arguments in
+            guard let key = arguments.first?.string else { return nil }
+            return SecureStorage.get(key).map(JSONValue.string) ?? .null
+        }
+        host.install("secureSet") { arguments in
+            guard let key = arguments[safe: 0]?.string, let value = arguments[safe: 1]?.string else { return nil }
+            SecureStorage.set(key, value)
+            return nil
+        }
+        host.install("secureRemove") { arguments in
+            guard let key = arguments.first?.string else { return nil }
+            SecureStorage.remove(key)
+            return nil
+        }
+
         #if canImport(JavaScriptCore)
         host.install("workerStart") { [weak self] arguments in
             guard let self, let id = arguments[safe: 0]?.int, let name = arguments[safe: 1]?.string else {
@@ -255,6 +357,70 @@ final class HostBridge {
         #endif
     }
 
+    #if canImport(UserNotifications)
+    /// The notification bridge, made when the app first uses notifications.
+    private var notificationBridge: NotificationBridge {
+        if let notifications { return notifications }
+        let bridge = NotificationBridge { [weak self] function, arguments in self?.callIn(function, arguments) }
+        notifications = bridge
+        return bridge
+    }
+    #endif
+
+    /// The WebSocket bridge, made when the app opens its first socket.
+    private var webSocketBridge: WebSocketBridge {
+        if let webSockets { return webSockets }
+        let bridge = WebSocketBridge(session: session) { [weak self] id, event in self?.callIn("__sbWebSocketEvent", [.number(Double(id)), .string(event.json)]) }
+        webSockets = bridge
+        return bridge
+    }
+
+    // MARK: crypto.subtle and haptics
+
+    static func digest(_ algorithm: String, _ data: Data) -> Data? {
+        #if canImport(CryptoKit)
+        switch algorithm {
+        case "SHA-256": Data(SHA256.hash(data: data))
+        case "SHA-384": Data(SHA384.hash(data: data))
+        case "SHA-512": Data(SHA512.hash(data: data))
+        case "SHA-1": Data(Insecure.SHA1.hash(data: data))
+        default: nil
+        }
+        #else
+        nil
+        #endif
+    }
+
+    static func hmac(_ algorithm: String, key: Data, _ data: Data) -> Data? {
+        #if canImport(CryptoKit) && !canImport(FoundationBridge)
+        let symmetricKey = SymmetricKey(data: key)
+        return switch algorithm {
+        case "SHA-256": Data(HMAC<SHA256>.authenticationCode(for: data, using: symmetricKey))
+        case "SHA-384": Data(HMAC<SHA384>.authenticationCode(for: data, using: symmetricKey))
+        case "SHA-512": Data(HMAC<SHA512>.authenticationCode(for: data, using: symmetricKey))
+        case "SHA-1": Data(HMAC<Insecure.SHA1>.authenticationCode(for: data, using: symmetricKey))
+        default: nil
+        }
+        #else
+        // The shim's CryptoKit has no HMAC.
+        nil
+        #endif
+    }
+
+    static func haptic(_ kind: String) {
+        #if canImport(UIKit) && !os(tvOS)
+        switch kind {
+        case "selection": UISelectionFeedbackGenerator().selectionChanged()
+        case "success": UINotificationFeedbackGenerator().notificationOccurred(.success)
+        case "warning": UINotificationFeedbackGenerator().notificationOccurred(.warning)
+        case "error": UINotificationFeedbackGenerator().notificationOccurred(.error)
+        default: UIImpactFeedbackGenerator(style: .medium).impactOccurred()
+        }
+        #elseif canImport(AppKit)
+        NSHapticFeedbackManager.defaultPerformer.perform(.generic, performanceTime: .now)
+        #endif
+    }
+
     /// Calls into JavaScript from a timer or a completion, where a throw has nowhere to go but the log.
     private func callIn(_ function: String, _ arguments: [JSONValue]) {
         do {