Moving initializr to new JS port

.github/workflows/scripts-javascript.yml

@@ -7,6 +7,8 @@ on:
       - 'scripts/run-javascript-browser-tests.sh'
       - 'scripts/run-javascript-screenshot-tests.sh'
       - 'scripts/run-javascript-headless-browser.mjs'
+      - 'scripts/run-javascript-lifecycle-tests.mjs'
+      - 'scripts/run-javascript-lifecycle-tests.sh'
       - 'scripts/build-javascript-port-hellocodenameone.sh'
       - 'scripts/javascript_browser_harness.py'
       - 'scripts/javascript/screenshots/**'
@@ -25,6 +27,8 @@ on:
       - 'scripts/run-javascript-browser-tests.sh'
       - 'scripts/run-javascript-screenshot-tests.sh'
       - 'scripts/run-javascript-headless-browser.mjs'
+      - 'scripts/run-javascript-lifecycle-tests.mjs'
+      - 'scripts/run-javascript-lifecycle-tests.sh'
       - 'scripts/build-javascript-port-hellocodenameone.sh'
       - 'scripts/javascript_browser_harness.py'
       - 'scripts/javascript/screenshots/**'
@@ -48,8 +52,22 @@ jobs:
       GITHUB_TOKEN: ${{ secrets.CN1SS_GH_TOKEN }}
       GH_TOKEN: ${{ secrets.CN1SS_GH_TOKEN }}
       ARTIFACTS_DIR: ${{ github.workspace }}/artifacts/javascript-ui-tests
-      CN1_JS_TIMEOUT_SECONDS: "180"
-      CN1_JS_BROWSER_LIFETIME_SECONDS: "150"
+      # CN1_JS_TIMEOUT_SECONDS guards the per-suite SUITE:FINISHED wait.
+      # The structural-optimization landing slowed cooperative-scheduler
+      # progress on bytecode-translator output; with cn1_ivAdapt wrapping
+      # at every hand-written port.js dispatch site, the screenshot suite
+      # now reaches the runTest phase. Once the RTA fix landed and
+      # Spinner3D started rendering its full date-wheel content (instead
+      # of the blank no-op the previous build emitted), the
+      # LightweightPicker / ValidatorLightweightPicker tests went from
+      # ~instant to ~30s each on shared GHA runners — the real paint
+      # path through SpinnerNode.layoutChildren / TextPainter.paint
+      # adds wall-clock work that the blank fallback skipped. 720s
+      # gives the slow-runner tail enough headroom to complete the
+      # full 35-test suite without re-introducing the blank-spinner
+      # regression as a workaround.
+      CN1_JS_TIMEOUT_SECONDS: "720"
+      CN1_JS_BROWSER_LIFETIME_SECONDS: "660"
       CN1SS_SKIP_COVERAGE: "1"
       CN1SS_FAIL_ON_MISMATCH: "1"
       BROWSER_CMD: "node \"$GITHUB_WORKSPACE/scripts/run-javascript-headless-browser.mjs\""
@@ -122,6 +140,62 @@ jobs:
           fi
           echo "bundle=$bundle" >> "$GITHUB_OUTPUT"
 
