@swiftbrowser/native 0.17.8 → 0.18.0

package/dist/undo.js

@@ -0,0 +1,44 @@
+/**
+ * The window's `UndoManager` for the app's undo manager (`useUndoManager`
+ * in @swiftbrowser/react): the host of the renderer environment's
+ * `undoManager` (Web/src/undo.ts) in the native app. The stack stays in
+ * JavaScript, the truth; the host mirrors what it can do, so the system's
+ * undo reaches it: each change goes to the bridge's `undoState(json)` as
+ * `{ canUndo, canRedo, undoActionName, redoActionName }` (UndoBridge.swift
+ * keeps one proxy action per side on the window's manager), and a shake, a
+ * three-finger swipe, ⌘Z or the Edit menu comes back as
+ * `__sbUndoCommand('undo' | 'redo')`. In the page (the round trip) the
+ * page's keyboard host is there already and nothing is installed over it.
+ */
+let installed = null;
+export function createUndoHost(native) {
+    let commands = null;
+    const host = {
+        update(state) {
+            native.undoState(JSON.stringify(state));
+        },
+        listen(given) {
+            commands = given;
+            return () => {
+                if (commands === given)
+                    commands = null;
+            };
+        },
+    };
+    const receive = (command) => {
+        if (command === 'undo')
+            commands?.undo();
+        else if (command === 'redo')
+            commands?.redo();
+    };
+    return { host, receive };
+}
+/** Keeps the host for `installHostEnvironment` (the runtime, once per install). */
+export function installUndoHost(host) {
+    installed = host;
+}
+/** The host the runtime made, or null outside the native app. */
+export function nativeUndoHost() {
+    return installed;
+}
+//# sourceMappingURL=undo.js.map

