NQ1 R4: original V8 constructor/test backend and native namespace ownership

Status: conductor-selected prospective source architecture candidate for the SAME unfinished NQ1 unit at draft1694. Different whole architecture review/GO remains required before positive code. This document supersedes R3's compressed compiler/cache semantic substitution; all R3 source captures, derivations, failed bounds, metadata decoder failures, commits and immutable packets remain retained. No product parser, constructor, test, compiler, native backend or runtime grant was executed or authored by this decision.

Selected actor and exact original source

The selected backend is the ORIGINAL Node-carried V8 constructor/test implementation in the same Core runtime, with its genuine CommonEnvironmentSetup isolate/environment, original owning thread, Locker/IsolateScope and already-selected jitless flags. Node22.23.2 original commit aa4c77582be995286fc6e00aaf530dc7ade102a9/tree cee5f56eb6b8b6b8e300419196dc90e8c7abd64b retains V8 12.4.254.21, ICU78.2/Unicode17 source/build association. Original optimization, parser, Unicode, atom/Irregexp interpreter, cache widths/misses/eviction, interrupt/failure order and post-peephole code object remain the backend's actual operations. Public engines>=22 is unchanged; reference-source/build/runtime compatibility and each genuine source-owner approval remain explicit primary CE2 obligations.

Primary owns the actual runtime producer: retain setup isolate/environment at original CommonEnvironmentSetup construction before linked binding/environment loading and borrow on its actual original Core thread. Neither a supplied Isolate pointer, NAPI tuple, version row, hash nor callback grants that object/source association. Companion process B cannot borrow this Core process A pointer. Source/runtime eligibility and real resource acquisition remain pending; the source choice is not a runtime grant.

Actual backend join must preserve constructor and test

The primary exact invocation candidate is a source-private immutable same-image native-owned JS closure, built once from an approved native source constant in the actual Core setup context, performing original new RegExp(pattern,flags).test(subject); syntax-only uses the original unflagged constructor. Native strong handles retain original closure/source/context/intrinsic identities. No supplied function callback, caller bytes as code, NewWithBacktrackLimit or replacement matcher is selected. Actual context/intrinsic drift invalidates native admission custody instead of forcing invariants; a parser result never supplies source approval. Complete owner/hook implementation remains pending whole review. Original api.cc blobf9ce798dc29e1d48c6cb4de84cbcea9ddae0106b shows RegExp::New calling JSRegExp::New, while RegExp::Exec calls RegExpUtils::RegExpExec, fetching exec and entering JavaScript. That Exec API is not automatically the actual RegExp.prototype.test path. Constructor/prototype lookup, fast/slow test path, return/exception and result allocations must be mapped to the exact original caller; do not replace test with Exec plus an invented boolean or silently add an array/capture allocation.

Native NQ still owns full original staged ZIP/gzip/TAR, strict/ordered JSON and Number/serialization, complete manifest/catalogue/owner-policy validation and accepted inventory canonicalization. Original JSON-created pattern/subject string width, substring/internalization/cache lineage, fatal UTF8 and role-specific BOM handling require genuine V8 string/source owners. The direct configuration/path nonstream UTF8 width relations from R3 remain source evidence; arbitrary JSON-created strings are not silently normalized to fresh one-byte strings. Policy has nine source pattern slots, but original runtime cache capacity and code versions are not capped at nine. Constructors/tests occur only at the original reached call and in original failure order.

With the ORIGINAL backend, actual GetCode allocates the original ByteArray and Assemble calls the real Isolate::IncreaseTotalRegexpCodeGenerated. Exact isolate.cc blobc2cc0458bb644ca362e848a50935c458621475fa adds actual code->Size(cage_base). R3's proposed compressed-port derived counter/history substitution is not selected. Genuine current counters, original objects and cache generations remain actual original runtime owners and observations, never receipt/source authority.

Unchanged domains and concrete physical proof obligations

