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\""
@@ -154,6 +172,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

@@ -241,12 +241,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,77 @@ public static void bindCrashProtection(final boolean consumeError) {
         Display.getInstance().addEdtErrorHandler(new ActionListener() {
             @Override
             public void actionPerformed(ActionEvent evt) {
+                // 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);
+                }
                 if (consumeError) {
-                    evt.consume();
+                    try {
+                        evt.consume();
+                    } catch (Throwable t) {
+                        p("[edtErr] consume threw: " + t, 1);
+                    }
                 }
-                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!");
+                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);
                 }
-                e((Throwable) evt.getSource());
-                if (getUniqueDeviceKey() != null) {
-                    sendLog();
+                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/html5/js/canvas/ImageData.java

@@ -15,4 +15,19 @@ public interface ImageData extends JSObject {
     int getWidth();
     int getHeight();
     Uint8ClampedArray getData();
+    /// Writes ARGB pixel data into ``imageData.data`` host-side, in one round
+    /// trip. The host bridge clones ``imageData.data`` when the worker reads
+    /// it (a perf optimization for ``get(index)`` loops, see ``hostResult``
+    /// in browser_bridge.js), so the natural-looking
+    /// ``((Uint8ClampedArraySetter)d.getData()).set(arr)`` writes from the
+    /// worker land in the *clone* — the live ``imageData.data`` stays
+    /// zero-initialised, ``putImageData`` then renders transparent black,
+    /// and any code that relies on the data round-trip
+    /// (``CommonTransitions``' rgbBuffer fade path, anything else that goes
+    /// through ``HTML5Implementation.createImage(int[], int, int)``) paints
+    /// nothing. ``writeArgbBuffer`` skips the round-trip: the int[] is
+    /// structured-cloned to host (one ``postMessage``), and a host-side
+    /// prototype extension in browser_bridge.js unpacks ARGB → RGBA into
+    /// the live ``this.data`` buffer there.
+    void writeArgbBuffer(int[] argb, int offset, int width, int height);
 }