Generator: derive property swap from node.

Previously, the "in" operator swap flag was relayed through generator
context.  This broke when call-end handlers switched to
njs_generator_stack_pop(NULL), which released the context before the
swap was read in njs_generate_3addr_operation_end().

The fix derives the swap directly from the node token type
(NJS_TOKEN_IN), eliminating the context relay.

Parser: isolate optional preserve wrapper details.

Introduce NJS_TOKEN_OPTIONAL_PRESERVE for optional-chain preserve nodes
instead of reusing OBJECT_VALUE, so OBJECT_VALUE remains strictly an
object/array literal structure token.

Route optional-preserve, object-value, and optional method-preserve
access through dedicated helper functions with narrow assertions,
removing direct u.object/left/right access from general parser and
generator paths.

No behavior change.

Preserve "this" for grouped optional calls.

Previously, grouped optional calls like (o?.m)() resolved the callee
through the optional chain but dispatched via plain FUNCTION_CALL,
losing the original receiver.

The fix stores the receiver on the call node so the upcoming
call-argument reorder can emit METHOD_FRAME with an explicit "this".
Call-expression setup and optional-chain preserve lookup are routed
through named helpers with generator-side validation.

Parser: lower property consumers to PROPERTY_REF.

Previously, the generator inferred reference intent from raw AST shape.

Now the parser marks the relevant property node as PROPERTY_REF before
building METHOD_CALL, assignment, or update nodes, and the generator
accepts both PROPERTY and PROPERTY_REF via
njs_generate_is_property_lvalue().

Introduce NJS_TOKEN_PROPERTY_REF as an explicit parser-side marker for
property accesses that carry reference semantics (assignment targets,
delete operands, increment/decrement, method-call receivers).

Version bump.

Version 0.9.6.

WebCrypto: validate JWK key type against algorithm in importKey().

Previously, importKey() did not verify that the JWK "kty" field
matched the requested algorithm.  For example, importing a JWK with
kty "oct" (symmetric) while specifying an asymmetric algorithm like
ECDH caused a SEGV in EVP_PKEY_free() during cleanup.  This happened
because the symmetric key data written into the union's "raw" member
overlapped with the "pkey" pointer, corrupting it.

The fix validates kty before calling any JWK import function:
    - "RSA" is only accepted for RSA-OAEP, RSA-PSS, RSASSA-PKCS1-v1_5
    - "EC" is only accepted for ECDSA, ECDH
    - "oct" is only accepted for HMAC, AES-GCM, AES-CTR, AES-CBC

Found by Akshay Jain (akshaythe@gmail.com).

Fixed string offset map corruption in scope values hash.

The issue was introduced in e7caa46d (0.9.5).  When compile-time
UTF-8 string constants were copied into the values hash in
njs_scope_value_index(), the string data layout was calculated
incorrectly: the map offset did not account for the null terminator
added in e7caa46d, the "size" variable was overwritten corrupting
the subsequent memcpy, and the offset map was never initialized
to zero.

This caused SEGV/SIGBUS crashes for any multi-byte UTF-8 string
constant with more than 32 characters when accessing a character
at index >= 32 (e.g. via .replace() or bracket notation).  The bug
only manifested when the string byte size was 4-byte aligned, as
otherwise alignment padding absorbed the missing byte.

The fix factors out njs_string_data_size() and njs_string_data_init()
helpers shared by njs_string_alloc() and njs_scope_value_index(),
eliminating the duplicated layout logic that caused the divergence.

Found by Akshay Jain (akshaythe@gmail.com).

Fixed logical assignment short-circuit with non-writable properties.

When the logical condition was already satisfied (e.g., falsy for &&=,
truthy for ||=, non-nullish for ??=), the short-circuit jump landed on
the property set instruction instead of past it.  This caused spurious
TypeErrors for non-writable, getter-only, and non-extensible property
targets even though no assignment should occur.

This fixes logical assignment introduced in 1a64ba68.
This change fixes 9 more tests in test262.

Added support for ??= operator.

Added support for ||= and &&= logical assignment operators.

Unlike regular compound assignments (+=, -=), these operators
short-circuit: the RHS is not evaluated and no assignment occurs
if the logical condition is already satisfied.

Implement optional chaining.

Generator: factor property lvalue setup.

Generator: factor property assignment reads.

Generator: factor test jump emission.

Generator: factor property assignment helpers.

Parser: factor right-link pop helper.