The landed Blueprint37 instance128MiB bound is the PARSER/STREAM copy domain, not a universal ordinary Node image/RSS cap. The conductor's earlier blanket interpretation is explicitly superseded. All attributable original-backend parser/stream/compiler/cache/heap/string/body/IO resources, active and retained history, must fit that SAME inherited domain; pre-existing, foreign or hidden parser scratch is not exempt. Ordinary image/startup resources require a separate finite SAME-owner classification under original CE1/Blueprint rules, not an unspecified free pool. No cap amendment or second parser pool is selected.

The primary whole owner map must join real native preallocation hooks with original Core/V8 heap/pages, Zone/bytecode growth, interpreter backtrack stack, ICU/string/control allocation, Node/external buffers, source index/windows, transport framing, native metadata and complete retained failure/archive/effect history. SourceMemberIndex96 raw4541088 and namespace/read banks raw37680/37024 remain explicit source layout terms before rounding/control. Original stack64MiB capacity, append-before-overflow observation, original stack growth and actual object/header geometry remain obligations; no smaller stack or instruction cap substitutes for the proof. The original backend choice alone proves neither those hooks nor a whole peak.

Initial Core READ_STAGE retains genuine authenticated ordinary23 result windows/sequence/EOF into its source-owned raw snapshot, without transferring the companion handle. The source actor phase preserves declared raw up to10MiB before owner archive rejection; failed expanded inventory up to262144*100=26214400 can remain held through original matching and later aggregate quota. Editable-string u matching is byte-guarded at at most512; configuration path iu is an accepted original decoded one-byte path at most240, while content imu follows whole fatal decoding and can have the original8MiB subject. These distinct source phases remain explicit, not an early quota or acceptance narrowing.

Qualified namespace byte phase remains OriginalBytesEligible -> CapsuleOriginalBytesTransferred -> MetadataOnly. Actual capsule append/readback, mandatory archive/effect handoff and zero genuine payload borrowers must establish physical bank end before the Windows67195929 whole signer backing. Immutable path/mode/count/SHA and original source/catalogue/stage/capsule/archive observations remain retained; old byte getters become unavailable. finishEOF, logical return, GC reachability, pointer clearing or a decremented counter does not supply physical retirement. Source asset/importer/custody association remains the primary private boundary; no positive data wrapper is an approval.

Review and prospective verification boundary

NQ-R01..R19 remain declarative UNRUN regressions. Their original compiler/cache/width/interrupt/failure/stack observations now apply to the selected actual V8 backend and complete native owner joins; compressed representation experiments remain retained counterevidence rather than selected execution. The next whole candidate must bind this exact primary invocation to the complete original string/heap/context/source lifetime join, real physical owner hooks and all original lifetimes/rounding/control/phase counts plus complete native parser semantics, full source/raw Git/failures/canonical relations and fresh entire byte inventory. No incremental packet is represented as a completed product or a whole SOURCE GO. Primary constructor/engine/caller integration, different final entire product SOURCE GO and NEW authentic execution admission remain required.

Selected compressed original stage and checked entry replay candidate

Conductor selects this material prospective R4/CE2 PRECODE candidate for the ONE whole architecture. This selects no implementation, existing positive interface, semantic equivalence, physical fit or resource grant. The immutable Core-owned original compressed snapshot remains held with genuine ordinary23 sequence/window/final receipt/EOF and stage/source association. It is not a companion handle, catalogue approval, a reconstructed ZIP or an approved hash. Original offsets, declared counts, modes, CRC and accepted original SHA observations are data-level views under that owner. No new spool/resource or public field is inferred.

The frozen original zip.ts decoder establishes a complete validation pass before validateAuthoredEntries: raw/declaration quota; complete expected-path validation; EOCD/count/central extent; then, in original central-record order, central flags/method/mode/name and fatal UTF8/NFC membership/duplicate checks, matching local header/name/body bounds, expanded/ratio quotas, stored-length equality, copy reservation, inflate with exact compressed-byte consumption, actual expanded length and CRC, SHA observation and record insertion. Only after all entries does it sort local regions and require contiguous coverage from zero through centralStart, exact final central cursor and complete membership. A later malformed record, CRC or local gap must therefore reject before any earlier configuration RegExp constructor/test. A lazy policy-first cursor would violate that order and is not the candidate.

