@swiftbrowser/native 0.0.0-stage → 0.10.0

package/src/runtime.ts

@@ -0,0 +1,208 @@
+/**
+ * The web globals a JavaScriptCore app expects, built on the bridge's
+ * primitives (`__sbNative`, see bridge.ts). React's scheduler reads
+ * `setTimeout` and `performance.now` when its module loads, so this module
+ * installs everything at import time and the bundler (build.ts) puts it
+ * first in `app.js`.
+ *
+ * What is installed when missing: `setTimeout`, `setInterval`, `clearTimeout`,
+ * `clearInterval`, `requestAnimationFrame`, `cancelAnimationFrame`,
+ * `queueMicrotask`, `console`, `performance`, `TextEncoder`, `TextDecoder`,
+ * `atob`, `btoa`, `fetch` with `Headers`, `Request`, `Response`,
+ * `AbortController` and `AbortSignal`, `URL`, `URLSearchParams`, `crypto`
+ * (`getRandomValues`, `randomUUID`), `localStorage`, `structuredClone`,
+ * `navigator`, and the bridge's callbacks `__sbTimerFired` and
+ * `__sbFetchResult`. `window` and `document` are not defined: code that
+ * checks for them takes its headless path, as it should here.
+ */
+
+import { nativeBridge, type NativeBridge } from './bridge';
+import { atobPolyfill, base64Decode, btoaPolyfill, SimpleTextDecoder, SimpleTextEncoder } from './encoding';
+import { createFetch } from './fetch';
+import { SimpleURL, SimpleURLSearchParams } from './url';
+
+type AnyGlobal = Record<string, unknown>;
+
+interface TimerEntry {
+  callback: (...args: unknown[]) => void;
+  args: unknown[];
+  repeats: boolean;
+}
+
+export interface InstallOptions {
+  /** Install over globals that exist already (tests). */
+  force?: boolean;
+}
+
+/**
+ * Installs the runtime on `target` (the global object) over `native`.
+ * Returns what it installed, by name.
+ */
+export function installRuntime(native: NativeBridge, target: AnyGlobal = globalThis as unknown as AnyGlobal, options: InstallOptions = {}): string[] {
+  const installed: string[] = [];
+  const define = (name: string, value: unknown): void => {
+    if (!options.force && target[name] !== undefined) return;
+    Object.defineProperty(target, name, { value, writable: true, configurable: true, enumerable: false });
+    installed.push(name);
+  };
+
+  // Timers: one native timer per JavaScript timer, by id.
+  const timers = new Map<number, TimerEntry>();
+  let nextTimer = 1;
+  const schedule = (callback: unknown, delay: unknown, args: unknown[], repeats: boolean): number => {
+    const id = nextTimer++;
+    const fn = typeof callback === 'function' ? (callback as TimerEntry['callback']) : () => {};
+    timers.set(id, { callback: fn, args, repeats });
+    native.setTimer(id, Math.max(0, Number(delay) || 0), repeats);
+    return id;
+  };
+  const cancel = (id: unknown): void => {
+    const key = Number(id);
+    if (!timers.delete(key)) return;
+    native.clearTimer(key);
+  };
+  const fired = (id: number): void => {
+    const entry = timers.get(id);
+    if (!entry) return;
+    if (!entry.repeats) timers.delete(id);
+    entry.callback(...entry.args);
+  };
+  define('setTimeout', (callback: unknown, delay?: unknown, ...args: unknown[]) => schedule(callback, delay, args, false));
+  define('setInterval', (callback: unknown, delay?: unknown, ...args: unknown[]) => schedule(callback, delay, args, true));
+  define('clearTimeout', cancel);
+  define('clearInterval', cancel);
+  define('__sbTimerFired', fired);
+
+  // Animation frames: a 60 Hz timer; the callback gets the time.
+  const now = (): number => native.now();
+  define('requestAnimationFrame', (callback: (time: number) => void) => schedule(() => callback(now()), 16, [], false));
+  define('cancelAnimationFrame', cancel);
+
+  define('queueMicrotask', (callback: () => void) => {
+    Promise.resolve().then(callback);
+  });
+
+  // The console: one line per call, formatted here.
+  const format = (value: unknown): string => {
+    if (typeof value === 'string') return value;
+    if (value instanceof Error) return value.stack ? String(value.stack) : `${value.name}: ${value.message}`;
+    if (typeof value === 'function') return `[Function ${value.name || 'anonymous'}]`;
+    if (typeof value === 'symbol' || typeof value === 'bigint') return value.toString();
+    try {
+      const json = JSON.stringify(value, (_key, inner: unknown) => (inner instanceof Error ? `${inner.name}: ${inner.message}` : inner), 2);
+      return json === undefined ? String(value) : json;
+    } catch {
+      return String(value);
+    }
+  };
+  const log = (level: string) => (...args: unknown[]) => native.log(level, args.map(format).join(' '));
+  const timersByLabel = new Map<string, number>();
+  const counts = new Map<string, number>();
+  define('console', {
+    log: log('log'),
+    info: log('info'),
+    warn: log('warn'),
+    error: log('error'),
+    debug: log('debug'),
+    trace: log('debug'),
+    dir: log('log'),
+    table: log('log'),
+    group: log('log'),
+    groupCollapsed: log('log'),
+    groupEnd: () => {},
+    assert: (condition: unknown, ...args: unknown[]) => {
+      if (!condition) native.log('error', `Assertion failed${args.length ? `: ${args.map(format).join(' ')}` : ''}`);
+    },
+    count: (label = 'default') => {
+      const count = (counts.get(label) ?? 0) + 1;
+      counts.set(label, count);
+      native.log('log', `${label}: ${count}`);
+    },
+    countReset: (label = 'default') => counts.delete(label),
+    time: (label = 'default') => timersByLabel.set(label, now()),
+    timeEnd: (label = 'default') => {
+      const start = timersByLabel.get(label);
+      if (start !== undefined) native.log('log', `${label}: ${(now() - start).toFixed(3)} ms`);
+      timersByLabel.delete(label);
+    },
+    timeLog: (label = 'default') => {
+      const start = timersByLabel.get(label);
+      if (start !== undefined) native.log('log', `${label}: ${(now() - start).toFixed(3)} ms`);
+    },
+  });
+
+  const origin = Date.now() - now();
+  define('performance', {
+    now,
+    timeOrigin: origin,
+    mark: () => {},
+    measure: () => {},
+    getEntries: () => [],
+    getEntriesByName: () => [],
+    getEntriesByType: () => [],
+    clearMarks: () => {},
+    clearMeasures: () => {},
+  });
+
+  define('TextEncoder', SimpleTextEncoder);
+  define('TextDecoder', SimpleTextDecoder);
+  define('atob', atobPolyfill);
+  define('btoa', btoaPolyfill);
+
+  const fetchGlobals = createFetch(native);
+  define('fetch', fetchGlobals.fetch);
+  define('Headers', fetchGlobals.Headers);
+  define('Request', fetchGlobals.Request);
+  define('Response', fetchGlobals.Response);
+  define('AbortController', fetchGlobals.AbortController);
+  define('AbortSignal', fetchGlobals.AbortSignal);
+  define('__sbFetchResult', fetchGlobals.__sbFetchResult);
+
+  define('URL', SimpleURL);
+  define('URLSearchParams', SimpleURLSearchParams);
+
+  define('crypto', {
+    getRandomValues: <T extends ArrayBufferView>(array: T): T => {
+      const bytes = base64Decode(native.randomBytes(array.byteLength));
+      new Uint8Array(array.buffer, array.byteOffset, array.byteLength).set(bytes.subarray(0, array.byteLength));
+      return array;
+    },
+    randomUUID: (): string => {
+      const bytes = base64Decode(native.randomBytes(16));
+      bytes[6] = (bytes[6]! & 0x0f) | 0x40;
+      bytes[8] = (bytes[8]! & 0x3f) | 0x80;
+      const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('');
+      return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+    },
+  });
+
+  const storage = {
+    getItem: (key: string): string | null => native.storageGet(String(key)),
+    setItem: (key: string, value: string): void => native.storageSet(String(key), String(value)),
+    removeItem: (key: string): void => native.storageRemove(String(key)),
+    clear: (): void => native.storageClear(),
+    key: (index: number): string | null => native.storageKeys()[index] ?? null,
+    get length(): number {
+      return native.storageKeys().length;
+    },
+  };
+  define('localStorage', storage);
+
+  define('structuredClone', <T>(value: T): T => (value === undefined ? value : (JSON.parse(JSON.stringify(value)) as T)));
+
+  define('navigator', {
+    userAgent: 'SwiftBrowserNative',
+    language: native.locale().replace('_', '-'),
+    languages: [native.locale().replace('_', '-')],
+    onLine: true,
+    platform: 'iOS',
+    hardwareConcurrency: 1,
+  });
+
+  return installed;
+}
+
+// Installed at import, over the bridge the app runs in. Outside it (a test,
+// a bundler's dry run) nothing happens until `installRuntime` is called.
+const bridge = nativeBridge();
+if (bridge) installRuntime(bridge);

