Fetch: free QuickJS response body chain after reading

Previously, Response.text(), json() and arrayBuffer() joined the body
chain into a new block of the engine pool and left both the chain
nodes and the joined copy in the pool.  The memory was released only
with the engine, so with js_context_reuse every response body read
accumulated in the pool, unaccounted by the context reuse memory
check.

Now, the chain is destroyed after the body is read.  For text() the
string is created with qjs_string_create_chb(), and for json() the
joined copy is freed after parsing.

The issue was introduced in b7f76b71 (0.9.1).

QuickJS: free joined string with chain pool in qjs_string_create_chb()

Previously, the joined string was freed with the JSContext passed as
the pool argument of the chain free function.  This only worked for
chains initialized with NJS_CHB_CTX_INIT(), where the pool is the
context itself.

Now, the chain pool is used, so the function works with chains using
any allocator.  No functional changes for existing callers.

QuickJS: fix fs callback return value leak

Previously, the value returned by a callback passed to the callback
flavor of fs functions was never freed.  The value stayed referenced
until the runtime was freed, triggering the
"list_empty(&rt->gc_obj_list)" assertion in JS_FreeRuntime() in debug
builds and accumulating in the runtime with js_context_reuse.

The issue was introduced in 1f8f9992 (0.8.9).

Modules: fix subrequest response body leak in QuickJS

Previously, alternating r.responseText and r.responseBuffer on a
subrequest reply overwrote the cached req->response_body value
without freeing it.  The value stayed referenced until the runtime
was freed, triggering the "list_empty(&rt->gc_obj_list)" assertion
in JS_FreeRuntime() in debug builds and accumulating in the runtime
with js_context_reuse.

The fix is to free the cached value before replacing it, as is
already done for r.requestText and r.requestBuffer.

The issue was introduced in 201b1276 (0.8.6).

WebCrypto: fix AES-CTR out-of-bounds write on empty input

Previously, the AES-CTR block count helper computed the number of
blocks as "1 + (dend - 1) / dsor".  This underflows for a zero-length
input, so njs_ceil_div(0, 16) and qjs_ceiling_div(0, 16) returned
2^28 instead of 0.

The fix is to use the zero-safe "(dend + dsor - 1) / dsor" form.

The njs engine code was introduced in 7b2b7612 (0.7.0) and the
QuickJS counterpart in 75ca26f8 (0.8.10).

Parser: fix reference atom IDs on big-endian systems

Previously, references to local variables and function arguments
failed with ReferenceError on 64-bit big-endian systems.  The parser
overwrote a uintptr_t reference atom ID through the overlapping
uint32_t value member, replacing the high half of the ID.

The issue was introduced in 9ff881e3 (1.0.2), which moved the
reference atom ID to the start of the parser node union.

Now, reference and value payloads share a uint32_t atom ID at the same
offset, initialized in the corresponding parser paths.
This removes the redundant value-member write and makes atom ID access
independent of byte order without increasing the parser node size.

This fixes #1143.

CI: split CLI and nginx checks into parallel jobs

Previously, check-pr runs all build configurations sequentially, so
an early failure prevents later configurations from being tested.

Split CLI checks into matrix configurations and nginx checks
into separate njs, QuickJS, and QuickJS-NG matrix jobs.  Disable
fail-fast and use fresh build directories without make clean.

Preserve the nginx module and SSL configure flags, sanitizer and
debug-memory settings, QuickJS-NG version, checkout action revision,
test commands, and failed-test retries.

Make engine selection explicit: njs jobs no longer auto-detect
QuickJS-NG, and the QuickJS CLI build uses an explicit library.

CI: add big-endian build and tests

Previously, GitHub Actions did not test the built-in engine on
big-endian systems, leaving byte-order regressions undetected.

Modules: fix incremental engine build dependencies

Existing archives prevent the nested make from checking engine source
changes.  QuickJS builds also omit libnjs.a and engine headers from
the module dependencies.

Changes to engine sources are now picked up by nginx make without
rerunning configure or removing the existing libraries.

Modules: isolate engine builds from the standalone CLI

nginx and the CLI share build artifacts and configuration.  Building
nginx replaces the CLI Makefile, while rebuilding the CLI can leave
nginx linking libraries compiled with incompatible flags.

Building nginx no longer changes the CLI configuration or libraries.
Rebuilding the CLI no longer breaks subsequent nginx builds.