A prospective validation pass can expose one exact expanded-entry owner at a time while retaining immutable record/index observations and original compressed backing, but it must preserve cumulative source quotas and their order even after payload retirement. It cannot replace the original reserve-before-inflate failure chronology with a smaller hidden reservation or regard CRC/SHA as permission to release unjoined IO/archive borrowers. The original reference materializes all entry Buffers before authoring; replacing that representation changes allocation and ownership chronology. Whether this is an eligible native source-owned representation under the existing physical-owner contract requires whole review. It is not established by the arithmetic reduction.

Only after complete ZIP validation may an entry be replayed from its held original compressed range for authoring or capsule emission. Every replay requires checked original source bounds, exact inflater termination/consumed compressed count, original expanded length and CRC and the genuine original byte relationship; retained SHA is an observation for correlation, not byte/source authority. Stored entries borrow the same immutable original range, while deflated entries need a physically charged inflater state/window and actual expanded-entry backing. Replay must not change dictionary, concatenate streams, accept trailing bytes, silently truncate, or regenerate canonical bytes. The native RFC1951 implementation, exact replay interruption and error mapping, physical allocations and end observations remain unresolved source obligations.

Re-inflation is additional work absent from the original eager authoring representation. The candidate therefore cannot assert unchanged deadline/resource/failure behavior merely because output bytes match. Any failed original source read, allocation, inflate or custody loss on a later replay must retain actual failed IO/owners and follow the already applicable private failure boundary; no new public parser result or fabricated receipt is selected. Admission end checks belong to genuine original work transitions. Extra per-byte interruption must not be inserted into original V8 SKIP_UNTIL loops or reorder its original POP_BT interrupt behavior. A complete replay work/end proof, including repeated policy/serialization/digest/emission uses, remains required before this alternative can be selected.

The original authoring order remains: complete inventory/total quota; manifest-size guard; authored manifest, baseline manifest and provenance strict parsing; exact manifest canonical bytes; full service manifest validation; provenance identity/origin; ordered manifest comparison and reached editable rules; then baseline-order entries. Each reached config entry adds raw byte count, performs whole fatal UTF8 decoding before name iu and short-circuited value imu tests, and only after that loop applies aggregate config quota. Provenance canonical comparison and final id/version follow. Failed expanded26214400 inputs may reach matching before that aggregate rejection. No early aggregate config check or narrower active-subject limit is introduced.

The phase ledger for review must include compressed snapshot plus authenticated transport/history controls, immutable native entry/source indices, independently held catalogue/baseline/policy/provenance/manifest owners, current entry inflater state/window/output, genuine original V8 primitive String and JSON graphs, original backend compiler/code/cache/stack/ICU/capture/history, and any simultaneous canonical comparison/digest/output windows. A replay cursor is not proof that only one owner is live: baseline equality, manifest comparison, configuration body, two-byte decode and original cache/heap histories can overlap. Complete64MiB valid capsule inventory and inherited parser128MiB support remain required. Before Windows signer, every replay/capsule/archive borrower must physically end in the consumable namespace phase; metadata retains the original associations while expanded byte getters become unavailable. No fit, SOURCE GO or positive lease/factory follows from this alternative.

Exact source-owned joins and retained replay history

The primary proposed data/owner joins are NativeOriginalStageSnapshot -> OriginalStageInflateValidationLease -> producer-owned endValidatedEntryBytes -> NativeStageEntryReplayLease. These are private prospective source ABI names, not positive definitions. Snapshot construction consumes ACTUAL ordinary23 Core sequence/frame/native peer/MAC/read results/final receipt and complete raw snapshot/sourceEOF; no companion handle, supplied callback or caller path substitutes. stageObservation retains original root/slot/generation/declaration/source and byte borrower links even after a payload bank ends.

validateComplete must finish the entire original central-order pass, actual per-entry inflate/length/CRC/SHA and final name membership/duplicate/local-region contiguity/central cursor checks before a completed validation lease is available to authoring. endValidatedEntryBytes is producer-owned and unavailable until immutable original member metadata is committed, all actual consumer/native IO/error-output and mandatory O2 effect/archive readback borrowers end, and the actual bank is observed retired or transferred under the SAME owner. Partial validation, a digest match, a returned method, GC or an empty borrower counter without original evidence is insufficient. Failed entry/readback/native end histories remain held and invalidate positive use.

