janela 0.8.0 → 0.10.0

package/runtime/janela.ts

@@ -19,13 +19,12 @@ declare function wvEval(h: number, js: string): number;
 declare function wvBind(h: number, name: string): number;
 declare function wvReply(h: number, body: string): number;
 declare function wvOnInvoke(h: number, cb: (req: string) => number): number;
-declare function wvOnTick(h: number, cb: () => void): number;
+declare function wvOnTimer(h: number, cb: (id: number) => void): number;
 declare function wvRun(h: number): number;
 declare function wvTerminate(h: number): number;
 declare function wvDefer(h: number): number;
 declare function wvResolve(h: number, id: number, status: number): number;
-declare function wvTickStart(h: number, intervalMs: number): number;
-declare function wvTickStop(h: number): number;
+declare function wvSchedule(h: number, id: number, ms: number): number;
 declare function wvFsRead(h: number, path: string): number;
 declare function wvFsWrite(h: number, path: string, data: string): number;
 declare function wvJobStatus(h: number, id: number): number;
@@ -148,11 +147,10 @@ function encodeFilters(filters: DialogFilter[] | undefined): string {
 const DRAIN_BUDGET_MS = 4; // = a quarter of a 60fps frame
 const DRAIN_SLICE = 131072; // 128 KB - granularity within the budget
 
-// 8 ms is plenty for timers and task chains, but while a payload is draining
-// the loop does real work every turn, and waiting 8 ms between 4 ms slices
-// would halve throughput for no benefit.
-const TICK_IDLE_MS = 8;
-const TICK_DRAIN_MS = 4;
+// The shell posts this id when a file read or a dialog reaches a terminal
+// state. It is not a continuation - it means "service the jobs you are
+// waiting on". Continuation ids start at 1, so the two can never collide.
+const TIMER_JOBS = -1;
 
 /**
  * A running janela app.
@@ -171,21 +169,23 @@ export class JanelaAppImpl<
   names: string[] = [];
   handlers: CommandHandler[] = [];
 
-  // ---- the host loop -------------------------------------------------------
+  // ---- scheduling ----------------------------------------------------------
   // scriptc's event loop is parked for as long as the program sits inside the
   // wvRun() FFI call, so setTimeout/await never fire while the window is open.
-  // These queues are drained instead by the retained tick handler that the
-  // shim's ticker posts to the UI thread, and the ticker only runs while there
-  // is work - an idle app costs nothing.
+  // The shell schedules instead: a continuation is parked here under an id and
+  // handed to wvSchedule(), and the shim calls onTimer(id) back on the UI
+  // thread once it comes due. Nothing here polls and nothing wakes
+  // periodically - an idle app is genuinely idle.
+  //
+  // This is the same shape the iOS shell must use, where the compiled TS links
+  // no event loop at all and could not hold a timer even if it wanted to.
   asyncNames: string[] = [];
   asyncHandlers: AsyncCommandHandler[] = [];
-  taskFns: (() => void)[] = [];
-  timerFns: (() => void)[] = [];
-  timerDue: number[] = [];
+  contIds: number[] = [];
+  contFns: (() => void)[] = [];
+  nextCont = 1; // ids start at 1; TIMER_JOBS (-1) is the shell's own
   jobIds: number[] = [];
   jobCbs: FsCallback[] = [];
-  ticking = false;
-  tickMs = TICK_IDLE_MS;
 
   // ---- the drain -----------------------------------------------------------
   // A finished job's bytes still have to be decoded into a TypeScript string,
@@ -194,6 +194,7 @@ export class JanelaAppImpl<
   // decoded a slice at a time, giving the run loop the thread back between
   // slices - total work is unchanged, but no single turn carries much of it.
   drainIds: number[] = [];
+  draining = false; // a drain continuation is already queued
   drainCbs: FsCallback[] = [];
   drainOk: boolean[] = [];
   drainParts: string[][] = [];
@@ -208,37 +209,49 @@ export class JanelaAppImpl<
     wvInit(h, BOOTSTRAP);
   }
 
-  retick(): void {
-    const want = this.drainIds.length > 0 ? TICK_DRAIN_MS : TICK_IDLE_MS;
-    if (!this.ticking || want === this.tickMs) return;
-    this.tickMs = want;
-    wvTickStart(this.handle, want);
-  }
-
-  wake(): void {
-    if (this.ticking) return;
-    this.ticking = true;
-    this.tickMs = this.drainIds.length > 0 ? TICK_DRAIN_MS : TICK_IDLE_MS;
-    wvTickStart(this.handle, this.tickMs);
+  /**
+   * Park `fn` with the shell and ask to be called back in `ms`.
+   *
+   * The id is the whole protocol: TS keeps the closure, the shell keeps the
+   * clock, and neither needs to know anything else about the other.
+   */
+  schedule(ms: number, fn: () => void): void {
+    const id = this.nextCont;
+    this.nextCont = id + 1;
+    this.contIds.push(id);
+    this.contFns.push(fn);
+    const delay = ms > 0 ? ms : 0;
+    // `+ 0` per the note at the top of this file: a bare FFI call is not safe
+    // in every position, and this one is silently dropped without it.
+    const rc = wvSchedule(this.handle, id, delay) + 0;
+    if (rc < 0) console.log("[janela] could not schedule continuation", id);
   }
 
-  idle(): void {
-    if (!this.ticking) return;
-    if (
-      this.taskFns.length > 0 ||
-      this.timerFns.length > 0 ||
-      this.jobIds.length > 0 ||
-      this.drainIds.length > 0
-    ) {
-      return;
+  /** Run the continuation parked under `id`, if it is still waiting. */
+  runCont(id: number): void {
+    for (let i = 0; i < this.contIds.length; i++) {
+      if (this.contIds[i] === id) {
+        const fn = this.contFns[i];
+        // Unregister BEFORE running: a continuation that schedules another one
+        // must not disturb the entry being removed, and a continuation that
+        // throws must not stay parked forever.
+        this.contIds.splice(i, 1);
+        this.contFns.splice(i, 1);
+        fn();
+        return;
+      }
     }
-    this.ticking = false;
-    wvTickStop(this.handle);
   }
 
   // Decode as much of the pending payloads as the budget allows, then yield.
   // Slices are taken from one job at a time so a big read finishes promptly
   // rather than every concurrent read finishing slowly.
+  /**
+   * Decode as much of the pending payloads as the budget allows, then hand the
+   * thread back. If work remains, a zero-delay continuation carries on at the
+   * top of the next turn, so a 100 MB read is spread across frames instead of
+   * freezing one.
+   */
   drainSome(): void {
     if (this.drainIds.length === 0) return;
     const started = Date.now() + 0;
@@ -281,38 +294,39 @@ export class JanelaAppImpl<
         // before starting another payload.
       }
 
-      if (Date.now() - started >= DRAIN_BUDGET_MS) return;
+      if (Date.now() - started >= DRAIN_BUDGET_MS) {
+        this.drainMore();
+        return;
+      }
     }
   }
 
-  // One turn of the loop: every task queued so far, plus every due timer.
-  // Tasks queued *by* this turn wait for the next one, so a defer() chain
-  // yields to the UI between slices instead of starving it.
-  turn(): void {
-    const tasks = this.taskFns;
-    this.taskFns = [];
-    for (let i = 0; i < tasks.length; i++) tasks[i]();
-
-    if (this.timerFns.length > 0) {
-      const now = Date.now() + 0;
-      const keptFns: (() => void)[] = [];
-      const keptDue: number[] = [];
-      const fire: (() => void)[] = [];
-      for (let i = 0; i < this.timerFns.length; i++) {
-        if (this.timerDue[i] <= now) {
-          fire.push(this.timerFns[i]);
-        } else {
-          keptFns.push(this.timerFns[i]);
-          keptDue.push(this.timerDue[i]);
-        }
-      }
-      this.timerFns = keptFns;
-      this.timerDue = keptDue;
-      for (let i = 0; i < fire.length; i++) fire[i]();
+  /** Continue draining on the next turn, without stacking duplicate work. */
+  drainMore(): void {
+    if (this.drainIds.length === 0 || this.draining) return;
+    this.draining = true;
+    this.schedule(0, () => {
+      this.draining = false;
+      this.drainSome();
+    });
+  }
+
+  /**
+   * The shell calls here on the UI thread when something it was holding comes
+   * due: a continuation TS parked (id >= 1), or a job that finished
+   * (TIMER_JOBS). This is the only entry into the loop, and it always lands at
+   * the top of a fresh turn — never underneath a TS frame.
+   */
+  onTimer(id: number): void {
+    if (id !== TIMER_JOBS) {
+      this.runCont(id);
+      return;
     }
+    this.serviceJobs();
+  }
 
-    // Finished file jobs: the worker thread has already done the blocking
-    // syscall, so all that happens on this (UI) thread is the drain.
+  /** A job reached a terminal state: move the finished ones to the drain. */
+  serviceJobs(): void {
     if (this.jobIds.length > 0) {
       const keptIds: number[] = [];
       const keptCbs: FsCallback[] = [];
@@ -346,8 +360,6 @@ export class JanelaAppImpl<
     }
 
     this.drainSome();
-    this.retick();
-    this.idle();
   }
 
   // Both dialog kinds share one path: start the job, then let the same drain
@@ -371,8 +383,7 @@ export class JanelaAppImpl<
       encodeFilters(filters),
     ) + 0;
     if (id < 0) {
-      this.taskFns.push(() => cb(null, "EAGAIN: could not open a dialog"));
-      this.wake();
+      this.defer(() => cb(null, "EAGAIN: could not open a dialog"));
       return;
     }
     this.jobIds.push(id);
@@ -384,7 +395,6 @@ export class JanelaAppImpl<
       // "null" is a cancel; anything else is a JSON array of paths.
       cb(JSON.parse(text) as string[] | null);
     });