Configure: fix pkg-config paths for absolute build directories

The generated njs.pc prepends the source directory to an absolute
build directory, producing invalid include and library paths.

Preserve absolute build paths and resolve only relative ones against
the source directory.  This also supports engine builds embedded in
nginx without changing the standalone CLI configuration.

Configure: allow explicit QuickJS library selection

Independent configure runs can select different QuickJS libraries.
Allow callers to pass the selected headers and linker options without
falling back to another library.

Configure: add configure mode without a source-root Makefile

Configuring a separate build directory still replaces the source-root
Makefile and redirects subsequent CLI builds.  Allow embedded builds
to leave the standalone build entry point unchanged.

WebCrypto: return false for wrong-length ECDSA signatures

ECDSA signatures of an invalid length cause verify() to throw instead
of returning false.  njs passes an empty DER signature to
EVP_PKEY_verify(), while QuickJS rejects the length during conversion.

The njs behavior dates back to 86c202c7 (0.7.7); QuickJS rejects these
signatures since 75ca26f8 (0.8.10).

Treat a length mismatch as an invalid signature, as required by
WebCrypto ECDSA Verify, while preserving diagnostics for conversion
failures.  Test all three supported curves with invalid lengths and
a valid signature.

WebCrypto: clear OpenSSL errors after a signature mismatch

Previously, crypto.subtle.verify(false) could leave errors for an
unrelated TLS handshake or WebCrypto operation.

The fix is to clear the queue when returning false, while retaining
diagnostics for operation failures.

This fixes #1141.

WebCrypto: fix algorithm availability in nginx modules

Previously, configure probes disabled Ed25519, X25519, and AES-KW in
nginx modules because the engine is configured with --no-openssl,
although WebCrypto uses nginx's OpenSSL and these algorithms were
available.

The fix is to detect 25519 APIs from OpenSSL headers and look up AES-KW
ciphers at runtime, removing the dependency on engine configuration
and direct references to wrap functions absent in some OpenSSL flavors.

This fixes #1139.

Modules: treat expired shared dict entries as absent

Expired entries are hidden by read APIs but can still be found by
write operations.  replace() can revive an expired entry, delete()
can report that it existed, and incr() can use its old value instead
of init.  Without an explicit timeout, incr() can return a value that
a subsequent get() cannot retrieve.

Use a common write-side lookup to remove expired entries and handle
them as missing in both engines.  incr() then creates a new entry
with init plus delta and the directive or explicit timeout.

Also return false instead of undefined when QuickJS delete() is
called for a missing key.

Modules: fix shared dict state JSON separators

When saving a shared dict zone with timeout=, expired entries are
skipped.  A comma is appended whenever another tree node follows a live
entry, even if all remaining nodes are expired.  This can leave a
trailing comma in the state file, making it invalid JSON.

Insert commas before live entries only when a previous entry has been
rendered, so skipped entries do not affect the separators.

Modules: initialize shared dict state entry expiration

When a shared dict state entry omits the optional expire field, its
expiration remains uninitialized.  In a zone with timeout=, the entry
can be discarded as expired or loaded with an arbitrary expiration
instead of receiving the zone timeout.

Initialize expiration to zero before parsing the entry so an omitted
expire field is treated like an explicit zero.  The entry then receives
the zone timeout and the state file is scheduled for saving.

Modules: limit waiting for shared dict state save on exit

If a worker dies while saving a shared dict zone state, the writing
flag remains set in shared memory and survives reloads.  Workers
with unsaved changes then receive NGX_AGAIN on every attempt and
keep rearming the save timer, so they never finish graceful shutdown.

Limit how long an exiting worker waits for an outstanding save to
60 seconds since the save started.  The shared writing flag is not
cleared and the writer is not interrupted, so a slow save is not
disturbed.  Running workers keep waiting as before.

Modules: track shared dict state changes per worker

With frequent changes to a shared dict zone using state=, old workers
can remain in shutting down after a configuration reload and continue
consuming resources even though their changes have already been included
in another worker's snapshot.  The shared dirty flag cannot distinguish
those changes from subsequent changes made by new workers, so old
workers can keep rearming their save timers while competing for writes.

