awslabs/llrt

LLRT is a high-performance, low-latency JavaScript runtime built in Rust, designed primarily for AWS Lambda serverless environments. It provides a Node.js-compatible API surface by implementing core modules such as fetch, streams, crypto, and file system access, while embedding a pre-compiled bytecode cache to minimize cold start times. The system supports cross-compilation for ARM64 architectures and includes extensive tooling for testing, benchmarking, and integration with AWS SDKs.

62 changes.

The project underwent a comprehensive architectural overhaul, restructuring the Rust codebase into modular crates and replacing legacy implementations with native, Node.js-compatible modules. This period focused on stabilizing the runtime through extensive unit and end-to-end testing, modernizing build infrastructure, and aligning examples with current AWS and Node.js standards.

24 changes.

This period focused on implementing core Web Platform and Node.js APIs, including the Web Streams API, Fetch API, DNS, and TLS modules. The work also established a robust module loading system with ESM/CJS support, embedded bytecode capabilities, and comprehensive test harnesses for WPT and Test262 conformance.

6 changes.

This period focused on expanding the runtime's API surface by implementing the Temporal date/time standard and the TransformStream web API with backpressure support. Concurrently, the crypto module underwent a significant architectural refactor to support pluggable backends, including pure-Rust AES variants and post-quantum algorithms, while adding shims for multi-region AWS signature signing.

This change introduces the AbortController and AbortSignal classes to the runtime, enabling developers to cancel asynchronous operations. The implementation includes the standard abort() method, the static AbortSignal.any() and AbortSignal.timeout() helpers, and support for the abort event and onabort property. These APIs are now available globally for use in fetch, streams, and other async workflows.

_modules/llrt\abort · high confidence

The \modules/llrt\_zlib\ module now exposes Brotli and Zstandard compression and decompression capabilities alongside existing Zlib methods. Users can call \brotliCompress\, \brotliCompressSync\, \brotliDecompress\, and \brotliDecompressSync\ for Brotli encoding, as well as \zstdCompress\, \zstdCompressSync\, \zstdDecompress\, and \zstdDecompressSync\ for Zstandard encoding. These new convenience methods enforce the \maxOutputLength\ option to prevent excessive memory allocation, matching the behavior of the existing Zlib functions.

_modules/llrt\zlib · high confidence

The \modules/llrt\_events\ module now exposes \EventTarget\, \Event\, and \CustomEvent\ classes to JavaScript. \EventTarget\ provides the core \on\, \off\, \emit\, \once\, \prependListener\, and \prependOnceListener\ methods for attaching and triggering event listeners. \Event\ and \CustomEvent\ allow users to create event objects with standard properties such as \type\, \bubbles\, \cancelable\, \composed\, and \detail\, enabling structured event handling within the runtime.

_modules/llrt\events · high confidence

The \llrt\_perf\_hooks\ module is introduced to provide compatibility with the Node.js \perf\_hooks\ API. It exposes a \performance\ global object that implements \performance.now()\ for measuring elapsed time and \performance.timeOrigin\ for the start time of the runtime, along with a \toJSON()\ method for serialization. This allows applications relying on standard performance timing hooks to function correctly within the environment.

_modules/llrt\_perf\hooks · high confidence

This change introduces the \Temporal\ global object and its core classes (\Duration\, \Instant\, \PlainDate\, \PlainDateTime\, \PlainTime\, \ZonedDateTime\) and the \Temporal.Now\ helper object. It provides a new JavaScript API for date and time manipulation, including features like rounding, addition/subtraction of durations, and conversion between different temporal types.

_modules/llrt\temporal · high confidence

This change introduces the \TransformStream\ API, allowing users to create streams that transform data as it passes through. The implementation includes the \TransformStreamDefaultController\ for enqueuing, erroring, and terminating chunks, and supports standard transformer options like \transform\, \flush\, and \cancel\ algorithms. It also correctly handles backpressure based on the readable side's high water mark, ensuring that writes are paused when the buffer is full, as verified by the included tests for identity passthrough, chunk transformation, and backpressure behavior.

_modules/llrt\_stream\web/src/transform · high confidence

The \modules/llrt\_dgram\ module introduces a new \dgram\ implementation compatible with Node.js, enabling UDP datagram communication. Users can now create IPv4 and IPv6 sockets using \dgram.createSocket()\, send and receive data, and bind to ports. The module exposes an event-driven API supporting \message\, \listening\, \close\, and \error\ events, along with async/await patterns for socket operations.

_modules/llrt\dgram · high confidence

The \stream/web\ module is now available, exposing the Web Streams API (ReadableStream, WritableStream, TransformStream, and associated controllers/readers) to JavaScript. This implementation allows users to consume and produce data streams using standard web APIs, with classes also registered on the global scope for convenience.

_modules/llrt\_stream\web/src · high confidence

Introduces a new AWS SAM example project that demonstrates running a TypeScript Lambda function using the LLRT (Low Latency Runtime) via a custom Lambda layer. The example includes a \template.yaml\ defining an ARM64 function on \provided.al2023\ that references the LLRT layer, along with a \samconfig.toml\ for deployment configuration, a \README.md\ with usage instructions, and the necessary source files (\app.ts\, \tsconfig.json\) to build and deploy the sample application.

example/llrt-sam · high confidence

Introduces a new example project demonstrating how to build and deploy a serverless application using the LLRT (Low Latency Runtime) on ARM64 architecture via AWS SAM. The example includes a Dockerfile that fetches the LLRT binary for ARM64, a SAM template defining an API Gateway-triggered Lambda function with container image packaging, and supporting configuration files (samconfig.toml, .gitignore) to facilitate local development and guided deployment.

example/llrt-sam-container-image · high confidence