+      - name: Run JavaScript lifecycle test
+        # Validates that the bundled app reaches both ``cn1Initialized``
+        # and ``cn1Started`` lifecycle flags within a per-bundle timeout
+        # — i.e. ``Lifecycle.init`` and ``Lifecycle.start`` both
+        # complete without throwing or hanging. Captures every
+        # ``PARPAR-LIFECYCLE`` marker and the most recent
+        # ``PARPAR:DIAG:FIRST_FAILURE`` so a stuck boot is visible
+        # without having to download the full screenshot-test
+        # browser log. Runs BEFORE the screenshot suite because if
+        # the lifecycle test fails the screenshots are doomed to
+        # time out anyway, and we want fast feedback for boot
+        # regressions.
+        #
+        # ``continue-on-error: true`` because the boot path is
+        # currently flaky on shared GHA runners (same bundle, same
+        # workflow: one runner finishes ``cn1Started`` in ~4s, the
+        # next stalls at host-callback id=11 even with a 480s
+        # budget). Until that variance is understood, treat the
+        # lifecycle marker as advisory and keep going so the
+        # screenshot suite — which has its own per-suite timeout
+        # and would always fail-fast in the same circumstances —
+        # still gets a chance to run and surface its own results.
+        # The lifecycle artifact upload below preserves the
+        # ``report.json`` either way.
+        continue-on-error: true
+        env:
+          # CI runners process bytecode-translator output noticeably
+          # slower than local, and shared GitHub Actions runners can
+          # vary by 5-10× in cooperative-scheduler throughput. The
+          # passing runs converge around 90-100 host callbacks in
+          # 240s; on a slow runner the same boot stalls below 20
+          # callbacks in the same window, far short of
+          # ``main-thread-completed``. 480s eats the worst case
+          # without hiding regressions (the passing path returns
+          # within ~30s either way).
+          CN1_LIFECYCLE_TIMEOUT_SECONDS: "480"
+          CN1_LIFECYCLE_REPORT_DIR: ${{ github.workspace }}/artifacts/javascript-lifecycle-tests
+        run: |
+          mkdir -p "${CN1_LIFECYCLE_REPORT_DIR}"
+          # Only the HelloCodenameOne bundle is built locally in this
+          # workflow; the Initializr bundle goes through the cloud
+          # build and isn't available on the runner. Pass the local
+          # bundle explicitly so the test doesn't try to rebuild
+          # missing artifacts.
+          node scripts/run-javascript-lifecycle-tests.mjs \
+            "${{ steps.locate_bundle.outputs.bundle }}"
+
+      - name: Upload JavaScript lifecycle artifacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: javascript-lifecycle-tests
+          path: artifacts/javascript-lifecycle-tests
+          if-no-files-found: warn
+          retention-days: 14
+
       - name: Run JavaScript screenshot browser tests
         run: |
           mkdir -p "${ARTIFACTS_DIR}"

.github/workflows/website-docs.yml

@@ -242,12 +242,23 @@ jobs:
           CLOUDFLARE_API_TOKEN: ${{ env.CLOUDFLARE_TOKEN }}
           PREVIEW_BRANCH: pr-${{ github.event.pull_request.number }}-website-preview
         run: |
-          set -euo pipefail
-          deploy_output="$(npx --yes wrangler@4 pages deploy docs/website/public \
+          set -uo pipefail
+          # Stream wrangler output to the job log (via tee) while still
+          # capturing it so we can pull the *.pages.dev preview URL out. The
+          # previous `deploy_output=$(... 2>&1)` form hid every line — when
+          # wrangler died without any stdout we had nothing to debug with.
+          # -e is intentionally off for the wrangler invocation so we can
+          # report its exit status explicitly instead of exiting opaquely.
+          deploy_log="$(mktemp)"
+          npx --yes wrangler@4 pages deploy docs/website/public \
             --project-name "${CF_PAGES_PROJECT_NAME}" \
-            --branch "${PREVIEW_BRANCH}" 2>&1)"
-          echo "${deploy_output}"
-          preview_url="$(printf '%s\n' "${deploy_output}" | grep -Eo 'https://[A-Za-z0-9._-]+\.pages\.dev' | tail -n1 || true)"
+            --branch "${PREVIEW_BRANCH}" 2>&1 | tee "${deploy_log}"
+          wrangler_status="${PIPESTATUS[0]}"
+          if [ "${wrangler_status}" -ne 0 ]; then
+            echo "wrangler pages deploy exited with status ${wrangler_status}" >&2
+            exit "${wrangler_status}"
+          fi
+          preview_url="$(grep -Eo 'https://[A-Za-z0-9._-]+\.pages\.dev' "${deploy_log}" | tail -n1 || true)"
           if [ -z "${preview_url}" ]; then
             echo "Could not determine Cloudflare preview URL from deploy output." >&2
             exit 1

CodenameOne/src/com/codename1/impl/CodenameOneImplementation.java