Parser: refactor call argument setup.

CI: added extra debug flags and enabled ASAN for njs basic tests.

Shell: fixed interactive mode detection for piped stdin.

Previously, libedit callback API (rl_callback_read_char) was used for
interactive input processing.  Unlike the blocking readline() API, the
callback interface does not work correctly when stdin is a pipe: input
characters are silently dropped and the line handler is never invoked.

The issue was introduced in 4988565c6ea7 (0.8.0).

The fix is to check isatty(STDIN_FILENO) and fall back to the file
processing mode when stdin is not a terminal.

Replace per-VM indexed array for modules with hash-based lookup.

Previously, evaluated module values were cached in a separate
vm->modules array indexed by module->index assigned at compile time.
This required keeping the array size in sync with shared->module_items,
which was error-prone in interactive mode where new modules could be
compiled across commands.

Instead, store evaluated module values directly in the per-VM module
copy already maintained by vm->modules_hash.  This unifies the import
and require() caching paths and eliminates the index-based array along
with module->index and shared->module_items fields.

This fixes `make shell_test` when configured with --debug=YES.

Modules: suppressed slab log_nomem for evict shared dict zones.

When evict is enabled, memory allocation failures are expected
and handled by evicting old entries.  The slab allocator's
"no memory" log messages are now suppressed for such zones.

Modules: fixed expire field truncation in shared dict state files.

The njs_sprintf buffer for the expire field was sized for 10-digit
numbers, but current millisecond timestamps are 13 digits. This caused
silent truncation, making entries appear expired on a full restart.

The issue has been present since eca03622 (0.9.1), which introduced
the shared dictionary state file support.

Fixed heap-buffer-overflow in atom hash caused by Symbol().

Previously, there was a key_hash collision between strings and
symbols in the atom hash table that led to use of uninitialized memory
and desynchronization of vm->atom_id_generator.

In the atom hash, string entries used djb_hash(content) as key_hash
while symbol entries used raw atom_id. Since djb_hash produces arbitrary
uint32_t values and atom_ids grow monotonically from NJS_ATOM_SIZE,
these spaces overlapped. When a symbol's atom_id matched an existing
string's djb_hash, njs_flathsh_insert() invoked the test function which
read uninitialized fhq.key fields (the function expected string data,
but the caller never initialized it for symbols). Additionally,
atom_id_generator was incremented before the insert, so on failure the
counter diverged from the actual element count, causing subsequent
njs_atom_to_value() calls to read out of bounds.

The fix is to partition the key_hash space using bit 31.

Found by OSS-Fuzz.

Refactored atom hash into orthogonal find and add operations.

Previously, njs_atom_find_or_add() and njs_atom_find_or_add_string()
duplicated the lookup logic and coupled find with insert. Splitting
them into njs_atom_find() and njs_atom_add() separates concerns:
find does a pure lookup with raw bytes, add inserts a pre-built value.

Align SyntaxError reporting with other JS engines.

Previously, "in <file>:<file>" was a part of the error message. Now
the file name is reported as "stack" property.

This fixes #1005 issue on Github.

Attach JS stack trace for exceptions thrown by C code.

This fixes #1019 issue on Github.

Modules: fixed stack attach for native fetch exceptions for qjs.

JS_ThrowInternalError() captures backtrace outside of JS call, resulting
in empty "stack" string.  Later, while unwinding, is_backtrace_needed()
returns false because "stack" property exists.

JS_NewError() does not try to attach stack, as a result a stack is
attached later during unwinding.

Attach stack in error constructors.

This aligns njs with QuickJS and most other JS engines.

Mark anonymous and unknown functions with <>.

To separate from normal functions with the same name.

Make Error.stack faster.

Previously, error.stack reported full names for native function (for
example Array.prototype.map -> map), but it was achieved by iteration
through a global object which is slow.

The fix is to report only function name at hand, this loses a bit
of verbosity but make it ~100 times faster.

make benchmark
before
        ...
exception.stack: 38.421µs, 26027 times/s
exception.native.stack: 226.711µs, 4410 times/s
after
        ...
exception.stack: 1.239µs, 807356 times/s
exception.native.stack: 2.419µs, 413339 times/s

Fixed stack attaching by stringifying function addresses in place.

This fixed Error stack output on CLI.

Fixed PTR macro compatibility with newer BFD library.

The deprecated PTR macro was removed in recent versions of binutils.
Replaced with (void **) cast.