A replay lease requires that COMPLETED validation association and exact original ordinal/offset/count/mode/path/CRC/SHA member relation. It retains the SAME compressed original object plus actual reader/inflater/output-bank owners. Before and after replay it checks genuine original identity, complete original source SHA, true source EOF and immutable member/source custody; matching SHA neither establishes identity nor replaces original byte IO. A check requiring full-source reread is real extra read/hash/window/work/history cost. The source must specify whether it borrows an independently still-valid original custody observation or actually rereads; it cannot claim an unperformed whole reread. No renewal, newly approved reconstructed archive, hidden spool or foreign storage results.

replayOriginalEntry(offset, maximum, originalDeadline) yields immutable owner-rooted byte windows. Its true inflater/source boundaries, consumed compressed extent, original expanded count/CRC/member byte relationship and actual failures remain explicit. It cannot yield mutable Node plan Buffers and call them transferred. The original V8 codec may copy/internalize those bytes into distinct genuine String/JSON/heap objects; the entry bank remains held while any native codec/backend/archive borrower remains, and actual copied runtime allocations remain separately charged after bank end. Subsequent entries reuse backing only after genuine source-native last-borrower/physical-end observations. Configuration name short-circuit still follows complete current body fatal decode, so an unreached value RegExp does not excuse its already allocated body.

The repeat ledger covers actual initial validation plus every later authoring comparison/manifest/provenance/canonical serialization/staged digest/materialization digest/capsule append/readback use, all compressed source reads and before/after identity/hash/EOF checks, native inflater states/windows, current expanded bytes, decoded original String/JSON and actual V8 compiler/cache/backtrack/capture history, and O2 archive/effect/failure/terminal IO. Number of uses must come from the complete reached original callgraph, including failure paths; neither entry count nor an absolute time end alone bounds attempts or retained controls. Original source-specific interruption and public error order remain preserved obligations. Resource loss or a later replay fault cannot silently reuse first-pass success as a receipt.

The domain ledger is unchanged: upload/raw stage snapshot10MiB with owner ZIP262144 rejection in its original phase; accepted inventory64MiB; declared-compressed stage reservation aggregate167772160; capsule aggregate1073741824; parser/stream resident134217728. The160MiB belongs to the original16-stage declared-compressed reservation paragraph (16*10MiB), not a universal observer archive ceiling, individual upload, expansion or second resident pool. Original observer/source-build evidence backing separately needs genuine finite permission/capacity. All attributable V8/cache/compiler/string/body/window/IO/history and controls overlap in the inherited parser domain; ordinary image/startup has separately finite SAME-owner classification. SOURCE-01 carrier backing/build is a separate governed source invocation and cannot silently borrow stage raw aggregate or capsule allowances. Original immutable work ends apply to all repeated NQ work; source building does not derive an end or permission from importer approval.

The selected private admin import40s starts at actual original native entry before argument, ROOT or HTTPS handling and covers its queue/authentication/import; it never samples a renewed end for validation/replay. Existing request10s/40s and native peer/provider work retain their own already-held original starts/absolute ends and actual clock associations. Endpoint/source actor joins remain primary-owned and whole-review pending; no namespace method manufactures a duration or changes the ordinary stage read/RegExp failure chronology.

Exact original test/capture subject retention

Retained original builtin source now pins regexp-test.tq blob4e3bcb906c66c2fd9615477173d88330b463b5fe, regexp.tq9c426ebd7b8d39e21f178f7835084c532157fa9f, regexp-exec.tq813dcd6baa20db9037f3b99b0ef0e5b367e0257b, builtins-regexp-gen.cc7f54ca5aee7184f4e48e0f02db6b7b99b238fc2f and builtins-regexp.ccea4776a4bb08a8fbfa0aead3f4d4b7838f099adc, with exact original path/mode/Git framing/SHA custody in R4-ORIGINAL-REGEXP-BUILTIN-SOURCE-RELATIONS.json. These are inert original source captures, not compiler or matcher execution.

