Migrate com.reactunity.quickjs to quickjs-ng

.github/workflows/native-quickjs.yml

@@ -0,0 +1,258 @@
+# Builds the twelve native `quickjs` artifacts com.reactunity.quickjs P/Invokes into.
+#
+# Why this exists: the binaries in unity/quickjs/Plugins/QuickJS were unity-jsb
+# prebuilts and this repo had no way to reproduce any of them. See
+# unity/quickjs/MIGRATION.md, "Gate 0".
+#
+# It deliberately does NOT commit what it builds. Every artifact is uploaded and
+# installing them is a separate, manual step -- the same shape as release-upm.yml,
+# and for the same reason: these are tracked binaries in a Unity package, and a
+# half-updated set is worse than a stale one. Nothing here needs Unity.
+#
+# One CMakeLists drives all of it (native/quickjs/CMakeLists.txt); the per-target
+# differences are the toolchain arguments below, which is why there is no build
+# script per platform. The Android and iOS invocations follow quickjs-ng's own CI.
+
+name: native-quickjs
+
+on:
+  workflow_dispatch:
+    inputs:
+      build-type:
+        description: CMake build type
+        type: choice
+        default: Release
+        options: [Release, Debug]
+  pull_request:
+    paths: ['native/quickjs/**', '.github/workflows/native-quickjs.yml']
+  push:
+    branches: [main]
+    paths: ['native/quickjs/**']
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  BUILD_TYPE: ${{ inputs.build-type || 'Release' }}
+
+jobs:
+  build:
+    name: ${{ matrix.name }}
+    runs-on: ${{ matrix.os }}
+    # Empty for every leg but linux-x64, which runs the job inside the image named there.
+    container: ${{ matrix.container || '' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # ---- desktop. `native` means the runner can execute what it built,
+          # which is what lets shim-test run rather than only link.
+          - name: windows-x64
+            os: windows-latest
+            artifact: x64/quickjs.dll
+            built: build/${{ github.event.inputs.build-type || 'Release' }}/quickjs.dll
+            configure: -A x64
+            native: true
+          - name: windows-x86
+            os: windows-latest
+            artifact: x86/quickjs.dll
+            built: build/${{ github.event.inputs.build-type || 'Release' }}/quickjs.dll
+            configure: -A Win32
+          - name: linux-x64
+            os: ubuntu-latest
+            # Built in an old container on purpose: glibc is backward compatible, never
+            # forward, so the floor a binary records is the oldest system it will load on.
+            # ubuntu-latest is 24.04 (2.39) and the Unity test container is older, so a
+            # runner-native build produced a .so Unity could not load at all --
+            # DllNotFoundException, which reads like a missing file rather than a too-new
+            # one. 22.04 gives 2.35. The binary this replaces asked for 2.17, so this is a
+            # narrower reach than users had; an older base is the fix if that matters.
+            container: ubuntu:22.04
+            artifact: x64/libquickjs.so
+            built: build/libquickjs.so
+            configure: -DCMAKE_BUILD_TYPE=${{ github.event.inputs.build-type || 'Release' }}
+            native: true
+          - name: macos-universal
+            os: macos-latest
+            artifact: quickjs.bundle/Contents/MacOS/quickjs
+            built: build/quickjs.bundle/Contents/MacOS/quickjs
+            # One bundle for both Macs; Unity ships OSXUniversal, not per-arch.
+            configure: >-
+              -DCMAKE_BUILD_TYPE=${{ github.event.inputs.build-type || 'Release' }}
+              "-DCMAKE_OSX_ARCHITECTURES=arm64;x86_64"
+            native: true
+
+          # ---- WSA. UWP compiles with /sdl, which promotes two warnings quickjs.c
+          # trips deliberately; the CMakeLists suppresses them. The static-library
+          # probe is needed because CMake's default try-compile builds and signs an
+          # appx, which fails on ARM64.
+          # WSA ARM (32-bit) is absent on purpose: the Windows SDK dropped 32-bit ARM
+          # (MSB8087 from 10.0.26100 on) and Unity no longer targets it.
+          - name: wsa-x64
+            os: windows-latest
+            artifact: WSA/x64/quickjs.dll
+            built: build/${{ github.event.inputs.build-type || 'Release' }}/quickjs.dll
+            configure: >-
+              -A x64
+              -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION=10.0
+              -DCMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY
+          - name: wsa-x86
+            os: windows-latest
+            artifact: WSA/x86/quickjs.dll
+            built: build/${{ github.event.inputs.build-type || 'Release' }}/quickjs.dll
+            configure: >-
+              -A Win32
+              -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION=10.0
+              -DCMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY
+          - name: wsa-arm64
+            os: windows-latest
+            artifact: WSA/ARM64/quickjs.dll
+            built: build/${{ github.event.inputs.build-type || 'Release' }}/quickjs.dll
+            configure: >-
+              -A ARM64
+              -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION=10.0
+              -DCMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY
+
+          # ---- Android. android-24 matches Unity 6's minimum API level.
+          # armeabi-v7a and x86_64 are Unity 6's other two ABIs; 32-bit x86 is not
+          # one of them, which is why the shipped set's `x86` is not rebuilt here.
+          - name: android-arm64-v8a
+            os: ubuntu-latest
+            artifact: Android/libs/arm64-v8a/libquickjs.so
+            built: build/libquickjs.so
+            android-abi: arm64-v8a
+          - name: android-armeabi-v7a
+            os: ubuntu-latest
+            artifact: Android/libs/armeabi-v7a/libquickjs.so
+            built: build/libquickjs.so
+            android-abi: armeabi-v7a
+          - name: android-x86_64
+            os: ubuntu-latest
+            artifact: Android/libs/x86_64/libquickjs.so
+            built: build/libquickjs.so
+            android-abi: x86_64
+
+          # ---- iOS. A static archive, per the IOS branch in the CMakeLists:
+          # Unity links it into the generated Xcode project.
+          - name: ios-arm64
+            os: macos-latest
+            artifact: iOS/libquickjs.a
+            built: build/${{ github.event.inputs.build-type || 'Release' }}-iphoneos/libquickjs.a
+            configure: >-
+              -G Xcode -DCMAKE_SYSTEM_NAME=iOS
+              -DCMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_ALLOWED=NO
+              -DCMAKE_OSX_ARCHITECTURES=arm64
+
+    steps:
+      # A bare distro image has none of this. GitHub mounts its own node in, so the
+      # actions themselves run, but git and a toolchain are ours -- and this has to
+      # precede checkout, which shells out to git.
+      - name: Container prerequisites
+        if: matrix.container
+        run: |
+          apt-get update
+          # python-is-python3 because the shared check step calls `python`, which a
+          # bare 22.04 does not provide even with python3 installed.
+          apt-get install -y --no-install-recommends git cmake build-essential ca-certificates python3 python-is-python3
+
+      - uses: actions/checkout@v7
+
+      - name: Configure
+        working-directory: native/quickjs
+        shell: bash
+        run: |
+          if [ -n "${{ matrix.android-abi }}" ]; then
+            cmake -B build \
+              -DCMAKE_TOOLCHAIN_FILE="$ANDROID_NDK_ROOT/build/cmake/android.toolchain.cmake" \
+              -DANDROID_ABI=${{ matrix.android-abi }} \
+              -DANDROID_PLATFORM=android-24 \
+              -DCMAKE_BUILD_TYPE=$BUILD_TYPE
+          else
+            cmake -B build ${{ matrix.configure }}
+          fi
+
+      # Always name the target: quickjs-ng registers run-test262, api-test and
+      # friends unconditionally, and a default build compiles all of them.
+      - name: Build
+        working-directory: native/quickjs
+        run: cmake --build build --config ${{ env.BUILD_TYPE }} --target quickjs
+
+      - name: Build and run shim-test
+        if: matrix.native
+        working-directory: native/quickjs
+        shell: bash
+        run: |
+          cmake --build build --config "$BUILD_TYPE" --target shim-test
+          # Multi-config generators put it in a per-config directory, single-config not.
+          for candidate in "build/$BUILD_TYPE/shim-test.exe" "build/$BUILD_TYPE/shim-test" "build/shim-test"; do
+            if [ -x "$candidate" ]; then "$candidate"; exit $?; fi
+          done
+          echo "shim-test binary not found" && exit 1
+
+      # Reads PE, ELF, Mach-O and archives, and takes the wanted set from the
+      # committed pinvoke-native.txt -- the .csproj it is otherwise derived from are
+      # generated by Unity and gitignored, so no job here could produce them.
+      - name: Check exports
+        working-directory: native/quickjs
+        shell: bash
+        run: |
+          # ubuntu images ship python3 without a `python` alias
+          PY=python3; command -v python3 >/dev/null || PY=python
+          "$PY" check-exports.py "${{ matrix.built }}"
+
+      - name: Stage artifact
+        working-directory: native/quickjs
+        shell: bash
+        run: |
+          mkdir -p "staged/$(dirname '${{ matrix.artifact }}')"
+          cp "${{ matrix.built }}" "staged/${{ matrix.artifact }}"
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: quickjs-${{ matrix.name }}
+          path: native/quickjs/staged/
+          if-no-files-found: error
+
+  # The WebGL backend has no native library, so its check is about the jslib
+  # rather than a binary. It belongs here because it asks the same question.
+  jslib:
+    name: webgl-jslib
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - name: Check the jslib against the P/Invoke surface
+        run: python3 native/quickjs/check-jslib.py
+
+      - uses: actions/setup-node@v6
+        with:
+          node-version-file: .node-version
+
+      # The jslib is generated from .source, and nothing else checks that the committed
+      # one is what .source produces -- a hand-edit or a forgotten rebuild would ship.
+      - name: Rebuild the jslib and check it matches
+        working-directory: unity/quickjs/Plugins/QuickJS/WebGL/.source
+        run: |
+          npx -y -p typescript@5 tsc
+          node postbuild.mjs
+          git diff --exit-code -- ../jsbplugin.jslib
+
+      # The module machinery is the one part of the jslib that runs outside a browser, and
+      # the part with a scanner in it. It is tested against the generated file, not .source.
+      - name: Run the jslib module tests
+        working-directory: unity/quickjs/Plugins/QuickJS/WebGL/.source
+        run: node --test jsbplugin.test.mjs
+
+  # One place to see whether the set is complete, and the only job worth making
+  # a required check.
+  collect:
+    name: all artifacts
+    needs: [build, jslib]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          path: artifacts
+          merge-multiple: true
+      - name: List what was built
+        run: find artifacts -type f | sort

.tegami/2026-08-24-4e91cb.md

@@ -0,0 +1,21 @@
+---
+packages:
+  "upm:com.reactunity.quickjs": minor
+  "upm:com.reactunity.core": minor
+---
+
+### QuickJS is now quickjs-ng, and modules load without blocking a frame
+
+`com.reactunity.quickjs` bound unity-jsb's fork of Bellard-era QuickJS. It now binds [quickjs-ng](https://github.com/quickjs-ng/quickjs). These are two different engines rather than two versions of one, so the native binary, the C shim over it, and every P/Invoke declaration were rebuilt rather than upgraded — the sources are in `native/quickjs` in the repo, which is new: the binaries used to arrive prebuilt from upstream with no way to rebuild them here.
+
+**What you get for it: `import` actually works.** ng has an asynchronous module loader, and the binding now uses it. A module graph is fetched over `UnityWebRequest` while the engine keeps running, so an `import` of an `http` URL — and therefore a dynamic `import()` — resolves without a blocking frame, and a graph whose second hop is only discoverable once the first arrives still completes. `import.meta.url` is populated on a fetched module, which is what the relative imports inside it resolve against. `EngineCapabilities.ModuleResolution` is how you ask whether the engine in front of you can do this.
+
+**WebGL too, which it never could before.** ES module syntax simply did not work on that backend: it has no QuickJS in it, and the JavaScript reimplementation standing in for one evaluates through `eval`, which cannot run `import` or `export` at all. It now fetches a graph through the same loader every other platform uses, then hands the linking to the browser it is already running in — so live bindings, top-level `await` and the module cache come from there. Two things to know. Circular imports are refused rather than resolved, with an error naming the cycle; and the page needs `unsafe-eval` and `blob:` scripts allowed, which is the default, and `unsafe-eval` was already required by `eval`.
+
+**A runaway script now throws instead of killing the process.** quickjs-ng caps how much C stack a script may use, but its 1 MB default is measured against the thread that created the engine — Unity's main thread, which has less than that left — so the guard never fired. Infinite recursion took out the player or the Editor with a `StackOverflowException` that no `catch` could see. The limit now defaults to 768 KB, so the same script raises an ordinary `RangeError` you can catch and log. `ScriptRuntime.MaxStackSize` changes it: raise it for deliberately deep code, lower it on a platform whose main thread has a smaller stack, and note that zero does not mean "no limit" but "use ng's default", which is the unusable one.
+
+**One behaviour change worth checking your code for.** QuickJS used to marshal an empty JavaScript string back to C# as `null`, which made it the one engine that could not represent `''`. It now returns `string.Empty`. If you wrote `?? ""` or a null check around a value that arrives from script, that workaround is no longer needed — and if you branched on `null` to mean "empty", that branch has changed meaning.
+
+**Two features are gone, and neither was reachable.** Operator overloading is not something ng implements, and the machinery for registering it had sat behind a permanently false guard. The editor-side code generator is gone too: it emitted C# bindings to compile at runtime, which the `.NET Standard` profile Unity compiles against excluded anyway, so it could not run in a Unity project at all. Reflection binding, which is what actually binds your types, is untouched.
+
+Verified against an IL2CPP player on Windows x64, not only in the Editor. The Editor is always Mono, so it says nothing about a P/Invoke stub the AOT compiler had to generate or a type the managed stripper deleted — which is most of what this binding is made of.