The llrt\_navigator module has been added, exposing a global \navigator\ object in the JavaScript runtime that includes a \userAgent\ property. This property is constructed using the string "llrt " concatenated with the current package version. Additionally, a new build helper library (llrt\_build) was introduced to conditionally enable the \rust\_nightly\ configuration flag when the compiler is running in nightly mode.

_libs/llrt\_build, modules/llrt\navigator · high confidence

The \modules/llrt\_stream\_web/src/utils\ directory now contains helper modules (\mod.rs\, \promise.rs\, \queue.rs\) that support the Web Streams API implementation. These utilities provide \ValueOrUndefined\ and \UnwrapOrUndefined\ traits to correctly handle JavaScript \undefined\ versus \null\ distinctions required by Web Platform Tests, a \PromisePrimordials\ struct to cache and trace native Promise constructors and methods, and a \QueueWithSizes\ struct to manage stream backpressure queues according to the Streams spec.

_modules/llrt\_stream\web/src/utils · high confidence

The \llrt\_stream\_web\ module now implements the \ByteLengthQueuingStrategy\ and \CountQueuingStrategy\ classes, allowing users to control stream backpressure using either byte counts or item counts. These strategies expose \highWaterMark\ and \size\ attributes, correctly coerce \highWaterMark\ values to numbers, and throw \RangeError\ for invalid values (negative or NaN) in compliance with the Web Streams specification.

_modules/llrt\_stream\_web/src/queuing\strategy · high confidence

The \libs/llrt\_dns\_cache\ library now provides a \CachedDnsResolver\ that caches DNS lookups for HTTP clients. This implementation uses a configurable cache size, concurrency limit, and Time-To-Live (TTL) to store resolved IP addresses, reducing the number of direct DNS queries made by the application.

_libs/llrt\_dns\cache · high confidence

This change introduces the missing pieces for the Streams API: a \ReadableStreamBYOBReader\ for read-into (Bring Your Own Buffer) operations and a \ReadableByteStreamController\ to manage byte-source streams. It also adds the necessary controller and reader abstractions (\ReadableStreamController\, \ReadableStreamDefaultReader\, \ReadableStreamDefaultController\) to support both default and byte-based reading modes, enabling full compliance with the Web Streams standard for byte-oriented data.

_modules/llrt\_stream\web/src/readable · high confidence

This change introduces a new \types/\ directory containing TypeScript declaration files (\.d.ts\) for a wide range of core modules, including \abort\, \assert\, \async\_hooks\, \buffer\, \child\_process\, \console\, \crypto\, \dgram\, \dns\, and \dom-events\. It also adds an ESLint configuration (\.eslintrc.cjs\) to enforce DefinitelyTyped standards for these definitions. These files provide static type checking and IntelliSense support for the corresponding runtime APIs, improving developer experience and code safety when using these modules.

types · high confidence

This change introduces the \WritableStream\ API and its associated components (\WritableStreamDefaultController\, \WritableStreamDefaultWriter\) within the \llrt\_stream\_web\ module. Users can now create writable streams with underlying sink callbacks (start, write, close, abort) and manage backpressure via high-water marks and size algorithms. The implementation includes locking mechanisms to ensure exclusive access by a single writer and exposes standard properties like \locked\, \desiredSize\, and promises for \ready\ and \closed\ states, aligning with the Web Streams specification.

_modules/llrt\_stream\web/src/writable · high confidence

The new \tty\ module exposes an \isatty\ function that allows JavaScript code to check whether a file descriptor (stdin, stdout, or stderr) is connected to a terminal. This enables scripts to detect interactive environments and adjust behavior accordingly, such as enabling colored output or interactive prompts only when running in a TTY.

_modules/llrt\tty · high confidence

The \llrt\_intl\ module introduces a lightweight internationalization implementation focused on timezone support, enabling compatibility with libraries like dayjs. It provides a minimal \Intl.DateTimeFormat\ API (supporting \format()\, \formatToParts()\, and \resolvedOptions()\) and patches \Date.prototype.toLocaleString\ to handle the \timeZone\ option. This functionality is powered by baked-in CLDR locale data and the \jiff\ library, allowing for timezone-aware date and time formatting without requiring the full ICU library.

_modules/llrt\intl · high confidence

The \llrt\_core\ crate now includes a \build.rs\ script that runs during compilation to pre-compile JavaScript modules from the \bundle/js\ directory into bytecode, storing them in a generated \BYTECODE\_CACHE\ map, and also generates an \SDK\_CLIENT\_ENDPOINTS\ map from \sdk.cfg\. This shifts the bundling and compilation of core JS assets and AWS SDK endpoint configurations from runtime or manual steps into the build process, ensuring these resources are embedded directly into the binary.

_llrt\core · high confidence