Replace the shared dirty flag with a write_id counter and record its
value locally in each worker on mutation.  Advance the shared counter
after preparing a snapshot so workers whose changes are covered can
stop retrying regardless of subsequent mutations.  On I/O failure, the
writer records the advanced counter locally to retain responsibility
for retrying the save.

Modules: limit shared dict state save frequency

Saving shared dict zone content to file is scheduled with a maximum
rate of one write per second in each worker.  The total rate can be
larger by a factor of the number of running workers.

Postpone a zone save if the previous save was less than one second
ago, using a shared timestamp to limit the rate across all workers.

Modules: fix shared dict state save error ordering

On save failure, writing is cleared before dirty is restored.  Another
worker can observe a clean, idle zone and stop retrying.  If the failed
writer is exiting, it also stops retrying and the changes remain unsaved.

Set dirty first and add a memory barrier before clearing writing to
publish the need for another save before releasing the writer.

Modules: fixed shared dict state save stuck forever

The "dirty" and "writing" flags of a shared dict were bit fields of
the same word.  ngx_js_dict_save() clears "writing" without holding
the lock, while set(), incr(), delete() and clear() set "dirty" under
the write lock in other workers.  The two read-modify-write operations
could interleave and leave "writing" set for good.

After that, every save attempt returned NGX_AGAIN: the state file was
never written again, and the save timer, re-armed every second and not
cancelable, prevented any worker of the zone from finishing a graceful
shutdown, regardless of worker_shutdown_timeout.  The flag lives in
shared memory, so it survived reloads.

The fix is to store the flags in separate words.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This fixes #1136.

Modules: abort shared dict state save on close failure

A close failure may report a delayed write error.  Do not rename the
temporary file over the previous state file in this case.  Invalidate
the descriptor before cleanup to avoid closing it twice.

Modules: initialize shared dict state file before allocation

Initialize the state file descriptor before allocating chain links and
buffers.  Allocation failures otherwise reach cleanup with an
uninitialized descriptor and may close an unrelated file.

Modules: preserve shared dict entries on failed updates

Shared dictionary updates temporarily remove timeout entries from the
expiration rbtree to prevent eviction while allocating a replacement.
ngx_rbtree_delete() clears the removed node key, so the failure path
reinserted the entry with a zero expiration and made its old value appear
expired.

Factor the shared-memory update into an engine-independent helper and
restore the previous expiration when allocation fails.  Keep value
conversion in the njs and QuickJS wrappers.

Version bump

Version 1.0.2

XML: return complete attribute values

Previously, $attr$ returned undefined for attributes containing entity
references, while $attrs returned only the first text fragment. libxml2
canonicalization expands the complete attribute value, creating an
interpretation difference for signed XML consumers.

Use xmlNodeGetContent() for both getters in the njs and QuickJS backends.
This preserves the existing explicit-attribute lookup and makes the
JavaScript value agree with canonicalization.

XML: release parser context after parsing

Previously, XML parser contexts were retained with their parsed documents.
When parsing failed in the njs engine, no cleanup was registered, leaking
the context and allowing repeated malformed XML input to grow memory usage
in long-lived NGINX worker processes.

The fix is to limit parser contexts to the parse operation and release
them immediately after parsing or error reporting. The VM cleanup now owns
only the parsed document.

VM: report import of a module removed after failed compilation

A module whose compilation fails is removed from the cache, but another
module compiled earlier in the same cycle may still import it.  Executing
such an import returned an error without setting an exception, so the
shell reported an unrelated TypeError.

Throw "Cannot load module" instead, and add a shell test for a cyclic
dependency of a module that fails to compile.

VM: preserve dependency code after failed module compilation

Commit fd54d52d freed all bytecode added after the parent module's
compilation checkpoint, including successfully compiled dependencies.
Those dependencies remain cached, so a later import in the same VM
executes freed bytecode.  This is reachable in the interactive shell
and in embedders that continue after a compilation error.

The fix is to remove eager bytecode cleanup while retaining removal of
the failed module from the cache so subsequent loads can retry.  Keep
the removed module and its name in the VM pool because cyclic
dependencies and code metadata can still reference them.  These
allocations are released when the VM is destroyed.

Add a shell regression test that retries a failed parent import and then
executes its cached dependency.

XML: preserve node methods with matching children

QuickJS exposes child elements as own properties, so a child named
like an XMLNode method hides the method on its prototype. Let methods
take precedence over bare child names, as on the njs engine. Keep the
child accessible through $tag$name and avoid deleting it when deleting
the method name.

