js-port: protect runtime-constructed bridge names from ident minification

The screenshot runner (port.js) dispatches the suite's test lambdas by
building their identifier at runtime via string concatenation, e.g.

  "cn1_..._Cn1ssDeviceRunner_lambda_" + methodName + "_" + i + "_" + sig

so the FULL generated identifier (".._lambda_runNextTest_2_<sig>") never
appears as a string literal -- only the 77-char stem does. The exact-match
string-literal exclusion therefore missed these, the minifier renamed the
lambda run methods to $M*, and the bridge's name lookup failed:
`lambda2RunBridge:missingDispatch=1`. With no runnable dispatch the
cooperative scheduler parked every thread (runnable=0) and the suite wedged
~28 tests in -> the javascript-screenshots hang/broken-pipe at 85a8e01.

Fix: treat every scanned cn1_ string token as a PREFIX and protect any
generated def that extends it at an identifier-segment boundary, so the
constructed name keeps its canonical identifier. A length floor (16) keeps
the generic construction roots "cn1_" (-> ___INIT__/___CLINIT__, already
skipped) and "cn1_s_" (dispatch-ids in the _qX table, never a def) out of
the prefix set -- "cn1_" as a prefix would match every def and disable all
minification. Over-protecting only forgoes a little size; under-protecting
breaks a name-resolved bridge.

Validated: HelloCodenameOne JS bundle keeps all 30 Cn1ssDeviceRunner lambda
identifiers verbatim while still minifying 12,836 generated functions
(translated_app.js 11.93MB -> 7.69MB, -36%); the local Playwright screenshot
run progresses past the prior wedge with sinceStepMs resetting (no parked
scheduler) instead of hanging.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: shai-almog

vm/ByteCodeTranslator/src/com/codename1/tools/translator/JavascriptBundleWriter.java

@@ -265,6 +265,45 @@ private static void minifyGeneratedIdentifiers(java.util.List<String> chunkStrin
         // override targets, by name) -- more reliable than scanning runtime JS text.
         excluded.addAll(JavascriptMethodGenerator.NATIVE_METHOD_IDENTIFIERS);
         defs.removeAll(excluded);
+        // Prefix protection: some bridge names are CONSTRUCTED at runtime by string
+        // concatenation, so the full identifier never appears as a literal -- only
+        // its stem does. The screenshot runner (port.js) builds
+        //   "cn1_..._Cn1ssDeviceRunner_lambda_" + methodName + "_" + i + "_" + sig
+        // so the scanned literal is the stem ".._lambda_" while the generated def is
+        // ".._lambda_runNextTest_2_<sig>". Treat every scanned cn1_ string token as a
+        // prefix and protect any def that extends it at an identifier-segment boundary
+        // (the next char is '_', or the stem already ends in '_'), so the constructed
+        // name still resolves after minification. Over-protecting only forgoes size;
+        // under-protecting breaks a name-resolved bridge -> wedge.
+        // Only class-qualified stems are eligible as prefixes. The generic
+        // construction roots "cn1_" (4, completes to ___INIT__/___CLINIT__, already
+        // skipped above) and "cn1_s_" (6, dispatch-ids resolved via the _qX table,
+        // never a function def) are short and would over-match -- "cn1_" as a prefix
+        // matches EVERY def and would disable all minification. A length floor keeps
+        // those out while admitting genuine fully-qualified stems (the only real one,
+        // the screenshot runner's lambda stem, is 77 chars).
+        final int MIN_PREFIX_PROTECT_LEN = 16;
+        if (!defs.isEmpty()) {
+            java.util.List<String> prefixTokens = new java.util.ArrayList<String>();
+            for (String t : stringTokens) {
+                if (t.length() >= MIN_PREFIX_PROTECT_LEN) {
+                    prefixTokens.add(t);
+                }
+            }
+            if (!prefixTokens.isEmpty()) {
+                java.util.Iterator<String> it = defs.iterator();
+                while (it.hasNext()) {
+                    String d = it.next();
+                    for (String t : prefixTokens) {
+                        if (d.length() > t.length() && d.startsWith(t)
+                                && (t.endsWith("_") || d.charAt(t.length()) == '_')) {
+                            it.remove();
+                            break;
+                        }
+                    }
+                }
+            }
+        }
         if (defs.isEmpty()) {
             return;
         }