-    this.wake();
   }
 
   /**
@@ -427,16 +437,14 @@ export class JanelaAppImpl<
 
   /** Run fn on the next turn of the host loop - the way to slice long work. */
   defer(fn: () => void): void {
-    this.taskFns.push(fn);
-    this.wake();
+    // Zero delay: the shell posts straight to the next turn, no timer at all.
+    this.schedule(0, fn);
   }
 
-  /** Run fn after at least ms. The host loop's timer; scriptc's setTimeout
+  /** Run fn after at least ms. The shell owns the clock; scriptc's setTimeout
    *  cannot fire while the window is open (its loop is parked inside run()). */
   sleep(ms: number, fn: () => void): void {
-    this.timerFns.push(fn);
-    this.timerDue.push(Date.now() + (ms > 0 ? ms : 0));
-    this.wake();
+    this.schedule(ms, fn);
   }
 
   /**
@@ -451,7 +459,6 @@ export class JanelaAppImpl<
     }
     this.jobIds.push(id);
     this.jobCbs.push(cb);
-    this.wake();
   }
 
   /** Write a file without blocking the window; cb(null) on success. */
@@ -465,7 +472,6 @@ export class JanelaAppImpl<
     // The write payload is empty on success; the shared callback shape just
     // ignores the text argument.
     this.jobCbs.push((err, _text) => cb(err));