Cover collisions for all XMLNode methods and prototype changes.

XML: add namespace-aware node accessors

The existing $attr$name and $tag$name accessors compare local names
only, so x:ID and ID, or x:Issuer and Issuer, are indistinguishable.

The new XMLNode methods getAttributeNS(namespaceURI, localName) and
getChildNS(namespaceURI, localName) match both the namespace URI and
the local name.

QuickJS: fix XML value leaks in "in" checks

Previously, property existence checks such as "'$attr$a' in node",
"'to' in node", or "'$tags$to' in node" created the property value and
never released it when no property descriptor was requested.  A leaked
XMLNode also held a reference to its document, so the whole document
was never freed.

Also, qjs_xml_node_make() and qjs_xml_attr_make() incremented the
document reference count before creating the object, so a failed
JS_NewObjectClass() left the document permanently referenced.

The fix is to free the value when no descriptor is requested and to
take the document reference only after the object is created.

Tests: tighten shell test checks

Previously, Expect treated timeouts as successful matches, and EOF
passed even if the REPL exited abnormally.  Some checks could match
the input echo alone, while completion checks required a bell that
varies between libedit versions.

The fix is to fail on timeouts, premature EOF, and abnormal exit;
check the result and prompt for Unicode input and guard against a
repeated promise rejection.  Send Unicode as ASCII escapes to work
around libedit 3.1.snap20150325-2.12 on SLES 15 SP7, which reports
a character count where the readline callback expects a byte count.

QuickJS: stop tracking rejections during final report

Converting the rejection reason to a log string may reject another
promise.  Disable the tracker before reporting so new rejections
cannot leave references in the request context after its list has
been drained.

Shell: fix unhandled rejection report in QuickJS

Previously, njs_engine_qjs_unhandled_rejection() kept a pointer to
the rejected promise list while converting the first rejection reason
to a string.  The conversion may call user JavaScript code, which can
reject more promises and cause the list to be reallocated.  After that,
the old pointer was used together with the new item count to free the
promise and reason values, which caused out-of-bounds reads and invalid
frees.

The fix is to take a reference to the first reason and free the list
before conversion, so that rejections created during conversion are
tracked in a new list.

The test/js/promise_rejection_tracker_recursive.t.js test is no longer
skipped for the QuickJS engine.

Promise: do not track handled rejections with no list

Previously, when a handled promise was reported and the rejected promise
list was NULL, the trackers fell through and added it as unhandled.  In
the interactive shell, handling a promise after its rejection had been
reported caused another, false unhandled rejection.  The QuickJS nginx
module could do the same while formatting a rejection reason.

The fix is to return for every handled notification, removing the promise
from the list only when the list exists.  Apply this to both engines in the
shell and nginx module.

Zlib: copy QJS dictionaries before conversion

Copy dictionary bytes before converting other JavaScript arguments so their
backing storage cannot be invalidated during zlib setup.

Zlib: validate NJS chunk sizes

Types: declare Buffer swap64 correctly

XML: guard against content allocation failure

Report a memory error when libxml cannot allocate node content instead of
passing a NULL pointer to the string conversion path.

Core: avoid float padding pointer wraparound

Skip padding when the formatted float is wider than its requested field.
This prevents unsigned width subtraction from forming an invalid pointer.

FS: convert QJS numeric modes safely

CHB: avoid overflow when enforcing the chain limit

Check the requested size against the remaining chain capacity instead of
adding it to the current total.  This prevents the size check from wrapping
and bypassing the configured chain limit.

Buffer: free QJS buffers on conversion failures

qjs_buffer_from_string() and qjs_buffer_create() leaked the newly
allocated buffer when qjs_typed_array_data() or string decoding failed.

Also check the JS_ToCStringLen() result in qjs_buffer_from_string(), so
an allocation failure is not followed by a NULL pointer dereference.

Buffer: reject oversized QJS alloc() and concat() sizes

Buffer.alloc() and Buffer.concat() converted sizes with JS_ToUint32(),
which wraps values modulo 2^32: Buffer.alloc(2 ** 32 + 16) returned a
16-byte buffer.  Use JS_ToIndex() instead, so these sizes throw a
RangeError.