RegExpPrototypeTest performs ToString_Inline then permissive fast-RegExp identity checks. Its fast path calls RegExpPrototypeExecBodyWithoutResultFast and returns boolean; the slow path performs original exec property retrieval/call/result validation. The fast body does not construct a JSRegExpResult, but still borrows original context RegExpMatchInfo and dispatches the actual atom/Irregexp/runtime path. Permissive checks include original map/positive-Smi lastIndex/species protector/prototype and exec identity. A native-owned closure alone does not prove those predicates or license forcing the fast path.

Original gen.cc successful execution sets RegExpMatchInfo lastSubject and lastInput to the original subject and stores capture registers. It may call original runtime when captures exceed the static offsets vector, subject cannot become direct, code is uninitialized, retry occurs or match-info capacity is too small. Original regexp.cc482959a4e680cacda8449c250aac22fa175f94c2 SetLastMatchInfo grows through its original runtime path and retains subject/input; atom success retains them as well. A false test does not overwrite them with the current subject. Actual capture capacity, runtime retries, remembered String owners and original strong context/heap references belong in the parser/history ledger even though the public result is boolean. Entry-window retirement cannot erase those V8 allocations or rewrite match info to manufacture physical end.

Reachability must use the original policy outcome: a forbidden configuration-name or value match immediately denies, so one successful large configuration match cannot proceed to a later configuration in that same validation. Nevertheless its original subject may remain retained after failure in the actual same runtime context, overlapping later call/current decoded bodies unless the genuine original owning context/object lifetime ends. Whether subsequent native entry borrows that context or a distinct original runtime generation must come from the primary actual source lifecycle; no within-call double-large-success example or zero-history assumption establishes a bound. The original backend's legitimate context/cache history is retained and physically accounted without adding a reset, synthetic GC, narrower pattern or new context to alter reference semantics.

Selected prospective private original interpreter stack repair

The conductor selects segmented alternativeC as a material PRIVATE original backend source proposal, requiring different whole architecture review before implementation. The original Node/V8 source closure remains retained unchanged; the future source-qualified reference/build association must identify the exact separately approved private interpreter patch and its full source/build dependency association. It cannot claim unmodified original binary equality or treat this selection as approval of an unspecified patch. The native-owned constructor/test closure and original full pattern language, original bytecode/counters/interrupt/CallOrigin/result behavior remain the candidate reference; exact changed failure/allocation observations below require review.

Exact original regexp-interpreter.cc blob31fe5039bdb82477bd5078f7d2ace9252b5cabec BacktrackStack::push emplaces its generic integer before checking existing kMaxSize. Original SmallVector blobedaab3a7a6b42f27fd5b91844655501b637f70bf Grow rounds to doubled capacity, allocates new storage, calls FatalOOM on null, copies, and only then deallocates old dynamic storage. Thus within-limit32-to64MiB growth has96MiB payload concurrently, and first growth beyond64MiB has192MiB payload before the original maximum check. These are conditional exact source allocation facts, not evidence that every accepted owner pattern reaches either state. Prior64MiB-plus-one-cell subtotal did not include original geometric growth and is not the original backend physical bound. All prior source failures and rejected replacement proofs remain retained.

The selected geometry is at most1024 payload segments of65536 bytes, each16384 integer cells on the exact qualified32-bit ValueT ABI, with fixed1024*24=24576 raw-byte directory. Each directory row retains native extent ordinal/generation plus first index/capacity fields; no caller pointer or serialized association is authority. Actual integer width/tag/pointer/alignment/source SDK ABI and segment backing/page/control/stack/native owner geometry are independently bound, not inferred from payload arithmetic or a measured sizeof. No second64MiB pool is selected.