Fixed build on MacOS after 220b9b03 (0.9.5).

MacOS linker does not support -Wl,-E as it exports binary
symbols by default.

This fixes #1015 on Github.

auto/cc: Use portable/POSIX 'command -v' instead of 'which'

'which' is not a portable utility as it is not specified by POSIX. Since
auto/cc is already a shell script, use the more direct and portable
'command' builtin to detect $CC.

There are two bugs linked here. The first one is a downstream report of
this issue. The second one is more general information on why 'which'
usage is an issue and should be avoided.

Bug: https://bugs.gentoo.org/969288
Bug: https://bugs.gentoo.org/646588
Signed-off-by: Zurab Kvachadze <zurabid2016@gmail.com>

Shell: fixed fuzzer harness to add NULL termination.

Guided-by: Dmitry Volyntsev <xeioex@nginx.com>
Signed-off-by: Ze Sheng <OwenSanzas@gmail.com>
Co-Authored-By: Claude Code <noreply@anthropic.com>

Making unit tests less brittle when libpcre2 changes.

This fixes #1011 issue on Github.

Version bump.

 Version 0.9.5.

QuickJS: added native module support in CLI.

QuickJS: added native module support.

Added "js_load_http_native_module" and "js_load_stream_native_module"
main nginx.conf level directives. The directives load a dynamic
library. For security reason it is only allowed in the main context.
Later, JS code may import modules loaded with these directives
with standard import syntax.