In Buffer.concat(), the total length of the list could also overflow the
32-bit accumulator.  Keep it in 64 bits and check it against
QJS_BUFFER_MAX_LENGTH.  The overflow now throws a RangeError instead of a
TypeError, as in Node.js.

Buffer: convert QJS array-like lengths

Convert array-like lengths through checked floating-point conversion before
applying ToLength semantics.  This avoids reading float-tagged QuickJS
numbers through the integer accessor.

The length is kept as a 64-bit value and passed to qjs_buffer_alloc()
unchanged, so an oversized length is rejected before any allocation
instead of being truncated.

Buffer: check QJS allocation sizes before narrowing

Take a 64-bit size in qjs_buffer_alloc() and reject sizes above
QJS_BUFFER_MAX_LENGTH before converting them.  Previously, a caller
holding a wider size had to narrow it to size_t first, which truncated
it silently on 32-bit platforms.

Tests: improve compatibility with Node.js

Accept RangeError from Buffer.concat() revalidation.
Remove oversized Buffer.from() cases that make Node.js allocate 4 GiB.
Expect empty Buffer.fill() values to fail.
Use fs.rm() for recursive removal under Node.js.
Check non-enumerable fs.Stats date properties directly.
Use distinct readlink fixtures for concurrently run test cases.

Known failures for js_test --binary=node are limited to module
resolution in import and XML module tests for v25.2.1 on linux.

FS: fix typo during BytesRead prototype instantiation

Promise: reject empty any inputs

Reject Promise.any() with an AggregateError when the input contains no
promises, as required by the promise combinator semantics.

Tests: update Test262 and allow unhandled rejections

Track the current Test262 revision and let the Test262 runner follow the
suite's handling of rejected promises instead of imposing a separate policy.

Tests: rename local JavaScript test target

Previously, the local JavaScript tests, including WebCrypto tests, were
run by the test262 target, while the official TC39 Test262 suite was
run by njs_test262_test.

The fix is to rename the local test target to js_test and make test262
run the official suite.  The engine-specific local targets are renamed
to js_test_njs and js_test_quickjs.

Webcrypto: clean up ECDSA conversion failures

While here, also report ECDSA signature encoding failures.

Webcrypto: clean up AES-CTR allocation failures

Webcrypto: use constant-time HMAC verification

Webcrypto: validate EC JWK curve type

Memory pool: cached slot index in a page

Previously, freeing a chunk searched the pool slots linearly to map the
chunk size back to its slot.

The fix is to keep the slot index in the page descriptor, in a byte
that was unused.

Memory pool: free page counter in a cluster

Previously, releasing a page walked all pages of its cluster to test
whether the whole cluster had become free.

The fix is to keep the number of free pages in the cluster block.

Memory pool: junk filling only in debug builds

Previously, every freed chunk was overwritten with 0x5A in all builds,
adding a memset to each njs_mp_free() call.

The fix is to keep the junk filling under NJS_DEBUG.  Release builds no
longer poison freed chunks; nothing ever inspected the pattern.

Memory pool: compare block addresses without overflow

Previously, the rbtree comparator converted the difference between two
addresses to intptr_t.  On 32-bit systems, addresses that differ by at
least 2 GiB could produce an incorrect ordering and prevent a later block
lookup from finding its cluster.

The fix is to compare the addresses directly and return -1, 0, or 1.
This fixes a pool that remained non-empty after all allocations were freed
in the x86 memory pool test.

Tests: memory pool unit test

Previously, the memory pool was covered only indirectly by a single
flathsh configuration.

The fix is to add direct coverage for allocation, reuse, alignment, and
mixed allocation sizes across valid pool configurations.  The test uses a
smaller workload in the regular matrix and a full stress workload in the
ASan job.

Library tests are included in the standard test target.  The added ASan
configuration omits debug memory so that the complete test target and the
pool page and cluster paths are exercised.  The library-test dependency
rule is also corrected for the new test executable.

Avoid undefined shifts in MurmurHash2

Previously, input bytes were promoted to signed int before being shifted
into a hash word.  A byte with its high bit set could make the 24-bit
shift undefined.

The fix is to cast input bytes to uint32_t before shifting.  This
preserves the hash result and avoids undefined behavior under UBSan.

Fetch: limit decoded chunked response bodies

Previously, fetch allowed decoded chunked bodies to reach ten times
max_response_body_size.