package/dist/undo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"undo.js","sourceRoot":"","sources":["../src/undo.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,IAAI,SAAS,GAAoB,IAAI,CAAC;AAEtC,MAAM,UAAU,cAAc,CAAC,MAAiD;IAC9E,IAAI,QAAQ,GAAwB,IAAI,CAAC;IACzC,MAAM,IAAI,GAAa;QACrB,MAAM,CAAC,KAAgB;YACrB,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;QAC1C,CAAC;QACD,MAAM,CAAC,KAAK;YACV,QAAQ,GAAG,KAAK,CAAC;YACjB,OAAO,GAAG,EAAE;gBACV,IAAI,QAAQ,KAAK,KAAK;oBAAE,QAAQ,GAAG,IAAI,CAAC;YAC1C,CAAC,CAAC;QACJ,CAAC;KACF,CAAC;IACF,MAAM,OAAO,GAAG,CAAC,OAAe,EAAQ,EAAE;QACxC,IAAI,OAAO,KAAK,MAAM;YAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;aACpC,IAAI,OAAO,KAAK,MAAM;YAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;IAChD,CAAC,CAAC;IACF,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;AAC3B,CAAC;AAED,mFAAmF;AACnF,MAAM,UAAU,eAAe,CAAC,IAAqB;IACnD,SAAS,GAAG,IAAI,CAAC;AACnB,CAAC;AAED,iEAAiE;AACjE,MAAM,UAAU,cAAc;IAC5B,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swiftbrowser/native",
-  "version": "0.17.8",
+  "version": "0.18.0",
   "type": "module",
   "description": "Run a @swiftbrowser/react app natively: the runtime a JavaScriptCore-hosted app needs (timers, console, fetch and the other web globals over the SwiftBrowser Native bridge), the `run` entry that renders into the native SwiftUI renderer, and the bundler that builds app.js for the Xcode target.",
   "repository": {
@@ -59,8 +59,8 @@
   },
   "dependencies": {
     "@babel/core": "^7.29.7",
-    "@swiftbrowser/react": "0.17.8",
-    "@swiftbrowser/web": "0.17.8",
+    "@swiftbrowser/react": "0.18.0",
+    "@swiftbrowser/web": "0.18.0",
     "esbuild": "^0.28.2",
     "react-refresh": "^0.17.0"
   },

package/src/bridge.ts

@@ -5,7 +5,7 @@
  * package defines (`__sbTimerFired`, `__sbFetchResult`, `__sbImageProbed`,
  * `__sbWorkerMessage`, `__sbOpenURL`, `__sbMediaSessionCommand`,
  * `__sbNotificationPermission`, `__sbPushRegistered`, `__sbNotification`,
- * `__sbWebSocketEvent`, `__sbHostResponse`).
+ * `__sbWebSocketEvent`, `__sbHostResponse`, `__sbUndoCommand`).
  */
 export interface NativeBridge {
   /** Applies a render pass's ops (a JSON array). Returns an error message, or nothing. */
@@ -87,6 +87,31 @@ export interface NativeBridge {
    */
   hostRequest?(id: number, kind: string, json: string): void;
 
+  /**
+   * The app's undo manager's state (undo.ts): `{ canUndo, canRedo,
+   * undoActionName, redoActionName }` as JSON, which the host mirrors on the
+   * window's `UndoManager` so the system's undo reaches the app; the undo or
+   * redo the system asks for arrives at `__sbUndoCommand('undo' | 'redo')`.
+   * Hosts before 0.18 lack it.
+   */
+  undoState?(json: string): void;
+
+  /**
+   * `measureText` (@swiftbrowser/react): the size `text` in `font` (a Font
+   * JSON object over the body font) takes wrapped to `width` points (one
+   * line when null), from `NSAttributedString`'s bounding rect, synchronously:
+   * `{ width, height, lines }`, or nothing when the host cannot measure.
+   * Hosts before 0.21 lack it.
+   */
+  measureText?(text: string, font: string, width: number | null): { width: number; height: number; lines: number } | null | undefined;
+
+  /**
+   * The app's standard directories as `file:` URLs, a JSON object
+   * `{ documents, applicationSupport, caches, temporary }` (hostRequests.ts
+   * `files`, Host/FilesBridge.swift). Hosts before 0.22 lack it.
+   */
+  appDirectories?(): string | null | undefined;
+
   // The Keychain (secureStorage.ts). Hosts before 0.20 lack them.
   secureGet?(key: string): string | null;
   secureSet?(key: string, value: string): void;

package/src/hostRequests.ts

@@ -4,20 +4,27 @@
  * renderer's `performHostRequest` with its `browserEnvironment`), answered by
  * the native app instead: the bridge's `hostRequest(id, kind, json)` performs
  * one with UIKit (a share sheet, the photo or document picker, the
- * pasteboard, the color picker, `ASWebAuthenticationSession`), answering
+ * pasteboard, the color picker, `ASWebAuthenticationSession`, a recording
+ * from the microphone with `AVAudioRecorder`), answering
  * `__sbHostResponse(id, { value } | { error })`. `installHostEnvironment`
- * fills the environment's gaps with these, leaving what the page has (the
- * round trip runs in a browser with a share sheet of its own).
+ * fills the environment's gaps with these, and with the window's undo
+ * manager (undo.ts), leaving what the page has (the round trip runs in a
+ * browser with a share sheet and a keyboard of its own).
  *
  * `webAuthenticate` is the sign-in window apps open for OAuth: the system's
  * sheet, resolving with the callback URL.
+ *
+ * `files` is the app's sandbox for `fileManager` (@swiftbrowser/react): the
+ * `files` requests of Host/FilesBridge.swift, bytes crossing as base64, with
+ * the standard directories from the bridge's `appDirectories()`.
  */
 
 import { objectURL, SimpleBlob, SimpleFile } from './blob';
 import type { NativeBridge } from './bridge';
 import { base64Decode, base64Encode } from './encoding';
+import { nativeUndoHost } from './undo';
 
