@react-native-quickjs/quickjs 1.0.0-alpha.1 → 1.0.0-alpha.3

package/CHANGELOG.md

@@ -1,36 +1,194 @@
 # Changelog
 
-## Unreleased
+All notable changes to this project are documented here.
 
-Nothing has been published yet. This section becomes the first release entry.
+The format is based on [Keep a Changelog][keep-a-changelog],
+and this project adheres to [Semantic Versioning][semver].
+
+## [Unreleased]
 
 ### Added
+- Update the embedded [quickjs-ng][ng] engine to v0.16.2.
+
+### Changed
+- Patch `0008`: faster eager `JSON.parse` through direct ASCII key-to-atom
+  parsing, optimized numeric arrays, integer-aware number parsing, and owned
+  dense-array construction.
+- Patch `0009`: faster `JSON.stringify` through direct atom enumeration,
+  efficient key/string quoting, and direct primitive formatting.
+- Patch `0010`: faster JSON tokenization with a dedicated common-punctuation
+  fast path for brackets, braces, commas and colons.
+- Patch `0011`: opt-in lazy `JSON.parse` for documents at least 4 KiB, using a
+  shared source document, structural tape, direct tape-node markers and
+  repeated-layout materialization. Application builds remain eager by default;
+  opt in from the existing `package.json` with
+  `react-native-quickjs.lazyJson: true`. Reviver calls remain eager, and
+  embedders can opt out per runtime with `JS_SetJSONLazyEnabled()`.
+- Patch `0012`: caches shapes for eligible repeated static object literals.
+  Representative object-literal workloads are approximately 12–52% faster.
+- Patch `0013`: accelerates forward `String.prototype.indexOf` and `includes`
+  searches with `memchr` and same-width `memcmp`; representative mixed
+  short/long searches are approximately 8–9% faster.
+- Patch `0014`: reclaims an opcode slot with a compact escape prefix for
+  debugger traps, preserving malformed-bytecode rejection.
+- Patch `0015`: adds foundational monomorphic inline caches for property reads,
+  writable overwrites, and transition stores, with lazy tables and a cheap
+  megamorphic call-site guard. In local paired release measurements,
+  constructor stores were 1.36× faster, React fiber allocation 1.92× faster,
+  tree rendering 1.29× faster, and RN commit performance was neutral.
+- Patch `0015` hardens serialized-bytecode and IC metadata validation, moves
+  prototype-watchpoint invalidation after successful mutations, and preserves
+  non-throwing lazy allocation and correct transition OOM unwinding.
+- Patch `0016`: composes explicitly enabled four-entry polymorphic sites,
+  guarded depth-two prototype reads, and a weak direct-mapped megamorphic
+  fallback cache. Width 1 remains the shipping default; the width-4 default
+  change is reserved for a later patch.
+- Patch `0016` validation covers weak fallback shape reuse, prototype mutation
+  invalidation, runtime destruction, width-4 ASan/OOM/differential paths, and
+  malformed serialized bytecode. Release CTest passed 15/15; host timings are
+  smoke results, with device performance based on the selected 1095 evidence.
+- Patch `0016` paired host Octane smoke results improved the geomean by 7.3%
+  over the IC-disabled baseline across three runs. The largest gains were
+  DeltaBlue (+34.1%), Richards (+24.3%), Raytrace (+19.7%), and Box2D
+  (+14.5%); Crypto, RegExp, Splay, Navier-Stokes, PDF.js, and Mandreel were
+  within neutral-to-small-regression noise. The full reference data is in
+  `tools/benchmark/octane/octane-results.json`.
+- Patch `0017`: makes four-entry inline-cache sites the shipping default after
+ the width-4 validation of the composed cache.
+- Patch `0018`: stores bounded literal, prefix, and first-set metadata
+  alongside compiled regexp bytecode.
+- Patch `0019`: adds the runtime-width backtracking matcher with computed-goto
+  dispatch and register-based execution.
+- Patch `0020`: analyzes patterns for literal, prefix, and first-set candidate
+  searches before entering the full matcher.
+- Patch `0021`: connects compiled search metadata to RegExp compilation and
+  execution.
+- Patch `0022`: adds direct candidate scans and stack storage for small capture
+  sets, reducing the work needed for common matches.
+- Patch `0023`: keeps `RegExp.prototype.test` result-free and streamlines
+  successful match handling.
+- Patch `0024`: accelerates split scanning and improves first-set handling for
+  whitespace-led patterns.
+- Patch `0025`: interns RegExp flag names as atoms for consistent reuse during
+  compilation.
+- Patch `0026`: serves eligible `.flags` reads from validated compiled flags
+  while preserving the generic observable path.
+- Patch `0027`: keeps the regexp fixture and bounds-accounting coverage aligned
+  with the matcher.
+- Patch `0028`: hardens serialized RegExp validation with safe opcode, operand,
+  target, metadata, allocator, and interrupt checks.
+- Patch `0029`: adds table-driven malformed-bytecode coverage and preserves
+  runtime serialization round-trip coverage through the embedding allocator.
+- Patch `0030`: replaces the serialized-bytecode checksum with portable
+  CRC-32C, using arm64 and x86-64 hardware instructions when available while
+  retaining a software fallback and corruption detection. This reduces the
+  checksum portion of bytecode loading without changing the application-facing
+  bytecode API. Hardware availability is probed per call, avoiding shared
+  runtime state, and bytecode tests cover the standard CRC-32C vector plus
+  empty, short, unaligned-length, and larger inputs.
+- Patch `0031`: frames serialized function bodies and adds copied lazy
+  function-body loading. The reader validates and owns the copied payload;
+  body parsing and reconstruction move to first use.
+- Patch `0032`: adds explicit borrowed lazy-bytecode input for embedders that
+  can keep their immutable payload alive for the required lifetime. It is not
+  used by the React Native runtime.
+- Patch `0033`: defers interning non-constant bytecode atoms until they are
+  first referenced, while preserving eager validation of their serialized
+  lengths and boundaries.
+- The React Native runtime integration enables copied lazy loading; it is an
+  integration change layered on top of patches `0031`–`0033`, not part of
+  patch `0031` itself.
+- In the isolated atom comparison, deferred interning saved 0.330 ms in the
+  host load-only median. The Android `bundleLoaded` median was 0.736 ms slower
+  with deferred atoms; the observed `appLoaded` difference is not conclusive
+  without variance measurements, so no device loading improvement is claimed.
+- JSON benchmark reporting now separates checksum-free parse-only timing from
+  traversal and parse-plus-consume timing. The lazy path reduces the
+  repeated-object parse-only workload from about 199 µs eager to about 43 µs.
+
+## [v1.0.0-alpha.2] — 2026-09-05
+
+### Changed
+- Updated the example app and tooling to React Native 0.85.3.
+- Bumped the `@react-native-quickjs/text-encoding` dependency to v1.0.1.
+
+## [v1.0.0-alpha.1] — 2026-09-05
+
+### Added
+- Native modules now fold into the engine's single `.so` on Android and iOS:
+  - `Intl` and `TextEncoding` native code compile into `libquickjsinstancejni.so`.
+  - A generated module registry is compiled into the app target on iOS, so
+    autolinked modules register without a separate registration step.
+- `@react-native-quickjs/intl` and `@react-native-quickjs/text-encoding` now
+  install as a dependency and ship their bytecode embedded in the engine binary.
+- New `scripts/release-module.js` and per-module CI workflows for publishing
+  the module workspace.
+- The engine now stringifies a bytecode function whose source was stripped as
+  `[stripped source]` instead of `[native code]` (new engine patch `0007`).
+- Release bundles compile to QuickJS bytecode on both platforms.
+
+### Changed
+- Prefer the root project's NDK version on Android.
+- `Intl`: memoized `supportedLocalesOf`, skip `String()` conversion, and an LRU
+  cache for `NumberFormatter`.
+- `text-encoding` module bumped to v1.0.1 (see below).
 