package/src/stubs/react-dom-client.ts

@@ -0,0 +1,17 @@
+/** `react-dom/client` for the native bundle: no DOM, so no roots (see react-dom.ts). */
+
+export interface Root {
+  render(children: unknown): void;
+  unmount(): void;
+}
+
+export function createRoot(): Root {
+  return {
+    render() {},
+    unmount() {},
+  };
+}
+
+export function hydrateRoot(): Root {
+  return createRoot();
+}

package/src/stubs/react-dom.ts

@@ -0,0 +1,15 @@
+/**
+ * `react-dom` as the native bundle sees it. @swiftbrowser/react's `Host`
+ * component (React DOM inside a SwiftUI tree) imports it; there is no DOM
+ * here, so a `Host` renders nothing and `flushSync` just runs its function.
+ */
+
+export function flushSync<R>(fn?: () => R): R | undefined {
+  return fn?.();
+}
+
+export function createPortal(): null {
+  return null;
+}
+
+export const version = '0.0.0-swiftbrowser-native';

package/src/types/react-refresh.d.ts

@@ -0,0 +1,38 @@
+// The parts of react-refresh's runtime and Babel plugin this package uses
+// (the package ships no types; @types/react-refresh would be one more dependency).
+declare module 'react-refresh/runtime' {
+  export interface Family {
+    current: unknown;
+  }
+  export type SignatureFunction = (type: unknown, key: string, forceReset?: boolean, getCustomHooks?: () => unknown[]) => unknown;
+  const RefreshRuntime: {
+    injectIntoGlobalHook(globalObject: Window): void;
+    register(type: unknown, id: string): void;
+    createSignatureFunctionForTransform(): SignatureFunction;
+    performReactRefresh(): unknown;
+    getFamilyByType(type: unknown): Family | undefined;
+    isLikelyComponentType(type: unknown): boolean;
+    hasUnrecoverableErrors(): boolean;
+  };
+  export default RefreshRuntime;
+}
+
+declare module 'react-refresh/babel' {
+  const plugin: unknown;
+  export default plugin;
+}
+
+declare module '@babel/core' {
+  export interface TransformOptions {
+    filename?: string;
+    configFile?: boolean;
+    babelrc?: boolean;
+    sourceType?: 'module' | 'script';
+    plugins?: unknown[];
+    sourceMaps?: boolean | 'inline';
+  }
+  export interface BabelFileResult {
+    code?: string | null;
+  }
+  export function transformAsync(code: string, options?: TransformOptions): Promise<BabelFileResult | null>;
+}