-export type HostRequestBridge = Required<Pick<NativeBridge, 'hostRequest'>>;
+export type HostRequestBridge = Required<Pick<NativeBridge, 'hostRequest'>> & Pick<NativeBridge, 'appDirectories'>;
 
 /** A file as it crosses the bridge: its name, MIME type and bytes (base64). */
 export interface BridgedFile {
@@ -105,9 +112,56 @@ export async function webAuthenticate(url: string, options: WebAuthenticateOptio
   return result.url;
 }
 
+interface FileDirectories {
+  documents: string;
+  applicationSupport: string;
+  caches: string;
+  temporary: string;
+}
+
+/** The app's directories the bridge reports, or null on a host without `appDirectories`. */
+function appDirectories(): FileDirectories | null {
+  try {
+    const json = bridge?.appDirectories?.();
+    if (!json) return null;
+    const parsed = JSON.parse(json) as Partial<FileDirectories>;
+    const { documents, applicationSupport, caches, temporary } = parsed;
+    if ([documents, applicationSupport, caches, temporary].every((url) => typeof url === 'string')) {
+      return { documents: documents!, applicationSupport: applicationSupport!, caches: caches!, temporary: temporary! };
+    }
+  } catch {
+    // Malformed: as if the host had none.
+  }
+  return null;
+}
+
+/** The app's files (`files` requests): `fileManager`'s host over the sandbox. */
+function nativeFiles(directories: FileDirectories): Record<string, unknown> {
+  const files = <T>(params: Record<string, unknown>): Promise<T> => hostRequest<T>('files', params);
+  return {
+    directories,
+    read: async (url: string): Promise<Uint8Array> => base64Decode((await files<{ data?: string }>({ action: 'read', url }))?.data ?? ''),
+    write: (url: string, data: Uint8Array): Promise<void> => files({ action: 'write', url, data: base64Encode(data) }).then(() => undefined),
+    remove: (url: string): Promise<void> => files({ action: 'remove', url }).then(() => undefined),
+    createDirectory: (url: string): Promise<void> => files({ action: 'createDirectory', url }).then(() => undefined),
+    list: async (url: string): Promise<string[]> => (await files<{ urls?: string[] }>({ action: 'list', url }))?.urls ?? [],
+    attributes: async (url: string): Promise<{ size: number; modified: number | null; directory: boolean } | null> => {
+      const found = await files<{ size?: number; modified?: number | null; directory?: boolean } | null>({ action: 'attributes', url });
+      if (!found || typeof found.size !== 'number') return null;
+      return { size: found.size, modified: typeof found.modified === 'number' ? found.modified : null, directory: found.directory === true };
+    },
+    move: (from: string, to: string): Promise<void> => files({ action: 'move', from, to }).then(() => undefined),
+    copy: (from: string, to: string): Promise<void> => files({ action: 'copy', from, to }).then(() => undefined),
+    // AVPlayer and UIImage read the file themselves.
+    loadURL: async (url: string): Promise<string> => url,
+  };
+}
+
 /** The environment fields the host answers, shaped as the web renderer's `HostRequestEnvironment`. */
 export function nativeHostEnvironment(): Record<string, unknown> {
+  const directories = appDirectories();
   return {
+    ...(directories ? { files: nativeFiles(directories) } : {}),
     share: async (data: { title?: string; text?: string; url?: string; files?: SimpleFile[] }): Promise<void> => {
       const params: Record<string, unknown> = {};
       if (data.title) params['title'] = data.title;
@@ -136,12 +190,26 @@ export function nativeHostEnvironment(): Record<string, unknown> {
       readText: async (): Promise<string> => (await hostRequest<{ text?: string }>('clipboard', { action: 'readText' }))?.text ?? '',
     },
     pickColor: async (color: string): Promise<string | null> => (await hostRequest<{ color?: string }>('pickColor', { color }))?.color ?? null,
+    // `AVAudioRecorder` (AudioRecorderBridge.swift): a recording ends as a file URL in Documents; `trim` writes another.
+    audioRecorder: {
+      start: (): Promise<void> => hostRequest('audioRecord', { action: 'start' }).then(() => undefined),
+      pause: (): Promise<void> => hostRequest('audioRecord', { action: 'pause' }).then(() => undefined),
+      resume: (): Promise<void> => hostRequest('audioRecord', { action: 'resume' }).then(() => undefined),
+      stop: (): Promise<{ url: string; duration: number; type: string }> => hostRequest('audioRecord', { action: 'stop' }),
+      cancel: (): Promise<void> => hostRequest('audioRecord', { action: 'cancel' }).then(() => undefined),
+      meter: (): Promise<{ level: number; time: number }> => hostRequest('audioRecord', { action: 'meter' }),
+      discard: (url: string): Promise<void> => hostRequest('audioRecord', { action: 'discard', url }).then(() => undefined),
+      trim: (url: string, keep: readonly { start: number; end: number }[]): Promise<{ url: string; duration: number; type: string }> =>
+        hostRequest('audioRecord', { action: 'trim', url, keep: keep.map((range) => ({ start: range.start, end: range.end })) }),
+    },
   };
 }
 
 /** Fills what `environment` lacks with the host's answers; what the page has stays. */
 export function installHostEnvironment(environment: Record<string, unknown>): void {
   if (!bridge) return;
+  const undo = nativeUndoHost();
+  if (undo && environment['undoManager'] === undefined) environment['undoManager'] = undo;
   for (const [key, value] of Object.entries(nativeHostEnvironment())) {
     if (environment[key] === undefined) environment[key] = value;
   }

package/src/index.ts

@@ -27,4 +27,5 @@ export { SimpleTextEncoder, SimpleTextDecoder, base64Encode, base64Decode, utf8E
 export { createWorker, NativeWorker, encodeMessage, decodeMessage, workerName, type NativeWorkerOptions, type WorkerLike, type WorkerMessageEvent, type WorkerErrorEvent } from './worker';
 export { onOpenURL } from './openURL';
 export { onNotification, registerForPush, type NotificationEvent, type NativeNotificationOptions, type RegisterForPushOptions } from './notifications';
+export { createUndoHost, nativeUndoHost } from './undo';
 export { createMediaSession, NativeMediaMetadata, type NativeMediaSession, type MediaMetadataInit, type MediaActionDetails, type MediaActionHandler, type MediaPositionState } from './mediaSession';

package/src/run.ts

@@ -8,7 +8,7 @@
  * ran and its pass was applied (docs/native.md, "Synchronous calls").
  */
 
-import { createSwiftUIRoot, type SwiftUIRoot } from '@swiftbrowser/react';
+import { createSwiftUIRoot, installTextMeasurer, type SwiftUIRoot, type TextMeasurerFunction } from '@swiftbrowser/react';
 import type { Op, RendererEvent } from '@swiftbrowser/web/src/protocol';
 import type { ReactNode } from 'react';
 import { browserEnvironment } from '@swiftbrowser/web/src/hostRequests';
@@ -47,6 +47,15 @@ export function run(element: ReactNode, options: RunOptions = {}): Running {
   // What `ShareLink`, `fileImporter` and the clipboard ask the browser for,
   // answered by the host where the page has nothing (hostRequests.ts).
   installHostEnvironment(browserEnvironment as unknown as Record<string, unknown>);
+  // `measureText` answers from the host's text system (HostBridge.swift, `measureText`).
+  const measurer: TextMeasurerFunction | null = native.measureText
+    ? (text, font, width) => {
+        const size = native.measureText!(text, JSON.stringify(font), width);
+        if (!size) throw new Error('measureText: the native host could not measure the text');
+        return size;
+      }
+    : null;
+  if (measurer) installTextMeasurer(measurer);
 
   if (current) {
     // Fast Refresh (devBuild.ts): the app bundle was evaluated again. Its
@@ -99,6 +108,7 @@ export function run(element: ReactNode, options: RunOptions = {}): Running {
     dispatch,
     unmount() {
       root.unmount();
+      if (measurer) installTextMeasurer(measurer, true);
       if (g['__sbDispatch']) delete g['__sbDispatch'];
       current = null;
     },

package/src/runtime.ts

@@ -16,6 +16,7 @@
  * bridge's `__sbImageProbed`, `Worker` (worker.ts) with the bridge's
  * `__sbWorkerMessage` and `__sbWorkerError`, `__sbOpenURL` (openURL.ts),
  * `__sbNotificationPermission`, `__sbPushRegistered` and `__sbNotification` (notifications.ts),
+ * `__sbUndoCommand` (undo.ts, on a bridge with `undoState`),
  * and the bridge's callbacks `__sbTimerFired` and `__sbFetchResult`. In a
  * worker's own context (its bridge has
  * `workerPostMessage`), `self`, `postMessage`, `addEventListener` and
@@ -38,6 +39,7 @@ import { setBodyRandomness } from './fetch';
 import { NativeWebSocket } from './webSocket';
 import { createSubtleCrypto } from './subtle';
 import { matchMedia } from './matchMedia';
+import { createUndoHost, installUndoHost } from './undo';
 import { installHostRequests, receiveHostResponse } from './hostRequests';
 
 type AnyGlobal = Record<string, unknown>;
@@ -205,10 +207,19 @@ export function installRuntime(native: NativeBridge, target: AnyGlobal = globalT
 
   // 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) });
+    installHostRequests({ hostRequest: native.hostRequest.bind(native), ...(native.appDirectories ? { appDirectories: native.appDirectories.bind(native) } : {}) });
     define('__sbHostResponse', receiveHostResponse);
   }
 
+  // The window's undo manager (undo.ts), mirroring the app's: the system's undo comes to `__sbUndoCommand`.
+  if (native.undoState && !native.workerPostMessage) {
+    const undo = createUndoHost({ undoState: native.undoState.bind(native) });
+    installUndoHost(undo.host);
+    define('__sbUndoCommand', undo.receive);
+  } else {
+    installUndoHost(null);
+  }
+
   // `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) {

package/src/site.ts

@@ -26,8 +26,8 @@ export interface SiteOptions extends Omit<BuildOptions, 'outfile'> {
   /**
    * The site's app name (letters, digits, `_` and `-`): the module's file
    * name and the document title. The entry's project folder's name by default
-   * (`js/src/index.tsx` → the folder holding `js`, as `native init` lays an
-   * app out), else `App`.
+   * (`src/index.tsx` → the folder holding `src`, as `native init` lays an
+   * app out; `js/src/index.tsx` → the folder holding `js`), else `App`.
    */
   name?: string;
   /** Shown as the document title and in the web manifest; `name` by default. */
@@ -59,7 +59,7 @@ export interface SiteResult {
 
 const APP_NAME = /^[A-Za-z0-9_-]+$/;
 
-/** The app name an entry suggests: the folder holding its `js/` project, else the entry's own folder. */
+/** The app name an entry suggests: the folder holding its `src/` (or an older layout's `js/`), else the entry's own folder. */
 export function siteNameFor(entry: string): string {
   const dir = path.dirname(path.resolve(entry));
   const parts = dir.split(path.sep);

package/src/undo.ts

@@ -0,0 +1,47 @@
+/**
+ * The window's `UndoManager` for the app's undo manager (`useUndoManager`
+ * in @swiftbrowser/react): the host of the renderer environment's
+ * `undoManager` (Web/src/undo.ts) in the native app. The stack stays in
+ * JavaScript, the truth; the host mirrors what it can do, so the system's
+ * undo reaches it: each change goes to the bridge's `undoState(json)` as
+ * `{ canUndo, canRedo, undoActionName, redoActionName }` (UndoBridge.swift
+ * keeps one proxy action per side on the window's manager), and a shake, a
+ * three-finger swipe, ⌘Z or the Edit menu comes back as
+ * `__sbUndoCommand('undo' | 'redo')`. In the page (the round trip) the
+ * page's keyboard host is there already and nothing is installed over it.
+ */
+
+import type { UndoCommands, UndoHost, UndoState } from '@swiftbrowser/web/src/undo';
+import type { NativeBridge } from './bridge';
+
+let installed: UndoHost | null = null;
+
+export function createUndoHost(native: Required<Pick<NativeBridge, 'undoState'>>): { host: UndoHost; receive: (command: string) => void } {
+  let commands: UndoCommands | null = null;
+  const host: UndoHost = {
+    update(state: UndoState) {
+      native.undoState(JSON.stringify(state));
+    },
+    listen(given) {
+      commands = given;
+      return () => {
+        if (commands === given) commands = null;
+      };
+    },
+  };
+  const receive = (command: string): void => {
+    if (command === 'undo') commands?.undo();
+    else if (command === 'redo') commands?.redo();
+  };
+  return { host, receive };
+}
+
+/** Keeps the host for `installHostEnvironment` (the runtime, once per install). */
+export function installUndoHost(host: UndoHost | null): void {
+  installed = host;
+}
+
+/** The host the runtime made, or null outside the native app. */
+export function nativeUndoHost(): UndoHost | null {
+  return installed;
+}

package/swift/Sources/SwiftBrowserNative/Host/AudioRecorderBridge.swift

@@ -0,0 +1,199 @@
+#if canImport(SwiftUI)
+import Foundation
+import SwiftBrowserProtocol
+#if os(iOS) && !canImport(FoundationBridge)
+import AVFoundation
+
+/// The `audioRecord` host request (packages/native/src/hostRequests.ts): the
+/// page's microphone recorder (Web/src/audioRecorder.ts) answered with
+/// `AVAudioRecorder`. `start` asks for the microphone the first time
+/// (`NSMicrophoneUsageDescription` in the app's Info.plist) and records AAC
+/// into `Documents/Recordings`; `meter` answers the input's level (0 silent
+/// … 1 loud, from -50 dB, as the page meters it) and the seconds recorded;
+/// `pause`, `resume` and `cancel` do as they say; `stop` answers `{ url,
+/// duration, type }`, the file's URL to play the recording at; `discard`
+/// (`url`) deletes one made before (only a file in `Recordings`); `trim`
+/// (`url`, `keep`: `[{ start, end }]` in seconds) writes a new file in
+/// `Recordings` of those parts in order, through an `AVMutableComposition`
+/// exported as AAC, and answers it like `stop` (the original stays).
+@MainActor
+final class AudioRecorderBridge {
+    private var recorder: AVAudioRecorder?
+    /// Seconds recorded before a pause (the recorder's own clock reads 0 while paused).
+    private var pausedAt: TimeInterval?
+
+    func handle(_ params: JSONObject) async throws -> JSONValue {
+        switch params.string("action") ?? "" {
+        case "start": try await start()
+        case "pause": pause()
+        case "resume": try resume()
+        case "stop": return try stop()
+        case "cancel": cancel()
+        case "meter": return meter()
+        case "discard": try discard(params.string("url"))
+        case "trim": return try await trim(params)
+        default: throw HostRequestFailure("unsupported: audioRecord \(params.string("action") ?? "without an action")")
+        }
+        return .object([:])
+    }
+
+    private func start() async throws {
+        guard recorder == nil else { throw HostRequestFailure("busy: already recording") }
+        guard await AVAudioApplication.requestRecordPermission() else {
+            throw HostRequestFailure("permission: the microphone was not allowed")
+        }
+        let session = AVAudioSession.sharedInstance()
+        // Recordings play back through the speaker, not the earpiece.
+        try session.setCategory(.playAndRecord, mode: .default, options: [.defaultToSpeaker, .allowBluetoothA2DP])
+        try session.setActive(true)
+        let folder = try FileManager.default.url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
+            .appendingPathComponent("Recordings", isDirectory: true)
+        try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
+        let file = folder.appendingPathComponent("\(UUID().uuidString).m4a")
+        let settings: [String: Any] = [
+            AVFormatIDKey: kAudioFormatMPEG4AAC,
+            AVSampleRateKey: 44_100,
+            AVNumberOfChannelsKey: 1,
+            AVEncoderAudioQualityKey: AVAudioQuality.high.rawValue,
+        ]
+        let recorder = try AVAudioRecorder(url: file, settings: settings)
+        recorder.isMeteringEnabled = true
+        guard recorder.record() else { throw HostRequestFailure("unavailable: the recording did not start") }
+        self.recorder = recorder
+        pausedAt = nil
+    }
+
+    private func active() throws -> AVAudioRecorder {
+        guard let recorder else { throw HostRequestFailure("idle: not recording") }
+        return recorder
+    }
+
+    private func pause() {
+        guard let recorder, recorder.isRecording else { return }
+        pausedAt = recorder.currentTime
+        recorder.pause()
+    }
+
+    private func resume() throws {
+        let recorder = try active()
+        guard !recorder.isRecording else { return }
+        _ = recorder.record()
+        pausedAt = nil
+    }
+
+    private func stop() throws -> JSONValue {
+        let recorder = try active()
+        let duration = pausedAt ?? recorder.currentTime
+        recorder.stop()
+        self.recorder = nil
+        pausedAt = nil
+        return .object(["url": .string(recorder.url.absoluteString), "duration": .number(duration), "type": .string("audio/mp4")])
+    }
+
+    private func cancel() {
+        guard let recorder else { return }
+        recorder.stop()
+        _ = recorder.deleteRecording()
+        self.recorder = nil
+        pausedAt = nil
+    }
+
+    private func discard(_ url: String?) throws {
+        guard let url, let parsed = URL(string: url), parsed.isFileURL else { return }
+        let file = AppFiles.current(parsed)
+        guard file.deletingLastPathComponent().lastPathComponent == "Recordings" else {
+            throw HostRequestFailure("unsupported: only a recording's own file can be discarded")
+        }
+        if FileManager.default.fileExists(atPath: file.path) { try FileManager.default.removeItem(at: file) }
+    }
+
+    private func trim(_ params: JSONObject) async throws -> JSONValue {
+        guard let url = params.string("url"), let parsed = URL(string: url), parsed.isFileURL else {
+            throw HostRequestFailure("unsupported: only a recording's own file can be trimmed")
+        }
+        let file = AppFiles.current(parsed)
+        let folder = file.deletingLastPathComponent()
+        guard folder.lastPathComponent == "Recordings", FileManager.default.fileExists(atPath: file.path) else {
+            throw HostRequestFailure("unsupported: only a recording's own file can be trimmed")
+        }
+        let ranges = AudioTrim.ranges(params.array("keep") ?? [])
+        guard !ranges.isEmpty else { throw HostRequestFailure("empty: nothing of the recording was kept") }
+        let output = folder.appendingPathComponent("\(UUID().uuidString).m4a")
+        let duration = try await Self.export(file, keeping: ranges, to: output)
+        return .object(["url": .string(output.absoluteString), "duration": .number(duration), "type": .string("audio/mp4")])
+    }
+
+    /// Writes the parts of `source` in `ranges` (seconds, in order) to
+    /// `output` as AAC in M4A and answers the seconds written. Off the main
+    /// actor: the composition, the asset and the export session are made
+    /// and awaited here, so none crosses an isolation boundary.
+    nonisolated private static func export(_ source: URL, keeping ranges: [AudioTrim.Part], to output: URL) async throws -> Double {
+        let asset = AVURLAsset(url: source)
+        let total = try await asset.load(.duration)
+        let composition = AVMutableComposition()
+        var cursor = CMTime.zero
+        for range in ranges {
+            let start = CMTime(seconds: range.start, preferredTimescale: 44_100)
+            let end = CMTimeMinimum(CMTime(seconds: range.end, preferredTimescale: 44_100), total)
+            guard end > start else { continue }
+            let part = CMTimeRange(start: start, end: end)
+            try await composition.insertTimeRange(part, of: asset, at: cursor)
+            cursor = cursor + part.duration
+        }
+        guard cursor > .zero else { throw HostRequestFailure("empty: nothing of the recording was kept") }
+        guard let session = AVAssetExportSession(asset: composition, presetName: AVAssetExportPresetAppleM4A) else {
+            throw HostRequestFailure("unsupported: the recording cannot be cut on this device")
+        }
+        if #available(iOS 18, *) {
+            try await session.export(to: output, as: .m4a)
+        } else {
+            session.outputURL = output
+            session.outputFileType = .m4a
+            await session.export()
+            guard session.status == .completed else {
+                throw HostRequestFailure("export: \(session.error?.localizedDescription ?? "the recording could not be written")")
+            }
+        }
+        return cursor.seconds
+    }
+
+    private func meter() -> JSONValue {
+        guard let recorder else { return .object(["level": .number(0), "time": .number(0)]) }
+        guard recorder.isRecording else { return .object(["level": .number(0), "time": .number(pausedAt ?? 0)]) }
+        recorder.updateMeters()
+        let decibels = Double(recorder.averagePower(forChannel: 0))
+        return .object(["level": .number(max(0, min(1, (decibels + 50) / 50))), "time": .number(recorder.currentTime)])
+    }
+}
+#endif
+
+/// The `keep` of an `audioRecord` `trim`: `[{ start, end }]` in seconds,
+/// each clamped to start at 0 at the earliest, the empty ones dropped, in
+/// time order, and overlapping ones merged, so the kept parts never repeat
+/// a sound (Web/src/audioRecorder.ts's `keptRanges` does the same, with
+/// the recording's length known; here the export clamps the end).
+enum AudioTrim {
+    struct Part: Equatable, Sendable {
+        var start: Double
+        var end: Double
+    }
+
+    static func ranges(_ keep: [JSONValue]) -> [Part] {
+        let clamped = keep.compactMap { value -> Part? in
+            guard let start = value["start"].double, let end = value["end"].double, start.isFinite, end.isFinite else { return nil }
+            let range = Part(start: max(0, start), end: max(0, end))
+            return range.end > range.start ? range : nil
+        }.sorted { $0.start < $1.start }
+        var merged: [Part] = []
+        for range in clamped {
+            if let last = merged.last, range.start <= last.end {
+                merged[merged.count - 1].end = max(last.end, range.end)
+            } else {
+                merged.append(range)
+            }
+        }
+        return merged
+    }
+}
+
+#endif