+## [intl-v1.0.0] — 2026-09-05
+
+### Added
+- `@react-native-quickjs/intl` 1.0.0:
+  - ECMA-402 `Intl` backed by the operating system's CLDR data (like Hermes),
+    with no locale data in your bundle.
+  - Lazy, bytecode-embedded implementation; materializes on first read.
+  - Covers `Intl.DateTimeFormat`, `NumberFormat`, `Collator`, `PluralRules`,
+    `RelativeTimeFormat`, `ListFormat`, `DisplayNames`, `Segmenter`, `Locale`,
+    `DurationFormat`, `getCanonicalLocales`, `supportedValuesOf`, and the
+    ECMAScript-side `toLocaleString` family.
+  - Platform backends for Android (`android.icu`) and Apple (`NSLocale`/friends),
+    plus a host stub for tests and benchmarks.
+
+## [text-encoding-v1.0.1] — 2026-09-05
+
+### Changed
+- `@react-native-quickjs/text-encoding` 1.0.1:
+  - Folded the Android module into the engine's single `.so`, so the package
+    ships no native code of its own on Android.
+  - Added `<jsi/jsi.h>` linkage to the CMake config so it builds against
+    `ReactAndroid::jsi` (Android) or `jsi` (host).
+  - Fixed `JNI_OnLoad` handling when folded (one `JNI_OnLoad` per `.so`).
+
+## [v1.0.0-alpha.0] — 2026-09-03
+
+### Added
 - QuickJS as a React Native JavaScript engine, compiled from source in the app
   build on Android and iOS. The engine is [quickjs-ng][ng], pre-patched with the