The fix is to apply max_response_body_size to decoded chunks.

Fetch: avoid reusing framed response connections

Previously, fetch cached fixed-length responses with bytes after their
declared body. Bodyless and chunked responses with such bytes did not
complete correctly.

The fix is to close a framed response connection with unconsumed bytes
instead of adding it to the keepalive cache.

Fetch: honor response body framing

Previously, fetch inferred body completion from Content-Length alone. This
completed close-delimited responses before EOF and conflated framing modes.

The fix is to track body framing explicitly, reject unsupported 1xx
responses, and exempt 204 and 304 representation lengths from body limits.

Fetch: validate response framing

Previously, fetch accepted conflicting Content-Length fields and a response
with both Transfer-Encoding and Content-Length.

The fix is to reject ambiguous framing to avoid interpreting the response
body inconsistently.

Fetch: validate response body size

Previously, a negative max_response_body_size could make a close-delimited
response appear as a successful empty body.

The fix is to reject the invalid option while parsing fetch arguments.

Modules: fix js_periodic worker affinity parsing

Previously, worker_affinity parsing reused the directive option index. This
skipped options after worker_affinity in HTTP and stream configurations.

The fix is to use a separate index while parsing the affinity mask.

Fetch: fix QJS numeric conversion

Previously, QuickJS wrote an int64_t through ngx_int_t fetch fields.

The fix is to use the checked native conversion helper so ILP32 builds
cannot overwrite adjacent state.

TypedArray: coerce length argument once on buffer construction

Previously, njs_typed_array_alloc() passed the length argument through
njs_value_to_index() twice, before and after the detached-buffer check,
and kept only the second result.  The argument's valueOf() was invoked
twice, which is observable.

The fix is to remove the second conversion.

Test262: add a native runner for the official suite

CI: test njs with UBSan

Build and run the base njs test suite with UndefinedBehaviorSanitizer.

Align opaque values

Opaque values are cast to njs_value_t pointers by the public API.  Match
njs_value_t alignment while retaining the four uint32_t filler fields.

UndefinedBehaviorSanitizer reports unaligned njs_value_t accesses.

CHB: avoid incompatible function pointer calls

Use adapters for memory pool allocators instead of casting their function
pointers to the generic chain buffer callback types.

Casting does not make an indirect call through an incompatible function
pointer type valid.  UndefinedBehaviorSanitizer reports these calls.

Date: avoid out-of-range conversion in timezone offset

The timezone offset helper converted a double to int64_t before checking
whether it was representable.  Check the range first.

UndefinedBehaviorSanitizer reports the out-of-range conversion.

Date: fix UTC setters

The Date setters always converted their result as local time.  Use the
setter's UTC flag instead.

Remove the intermediate range check in njs_make_date().  TimeClip already
checks the result after local-to-UTC conversion, which can move a value
across the valid time range boundary.

Fix the conversion of a property key to an array index

Previously, a double was converted to uint32_t before its range was tested,
so a property key that is NaN, negative or larger than 2^31 made the
conversion undefined.  UndefinedBehaviorSanitizer reported it for every VM
creation, where an environment variable name is atomized.

The fix is to test the range first and to share one njs_number_is_atom_index()
helper between the four places that repeated the pattern.

VM: remove dead code introduced in fd54d52de557

The lambda structure is allocated at the end of module compilation,
and if the allocation fails, lambda is NULL.  Since nothing fails after
a successful allocation, lambda is always NULL on the failed path.

Found by Coverity (CID 1701143).

Types: align XML declarations with API

Previously, XML declarations did not accurately model XML node property
values, mutation deletion semantics, or canonicalization aliases.

The fix is to align XMLDoc and XMLNode types with the current API and
add TypeScript coverage for the supported operations.

QuickJS: align XML tag assignment with njs

Previously, assigning null or undefined to node.$tag$name removed
matching children in QuickJS, while the njs engine rejected every
assignment.

The fix is to distinguish property assignment from deletion in the
QuickJS exotic property handler. Assignments now throw TypeError in both
engines, while delete node.$tag$name remains supported.

XML: retain QuickJS tag sources during copy

XML: mutate XML nodes in place

Previously, text and structural mutators copied and replaced the receiver's
libxml2 node.  Existing XMLNode wrappers continued to point at the detached
original, while subsequent lookups returned the replacement.  Wrappers for
children preserved by the operation likewise pointed into the detached old
subtree.  In QuickJS, mutating the detached receiver again could dereference
the NULL result of xmlReplaceNode().

