NQ1-R1: exact native dependency and original authority counterevidence
Status: Development SOURCE ONLY, #1643, SPEC-002 AC-4CF.1b / SPEC-006 AC-6E.SA1, CA03/CA04/CA06. The completed DIFFERENT entire NQ1 review at unchanged6a71d49a/tree02904d84 returned WHOLE_ARCHITECTURE_NO_GO_FOR_POSITIVE_NQ1_IMPLEMENTATION; report SHA25692aab774fb176be9bec3447eb73f5dd9c6a9f5d3d2daa59a9dc460f1b98563f5. That review and the original frozen01 packet remain unchanged. R1 corrects the capacity vector and replaces vague promises with exact source counterevidence and owning decisions. It does not claim a selected positive architecture, product implementation, native equivalence, allocator qualification or execution admission.
Actual CE1 producer, consumer and absent catalog association
Accepted CE1 names the prospective owner-side producer retainOriginalCoreOwnerInputs(originalOwnerAuthorization, originalAdmittedPacket) and bootstrap consumer acquireOriginalCoreAdmissionInputs(). These names occur in the accepted decision document, not executable definitions in the frozen complete30 native source files or actual1101 current tracked source files. NativeApplicationConnection remains the prospective application consumer declaration; native constructor/engine integration stays with the primary Core author. OriginalInputObjectRead is the implemented transferred-object IO reader with exact native type/object/length/hash/read/EOF observations. Its constructor, a NativeCapsuleNamespace, a const/shared ownership wrapper, a profile capability, OS owner and provider MAC authenticate no source-owner/publication realm.
The required REAL acquisition is the existing original owner administrative action's independently SOURCE-admitted native consumer. CE1 requires both original caller/provider process/birth/image/owner/control-transfer authentication and original authority authentication of EACH offered source-owner approval/native-input ROOT/source-publication/qualification packet. No concrete authentic realm implementation, source-pinned producer executable, eligible publisher tuple, original control channel, transfer provenance or corresponding catalog acquisition C++ type is present in the examined source. The primary author explicitly confirmed that absence during NQ1 coordination. Naming an invented OriginalCatalogLease would not repair it. R1 therefore rejects a positive typed factory rather than replacing its earlier placeholder with nominal authority.
The exact constructor owning decision is to supply the actual original realm implementation and its private source-owned acquisition type from that owner action, together with its original producer source/image association and complete per-packet admission code, BEFORE a native factory is defined. It must carry original independently admitted repository/full commit/blob/raw/source/publisher association, catalog tuple and publication assets, genuine transferred original four asset handles, actual ownership/transfer/current-image association, original finite allocator/control lifetime and original loss behavior. The original authority must authenticate those objects independently of their raw hashes/provider key lineage. No new endpoint, actor, signer, ordinary23 command, public/profile field or grant is proposed.
Consumer borrowing must retain that actual source acquisition owner alongside the four OriginalInputObjectRead objects, the original stage reader, parser result and native journal/capsule engine. Loss or changed association during lookup, parse, emission, seal/readback or acceptance must fail closed BEFORE the next effect and retain unknown originals. Reacquisition cannot replace a lost association or renew an original deadline. Engine receipt/observer correlation must see the original read/EOF borrowers and actual ended controls; the data parser emits none. Until actual source supplies this producer/type/control implementation, original admission remains unavailable and no positively qualified namespace can be constructed. This is an explicit source feasibility blocker, not a request for runtime provisioning.
Exact official reference sources inspected
Two genuine official Node tags were dereferenced through the GitHub API and their original HTTP source bodies retained outside the repository:
| Reference | Original annotated tag | Original target commit | V8 header | ICU header / Unicode header |
|---|---|---|---|---|
| Node22.0.0 | ec49bec48284ab642db1d109d917c6ae3b695c13 | 12fb157f79da8c094a54bc99370994941c28c235 | 12.4.254.14 | ICU74.2 / Unicode15.1 |
| Node22.20.0 | 58936cf2150d27ec8529f8887f37e771a4f373f6 | caa20e28dc1f21a97f7b2a7134973fd6435b65f0 | 12.4.254.21 | ICU77.1 / Unicode16.0 |
These are research reference identities, not selected runtime/build/source authority or a recommendation to deploy either historical release. Repository package.json currently allows Node>=22, and workflows select22; neither binds one patch/V8/ICU/Unicode build. A version-only V8 pin also omits Node's carried patches and original build flags/ICU configuration. Therefore “equivalent to Node22” is not one exact source contract. R1 does not silently narrow supported runtime versions to22.20.0 or assert a single native engine equivalent to every supported runtime. The primary whole architecture must bind the actual originally qualified runtime/source/build/Unicode association and define coherent behavior across supported versions before a production dependency is selected.
Original official source URLs: V8 version, ICU version, Unicode version. External OFFICIAL-SOURCE-MANIFEST.json binds every retained original body by URL/repository/commit/path/length/SHA and preserves failed acquisitions. HTTP/hash/GitHub tag verification is research custody, not independent project source approval.
Concrete full native options and source findings
Option A is the exact Node-carried V8/Irregexp+ICU source associated with the actual qualified Core runtime, embedded natively and called through native RegExp APIs without Node callbacks or arbitrary JS. It supports actual language syntax through the same parser. This option is NOT selected: public ArrayBuffer allocation hooks own backing buffers, while RegExp AST/compiler Zone allocations, interpreter SmallVector registers/backtracking storage, ICU sets/tables, isolate/heap/code/native stacks and scheduler/control objects require separate complete native ownership. Page/heap limits alone do not account those owners. An unchanged embedding does not satisfy the current original128MiB proof.
The exact RegExp parser uses Zone-backed syntax structures and ICU UnicodeSet/property/case operations. Zone accounting has its own segment/page allocation path. ArrayBuffer/isolate APIs do not grant a hook for every one of these objects. These are specific allocation paths to integrate, not an assertion that V8 cannot ever be adapted.
The exact interpreter retains register and backtracking SmallVectors and consults interrupts during POP_BT. Its underlying SmallVector allocates new doubled storage before copying/freeing the previous storage; logical length understates transient physical occupancy. A64MiB ceiling can coexist temporarily with an older32MiB backing allocation. RegExpStack defines a64MiB ceiling, not a project ownership receipt. Full compilation, Unicode processing and non-backtracking forward execution still need the same original-end checks and original interruption/physical-end observation. Public RequestInterrupt/TerminateExecution names do not prove that all those native bodies have completed or that allocation has ended. No extra backtrack/instruction limit or fallback language restriction is selected.
Option B is a source-owned native extraction/port of the exact reference Irregexp parser+AST+compiler+bytecode interpreter and exact associated ICU Unicode semantics, replacing V8 heap/Zone/SmallVector/native allocation and control dependencies with the SAME original project physical owner. This is the specific reference port candidate for future evaluation, not a blanket feasibility/equivalence result. Every native parser/compiler Unicode operation and execution cycle would need original-end checks, with no semantics-changing counter/timeout/limited regex grammar. Original flags u/iu/imu and unflagged general manifest compilation, captures/backreferences/lookarounds and all accepted syntax remain full. Exact reference build and test differential, all transitive license/source/dependency files, actual allocator implementation, finite worst-case occupancy and completed native interrupt/control proof must be frozen together before selection. Current source provides none of that port.
The official V8 non-backtracking alternative excludes important pattern/flag classes in its fallback eligibility; it cannot replace Irregexp for this contract. std::regex, RE2, hardcoded patterns, ASCII-only Unicode and Node callbacks remain rejected. Selecting a different complete engine would require exact independent equivalence counterexamples/positives and source/Unicode/ownership/deadline review, rather than an “ECMAScript compatible” product label.
Decision: unmodified embedded V8 is NO_GO for the claimed project ownership/deadline route. An extracted port is an exact research candidate with unresolved feasibility, not approved positive implementation. No exact native engine can be declared selected against an unfrozen original Core runtime and absent physical allocator/control implementation. The remaining owning decision is an exact originally qualified reference runtime/source/ICU/Unicode/build tuple plus a complete arena/control source route, or an explicit whole architecture amendment supported by concrete counterevidence. No dependency was installed or source executed.
Correct physical occupancy and capacity classification
The current owner policy caps canonical compressed archive at262144, canonical TAR expansion at524288, manifest at65536, config aggregate at65536 and provenance at4096. A conservative complete authored-byte upper bound is524288+65536+65536+4096=659456, before subtracting replaced baseline members. ZIP expansion ratio100 additionally implies <=26214400 expanded bytes before archive overhead. Neither bound allows a current64MiB semantic positive. The source64MiB capsule/expanded ceiling and original128MiB owner remain unchanged; NQ-Z04a exercises generic native byte/framing capacity and NQ-Z04b exercises a real independently admitted owner semantic positive. Neither supplies approval for the other.
Use the original native staged read buffers themselves as segmented immutable compressed backing, indexed by bounded metadata. Do not retain all original buffers AND a second contiguous raw ZIP. Source original assets similarly retain one backing set; TAR baseline entries borrow the single <=524288 decoded TAR owner. Authored expanded bytes allocate once. JSON uses native fixed-record offset/parent/sibling nodes and decoded strings; manifest validation checks raw values while retaining original pretty bytes, never materializes its normalized projection into a second inventory. Serialization streams comparison/hash into bounded buffers. Each allocation owner includes actual capacity/alignment/metadata, including growth overlap; each failure carrier is reserved before source operations so it never loses owners while allocating during failure.
| Retained phase | Required physical owners | What is concretely known |
|---|---|---|
| Original acquisition | genuine source authority/control objects, four asset native reads, stage read, native IO/control/EOF observations | Raw assets<=296448 and stage compressed<=262144 under current owner, but actual realm/observer/control backing bound is absent |
| Canonical/semantic parsing | single TAR<=524288, single authored<=659456, JSON/source namespace metadata, inflater tables/state, original buffers | Full byte upper bounds follow current source; exact native node/arena representations and all control sizes still require implementation |
| RegExp compile/match | exact AST/compiler/Unicode sets/programs/captures/registers/backtracking and old/new growth allocations, native thread/control stacks | Exact source64MiB effective stack ceiling has growth-before-check and may attempt192MiB transient backing before overflow rejection; compiler/Unicode/isolate/control totals and reachable worst-case remain unproved |
| Generic64MiB native capacity | one64MiB inventory, original segmented compressed<=10MiB, bounded metadata/read buffers/chunk emission/control | Must retain source capacity with no second64MiB envelope; it does not run the unapproved owner semantic/RegExp route or return source qualification |
| Emission/seal/readback | qualified accepted owners, genuine authority, original capsule native writer/readback/provider/observer borrowers | Same shared result retained; namespace const view alone does not preserve actual owners or prevent aliases |
| Failure/loss/deadline | actual original pending allocations/reads/authority/control and failure carrier | Unknown stays retained; destructor/counter/GC is not physical end or FREE |
There is no honest concrete worst-case128MiB success sum yet: raw-byte arithmetic is a small component of it, and the exact remaining RegExp/native-control owners are unbounded by the proposed source representations. Taking the remaining bytes as a new regex quota would introduce an unreviewed input restriction; it is forbidden. This table records precisely why full valid-source physical feasibility cannot be claimed and names every owning dependency needed to establish it. Generic native capacity may be implemented/tested independently only under accepted existing interfaces and new exact execution admission; it cannot bypass the positive semantic NO_GO.
Review boundary and next source action
Primary constructor owner must first supply authentic CE1 acquisition source/type/control evidence and exact runtime reference association, then one complete native port/allocator/end-control design with all dependencies and a derived physical occupancy proof. These are source decisions, not a request to create accounts, providers or runtime resources. A DIFFERENT complete review assesses the amended WHOLE packet including this counterevidence, original NQ1/CE1/D1 inputs, exact official bodies, primary callgraph/ownership and all regressions. Until then, the accepted architecture permits no positive NQ1 parser/factory implementation. Full product integration, final entire SOURCE GO, NEW authentic executable admission and original native/released acceptance remain separate.
Exact source port candidate and phase arithmetic
The constructor owner confirms the implementable source obligation is CE1 section21's original owner action retainOriginalCoreOwnerInputs(authenticated original owner context, independently admitted packet) and section23's one bootstrap consumer acquireOriginalCoreAdmissionInputs. The data side borrows four OriginalInputObjectRead leases plus the immutable decoded catalogue row. The association object can be constructed exclusively by that original action after conjunctive caller and EACH packet admission; no parser/public caller constructor, opaque callback approval, or decoded-row/hash/OS-owner conversion is permitted. Exact original realm credential validation/action implementation and independently admitted baseline are absent, so this source obligation is not a selected positive factory type. Association loss retains actual held leases and failed IO, invalidates further semantic use, and never reenrolls or renews. This is a source adapter gap as well as an absent runtime grant.
A concrete candidate for further whole review is a source-owned port of the pinned Irregexp parser, bytecode generator/interpreter and matching ICU Unicode tables, with the actual reference-runtime build selected by original realm association. The retained Node22.20 commit remains a research reference, not authority to narrow engines>=22. The native implementation must preserve all original RegExp syntax, flags, UTF16 indices, capture/backreference/lookaround/case/property behavior and compile/error semantics. Fixed-size physically charged stack segments replace SmallVector growth; the original64MiB effective backtrack capacity remains, with overflow tested before backing allocation. Interpreter source push() currently allocates first and tests afterward, so a full64MiB SmallVector can attempt a128MiB new allocation alongside old64MiB before reporting overflow. Segmentation avoids that overlap without a smaller stack ceiling. It needs a separate prospective equivalence vector at original overflow, and deadline checks before every segment allocation and throughout compile/execute loops without an instruction-count cap.
The exact register source bound is65536 int32 registers (262144bytes), with at most another262144bytes of capture-output backing. Subject decoding must use the one original retained UTF8 byte owner through a native indexed UTF16 view, preserving surrogate pairs and UTF16 positions, rather than duplicate a maximum26,214,400-byte failing subject into52,428,800bytes of UTF16. Bounded checkpoints provide original-byte offsets and UTF16 indices; exact record/capacity/alignment totals still require the reviewed representation. Compilation owns only one pattern/program at a time, not a cache of every owner rule. Native parser/compiler/Unicode temporary owners must physically end before match where the source permits; no GC/destructor declaration is a release observation.
Call-order matters: owner rule patterns are<=512 UTF8bytes, but validateServiceManifest first constructs unflagged outputvarregex patterns from a manifest<=65536bytes before immutable owner comparison. validateAuthoredEntries executes configuration forbidden-value imu before checking aggregate configBytes<=65536 at the end. Thus an accepted semantic configuration is small, while an original failing candidate can reach RegExp with ZIP-expanded<=26,214,400bytes; early quota rejection would change original call order and is not assumed. The capacity route and semantic-positive route remain distinct.
A preliminary failing-match occupancy uses262144 raw ZIP +26,214,400 single expansion +67,108,864 segmented stack +524288 register/output +296448 original assets +524288 TAR =94,930,432bytes, before all native controls, decoded metadata, bytecode, Unicode views and allocations. Remaining128MiB domain is39,287,296bytes; it is NOT a regex quota or a proof of fit. Source generation's1MiB compiled-code heuristic and16MiB executable-memory heuristic only disable optimization and are not allocation caps. Zone AST/range copies, Unicode sets, compiler graph, bytecode grow/copy owners, allocation alignment, original IO/authority borrowers and failure reserve still need an exact source-derived worst peak. A segmented stack plus indexed subject makes a complete route plausible without hidden smaller input caps; it does not establish blanket equivalence or feasibility until the whole source port and original semantic reference association are selected and independently reviewed.