Push obtains source-pre-enrolled actual segment backing only when required within the EXISTING67108864 semantic maximum. An over-maximum push checks that existing limit before another acquisition and follows the original MaybeThrowStackOverflow continuation. Original helper throws through original isolate StackOverflow for kFromRuntime and otherwise returns interpreter EXCEPTION into the genuine original builtin continuation. Original generic integer push/pop/peek/sp/set_sp, bytecode target/register values, original backtrack counter and interrupt chronology remain. The prospective change removes geometric copy growth and changes overflow allocation-before-check, the stored over-limit element/failure-attempt chronology and allocation failure locations. Those differences are explicitly material; unchanged public language alone is not a complete semantic proof. Required segment acquisition failure preserves original FatalOOM rather than becoming recoverable native Denied, a fabricated exception or allocator fallback.

Every acquired segment stays held until original interpreter invocation end, even after pop/set_sp; no capacity credit follows from reduced sp. Genuine source owner borrower/native/O2/archive joins establish subsequent physical retirement, including failed acquisition/publication/close/history and actual allocations that succeeded before failure. At every phase the entire still-owned segment bank/directory/page rounding/control/native stack/history overlaps SAME parser128 with compressed snapshot/indices/catalogue/baseline/policy/manifest/provenance/inflater/current bytes and all original V8 String/JSON/cache/compiler/ByteArray/capture/prior subject owners. Segmentation removes the proven old-plus-new stack copy, but24576+67108864 is only a raw subtotal, not whole fit. There is no residual allowance, narrower accepted input, early configuration quota or pre-existing cache exemption.

Accepted-policy/input reachability and complete physical owner hooks remain source obligations. Owner patterns up to512 and full permitted configuration subject do not by themselves prove either unreachable maximum or a concrete maximum witness: optimized loops, generic unwind register/current-position/backtrack pushes, original string width, cache history and rejection/interrupt paths must be followed in the actual source. No pattern was parsed, compiled or executed to infer this. OriginalV8 fatal heap/Zone/native failures remain distinct from namespace/ZIP public errors. A hook returning null cannot be advertised as a recoverable response without the original allocator callsite's real disposition.

Original Node-carried raw inflater and replay ABI

The reference is the exact Node-carried zlib source/build closure, not a system zlib or version-equivalent DLL. Inert retained captures pin lib/zlib.js3aad698b5cadcb689d8fd452f736629c463fd8f3, src/node_zlib.ccd2d9570baf1f9641f3fd15ec657dcfedac1ba512, inflate.c0990ae7bf9a8d2a93b3146a23d7933d7f265c19d, inflate.hf127b6b1fa5f7d0266e3b502701948dfd3c6abc8, zlib.h8b2f6c1db99a5e913b4c8bfddb083079336982bd (declared1.3.1), zutil.c/h, zconf.h and the original zlib.gyp/BUILD.gn associations in R4-ORIGINAL-ZLIB-SOURCE-RELATIONS.json. Complete transitive platform/optimized inflate/checksum/build/allocator source association and actual ABI remain whole-candidate dependencies; ten retained files are not represented as a separately complete build closure.

Original ZIP uses inflateRawSync(original compressed subarray,{maxOutputLength:Math.max(1,declaredExpanded),info:true}). Node convenience construction creates original InflateRaw/binding and Uint32Array(2) state, no dictionary, default windowBits15 negated by native INFLATERAW, default output chunk16384, finishFlush Z_FINISH. processChunkSync repeatedly writeSyncs the remaining original input into output chunks; it first checks original emitted/native errors, then updates inputRead and output slices. It appends nonempty slices, increments nread and only then closes/throws ERR_BUFFER_TOO_LARGE when nread exceeds maxOutputLength. A full output chunk obtains a NEW16384 Buffer before the next call/break; multiple slices remain held and finally Buffer.concat allocates a distinct nread output, while one slice aliases its original chunk. Zero output returns an original empty FastBuffer. bytesWritten=inputRead and native close precede the return/concat path. Therefore an exact multiple can hold an additional unused chunk, and concat overlaps all prior chunks; a single preallocated declared-size cursor changes these actual allocation/failure locations.