The fix is to modify the existing receiver's child list directly.  Existing
wrappers and subsequent lookups therefore continue to refer to the same
libxml2 node.  Removed child lists remain readable until the QuickJS
document or njs VM is destroyed.  A node is considered live only when
following its parent links reaches its xmlDoc.  Replacement children and
cleanup records are prepared before the live tree is modified.

Changed behaviour:
- A removed child has an undefined $parent, while its descendants retain
  their internal parent links.
- Mutating or canonicalizing a removed XMLNode throws TypeError.
- Text and attribute values must be primitive strings; null and undefined
  retain their deletion semantics.
- C14N rejects an excluding node from another document or a detached list.
- addChild() and $tags reject namespace-bearing or unsupported source trees
  before mutation.
- Named $tags assignments are consistently rejected by both engines.

While here, use an unsigned QuickJS $tags array length, support assigning
$tags on an empty njs XMLNode, and make deleting $tags from an empty node
a no-op.

XML: create text nodes before mutation

Previously, text updates encoded content manually and then passed it to
libxml2. This duplicated libxml2 escaping rules and allocated the
encoded buffer before creating the text node.

The fix is to create a libxml2 text node from the unencoded value before
replacing the copied node's children. libxml2 now owns escaping, and a
failure leaves the original XML tree unchanged.

Generator: bound value preservation analysis

Value-preservation analysis recursively examines the upcoming expression before
the generator decides whether mutable-slot operands need temporary copies.
Deeply nested binary expressions and arrays could therefore exhaust the native
stack.

Move the generator-specific predicate out of the parser API and limit its
recursive walk to 128 levels.  At the limit, conservatively require
preservation: an extra move is safe, whereas missing a deeper side effect can
change evaluation semantics.

VM: clean up failed module compilation

Module compilation publishes a provisional module before parsing to support
recursive loading.  Remove that module on failure and release code records,
line maps, and code buffers produced after the compilation checkpoint so a
failed load does not poison subsequent lookups.

VM: clean up failed AST serialization

Parser: release non-global semantic state

Allocate non-global scopes, local variables, variable tree nodes, references,
and declaration arrays from the compilation pool.  The global scope and its
symbol table remain persistent for runtime lookup and later compilation.

Build closure-index arrays temporarily, then copy the finalized indexes into
VM-owned storage referenced by each lambda.  Preserve declaration-origin type
without retaining pointers to released block scopes.

Generator: release temporary compilation memory

Use the parser invocation pool for generator stack entries, copied contexts,
blocks, jump patches, index caches, and traversal scratch.  Nested function
generators share the same temporary pool, while generated code and runtime
metadata remain in the VM pool.

Parser: release temporary compilation memory

Create a pool for each parser invocation and allocate parser nodes, array-item
storage, continuations, preread tokens, and active labels from it.  Destroy the
pool after generation and on parser or generator failures.

Keep atoms, lambdas, regexp patterns, scopes, variables, bytecode, and runtime
constants in the VM pool.  Clear persistent scope AST roots before releasing
the temporary pool.

Parser: shrink variable flags

Parser: store statement labels as atom identifiers

Parser: use compact active labels

Parser: reduce variable reference payload

Store the atom identifier and resolved variable directly in parser nodes and
move the undefined-reference flag into the common node flags.  This removes the
separately allocated reference object and helps reduce parser nodes to the
64-byte memory-pool class.

Parser: compact array literal elements

The generic object-property lowering used six parser nodes and several
generator continuations for each array element.  Store array values and indexes
in compact records and emit a dedicated immediate-index initializer instead.

This also avoids interning numeric element indexes and generates elements in
source order with constant continuation depth.  Keep template backing arrays
flat because template concatenation requires contiguous storage.

Fix large array literal initialization

Large literals switch to slow arrays above the fast-array capacity limit, but
the previous initialization path left their indexed values unset.  Initialize
slow arrays directly so literals above 32760 elements preserve their contents.

Tests: add parser stress benchmarks

Add generated workloads for large array literals, declarations, references,
closures, and labels.  These tests are intended to expose catastrophic parser
scaling and compare compilation changes; source construction and Function()
compilation are both included in the measured interval.