NQ1 complete native RegExp representation and source-phase resource candidate
Status: MATERIAL PRECODE CANDIDATE WITH SOURCE COUNTEREVIDENCE; NOT A COMPLETE ACCEPTED REGEXP ROUTE. DIFFERENT WHOLE ARCHITECTURE GO REQUIRED. No positive parser/factory implementation and no executable admission. This continues the same NQ1 unit and supersedes the provisional occupancy arithmetic in R1 without modifying frozen packets01/02 or any review. Constructor/importer/engine source belongs to its primary owner.
Original generic candidate (superseded by actual closure and counterevidence below)
The earlier generic candidate proposed a source-owned, nonoptimizing Irregexp parser/generic node lowering/bytecode interpreter port. That complete route is rejected by the optimization/stack counterevidence below; it is not the current selected architecture. The exact retained research source is Node commit caa20e28dc1f21a97f7b2a7134973fd6435b65f0, carrying V8 12.4.254.21 and ICU77.1/Unicode16.0. Earlier admitted semantic references are not silently changed to this build: Node22.0 research source carries V8 12.4.254.14 and ICU74.2/Unicode15.1. The public engines>=22 contract is unchanged. Each actual owner-approved reference requires its original held source/build/dependency association and the matching grammar/flags/property/case tables. Version strings, arbitrary decoded catalogue fields and matching source digests do not supply approval. New reference closures require their complete compatibility/source proof; this candidate makes no equivalence claim for unknown Node/V8 revisions.
Primary owner's pending CE2 ABI proposes importer-private NativeAdmittedCatalogLease, constructed solely by NativeOriginalInputImporter after BOTH the original baseline companion/native transfer and explicit existing GitHub owner EACH-packet approval. It retains original owner decision, baseline peer, source packet, qualification, publication and four original asset IO leases. catalogEntry() is an immutable data view; asset(Archive|Descriptor|Policy|Sums) borrows original leases; source/qualification/publication associations and referenceRuntime() borrow genuine held objects. NativeReferenceRuntimeLease must retain exact Node/V8/ICU source-object/build/dependency and Unicode table/source association, plus original allocation ownership and custody checks. These are private source/build closure dependencies, not new public image/profile fields. This is proposed source ABI, not a selected CE2 action, actual role resource or grant.
Runtime codec must resolve original object references through the importer-held association, not construct positive leases from received IDs/hashes. It identifies the exact source-object/build relation, interpreter grammar/flag configuration, Unicode/property/case data relation, generated-table build relation, owner allocation and original clock/end association. Each object remains borrowed from the genuine original producer. Loss or failed IO invalidates semantic use while preserving held objects, borrowers and actual failure observations; no renewal, reenrolment or positive callback. Actual producer/action/credential source selection remains primary owner's CE2 decision boundary.
Historical compact representation candidate and unproved compiler invariants
The rejected generic candidate retained no stock V8 isolate, runtime ICU allocator, Zone allocator, optimization cache, JIT code, UnicodeSet expansion or per-pattern Unicode property table. The original grammar and generic matching semantics remain. Optimization-only quantifier unrolling, graph filtering, atom optimization, speculative trace copies and Boyer-Moore tables are omitted; the generic ordered backtracking path preserves language/capture/greediness/lookaround behavior. It introduces no instruction cap or pattern-language subset. This material transformation requires complete semantic review rather than assuming an optimization switch proves equivalence.
An AST record is exactly64bytes: fixed tag/flags plus fourteen uint32 operands for original UTF16/source span, child/sibling indexes, literal/range/property selector, capture/name selector and quantifier bounds. All indexes reference the original held source or fixed arenas. Each original UTF16 input unit owns at most eight records: scalar/escape, class term/range, group/capture, quantifier, concatenation, alternative edge, source/name reference and deferred parser state. Empty implicit alternatives use the extra sentinel unit. No decoded property range or capture-list copy is attached to an AST node. Thus AST physical record capacity is 64*8*(L+1), where L is the original pattern UTF16 length. Parser states are32byte fixed records, at most one per input unit plus sentinel; decoded source/name scratch is at most4*(L+1)bytes. Tokenization/counting checks original end at every original source advance. No capacity overflow is a new public rejection: implementation must uphold this source invariant for every original accepted grammar form.
Names share one capture-membership list; each capture appears once. Named backreferences store the shared list index. This is necessary because original ToNode creates one BackReferenceNode per candidate capture for EACH named reference, permitting a quadratic representation. The port's COMPARE_NAMED_CAPTURE_LIST executes the same ordered comparisons with native deadline checks; unmatched candidates remain empty and duplicate-name admissibility comes from the exact original parser. No duplicated graph per backreference is allocated.
Unicode class terms remain symbolic literal/range/property/complement selectors. An exact native scalar predicate applies original property-alias rules, class negation and case closure in the original order, including u-mode complement-before-fold behavior. It advances the same UTF16 units and handles lone surrogate escapes. It does not expand astral ranges into a graph of lead/trail surrogate alternatives. Character-set values are not normalized into a different policy. Every u/iu/imu and unflagged grammar form, backreference, lookahead/lookbehind, capture, zero-width loop and scoped modifier admitted by the original reference must be covered.
Generic lowering has at most16 records per original input unit plus sentinel. Records include every branch edge and guard, not only node objects. Each is128bytes, with fixed indexes/operands and no vector growth. Derivation: literal/class/any term <=4; capture <=2 plus charged body; group modifiers <=2 plus body; lookaround <=6 plus body; quantifier <=10 plus body, with no unrolling; choice has one node and individually charged original alternative edges; empty creates no body; assertions use a direct exact predicate or <=12 fixed control records; shared backreference-list selector is one record. Search entry/control fits the sentinel's16. Atom units and alternative edges are charged to their original token, not multiplied by the full expression. This bound is an implementation obligation for the selected compact lowering, not a claim that unchanged V8 allocations already satisfy it.
Bytecode instructions are16bytes: opcode/flags plus three32bit operands. A generic lowering record emits at most16 instructions. Variable-length literal, range, register and named-capture operations use indexed original arrays rather than expanding instructions per member. CLEAR_CAPTURE_RANGE, PUSH_REGISTER_RANGE and RESTORE_REGISTER_RANGE perform original register/int operations in their original order, checking the same64MiB backtrack bound before each integer and checking original end inside the loop. They change representation only. Symbolic class and named-backreference operations similarly iterate original ordered data without an instruction-count cutoff. Compiler creates one pattern/program at a time; no source-wide cache.
| Generic record operation | Maximum instructions and required behavior |
|---|---|
| Literal/class/any | <=4: obtain original indexed UTF16/codepoint, exact predicate, advance, failure |
| Assertion | <=12: original start/end/line/word predicate and ordered branches; Unicode word closure preserved |
| Capture/store/action | <=8: original saved register/position/stack state and ordered restore; range operands remain borrowed |
| Quantifier/guard/choice edge | <=16: original counter/empty-match check, greedy/lazy branch and original stack writes |
| Lookaround | <=12: original CP/SP/capture save, forward/backward child relation and success/failure restoration |
| Backreference selector | <=4: original matched/unmatched candidate list comparison and UTF16 advance; internal loop checks original end |
| Success/failure/search entry | <=16 sentinel/control instructions; no fabricated public outcome |
Parser and generic graph owners physically end before match. If their actual closure is pending or unknown, matching does not start and original objects remain retained. Runtime bytecode does not borrow freed AST/graph storage: all required operands reference original source owners, fixed shared Unicode owners, fixed capture/name lists or program-owned literal spans. Transfer/copy spans are included in program capacity and done before closing compile owners.
Superseded universal Unicode table representation
The selected reference has50 binary properties admitted in u mode; the seven additional properties of strings are v-only and no caller requests v. This is the exact source allowlist, not a newly reduced grammar. General category/script/script-extension and Any/ASCII/Assigned behavior remain. Native generation is a future admitted build operation from the exact held source/ICU dependency, not an owner approval factory. It emits immutable tables and must prove full-universe agreement with the original ICU/V8 operations before executable acceptance. No generation was executed here.
Use codepoint universe U=0x110000. Fifty scalar-property bitmaps cost50*(U/8)=6,963,200bytes. General categories use Ubytes; packed original Script_X selectors use2Ubytes. The original mask0x0fff preserves primary/Common/Inherited/Other discrimination and extension offsets, not merely primary script IDs; uchar.cpp original getScript/hasScript logic resolves the same selected entries. Script_Extensions borrows the exact source's526 uint16 entries,1052bytes; no per-codepoint vector. Case closure uses an exact equivalence-class partition of all scalar/codepoint values: one uint32 class ID per codepoint, one uint32 offset per class plus sentinel, and one uint32 member per codepoint, upper bound 4U+4(U+1)+4U=13,369,348. Exact original ICU singleton closure with strings removed determines the partition; inverse members make class closure membership finite without materializing a set per class. This relation and its use for u-mode complement/class folding require exhaustive prospective comparison against the reference. Unflagged ignore-case/scoped modifiers use original ECMAScript BMP canonicalization in a65536-entry uint16 table,131072bytes. Case-folded backreference comparison uses the exact reference relation and original UTF16 direction.
Actual propname source arrays are1494 int32+16091 bytes+24294 chars+8 int32 =46,393bytes, shared for exact alias matching. Table headers/index/control allowance is a fixed65,536byte source layout containing the fifty descriptors, class-table descriptors, property enums and immutable source association indexes. Total Unicode table layout is23,918,937bytes. Fixed arrays include identity classes; sparsity is not needed for the bound. Normalization/emoji/bidi-backed binary properties are represented by the fifty exact bitmaps, so runtime has no hidden normalization factory or emoji data loader. Their generation must use complete original ICU dependencies, including data omitted from the small headers; headers alone do not establish semantic validity.
These quantities prove the representation bound for the selected source candidate. They do not approve generated contents, authenticate a runtime or claim every future Node source uses the same allowlist/data layout. The original reference association must select its complete codec/table closure, and a different closure receives a full source compatibility/bound review without changing the public supported-Node requirement.
Original call order and live byte owners
Actual authored/baseline manifests use parseStrictJson defaults: bytes65536, decoded stringBytes4096, depth16, tokens65536 and members4096. Thus each unflagged outputvarregex constructor sees L<=4096, though the complete manifest remains65536. Native syntax verification must preserve the entire grammar inside this original bound; standalone general validator semantics are not silently capped. Original owner policy patterns are<=512 UTF8bytes, so tested u/iu/imu patterns have L<=512. The parser rejects actual decoded unpaired-surrogate JSON strings, while ASCII regex surrogate escapes remain legal original pattern syntax.
Controller obtains genuine stage EOF/hash/read observations, then original canonical assets, then ZIP decoding, then authored validation. Whole decoded ZIP bytes can reach262144*100=26,214,400; each entry is at most8,388,608. Configuration forbidden-value matching occurs BEFORE config aggregate65536 is checked. Therefore a failing original candidate can retain26,214,400bytes while executing imu on an8MiB subject. No early semantic quota check or error reorder is assumed. Generic native64MiB capacity remains a separate byte/framing route with no owner semantic qualification.
Retain one compressed stage backing, one original asset backing set and one decoded TAR. Expanded authored entries share one backing set, with no second flattened64MiB envelope. UTF16 subject indexing uses one16byte checkpoint per256 original UTF8bytes plus sentinel; maximum8MiB subject index is524,304bytes. It reads exact retained bytes, including codepoint/UTF16 positions and backward matching, without a full second UTF16 subject. Each index probe/reconstruction checks original end inside native loops. No source path or byte is normalized by the index.
All JSON value records are32bytes: fixed tag,parent,next,first and four operand/key indexes. Allocation is conservatively one record per original source byte, covering keys/members/values without vectors or copied maps. Decoded UTF16 plus validation scratch is at most fourbytes per source byte, with original number lexemes and keys retained. Authored manifest65536 +baseline manifest65536 +policy32768 +provenance4096 +descriptor1024 =168960sourcebytes, so all simultaneous JSON records/scratch cost36*168960=6,082,560bytes. Validation traverses borrowed nodes and retains original raw manifest bytes; normalized validateServiceManifest projections are never substituted into accepted inventory. Property/field validation, defaults and throw order follow the complete original validator.
Catalog source/owner repository strings have no genericbyte ceiling in catalog.ts. The importer must supply source association views over held original objects or exact immutable admitted packet sizes, not copy arbitrarily long strings into bounded native records. Original source/build closure files are held through immutable native IO/borrowers; the complete Node source tree is not copied into the128MiB allocation domain. This is an importer representation obligation, not a new metadata limit.
Physical allocation layout and peak proof boundary
Backtracking payload preserves the original64MiB effective capacity. Exactly1024 possible64KiB segments each have64byte aligned block header plus128byte original-owner/custody record; the pointer table is8192bytes. Total charged source layout is67,313,664bytes before OS rounding. The original interpreter allocates before checking its64MiB bound and can attempt128MiB new backing alongside old64MiB; this port checks the original bound before each write and adds a segment only when needed. No old/new payload copy exists. Every segment and owner record belongs to the SAME original finite owner and deadline, and failed/unknown closure remains retained.
For L<=512, program capacity 16 instructions*16bytes*16*(L+1) is2,101,248bytes. Registers retain original source maximum65536 int32 =262144bytes plus at most262144bytes output capture storage. Compile phase also uses at most AST262656, parser16416, decode2052 and graph1050624bytes, then transfers to program and physically closes compile owners. Syntax-only unflagged L<=4096 has AST2097664 +parser131104 +decode16388 and no matcher backtracking storage. No unchecked multiplier depends on quantifier numeric value, Unicode range count or duplicate-name cross product.
| Simultaneous match owner | Bytes |
|---|---|
| Original stage compressed262144 +four assets296448 +TAR524288 +whole failing authored expansion26214400 | 27,297,280 |
| Full retained JSON records/decoded scratch | 6,082,560 |
| Shared Unicode tables/headers | 23,918,937 |
| Full backtracking segments/headers/custody records/pointers | 67,313,664 |
| Tested pattern program | 2,101,248 |
| Indexed UTF16 subject checkpoints | 524,304 |
| Register/output arrays | 524,288 |
| Specified representation subtotal | 127,762,281 |
This subtotal leaves6,455,447bytes of the unchanged134,217,728 domain. It is not a permitted residual quota. The whole proof must ADD actual original importer/reference/control/native-code/IO/clock/failure owners and platform physical alignment/page rounding. The primary constructor owner must select their exact source layout/borrower count and the admitted original allocation backend before the candidate can claim a complete128MiB peak. No arbitrary2MiB control reserve, malloc logical size, GC/destructor release or OS-owner label fills this gap. NQ arrays can share charged phase arenas; each backing reports actual capacity/rounding and retains original borrowers until genuine physical closure. No arena resize/realloc/growth overlap occurs.
Canonical/ZIP/JSON/compile phases have no64MiB backtracking payload and are lower than the listed match subtotal even while AST/graph/program coexist. Failure at a full stack retains the listed owners plus the original preallocated failure/control carriers; no extra allocation is required to record failure. Seal/readback uses the same accepted byte owners and bounded chunk emission; original readback bytes/EOF and original namespace are observed by the actual native caller. Generic64MiB capacity uses one64MiB inventory +original compressed<=10MiB +bounded entry/path/framing/chunk owners and excludes these semantic Unicode/program tables; it produces no QualifiedNamespace/source approval. Neither route allocates a second64MiB envelope.
Required prospective whole regressions (UNRUN)
Require complete original grammar/property/case/capture/reference-version comparison, not hand-picked accepted regexes: u/iu/imu/unflagged, scoped flags when the reference admits them, all original alias spellings/invalid aliases, full-codepoint singleton closures and properties, complement-before-fold versus class negation, astral/lone-surrogate escapes, duplicate-name disjoint alternatives and repeated backreferences, positive/negative lookbehind captures, empty greedy/lazy quantifiers, large numeric quantifiers with no expanded program, original64MiB stack boundary, full4096 unflagged syntax, and original invalidownerpattern versus caught invalidmanifestpattern failure categories. Actual failures/deadline loss must keep all original owners and show genuine physical end; no manufactured receipt.
Require physical occupancy observations at original failing26,214,400 expansion/8MiB subject before aggregate config rejection, all maximum JSON trees, all50 property tables and full stack, compile-to-match actual closure, segment allocation loss, unknown borrower closure, generic64MiB capacity with one retained backing, emission/seal/readback and original EOF. These are new meaningful prospective source obligations, all UNRUN. A DIFFERENT complete whole review must assess grammar transformation, counts/layouts and full primary control/realm ABI before positive implementation. Final integrated SOURCE GO and NEW authentic execution admission remain separate.
Original clock and prospective source interface binding
The primary checkpoint16 Deadline type has an original-clock path and compatibility chrono paths. The NQ1 port requires the original-clock path: hasOriginalClock() must already be true, with the producer-held clock realm/sample and original tick end associated to the same native context; every native loop calls that original Deadline::check(). It never constructs a new40second allowance, maps a decoded epoch, captures a replacement end, subtracts from an unrelated clock or uses the compatibility constructor to legitimize positive admission. Budget is the same producer-held original owner (sameOriginalOwner), not a new Budget128 constructor. These checks correlate original objects; they do not authenticate an owner or turn decoded tuples into approval.
No native regex helper spawns a thread or waits on Node, and no Node callback evaluates a candidate or produces a source grant. Parser source advance, graph walk, bytecode emit, Unicode/property/alias/closure lookup, indexed subject reconstruction, backreference comparisons, bulk register operations and each backtrack write poll original end. Quantifier counts remain original numeric operands; execution has no extra instruction/backtrack cap. Original generic RegExp exceptions preserve their original private failure category/order: owner-policy pattern length is checked before compilation but invalid pattern syntax escapes generic authored validation, whereas invalid unflagged outputvarregex is caught by general manifest validation and maps to manifest_schema_invalid. A universal template_difference denial would change original behavior and is forbidden. Actual native original failure mapping stays the primary engine boundary.
Prospective vector additions (all UNRUN): full4096bytes of nested unflagged constructs after original strict JSON string validation; many disjoint duplicate-named captures with repeated named references proving shared membership avoids quadratic backing while keeping original parser/flag acceptance; maximal case/property classes without UnicodeSet cloning; exact Script_X Common/Inherited/Other selection and shared526entry extensions; original normalization/emoji/bidi-backed binary properties; Unicode15.1 versus16.0 source-association disagreement without version-string approval; same source digest with wrong held build/dependency association; compatibility chrono deadline presented without original clock; actual original end loss during every bulk-op/subject-index/segment allocation loop; private invalidownerpattern versus caught invalidmanifestpattern; failure after full stack preserving original owners and genuine closure.
Actual CE2 reference closure and optimization counterevidence
Primary now proposes the genuine retained Node22.23.2 source commit aa4c77582be995286fc6e00aaf530dc7ade102a9, root tree cee5f56eb6b8b6b8e300419196dc90e8c7abd64b. Original N1 bare Git custody and raw objects supply source bytes; they are not original realm approval. Fifteen directly relevant objects were read from original raw storage and verified with genuine Git blob type/length/NUL SHA1 framing. This actual source still carries V8 12.4.254.21 but ICU78.2/Unicode17.0, so the prior22.20 research baseline cannot be substituted based on the same V8 version. Actual Script_Extensions has562 uint16 entries and propname arrays1509 int32/16301 bytes/24665 chars/8 int32, total47034bytes. The universal-layout arithmetic increases713bytes to23,919,650, match subtotal127,762,994 before the unresolved original whole-domain owners. Reference source/build/flags/custody association remains proposed and unauthenticated until CE2 selection and actual admission.
The nonoptimizing compact route above has a material semantic-resource counterexample: abstract language equivalence does not establish preservation of every originally successful pattern. Original compiler greedy-loop compression, trace specialization and quantifier unrolling can reduce backtracking storage. Generic per-character CP/register pushes can overflow while the original optimized matcher succeeds. Original default native JIT uses its architecture-specific stack word model and32-location slack; original interpreter uses int32 locations. Therefore the compact counts above are a bounded representation candidate, not a valid accepted-input/full64MiB stack proof. Positive implementation must retain the original optimization/stack behavior or prove a complete resource-preserving transformation; no original stack failure may be recategorized as template difference and no new smaller effective capacity is accepted.
The exact original optimized source has nested quantifier expansion factor<=6 and code-version count10. Blindly multiplying the generic program/graph budgets does not establish128MiB feasibility. Optimization-aware parametric code/trace representation or genuinely original held program-spool IO could avoid duplicated instruction backing, but neither has a selected complete source/lifetime proof. A spool requires actual existing original native owner namespace/write/readback/custody leases; held readonly NativeStageRead cannot grant it. No scratch role, provider key, allocation allowance or callback is inferred. Exact source stack-word encoding may retain logical capacity with smaller physical words only after the full original assembler value/overflow/order model is proved; it is not a declaration that all slots are ordinary int32 values.
Full Node-carried ICU static data and same-image Core Node/B runtime/image/control ownership remain a primary CE2 physical-domain dependency. The custom23,919,650byte tables replace runtime ICU loading in a minimal native port; they do not make a concurrently held Node33,107,424byte ICU image free. Original source objects can be nonresident native IO, but a live baseline companion/runtime/image cannot be called nonresident source metadata. Its genuine lifetime/physical owners must be included or genuinely physically closed before the phase, with original admission still valid. No whole128MiB success is claimed while this remains unresolved. This amendment preserves actual counterevidence and continues material source resolution rather than sending the known incomplete route for another positive review.
Exact ICU78 source topology census and domain correction
The authorized inert source-data census is retained in the working port evidence with closed literal decoder, exact original object relations, input hashes, output and the initial rejected source-shape assertion. It reads original Node22.23.2 ICU78.2/Unicode17.0 integer literals only; it does not load ICU, run a candidate, evaluate RegExp or establish physical occupancy. Six further required source objects came from the already held N1 raw Git closure with genuine blob framing verification, without acquiring a new runtime role. The decoder rejects expressions/macros instead of evaluating C++.
The six fixed-size uchar arrays have exactly170,720 bytes: propsTrie_index48,216; propsVectorsTrie_index86,264; propsVectors27,252; scriptExtensions1,124; block_trieIndex1,668; block_trieData6,196. Across all1,114,112 codepoints, the exact original UTrie2 index topology yields11,723 runs of the combined core/three-vector tuple,4,144 general-category runs and1,892 Script_X runs. Column1 individual-bit run counts have maximum1,809. These are representation cardinalities, not accepted-pattern evaluation. They do not include normalization/case/emoji/bidi-derived properties, property alias compilation, case closure or optimized graph/trace copies. A selected compact original-trie route must retain those missing dependencies and exact lookup/closure behavior; the counts cannot justify dropping any property or silently declaring all50 properties bounded by1,809.
This is a material replacement candidate for the23,919,650 byte universal tables rather than a reservation of the arithmetic residual. Original compressed case data has a separate trie with13,544 uint16 literals plus1,672 exception and370 unfold literals; source-directed case closure must preserve the original special cases and mapping/closure order. Merely grouping equal simple-fold values does not establish the exact ICU closeOver(USET_CASE_INSENSITIVE), string removal, complement/fold and legacy non-Unicode behavior. No complete optimized lowering bound follows from the census alone. The whole selected source route remains pending those derivations and the original controls.
Blueprint37's134,217,728 parser/stream bound is not a statement that the entire Node image/RSS is128MiB. The earlier sentence requiring all Node-carried ICU image bytes in that particular subtotal was conditional and must not be read as that normative claim. NQ resident input, tables, program, stack, parser/stream copies and their controls remain in the same parser domain with no second pool. CE1 separately requires current held leases, parser/copy/capture/runtime/IO/metadata to be charged to the same original admission owner before C. Actual runtime/image/early-bootstrap owners need a finite separately stated source layout and lifetime under that owner; they cannot be declared free or exempt merely because the parser clause does not bound entire RSS. No finite runtime/image allowance is supplied by this amendment.
Current controller parseStage retains its full raw Buffer and expanded immutable entry Buffers. A native NQ borrower must share original held byte windows or obtain an exclusive phase with actual physical closure before replacing the Node authoring representation. A function return, moved pointer, logical charge release or duplicate parser instance does not create capacity. The original failing26,214,400 expansion remains retained through the earlier RegExp call, before the aggregate config rejection; no quota/order change is introduced. Actual source/runtime associations can remain nonresident IO, while live runtime/control owners remain genuine held owners.
Full generic capacity handoff to the original capsule consumer
The current checkpoint16 Controller.capsule source keeps ParsedStage.entries Buffer borrowers live across the return/await of channel.sealCapsule; commit retains parsed afterwards for audit/binding correlation. Current native channel providerMessageMaximum_ is67,195,929. Concurrent full generic expanded inventory67,108,864 plus that one-message backing is134,304,793, already87,065 above the unchanged parser domain before other owners. This is a source-derived overlap, not an observed execution result. The accepted owner semantic inventory and failing26,214,400 parse route remain distinct from this generic capacity case.
The proposed owning QualifiedNamespace retains genuine NativeStageRead custody, accepted original native entry byte-window leases and immutable inventory observations. capsuleNamespace() and binding() borrow the same retained objects. Chunk emission consumes original window borrowers instead of copied mutable Node plan buffers; after materialization/seal only path/mode/count/hash observations are needed for later native discovery correlation. Existing Node raw-entry borrowers must have genuine acknowledged physical retirement before allocating the full signer/provider backing. Native replacement bytes must remain in original admitted capsule/window custody with actual IO/readback and original EOF; the readonly stage lease does not manufacture a writable scratch namespace or authority. No positive producer/type or controller integration is implemented yet. The primary constructor/engine owner must select the exact original capsule consumer, storage/write/readback lease and physical retirement interface as part of whole reviewed integration.
Nulling entries, a moved vector, awaiting seal, a function return, finalizer/GC or logical budget decrement cannot prove physical retirement. Source-private original IO windows and exclusive phases are an implementation obligation, not a new public field or narrowed capacity. Full64MiB generic framing must still work; it does not mint QualifiedNamespace or independently authorize a semantic source packet.
Core actor READ_STAGE snapshot and earlier raw phase
Blueprint's canonical semantics actor is Core. Frozen NativeStageRead is companion IO ownership, so the prospective Core-native adapter must not pretend Core possesses the companion HANDLE/FD. Existing operation23 READ_STAGE supplies authenticated inline chunks and final receipt/EOF/metadata. The proposed adapter retains actual native response-window owners, verifies existing offset/length/EOF/hash/metadata order and copies once into one Core-owned original raw ZIP snapshot for random access. No ancillary handle transfer, new operation, callback approval or duplicate Node raw snapshot is selected. Authentic final receipt remains original IO observation, never a parser-generated proof.
The current parseStage source reserves and allocates declared archiveBytes, reads/hashes the entire original stream and genuine EOF, then reads/validates canonical assets, then calls decodeAdmissionZip. zip.ts line44 rejects raw.length above min(owner compressed limit,10,485,760) before central directory/inflate or authored RegExp. Thus the initial source phase must support the full10MiB raw snapshot plus actual concurrent peer/response frame and original controls; the match subtotal's262,144 raw ZIP term only applies after that exact earlier owner limit check. Oversized raw bytes may not be rejected before original full-read/EOF/canonical validation by inventing an early quota. No regex/expanded-inventory overlap occurs for a raw ZIP rejected at that check, but canonical asset/parser controls still overlap the original oversized snapshot.
The snapshot allocation, inline response borrower retirement, original peer/frame carrier and actual authentication/clock/failure controls are not yet positive source implementations. They must be charged to the same original owner; response closure requires real acknowledgement/physical end before a following backing, rather than a logical-copy credit. The native Core adapter itself remains the primary importer/constructor boundary's material source obligation. Existing namespace declarations cannot stand in for that source or an authentic Core-window producer.
JSON record-count bound independent of candidate parsing
For each strict JSON document of B original bytes, count all value nodes N=I+S, where I counts object/array containers and S scalar values; object keys reside in the corresponding member value record, not separate value nodes. Container delimiters require at least2I bytes, scalars at leastS, and commas require N-1-D bytes, where D is the number of nonempty containers and D<=I. Colons, key strings and whitespace only increase B. Hence B>=2I+S+N-1-I=2N-1, so N<=floor((B+1)/2). This proves a syntax representation cardinality without parsing/evaluating any candidate and does not narrow original tokens/members/depth/bytes limits.
For the proposed32byte-per-value record layout and the same conservative4B decoded/scratch allocation, the five maximum documents totaling168,960bytes require at most84,480 records:2,703,360 record bytes plus675,840 scratch=3,379,200, reducing the prior6,082,560 conservative JSON term by2,703,360. The record layout remains a proposal needing exact fields, original key/source offsets and physical owner controls; this arithmetic is not an allocation allowance or a complete fit proof. It does not establish the unresolved optimized RegExp representation or authentic source-owner association. The original raw/expanded retention and earlier failure order remain unchanged.
Bounded original ICU package directory custody
The parent authorized bounded metadata decompression and package-directory/span census of the exact original source object. Original blob5be75974fa3edd433ea08a7a60e880f8fb1221e9 is11,346,114 bytes, SHA256 ccbf06da23e25de9284ba66049f263f8beb8ede796a746ca81888fa55ead130b. Genuine Git framing matches the retained Node22.23.2 source closure. The retained decoder enforces a20MiB source-input ceiling and40MiB decompressed metadata ceiling, checks genuine bzip EOF/no trailing stream, original little-endian ICU CmnD header, finite4305-entry directory, ASCII unique names, bounded offsets and unique physical spans. These are analysis ceilings for this exact source object, not public product quotas or accepted-input restrictions. Output is33,107,424 bytes, SHA256 2cac4f3277df9fa37f8ebd5d3459d4151e99f7d84d99fca5b7392fcd3c880ea9. No ICU load, property evaluation or candidate parser execution occurred.
The exact uemoji.icu source span is14,400 bytes (SHA256 ebf60beb2a2fe55dbc31b7cbd3d3ce8d349ca040c7a35bf13fd5d2c2a07b1fc3); nfkc_cf.nrm is53,440 (04e59e4c1fe38a5611ca64dd18e6607348437c186a8d6cbd61fd5a3442db63bb). Span lengths include original alignment and bound full retained source spans, not interpreted semantic payload. Fixed literal arrays from core/case/bidi/NFC total266,736; adding these two needed package spans gives334,576 before alias/control/source headers and exact generated legacy tables. The other nfkc.nrm source span is56,128 if the selected original dependency walk requires it; no dependency is silently discarded merely because a smaller sum is convenient.
This supplies a concrete compressed original source-data representation route instead of resident universal bitmap/case-class duplication. Exact original algorithms can operate on those held source spans, but the port still requires full original case closure, normalization-derived property lookup, emoji trie lookup, alias validation, Unicode set folding/complement order and optimized virtual/shared class lowering. Directory custody sizes alone do not prove those algorithms, compile graph limits or source/runtime authority. Full same-image Node runtime may separately retain the entire33,107,424byte ICU image; that actual owner's lifetime cannot be renamed this smaller NQ table representation. All original reference source/build associations remain CE2 proposed, not admitted.
Exact optimized deferred-action and greedy-loop obligations
Original regexp-compiler.cc Trace::PerformDeferredActions scans affected registers in ascending order, but each register's actions in reverse historical order. It derives the final store/clear/absolute/increment value and the undo action from the chronologically first applicable action. Capture0/1 stores deliberately omit undo; capture stores choose CLEAR, ordinary stores RESTORE; SET_REGISTER_FOR_LOOP and INCREMENT preserve their exact accumulated/absolute behavior. Original restore scans registers descending, coalescing contiguous clears. Flush first pushes original CP when a concrete backtrack label exists, then pushes RESTORE registers in ascending order, applies final actions, advances CP, and pushes the undo target. On failure it restores descending, then either original backtrack or CP pop/jump. Merely retaining final register values loses this exact stack/undo behavior.
A proposed aggregate action descriptor is32 bytes per original register: tag/seen flags and original chronological-undo selector, final value/absolute indicator, final store CP offset, clear selector, original source/action relation and restore/clear membership. Up to65,536 original registers gives2,097,152 bytes, with three exact affected/pop/clear bitsets at8,192 bytes each. This bounds one fully specified action-summary workspace; it does not prove the number of simultaneously retained specialized traces or final program descriptors. The original action fold/order must be derived for every original action type and both backend stack checks before it replaces linked deferred actions. No compiler implementation or candidate action evaluation was run.
Native original stack_limit_slack controls the periodic check in PerformDeferredActions via (slack+1)/2; original CP/backtrack and register pushes do not all independently perform a check. Full64MiB logical stack and original overflow/order must be preserved, including original slack, without old/new allocation overlap. Checking every slot using a newly reduced payload ceiling would change original failure timing. The retained segmented backing can replace growth overlap only with an exact original checked-push/slack model and actual physical allocation/owner/layout proof.
Original EmitGreedyLoop pushes CP once, emits the first simple text alternative under stop_node/loop_label trace, then checks the saved base and decrements by fixed text length during unwind. It avoids one backtracking frame per matched repetition. The port must retain this behavior; a generic repeated term with per-character frames is not resource equivalent. Original stop_node also bypasses LimitVersions, so kMaxCopiesCodeGenerated10 cannot be applied globally. Shared/virtual class lowering and specialized trace identity remain the unresolved global compile/program bound; the one-workspace2,121,728-byte bound and compressed Unicode spans are not a whole match allowance.
Bounded original greedy-loop exception to version sharing
Exact original compiler header has kMaxRecursion100 and Trace's initial flush_budget100. GreedyLoopTextLengthForAlternative uses if(recursion_depth++ >100), so at most101 simple nodes can be accepted before returning to the loop choice; the102nd fails that source optimization predicate. ActionNode explicitly returns too-complex, while TextNode returns fixed Length. The accepted greedy body therefore has no register actions/inner choice/control nodes; original TextNode::Emit performs its ordered text passes and deferred CP/quick-check/bounds updates, then the stop-node back edge advances by original fixed text length and jumps to the loop label. Source CP offset limits are[-32768,32767]. These are original optimization rules, not new pattern/depth caps.
This provides a bounded source-sharing route for the previously unbounded-by10 stop_node exception: a loop-owner descriptor with its original ordered<=101 text-node relation, CP offsets, original failure/loop targets, source range/alias selectors and pass/preload/bounds state can represent the specialized body without cloning its character-range instruction backing. It must preserve all TextEmitPass ordering and original no-register-action property; a direct scalar class predicate alone is not proof of original astral class alternative effects. Exact virtual/shared class lowering, how generic/specialized labels and deferred-action identities are retained, and their total simultaneous cardinality remain to be proved. The101 local bound does not establish a global101 or10 multiplier per arbitrary graph node.
Original source-bound UCPTrie census also validates the full supplementary18-bit-index branch and every native index bound for all1,114,112 codepoints, yielding469 raw codepoint-value runs for uemoji and8,591 for NFKC_CF. These are raw topology values, not semantic property/range results. Their source hashes, major formats/endian/options/length checks, script and outputs are retained separately from candidate evaluation.
Original Unicode class sharing bound
Actual AddNonBmpSurrogatePairs canonicalizes original astral ranges and groups partial trailing sets by a singleton lead surrogate; only partial first/last endpoints create those keys. There are at most1,024 such lead values. Full trailing ranges are grouped into one separate TextNode with canonical lead ranges. Adding the one BMP alternative and up toone lone-lead andone lone-trail alternative gives at most1,028 original class-choice alternatives, independent of the total property-range count. Lone surrogate alternatives use original negative lookarounds; a scalar Unicode predicate cannot erase those generated register/stack effects.
Original RegExpClassRanges::ToNode also sets do-not-inline when the folded/negated ranges length exceeds32. Actual SetDoNotInline sets trace_count_ to kMaxCopiesCodeGenerated, causing nontrivial callers to flush into the generic choice label rather than emit ten copies of every large property class. Large classes therefore do not inherit an arbitrary tenfold choice expansion; smaller classes and child text specializations still need their complete original label/trace derivation. The grouping map's original iteration order, full-trailing-first order, BMP/astral/lone-surrogate order and lookaround actions must be retained or covered by an exact failure/stack-equivalence proof. No provider or range source is inferred from these graph cardinalities.
This narrows the shared/virtual class lowering candidate to at most1,028 class branch selectors rather than one graph descriptor per universe point. A selected parametric branch-template route would borrow original range/source selectors and generic continuation identities, preserving original macro-operation/stack trace rather than replacing the entire class by an unproved direct matcher. Its total selectors, compiler labels, action histories, specialized continuation identities and actual byte layout are still not a complete whole128MiB proof.
Selected original jitless interpreter reference
The primary Core owner confirms the selected original Core reference remains jitless. Exact held Node22.23.2 flag-definitions.h blob feb025c1d2061e19eeb4d1cf87ed97165faa1d51 has DEFINE_IMPLICATION(jitless, regexp_interpret_all), with regexp_optimization defaulttrue; regexp.cc blob482959a4e680cacda8449c250aac22fa175f94c2 permits bytecode under interpret_all. Both actual raw objects were independently framed/verified and retained. The candidate must therefore preserve optimized Irregexp INTERPRETER behavior for this original selected source/build association. Earlier native-JIT pointer/slack alternatives are research counterevidence, not the selected reference. This does not supply authentic source/build/image eligibility or silently limit the public engines>=22 contract.
Actual RegExpBytecodeGenerator stack_limit_slack is1. Its PushRegister ignores the native check-stack argument and emits PUSH_REGISTER; the interpreter checks every PUSH_CP/PUSH_BT/PUSH_REGISTER after emplace_back. Original BacktrackStack::push appends first, then rejects size above64MiB/4. A resource-equivalent segmented store must retain the full16,777,216 original int32 slots AND one charged original overflow observation slot for push16,777,217 before returning the original stack-overflow exception. It cannot reject before the original write or reduce usable stack to reserve its headers. That extra4byte logical slot needs actual charged physical backing/alignment in the whole arena layout; no uncharged escape slot or old/new128MiB growth is allowed. Original set_sp/pop/read register semantics remain.
Interpreter POP_BT increments original backtrack_count, observes the original configured limit (kNoBacktrackLimit0), then handles interrupts before popping/jumping. The candidate cannot insert a smaller instruction/backtrack ceiling or select the experimental fallback as a language substitute. It uses the producer-held original deadline/clock and must retain original interrupted/overflow private failure order and owners. Correcting the selected backend removes the native32-location slack from this candidate; it does not prove the remaining compiled parametric program/trace/label space or actual original physical controls.