The \example/register-hooks\ directory now provides a working example of using \node:module.registerHooks()\ to intercept module resolution and loading. It includes hook implementations that polyfill the \fs\ module (mapping it to an internal LLRT implementation), resolve a custom \calc\ module with inline source code, and load the \http\ module from a local file. The example also features a minimal HTTP server implementation in \src/http.js\ and a test script that verifies the hooks by importing \fs\, \calc\, and \v8\ (which is polyfilled to use LLRT's QJS memory usage), demonstrating how to run these hooks via the \--import\ flag.

example/register-hooks · high confidence

The process.versions object now includes an @aws-sdk property that reflects the version of the bundled AWS SDK, making it available for runtime detection and compatibility checks.

_modules/llrt\process · high confidence

The \llrt\_core\ module now includes a polyfill for the Node.js \stream/promises\ API, specifically exporting the \finished\ and \pipeline\ functions from \readable-stream\. This allows JavaScript code running in the environment to use promise-based stream utilities that were previously unavailable or required manual implementation.

_llrt\core/src/modules/js/stream · high confidence

Added the core implementation for the Web Streams API \ReadableStream\, including the underlying source algorithms (start, pull, cancel), stream state management, and support for piping to writable streams and tearing streams into branches. This brings the runtime closer to Web Platform Tests (WPT) conformance for stream handling.

_modules/llrt\_stream\web/src/readable/stream · high confidence

This change introduces the \SubtleCrypto\ interface, providing a comprehensive set of cryptographic operations including key generation, import, export, and management, as well as data encryption and decryption, hashing, and key derivation. It supports a wide range of algorithms such as AES (CBC, CTR, GCM, KW), RSA (OAEP, PSS), EC, Ed25519, X25519, ChaCha20-Poly1305, HMAC, PBKDF2, HKDF, and modern post-quantum schemes like ML-KEM, ML-DSA, and Hybrid KEMs. The implementation also includes SHA-3, cSHAKE, and TurboSHAKE digest algorithms, along with encapsulation/decapsulation for key exchange.

_modules/llrt\crypto/src/subtle · high confidence

Added the \llrt\_path\ module (\modules/llrt\_path/src/lib.rs\), providing a new path manipulation API for users. This implementation includes platform-specific handling for Windows (UNC paths, drive letters, backslash normalization) and POSIX systems, exposing core functions like \dirname\ to resolve directory components from file paths.

_modules/llrt\_assert, modules/llrt\path/src · high confidence

The \libs/llrt\_logging\ crate has been added, introducing a new logging subsystem for the runtime. This library provides formatted console output capabilities, including support for ANSI color codes, configurable log levels (Trace through Fatal), and object serialization logic that handles circular references and custom inspection symbols. It serves as the foundational component for console logging within the LLRT environment.

_libs/llrt\logging · high confidence

The \dns\ module is now available, exposing the \lookup\ function to resolve hostnames to IP addresses. This implementation supports IPv4 and IPv6 resolution, allows specifying address family preferences (IPv4, IPv6, or both), and respects address ordering options (\verbatim\, \ipv4first\, \ipv6first\) to control the order in which results are returned to the callback.

_modules/llrt\dns · high confidence

Adds the \llrt\_child\_process\ module, exposing Node.js-compatible APIs for spawning and executing child processes. This includes \spawn\ for streaming I/O via readable/writable streams, \exec\ for running commands with output buffering, and \execFile\ for executing files directly. The implementation handles platform-specific signal management (Unix vs. Windows) and provides a \ChildProcess\ object with \pid\ and \kill\ capabilities, enabling users to run external commands and manage their lifecycle within the runtime.

_modules/llrt\_child\process · high confidence

This change adds a new embedded module system that allows the runtime to load pre-compiled bytecode modules directly from an embedded cache. It introduces an \EmbeddedLoader\ and \EmbeddedResolver\ that handle module resolution and loading, supporting both compressed and uncompressed bytecode formats with zstd decompression. The system integrates with the JavaScript runtime by setting a \\_\_require\_hook\ global, enabling seamless loading of embedded modules alongside standard file-based modules. This provides a mechanism for bundling and efficiently loading application code without requiring external file system access at runtime.

_llrt\core/src/modules/embedded · high confidence

Adds a new \net\ module (\modules/llrt\_net\) providing Node.js-compatible networking APIs, including \Socket\ and \Server\ classes for TCP and Unix domain sockets. The module exposes \connect\, \createConnection\, and \createServer\ functions, supports event-driven I/O via \EventEmitter\, and includes configurable allow/deny lists for network access control.

_modules/llrt\net · high confidence

The \llrt\_http\ module now exposes an \Agent\ class that allows users to create HTTP clients with custom TLS settings, specifically the ability to disable certificate verification (\rejectUnauthorized\) and provide custom CA certificates (\ca\). This new agent-based architecture is supported by internal refactoring that separates client construction logic into feature-gated modules (supporting Rustls and OpenSSL backends) and introduces configuration options for HTTP version selection (HTTP/1.1 vs HTTP/2) and connection pool idle timeouts.

_modules/llrt\http · high confidence

The Rust crypto provider now includes dedicated AES cipher variant types (AES-CBC, AES-CTR, and AES-GCM) to handle encryption and decryption operations. This addition supports multiple key lengths (128, 192, 256 bits) and specific parameters like counter sizes and tag lengths, enabling more granular and compatible AES operations within the pure-Rust backend.

_modules/llrt\crypto/src/provider/rust · high confidence

The new \modules/llrt\_timers\ module implements the standard JavaScript timer APIs (\setTimeout\, \setInterval\, \setImmediate\, \clearTimeout\, \clearInterval\) and \queueMicrotask\ for the LLRT runtime. It manages timer state per JavaScript runtime instance, ensuring that \setImmediate\ callbacks execute before \setTimeout\ callbacks with zero delay to align with Node.js event loop specifications. The implementation integrates with async hooks for initialization tracking and uses finalization registries to manage callback lifecycle.

_modules/llrt\timers · high confidence

The llrt\_core library has been reorganized into a modular structure, introducing new capabilities such as custom inspect functions for Map, Set, DataView, and ArrayBuffer to improve debugging output, and a benchmark suite for codec performance. The bytecode compiler now supports generating self-contained executables via the --executable flag, and the runtime client includes SDK connection warmup logic for global endpoints. Additionally, the codebase adds support for extra CA certificates, HTTP/2, and environment-variable-driven resolver control, while exposing the llrt:qjs module and improving structuredClone transfer handling.

_llrt\core/src · high confidence

The \llrt\ directory now contains the source for a standalone Rust binary, making the runtime available as a crate. This introduces a new \main.rs\ entry point that initializes the VM and routes execution between a Lambda runtime handler and a CLI mode. The CLI supports running JavaScript files, evaluating expressions, and compiling JS to bytecode. A new REPL module (\repl.rs\) provides an interactive shell with history, cursor control, and async execution. The minimal tracer (\minimal\_tracer.rs\) has been updated to use the \jiff\ library for timestamps and respects the \LLRT\_LOG\ environment variable for filtering. The self-extracting binary logic in \main.c\ has been refactored to use memory-mapped I/O for decompression.

llrt · high confidence

The crypto module has been refactored to support pluggable cryptographic backends, allowing users to select their preferred implementation via feature flags. The new architecture introduces a \CryptoProvider\ trait and registers specific providers: \Graviola\ (high-performance, formally verified assembler for SHA256/384/512, HMAC, and AES-GCM), \OpenSSL\ (standard OpenSSL bindings), \Ring\ (safe Rust crypto library), and \Modern\ (supporting ChaCha20-Poly1305 and post-quantum algorithms like ML-DSA, ML-KEM, and hybrid KEMs when the \pqc\ feature is enabled). The \mod.rs\ file enforces mutual exclusivity between these backends (e.g., \crypto-rust\, \crypto-openssl\, \crypto-ring\, \crypto-graviola\) to ensure only one provider is active at compile time.

_modules/llrt\crypto/src/provider · high confidence

The \modules/llrt\_buffer\ module now provides native implementations of the \Buffer\, \Blob\, and \File\ classes, along with \ArrayBufferView\ support. \Buffer\ is implemented as a subclass of \Uint8Array\ to inherit standard prototype methods, while \Blob\ and \File\ expose Web API-compatible features such as \textStream()\, \arrayBuffer()\, \bytes()\, and \slice()\. The module also exports \atob\, \btoa\, and \buffer.constants\ (including \MAX\_LENGTH\ and \MAX\_STRING\_LENGTH\), ensuring broader compatibility with web standards and existing JavaScript libraries.

_modules/llrt\buffer · high confidence

This change introduces new JavaScript modules for LLRT, including type definitions for codec (base64/hex encoding), XML parsing, and QJS memory inspection, alongside a new timezone module for handling IANA timezone offsets. It also adds a new stream module that bridges Node.js streams to Web Streams API, enabling interoperability between the two streaming standards.

_llrt\core/src/modules/js · high confidence

The \modules/llrt\_os\ module is introduced, exposing a comprehensive set of operating system information and control functions. It provides network interface details (including IP addresses, netmasks, and MAC addresses) via the \networkInterfaces\ function, and system statistics such as CPU models, speeds, and memory usage (free/total) through \cpus\, \freemem\, and \totalmem\. Platform-specific behaviors are handled via conditional compilation: Unix systems use \uzers\ for user info and \libc\ for priorities, while Windows uses \whoami\ and registry queries for version detection. The module also exposes standard properties like \arch\, \platform\, \endianness\, \homedir\, and \tmpdir\, along with optional system metrics like \hostname\, \loadavg\, and \uptime\ when the \system\ feature is enabled.

_modules/llrt\os · high confidence

A new \string\_decoder\ module has been added, exposing a \StringDecoder\ class that handles streaming decoding of UTF-8, UTF-16LE, and Base64 encoded data. This component manages incomplete character boundaries across chunks—buffering trailing bytes until the next chunk arrives—ensuring correct decoding of multi-byte characters and surrogate pairs even when data is split mid-character.

_modules/llrt\_string\decoder · high confidence

The \libs/llrt\_encoding\ crate has been introduced to provide core text encoding capabilities. It supports encoding and decoding for UTF-8, UTF-16 (LE/BE), Hex, Base64 (including URL-safe variants), and Windows-1252. The library includes a build script to configure nightly Rust features and exposes a unified \Encoder\ enum for handling various character sets, enabling consistent string and byte transformations across the platform.

_libs/llrt\encoding · high confidence

The \llrt\_fetch\ module introduces a complete implementation of the Fetch API, exposing the \fetch\ global function along with \Request\, \Response\, \Headers\, and \FormData\ classes. This includes support for streaming request and response bodies, Subresource Integrity (SRI) verification, and configurable URL allow/deny lists for security. The implementation adheres to the Fetch Standard by enforcing Header Guards, handling redirections, and providing compliant body consumption behavior.

_modules/llrt\fetch · high confidence

The \fs\ module now exposes \chmod\ and \chmodSync\ for changing file permissions, as well as \symlink\ and \symlinkSync\ for creating symbolic links (with Windows junction support). The \open\ function now returns a \FileHandle\ object, which provides methods like \chmod\, \chown\, \read\, and \close\ for managing open files. Additionally, \mkdir\ and \mkdtemp\ now support a \mode\ option to set directory permissions, and \writeFile\ and \writeFileSync\ accept a \mode\ option to set file permissions upon creation.

_modules/llrt\fs · high confidence

This change introduces four new internal modules in the \llrt\ namespace: \llrt:codec\ exposes base64 and hex encoding/decoding functions; \llrt:qjs\ provides a \ComputeMemoryUsage\ function to inspect QuickJS runtime memory statistics; \llrt:util\ adds utility functions for terminal dimensions, loading files with specific eval options, and printing to stdout/stderr; and \llrt:xml\ implements an \XMLParser\ class for parsing XML data into JavaScript objects with configurable options for attributes, entities, and text nodes.

_llrt\core/src/modules/llrt · high confidence

The crypto module has been restructured into a modular architecture, introducing new classes for CRC32 and CRC32C checksums, as well as generic Hash and Hmac implementations supporting MD5, SHA-1, SHA-256, SHA-384, and SHA-512. This change also integrates SubtleCrypto functionality for advanced cryptographic operations and improves compatibility with Web Platform Tests (WPT) by refining encoding handling and key derivation behaviors.

_modules/llrt\crypto/src · high confidence

This change introduces the \PackageLoader\ and \PackageResolver\ components within the \llrt\_modules/src/package\ module. The loader now handles loading ES modules with caching, CommonJS modules (via \require\ wrapping), and JSON files (with proper escaping and \type: json\ attribute enforcement). The resolver implements Node.js-style module resolution, including support for \node\_modules\ lookup paths, symlink resolution, and handling of relative/absolute paths. This provides the underlying infrastructure for module loading and resolution in the runtime.

_llrt\modules/src/package · high confidence

The \libs/llrt\_compression\ crate has been introduced to provide streaming compression and decompression capabilities. It exposes modules for gzip, deflate, zlib, zstd, and brotli (with optional C or Rust backends), and includes a \StreamingDecoder\ enum in \streaming.rs\ that allows users to decompress data in chunks for gzip, deflate, zstd, and brotli encodings, handling state across multiple input buffers.

_libs/llrt\compression · high confidence

Added a new \llrt\_test\ library that provides helper functions and types for testing JavaScript modules within the QuickJS runtime. This includes utilities to create temporary files, initialize an \AsyncRuntime\ with a custom resolver, and execute test functions asynchronously or synchronously against the JS context. It also offers helpers to evaluate JS and Rust modules and invoke exported \test\ functions, streamlining the setup for integration tests.

_libs/llrt\test · high confidence

The new \llrt\_util\ module exposes the Node.js-compatible \util\ API, adding \TextEncoderStream\ and \TextDecoderStream\ for streaming text encoding/decoding, \util.styleText\ for applying ANSI color/style codes to strings, and \util.inspect\ (including \inspect.custom\) for formatted object inspection. It also provides \util.inherits\ for prototype-based class inheritance and re-exports the global \TextEncoder\ and \TextDecoder\ classes.

_modules/llrt\util · high confidence

A new shim for the AWS SDK's multi-region signature functionality has been added, enabling requests to be signed using either standard SigV4 or the newer SigV4a protocol. This change allows the application to handle signing operations across multiple AWS regions, automatically selecting the appropriate signer based on the specified signing region.

shims/@aws-sdk · high confidence

The HTTP module has been removed from the codebase, deleting the implementation files for fetch, headers, request, response, URL, and URLSearchParams. This eliminates the ability to make network requests and parse URLs within this component.

src/http · high confidence

The JavaScript-based Lambda runtime implementation located in src/js/@llrt has been removed. This deletion eliminates the previous JavaScript logic for handling Lambda initialization, runtime invocations, standard library shims, and the built-in test framework, indicating a shift away from this JS-based runtime layer.

src/js/@llrt · high confidence

The patch that previously modified the QuickJS engine to print function invocation times has been removed. This eliminates the custom instrumentation that logged execution duration for specific functions, reverting the engine's behavior to exclude these performance metrics from output.

patches · high confidence

The file system module implementation located in src/fs has been completely removed. This deletion eliminates the asynchronous JavaScript bindings for file operations including reading, writing, directory listing, and file statistics, along with their associated helper structs like Dirent and Stat.

src/fs · high confidence

The \src/encoding\ module has been removed, deleting the \encoder.rs\ implementation and the \mod.rs\ exports. This eliminates the \HexModule\, \TextEncoder\, \TextDecoder\, and \StringBuilder\ classes that were previously registered as global JavaScript objects. Users relying on these specific encoding utilities or string builder classes from this location will no longer have access to them via this module.

src/encoding · high confidence

The \src\ directory has been cleared of numerous legacy Rust source files and JavaScript/TypeScript definitions, including \allocator.rs\, \buffer.rs\, \child\_process.rs\, \console.rs\, \crypto.rs\, \events.rs\, \macros.rs\, \main.rs\, \module.rs\, \os.rs\, \path.rs\, \process.rs\, \security.rs\, \timers.rs\, \util.rs\, \llrt.d.ts\, and \stream.ts\. This change removes the internal implementations and module definitions for these components from the source tree.

src · high confidence

The \src/net\ directory, which previously contained the \NetModule\ and \Socket\/\Server\ implementations for JavaScript network APIs, has been deleted. This change removes the existing TCP/Unix socket handling code and its associated module definitions, indicating a migration away from this specific implementation.

src/net · high confidence

The \llrt\_modules\ crate now serves as the single point for assembling and registering Node.js-compatible modules. It exposes a comprehensive set of modules—including \assert\, \async\_hooks\, \buffer\, \child\_process\, \console\, \crypto\, \dgram\, \dns\, \events\, \fetch\, \fs\, \net\, \os\, \path\, \process\, \stream\_web\, \temporal\, \timers\, \tty\, \url\, \util\, and \zlib\—controlled via Cargo features. A new \ModuleBuilder\ centralizes the logic for attaching these modules and their global initializers to the runtime context, replacing the previous distributed registration approach.

_llrt\modules/src · high confidence

This change introduces new shim files under shims/@smithy to provide browser-compatible implementations of specific @smithy utilities for the LLRT runtime. It adds a base64 and hex encoding shim that delegates to the native llrt:codec module, a new abort-controller shim (noting that a global object already exists), and a comprehensive getAwsChunkedEncodingStream shim. The chunked encoding shim specifically adapts AWS S3 streaming requirements for LLRT by ensuring data is encoded to Uint8Array, buffering chunks to meet the 8192-byte minimum, computing checksums inline, and converting Node.js Readable streams to Web ReadableStreams. Additionally, the existing util-utf8 shim was moved into the @smithy directory structure.

shims/@smithy · high confidence

A new benchmark file, benchmarks/fetch-streaming.mjs, has been added to measure the performance of fetch body streaming (using getReader().read()) across LLRT, Node.js, and Bun runtimes. Additionally, the V8 benchmark suite (v8-v7) has been reformatted to modernize the code style (e.g., arrow functions, spacing) and the entry point (index.js) now imports utilities from the llrt:util module.

benchmarks · high confidence

The console module has been refactored to support distinct logging behaviors for standard environments versus AWS Lambda. In Lambda mode, console output is formatted as structured JSON logs, respects the \AWS\_LAMBDA\_LOG\_LEVEL\ environment variable for filtering, and uses a specific time format, while standard terminal output retains human-readable formatting. This change ensures compatibility with Lambda's logging infrastructure without altering the API surface for users.

_llrt\core/src/modules · high confidence

The React application now displays the release name in the main header alongside the 'LLRT React TODO' title. This is achieved by passing a new \releaseName\ prop from the server-side rendered context (via \window.releaseName\ in \index.tsx\) to the \App\ component, which renders it in the \\<h1\>\ tag. Additionally, the entry includes minor code style fixes (indentation, semicolons) and a correction of an error message in the \TodoList\ component from 'Could not create todo' to 'Could not delete todo'.

example/functions/src/react · high confidence

The example functions in \example/functions/src\ have been updated to align with modern Node.js and React standards. Several files (\api.ts\, \v3-s3.mjs\) now import Node.js built-in modules (such as \crypto\) using the \node:\ prefix, and \ssr.ts\ has switched to the Edge-compatible \react-dom/server.edge\ entry point. Additionally, the server-side rendering handler now injects the Node.js release name into the initial HTML payload, and the API handler has been simplified to return items directly without logging the full response. The legacy \v2.mjs\ file using the old AWS SDK v2 has been removed, while other v3 examples have been reformatted for consistency.

example/functions/src · high confidence

The example infrastructure has been updated to use Node.js 20 as the default runtime for Lambda functions and AWS Lambda Runtime AL2023 for LLRT-based functions, replacing the previous Node.js 18 and AL2 defaults. The build process now uses Node.js directly instead of Yarn, and the React build output is organized into a dedicated subdirectory. Additionally, the infrastructure now uses the stable AWS CDK API Gateway v2 constructs instead of the alpha versions, and the example now includes a new function demonstrating the use of a non-included AWS SDK client with LLRT.

example/infrastructure · high confidence

The \llrt\_exceptions\ module now provides a native Rust implementation of the \DOMException\ class, replacing previous eval-based or incomplete approaches. This change introduces a structured error type that exposes standard properties (\name\, \message\, \code\, \stack\) and registers 25 specific error constants (such as \INDEX\_SIZE\_ERR\, \QUOTA\_EXCEEDED\_ERR\, and \DATA\_CLONE\_ERR\) on both the constructor and prototype. By routing DOM exception throws through this native constructor lookup via primordials, the runtime ensures consistent error handling and improved compatibility with Web Platform Tests (WPT) for web APIs that rely on precise exception types.

_modules/llrt\exceptions · high confidence

This change introduces the \llrt\_url\ module, providing JavaScript-compatible \URL\ and \URLSearchParams\ classes. The implementation includes specific behavioral fixes to align with the WHATWG URL Standard, such as correctly handling opaque paths with trailing spaces, preserving file URL hosts for Windows drive letters, and ensuring blob URL origins are computed correctly. These updates improve compatibility with web standards and WPT test suites.

_modules/llrt\url · high confidence

The \modules/llrt\_console\ module now provides a dedicated implementation of the JavaScript Console API, exposing methods such as \log\, \debug\, \info\, \trace\, \error\, \warn\, \assert\, and \clear\ to the global context. This change introduces support for console-specific state management, including \count\, \countReset\, \time\, \timeLog\, and \timeEnd\ functions, which rely on internal state tracking for labels and timers. The module is registered as a standard library module, ensuring that console output is formatted and written to stdout or stderr based on the method called, thereby improving compatibility with standard console namespace expectations.

_modules/llrt\console · high confidence

The project has adopted the Apache 2.0 license, replacing the previous MIT license, and established a formal governance model with a defined Steering Committee and maintainer responsibilities. The build system has been significantly restructured: the Makefile now uses \cargo-zigbuild\ for cross-compilation, introduces multi-flavor Lambda artifacts (full, standard, and no-SDK bundles), and updates the Rust nightly toolchain. Additionally, the Web Platform Tests (WPT) are now included as a git submodule, and the AWS SDK configuration is managed via a new \sdk.cfg\ file.

(repo-wide) · high confidence

The \libs/llrt\_utils\ crate has been restructured into a modular library, introducing new capabilities for asynchronous execution and data handling. A new \llrt\_context\ crate provides \spawn\_exit\ and \spawn\_exit\_simple\ methods for managing future lifecycles and error handling, while \llrt\_hooking\ adds support for asynchronous hooks via the \LLRT\_ASYNC\_HOOKS\ environment variable. The \bytes\ module now features optimized UTF-8 validation and lossy string conversion using \simdutf8\ and \memchr\, and \array\_buffer\ exposes zero-copy, immutable shared views for efficient memory handling. Additionally, the crate includes new utilities for object inspection, structured cloning, and file system walking.

_libs/llrt\utils · high confidence

The module loading and resolution logic in \llrt\_modules/src/module\ has been restructured to support the \module.registerHooks()\ API, allowing users to intercept and override module resolution and loading via \resolve\ and \load\ hooks. This refactor introduces a new \ModuleLoader\ and \ModuleResolver\ that process these hooks, and adds an ESM module cache (\ModuleCache\) to store loaded modules, improving consistency and performance for ES module imports.

_llrt\modules/src/module · high confidence

The \shims/@aws-crypto\ directory now provides compatibility layers for AWS cryptographic utilities by re-exporting native Node.js \node:crypto\ implementations (such as \Sha256\, \Sha1\, \Crc32\, and \Crc32c\) instead of relying on the external \@aws-crypto\ packages. This change ensures that applications using these shims can leverage built-in Node.js capabilities for hashing and checksumming, resolving previous loading issues and reducing external dependency overhead.

shims/@aws-crypto · high confidence

The JSON module has been rewritten from scratch to use a custom parser (powered by simd\_json) and a custom stringifier, replacing the previous native bindings. This change introduces a new escape mechanism that correctly handles WTF-8 encoding (including lone surrogates) and significantly improves serialization performance through SWAR-based byte scanning. The new \JSON.stringify\ implementation supports replacer functions and space-based indentation, while \JSON.parse\ now falls back to the native engine only when necessary to maintain spec compliance with permissive content.

_libs/llrt\json/src · high confidence

The stream module has been restructured to support the QuickJS NG upgrade, moving from the internal \src/stream\ layout to the \modules/llrt\_stream\ crate. This change updates the codebase to use the new \llrt\_events\ and \llrt\_utils\ crates, implements \JsLifetime\ traits for \DefaultReadableStream\ and \DefaultWritableStream\, and modifies the \WriteCommand\ enum to accept \Value\ objects instead of raw byte arrays, allowing the stream to handle data conversion internally via \ObjectBytes\. Additionally, the \destroy\ method signature was simplified by removing the unused context parameter, and event emission logic was adjusted to use \this\ directly instead of \This(this)\ wrappers.

_modules/llrt\stream · high confidence

The \llrt\_tls\ module has been modularized to support multiple TLS backends (rustls with ring, aws-lc, or graviola providers, and OpenSSL) selected via mutually exclusive feature flags. This change introduces the ability to configure custom CA certificates and TLS protocol versions for client connections, and adds a \NoCertificateVerification\ verifier to allow disabling certificate validation when needed. Additionally, a new \llrt\_test\_tls\ library provides a mock TLS server for testing, complete with generated test certificates and an echo service.

_libs/llrt\_test\_tls, modules/llrt\tls · high confidence

Added a test fixture to verify that the module system correctly resolves and executes a 'require' call referencing a parent directory (using '..'). The fixture demonstrates importing the 'bar' function from the parent scope, ensuring that relative path resolution works as expected in this scenario.

fixtures/test1245 · high confidence

Added test fixture files (bar.mjs and foo.mjs) to verify that relative imports are correctly resolved, addressing a bug where relative paths were being accidentally stripped.

fixtures/test903 · medium confidence

The \llrt\_numbers\ library now provides a corrected implementation of \Number.prototype.toString()\. This change fixes incorrect string representations for zero across all radix values, as well as proper handling for NaN, Infinity, and floating-point numbers. Users will see accurate string conversions for these edge cases when calling \.toString()\ with different bases.

_libs/llrt\numbers/src · high confidence

The shims layer has been updated to align with modern AWS SDK patterns. The previous \aws-crypto\ shim, which provided custom wrappers for SHA256, SHA1, and CRC algorithms, has been removed. A new \string-hasher\ shim has been added to handle string-to-Uint8Array conversion and hashing using \@smithy/util-utf8\, improving compatibility with SDK v3. Additionally, the legacy \util-hex-encoding\ shim has been removed, indicating a shift away from the previous hex encoding implementation.

shims · high confidence

Add ESM module cache test fixture; Add Web Platform Tests (WPT) and Test262 test harnesses; Added JSON performance benchmarks; Added benchmark for path slash replacement; Added benchmark suite for number conversion functions; Added end-to-end integration tests for AWS SDK clients; Added fixtures for recursive directory listing; Added test fixtures for module resolution scenarios; Expanded test fixtures for CJS, ESM, and SDK runtime scenarios; Expanded unit test coverage for core modules and APIs; New multi-process test runner with colored output and socket-based worker communication; Removal of legacy test suite files.

This release updates the LLRT runtime to version 0.9.0-beta, introducing a comprehensive restructuring of the codebase into modular crates (e.g., \llrt\_core\, \llrt\_modules\, \llrt\_build\, \llrt\_compression\). Key dependency upgrades include \rquickjs\ to version 0.14, \simd-json\ to 0.18, \quick-xml\ to 0.42, and \rand\ to 0.10. The build system now utilizes \snmalloc-rs\ (0.7) for memory allocation on non-Windows platforms and \jiff\ (0.2) for time handling. TLS and crypto backends are configurable via features like \tls-ring\, \tls-graviola\, and \crypto-rust\, with \rustls\ updated to 0.23. Example projects and fixtures have been updated to reflect these new module structures and dependency versions.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 55 → 56 (+1.2)
• Rubric changed (rubric-2026.09.9 → rubric-2026.09.17) — scores are not directly comparable.

• Code Health 72 → 59 (-13.5)
• Architecture 82 → 56 (-26.4)
• Maturity 62 → 60 (-2.0)
• Readiness 56 → 55 (-1.5)
• Security 45 → 60 (+15.5)

• Duplicated block (11 lines × 2) (modules/llrt_fetch/src/body_helpers.rs)
• Duplicated block (12 lines × 2) (modules/llrt_crypto/src/subtle/key_algorithm.rs)
• Duplicated block (5 lines × 11) (modules/llrt_buffer/src/array_buffer_view.rs)
• Duplicated block (7 lines × 2) (modules/llrt_stream_web/src/transform/stream.rs)
• Duplicated block (7 lines × 2) (modules/llrt_stream_web/src/transform/stream.rs)
• Hotspot: build.mjs (build.mjs)
• Hotspot: libs/llrt_encoding/src/lib.rs (libs/llrt_encoding/src/lib.rs)
• Hotspot: modules/llrt_crypto/src/provider/mod.rs (modules/llrt_crypto/src/provider/mod.rs)
• Hotspot: modules/llrt_crypto/src/provider/rust/mod.rs (modules/llrt_crypto/src/provider/rust/mod.rs)
• Hotspot: modules/llrt_crypto/src/subtle/supports.rs (modules/llrt_crypto/src/subtle/supports.rs)
• Hotspot: modules/llrt_fetch/src/headers.rs (modules/llrt_fetch/src/headers.rs)
• Hotspot: modules/llrt_stream_web/src/readable/byob_reader.rs (modules/llrt_stream_web/src/readable/byob_reader.rs)
• Hotspot: modules/llrt_util/src/text_decoder.rs (modules/llrt_util/src/text_decoder.rs)
• Members sharing a duplicated core (5 members, 50+ identical tokens) (modules/llrt_fetch/src/request.rs)
• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #2
• Orphaned knowledge (modules/llrt_stream_web/src/readable/default_controller.rs)
• Orphaned knowledge (modules/llrt_stream_web/src/readable/iterator.rs)
• Orphaned knowledge (modules/llrt_stream_web/src/readable/stream/mod.rs)
• Orphaned knowledge (modules/llrt_stream_web/src/readable/stream/tee.rs)
• …and 3 more

• Ambiguous naming and signature overlap in Encoder. encode and encode_to_string appear to perform similar encoding operations, but encode_to_string explicitly includes a lossy parameter while encode does not. It is unclear if encode defaults to lossy or lossless, or if it returns a different type (e.g., Vec<u8> vs String).
• ClassTooLong: WritableStreamDefaultController (modules/llrt_stream_web/src/writable/default_controller.rs)
• Duplicate Console implementation. There are two distinct Console types in different modules (llrt_core.modules.console and llrt_console) with identical method signatures. This suggests redundant code or a namespace collision that could confuse users about which console instance is active.
• Duplicated block (10 lines × 2) (modules/llrt_crypto/src/subtle/key_algorithm.rs)
• Duplicated block (11 lines × 2) (modules/llrt_fetch/src/body_helpers.rs)
• Duplicated block (14 lines × 2) (modules/llrt_stream_web/src/readable/stream/tee.rs)
• Duplicated block (5 lines × 11) (modules/llrt_buffer/src/array_buffer_view.rs)
• Duplicated block (6 lines × 2) (modules/llrt_util/src/text_encoder_stream.rs)
• Duplicated block (8 lines × 2) (modules/llrt_util/src/text_decoder_stream.rs)
• Fragmented error throwing methods. There are four distinct methods for throwing errors from a Result, differentiated only by the type of error or message handling. This forces users to choose the correct method based on subtle distinctions rather than a single, flexible API.
• Hotspot: modules/llrt_fetch/src/fetch.rs (modules/llrt_fetch/src/fetch.rs)
• Inconsistent return types for decoder constructors across compression modules. Most return specific typed decoders (GzDecoder, DeflateDecoder, etc.), while zstd and brotli return a generic Result, and the streaming module uses a constructor pattern with a string encoding argument instead of a generic reader. This forces consumers to handle different initialization patterns and return types depending on the algorithm.
• Inconsistent return types for hex and base64 encoding. bytes_to_hex and bytes_to_b64 return u8 (likely a bug or internal representation), while bytes_to_hex_string and bytes_to_b64_string return String. This creates confusion about which function to use for actual string output.
• Inconsistent return types for string extraction. get_coerced_string_bytes returns u8 (likely a pointer or handle), while get_string_bytes returns a Result. This inconsistency makes it difficult to handle errors uniformly when extracting string data from values.
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Members sharing a duplicated core (5 members, 50+ identical tokens) (modules/llrt_fetch/src/request.rs)
• …and 52 more

• 49 commits — 38 feature/other, 11 fixes

• (root) — 20 commits
• (repo) — 19 commits
• modules/llrt_fetch — 3 commits
• modules/llrt_buffer — 2 commits
• libs/llrt_utils — 1 commit
• llrt_core/src — 1 commit
• modules/llrt_stream_web — 1 commit
• modules/llrt_util — 1 commit
• tests/wpt — 1 commit

• fix: Merge pull request #1778 from nabetti1720/fix/web-streams
• fix: Merge pull request #1787 from nabetti1720/fix/improve-wpt
• fix: Merge pull request #1788 from nabetti1720/fix/encoding-streams
• fix: Run cargo fmt on the rquickjs 0.14 API fixes
• fix: chore: Revert the exclusion conditions for the fetch WPT
• fix: fix(encoding,util): Fix encoding streams behavior and share WTF-8 encoding logic
• fix: fix(encoding,util): use primordials and atomics in TextEncoderStream
• fix: fix(webstreams): Fix Web Streams conformance and structuredClone transfer handling
• fix: fix(wpt): improve harness compatibility and narrow Fetch skips
• fix: fix: correct wpt_errors.txt baseline for pqc-enabled WPT run
• fix: fix: update wpt_errors.txt for intl402's effect on 5 unrelated tests
• change: Avoid extra copy in lossy UTF-8 conversion via Cow-based bytes_to_utf8_string_lossy
• change: Bump rquickjs to 0.14.0 and adapt to its breaking API changes
• change: Enable pqc by default in make test and check-wpt
• change: Make Intl/Temporal opt-in via a new intl402 feature
• change: Make pqc default-on again, keep it toggleable
• change: Merge pull request #1771 from awslabs/chore/reduce-binary-size
• change: Merge pull request #1775 from nabetti1720/chore/skip-historical-test
• change: Merge pull request #1776 from nabetti1720/feat/impl-teststream
• change: Merge pull request #1777 from nabetti1720/chore/skip-invalid-url-cases
• …and 29 more

• Containers 1 added · 0 removed · contexts 0 added · 0 removed · edges 0 added · 0 removed

• cli:%name.PascalCased%.template

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

awslabs/llrt was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.