@@ -338,8 +338,17 @@ protected static void registerPollingFallback() {
     public final void initImpl(Object m) {
         init(m);
         if (m != null) {
-            String clsName = m.getClass().getName();
-            packageName = clsName.substring(0, clsName.lastIndexOf('.'));
+            // Defensive: ParparVM JS port surfaces ArrayIndexOutOfBoundsException
+            // here when getName()/lastIndexOf interact with mangled class names.
+            // Failing the whole boot for a packageName lookup is wrong; fall
+            // back to "" if anything throws.
+            try {
+                String clsName = m.getClass().getName();
+                int dotIdx = clsName.lastIndexOf('.');
+                packageName = dotIdx >= 0 ? clsName.substring(0, dotIdx) : "";
+            } catch (Throwable t) {
+                packageName = "";
+            }
         }
         initiailized = true;
     }

CodenameOne/src/com/codename1/io/Log.java

@@ -388,21 +388,62 @@ public static void bindCrashProtection(final boolean consumeError) {
         Display.getInstance().addEdtErrorHandler(new ActionListener() {
             @Override
             public void actionPerformed(ActionEvent evt) {
-                if (consumeError) {
-                    evt.consume();
-                }
-                p("Exception in " + Display.getInstance().getProperty("AppName", "app") + " version " + Display.getInstance().getProperty("AppVersion", "Unknown"));
-                p("OS " + Display.getInstance().getPlatformName());
-                p("Error " + evt.getSource());
-                if (Display.getInstance().getCurrent() != null) {
-                    p("Current Form " + Display.getInstance().getCurrent().getName());
-                } else {
-                    p("Before the first form!");
+                // TEMPORARY DIAGNOSTIC INSTRUMENTATION (PR #4795): the ParparVM
+                // JS port currently surfaces every original EDT exception as a
+                // bare ``Exception: <class>`` line because *this* listener
+                // throws an NPE while trying to format the report — the
+                // formatting NPE is the one that ends up logged, the original
+                // is silently swallowed. Wrap each step so we can identify
+                // which sub-call fails AND so the caught ``evt.getSource()``
+                // throwable still reaches ``Log.e`` even when a preceding
+                // line dies. Use ``Log.p(s, 1)`` (level=INFO) for the
+                // markers so they survive the JS port's
+                // ``console.error``-only echo path — the worker-side
+                // ``System.out.println`` route is gated behind the
+                // ``?parparDiag=1`` flag and gets dropped on the live
+                // preview. Remove this granular wrapping once the JS-port
+                // root cause is fixed.
+                p("[edtErr] enter listener", 1);
+                Object source = null;
+                try {
+                    source = evt.getSource();
+                    p("[edtErr] source-class=" + (source == null ? "null" : source.getClass().getName()), 1);
+                } catch (Throwable t) {
+                    p("[edtErr] getSource threw: " + t, 1);
                 }
-                e((Throwable) evt.getSource());
-                if (getUniqueDeviceKey() != null) {
-                    sendLog();
+                if (consumeError) {
+                    try { evt.consume(); }
+                    catch (Throwable t) { p("[edtErr] consume threw: " + t, 1); }
                 }
+                try {
+                    p("Exception in " + Display.getInstance().getProperty("AppName", "app") + " version " + Display.getInstance().getProperty("AppVersion", "Unknown"));
+                } catch (Throwable t) { p("[edtErr] appName/version threw: " + t, 1); }
+                try {
+                    p("OS " + Display.getInstance().getPlatformName());
+                } catch (Throwable t) { p("[edtErr] platformName threw: " + t, 1); }
+                try {
+                    p("Error " + source);
+                } catch (Throwable t) { p("[edtErr] sourceLog threw: " + t, 1); }
+                try {
+                    if (Display.getInstance().getCurrent() != null) {
+                        p("Current Form " + Display.getInstance().getCurrent().getName());
+                    } else {
+                        p("Before the first form!");
+                    }
+                } catch (Throwable t) { p("[edtErr] currentForm threw: " + t, 1); }
+                try {
+                    if (source instanceof Throwable) {
+                        e((Throwable) source);
+                    } else {
+                        p("[edtErr] source not Throwable, skipping Log.e", 1);
+                    }
+                } catch (Throwable t) { p("[edtErr] Log.e threw: " + t, 1); }
+                try {
+                    if (getUniqueDeviceKey() != null) {
+                        sendLog();
+                    }
+                } catch (Throwable t) { p("[edtErr] sendLog threw: " + t, 1); }
+                p("[edtErr] exit listener", 1);
             }
         });
         crashBound = true;

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

@@ -7619,12 +7619,30 @@ public InputStream getResourceAsStream(Class cls, String resource)  {
                 return rootStream;
             }
         }
-        if (!"icon.png".equals(resource)) {
-            resource = "assets/"+resource;
+        String assetPath = "icon.png".equals(resource) ? resource : ("assets/" + resource);
+        InputStream out = getStream(assetPath);
+        if (out != null) {
+            notifyProgressLoaderThatResourceIsLoaded(assetPath);
+            return out;
         }
-        InputStream out = getStream(resource);
-        notifyProgressLoaderThatResourceIsLoaded(resource);
-        return out;
+        // Fall back to the bundle root for resources the translator drops
+        // there directly (most ``.properties`` resource bundles, for one —
+        // ``ParparVMBootstrap`` mirrors the jar layout and only the explicit
+        // relocations in ``build-javascript-port-initializr.sh`` /
+        // ``build-javascript-port-hellocodenameone.sh`` move things into
+        // ``assets/``). Without this fallback every
+        // ``ResourceBundle.getResourceAsStream("/messages_xx.properties")``
+        // call returns null, the ``Resources.getL10N`` lookup throws (or
+        // returns null), and any UI that catches the throw and logs via
+        // ``Log.e`` floods the console with ``Exception: null`` — see
+        // ``initializr/common/.../TemplatePreviewPanel.loadBundleProperties``.
+        InputStream rootFallback = getStream(resource);
+        if (rootFallback != null) {
+            notifyProgressLoaderThatResourceIsLoaded(resource);
+            return rootFallback;
+        }
+        notifyProgressLoaderThatResourceIsLoaded(assetPath);
+        return null;
 
     }
 

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

@@ -38,7 +38,16 @@ public static Lifecycle createLifecycle(String className) {
     @JSBody(params = {}, script = "window.cn1Started = true;")
     private static native void setStarted();
 
-    @JSBody(params = {"url"}, script = "var l = window.location; var base=l.protocol+'//'+l.hostname+(l.port?':':'')+l.port; return url.indexOf(base)===0;")
+    // The @JSBody body runs against the raw worker-side argument. In the
+    // ParparVM JS port a Java ``String`` arrives as a wrapped object
+    // ({__class:"java_lang_String", cn1_..._value: char[]}), not a native
+    // JS string — calling ``url.indexOf`` directly throws
+    // ``TypeError: url.indexOf is not a function`` and bubbles up through
+    // ``proxifyUrl`` → ``ImplementationFactory.proxifyURL`` whenever the
+    // app loads any image off the theme. Coerce to a native string up
+    // front (mirrors the pattern already in place for the
+    // ``measureAscent`` / ``measureDescent`` @JSBody helpers).
+    @JSBody(params = {"url"}, script = "var s = String(url == null ? '' : url); var l = window.location; var base=l.protocol+'//'+l.hostname+(l.port?':':'')+l.port; return s.indexOf(base)===0;")
     private static native boolean urlIsSameDomain(String url);
 
     public static String proxifyUrl(Display display, String url) {

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

@@ -31,10 +31,34 @@ public static void bootstrap(Lifecycle lifecycle) {
         bootstrap.run();
     }
 
+    // ``window.cn1Initialized = true`` lands on the worker's global
+    // (window === self inside the worker), but the headless test
+    // harness and every other main-thread consumer reads its own
+    // ``window.cn1Initialized``. The bridge (browser_bridge.js)
+    // already flips its main-thread copy when ``startParparVmApp``
+    // runs, so the worker side is best-effort — the real signal
+    // travels through the message-passing channel instead.
     @JSBody(params = {}, script = "window.cn1Initialized = true;")
     private static native void setInitialized();
 
-    @JSBody(params = {}, script = "window.cn1Started = true;")
+    // For ``cn1Started`` we need the same main-thread signal but
+    // there's no ``startParparVmApp``-style hook on this side. The
+    // worker emits a ``{type: 'lifecycle', phase: 'started'}`` VM
+    // message at the same time so ``browser_bridge.js`` can flip
+    // its own ``cn1Started``. Fall back gracefully when neither
+    // ``parentPort`` (Node worker_threads) nor ``self.postMessage``
+    // (browser Worker) is available — that path applies to direct
+    // in-page invocations from the JavaScript-port simulator.
+    @JSBody(params = {}, script = ""
+            + "window.cn1Started = true;"
+            + "var __cn1LifecycleMsg = {type: 'lifecycle', phase: 'started'};"
+            + "if (typeof parentPort !== 'undefined' && parentPort && typeof parentPort.postMessage === 'function') {"
+            + "  parentPort.postMessage(__cn1LifecycleMsg);"
+            + "} else if (typeof self !== 'undefined' && self !== this && typeof self.postMessage === 'function') {"
+            + "  self.postMessage(__cn1LifecycleMsg);"
+            + "} else if (typeof postMessage === 'function') {"
+            + "  postMessage(__cn1LifecycleMsg);"
+            + "}")
     private static native void setStarted();
 
     @Override