Switch initializr JavaScript build to local ParparVM target

.github/workflows/website-docs.yml

@@ -144,6 +144,11 @@ jobs:
           WEBSITE_INCLUDE_DEVGUIDE: "true"
           WEBSITE_INCLUDE_INITIALIZR: "auto"
           WEBSITE_INCLUDE_PLAYGROUND: "auto"
+          # The Initializr's JavaScript app is built with the local ParparVM
+          # target, whose builder lives in the repo (8.0-SNAPSHOT) plugin rather
+          # than the pinned release. Bootstrap the local snapshot artifacts so
+          # the initializr (and the other site apps) build against repo HEAD.
+          WEBSITE_BOOTSTRAP_CN1_SNAPSHOTS: "true"
           # PR previews build with future-dated posts visible so reviewers
           # can read posts staged for later in the week. Production deploys
           # (push to master) keep the default so future posts only appear

Ports/JavaScriptPort/src/main/java/com/codename1/impl/html5/HTML5Implementation.java

@@ -1233,7 +1233,16 @@ private void __init() {
         document = window.getDocument();
         canvas = (HTMLCanvasElement)document.createElement("canvas");
         outputCanvas = (HTMLCanvasElement)document.getElementById("codenameone-canvas");
-        outputCanvas.getStyle().setProperty("pointer-events", "none");
+        // The canvas must be hit-testable from the start: it boots with no
+        // active peers, and the per-event listeners installed later only
+        // flip pointer-events to "none" when the point is over a native
+        // peer. Booting with "none" relied on the window-level restore
+        // listener flipping it back on the first event -- but that restore
+        // round-trips through the worker bridge, so the initial pointer
+        // DOWN is always lost and the first gesture after load is silently
+        // swallowed (observed on the Initializr as scroll/drag doing
+        // nothing).
+        outputCanvas.getStyle().setProperty("pointer-events", "auto");
         peersContainer = (HTMLElement)document.createElement("div");
         peersContainer.setAttribute("id", "cn1-peers-container");
         outputCanvas.getParentNode().insertBefore(peersContainer, outputCanvas);

Ports/JavaScriptPort/src/main/java/com/codename1/impl/platform/js/NativeInterfaceBridge.java

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026 Codename One and contributors.
+ * Licensed under the PolyForm Noncommercial License 1.0.0.
+ * You may use this file only in compliance with that license.
+ * The license notice for this subtree is available in Ports/JavaScriptPort/LICENSE.md.
+ */
+package com.codename1.impl.platform.js;
+
+/**
+ * Host bridge that dispatches Codename One {@code NativeInterface} method calls
+ * to their JavaScript implementation registered in {@code cn1_native_interfaces}.
+ *
+ * <p>The generated {@code <Interface>Impl} classes (emitted by the JavaScript
+ * builder) delegate every interface method to one of the {@code call*} natives
+ * below, picked by the method's return type. These natives are runtime-
+ * implemented in {@code parparvm_runtime.js}: the worker suspends, the call is
+ * replayed on the <em>main thread</em> (via {@code browser_bridge.js}) where the
+ * developer-authored JS stub runs with full DOM access and completes the call
+ * through its callback, and the worker resumes with the result coerced to the
+ * declared Java type.</p>
+ *
+ * <p>Supported types mirror {@code NativeInterface}: all primitives, {@code String},
+ * primitive arrays plus {@code String[]} (via {@link #callArray}), and
+ * {@code com.codename1.ui.PeerComponent} (routed through {@link #callObject}).</p>
+ *
+ * <p>{@code iface} is the interface class name with dots replaced by underscores
+ * (the {@code cn1_native_interfaces} registry key), {@code method} is the
+ * trailing-underscore method key (e.g. {@code "isDarkMode_"}), and {@code args}
+ * holds the (boxed) Java arguments, or an empty array for a no-arg method.</p>
+ */
+public final class NativeInterfaceBridge {
+    private NativeInterfaceBridge() {
+    }
+
+    public static native boolean callBoolean(String iface, String method, Object[] args);
+
+    public static native byte callByte(String iface, String method, Object[] args);
+
+    public static native short callShort(String iface, String method, Object[] args);
+
+    public static native int callInt(String iface, String method, Object[] args);
+
+    public static native char callChar(String iface, String method, Object[] args);
+
+    public static native long callLong(String iface, String method, Object[] args);
+
+    public static native float callFloat(String iface, String method, Object[] args);
+
+    public static native double callDouble(String iface, String method, Object[] args);
+
+    public static native String callString(String iface, String method, Object[] args);
+
+    public static native Object callObject(String iface, String method, Object[] args);
+
+    public static native void callVoid(String iface, String method, Object[] args);
+
+    /**
+     * Array-returning call. {@code componentToken} identifies the element type so
+     * the runtime can build the correctly-typed Java array: {@code "JAVA_INT"},
+     * {@code "JAVA_BYTE"}, {@code "JAVA_LONG"}, {@code "JAVA_DOUBLE"},
+     * {@code "JAVA_FLOAT"}, {@code "JAVA_BOOLEAN"}, {@code "JAVA_CHAR"},
+     * {@code "JAVA_SHORT"} or {@code "java_lang_String"}. The caller casts the
+     * result to the concrete array type.
+     */
+    public static native Object callArray(String iface, String method, Object[] args, String componentToken);
+}

Ports/JavaScriptPort/src/main/java/com/codename1/teavm/io/ArrayBufferInputStream.java

@@ -24,18 +24,36 @@ public class ArrayBufferInputStream extends InputStream {
     int pos = 0;
     int len;
     String src;
+    // Worker-local copy of the backing buffer, materialised lazily on the
+    // FIRST single-byte read. ``buf.get(pos++)`` is a JSO-bridge virtual
+    // dispatch (string-parsed method id + wrapper unwrap per call);
+    // ``Resources.load(theme.res)`` issues hundreds of thousands of
+    // single-byte reads through DataInputStream, which made the
+    // Initializr's boot crawl for minutes. One bulk copy turns every
+    // subsequent read into a plain Java array access. Callers that only
+    // bulk-read (media) or grab the blob/buffer never pay the copy.
+    private byte[] local;
+
     public ArrayBufferInputStream(Uint8Array buf, String type) {
         this.buf = buf;
         this.type=type;
         this.len = buf.getByteLength();
     }
 
+    private void ensureLocal() {
+        if (local == null) {
+            local = new byte[len];
+            readBulkImpl(buf, 0, local, 0, len);
+        }
+    }
+
     @Override
     public int read() throws IOException {
         if ( pos >= len ){
             return -1;
         }
-        return buf.get(pos++);
+        ensureLocal();
+        return local[pos++] & 0xFF;
     }
 
     @Override
@@ -51,6 +69,11 @@ public int read(byte[] b, int off, int length) throws IOException {
         if (n > avail) {
             n = avail;
         }
+        if (local != null) {
+            System.arraycopy(local, pos, b, off, n);
+            pos += n;
+            return n;
+        }
         // Native intrinsic: one JS-side loop copies n bytes from the
         // backing Uint8Array into the Java byte[] without per-byte
         // virtual dispatch through the cooperative scheduler. This
@@ -99,6 +122,7 @@ public int available() throws IOException {
     @Override
     public void close() throws IOException {
         buf = null;
+        local = null;
         len = 0;
     }
 

Ports/JavaScriptPort/src/main/webapp/port.js

@@ -3413,6 +3413,7 @@ bindCiFallbackWithMethodId("Form.addComponentNullContentPaneGuard", formAddCompo
 
 const cn1ssCompleteMethodId = "cn1_com_codenameone_examples_hellocodenameone_tests_Cn1ssDeviceRunnerHelper_complete_java_lang_Runnable";
 const cn1ssEmitChannelMethodId = "cn1_com_codenameone_examples_hellocodenameone_tests_Cn1ssDeviceRunnerHelper_emitChannel_byte_1ARRAY_java_lang_String_java_lang_String";
+const cn1ssBridgeCountsMethodId = "cn1_com_codenameone_examples_hellocodenameone_tests_Cn1ssDeviceRunnerHelper_jsBridgeCallCounts_R_java_lang_String";
 const baseTestCreateFormMethodId = "cn1_com_codenameone_examples_hellocodenameone_tests_BaseTest_createForm_java_lang_String_com_codename1_ui_layouts_Layout_java_lang_String_R_com_codename1_ui_Form";
 const baseTestRegisterReadyCallbackMethodId = "cn1_com_codenameone_examples_hellocodenameone_tests_BaseTest_registerReadyCallback_com_codename1_ui_Form_java_lang_Runnable";
 const baseTestFormSubclassClassId = "com_codenameone_examples_hellocodenameone_tests_BaseTest_1";
@@ -5128,6 +5129,19 @@ bindCiFallback("Cn1ssDeviceRunnerHelper.emitCurrentFormScreenshotDom", [
   return null;
 });
 
+// Bridge-call counters for BridgeBulkTransferGuardTest: large-volume
+// transfers must cost bridge calls proportional to operations, not bytes.
+bindCiFallback("Cn1ssDeviceRunnerHelper.jsBridgeCallCounts", [
+  cn1ssBridgeCountsMethodId,
+  cn1ssBridgeCountsMethodId + "__impl"
+], function*() {
+  // _L is the runtime's exported string-literal constructor (the same one
+  // every translated call site uses), so the return value is a real
+  // java.lang.String object.
+  return _L("jso=" + (jvm.__cn1JsoDispatchCount | 0)
+    + ":host=" + (jvm.__cn1HostCallCount | 0));
+});
+
 bindCiFallback("Cn1ssDeviceRunnerHelper.emitChannelFastJs", [
   cn1ssEmitChannelMethodId,
   cn1ssEmitChannelMethodId + "__impl"