janela 0.13.1 → 0.14.1

package/README.md

@@ -5,8 +5,11 @@
 Desktop and mobile apps in pure TypeScript, compiled to native. No Rust, no
 Node, no Electron. The backend is TypeScript compiled to a native binary by
 [scriptc](https://scriptc.dev); the window is the OS webview via
-[webview/webview](https://github.com/webview/webview). Binaries come out
-around 400–500 KB, with no bundled browser and no bundled runtime.
+[webview/webview](https://github.com/webview/webview). A desktop binary comes
+out around 200–400 KB — 191 KB for the smallest template — with no bundled
+browser and no bundled runtime; iOS and Android bundles land around
+211–415 KB. Per-template figures are in
+[docs/frontend.md](../../docs/frontend.md).
 
 Five targets, one runtime — the same `main.ts`, the same typed contract and the
 same frontend build for each:
@@ -542,7 +545,7 @@ app.command("add", (args) => {
 Mechanically: drop the `JSON.parse(argsJson)` (cast `args` instead), drop
 every `JSON.stringify` around a result, `resolve`/`reject`/`emit` payload, and
 return nothing at all where you used to return `"null"`. Requires Node 24 to
-build (scriptc 0.0.35's floor).
+build (scriptc 0.0.36's floor).
 
 ## What the CLI hides
 
@@ -559,10 +562,6 @@ no `-framework` support) and the binary is wrapped into an ad-hoc-signed
   the boundary, so anything that survives `JSON.stringify`/`JSON.parse` round
   trips (including full Unicode). `args` is typed `unknown` — cast it to the
   shape you expect.
-- Never use a bare FFI call as a complete variable initializer or assignment
-  RHS — it is silently miscompiled. Wrap it in any expression (`+ 0`). Plain
-  TypeScript is unaffected; only the runtime does FFI, so app code rarely
-  meets this.
 - One window per app for now. Host code is single-threaded: a synchronous
   command blocks the UI while it runs — use `commandAsync` + `defer`/`sleep`
   (see "Async commands") for anything slow.
@@ -583,8 +582,10 @@ It is **simulator-only** so far — device builds and code signing are not
 wired up yet. Commands, the typed
 contract, events, Vite frontends, async commands (`commandAsync`, `defer`,
 `sleep`) and file I/O all work the same as on desktop — the shell owns the
-clock and the file queue on both. File dialogs are not on iOS yet and report
-clearly when called; window control is a no-op there by nature. See
+clock and the file queue on both. `openFileDialog` works as of 0.13.0 — the
+picked file is copied into the app container and that path returned, so
+`readFileAsync` opens it exactly as on desktop. `saveFileDialog` reports
+clearly when called, and window control is a no-op there by nature. See
 [docs/ios.md](../../docs/ios.md).
 
 ## Android
@@ -615,11 +616,18 @@ The design notes and scriptc findings behind it are in
 [docs/findings.md](../../docs/findings.md), with per-platform notes in
 [docs/ios.md](../../docs/ios.md) and [docs/android.md](../../docs/android.md).
 
-Not yet: native dialogs and window control on mobile; device builds and code
-signing; icons, installers and notarization; async commands that run in
-parallel (host code is single-threaded, so `commandAsync` interleaves and a
-CPU-bound handler still needs slicing); an async HTTP client; tray icons and
-menus; multi-window; directory picking on Windows; and `app.center()`.
+Not yet: `saveFileDialog` and window control on mobile (both deliberate —
+mobile "save" means exporting a file that already exists, which the desktop
+signature cannot express, and window geometry is meaningless on a phone);
+iOS device builds and code signing; installers and notarization; async
+commands that run in parallel (host code is single-threaded, so
+`commandAsync` interleaves and a CPU-bound handler still needs slicing); an
+async HTTP client; tray icons and menus; multi-window; directory picking on
+Windows and iOS; and `app.center()`.
+
+`openFileDialog` **does** work on iOS and Android as of 0.13.0 — a picked
+file is copied into the app container and that path returned, so
+`readFileAsync` opens it exactly as on desktop.
 
 ## Releasing
 

package/bin/janela.mjs

@@ -372,6 +372,13 @@ function buildIos(root, conf, buildDir, outDir) {
     `-I${join(KIT, "vendor-webview", "core", "include")}`,
     "-framework", "UIKit", "-framework", "WebKit", "-framework", "Foundation",
     lib,
+    // scriptc runs its section elimination only when it performs the final
+    // executable link itself; `--lib` deliberately keeps the archive intact
+    // (see executableSectionEliminationFlags in its native-toolchain.js), so
+    // on the mobile lanes the last link is ours and so is the stripping.
+    // ld64 dead-strips per symbol subsection, so the archive needs no
+    // -ffunction-sections to benefit: 409 KB -> 232 KB stripped.
+    "-Wl,-dead_strip",
     "-o", join(bundle, conf.name),
   ]);
   run(["strip", join(bundle, conf.name)]);
@@ -551,6 +558,14 @@ function buildAndroid(root, conf, buildDir, outDir) {
     // libc++_shared.so beside ours; static keeps the APK to one library.
     "-static-libstdc++",
     `-I${join(KIT, "vendor-webview", "core", "include")}`,
+    // As on iOS, the final link is ours, so the section GC is too. A shared
+    // library exports every default-visibility symbol, which roots the whole
+    // scriptc archive and leaves --gc-sections nearly nothing to collect
+    // (1.41 MB -> 1.35 MB on its own). --exclude-libs drops the archive out
+    // of the dynamic symbol table first, so GC can then discard what the
+    // shell never reaches: 1.41 MB -> 853 KB stripped. The JNI entry points
+    // come from app.cc rather than the archive, so they stay exported.
+    "-Wl,--gc-sections", "-Wl,--exclude-libs,ALL",
     lib, "-llog", "-o", so,
   ]);
   run([join(sdk.toolchain, "llvm-strip"), so]);
@@ -994,7 +1009,7 @@ function build(root, { devUrl = null, gui = true, target = "desktop" } = {}) {
       `}\n`
     : `const app = createApp<CmdsOf<typeof setup>, EvtsOf<typeof setup>>(WINDOW);\n` +
       `setup(app);\n` +
-      `const rc = app.run(INDEX_HTML) + 0;\n` +
+      `const rc = app.run(INDEX_HTML);\n` +
       `console.log("[janela] run returned", rc);\n`;
 
   writeFileSync(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "janela",
-  "version": "0.13.1",
+  "version": "0.14.1",
   "description": "Desktop, iOS and Android apps in pure TypeScript, compiled to native. No Rust, no Node, no Electron.",
   "type": "module",
   "bin": {
@@ -21,7 +21,7 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "scriptc": "0.0.35"
+    "scriptc": "0.0.36"
   },
   "license": "MIT",
   "author": "Mateus Lage",

package/runtime/janela.ts

@@ -4,11 +4,6 @@
 // (name, argsJson) envelope, dispatched to handlers registered on the app
 // object. Handlers see decoded values — the runtime owns JSON at the boundary.
 // Backend→frontend events ride wv_eval into the injected bootstrap.
-//
-// NOTE ON STYLE: every FFI call whose result initializes a variable is written
-// `f(...) + 0`. scriptc miscompiles a bare FFI call used as a complete
-// initializer/assignment RHS — still true in 0.0.35, and reported upstream as
-// vercel-labs/scriptc#21. Any enclosing expression is the workaround.
 
 declare function wvCreate(debug: number): number;
 declare function wvSetTitle(h: number, title: string): number;
@@ -202,7 +197,7 @@ export class JanelaAppImpl<
   drainSize: number[] = [];
 
   constructor(cfg: WindowConfig) {
-    const h = wvCreate(0) + 0;
+    const h = wvCreate(0);
     this.handle = h;
     wvSetTitle(h, cfg.title);
     wvSetSize(h, cfg.width, cfg.height, 0);
@@ -221,9 +216,7 @@ export class JanelaAppImpl<
     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;
+    const rc = wvSchedule(this.handle, id, delay);
     if (rc < 0) console.log("[janela] could not schedule continuation", id);
   }
 
@@ -254,14 +247,14 @@ export class JanelaAppImpl<
    */
   drainSome(): void {
     if (this.drainIds.length === 0) return;
-    const started = Date.now() + 0;
+    const started = Date.now();
 
     while (this.drainIds.length > 0) {
       let chunk = "";
       const taken =
         wvJobTakeAt(this.handle, this.drainIds[0], this.drainOff[0], DRAIN_SLICE, (text) => {
           chunk = text;
-        }) + 0;
+        });
 
       // A negative count means the job vanished; treat the payload as final
       // rather than spinning on it forever.
@@ -334,7 +327,7 @@ export class JanelaAppImpl<
       const doneCbs: FsCallback[] = [];
       const doneOk: boolean[] = [];
       for (let i = 0; i < this.jobIds.length; i++) {
-        const st = wvJobStatus(this.handle, this.jobIds[i]) + 0;
+        const st = wvJobStatus(this.handle, this.jobIds[i]);
         if (st === JOB_PENDING) {
           keptIds.push(this.jobIds[i]);
           keptCbs.push(this.jobCbs[i]);
@@ -355,7 +348,7 @@ export class JanelaAppImpl<
         this.drainOk.push(doneOk[i]);
         this.drainParts.push([]);
         this.drainOff.push(0);
-        this.drainSize.push(wvJobSize(this.handle, doneIds[i]) + 0);
+        this.drainSize.push(wvJobSize(this.handle, doneIds[i]));
       }
     }
 
@@ -381,7 +374,7 @@ export class JanelaAppImpl<
       defaultPath === undefined ? "" : defaultPath,
       defaultName === undefined ? "" : defaultName,
       encodeFilters(filters),
-    ) + 0;
+    );
     if (id < 0) {
       this.defer(() => cb(null, "EAGAIN: could not open a dialog"));
       return;
@@ -452,7 +445,7 @@ export class JanelaAppImpl<
    * worker thread; the callback lands on the UI thread on a later turn.
    */
   readFileAsync(path: string, cb: FsCallback): void {
-    const id = wvFsRead(this.handle, path) + 0;
+    const id = wvFsRead(this.handle, path);
     if (id < 0) {
       this.defer(() => cb("EAGAIN: could not start a read of '" + path + "'", ""));
       return;
@@ -463,7 +456,7 @@ export class JanelaAppImpl<
 
   /** Write a file without blocking the window; cb(null) on success. */
   writeFileAsync(path: string, data: string, cb: (err: string | null) => void): void {
-    const id = wvFsWrite(this.handle, path, data) + 0;
+    const id = wvFsWrite(this.handle, path, data);
     if (id < 0) {
       this.defer(() => cb("EAGAIN: could not start a write of '" + path + "'"));
       return;
@@ -555,7 +548,7 @@ export class JanelaAppImpl<
           // Park the page's promise: the shim holds this call's id and
           // answers it when resolve/reject reaches wvResolve, whenever
           // that is. Meanwhile the loop is free to serve other calls.
-          const id = wvDefer(h) + 0;
+          const id = wvDefer(h);
           if (id < 0) {
             wvReply(h, encode("cannot defer command: " + cmd));
             return 1;
@@ -579,7 +572,7 @@ export class JanelaAppImpl<
 
     wvBind(h, "__invoke");
     wvSetHtml(h, html);
-    const rc = wvRun(h) + 0;
+    const rc = wvRun(h);
     return rc;
   }
 }

package/templates/main.ts

@@ -3,10 +3,6 @@
 // Register commands here; the page calls them with `await janela.invoke(name, args)`.
 // Handlers take the arguments as a value and return a value — the runtime owns
 // JSON at the boundary, so there is no parsing or stringifying to do here.
-//
-// Gotcha inherited from scriptc: never use a bare FFI-backed call as a
-// complete variable initializer — wrap it in any expression (`+ 0`). Plain
-// TypeScript like everything in this file is unaffected.
 
 import type { JanelaApp } from "janela/host";
 

package/templates/react/files/src-host/main.ts

@@ -6,11 +6,8 @@
 // names, argument shapes, results and event payloads — with no code
 // generation and nothing to keep in sync.
 //
-// Two gotchas inherited from scriptc:
-//   - never use a bare FFI-backed call as a complete variable initializer;
-//     wrap it in any expression (`+ 0`);
-//   - a command that returns nothing is declared `() => void` and its handler
-//     returns `null`; every command answers the page's promise with a value.
+// A command that returns nothing is declared `() => void` and its handler
+// returns `null`; every command answers the page's promise with a value.
 
 import type { JanelaApp } from "janela/host";
 

package/templates/solid/files/src-host/main.ts

@@ -6,11 +6,8 @@
 // names, argument shapes, results and event payloads — with no code
 // generation and nothing to keep in sync.
 //
-// Two gotchas inherited from scriptc:
-//   - never use a bare FFI-backed call as a complete variable initializer;
-//     wrap it in any expression (`+ 0`);
-//   - a command that returns nothing is declared `() => void` and its handler
-//     returns `null`; every command answers the page's promise with a value.
+// A command that returns nothing is declared `() => void` and its handler
+// returns `null`; every command answers the page's promise with a value.
 
 import type { JanelaApp } from "janela/host";
 

package/templates/svelte/files/src-host/main.ts

@@ -6,11 +6,8 @@
 // names, argument shapes, results and event payloads — with no code
 // generation and nothing to keep in sync.
 //
-// Two gotchas inherited from scriptc:
-//   - never use a bare FFI-backed call as a complete variable initializer;
-//     wrap it in any expression (`+ 0`);
-//   - a command that returns nothing is declared `() => void` and its handler
-//     returns `null`; every command answers the page's promise with a value.
+// A command that returns nothing is declared `() => void` and its handler
+// returns `null`; every command answers the page's promise with a value.
 
 import type { JanelaApp } from "janela/host";
 

package/templates/vue/files/src-host/main.ts

@@ -6,11 +6,8 @@
 // names, argument shapes, results and event payloads — with no code
 // generation and nothing to keep in sync.
 //
-// Two gotchas inherited from scriptc:
-//   - never use a bare FFI-backed call as a complete variable initializer;
-//     wrap it in any expression (`+ 0`);
-//   - a command that returns nothing is declared `() => void` and its handler
-//     returns `null`; every command answers the page's promise with a value.
+// A command that returns nothing is declared `() => void` and its handler
+// returns `null`; every command answers the page's promise with a value.
 
 import type { JanelaApp } from "janela/host";