package/src/url.ts

@@ -0,0 +1,202 @@
+/**
+ * `URL` and `URLSearchParams` for an engine without them. Enough for what
+ * apps and libraries do with them (build and read absolute URLs, query
+ * strings); not the whole WHATWG parser: no IDNA, no percent-encoding
+ * normalization beyond `encodeURIComponent` in the search params.
+ */
+
+export class SimpleURLSearchParams {
+  private entries: [string, string][] = [];
+  /** Called when the params change, so an owning URL updates its `search`. */
+  onChange: (() => void) | null = null;
+
+  constructor(init: string | Record<string, string> | [string, string][] | SimpleURLSearchParams = '') {
+    if (typeof init === 'string') {
+      const text = init.startsWith('?') ? init.slice(1) : init;
+      for (const part of text.split('&')) {
+        if (!part) continue;
+        const at = part.indexOf('=');
+        const key = at < 0 ? part : part.slice(0, at);
+        const value = at < 0 ? '' : part.slice(at + 1);
+        this.entries.push([decodeComponent(key), decodeComponent(value)]);
+      }
+    } else if (init instanceof SimpleURLSearchParams) {
+      this.entries = init.entries.map(([k, v]) => [k, v]);
+    } else if (Array.isArray(init)) {
+      this.entries = init.map(([k, v]) => [String(k), String(v)]);
+    } else {
+      this.entries = Object.entries(init).map(([k, v]) => [k, String(v)]);
+    }
+  }
+
+  get size(): number {
+    return this.entries.length;
+  }
+  append(name: string, value: string): void {
+    this.entries.push([name, String(value)]);
+    this.onChange?.();
+  }
+  delete(name: string): void {
+    this.entries = this.entries.filter(([k]) => k !== name);
+    this.onChange?.();
+  }
+  get(name: string): string | null {
+    return this.entries.find(([k]) => k === name)?.[1] ?? null;
+  }
+  getAll(name: string): string[] {
+    return this.entries.filter(([k]) => k === name).map(([, v]) => v);
+  }
+  has(name: string): boolean {
+    return this.entries.some(([k]) => k === name);
+  }
+  set(name: string, value: string): void {
+    const index = this.entries.findIndex(([k]) => k === name);
+    if (index < 0) this.entries.push([name, String(value)]);
+    else {
+      this.entries[index] = [name, String(value)];
+      this.entries = this.entries.filter(([k], i) => k !== name || i === index);
+    }
+    this.onChange?.();
+  }
+  sort(): void {
+    this.entries.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+    this.onChange?.();
+  }
+  forEach(callback: (value: string, key: string, parent: SimpleURLSearchParams) => void): void {
+    for (const [k, v] of this.entries) callback(v, k, this);
+  }
+  keys(): IterableIterator<string> {
+    return this.entries.map(([k]) => k)[Symbol.iterator]();
+  }
+  values(): IterableIterator<string> {
+    return this.entries.map(([, v]) => v)[Symbol.iterator]();
+  }
+  [Symbol.iterator](): IterableIterator<[string, string]> {
+    return this.entries.map(([k, v]) => [k, v] as [string, string])[Symbol.iterator]();
+  }
+  toString(): string {
+    return this.entries.map(([k, v]) => `${encodeComponent(k)}=${encodeComponent(v)}`).join('&');
+  }
+}
+
+function encodeComponent(value: string): string {
+  return encodeURIComponent(value).replace(/%20/g, '+');
+}
+function decodeComponent(value: string): string {
+  try {
+    return decodeURIComponent(value.replace(/\+/g, ' '));
+  } catch {
+    return value;
+  }
+}
+
+const URL_PATTERN = /^([a-zA-Z][a-zA-Z0-9+.-]*):(?:\/\/(?:([^@/?#]*)@)?([^:/?#]*)(?::(\d+))?)?([^?#]*)(\?[^#]*)?(#.*)?$/;
+const DEFAULT_PORTS: Record<string, string> = { 'http:': '80', 'https:': '443', 'ws:': '80', 'wss:': '443', 'ftp:': '21' };
+
+export class SimpleURL {
+  protocol = '';
+  username = '';
+  password = '';
+  hostname = '';
+  port = '';
+  pathname = '';
+  hash = '';
+  readonly searchParams: SimpleURLSearchParams;
+  private _search = '';
+
+  constructor(url: string, base?: string | SimpleURL) {
+    let text = String(url);
+    if (!URL_PATTERN.test(text) || /^[a-zA-Z][a-zA-Z0-9+.-]*:(?!\/\/)/.test(text) === false && !/^[a-zA-Z]/.test(text)) {
+      if (base === undefined) throw new TypeError(`Invalid URL: ${text}`);
+      text = resolve(text, base instanceof SimpleURL ? base.href : String(base));
+    } else if (!/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(text)) {
+      if (base === undefined) throw new TypeError(`Invalid URL: ${text}`);
+      text = resolve(text, base instanceof SimpleURL ? base.href : String(base));
+    }
+    const match = URL_PATTERN.exec(text);
+    if (!match) throw new TypeError(`Invalid URL: ${text}`);
+    const [, scheme, auth, host, port, path, search, hash] = match;
+    this.protocol = `${scheme!.toLowerCase()}:`;
+    if (auth !== undefined) {
+      const at = auth.indexOf(':');
+      this.username = at < 0 ? auth : auth.slice(0, at);
+      this.password = at < 0 ? '' : auth.slice(at + 1);
+    }
+    this.hostname = (host ?? '').toLowerCase();
+    this.port = port !== undefined && DEFAULT_PORTS[this.protocol] !== port ? port : '';
+    this.pathname = path || (host !== undefined ? '/' : '');
+    this._search = search && search !== '?' ? search : '';
+    this.hash = hash && hash !== '#' ? hash : '';
+    this.searchParams = new SimpleURLSearchParams(this._search);
+    this.searchParams.onChange = () => {
+      const text = this.searchParams.toString();
+      this._search = text ? `?${text}` : '';
+    };
+  }
+
+  get search(): string {
+    return this._search;
+  }
+  set search(value: string) {
+    const text = value.startsWith('?') ? value : value ? `?${value}` : '';
+    this._search = text === '?' ? '' : text;
+    const next = new SimpleURLSearchParams(this._search);
+    // Replace the entries in place so the same object keeps working.
+    (this.searchParams as unknown as { entries: [string, string][] }).entries = [...next];
+  }
+  get host(): string {
+    return this.port ? `${this.hostname}:${this.port}` : this.hostname;
+  }
+  set host(value: string) {
+    const at = value.indexOf(':');
+    this.hostname = at < 0 ? value : value.slice(0, at);
+    this.port = at < 0 ? '' : value.slice(at + 1);
+  }
+  get origin(): string {
+    return this.hostname ? `${this.protocol}//${this.host}` : 'null';
+  }
+  get href(): string {
+    const auth = this.username ? `${this.username}${this.password ? `:${this.password}` : ''}@` : '';
+    const authority = this.hostname || this.protocol === 'file:' ? `//${auth}${this.host}` : '';
+    return `${this.protocol}${authority}${this.pathname}${this._search}${this.hash}`;
+  }
+  set href(value: string) {
+    const next = new SimpleURL(value);
+    Object.assign(this, { protocol: next.protocol, username: next.username, password: next.password, hostname: next.hostname, port: next.port, pathname: next.pathname, hash: next.hash });
+    this.search = next.search;
+  }
+  toString(): string {
+    return this.href;
+  }
+  toJSON(): string {
+    return this.href;
+  }
+
+  static canParse(url: string, base?: string): boolean {
+    try {
+      new SimpleURL(url, base);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+/** Resolves a relative reference against a base (RFC 3986 section 5.2, the common cases). */
+function resolve(reference: string, base: string): string {
+  const b = new SimpleURL(base);
+  if (reference.startsWith('//')) return `${b.protocol}${reference}`;
+  if (reference.startsWith('/')) return `${b.origin}${reference}`;
+  if (reference.startsWith('?')) return `${b.origin}${b.pathname}${reference}`;
+  if (reference.startsWith('#')) return `${b.origin}${b.pathname}${b.search}${reference}`;
+  if (reference === '') return `${b.origin}${b.pathname}${b.search}`;
+  const directory = b.pathname.slice(0, b.pathname.lastIndexOf('/') + 1);
+  const segments: string[] = [];
+  for (const segment of `${directory}${reference}`.split('/')) {
+    if (segment === '..') segments.pop();
+    else if (segment !== '.') segments.push(segment);
+  }
+  let path = segments.join('/');
+  if (!path.startsWith('/')) path = `/${path}`;
+  return `${b.origin}${path}`;
+}

package/src/vendor.ts

@@ -0,0 +1,30 @@
+/**
+ * The vendor half of the dev bundle (devBuild.ts): the runtime, React Fast
+ * Refresh's runtime (before React), React, `@swiftbrowser/react` and this
+ * package, evaluated once. The app half is built against shims that read
+ * these from `__sbVendor`, so re-evaluating it on a save keeps one React and
+ * refreshes the mounted components in place.
+ */
+
+import './runtime';
+import './refresh';
+import * as React from 'react';
+import * as JSXDevRuntime from 'react/jsx-dev-runtime';
+import * as JSXRuntime from 'react/jsx-runtime';
+import * as SwiftBrowserReact from '@swiftbrowser/react';
+import { injectIntoDevTools } from '@swiftbrowser/react';
+import * as Native from './index';
+
+// The reconciler tells the DevTools hook (which the refresh runtime installed)
+// about itself, which is how Fast Refresh reaches the mounted roots.
+injectIntoDevTools();
+
+export const vendor: Record<string, unknown> = {
+  react: React,
+  'react/jsx-runtime': JSXRuntime,
+  'react/jsx-dev-runtime': JSXDevRuntime,
+  '@swiftbrowser/react': SwiftBrowserReact,
+  '@swiftbrowser/native': Native,
+};
+
+(globalThis as unknown as { __sbVendor: typeof vendor }).__sbVendor = vendor;

package/src/wasmHost.ts

@@ -0,0 +1,147 @@
+/**
+ * The host's JavaScript as SwiftBrowser Native's engine (docs/native.md,
+ * "The round trip"): for a module built with the round-trip target
+ * (`Native/RoundTrip`, the native views compiled against the shim), this
+ * answers its one import, `sb_native.request`, and exposes the native
+ * functions Swift installs (`applyOps`, `log`, `now`, …) on `__sbNative`,
+ * each a call of the module's `sb_native_invoke` export.
+ *
+ * Node (scripts/run-wasi.mjs) and a page use it the same way: merge
+ * `imports` into the module's imports, instantiate, then `attach` the
+ * instance. Strings cross linear memory as UTF-8; an answer to Swift is a
+ * buffer from `sb_alloc` holding a little-endian 4-byte length and the
+ * bytes, which Swift frees, and a result from Swift is the same layout,
+ * freed with `sb_native_free` once read.
+ */
+
+export interface WasmNativeHostOptions {
+  /** Runs a script at the global scope (default: an indirect `eval`). */
+  evaluate?: (script: string, name: string) => void;
+  /** The global object the bundle's globals live on (default `globalThis`). */
+  global?: Record<string, unknown>;
+}
+
+export interface WasmNativeHost {
+  /** Merge into the module's import object before instantiating. */
+  imports: {
+    sb_native: {
+      request: (kind: number, kindLength: number, a: number, aLength: number, b: number, bLength: number) => number;
+    };
+  };
+  /** The instance, once instantiated: its memory and the exports the host calls. */
+  attach(instance: WebAssembly.Instance): void;
+  /** The `__sbNative` object as it stands (replaced by a reset). */
+  readonly native: Record<string, (...args: unknown[]) => unknown>;
+}
+
+interface Exports {
+  memory: WebAssembly.Memory;
+  sb_alloc: (length: number) => number;
+  sb_native_invoke: (name: number, nameLength: number, args: number, argsLength: number) => number;
+  sb_native_free: (pointer: number) => void;
+}
+
+/** The globals a bundle defines, dropped by a reset (`JSHost.reset`). */
+const BUNDLE_GLOBALS = ['__sbDispatch', '__sbTimerFired', '__sbFetchResult', '__sbRefresh', '__sbVendor'];
+
+export function wasmNativeHost(options: WasmNativeHostOptions = {}): WasmNativeHost {
+  const g = options.global ?? (globalThis as unknown as Record<string, unknown>);
+  const evaluate = options.evaluate ?? ((script: string) => (0, eval)(script));
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  let exports: Exports | null = null;
+  let native: Record<string, (...args: unknown[]) => unknown> = {};
+
+  const need = (): Exports => {
+    if (!exports) throw new Error('wasmNativeHost: attach(instance) before the module runs');
+    return exports;
+  };
+  const read = (pointer: number, length: number): string =>
+    decoder.decode(new Uint8Array(need().memory.buffer, pointer, length));
+  /** A buffer from `sb_alloc` with the text's length and bytes; Swift frees it. */
+  const answer = (value: unknown): number => {
+    const bytes = encoder.encode(JSON.stringify(value));
+    const pointer = need().sb_alloc(bytes.length + 4);
+    // The allocation may have grown the memory: take the view after it.
+    const view = new DataView(need().memory.buffer);
+    view.setUint32(pointer, bytes.length, true);
+    new Uint8Array(need().memory.buffer, pointer + 4, bytes.length).set(bytes);
+    return pointer;
+  };
+  const describe = (error: unknown): string => (error instanceof Error ? (error.stack ?? error.message) : String(error));
+
+  /** A native function's call: into Swift and back with its JSON result. */
+  const invoke = (name: string, args: unknown[]): unknown => {
+    const nameBytes = encoder.encode(name);
+    const argsBytes = encoder.encode(JSON.stringify(args));
+    const namePointer = need().sb_alloc(nameBytes.length || 1);
+    new Uint8Array(need().memory.buffer, namePointer, nameBytes.length).set(nameBytes);
+    const argsPointer = need().sb_alloc(argsBytes.length || 1);
+    new Uint8Array(need().memory.buffer, argsPointer, argsBytes.length).set(argsBytes);
+    const result = need().sb_native_invoke(namePointer, nameBytes.length, argsPointer, argsBytes.length);
+    if (result === 0) return undefined;
+    const length = new DataView(need().memory.buffer).getUint32(result, true);
+    const text = read(result + 4, length);
+    need().sb_native_free(result);
+    const value: unknown = JSON.parse(text);
+    if (value && typeof value === 'object' && 'error' in value && Object.keys(value).length === 1) {
+      throw new Error(String((value as { error: unknown }).error));
+    }
+    return value;
+  };
+
+  const reset = (): void => {
+    for (const name of BUNDLE_GLOBALS) delete g[name];
+    native = {};
+    g['__sbNative'] = native;
+  };
+
+  const request = (kind: number, kindLength: number, a: number, aLength: number, b: number, bLength: number): number => {
+    const what = read(kind, kindLength);
+    const first = read(a, aLength);
+    const second = read(b, bLength);
+    switch (what) {
+      case 'reset':
+        reset();
+        return 0;
+      case 'install':
+        native[first] = (...args: unknown[]) => invoke(first, args);
+        return 0;
+      case 'eval':
+        try {
+          evaluate(first, second);
+          return 0;
+        } catch (error) {
+          return answer({ error: describe(error) });
+        }
+      case 'call': {
+        const fn = g[first];
+        if (typeof fn !== 'function') return answer({ error: `${first} is not defined` });
+        try {
+          const result: unknown = (fn as (...args: unknown[]) => unknown)(...(JSON.parse(second) as unknown[]));
+          return answer({ ok: result === undefined ? null : result });
+        } catch (error) {
+          return answer({ error: describe(error) });
+        }
+      }
+      case 'has':
+        return answer({ ok: first in g });
+      default:
+        return answer({ error: `unknown request ${what}` });
+    }
+  };
+
+  reset();
+  return {
+    imports: { sb_native: { request } },
+    attach(instance) {
+      for (const name of ['memory', 'sb_alloc', 'sb_native_invoke', 'sb_native_free']) {
+        if (!(name in instance.exports)) throw new Error(`wasmNativeHost: the module does not export ${name}`);
+      }
+      exports = instance.exports as unknown as Exports;
+    },
+    get native() {
+      return native;
+    },
+  };
+}