-    this.wake();
   }
 
   /** Show the native "open" dialog; cb gets the paths, or null on cancel. */
@@ -531,8 +537,8 @@ export class JanelaAppImpl<
     const h = this.handle;
     // Both handlers are retained: registered once here, called by the shim
     // for as long as the window is open.
-    wvOnTick(h, () => {
-      this.turn();
+    wvOnTimer(h, (id) => {
+      this.onTimer(id);
     });
     wvOnInvoke(h, (req) => {
       const env = JSON.parse(req) as string[];

package/shim/ios/app.mm

@@ -0,0 +1,386 @@
+// janela's iOS shell: UIKit owns the run loop, WKWebView is the window, and
+// the app's TypeScript is a linked scriptc library we call into.
+//
+// This is the mirror image of the desktop shim. There, TypeScript owns main()
+// and drives a C library over FFI; here the platform owns main() and calls a
+// TypeScript library. scriptc builds iOS as a library only, and library mode
+// links no event loop (SC4005), so there is nothing to pump: each invoke runs
+// to completion and returns.
+//
+// The WKWebView / WKUserContentController / script-message-handler wiring
+// follows the approach used by wry (https://github.com/tauri-apps/wry,
+// Apache-2.0, © Tauri Programme within The Commons Conservancy) in
+// src/wkwebview/. wry attaches its webview to a UIView supplied by tao; janela
+// has no tao, so it creates the UIWindow and root view controller itself. The
+// IPC envelope and the page-side bridge are janela's own, and match what the
+// desktop shim injects so that `janela/api` works unchanged.
+
+#import <UIKit/UIKit.h>
+#import <WebKit/WebKit.h>
+
+#include <string.h>
+
+// ---- the scriptc library's C ABI (see the generated profile) ---------------
+extern "C" {
+void jl_init(void);
+void jl_reset(void);
+void jl_set_panic_sink(void (*fn)(void *, const char *, size_t, const char *, size_t), void *ctx);
+int32_t jl_set_callback(const char *name, void (*fn)(void), void *ctx);
+void jl_handle_invoke(const char *cmd, size_t cmd_len, const char *args, size_t args_len,
+                      char **out, size_t *out_len);
+void jl_index_html(char **out, size_t *out_len);
+void jl_on_timer(double id);
+void jl_on_fs_done(double id, bool ok, const char *payload, size_t payload_len);
+}
+
+static WKWebView *gWebView = nil;
+
+/// Settle one page-side promise with an envelope that is already JSON.
+static void settlePage(NSNumber *callId, NSString *envelope) {
+  NSString *js =
+      [NSString stringWithFormat:@"window.__janelaSettle(%@,%@);", callId, envelope];
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [gWebView evaluateJavaScript:js completionHandler:nil];
+  });
+}
+
+static void panicSink(void *ctx, const char *sym, size_t symlen, const char *msg, size_t msglen) {
+  (void)ctx;
+  NSLog(@"[janela] host panic in %.*s: %.*s", (int)symlen, sym, (int)msglen, msg);
+}
+
+// ---- what the shell owns for the library ----------------------------------
+//
+// Two tables, mirroring the desktop shim: continuations the library parked
+// with us, and page replies we are holding until the library says what they
+// are. Both live on the main queue and are only touched there.
+//
+// THE RULE (upstream #263): a channel handler must never re-enter the library.
+// Every handler below therefore only records what it was told and returns; the
+// re-entry happens from a dispatch_async block, i.e. at the top of a later
+// turn with no library frame beneath it. A breach silently appears to work, so
+// this has to hold by construction rather than by testing.
+
+/// Page replies whose answer was not ready when handle_invoke returned.
+/// pendingId -> the page-side call id we have not settled yet.
+static NSMutableDictionary<NSNumber *, NSNumber *> *gHeld = nil;
+/// Envelopes that arrived before we knew the page call id — a command that
+/// resolves synchronously settles during its own dispatch, before the
+/// {"pending":id} envelope has made it back to us.
+static NSMutableDictionary<NSNumber *, NSString *> *gEarly = nil;
+
+/// Answer the page for a pending id, whichever half arrived first.
+static void resolvePending(NSNumber *pendingId, NSString *envelope) {
+  NSNumber *callId = gHeld[pendingId];
+  if (callId) {
+    [gHeld removeObjectForKey:pendingId];
+    settlePage(callId, envelope);
+  } else {
+    gEarly[pendingId] = envelope; // handle_invoke has not returned yet
+  }
+}
+
+/// Register the page call id a pending answer belongs to.
+static void holdPending(NSNumber *pendingId, NSNumber *callId) {
+  NSString *early = gEarly[pendingId];
+  if (early) {
+    [gEarly removeObjectForKey:pendingId];
+    settlePage(callId, early); // it resolved synchronously; answer now
+  } else {
+    gHeld[pendingId] = callId;
+  }
+}
+
+// ---- channels the library calls (TS -> shell) ------------------------------
+
+/// Park a continuation with us and call back when it comes due. A zero delay
+/// still goes through dispatch_after(0), which posts to the next turn — that
+/// is app.defer(), and it costs no timer.
+static void hostSchedule(void *ctx, double id, double ms) {
+  (void)ctx;
+  int64_t delay = (int64_t)(ms > 0 ? ms : 0);
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delay * NSEC_PER_MSEC),
+                 dispatch_get_main_queue(), ^{
+    jl_on_timer(id); // fresh turn: no library frame beneath us
+  });
+}
+
+/// The library has an answer for a held page reply.
+static void hostSettle(void *ctx, double pendingId, const char *env, size_t env_len) {
+  (void)ctx;
+  NSString *envelope = [[NSString alloc] initWithBytes:env
+                                                length:env_len
+                                              encoding:NSUTF8StringEncoding] ?: @"null";
+  NSNumber *key = @((int64_t)pendingId);
+  dispatch_async(dispatch_get_main_queue(), ^{
+    resolvePending(key, envelope);
+  });
+}
+
+/// The file queue: blocking I/O happens here, never on the main queue, and
+/// never inside the library. The library links no threads of its own, so this
+/// is the only place a read can go.
+/// An iOS app has no useful working directory and cannot see host paths, so a
+/// relative path is taken as relative to the app's Documents directory — the
+/// one place a sandboxed app can freely read and write.
+static NSString *resolvePath(NSString *path) {
+  if ([path hasPrefix:@"/"]) return path;
+  NSArray<NSString *> *dirs =
+      NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
+  NSString *docs = dirs.firstObject ?: NSTemporaryDirectory();
+  return [docs stringByAppendingPathComponent:path];
+}
+
+static dispatch_queue_t fsQueue(void) {
+  static dispatch_queue_t q;
+  static dispatch_once_t once;
+  dispatch_once(&once, ^{
+    q = dispatch_queue_create("dev.janela.fs", DISPATCH_QUEUE_SERIAL);
+  });
+  return q;
+}
+
+static void finishFs(double id, bool ok, NSString *payload) {
+  // Convert INSIDE the block: -UTF8String hands back an autoreleased buffer
+  // whose lifetime does not survive the hop to another queue. The NSString is
+  // captured (and retained) by the block; the bytes are taken on arrival.
+  dispatch_async(dispatch_get_main_queue(), ^{
+    const char *bytes = payload.UTF8String ?: "";
+    jl_on_fs_done(id, ok, bytes, strlen(bytes));
+  });
+}
+
+static void hostReadFile(void *ctx, double id, const char *path, size_t path_len) {
+  (void)ctx;
+  NSString *p = resolvePath([[NSString alloc] initWithBytes:path
+                                                     length:path_len
+                                                   encoding:NSUTF8StringEncoding] ?: @"");
+  dispatch_async(fsQueue(), ^{
+    NSError *err = nil;
+    NSString *text = [NSString stringWithContentsOfFile:p
+                                               encoding:NSUTF8StringEncoding
+                                                  error:&err];
+    if (text) finishFs(id, true, text);
+    else finishFs(id, false, err.localizedDescription ?: @"read failed");
+  });
+}
+
+static void hostWriteFile(void *ctx, double id, const char *path, size_t path_len,
+                          const char *data, size_t data_len) {
+  (void)ctx;
+  NSString *p = resolvePath([[NSString alloc] initWithBytes:path
+                                                     length:path_len
+                                                   encoding:NSUTF8StringEncoding] ?: @"");
+  NSString *d = [[NSString alloc] initWithBytes:data
+                                         length:data_len
+                                       encoding:NSUTF8StringEncoding] ?: @"";
+  dispatch_async(fsQueue(), ^{
+    NSError *err = nil;
+    BOOL ok = [d writeToFile:p atomically:YES encoding:NSUTF8StringEncoding error:&err];
+    if (ok) finishFs(id, true, @"");
+    else finishFs(id, false, err.localizedDescription ?: @"write failed");
+  });
+}
+
+/// Copy a library-owned result out of its arena and release it. Results live
+/// until the next jl_reset(), so nothing may hold the pointer past this call.
+static NSString *takeResult(char *out, size_t out_len) {
+  NSString *s = out ? [[NSString alloc] initWithBytes:out
+                                               length:out_len
+                                             encoding:NSUTF8StringEncoding]
+                    : nil;
+  jl_reset();
+  return s ?: @"null";
+}
+
+/// Escape a JSON document for splicing into a JS expression as a string
+/// literal. Used for the event payload, which the page parses back.
+static NSString *jsQuote(NSString *raw) {
+  NSData *d = [NSJSONSerialization dataWithJSONObject:@[ raw ] options:0 error:nil];
+  NSString *arr = [[NSString alloc] initWithData:d encoding:NSUTF8StringEncoding];
+  // ["..."] -> "..."
+  return [arr substringWithRange:NSMakeRange(1, arr.length - 2)];
+}
+
+// ---- host -> page: the event channel ---------------------------------------
+//
+// The library calls this through the declared callback channel whenever the
+// app emits. Evaluating JS must happen on the main queue.
+
+static void emitEvent(void *ctx, const char *name, size_t name_len,
+                      const char *payload, size_t payload_len) {
+  (void)ctx;
+  NSString *event = [[NSString alloc] initWithBytes:name length:name_len
+                                           encoding:NSUTF8StringEncoding];
+  NSString *json = [[NSString alloc] initWithBytes:payload length:payload_len
+                                          encoding:NSUTF8StringEncoding];
+  if (!event || !json) return;
+  NSString *js = [NSString stringWithFormat:@"window.__wvEmit(%@,%@);", jsQuote(event), json];
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [gWebView evaluateJavaScript:js completionHandler:nil];
+  });
+}
+
+// ---- page -> host: the invoke bridge ---------------------------------------
+
+@interface JanelaBridge : NSObject <WKScriptMessageHandler>
+@end
+
+@implementation JanelaBridge
+
+- (void)userContentController:(WKUserContentController *)controller
+      didReceiveScriptMessage:(WKScriptMessage *)message {
+  NSDictionary *body = (NSDictionary *)message.body;
+  if (![body isKindOfClass:NSDictionary.class]) return;
+
+  NSNumber *callId = body[@"id"];
+  NSString *cmd = body[@"cmd"];
+  NSString *args = body[@"args"] ?: @"null";
+  if (!callId || !cmd) return;
+
+  const char *c = cmd.UTF8String;
+  const char *a = args.UTF8String;
+  char *out = NULL;
+  size_t out_len = 0;
+  jl_handle_invoke(c, strlen(c), a, strlen(a), &out, &out_len);
+  NSString *reply = takeResult(out, out_len);
+
+  // An async command answers later: the library returns {"pending":<id>} and
+  // we hold the page's promise until hostSettle() tells us what it is.
+  NSData *replyData = [reply dataUsingEncoding:NSUTF8StringEncoding];
+  NSDictionary *env = replyData
+      ? [NSJSONSerialization JSONObjectWithData:replyData options:0 error:nil]
+      : nil;
+  NSNumber *pendingId = [env isKindOfClass:NSDictionary.class] ? env[@"pending"] : nil;
+  if (pendingId) {
+    holdPending(pendingId, callId);
+    return;
+  }
+
+  // Otherwise the reply is an envelope: {"ok":true,"value":…} or
+  // {"ok":false,"error":…}, already JSON, so it splices straight into the
+  // expression that settles the page-side promise.
+  settlePage(callId, reply);
+}
+
+@end
+
+// ---- the page-side bridge --------------------------------------------------
+//
+// Same surface the desktop shim injects — window.janela.invoke/listen and
+// window.__wvEmit — so `janela/api` and a project's frontend work unchanged.
+// Only the transport differs: a script message instead of a webview bind.
+
+static NSString *const kBootstrap =
+    @"window.__wvListeners = {};"
+    @"window.__janelaPending = {};"
+    @"window.__janelaSeq = 0;"
+    @"window.__janelaSettle = function (id, env) {"
+    @"  var p = window.__janelaPending[id];"
+    @"  if (!p) return;"
+    @"  delete window.__janelaPending[id];"
+    @"  if (env && env.ok) p.resolve(env.value); else p.reject(new Error((env && env.error) || 'janela: invoke failed'));"
+    @"};"
+    @"window.janela = {"
+    @"  invoke: function (cmd, args) {"
+    @"    var id = ++window.__janelaSeq;"
+    @"    return new Promise(function (resolve, reject) {"
+    @"      window.__janelaPending[id] = { resolve: resolve, reject: reject };"
+    @"      window.webkit.messageHandlers.janela.postMessage({"
+    @"        id: id, cmd: cmd, args: JSON.stringify(args === undefined ? null : args)"
+    @"      });"
+    @"    });"
+    @"  },"
+    @"  listen: function (event, cb) {"
+    @"    if (!window.__wvListeners[event]) window.__wvListeners[event] = [];"
+    @"    window.__wvListeners[event].push(cb);"
+    @"    return function () {"
+    @"      var a = window.__wvListeners[event] || [];"
+    @"      var i = a.indexOf(cb);"
+    @"      if (i >= 0) a.splice(i, 1);"
+    @"    };"
+    @"  },"
+    @"};"
+    @"window.__wvEmit = function (event, payload) {"
+    @"  var cbs = window.__wvListeners[event] || [];"
+    @"  for (var i = 0; i < cbs.length; i++) cbs[i](payload);"
+    @"};";
+
+@interface JanelaViewController : UIViewController
+@end
+
+@implementation JanelaViewController {
+  JanelaBridge *_bridge;
+}
+
+- (void)viewDidLoad {
+  [super viewDidLoad];
+
+  WKWebViewConfiguration *config = [[WKWebViewConfiguration alloc] init];
+  WKUserContentController *manager = config.userContentController;
+
+  _bridge = [[JanelaBridge alloc] init];
+  [manager addScriptMessageHandler:_bridge name:@"janela"];
+
+  // Injected before the document loads, exactly as the desktop shim does with
+  // webview_init — so the page can call janela.invoke from its first line.
+  WKUserScript *boot = [[WKUserScript alloc] initWithSource:kBootstrap
+                                              injectionTime:WKUserScriptInjectionTimeAtDocumentStart
+                                           forMainFrameOnly:YES];
+  [manager addUserScript:boot];
+
+  WKWebView *webview = [[WKWebView alloc] initWithFrame:self.view.bounds
+                                          configuration:config];
+  webview.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+  [self.view addSubview:webview];
+  gWebView = webview;
+
+  char *out = NULL;
+  size_t out_len = 0;
+  jl_index_html(&out, &out_len);
+  NSString *html = takeResult(out, out_len);
+  [webview loadHTMLString:html baseURL:nil];
+}
+
+@end
+
+@interface JanelaAppDelegate : UIResponder <UIApplicationDelegate>
+@property(nonatomic, strong) UIWindow *window;
+@end
+
+@implementation JanelaAppDelegate
+
+- (BOOL)application:(UIApplication *)application
+    didFinishLaunchingWithOptions:(NSDictionary *)options {
+  // Registration is a pure store and is legal before init; the panic sink and
+  // the event channel must both be in place before any TypeScript runs, since
+  // setup() executes during jl_init().
+  jl_set_panic_sink(panicSink, NULL);
+  gHeld = [NSMutableDictionary dictionary];
+  gEarly = [NSMutableDictionary dictionary];
+  // Registration is a pure store and is legal before init; it also survives
+  // jl_reset(), so it is done once here.
+  if (jl_set_callback("hostSchedule", (void (*)(void))hostSchedule, NULL) != 0 ||
+      jl_set_callback("hostSettle", (void (*)(void))hostSettle, NULL) != 0 ||
+      jl_set_callback("hostReadFile", (void (*)(void))hostReadFile, NULL) != 0 ||
+      jl_set_callback("hostWriteFile", (void (*)(void))hostWriteFile, NULL) != 0) {
+    NSLog(@"[janela] could not register a host channel");
+  }
+  if (jl_set_callback("janelaEmit", (void (*)(void))emitEvent, NULL) != 0) {
+    NSLog(@"[janela] could not register the event channel — app.emit will trap");
+  }
+  jl_init();
+
+  self.window = [[UIWindow alloc] initWithFrame:UIScreen.mainScreen.bounds];
+  self.window.rootViewController = [[JanelaViewController alloc] init];
+  [self.window makeKeyAndVisible];
+  return YES;
+}
+
+@end
+
+int main(int argc, char *argv[]) {
+  @autoreleasepool {
+    return UIApplicationMain(argc, argv, nil, NSStringFromClass([JanelaAppDelegate class]));
+  }
+}