-  six changes described in `engine/patches/README.md`.
+  changes described in `engine/patches/README.md`.
 - `npx react-native-quickjs install`, plus `revert` and `doctor`, and an Expo
   config plugin for `npx expo prebuild`.
 - Release bundles compile to QuickJS bytecode on both platforms.
 - Chrome DevTools debugging: breakpoints, stepping, the call stack, variable
   inspection and expression evaluation.
-- A Hermes compatibility shim, so libraries that link against Hermes -- most
+- A Hermes compatibility shim, so libraries that link against Hermes — most
   importantly `react-native-worklets`, and through it `react-native-reanimated`
-  -- run unmodified. It is built only for an app that has left Hermes.
+  — run unmodified. It is built only for an app that has left Hermes.
 - `TextEncoder` and `TextDecoder`, as `@react-native-quickjs/text-encoding`,
   a dependency of this package so every app has them.
+- A JSI implementation covering host objects, functions, arrays, arraybuffers,
+  strings, symbols, bigints, weak references, native state, microtasks,
+  deferred GC scheduling and safepoints, exceptions, and bytecode compilation
+  (`qjsc`).
 
-### Known limitations
+## [text-encoding-v1.0.0] — 2026-09-03
 
-- iOS compiles React Native core from source: removing Hermes removes the JSI
-  implementation that ships inside `hermesvm.framework`.
-- Conditional breakpoints stop unconditionally; the condition is stored and
-  reported but never evaluated.
-- React Native's non-Hermes path is patched at `pod install`. Each workaround
-  fails with a named error if React Native changes.
-- Expo's `getDefaultReactHost` hardcodes Hermes, so the config plugin edits
-  `node_modules`. Until [expo#49686][expo-pr] lands, an `npm install` reverts
-  that edit and the app silently launches on Hermes.
+### Added
+- `@react-native-quickjs/text-encoding` 1.0.0:
+  - `TextEncoder` and `TextDecoder` per the WHATWG Encoding spec, as direct
+    QuickJS bindings — the package `@react-native-quickjs/quickjs` depends on.
+  - Behaviour: unpaired surrogates encode as U+FFFD; a leading BOM is stripped
+    unless `ignoreBOM` is set; `fatal: true` throws on ill-formed input;
+    `encodeInto` stops on character boundaries.
 
+[keep-a-changelog]: https://keepachangelog.com/en/1.1.0/
+[semver]: https://semver.org/
 [ng]: https://github.com/quickjs-ng/quickjs
 [expo-pr]: https://github.com/expo/expo/pull/49686

package/README.md

@@ -94,6 +94,23 @@ class ReactNativeDelegate: RCTDefaultReactNativeFactoryDelegate {
 
 Then run `pod install`.
 
+### Lazy JSON parsing
+
+Lazy JSON parsing is disabled by default. To opt in without editing a Podfile
+or Gradle file, add this to the app's existing `package.json`:
+
+```json
+{
+  "react-native-quickjs": {
+    "lazyJson": true
+  }
+}
+```
+
+The iOS Podspec and Android CMake integration read the same setting. The
+low-level compile definition and `JS_SetJSONLazyEnabled()` API remain available
+to embedders; `QJS_JSON_LAZY=0/1` remains useful for tests.
+
 ## Android
 
 **1. `android/gradle.properties`**

package/ReactNativeQuickJS.podspec

@@ -2,6 +2,17 @@ require "json"
 
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
 
+# The consuming app's existing package.json is the cross-platform opt-in. The
+# package's own manifest describes the library, so read from CocoaPods'
+# installation root rather than __dir__ here.
+consumer_roots = [Pathname.new(Pod::Config.instance.installation_root.to_s)]
+consumer_roots << consumer_roots[0].parent
+consumer_roots << consumer_roots[0].parent.parent
+consumer_manifest = consumer_roots.map { |root| root.join("package.json") }
+  .find { |manifest| manifest.file? }
+consumer_package = consumer_manifest ? JSON.parse(File.read(consumer_manifest)) : {}
+json_lazy_default = consumer_package.dig("react-native-quickjs", "lazyJson") == true
+
 # The engine compiled here is engine/quickjs-rel: the committed, pre-patched
 # projection of the engine/quickjs-ng submodule, generated by
 # scripts/sync-quickjs-rel.js. The submodule cannot be what ships -- our patches
@@ -111,7 +122,8 @@ Pod::Spec.new do |s|
     # RNQJS_ENABLE_CDP is absent on purpose: undefined means no DevTools
     # backend, and react_native_quickjs_post_install defines it for debug only.
     "GCC_PREPROCESSOR_DEFINITIONS" =>
-      "$(inherited) _GNU_SOURCE=1 JS_ENABLE_DEBUGGER=1",
+      "$(inherited) _GNU_SOURCE=1 JS_ENABLE_DEBUGGER=1" \
+      + (json_lazy_default ? " RNQJS_JSON_LAZY_DEFAULT=1" : ""),
     "USE_HEADERMAP" => "YES",
   }
 

package/android/CMakeLists.txt

@@ -94,6 +94,12 @@ endif()
 
 add_library(quickjsinstancejni SHARED ${RNQJS_QUICKJSINSTANCE_SOURCES})
 
+if(RNQJS_BYTECODE_LAZY)
+  target_compile_definitions(quickjsinstancejni PRIVATE RNQJS_BYTECODE_LAZY=1)
+else()
+  target_compile_definitions(quickjsinstancejni PRIVATE RNQJS_BYTECODE_LAZY=0)
+endif()
+
 target_include_directories(quickjsinstancejni PRIVATE
   "${RNQJS_ROOT}/src/bytecode"
   "${RNQJS_ROOT}/src/module"

package/android/build.gradle

@@ -54,7 +54,9 @@ android {
         // off by default, r28 turns it on, and no host build can see it.
         arguments "-DANDROID_STL=c++_shared",
                   "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON",
-                  "-DREACT_NATIVE_DIR=${reactNativeDir()}"
+                  "-DREACT_NATIVE_DIR=${reactNativeDir()}",
+                  "-DRNQJS_JSON_LAZY_DEFAULT=${jsonLazyEnabled() ? 'ON' : 'OFF'}",
+                  "-DRNQJS_BYTECODE_LAZY=${quickjsLazyEnabled() ? 'ON' : 'OFF'}"
         if (quickjsModuleDirs().size() > 0) {
           arguments "-DRNQJS_QUICKJS_MODULES=${quickjsModuleDirs().join(';')}"
         }
@@ -141,6 +143,26 @@ def reactNativeArchitectures() {
   return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
 }
 
+// The app's existing package.json is the single cross-platform opt-in. A
+// Gradle property remains useful for CI and local experiments without adding
+// another project file.
+def jsonLazyEnabled() {
+  if (project.hasProperty('rnqjsJsonLazy')) {
+    return project.property('rnqjsJsonLazy').toString() != 'false'
+  }
+  def manifest = new File(rootProject.projectDir.parentFile, "package.json")
+  if (!manifest.exists()) return false
+  def json = new groovy.json.JsonSlurper().parse(manifest)
+  return json["react-native-quickjs"]?.lazyJson == true
+}
+
+def quickjsLazyEnabled() {
+  if (project.hasProperty('rnqjsLazy')) {
+    return project.property('rnqjsLazy').toString() != 'false'
+  }
+  return true
+}
+
 // Autolinked QuickJS modules (@react-native-quickjs/* declaring
 // reactNativeQuickJSModule with an android/ dir), folded into this engine's
 // single .so.
@@ -195,9 +217,8 @@ gradle.projectsEvaluated {
   }
 }
 
-// Compile the release bundle to QuickJS bytecode, after React Native has
-// written it. Debug builds load JavaScript from Metro and never produce a
-// bundle, so there is nothing to compile. -PrnqjsBytecode=false turns it off.
+// Compile each QuickJS bundle after React Native has written it.
+// -PrnqjsBytecode=false turns this off.
 
 // ExecOperations is how a Gradle 9 build spawns a process; project.exec was
 // removed. A plain ProcessBuilder also runs, but not identically: under a
@@ -224,9 +245,15 @@ gradle.projectsEvaluated {
     app.tasks.matching { it.name ==~ /createBundle.*JsAndAssets/ }.configureEach { bundleTask ->
       bundleTask.doLast {
         // Found by name rather than by reading the task's own properties,
-        // which are React Native Gradle plugin internals.
+        // which are React Native Gradle plugin internals. Restrict the scan
+        // to this task's variant so a prior variant's bytecode is not passed
+        // back through qjsc as if it were source JavaScript.
+        def variant = bundleTask.name - 'createBundle' - 'JsAndAssets'
+        def variantDir = variant.substring(0, 1).toLowerCase() + variant.substring(1)
         def assets = app.layout.buildDirectory.dir("generated/assets").get().asFile
-        app.fileTree(assets).matching { include '**/index.android.bundle' }.each { bundle ->
+        app.fileTree(assets).matching {
+          include "**/${variantDir}/index.android.bundle"
+        }.each { bundle ->
           process.exec {
             commandLine(*node, compiler.absolutePath, bundle.absolutePath)
             workingDir app.rootDir

package/cmake/quickjs.cmake

@@ -57,6 +57,15 @@ add_library(quickjs STATIC
 target_include_directories(quickjs PUBLIC "${QUICKJS_DIR}")
 target_compile_definitions(quickjs PRIVATE _GNU_SOURCE)
 
+# Lazy JSON is opt-in for applications. Android and CocoaPods derive this
+# option from the consuming app's package.json; host builds can override it
+# with -DRNQJS_JSON_LAZY_DEFAULT=ON or QJS_JSON_LAZY at runtime for tests.
+option(RNQJS_JSON_LAZY_DEFAULT
+       "Enable lazy JSON parsing by default for this build" OFF)
+if(RNQJS_JSON_LAZY_DEFAULT)
+  target_compile_definitions(quickjs PRIVATE QJS_JSON_LAZY_DEFAULT=1)
+endif()
+
 # The maths functions are in libSystem on Apple and in a separate libm
 # elsewhere, so a macOS host build links clean while Linux fails at the link
 # step on round, floor, pow and friends. Detected rather than assumed, the way

package/engine/quickjs-rel/MANIFEST.json

@@ -1,6 +1,6 @@
 {
   "_comment": "Generated by scripts/sync-quickjs-rel.js. Do not edit. These files are engine/quickjs-ng at the commit below, with the patches below applied.",
-  "upstreamCommit": "3d3cf3d86b66551403745a5b06acbed2b0f31dfd",
+  "upstreamCommit": "df836d1f4490dfc6a65dbceda8a71d14ddc7f45c",
   "patches": [
     {
       "name": "0001-runtime-malloc-size-accessor.patch",
@@ -12,7 +12,7 @@
     },
     {
       "name": "0003-debugger-interface.patch",
-      "sha256": "eb0e05d2449685768cdd44c8458c3ffb13efa47a92994363ba040ecef46b22e4"
+      "sha256": "ab36772fcde3abe2e2d53f7dd9eb3fe11d7644f4300e7c7d0933c39dbc458fa2"
     },
     {
       "name": "0004-debugger-frame-info.patch",
@@ -30,30 +30,135 @@
       "name": "0007-stripped-source-tostring.patch",
       "sha256": "5543d3f33108b3666ccc2317b65afc3ae132a8a12e223ed9f6defeaef2367b8b"
     },
+    {
+      "name": "0008-json-fast-paths.patch",
+      "sha256": "2e91ce53e8df08296a4a1fb978e1a52175587af12452cce6677f83fc8837e73c"
+    },
+    {
+      "name": "0009-json-stringify-fast-paths.patch",
+      "sha256": "dfde7e3637b3277f602a0c0c84bc5bcf3a29f63dddd7d355c5e929028fc4fabb"
+    },
+    {
+      "name": "0010-json-tokenizer-punctuation.patch",
+      "sha256": "4fca4da49b5f985224f32353a270c3208897a1c49148e7d708f9f663f4dacb5c"
+    },
+    {
+      "name": "0011-lazy-json-markers.patch",
+      "sha256": "75ef0fea774eeb4d839d0f114344dd4aa105a10089a18ba65566a39a551b06b7"
+    },
+    {
+      "name": "0012-object-literal-shape-templates.patch",
+      "sha256": "2537a703361646275ab8426bbc77291222dee112e8e921a76e6c30e28ed4374e"
+    },
+    {
+      "name": "0013-string-memchr-search.patch",
+      "sha256": "e23816f01dc98dea510a7d85f20ac803f5708c19276216f33d97e3775c0deb3d"
+    },
+    {
+      "name": "0014-opcode-space.patch",
+      "sha256": "ec17da3ec906c5fe49ca0d9800e84befd5e3ab11cc6fa88b09948becf5aab1e9"
+    },
+    {
+      "name": "0015-inline-caches.patch",
+      "sha256": "24decd2b7639b67644a078289c5b8d3bb207e0d4e00d65b2d0d1b3d908ab56cb"
+    },
+    {
+      "name": "0016-composed-ic-4wide-depth2-mega.patch",
+      "sha256": "ff52e5ffa26106f0de611acdbff82e119285cc23384cf4ea41f22bc40c76d02a"
+    },
+    {
+      "name": "0017-ic4-width-4-inline-cache-default-on.patch",
+      "sha256": "c8527464beb2a05afab4948edee31a419b149d2a6e76797f7d7524ee4813e2fd"
+    },
+    {
+      "name": "0018-regexp-metadata.patch",
+      "sha256": "674bb67c6cfd8ee1129d05cca528f97507d37e7f1303a2129b51db87ce6ce5c0"
+    },
+    {
+      "name": "0019-regexp-matcher-core.patch",
+      "sha256": "f71c6efc193f7805f0cdd2af940721673c331b01a8306c36eda02eee4ab6527a"
+    },
+    {
+      "name": "0020-regexp-prefilter-analysis.patch",
+      "sha256": "8cd48dd0ed65a0bcc43b97f0e5b6e1e0e70cbabd5543e4ebd0b990a9297e10ae"
+    },
+    {
+      "name": "0021-regexp-prefilter-integration.patch",
+      "sha256": "6fc4b32b0f26c597ae308dc8f82f4a4f7d25486b4a18f415cc815bfb2f9ca05c"
+    },
+    {
+      "name": "0022-regexp-exec-fast-paths.patch",
+      "sha256": "26b6151109f20d3f1e960d69f9f0078405d62afc609f415e0a1cffabd220850b"
+    },
+    {
+      "name": "0023-regexp-result-optimization.patch",
+      "sha256": "a688acc0aec07ae143457860843234a47afbac947696f873c48aff2b444af4af"
+    },
+    {
+      "name": "0024-regexp-split-scan-and-space-first-set.patch",
+      "sha256": "f8564a1336bc656bdf4b5e8093f8a0c625d234c5396ae3b020a8c559d82cb80e"
+    },
+    {
+      "name": "0025-regexp-flag-name-atoms.patch",
+      "sha256": "55dcc10393c2d84375e460219b2f5a739f0be04aee26c41ed47ac1dcf1f6b133"
+    },
+    {
+      "name": "0026-regexp-flags-from-bytecode.patch",
+      "sha256": "fa087ea4c14a5d86d04df7fda2e80842dc7ab47a04d161a5c1f6cb58063cfa41"
+    },
+    {
+      "name": "0027-regexp-test-fixture-correctness.patch",
+      "sha256": "da90adbb88285da1d37ac14c6611f60fbf44ec4098a23775a8c3bd5dab37cc3a"
+    },
+    {
+      "name": "0028-regexp-metadata-hardening.patch",
+      "sha256": "82d5fa08ddba839bc98f2acb001bb995ceef605f95a91b85a4f1e6a4bf682a7d"
+    },
+    {
+      "name": "0029-regexp-metadata-tests.patch",
+      "sha256": "32f31ab67f340b0c94f54ab64bf158a47189bd03625934a639b9ed4b0f92a1f9"
+    },
+    {
+      "name": "0030-crc32c-bytecode-checksum.patch",
+      "sha256": "b0f244db173181a94b7d7a090f61da9ff66e6cb3c2a93eac4991af1adec72388"
+    },
+    {
+      "name": "0031-lazy-bytecode-function-bodies.patch",
+      "sha256": "54c8f8e79d4832e73adfa3acb33cf667b33bacec0d6cb0331d7d267e46906c5a"
+    },
+    {
+      "name": "0032-borrowed-lazy-bytecode-input.patch",
+      "sha256": "e282fa2687a1cf5ed042bcc91478ec7de0d68b5165e33cb4a5eadd0085eed6c3"
+    },
+    {
+      "name": "0033-deferred-bytecode-atoms.patch",
+      "sha256": "bc5d8aba4747e808f9dcc0e0150db5cbbc34edbafa5624430ba8fb78fedc0242"
+    },
     {
       "name": "9999-bc-version-bump.patch",
-      "sha256": "1a89bc63c09a7411d3f5d8cacbccbb7c525ad37ec4f7f07ee130f5ade736d428"
+      "sha256": "06463ac103bea52a86b1cc413ac056ec19980640ff6d57af5444a1728d4d5aad"
     }
   ],
   "files": {
-    "quickjs.c": "9016fa1b5e6682c0c45fef8d1b057aa44cfad95ff1eb50e3432ad520187a86e1",
-    "libregexp.c": "27cd5fb4f4f0d8c05fea4cb0ddcd4dede7f39364e87f0f5610cfc25a89908158",
-    "libunicode.c": "d88f53190ad772dd09b2beb93ffb8fc3097852f4987485aac8663a00189c43eb",
+    "quickjs.c": "aab1e3ae19a8ee2b320814e3eb7054866f20b682680efeccf1edb3904025b950",
+    "libregexp.c": "98d43216a43bd02950168529fd8962558c9dda612eed7ce93d3cba40e1223232",
+    "libunicode.c": "d755606498ff707dc3a93826713c749f77b9222d8a6b066621d72a308460bf2d",
     "dtoa.c": "a8d2cf2d04db406e0c16acdd95ab0e709d309902865722f41dac07a1ba5676af",
-    "builtin-array-fromasync.h": "f41eb2eb028832cff9a5f8d8d2cb438c27771a9d7d85c30dfd16aa78f34fe6de",
-    "builtin-iterator-zip-keyed.h": "b44cb8065f2eb2d4689b426bbc08fdf24ac996065cd909a09748566ce0b6a446",
-    "builtin-iterator-zip.h": "8d30bc2ebbc77f18754059444ee1e2686a6b2229cedfadcc0c593baa656acec2",
+    "builtin-array-fromasync.h": "d826a4f17d0674dffb10f31b57e9ef054dd9dcb95fe9f1947b80cbc256c75aaa",
+    "builtin-iterator-zip-keyed.h": "ec83ae715ba78bd52d7ce3fe7245cec656a4ba3c248d31dbcdf78b2838ac4913",
+    "builtin-iterator-zip.h": "9fcae978ad59a328defaa4be372bc2a24387e67a8ee42779ddddaf6a5a4aca01",
     "cutils.h": "810709e35fe0ece09321ad4c207dba9973aa19f91fa909e00754896b39cc3201",
     "dtoa.h": "1c4a4540c0038632c8a4c225472fbc21bd476fb35c4da4a857a11965b58231b9",
     "libregexp-opcode.h": "2a98d646089f3a72f25480116297c5fdb5b28fd9f815447273951f4ade4a115e",
-    "libregexp.h": "53ff95a038f7001b752c455d195d998e2955f0ae4ed62a002c13eca798db3ceb",
-    "libunicode-table.h": "2ec1c935e1268c1bd76ac10cad63e6e0f1f4bb3f125e69ddcfc2b9123582b8db",
+    "libregexp-backtrack.c.inc": "c0048b115cb43a46f9e3688b962fd2c95188acc528d65cfd7191f73c787c861a",
+    "libregexp.h": "2e6fca80aace54a614b5a3f65912f2d6b03dd0d87a7ed3f25f064d997e6eb557",
+    "libunicode-table.h": "5840a921ac11664b505ee37b1219f518fff2a04972fe848b4bdf1e85c5a0bd83",
     "libunicode.h": "ad13f66aaea3fab1616e84b9c048f2a315e1bdbab628b966617a7a3e55bcba2b",
     "list.h": "cb6e24e8ee54bccdd66234fe54cd702d1160b9841db2b9b9adeb5003afe301d5",
     "quickjs-atom.h": "66654ae6533d15073ea527979c453709d7ed83162142c656095a10dcef737a60",
     "quickjs-c-atomics.h": "29883c742a5c512278fce54d19b1b9af949006e1d7dfc9ffa2e0946b184d8c5c",
-    "quickjs-opcode.h": "c5b3354ae71cd209e8ebe3234768ac906b7f541fb0ab7fac5d69ef66210250bc",
-    "quickjs.h": "bdda3829c255b663e6db572f63e5a40dcde529b28c2c10806e419d99dbdb27b0",
+    "quickjs-opcode.h": "ede502651cd914c9cf44ecf1202c5ac33263286a31c06065e2b0ea985463fb82",
+    "quickjs.h": "a532b83c8c37cc79fedff1846ed2469478fc4f1ca1e6197cb402443c66a8996d",
     "LICENSE": "96f73f9d2a16c21a36b418f06073be26e7d6d5e7c1bc99756b21a4f2c74ef171"
   }
 }