ZIP next checks returned engine.bytesWritten equals the declared compressed count, then returned output length and CRC, then SHA. Node raw inflate may stop at stream end with unused compressed bytes; the ZIP consumption check rejects them. GUNZIP's separate concatenated-member loop is not INFLATERAW and cannot be imported into ZIP. Truncation is not merely any non-Z_STREAM_END result: native GetErrorInfo accepts Z_OK/Z_BUF_ERROR only under the actual avail_out/flush conditions, yielding unexpected-end error for nonzero avail_out with Z_FINISH; dictionary and other statuses have distinct original native error objects. ZIP catches recoverable non-AdmissionArchiveError exceptions from the original inflate call and returns archive_unsafe; its copy reservation occurs before that call. Actual fatal process/allocator failures are not JavaScript exceptions and cannot be translated to archive_unsafe or recoverable Denied.

Native source zalloc multiplies original uInt items/size with overflow checking, adds reserveSizeAndAlign=max(sizeof(size_t),alignof(max_align_t)), calls UncheckedMalloc, stores the real allocation size before its aligned payload and accumulates original external allocation reporting. Null returns to zlib; actual inflateInit2 allocates its original inflate_state and returns Z_MEM_ERROR on null; updatewindow can allocate32768 bytes for windowBits15 and return Z_MEM_ERROR on failure. inflateEnd frees actual window/state. Node maps genuine CompressionError through zlibOnError into original generic Node error, destroy/kError and synchronous processChunkSync throw. That differs from original V8 SmallVector/Zone/heap FatalOOM and must retain the real source callsite/status. No custom common null-to-Denied adapter or default allocator fallback is selected.

Prospective native inflater ABI must retain original compressed member window/root/ordinal, exact offset/remaining input/declared output, original z_stream/state/window owner generations and selected source/build/ABI association. Its source-private zalloc/zfree join the SAME pre-enrolled physical owner before actual acquisition/effect, including alignment/header/rounding, allocation result/error/native IO/O2 archive history; zfree is an actual observed end after genuine borrowers, not a decremented charge. Next-window views retain owner/custody and exact consumed/produced counters, original flush/method/mode and true member/source boundaries. A completed entry requires original consumed count/output count/CRC/SHA observations plus immutable source relationship; the borrower cannot supply its own approved bytes or successful status.

There is no selected positive definition of this adapter, recoverable custom status map or demonstrated chunk equivalence. Whole review must explicitly resolve original Node output-chunk/spare/concat/reserve failure chronology against native replay's proposed per-entry bank, including allocation before first output, limit overflow after output, native close before final concat, errors with live partial chunks and repeated immutable-source IO/EOF/custody failures. The replay candidate is eligible for analysis, not automatically a source-compatible substitute merely because successful output hashes match.

For a reached declared output E, original reference output backing includes held16384 chunks (plus the actual extra full-chunk spare), and a distinct E-byte concatenation when more than one slice is returned, with original state/window/wrapper/Uint32Array/Buffer controls/alignment. Those payloads may be retired before genuine original V8 String conversion only after actual native/codec/O2 last-borrower joins. On matching phases the current native expanded bank, decoded one/two-byte String, prior actual successful match subject, JSON/cache/compiler/capture/stack and immutable compressed/source/metadata/history owners are distinct unless the real source proves a shared backing. A phase equation must use actual source width and retained lifetimes, not combine incompatible peaks or silently exclude concat/native backing. No remaining arithmetic room proves whole134217728 fit.

Actual backend matching-phase and cache lifetime equation

Exact retained compilation-cache.ccb46ebe30891e079056dcb36e865b03e75c3f2aef and .h0b25c5b404cd4595501d836c69972a8a94183a14 have TWO RegExp generations, not two objects or nine permitted pattern keys. GetTable lazily allocates; Lookup searches both and promotes an older hit by Put of the SAME FixedArray into generation zero. Age shifts table roots and marks generation zero unborn. Iterate retains the original tables as roots. Dropped roots/handles/Age are not physical page end, and enabling/disabling script/eval caches does not disable this RegExp cache. Original regexp-match-info.cc248eefc03ef230b8f698eddc38298ac98add8ae7 ReserveCaptures allocates new info and copies old capacity before native-context replacement. These five history-source blobs have inert Git/SHA custody in R4-ORIGINAL-CACHE-MATCHINFO-SOURCE-RELATIONS.json.