example.conf:
    ...
    js_load_http_native_module /path/to/lib.so;
    js_load_http_native_module /path/to/lib2.so as lib2;

    http {
        js_import main.js;
...

main.js:
    import * as lib from 'lib.so';
    import * as lib2 from 'lib2';
    ...

See quickjs.h for the complete QuickJS API reference and
nginx/t/js_native_module.t for a working example.

This closes #968 feature request on Github.

Modules: extracted config-time merging into separate function.

This introduces ngx_js_merge_conftime_loc_conf() to handle merging
of configuration-time properties.

Normally ngx_js_merge_conf() does all the default value initialization
for child location configurations.

There is a special case for global "http" or "stream" configuration
where the parent configuration needs to be initialized (so it can be
reused by server configurations if no additional directives were
defined in them). But parent configurations are not initialized by
ngx_js_merge_conf().

Most of the ngx_js_loc_conf_t values are only used at runtime, so
only configuration-time values need to be merged in the parent.
The runtime values will be provided from the appropriate
ngx_js_loc_conf_t during request processing.

Previously, configuration-time merging was done inline. Extracting
it into a dedicated function simplifies adding new configuration-time
properties.

QuickJS: fixed js_body_filter with multiple chunks.

Previously, last_key atoms was freed too early. Also, js_body_filter.t
is modified to ensure js_body_filter sees multiple data chains to catch
the issue.

HTTP: improved r.subrequest() error handling after d34fcb0 (0.8.5).

This reverts code changes introduced in d34fcb0. To fix the original
problem JS errors are not propagated as nginx errors in r.subrequest().

This also fixes a problem of a lost write event when the njs handler
making r.subrequest() is called from a lua handler as a subrequest:

nginx.conf:
    ...
    location = /subrequest {
        access_by_lua_file scripts/subrequest.lua;
proxy_pass  http://localhost:8080/pass;
    }

    location = /nested/subrequest {
        internal;
        js_content main.getToken;
    }

scripts/subrequest.lua:
    local res = ngx.location.capture('/nested/subrequest')
    ngx.log(ngx.STDERR, "Subrequest  status: " .. res.status)

    if res.status ~= 200 then
      ngx.log(ngx.STDERR, "Subrequest failed with status: " .. res.status)
      return nil
    end

    return res.body

main.js:
    async function getToken(r) {
        var reply = await r.subrequest('/api/auth');
        r.error("reply.status :: " + reply.status);

        var status = reply.status;
        r.return(status, "{"result":"OK!"}");
    }

    export default { getToken };

$ curl localhost:8080/subrequest

error.log (before the fix):
    ...
    *1 http js event finalize rc: 0
    *1 post event 0000B4BCA64C5FF0
    *1 http log handler
    *1 http request count:3 blk:0
    timer delta: 0
    posted event 0000B4BCA64C5FF0
    *1 delete posted event 0000B4BCA64C5FF0
    *1 http run request: "/subrequest?"
    *1 access phase: 11
    *1 lua access handler, uri:"/subrequest" c:2
    *1 lua run write event handler: timedout:0, ready:1, writing_raw_req_socket:0
    *1 useless lua write event handler <<<---

error.log (after the fix):
    ...
    *1 http js event finalize rc: 0
    *1 http posted request: "/nested/subrequest?"
    *1 http js content write event handler
    *1 http js content rc: 0
    *1 http finalize request: 0, "/nested/subrequest?" a:0, c:3
    *1 lua run post subrequest handler, rc:0 c:3
    *1 http log handler
    *1 http wake parent request: "/subrequest?"
    *1 http posted request: "/subrequest?"
    *1 access phase: 11
    *1 lua access handler, uri:"/subrequest" c:2
    *1 lua run subrequests done, resuming lua thread

Types: fixed CipherAlgorithm and Pbkdf2Params

Configure: respecting user provided CFLAGS.

See https://www.gnu.org/prep/standards/html_node/Command-Variables.html
and discussion in #990 issue on Github.

Configure: added option to configure position independent code flag.

HTTP: fixed buffer_type inheritance in if blocks.

Previously, when js_body_filter was used inside an if block that
evaluated to true, the data parameter received Buffer type instead
of the expected String type. This happened because buffer_type field
in ngx_http_js_loc_conf_t was not properly initialized, causing the
configuration merge to fail when nginx created a new location context
for if blocks.

This fixes #999 issue on Github.

Fixed js_body_filter when data is not in memory.

Previously, when upstream data was delivered from nginx cache
js_body_filter was not able to process it correctly. In particular,
it was treated as a chain of empty buffers.

The fix is to set r->filter_need_in_memory flag, which ensures
that ngx_http_core_module reads the data into memory before
js_body_filter sees it.

This fixes #992 issue on Github.

FS: fixed path restoration in fs.mkdir() and friends on error.

FS: fixed fs.mkdir() and friends.

Fixed missed allocation check in promise code.

Found by Coverity (CID 1646931, 1646932).

XML: fixed XMLNode update.

XML: fixed XMLAttr object.

Pointer to xmlAttr to which XMLAttr used to point might become invalid
when the parent XMLNode was modified.

The fix is to hold a pointer to xmlNode.

Removed non-compliant Buffer.prototype.length.

Fixed ArrayBuffer with detached buffers.

Added missing detached array checks.

Preserving strings are zero-terminated in njs_string_truncate().

This is linked to changes introduced in e7caa46.

CI: cancel stale workflows.

CI: using meson and pkg-config for QuickJS-NG.

Added pkg-config discovery for QuickJS-NG.

QuickJS: fixed compatibility issue with QuickJS-NG 0.11.0.

Modules: removed extra not needed QuickJS checks.

Using printing and parsing library from QuickJS.

- Number.prototype.toString(radix)
    Improved accuracy for edge cases
    Reimplemented using njs_dtoa2() with JS_DTOA_FORMAT_FREE | JS_DTOA_EXP_DISABLED
- Number.prototype.toFixed(frac)
    Reimplemented using njs_dtoa2() with JS_DTOA_FORMAT_FIXED
    Removed old njs_fixed_dtoa() implementation
- Number.prototype.toPrecision(prec)
    Reimplemented using njs_dtoa2() with precision format
    Removed old njs_dtoa_precision() implementation
- Number.prototype.toExponential(frac)
    Reimplemented using njs_dtoa2() with exponential format
    Removed old njs_dtoa_exponential() implementation
- parseInt()
    Simplified parsing implementation
    Removed custom njs_number_radix_parse() helper
- parseFloat()
    Simplified parsing implementation

Removed custom njs_number_bin_parse(), njs_number_oct_parse(),
njs_number_dec_parse() and njs_strtod.c module Better handling of large
numbers and denormal floats and invalid inputs.

Ensuring string values are zero-terminated.

This helps when some code requires a string value to be zero-terminated
to avoid copying and adding \0 byte.

It adds small overhead (less than 3% in worst case of an empty string
value) to existing sizeof(njs_value_t) + sizeof(njs_string_t) = 32.

Fixed --debug=YES build after d4cedc0.

Added Symbol.toPrimitive to Date and Symbol prototypes.

Added Object.hasOwn().

Fixed Object prototype methods according to the spec.

Added promises execution after njs.on('exit', ..) hook.

Modules: improved handling of results of async handlers.

Previously, r.setReturnValue() had to be used when returning a value from async js_set handler.

async function hash(r) {
    let hash = await crypto.subtle.digest('SHA-512', r.headersIn.host);
    r.setReturnValue(Buffer.from(hash).toString('hex'));
}

Now r.setReturnValue() is not needed:

async function hash(r) {
    let hash = await crypto.subtle.digest('SHA-512', r.headersIn.host);
    return Buffer.from(hash).toString('hex');
}

Also added promise handling in global qjs code.

Added API to work with promises.

Version bump.

Fetch: making sure catch handler is executed asynchronously.

Version 0.9.4.

Fetch: added forward proxy support with HTTPS tunneling.

Supports Basic authentication via Proxy-Authorization header.

- js_fetch_proxy - configures forward proxy URL. It takes proxy URL
    as a parameter. The URL may optionally contain user and password.
     Parameter value can contain variables. If value is empty,
     forward proxy is disabled.

example.conf:
...
  http {
      js_import main.js;

      server {
          listen 8080;

          resolver   127.0.0.1:5353;

          location /api {
              js_fetch_proxy http://user:pass@proxy.example.com:3128;
              js_content main.fetch_handler;
          }
      }
  }

This implements #956 feature request on Github.

Fetch: added default user agent.

Fetch: introduced ngx_js_chain_to_buf() helper function.

Fetch: refactored request building logic into separate function.

Fetch: introduced port and protocol helper macros.

Tests: making sure dns stub in js_fetch_https.t resolves only known hosts.

Fetch: simplified ngx_js_http_resolve().

Modules: added error handling when logging a js exception string.

QuickJS: fixed r.subrequest() to a location with JS handler.

Previously, when a subrequest location had a JS handler, an object of a
subrequest JS context was provided as an argument to a parent contexts.
This may cause all sorts of problems due to incorrect reference
counting.

After this change in bellard/quickjs@42eb2795 the bug became apparent.

Version bump.

Version 0.9.3.

Fixed heap-use-after-free in js_set handler.

The issue was introduced in commit 04f6dfb (0.9.2) by moving VM
destruction from the pool cleanup handler to the http cleanup handler.

Moving VM destruction to the http cleanup handler broke js_set variable
usage during the log phase, because these variables are called after the
VM has been destroyed.

The fix is to move VM destruction back to the pool cleanup handler, but
use a temporary pool while njs.on('exit', ...) is executing.

This fixes #969 and #971 issues on Github.

Module: fixed heap-use-after-free while module loading.

Making a copy of file argument because the engine may outlive
current ngx_cycle.

The bug became visible since 283282f (0.8.8).

Modules: fixed memory leak when module loading failed.

Fixed potential heap-use-after-free in njs_vm_compile_module().

Passing a local copy of name argument to njs_parser_init().

Version bump.

Readme: updated hero graphic.

Version 0.9.2.

Modules: fixed building when http_ssl and stream_ssl unavailable.

This fixes issue introduced in 7b3c8a66.

Fixed build with gcc-15 and -O3.

build/src/njs_object.dep -MT build/src/njs_object.o \ src/njs_object.c
In file included from src/njs_main.h:18, from src/njs_object.c:8: In
function ‘njs_utf8_copy’, inlined from ‘njs_object_enumerate_string’ at
src/njs_object.c:769:21: src/njs_utf8.h:115:20: error: writing 1 byte
into a region of size 0 [-Werror=stringop-overflow=] 115 |
*dst++ = c; |             ~~~~~~~^~~ src/njs_object.c: In function
‘njs_object_enumerate_string’: src/njs_object.c:719:24: note: at offset
4 into destination object ‘buf’ of size 4 719 |     u_char
buf[4], *c; |                        ^~~ In function ‘njs_utf8_copy’,
inlined from ‘njs_object_enumerate_string’ at src/njs_object.c:769:21:
src/njs_utf8.h:115:20: error: writing 1 byte into a region of size 0
[-Werror=stringop-overflow=]

GCC-15 does not know that the loop in njs_utf8_copy() is bounded
because the input is a valid UTF-8 here.

This fixes #967 issue on Github.

Fetch: added keepalive support for ngx.fetch() API.

This closes #957 feature request on Github.

Fetch: added parsing of HTTP version.

Modules: simplified access to nginx values from JS engines.

QuickJS: added njs.on('exit') API support.

This closes #955 issue on Github.

QuickJS: removed extra copy of body argument in ngx.fetch().