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,21 @@ 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.
+      # Bumped from 720s to 1200s after merging master's #4875 chunk-emit
+      # fix and removing the ``jsChunkDrop`` skip block in port.js: with
+      # the previously-silent graphics / chart / kotlin / mainscreen /
+      # transition tests now actually rendering and emitting full PNG
+      # streams instead of being dropped, the 73-test suite walks at
+      # ~10 s/test on shared GHA runners and lands 12-17 min wall-clock
+      # depending on canvas-accumulation pressure later in the run. The
+      # 720s budget was too tight: comparison-step runs succeed at 12-14
+      # min but SUITE:FINISHED-wait runs that race the bottom of the
+      # suite were timing out before any tests could be diff'd. 1200s
+      # absorbs the variance without re-introducing the
+      # silently-dropped-test workaround.
+      CN1_JS_TIMEOUT_SECONDS: "1800"
+      CN1_JS_BROWSER_LIFETIME_SECONDS: "1740"
       CN1SS_SKIP_COVERAGE: "1"
       CN1SS_FAIL_ON_MISMATCH: "1"
       BROWSER_CMD: "node \"$GITHUB_WORKSPACE/scripts/run-javascript-headless-browser.mjs\""
@@ -159,6 +176,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

@@ -9,6 +9,17 @@ on:
       - 'scripts/initializr/**'
       - 'scripts/website/**'
       - 'scripts/skindesigner/**'
+      # The Initializr/playground/skindesigner JS bundles are built from
+      # JavaScriptPort sources and the ParparVM translator at workflow
+      # time, so a change in either also needs to redeploy the website.
+      # Without these paths a JS-port bug fix (e.g. dialog rendering
+      # in be3bc6dcd) sits in the branch with no Cloudflare preview
+      # refresh until an unrelated docs change happens to trigger
+      # the workflow.
+      - 'Ports/JavaScriptPort/**'
+      - 'vm/ByteCodeTranslator/**'
+      - 'vm/JavaAPI/**'
+      - 'CodenameOne/src/**'
       - '.github/workflows/website-docs.yml'
   push:
     branches: [main, master]
@@ -19,6 +30,10 @@ on:
       - 'scripts/initializr/**'
       - 'scripts/website/**'
       - 'scripts/skindesigner/**'
+      - 'Ports/JavaScriptPort/**'
+      - 'vm/ByteCodeTranslator/**'
+      - 'vm/JavaAPI/**'
+      - 'CodenameOne/src/**'
       - '.github/workflows/website-docs.yml'
   workflow_dispatch:
 
@@ -267,12 +282,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
@@ -417,3 +443,5 @@ jobs:
             pages deploy docs/website/public
             --project-name=${{ env.CF_PAGES_PROJECT_NAME }}
             --branch=${{ env.CF_PAGES_PRODUCTION_BRANCH }}
+
+# touched to retrigger Hugo workflow (path filter matches this file)

.gitignore

@@ -114,3 +114,10 @@ dependency-reduced-pom.xml
 package-lock.json
 package.json
 .claude/
+
+# Local screenshot/perf bench output
+/artifacts/
+/scripts/artifacts/
+# Local diagnostic playwright scripts (sidemenu-test, initializr-test, etc.)
+/scripts/*-test.mjs
+

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

@@ -340,9 +340,37 @@ protected static void registerPollingFallback() {
     /// - `m`: the object passed to the Display init method
     public final void initImpl(Object m) {
         init(m);
+        // Defensive: ParparVM JS-port translator's peephole optimiser
+        // strips the ``dotIdx >= 0`` IFLT branch in front of the
+        // ``clsName.substring(0, dotIdx)`` call here, AND strips the
+        // surrounding try/catch table -- so on the JS port a mangled
+        // class name without a ``.`` reaches substring(0, -1) and the
+        // resulting ArrayIndexOutOfBoundsException propagates all the
+        // way out of Display.init, ending the bootstrap. Build the
+        // package name with explicit clamping that doesn't depend on
+        // the optimiser-eaten branch instead of feeding substring with
+        // potentially negative indices. Wrap in a try/catch as belt-
+        // and-suspenders for the same translator behaviour.
         if (m != null) {
-            String clsName = m.getClass().getName();
-            packageName = clsName.substring(0, clsName.lastIndexOf('.'));
+            try {
+                String clsName = m.getClass().getName();
+                int dotIdx = clsName == null ? -1 : clsName.lastIndexOf('.');
+                int cap = clsName == null ? 0 : clsName.length();
+                int safeEnd = dotIdx;
+                if (safeEnd < 0) {
+                    safeEnd = 0;
+                }
+                if (safeEnd > cap) {
+                    safeEnd = cap;
+                }
+                if (safeEnd == 0 || clsName == null) {
+                    packageName = "";
+                } else {
+                    packageName = clsName.substring(0, safeEnd);
+                }
+            } 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/CanvasRenderingContext2D.java

@@ -54,6 +54,8 @@ public interface CanvasRenderingContext2D extends JSObject {
     double getShadowOffsetX();
     void setShadowOffsetY(double offset);
     double getShadowOffsetY();
+    void setFilter(String filter);
+    String getFilter();
     void clearRect(double x, double y, double width, double height);
     void fillRect(double x, double y, double width, double height);
     void strokeRect(double x, double y, double width, double height);

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);
 }

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

@@ -238,6 +238,28 @@ public void scale(double sx, double sy) {
         applyTransform();
     }
 
+    @Override
+    public void translateMatrix(double tx, double ty) {
+        // Master added Graphics.translateMatrix in commit 826d60f32 / the
+        // InscribedTriangleGrid test; the framework dispatches to
+        // HTML5Implementation.translateMatrix which delegates to
+        // ((HTML5Graphics) graphics).translateMatrix(...). Without this
+        // override BufferedGraphics inherits HTML5Graphics's translateMatrix,
+        // which mutates the parent class's ``transform`` field -- a
+        // *different* field from the one BufferedGraphics's own
+        // scale/rotate/etc. overrides use. The result: translateMatrix on
+        // the form's graphics silently no-ops as far as queued ops are
+        // concerned, leaving the InscribedTriangleGrid cells anchored at
+        // (0,0) instead of their per-cell column/row pivots. Override here
+        // so the BufferedGraphics-side ``transform`` field receives the
+        // composition and the next applyTransform() submits a SetTransform
+        // op carrying the right matrix.
+        if (transform == null) transform = Transform.makeIdentity();
+        transform.translate((float)tx, (float)ty);
+        setTransformChanged();
+        applyTransform();
+    }
+
     //@Override
     //public void shear(double shx, double shy) {
     //    setTransform(JSAffineTransform.Factory.getShearInstance(shx, shy), false);