At a reached config matching transition define S(t) as genuine original compressed snapshot backing, E(t) as current native expanded bytes, U(t) as actual original decoded String backing, L(t) as distinct prior successful subject backing, K(t) as all actual retained table/key/pattern/FixedArray/one-byte-code/two-byte-code owners, B(t) as allocated segmented stack and directory, G(t) as current compiler/Zone/bytecode/register/capture/match-info and genuine old/new growth owners, A(t) as original asset/baseline/policy/manifest/provenance/JSON/index/namespace owners, and H(t) as real transport/IO/error/O2/archive/terminal/native-stack/control/history owners. Rounding, headers and actual allocator/kernel backing belong to each actual physical owner rather than a detached residual pool. The phase predicate is the SUM over DISTINCT still-owned physical backings in the union of those sets, at most134217728. A shared String referred by lastSubject and lastInput is counted once; two cache tables referring the same data/code likewise do not duplicate that backing. Conversely copied current native bytes and a V8 String are distinct unless actual source owners establish a shared backing.

The reached single-call source bounds are compressed stage raw at most262144 after original owner rejection (the earlier10MiB initial read phase has not yet invoked regex), E at most8388608, UTF16 code-unit payload U at most2E and segmented integer payload at most67108864 plus24576 raw directory. Actual one-byte decoding can lower U, but a content-width test must follow original UTF8 codec/BOM behavior; unconditional one-byte normalization is prohibited. A prior context subject L may come from an earlier denied configuration and remains until actual original replacement/context end/physical retirement. Failed matching preserves that subject. Earlier unsuccessful source work/history may also retain its own snapshot/body/controls and belongs to H/A rather than disappearing at entry. Those source maxima are phase terms, not a proof that their simultaneous rounded physical maximum and compiler/cache/history fit.

K(t) is the union of actual original held generations, live JSRegExp data and physically retained unreachable heap objects until original native retirement; include old/new hash tables during real growth, original Latin1 and UC16 bytecode versions and cache-hit sharing/eviction/recompilation. Original constructor and compile events increment their actual counters even if data later leaves cache. Nine policy source slots do not bound all original baseline/general-validator/runtime keys, code versions or cross-call history. Source-bound pattern/key reachability must include every actual consumer on that genuine runtime context; source-private fixed closure construction does not isolate or reset an existing isolate cache. No GC/age counter is an owner receipt or known physical extent capacity.

A complete positive whole source capacity proof must substitute exact actual owner geometries and finite selected original caller/history capacities into this equation, show pre-acquisition reservation and every genuine end/archive transition, and retain fatal versus recoverable source allocation dispositions. Segmentation and entry replay reduce selected payload overlap but do not independently close K/G/H or satisfy the equation. Current prospective decisions supply no independently source-qualified allocator/page/stack/native layout or all-history physical fit; no fabricated numeric budget is added to close it.

Source-declared inflater state cardinality

Exact retained Node-carried inftrees.h6e7f0fa2a8afdea3875ab8cbbc987444ba19cdd5 defines ENOUGH_LENS1332 and ENOUGH_DISTS592, hence1924 code entries. The code fields are unsigned char op/bits and unsigned short val; the original source documents four-byte entries. inflate_state declares lens320 unsigned shorts, work288 unsigned shorts and codes1924. On the separately qualified ushort2/code4 ABI those arrays alone are8912 raw bytes, before six pointer fields, three unsigned-long fields, one mode enum plus six int fields, sixteen unsigned fields and all padding/alignment. The approximate7K comment in inflate.h is not a source upper bound and upstream table-count assumptions are incorrect for this exact closure. Original state allocation is actual sizeof(inflate_state), independent window up32768 and Node zalloc reserveSizeAndAlign prefix, each with real allocator/page/control/history ownership. R4-INFLATER-STATE-LAYOUT-SOURCE-RELATIONS.json binds this inert additional original header. No compiler, sizeof measurement, inflater initialization or native layout was executed; actual selected build/packing/enum/type/pointer ABI and complete optimized dependencies remain required.