NQ1 R3: original optimized interpreter with compressed source data

Status: HISTORICAL UNACCEPTED COMPRESSED REPRESENTATION CANDIDATE. The conductor now selects the original V8 constructor/test backend in CORE-NATIVE-QUALIFIED-NAMESPACE-ORIGINAL-V8-BACKEND-PRECODE.md; compressed compiler/cache substitution is not selected. All source/proof/failure history is retained. Whole accepted-input transformation and physical peak proof remain unfinished. No positive implementation, factory, execution or architecture GO. This is the same bounded NQ1 unit at draft1694; frozen01, completed independent review and amendment02 remain immutable. R2 contains the derivation history; this document gives the current route without selecting its rejected nonoptimizing proposal.

Actual reference and actor

Proposed CE2 reference source is original Node22.23.2 commit aa4c77582be995286fc6e00aaf530dc7ade102a9, tree cee5f56eb6b8b6b8e300419196dc90e8c7abd64b: V8 12.4.254.21 with ICU78.2/Unicode17.0. Genuine source custody is not realm/build approval. The reference is original optimized jitless INTERPRETER: jitless implies regexp_interpret_all and regexp_optimization is true. Source/build/Unicode data/flags and original clock/allocation association must come from the primary importer's independently admitted source-owner route. Public engines>=22 is unchanged; a version string never supplies semantic compatibility or approval.

Core owns canonical semantic evaluation. Existing23 READ_STAGE carries authenticated inline chunks and final original receipt/EOF/metadata; companion NativeStageRead does not transfer a HANDLE/FD into Core. Core must retain one original native raw snapshot and actual response-window owners without another Node snapshot. Whole10MiB original read/EOF/hash precedes canonical validation and ZIP's262144 owner limit; that limit rejects before expansion/RegExp. The match phase can use262144 raw bytes only after preserving that actual earlier order.

Original source/data custody and finite representation

All analysis is source/raw-data only. Original objects are verified by genuine Git type/length/NUL framing; bounded raw capture uses already held N1 custody. No ICU loading, property semantic execution, RegExp matching, candidate parser/compiler/native/test run or runtime grant occurred. Analysis scripts reject unknown/macro-dependent geometries rather than evaluating source.

Original source representation	Retained bytes/count
Fixed core uchar arrays	170720
Fixed case arrays	31172
Fixed bidi arrays	28652
Fixed NFC arrays	36192
Original NFKC_CF package span, including alignment	53440
Original emoji package span, including alignment	14400
Those six components	334576
Propname source arrays	47034
Additional nfkc.nrm span if required by the complete dependency walk	56128

Original icudt78l.dat.bz2 blob5be75974fa3edd433ea08a7a60e880f8fb1221e9 is11346114bytes. Bounded metadata decompression yields33107424bytes/SHA2562cac4f3277df9fa37f8ebd5d3459d4151e99f7d84d99fca5b7392fcd3c880ea9 with4305 directory entries. Input20MiB/output40MiB analysis ceilings do not change product caps. Exact span hashes, directory, decoders, source layout hashes, raw arrays and failures are retained in working03 pending whole freeze.

Core/vector original UTrie2 raw topology has11723 combined tuple runs,4144GC runs and1892Script_X runs. uemoji UCPTrie encoded4840bytes has469 codepoint raw-value runs; NFKC_CF encoded30620bytes has8591. These are topology metadata, not derived property sets or a case partition. Compressed source lookup avoids compulsory universal23.9MiB tables, but must port all original normalization/case/bidi/emoji/alias/closure behavior with exact original dependencies. Runtime Node may separately retain its wholeICU image; it is not this smaller NQ data owner.

Selected representation route and original observable behavior

The candidate is a source-owned native optimized Irregexp macro-operation interpreter. It uses the original parser grammar, flag admission, AST operators and optimization decisions; it does not disable greedy-loop compression, trace flushes, quick-check/preload behavior, quantifier unrolling, surrogate lookarounds or named-capture relations. Immutable original class data/selectors can be shared across graph copies, while distinct register/continuation/trace identities remain distinct. A parametric macro-operation template replaces duplicated instruction backing only when its original CP/register/stack/current-character/branch effects are proved identical. A direct scalar class predicate is not a substitute for the original generated class choice and lone-surrogate lookarounds.

Original class grouping yields at most1024 partial singleton-lead alternatives plus one full-trailing, one BMP and up toone lone-lead/trail each:1028 total. Classes with more than32 folded/negated ranges set do-not-inline and force generic choice sharing. Smaller child specialization still follows original version rules. Original unordered-map iteration/source-build relation and original range grouping order must be retained or proved resource/failure equivalent; no alphabet/language subset or property omission is selected.

Ordinary nontrivial node versions have the original count10 limit; it is not universal. Greedy stop-node body generation bypasses that limit, but accepts at most101 simple text nodes, contains no register-action nodes, has original fixed CP span within[-32768,32767], pushes CP once and performs exact fixed-length unwind. Shared greedy-body templates retain original text-pass/bounds/preload/failure order and original loop-owner targets. No per-character generic backtracking frames replace them.

Deferred actions retain original chronological undo plus final/accumulated effects. Flush pushes original CP if needed, pushes RESTORE registers ascending, applies actions/CP advance and pushes the original undo target. Restore traverses registers descending and coalesces clears. Capture0/1 intentionally omit capture undo; original clear/store/loop behavior cannot be replaced by final values alone. A32byte-per-register fold workspace and three bitsets upper-bounds one summary at2121728bytes under original65536register bound; total retained specialized histories/labels/program space is still a separate unresolved derivation.

Native macro-operation loops poll the producer-held original clock/end, including source scans, Unicode/property lookup, register work, subject reconstruction and backreference comparisons. No new40second end, compatibility clock, instruction count or reduced backtrack quota is selected. Invalid owner pattern syntax, invalid caught manifest output regex, stack overflow, original end/loss and actual IO failures retain their original private failure order/categories.

Full original stack with no growth overlap

Selected interpreter stores int32 values and checks each original push AFTER appending. Full16777216slots occupy67108864bytes. Push16777217must have a charged overflow-observation slot before original stack-overflow return; early rejection changes original order. Fixed charged segments replace SmallVector old/new doubling overlap, while preserving peek/pop/set_sp, saved registers and bytecode target semantics. Segment/control/custody/page rounding and that overflow slot must all appear in the actual physical arena, outside none of its charges. Native JIT32-location slack and pointer-width arithmetic are historical research, not selected reference.

A parametric program must give every original backtracking target a deterministic fixed-width identity compatible with the original int32 slot model. Dynamic target descriptions may not spill into uncharged storage. Their complete cardinality/encoding is currently unproved; no64bit-per-slot expansion or silently smaller stack is selected.

Ownership phases and current proof obligations

Phase	Original simultaneous owners that must be counted
Stage acquisition	Up to10MiB Core raw snapshot, actual authenticated response/peer/frame owners, original assets/canonical parsers, clock/failure/control carriers. No expansion/RegExp after oversize ZIP rejection.
Compile	Valid raw262144, assets296448, TAR524288, failed authored expansion26214400, retained JSON/source owners, compressed Unicode source owners, original AST/graph/label/trace/program generation owners and actual controls. No matching stack yet.
Match	Same original raw/assets/TAR/failed expansion and JSON/source owners, compressed Unicode owners, immutable parametric program/trace/class operands, indexed subject, register/output arrays, full64MiB stack plus overflow slot, actual original controls/rounding. Compile owners require genuine physical closure.
Generic64MiB emission/seal	One full inventory backing/windows, original compressed input up to10MiB, framing/chunks and genuine capsule/storage/readback owners. Node raw-entry borrowers must physically retire before full signer/provider backing. No semantic qualification follows from generic capacity.
Failure/loss	All held original objects/borrowers and failed IO observations remain; original preallocated failure carriers and actual physical end are counted. No callback approval, renewal, logical-return FREE or fabricated receipt.

JSON syntax independently bounds value nodes N<=floor((B+1)/2); the proposed32byte record plus4B scratch layout for five maximum documents168960bytes is3379200bytes. Exact key/source/child field layout and physical controls still need whole source review. This arithmetic is not a quota.

Current signer/provider envelope67195929 plus full generic Node entry buffers67108864 is134304793, already87065above parser134217728 before other owners. The native consumer needs original private byte windows and genuine borrower retirement; current Controller retains parsed entries across seal and afterwards. Path/mode/count/hash observations may remain after bytes physically retire; GC/null/function return does not prove that retirement. Existing readonly stage windows do not grant a writable spool or replacement namespace.

Blueprint37's134217728parser/stream domain is preserved, with no second pool. CE1 also charges current runtime/IO/capture/metadata/leases to the same original admission owner. It does not by itself make entire Node RSS128MiB. Finite runtime/image/early-bootstrap layouts and lifetimes still need primary original ownership representation. Source-object IO may be nonresident; actual live image/control owners may not be called nonresident or free.

The exact remaining whole source obligations are: complete parametric branch-template/effect proof; all grammar/alias/case/complement/Unicode/legacy behavior; global immutable program/label/deferred-history/target cardinality and fields; original stack overflow and target encoding; actual Core response-window/snapshot/retirement producer; importer/reference/clock/failure/control physical layouts and phase peaks; and authentic CE2 source-owner producer association. Runtime grant absence is separate from missing source implementation/selected layout. None is replaced by a residual allowance, opaque callback, hash/MAC/OS-owner label or constructor flag.

All meaningful prospective whole regressions remain UNRUN. Whole source candidate review must be DIFFERENT and complete after these concrete obligations are resolved. Parent integration, final whole consumer SOURCE GO and NEW authentic execution admission remain required. Working03 has not been frozen or presented as a completed product/candidate GO.

Original READ_STAGE transport overlap is concrete current-source evidence supplied by the primary owner: request body45bytes; outbound Writer81 and sent native-owned81 coexist; inbound header4, received65696(maxresult65664+MAC32) and decoded result65664 coexist,131364 payload bytes before controls/rounding. NAPI retains actual input45 and exposes the same result as an external Buffer; BinaryReader.raw aliases it rather than another chunk backing. Existing finalizeBytes retires the native owner only via GC, so repeated reads do not yet have a deterministic physical borrower end. Outbound/input/control lifetimes cannot be removed from overlap merely by a phase table; the exact source-owned arena and retirement path must prove their closure. These fields/counts supply no calibrated mutex/atomic/string/control occupancy or fabricated fixed reserve.

The native snapshot route must consume the actual unique C++ response before NAPI external exposure and retain the existing authenticated NativeWire sequence relation. TS currently owns sequence advancement; no native batch/sequence-handoff adapter is implemented. A supplied sequence number or private callback cannot grant custody or preserve the original sequence across later commands. The primary boundary must select an original source-owned header-sequence/caller transfer under the same work/clock token, original final raw result/receipt assertion and genuine native borrower retirement. This is an additional concrete source obligation, not receipt qualification or a new public operation.

Compact original trace/root representation candidate

The ordinary immutable root candidate has24bytes, with exact field/effect derivation below. Greedy stop-node context and compile-time quick checks have separate counted records. An immutable deferred action cell has16bytes: tag/capture bits and register/interval selector(u32), original set/increment/store/clear operand(i32), next-cell identity(u32), original source/CP relation(u32). Cells retain original chronological undo as well as accumulated effects. Their complete persistent-prefix count is not yet proved.

Fixed root-ID lists apply only to original limiter-admitted bodies, while the actual visit counter, generic work-list/bound state, flush continuations and greedy contexts remain distinct. Equal trace fields do not suppress an original visit or reuse specialized emission. Assertions, terminals and unguarded single-choice bypasses require incoming-path/template charging. The original ten-body limit is not a universal root/program bound.

Every original saved undo/next-alternative/lookaround/greedy target needs a deterministic int32-compatible identity. Side-effect-free range comparisons may be represented by source-selector templates only after preserving original current-character, CP bounds, preload, branch order and target effects. Source class operands can be shared across unroll copies; flags/direction/register/continuation identities remain distinct. Neither target callbacks nor uncharged descriptors supply this mapping. The complete global graph/edge/flush/history/target charging derivation remains unfinished.

Live Trace field reduction from exact source consumers

Full original Trace consumers narrow the historical32byte immutable root candidate recorded in R2. In regexp-compiler.cc, the performed quick-check state is consumed only by DeterminedAlready (characters and per-position determines_perfectly), Clear and Advance; is_trivial additionally observes characters. Its old mask_/value_ are expressly not updated or reused after Advance. Compile-time QuickCheckDetails::Rationalize/Merge remain complete original work records before the check is emitted; dropping their fields there would be invalid. The already-performed trace can retain characters/perfect bits, shift/clear them exactly, and preserve is_trivial without two persistent32bit mask/value fields.

Accordingly the proposed ordinary immutable macro root is24bytes: virtual-node(u32), deferred-head(u32), backtrack-target(u32), successor-target(u32), CP offset(i16), checked extent(u16), packed at-start/preload/performed-character counts/other original mode bits(u16), flush budget(u8), performed perfect mask(u8). Ordinary roots have null stop_node/loop_label; the original greedy-body template carries its separate real loop-owner/label context. Those extra owners are counted separately rather than squeezed into spare bits. Compile-time quick checks preserve all original32bit Position masks/values, cannot_match, character count and perfect bits; exact originals are reconstructed/retained as work records, not confused with already-performed trace state.

The original interpreter counter is uint32, including its native increment/comparison behavior; native source must preserve that width and original limit0 semantics rather than widen, remove or add a count rule. No claim of an arbitrarily unbounded mathematical counter replaces original code. This source-level reduction provides a concrete field/effect reason for sharing, not a whole program/arena bound; all target relationships, branch templates and compile work lifetimes still need the complete derivation.

Original staged grammar flags remain source-associated

Exact Node22.23.2 source places js_regexp_modifiers and js_regexp_duplicate_named_groups in JAVASCRIPT_STAGED_FEATURES, while harmony_regexp_unicode_sets is shipping. Parser group-modifier branches explicitly test js_regexp_modifiers, and duplicate-name acceptance tests its independent original flag. The reference association must retain actual original image/build/flag eligibility; merely observing parser code for a feature does not enable it. Future source versions or originally enabled staged flags need their genuine original association, not a public Node>=22 version comparison. The native port preserves each reference's full acceptance AND rejection, including these flag-conditioned forms; it neither unconditionally admits staged syntax nor invents a smaller supported regex subset.

Prospective vectors (all UNRUN) include identical scoped-modifier/duplicate-name source under distinct genuinely held original flag associations, rejection under the original default staged-disabled reference, same V8version with different ICU source, changed Node source with unchanged public engines range, and inability of supplied decoded flags to select a positive native profile. Exact original source/build/flag association remains the primary importer dependency.

Original isolate-state optimization dependency

Exact regexp.cc TooMuchRegExpCode checks original pattern length and the conjunction of isolate.total_regexp_code_generated()>1MiB with heap.CommittedMemoryExecutable()>16MiB. The first counter includes previously freed compiled code. Exact original regexp.h source has kRegExpTooLargeToOptimize20KiB, so512byte matched patterns and4096byte syntax-only patterns do not trigger that length term. These constants are optimization decisions, not public quotas or a portable allocation bound.

The selected jitless source may permit a proof that the executable-heap conjunct cannot become true, but neither zero dynamic JIT code nor the separate Node image domain proves that alone. The primary original runtime/physical-owner source walk must establish that invariant or provide genuine original runtime observations at the actual original compile point. A decoded counter, callback-provided scalar, reset after native program retirement or source digest does not supply it. Native port optimization cannot silently depend on its own smaller generated representation in place of the original reference's facts.

Original sample-subject128-character frequency collection and its exact indexed UTF16 location also affect original Boyer-Moore selection. The port must preserve original subject representation, one-byte/two-byte choice, sample and optimization decision dataflow under the same original deadline; no replacement random sample or synthetic runtime profile is selected. This is a material source dependency within the whole optimized route, distinct from missing authentic execution resources.

Exact ICU closure dispatch and retained source operands

Original ICU78.2 uniset_closure.cpp blob ae777c5facdfe2d1c66f3609dce7e38fa7f41051 dispatches USET_CASE_INSENSITIVE to full closure and USET_SIMPLE_CASE_INSENSITIVE to simple closure. Full closure starts with the original set, removes its copied strings, invokes ucase_addCaseClosure for each original codepoint, and separately processes original input strings through full folding and the original unfold table. Simple closure instead invokes ucase_addSimpleCaseClosure and simple-folds original input strings. Both use maybeOnlyCaseSensitive for sets of size>=30; failure to acquire that original property set falls back to the original input codepoints. The optimization and its failure behavior remain a dependency, not a grant to omit source fields.

These algorithms have distinct actual V8 consumers. NeedsDesugaringForIgnoreCase uses full closeOver then removeAllStrings and observes size>1. CharacterRange::AddUnicodeCaseEquivalents uses simple closure; property expansion likewise requests simple closure before string removal. Original compiler legacy filtering uses full closure with its original pre/post filters. Consequently neither a single simple-fold equivalence partition nor a full-fold string table can replace all consumers. The retained31172byte case arrays contain original trie/exception/unfold operands for the source algorithm; their small backing does not prove result-set, iterator, UnicodeSet copy or closure work allocation bounds.

Original simple closure decodes exception slots, conditional-fold I handling, lower/fold/upper/title mappings, optional signed delta and UTF16 closure strings. It skips all four full-mapping strings before reading the closure string. Full closure additionally adds the full-fold mapping string. These exact source branches must survive a compact iterator/lookup port with original UTF16 iteration and failure order; no case/property semantic execution has established a replacement. Source literal unfold header73rows/5units/3fold-string units agrees with370units total, but its raw geometry is not a computed semantic partition. Original closure source and capture failure/correction are retained in working03, pending the complete source-bound packet.

Original graph constructor charging, local derivation

Exact regexp-compiler-tonode.cc supports the following local constructor accounting, counting virtual effect nodes separately from ranges, guards, lists and source operands. Atom/text contributes one TextNode; empty contributes none; capture adds two StorePosition actions around its body; modified group adds two ModifyFlags actions while an unchanged group adds none. Positive lookaround adds BeginPositiveSubmatch and PositiveSubmatchSuccess around its body; negative lookaround adds BeginNegativeSubmatch, NegativeLookaroundChoiceNode and NegativeSubmatchSuccess. Multiline end assertion adds five nodes: choice, newline TextNode, positive-success action, begin-positive action and end assertion.

Unicode word-boundary lowering adds one outer choice and two pairs of lookarounds. Each lookaround adds its TextNode plus two positive or three negative wrapper nodes. For boundary, each branch has one positive and one negative lookaround; for nonboundary the branches have two positive and two negative respectively. Both total fifteen virtual nodes. Their original word-range operands and guards are separate charges. UnicodeLookaroundStackRegister and UnicodeLookaroundPositionRegister are compiler-cached registers; ordinary explicit lookarounds still allocate their own two registers. Source-owned sharing cannot alias distinct explicit-lookaround register identities.

A non-unrolled quantifier adds at most six nodes around its once-converted body: center LoopChoiceNode, counter increment, empty-match check, body-start StorePosition, capture-clear action and initial counter SetRegister. Up to two original guard operands remain separate. Optional unrolling adds one choice per copy; forced unrolling recursively emits the remainder plus the forced body copies. The original nested expansion limiter constrains the product to six, but its accounting must include remainder/control nodes and original conditions (nonempty body, no capture clearing, optimize enabled). It is not a blanket sixfold bound on every program/history owner.

Named backreference lowering emits one BackReferenceNode for each original possible capture, not one per textual backreference. Default staged-disabled duplicate names simplify this relationship, but the complete source-associated flag route must also count the independently enabled duplicate-name case rather than silently using the default as a public syntax cap. Class surrogate alternatives, assertions rewritten in sequences, greedy stop-node emission, root specialization, deferred actions and target templates still require separate global charging. These local constructor counts are source derivations, not a whole arena fit or executed parser result.

Original version admission counts visits, not trace equivalence

LimitVersions increments trace_count on every nontrivial visit before checking recursion, optimize and trace_count<10. It does not look up equivalent trace keys or reuse an earlier specialized body. The proposed fixed root-ID lists therefore cannot suppress an original visit, increment or flush by deduplicating equal fields. Their field comparisons may identify immutable operand sharing only after retaining the original event order and distinct successor/undo identities. Generic versions use the original bound/on-work-list/recursion conditions; greedy stop-node contexts bypass the ordinary limit entirely and remain separately counted.

Only the first nine admitted ordinary nontrivial visits can emit a specialized body, plus the generic body. Later visits still invoke original Trace::Flush under limiting_recursion and can emit CP/action/undo operations. Thus ten bodies per virtual node does not bound all flush roots or saved targets: incoming emission visits and choice-edge continuations must be charged separately. Four deferred-action constructors are stack-local original objects during recursive emission; a compact persistent action-cell route may share immutable prefixes but must count each retained prefix and preserve its original chronology rather than assume ten histories per node. This exact source distinction closes a misleading deduplication interpretation of the earlier root-list candidate; the global incoming-visit/flush cardinality derivation remains open. AssertionNode::Emit has no LimitVersions call and recursively emits its successor; EndNode and NegativeSubmatchSuccess likewise do not use the ordinary version limiter. A single unguarded ChoiceNode bypasses it before the usual choice body. The ten-body bound therefore applies only to actual limiter-using node kinds (text, guarded/multiple choice, action and backreference), not every ordinary virtual node. Assertions and bypass choices require incoming-path/template charging; terminal nodes require per-emission accounting even after their generic labels are bound. This source fact further rejects a universal ten-roots-per-node allocation proof. Original assertion sequence rewrites can reduce chains, but that optimization cannot be assumed to erase all repeated assertion emission.

Small-class specialization has a tighter original alternative bound

The original32-range inline threshold is checked against the post-folding/post-negation ranges actually supplied to UnicodeRangeSplitter. Each non-BMP canonical interval creates at mosttwo partial singleton-lead groups and one full-trailing contribution; full-trailing contributions combine into one emitted alternative. BMP, lone lead and lone trail add at mostone alternative each. For an inlinable class with R<=32 actual ranges, its surrogate-choice alternative count is therefore at most2R+4<=68. This is distinct from the general1028 bound for larger classes, whose choice is marked do-not-inline. It uses no new pattern/range cap and does not assume a shorter property set.

The proposed source-selector template can share immutable original class operands while retaining actual range-group ordering, flags/direction, original generic/specialized visit events, preload/quick-check effects and distinct continuation/undo targets. Larger classes' generic choice body is not evidence that every child or downstream continuation can be discarded. The68/1028 distinction gives a concrete smaller charging input for the whole incoming-edge/template derivation, but neither count alone establishes that complete derivation or a physical-fit claim.

Legacy folding includes original generated build closure

Original gen-regexp-special-case.cc blob86f6b212c93ceeddafa34049fd8c5233d795b0a0 and special-case.h blob753c9231ede397851d7686e07245d71aa50a8bca show that IgnoreSet/SpecialAddSet are generated build outputs, not committed universal tables. The original generator enumerates nonsurrogate BMP source codepoints, invokes full ICU closure, compares the original Canonicalize results, and verifies the resulting special-class invariant before emitting frozen sets. It was not run here. The original tree lacks generated special-case.cc; authentic reference build/dependency association must include the actual generated output or an independently reviewed exact source-bound derivation, rather than infer it from a Node/V8 version.

Canonicalize uses original UnicodeString::toUpper on a one-code-unit string, returns the original unit when the uppercase result has length other thanone, and retains the original unit when a nonASCII input uppercases to ASCII. Thus the earlier prospective65536uint16 map would have finite131072byte backing, but no such native map has been generated, evaluated or admitted. Full uppercase/string/context/dependency behavior and generated-set relationship remain source obligations. The retained generator and header objects narrow the exact missing build relation; they do not provide fabricated generated bytes or a runtime grant.

Quick-check work preserves full original uint32 masks

Original class GetQuickCheckDetails computes common_bits using uint32 complement of SmearBitsRight, so its Position.mask can retain high bits above the16bit code-unit domain. Rationalize later masks CharMask, but Merge compares raw Position masks/values/perfect fields beforehand. Narrowing compile-time masks to16bits can therefore change the original perfect-check decision even for a two-byte subject. A compact source-selector work representation must retain all original32bit values until those consumers have ended. Backward TextNode quick-check collection returns immediately; it does not synthesize a forward mask.

Original GetCaseIndependentLetters retains IgnoreSet/SpecialAddSet, full closure and Canonicalize filtering; its four-letter caller buffers and original pre-filter CHECK are source behavior, not a newly selected pattern/class cap. No executed closure cardinality or manufactured native canonical map is supplied by this analysis. Full source-derived class/work/target bounds remain required.

Original legacy canonicalization has a default-locale dependency

Exact ICU78.2 unistr_case_locale.cpp blob8b6a9ca0ca51a3066fbe8257727dcffb24568ab9 routes the no-argument UnicodeString::toUpper used by original RegExpCaseFolding::Canonicalize through ustrcase_getCaseLocale(nullptr). Exact ustrcase_locale.cpp blob176add9c5108ce1e44013a2617a6fd2e92566944 resolves nullptr by uloc_getDefault(), returning root only for an empty locale and otherwise ucase_getCaseLocale. By contrast original foldCase routes explicitly through UCASE_LOC_ROOT. The native port cannot use that latter fact to infer root uppercase canonicalization.

The generated legacy sets' build locale and runtime Canonicalize locale therefore need their original source/build/runtime association or a complete actual initialization invariant. A scoped exact-commit source search of src and deps/v8/src found the explicit setter only in d8; this is not a whole initializer proof or an observed Node locale. No host ENV, ICU load, native probe or case evaluation occurred. A supplied locale string, version/digest or parser constructor flag supplies neither the original state nor its unchanged lifetime. This is an additional precise source obligation within the genuine reference association, not a new public profile field or smaller accepted pattern language.

Existing metadata container ABI must join the physical owner

Frozen capsule.hpp's NativeCapsuleNamespace has std::string fields and std::vector<NativeCapsuleApproval>, whose path is also std::string. The original reader limits entries to128; metadata is not an expanded64MiB byte borrower. Nevertheless default-allocator string/vector backing and NativeCapsuleRead result containers are actual admission-resident allocations. Returning the earlier proposed const NativeCapsuleNamespace reference does not route those allocations into the primary's one-VM-backed parser arena or account for their physical allocator controls.

The primary moving whole candidate now selects the explicit private metadata view amendment below, requiring complete separate review before implementation. No global operator-new hook, pmr conversion, libc fallback or fixed sizeof-only allowance is inferred. NQ may expose immutable byte/source observations, but its new header alone cannot rewrite the owned capsule container type or manufacture this join. Small immutable metadata/catalog associations can remain live through sign/readback with their genuine charges; full expanded entry byte retirement is a distinct obligation. The primary selected data-level NativeCapsuleNamespaceView candidate replaces default dynamic containers: fixed header816bytes and at most128 NamespaceEntry288 records,37680raw bytes before real backend rounding. Header fields retain bounded original catalog identity256, manifest path240, template ID128, commit40 and version64 with actual lengths, contract/count and five original lease ordinals. Each entry retains path length/path240, mode/authored flag, count, SHA and explicit reserved bytes. The original flag remains metadata; it never supplies semantic qualification or original byte custody.

NativeCapsuleRead uses at most128 ReadEntry288 records,36864raw bytes before its separately derived original object-variant/header and rounding. The proposed NQ accessor therefore joins as borrowed const NativeCapsuleNamespaceView&, a material private ABI amendment to the earlier frozen std::string/vector signature. Immutable original catalog/stage/reference/source leases and inventory byte windows remain genuine owner-held joins. Unbounded repository/source fields remain original source spans. This change requires the full storage/materializer/result-encoder consumer replacement, with no defaultallocator compatibility overload; it is not implemented or approved here. These fixed raw record sizes are not a complete count/lifetime/peak proof. Additional closed source metadata census binds original NFC norm2_nfc_data.h blob562c2b2513e61c0843d60126a51a4aba5fe131e2 to its exact static FAST16 UCPTrie shape and original UCPTrie layout hashes. The1888index/8162data uint16 arrays occupy20100bytes and yield4041codepoint raw-value runs/2304distinct raw values over all1114112codepoints. The decoder rejects changed aggregate geometry, nonliteral/macro-dependent array tokens and out-of-bounds topology; source/read/output ceilings are finite. This extends raw backing/topology evidence only. It does not evaluate NFC/derived properties, prove class-set cardinality or native physical peak. The source decoder/output are retained in working03 for the eventual full packet.

Consumable namespace byte phase and immutable metadata lifetime

The data-level ABI distinguishes OriginalBytesEligible, CapsuleOriginalBytesTransferred and MetadataOnly. stageObservation() remains an immutable genuine original observation/source/catalogue association. originalStageSnapshot() and entryBytes are byte borrowers only while OriginalBytesEligible; no unconditional accessor requires resident raw/expanded banks through signing. QualifiedNamespace's positive production and this private state transition remain unimplemented and require the complete separate review.

Only the primary actual op17 storage producer's complete original append/readback, genuine O2 archive/effect handoff, zero remaining original byte borrowers and observed physical bank retirement can establish MetadataOnly before Windows signer allocation. A callback, supplied receipt, function return or counter decrement cannot establish the transition. The exact original storage/observer join produces the retained capsule/archive association; NQ's parser cannot construct that approval from matching bytes or a digest.

MetadataOnly retains the immutable NativeCapsuleNamespaceView, path/mode/count/SHA and actual source/catalogue/stage/capsule/archive observations with their genuine owners and charges. checkOriginalCustody thereafter checks those retained associations rather than pretending the old byte banks are live. Failure/loss preserves real unresolved objects and attempted IO; it does not force success retirement. No raw archive/spool resource, namespace authority or caller mutation grant follows from the phase names. The complete selected storage/observer transition signature and physical lifetime proof remain in the primary boundary.

Original atom dispatch and lazy syntax-only construction

Exact regexp.cc RegExp::Compile parses syntax and initializes original data; IrregexpInitialize sets uncompiled entries rather than lowering a match program. Full Irregexp compilation occurs when the first actual subject reaches preparation. The unflagged manifest constructor validation up to4096bytes therefore has its syntax/metadata phase without a full match program or64MiB matcher stack. Original atom dispatch is distinct: non-ignoreCase/nonsticky atom trees can select AtomCompile according to HasFewDifferentCharacters. Jitless's interpreter implication applies to Irregexp, not a mandate to force every original valid pattern through it.

Original AtomExecRaw dispatches all four one-byte/two-byte subject/needle cases through StringSearch and retains original match indices. Source string-search.h blob01326900990fc334c9149e0a57dc695e7d8c2f1b selects failure, single-character, linear, initial, Horspool and Boyer-Moore strategies using original conditions. Exact isolate.h blob8f40fe7e101803ce53ddcfe16d8643a001381399 fixes alphabet256/maxshift250 and arrays256,251,251 ints:3032raw table bytes before controls. These are original optimization tables, not a pattern cap. The complete source-owned indexed subject adaptation must preserve original algorithm/code-unit effects and deadline rather than invent a second flattened subject backing.

Original compilation-cache lookup can avoid parsing and lazy code generation; original counters/subject-width compilation and retained reference runtime state remain genuine association obligations. One-at-a-time physical ownership is not evidence that original cache/state never existed. The complete route retains original atom/Irregexp selection and syntax-before-match failure order. No search algorithm, parser or candidate pattern executed here; these source files and relations are retained in working03.

Source reachability can narrow the locale obligation

Current matching consumers request u/iu/imu; the unflagged manifest pattern consumer validates construction only. Exact parser AddCharacter/AddTrailSurrogate desugars Unicode-ignore-case literals when full closure after string removal contains more thanone codepoint. Original generated SpecialAddSet membership requires at leastone other equal-canonical and one other unequal-canonical codepoint in that full closure, so such a character necessarily has more thanone codepoint and is desugared before the atom emit path. The generator excludes surrogate units. Original class text emission uses EmitClassRanges rather than GetCaseIndependentLetters; its quick-check/Boyer-Moore class branches likewise use ranges.

Consequently a complete coherent identical build/runtime ICU closure and whole current flag/callgraph proof may show that the runtime SpecialAddSet Canonicalize branch is unreachable for these actual Unicode matching atoms. This is a source-derived route to remove an unnecessary locale observation, not an assumption that toUpper is root-locale or that arbitrary nonUnicode-ignore-case matching shares that property. Staged inline modifiers cannot silently enable a new consumer route; actual source flags and constructor-only unflagged behavior still need their complete association. The earlier locale source fact remains retained counterevidence until this whole reachability proof is completed, alongside generated-set/source identity and all remaining original reference dependencies.

Scoped flags and optimization traversal preserve original state effects

Exact original parser ParseOpenParenthesis copies the parent builder flags and permits only m/i/s changes, preserving Unicode mode. Its new RegExpParserState receives those flags; grouping captures the actual builder flags into RegExpGroup before restoring the parent state. This source relationship applies even when the original staged modifier feature is enabled; rejecting all such syntax is not selected.

Original ActionNode::FillInBMInfo saves the compiler flags at MODIFY_FLAGS, installs the actual group flags, recurses with the original budget and restores the saved flags even when recursion stops before the resetting action. Original GetQuickCheckDetails instead installs MODIFY_FLAGS and recurses without that local restoration; Emit also installs the original action flags. The port must retain these distinct source effects and caller restoration/order, rather than replace all traversals with a lexical flag lookup. All four GetCaseIndependentLetters call sites are original atom consumers (two emission helpers, atom quick-check and atom Boyer-Moore); the class branches use their actual ranges. This completes the direct call-site census, not all incoming optimization-state paths.

The conditional locale reachability argument therefore requires the complete original parser/group lowering plus compiler traversal flags relationship and identical build/runtime ICU closure. It does not authorize a generic nonUnicode-ignore-case path, infer V8_INTL_SUPPORT, fabricate generated SpecialAddSet bytes or discard an original failure branch. Direct source reading only occurred; no pattern parsing, case evaluation, matching or compiler execution established semantic equivalence. The global graph/history/program bound and shared physical-owner proof remain unfinished.

Assertion bypass can duplicate downstream emission

Original AssertionNode::EmitBoundaryCheck's UNKNOWN next-word path invokes BacktrackIfPrevious independently for before-nonword and before-word. Each invocation recursively emits on_success with its own invalidated-current-character trace. Consequently a bypass assertion can duplicate successor emission; treating every assertion as one incoming-chain continuation would be incorrect. Original ToNode selects BoundaryAssertionAsLookaround only when NeedsUnicodeCaseEquivalents holds, so a Unicode pattern without ignore-case can still reach the ordinary boundary assertion. The actual u consumer cannot be omitted from the complete charging proof.

Original AssertionSequenceRewriter folds identical assertions and replaces a boundary/nonboundary contradiction with failure in consecutive AST assertion terms. It does not itself state a bound for transparent nested grouping between those terms. Complete graph charging must derive the actual post-lowering incoming assertion paths and original state-dependent boundary choices, or select an exact shared continuation representation preserving every original emission/trace/target effect and compiler work/deadline. Neither a universal ten-body bound nor a linear-edge bound has been established here. These source facts sharpen the unresolved whole program/history proof; no candidate pattern or compiler was executed and no universal infeasibility conclusion follows. Exact RegExpGroup::ToNode returns body_->ToNode directly when flags equal compiler flags; changed flags alone introduce the two ModifyFlags actions. RegExpAlternative::ToNode runs AssertionSequenceRewriter on its own AST child list before independently lowering each child. Thus the global proof cannot use that rewriter as an automatic post-lowering assertion-chain barrier across unchanged-flag groups. NQ-R12 records this actual source join as a prospective UNRUN regression obligation, without evaluating a candidate pattern or claiming an executed exponential allocation measurement.

Original interpreter peephole source phase is part of the route

Original RegExpBytecodeGenerator::GetCode selects the original regexp_peephole_optimization flag, whose default is build-dependent REGEXP_PEEPHOLE_OPTIMIZATION_BOOL. Exact retained original regexp-bytecode-peephole.cc blobafe92661e829d37dd9ccc61cdf641e30e19569d3 and header blobd73068c2143c7278e76e95865ece11ce617e5d4c establish six standard source sequences. Selection uses the longest valid sequence plus original argument/address comparisons, not a native optimizer's preferred rewrite. Fused SKIP_UNTIL operations retain their original interpreter effect and interrupt cadence; source equivalence cannot assume unfused dispatch has the same original deadline observations.

The original optimizer reserves its output at the prior bytecode length, retains a sequence trie and five ordered maps for original/mapped jumps, destination usage and source/destination fixups, and allocates the final ByteArray while the optimizer and original generator backing are still live. Interior jump destinations can require preservation of an original suffix alongside the fused operation. Original source explicitly warns that this can increase output length, so output no larger than input is not a valid physical bound. Original operand mappings include signed packed24bit values and original target-endianness branches; target/build identity remains genuine reference association.

The proposed compact source-selector route must represent the same longest-sequence decisions, mapped/ignored jump usage, preserved interior target suffix and final fixup identities without assuming two full program arrays fit. This is a material continuation of the whole program/target proof, not approval to disable peephole optimization or select a different original build flag. The closed two-file raw-capture script and exact source relations remain in working03; no bytecode optimizer, pattern, parser or compiler executed. The complete source-owned representation/physical peak is still unfinished.

Peephole local output bound from exact original instruction geometry

Original regexp-bytecodes.h blob3d51f116f277b6675b19c9c4e30e7cecb6f2561b supplies the following inert source lengths. The preserved suffix starts strictly after the sequence's first instruction when an original interior bytecode target exists; each first instruction is8bytes. Original scanner consumes each replaced sequence once. These are source-layout arithmetic, without decoding/evaluating candidate bytecode.

Original fused sequence	Original bytes	Fused bytes	Maximum preserved suffix	Maximum combined bytes
Bit-table skip	40	32	32	64
Position-checked character skip	28	20	20	40
Position-checked masked character skip	32	24	24	48
Character skip	24	16	16	32
Two-character skip	32	20	24	44
Greater-than/table skip	56	32	48	80

For valid original bytecode targets, each consumed segment therefore contributes at most8/5 of its original bytes; untouched segments contribute exactly their original length. This supplies a local final-output bound replacing an incorrect non-growth assumption, with genuine jump-target validity and exact original source geometry as conditions. It does not bound the prior program length, five map cardinalities/control backing, trie records, growth overlap or whole simultaneous phase. A compact shared operand/preserved-suffix representation still needs exact original fixup identities and final interpreter effects; the8/5 bound is not a parser quota or a physical-fit claim. The bounded original layout capture and relation record are retained in working03. The six exact source chains have18unique trie nodes including the dummy root,17child edges,35argument mappings,10argument checks and9ignored-argument records. Counts derive directly from the retained literal CreateSequence/FollowedBy/MapArgument/check/ignore source calls and shared prefixes; no constructor was invoked. A proposed indexed rule table can retain six u32 fields per node (opcode/replacement/index/startOffset/parent/childHead),17two-u32 edges,35three-i32 mappings,10five-i32 checks and9two-i32 ignored records:432+136+420+200+72=1260raw bytes. List spans/endpoints and actual owner/object/alignment fields remain additional explicit charges; the1260figure is not a rounded backing allocation or whole phase allowance.

Child lookup in this finite standard trie selects a key, not iteration order; this differs from the original class surrogate ZoneUnorderedMap iteration whose build-dependent ordering remains observable. Replacing five dynamic per-program jump/fixup maps still requires the complete program-dependent cardinality/target proof. Static standard sequences do not constitute a hardcoded accepted-pattern subset or supply source/runtime eligibility. Exact source semantics, flag-conditioned ownership and original failure/deadline observations require the complete independent review before a source-owned table implementation. For an original prior-bytecode length P, let J count original distinct jump-source operands and K count actually replaced disjoint sequences. Exact source retains at most J original jump edges,2K mapped edges (each standard sequence maps two jump destinations),J destination-usage entries including entries decremented tozero,K+2 source-fixup entries, and3K+2 destination-fixup entries. The latter preserves one relative start fixup plus up totwo absolute suffix fixup boundaries per replacement; both maps retain their two original sentinels. Thus all five map entry cardinalities together are bounded by2J+6K+4, with physical ordered-container controls still additional.

Original unfused opcode geometry has at mostone jump-source operand per instruction that is at least8bytes, while the shortest replaced standard sequence is24bytes. Consequently J is at most floor(P/8), K at most floor(P/24), and the five entry counts together at most floor(P/2)+4. This source-level bound does not prove P or charge a compressed program by its virtual byte length as if actual entry backing were absent. It gives a finite local term for the complete graph/target derivation. EmitOptimization's temporary delete-jumps list has at mostfive entries per replacement (two mapped plus three ignored); the source Zone retains allocations despite local list destruction, so a prospective reusable five-entry work record needs genuine observed physical lifetime rather than function-return-as-free. No map, bytecode or compiler was executed here.

Register constructor bound can be charged to source sites

Exact AllocateRegister call-site census in original lowering consists of two multiline-end registers, two explicit-lookaround registers, quantifier body-start and counter registers; Unicode surrogate/boundary helpers use the compiler's two lazily cached registers. Capture registers are preseeded once by RegistersForCaptureCount. Emit/quick-check/history visits do not allocate fresh compiler registers. This distinction permits a source-site bound even while the whole emitted-program/history bound remains open.

The original expansion limiter's six-unit budget needs a weighted induction rather than a blind multiplier on all work. For forced-min unrolling, the limiter holds F*(m+1) while m forced body conversions and one remaining quantifier are converted. If the remainder optionally expands r copies, their factor is F*(m+1)r. Charging each descendant copy at its allowed integer remaining capacity makes rfloor(6/(F*(m+1)r)) no larger than floor(6/(F(m+1))); adding the m forced charges is at most floor(6/F). When the recursive optional limiter rejects expansion, the remainder converts the body once under the held parent factor. Direct optional expansion similarly splits the held capacity across r copies. Empty/capture-containing bodies do not enter these unrolling branches. A synthetic remaining quantifier does not allocate the outer unrolled quantifier's absent registers twice.

With the complete grammar source-site association retained, each original capture/lookaround/end-assertion/quantifier site consumes a distinct original pattern unit and contributes at most twelve register slots including allowed copies; base capturezero plus two cached Unicode registers add four. The proposed conservative source-local register bound is therefore12L+4, yielding6148int32 slots/24592raw bytes for matched L at most512. Output capture slots are independently at most2L+2, yielding1026int32 slots/4104raw bytes. This is not a smaller public register/pattern cap; allocations follow the actual original count and full source language. Original unanchored synthetic search has min0/infinite maximum/nonempty body and allocates no counter/body-start register; capturezero and cached Unicode helpers are already charged.

This source-site/weighted-induction proof is a separate review obligation, including every grammar-generated site and original preprocessing/filtering path, before replacing the earlier conservative65536slot bank in the whole peak table. Syntax-only4096 construction still has its actual lazy phase without matching register banks. Root/target cardinality, trace folding work and real owner rounding do not follow from the register bound; no parser/compiler or candidate pattern was executed.

Large surrogate-choice bodies exclude the greedy stop-node bypass

Exact RegExpNode::GreedyLoopTextLength defaults to the too-complex sentinel; ChoiceNode does not override it. Original GreedyLoopTextLengthForAlternative follows only nodes whose virtual length is accepted, and EmitGreedyLoop installs stop_node only on that proven simple chain. A Unicode surrogate ChoiceNode therefore cannot occur inside that chain. This closes the stop-node bypass specifically for the large surrogate-choice body; it does not remove the bypass from original simple TextNode greedy chains.

For a post-fold/post-negation class with more than32ranges and at leasttwo retained alternatives, original SetDoNotInline initializes its trace counter to10, so all ordinary nontrivial incoming visits flush toward its generic version. Its generic body emits once according to original bound/work-list rules; each alternative's full inline or linked out-of-line continuation emits once in that body. The resulting child operand/history charging should not blindly multiply all1028possible alternatives by ten parent specialized bodies. Original incoming trace increments, flush targets, child visit state and shared downstream successor visits still survive.

The single-unguarded-alternative case bypasses the choice limiter and instead reaches its actual child limiter; original one-byte filtering can change retained alternative geometry. That case needs its separate actual source path, rather than applying the multi-alternative lemma unconditionally. These local facts support the prospective class-selector template representation without granting it a whole cardinality/physical proof or arbitrary reordering. No class, pattern, filter or compiler executed here. The primary inert physical-owner-layout-proposal.hpp now defines the actual source-data candidate CapsuleNamespaceHeader816/Entry288 and CapsuleReadHeader160/Entry288. Exact5453byte moving source SHA16cce42d6259a630b5d7686ccf6b49f4eb2d80967bad00db565285271765f346 was fully read and retained in working03 with its private source relation, without compiling or including it. Namespace raw bank remains816+128288=37680; read raw bank is160+128288=37024, adding the now explicit160byte header to the earlier36864entry array. Contract/frame/whole/terminal digests and original association slots remain observed data, never constructor authority or receipt qualification. Backend rounding, record counts and genuine importer/consumer phase joins remain separate whole-proof obligations. Exact ChoiceNode::FilterOneByte preserves the same ChoiceNode when at leasttwo alternatives survive, rebuilding only its alternative list if some were removed; original SetDoNotInline state therefore remains on that multi-alternative node. With zero/one survivor it returns the survivor rather than manufacturing a new specialized choice. The rebuilt source ZoneList and old list coexist in the original Zone, including the two preprocessing filter passes; a native ordered active-view projection needs its real backing/retirement charge instead of treating replacement assignment as physical free.

Original TextNode::FilterOneByte may mutate shared atom quarks through const_cast after Latin1 conversion and canonicalizes its class ranges. A source-span port must keep original input byte leases immutable while retaining the exact derived operand mutation and shared AST alias relation within compilation; merely looking up untouched original pattern units is insufficient. SeqRegExpNode forwards the supplied original filtering flags; this path is distinct from MODIFY_FLAGS installation during emitting/quick-check/Boyer-Moore traversal. Source-only analysis cannot replace it with a corrected lexical-flag interpretation. These original filtering/dataflow facts remain part of the whole exact-reference representation proof.

Flush bitmaps have nested original emission lifetimes

Full original Trace::Flush creates the three DynamicBitSet undo sets affected_registers, registers_to_pop and registers_to_clear, computes deferred effects, then recursively emits its successor before emitting the undo target and restoring affected registers. Those three undo sets therefore remain live across successor compilation. The earlier32byte-per-register fold workspace plus three bitsets is a local computation term, not a whole simultaneous bank allowance. Only the completed folding scratch can be physically reused before successor work, with real original owner/borrower retirement; the parent undo bitmap data must survive.

LimitVersions-triggered Flush sets limiting_recursion so its successor is queued/jumped rather than recursively emitted. Other paths, including Choice's pre-body flush-budget branch and Action begin-submatch handling, can recursively enter a generic successor while prior undo bitmaps remain held. Original RecursionCheck increments in text/choice/action/backreference bodies, but assertion and terminal bypass paths need separate charging. The prospective102-bank ceiling from original maxRecursion100 plus boundary/terminal cases still requires the complete cycle/bypass path proof; it is not a selected owner-slot count. For R registers and W-bit bitmap words the source-data term is threeceil(R/W)(W/8) bytes per live undo bank, before real headers/rounding. An actual fixed bitmap-stack representation must preserve original branch/undo identity and deepest failure ownership, not overwrite an ancestor bank or treat a recursive function return as evidence of physical end. Original DynamicBitSet is not a dense allocated bitmap: it stores the first32membership bits in uint32 first_, then an original ZoneList of unique unsigned register numbers for values at least32. Get observes membership; Set adds only absent numbers. FindAffectedRegisters visits deferred actions and clear intervals, PerformDeferredActions processes registers ascending, and RestoreAffectedRegisters processes descending with contiguous clears. The proposed dense bitmap preserves those membership queries and explicit register ordering; it must separately preserve original control/failure behavior and actual physical owners, not claim the original list had dense-bit storage. Original ZoneList growth/history is a source allocation fact, while W-bit words are the explicit candidate representation. Ancestor membership sets still survive recursive successor emission whichever admitted representation is selected.

UTF8 subject decoding has role-specific BOM and failure order

Actual canonical-policy configuration processing adds the original raw byte count, then completes TextDecoder utf-8 fatal:true decoding before constructing/testing either the iu forbidden-name or imu forbidden-content expression. Its decoder does not set ignoreBOM; strict-json explicitly sets fatal:true and ignoreBOM:true. The native text adapter must preserve the original leading-BOM treatment for each role and validate the entire configuration byte sequence before either regex check, including a candidate which later fails aggregate configuration quota. It cannot substitute replacement-character decoding or run the name test first to avoid text validation.

Original raw byte counts include any BOM even when the resulting configuration subject excludes it. A checkpoint/source-window view must retain that original offset-to-UTF16 relation, noninitial BOM content and actual EOF/decoder failure observation. Actual one-byte/two-byte original string representation remains a separate original Node/V8/ICU codec source dependency; stripping a BOM and observing ASCII codepoints alone does not establish the original representation. No text decoder or candidate bytes executed here. The two-role original source calls and exact ordering are part of the complete borrowed subject/reference association.

Exact original nonstream UTF8 binding and configuration width

Original lib/internal/encoding.js bloba29fe031c8bb50c2100109e2a426d66072417abe selects its UTF8 fast path independently of fatal:true and ignoreBOM, disabling it only for stream requests. The actual configuration and strict-JSON source calls are nonstream. Original src/encoding_binding.cc blob5e0606352d3587383613c7fd005fd06fe8ab50a9 validates the entire input through simdutf::validate_utf8_with_errors when fatal, then removes initial EFBBBF bytes only when ignoreBOM isfalse, then calls StringBytes::Encode UTF8. The ICU ConverterObject's full UChar scratch is therefore not an allocation of this actual selected nonstream route; hasIntl/build/source eligibility and original simdutf dependencies remain genuine reference associations.

Original string_bytes.cc blobaddb7e21ba6a3bbabf3ff5f32240a5e428d176ee uses String::NewFromUtf8 with normal string type. Original api.cc blobf9ce798dc29e1d48c6cb4de84cbcea9ddae0106b forwards that to Factory::NewStringFromUtf8; factory.cc blobd0764779efd209d70438e9be89bff181a9e1e1b1 selects NewStringFromBytes with Utf8Decoder. Exact unicode-decoder.cc blob86c0433be177b8361c570eebbaeb1cdc9c5c92a7 / header blob646120a94a1dc46342a23ddf10787909891ae115 computes Latin1 versus UTF16 from decoded scalar values and allocates the corresponding raw one-byte/two-byte string. Fatal prevalidation precedes this otherwise lossy decoder, so invalid-byte replacement is not reached by a valid configuration subject.

For nonempty valid configuration content after original BOM treatment, this completes the direct source width relation: one-byte when every decoded scalar is at most255, otherwise two-byte; nonBMP scalars contribute two UTF16units. The single-character cache uses the same one-byte codepoint branch. Empty content follows the actual original empty-string root path and retains its original source/image association. This narrows the earlier representation concern specifically for this complete configuration codec path, without assuming arbitrary JSON-created strings use the same construction. The borrowed indexed view can reproduce these source observations without a second full decoded string allocation only after the complete port/physical review. Source captures are bounded original Git bytes; no decoder or candidate data executed.

JSON-created subjects retain their distinct string construction

Exact json-parser.cc blob7bd445f94b2d5529b29872c249edafb9c08197a2 / header blob58fc5c966587c2d093d967776e36458ab796a41e show ScanJsonString collecting decoded width bits, selecting conversion relative to one-byte/two-byte source Char, and MakeString allocating the corresponding one-byte/two-byte intermediate for noninternalized values. DecodeString handles the original escapes into that selected sink. The actual strict-JSON string helper invokes JSON.parse on its token slice, so this native JSON source relation matters to schema string subjects and owner patterns; configuration's direct UTF8 factory path alone cannot establish it.

Original JSON scanning internally selects short string values of length less than10 from a one-byte source for internalization, while keys may always request it. MakeString also has actual matching-hint and original string-table paths. Their genuine original source/image/cache association or complete internalized-width invariant must be retained, rather than asserting every JSON-created Latin1 logical value has a freshly allocated one-byte representation. Noninternalized width allocation is directly source-derived; complete cache/internalization joins remain a precise source proof obligation. This ten-character threshold is original optimization behavior, not a new parser cap or accepted-language restriction. Bounded original source captures are retained in working03; no JSON parser, token slice, pattern or candidate data executed.

Source member index and stage snapshot are separate held owners

The primary inert physical-owner-layout-proposal.hpp source snapshot of5815bytes, SHA256 b5ff6a84639fc7fe2d4a88afff87da1a0db9d541c44f77cd7521b895f19e0846, now includes SourceMemberIndex96. Its five uint64 fields retain ordinal/header/path/body offsets and body length; the record also holds32raw SHA bytes,20Git object bytes, original type/mode length and reserved bytes. Its96byte source layout is a proposed data representation; static assertions were read, not compiled. For47300original source members plus three proposed genuine closure bodies,47303*96 gives4541088raw resident index bytes before actual allocator/control/rounding. This term belongs to the same physical-owner proof and cannot be deducted as nonresident source custody or treated as a remaining-room allowance.

The selected original source carrier is a distinct owner from the Core stage ZIP snapshot and retained expanded inventory. Primary source enumeration reports635654137carrier bytes including all47300original logical bodies and three closure bodies. That reported enumeration does not establish all-body fresh hashes, an authentic source acquisition, a resident backing exemption or a runtime grant. Original source windows/index/actual backing and cache lifetime still require the complete physical classification; the full carrier need not be asserted as a simultaneously resident parser copy without that source proof.

The Core stage input is assembled from original authenticated ordinary23 inline result windows, sequence, final receipt and actual EOF. StageSession remains companion-owned; no companion handle is transferred. Mandatory archive/effect borrowers and exact native snapshot copies must physically end or transfer before the associated payload bank can retire. An observed finish EOF alone cannot reconstruct lost local readback owner history. Namespace OriginalBytesEligible to CapsuleOriginalBytesTransferred to MetadataOnly therefore requires the actual source snapshot/readback/archive join, not a logical return or pointer clearing. The number of actual stage sessions/control records remains an independently derived lifetime obligation, not a count inferred from journal collection capacity.

One-byte lowering precedes Unicode surrogate graph construction

Exact retained regexp-compiler-tonode.cc RegExpClassRanges::ToNode canonicalizes ranges and performs required Unicode case folding, then returns a TextNode when the compiler is one-byte, when flags are nonUnicode, or when the class contains a split surrogate. This branch precedes the Unicode negation/splitting/surrogate-choice construction. Consequently the1028surrogate-alternative term is a two-byte compilation case, not an intermediate graph later discarded by the one-byte filter. One-byte compilation still owns the original folding/range operands and TextNode/filter alias history. Peak phases must preserve that earlier branch and its source flags, rather than charge both different-width graphs as necessarily concurrent or remove folding from the one-byte route.

Internalization does not universally normalize Latin1 strings

Additional bounded original source captures bind factory-base.h blobacbc68090a28ddc1d82cd98614a36d84c4aca158, string-table.cc blobb99e9e6afda12b9807b71cce2e945936b8312395, string-table.h blobeb842a0c8a618a7810c46b5843ca2dfb407e4347, string-table-inl.h blob511a8212169a73aa731b5d437c6a30332ddae748, string-inl.h blob124d830e7449eaf82331812ec866cb1e2622a47a and string.h blob820ec384adb53fcae07ef295068457f29eb35ff6. FactoryBase InternalizeString uint16 overload defaults convert_encoding tofalse. SequentialStringKey matches an existing string by content, independently of representation; its insertion selects two-byte when Char isuint16 and convert isfalse, even when logical content is Latin1. StringTable::LookupKey returns an existing matched object before PrepareForInsertion and can return a concurrently inserted match after preparation.

Therefore a universal invariant that every internalized Latin1 value is one-byte is not supplied by these original constructors. The actual original Core/cache/source lineage must either establish that the specific relevant existing strings were normalized or retain their genuine representation association. This is precise source counterevidence, not a claim that a two-byte cache entry is present in the selected runtime. Original JSON MakeString explicitly requests its own needs_conversion for unescaped substrings; escaped internalized intermediates and pre-existing matches retain their separate original paths. A source-span port cannot silently normalize every lookup hit to freshly derived width and thereby select a different regexp lowering/optimization history. No internalization, parser or candidate was executed.

Boundary successor branches do not install a word-state fact

In original AssertionNode::BacktrackIfPrevious, each call copies the incoming Trace, calls InvalidateCurrentCharacter, emits the prior-character/start checks, and invokes on_success Emit with that copied trace. InvalidateCurrentCharacter only sets characters_preloaded tozero; no word-state fact is installed. For EmitBoundaryCheck's UNKNOWN next-word case, the two prior-character alternatives therefore invoke the same successor with the same trace fields, apart from the compiler/assembler's chronological mutation caused by the first emission. The runtime paths differ in checks and branch placement, but source generation does not pass the proven current-word status into the successor.

This supplies a local representation opportunity: retain a shared immutable successor-description operand and two distinct original emission occurrences, with their own virtual byte offsets/labels and actual chronological compiler-state transitions. It does not authorize deduplicating the occurrences, treating them as one native instruction, or reusing a stale mutable trace_count/cache state. EndNode::Emit bypasses LimitVersions and emits Succeed again even when its label is already bound; assertion bypass runs therefore cannot be bounded merely by generic-node label reuse. The prospective transparent-group vectorR12 remains UNRUN, and complete parsing/rewrite/lookahead reachability plus chronological history compression remain whole-proof obligations.

Original RegExpBytecodeGenerator ExpandBuffer doubles its ZoneVector backing; its length is signedint pc, and GetCode binds the backtrack target then emits Backtrack before original peephole processing or ByteArray copying. A virtual-history representation must preserve these exact original byte positions, fixup/source traversal and real allocation/failure ordering under the admitted reference; an invented instruction-count cutoff or byte-array quota cannot be substituted for the unresolved history bound. Shared immutable descriptions alone establish neither full cardinality nor failure equivalence nor the whole128MiB physical peak.

Actual u-only subject branch is separate from large configuration matching

Frozen canonical-policy.ts validateOwnerPolicy bounds owner string patterns to512UTF8 bytes. Its author-editable scalar maximumBytes values are at most512 for description,120 for name,63 for id,64 for version and256 for repository URL; array items are at most120 for developer names or48 for tags. checkRule rejects the candidate's byte length before constructing/testing its u-only expression. This is an existing source guard, not a proposed smaller accepted cap. Ordinary word-boundary assertion history remains reachable in that u-only branch, even though its subject is small; subject size does not bound compilation history.

The large configuration route decodes raw configuration bytes before its iu and imu matching. These flags select NeedsUnicodeCaseEquivalents and the original boundary-as-lookaround lowering, unlike u-only ordinary AssertionNode boundaries. Consequently the source proof must keep separate concurrent phase maxima: large decoded/indexed configuration subject with iu/imu lowering, and existing byte-bounded editable-string subject with u-only lowering. A global upper bound may conservatively join both, but cannot claim the exact8MiB configuration subject and an unchanged u-only boundary graph are necessarily the same accepted call. Invalid expanded26,214,400inventory can remain held in either route until the original later quota check; no inventory bank is freed by this distinction. All matching/constructor failure order and whole reference compatibility still require the complete history and physical proof.

Configuration-name subject is an original decoded one-byte path

Frozen zip.ts first validates expected paths as printableASCII of at most240characters, then fatal nonstream UTF8-decodes each central-directory name and requires exact membership in that original expected-path set. The yielded AdmissionEntry.path is that decoded name. validateAuthoredEntries revalidates all entry paths before the configuration loop; its forbiddenNamePattern iu test uses current.path, not an arbitrary catalogue string substituted as subject. Combined with the exact nonstream UTF8 factory width relation, this actual accepted-path subject is nonempty one-byte and at most240units. A valid leadingBOM treatment remains the original decoder's behavior, and original raw name bytes/count are retained separately.

The configuration content is already fully decoded before the name expression executes, so its source view/checkpoints remain held even when the iu name test is evaluated first. A denied name short-circuits the imu value expression only after fatal content validation. The name compilation phase can use the actual one-byte lowering branch while retaining the separate content view; it cannot defer validation or discard content owners before the source short-circuit. JSON-created pattern width/cache association remains distinct from subject width. This is a complete source relation for the accepted stage-path role, not a promise that all arbitrary catalogue/runtime strings or edited manifest subjects are one-byte.

Original regexp compilation itself can create two-byte internalized names

The exact retained regexp.cc CreateCaptureNameMap sorts original capture indices, then calls factory InternalizeString with a uint16 capture-name vector. Combined with the source-default convert_encoding=false and SequentialStringKey insertion path above, this is a concrete regexp-owned source route capable of creating a two-byte internalized Latin1 name on a cache miss. It does not require a fabricated external caller or an invented Native API. It still does not prove that a particular selected runtime cache contains such a name: an existing hit can return the original matched representation, and the actual prior source history must be retained.

The same original RegExpCompile checks the compilation cache by pattern and flags before parsing; a hit assigns its retained data and returns. A successful miss stores that data after AtomCompile or IrregexpInitialize. IrregexpPrepare then checks the subject's underlying one-byte/two-byte representation and EnsureCompiledIrregexp uses separate width-specific compiled/bytecode fields, compiling only when the selected width needs it. Therefore constructor/test return does not establish physical retirement of every preceding compiled program; original cache data can retain both width versions. One active match stack can be separately charged, but accepted cache/program/source ownership and original code-generated counters cannot be reset or assumed absent per expression. The native source representation must model genuine cache lifetime or prove the exact admitted cache/reference relation, including existing hits and width versions; no extra parser pool or callback-produced counter is selected.

Additional original case/bidi raw trie topology census

The authorized inert source census now covers the exact ucase_props_data.h bloba34fdd318e358123c3a05360d6b4857d925bb108 and ubidi_props_data.h blob90d1fba117e5fca341db4ca7dfe4cb08d861d425, with original UTrie2 layout blob431f11568e16f0e8dc7eac57d9dfaed052cbe30e. The closed numeric-literal decoder checks source SHA256 and framed original Git identity, exact array lengths and complete selected aggregate geometry, with a1MiB per-source ceiling and exactly1114112codepoint-index observations per trie. It performs raw source topology lookup only, without loading ICU or interpreting a property/case mapping.

The case trie has3132codepoint raw-value runs and493distinct raw values; the bidi trie has2016runs and61values. These counts describe original encoded-value constancy, including source highStart/highValueIndex, not case equivalence classes, property membership or a complete compound semantic range bound. Auxiliary exception/mirror/joining arrays and algorithms remain separate dependencies. The initial aggregate check rejected an inferred null-data offset+128 rather than the exact original0xe08 literal; the failed decoder source and failure record remain retained. The corrected decoder selects only the exact source0xe08/0xed4 fields and emitted the raw census; unknown forms still reject. Working03 holds decoder/input relations/output/failure, not a whole frozen candidate or native peak measurement.

Range-only case closure has a source-algebraic local bound

For a nonbogus range-only UnicodeSet input with R canonical disjoint ranges, the exact case trie3132raw-value runs partition the codepoint domain. Splitting additionally at the four explicit closure special points U+0049/U+0069/U+0130/U+0131 and their successor positions adds at most8cuts. Intersecting the input ranges with that partition yields at most R+3139 nonempty pieces. On each piece, a nonexception raw word gives at most one c+delta interval; an exception raw word fixes the original exception pointer/slot words. Four simple slots contribute at most four constant points, the exception delta contributes one affine interval, and the closure-length mask0xf contributes at most15constant codepoints. The full-fold string contributes at most one additional character point: exact uniset.cpp blob0a63dad9dd0f3f55f74c993d2a39a0ceb36cc4a5 add(UnicodeString) adds a single-codepoint string as that character and otherwise keeps a string member. Retained strings are outside the range-only output of the V8 range consumers.

Including original input ranges, a conservative full range-closure contribution bound is22*(R+3139); simple closure omits the full-fold string contribution and has21*(R+3139). Original maybeOnlyCaseSensitive cannot introduce an additional topology split in an eligible source-correct property set: ucase_isCaseSensitive reads only the same raw props word or its fixed exception word, so its membership is constant on each raw run; its documented acquisition-failure fallback uses the whole original input. These are source-algebraic interval bounds, not computed case mappings or native allocations. No Unicode property/case/candidate was evaluated.

This lemma selects a finite local range-transformation route for review: retain original raw trie/exception source associations and represent affine/constant interval contributions without a full codepoint map. It does not yet supply the total simultaneous class operand bank. R for every original property/compound class, generated legacy IgnoreSet/build association, original strings/failure/order, sorted canonicalization/workspace and old derived-range history remain separate whole obligations. Source-private arena/borrower controls and a genuine consuming transfer are still required before any workspace can end. The additional bounded UnicodeSet source capture initially failed on a trailing allowlist comma; that failed capture script/record is preserved before repair. No native port implementation or whole semantic/physical GO follows from the lemma.

Literal desugaring has a smaller point-local case term

Original RegExpTextBuilder NeedsDesugaringForIgnoreCase creates a singleton UnicodeSet, performs full closure, removes strings and tests size greaterthanone. The full per-codepoint source adds at most21character points beyond the original point, so this particular singleton decision owns at most22character points before canonical merging, plus separately retained full-string/control/failure work. It is not a3132-run enumeration or a full Unicode map. When desugaring is chosen, AddClassRangesForDesugaring constructs a singleton RegExpClassRanges; its later actual Unicode range folding uses simple closure, with at most20added points plus the original point. Pending lone surrogates and paired nonBMP literal handling remain the original parser paths.

These source point-local terms distinguish literal desugaring from an arbitrary wide/negated/property class. The1028surrogate-choice upper term is not automatically needed for every case-insensitive literal class; exact choice/control counts still follow the original grouped-surrogate lowering and source width branch. Total duplicated literal operands under forced quantifier expansion, original full-fold decision scratch/strings and alias history must be counted in the whole grammar proof. No case points were generated, evaluated or substituted, and no per-pattern acceptance cap changed.

Owner policy carries nine pattern slots, not nine runtime cache entries

Frozen closed manifestFields has five scalar string rules for id/name/description/version/repository URL and two array-item string rules for developer names/tags; enabled has no pattern. Configuration supplies two additional pattern slots. Every owner pattern slot is byte-bounded to512 by actual validateOwnerPolicy, so these nine source slots contribute at most4608UTF8 pattern bytes in an admitted policy. Repeated array-item checks reuse the same original item rule and u flag. The two configuration slots have iu and imu respectively; string-content equality between differently flagged slots does not merge their original cache keys.

This fixed source-slot count is useful for counting retained policy operands, but it is not an original runtime cache capacity or a proof of only nine code versions. Actual one-byte/two-byte compiled fields, prior realm cache entries, cache eviction/recompilation, syntax-only manifest expressions and source code-generated counters remain separately owned. A native representation may refer to the same immutable original slot data for repeated checks after review; it must compile at the original first reached call rather than eagerly compile an unused later rule and reorder its failure. No nine-entry cap, fresh realm reset or precompiled policy grant is selected.

Genuine runtime counter sampling and compressed compiler history are distinct

The primary prospective producer is actual same-image Core CommonEnvironmentSetup construction: retain setup isolate/environment in OriginalCoreRuntimeLease before linked binding/environment loading, then borrow/sample on the genuine owning Core thread under its original Locker/IsolateScope. This is a concrete source producer route under the primary constructor/runtime boundary, still a whole-review candidate with no positive lease implementation or runtime grant. The companion cannot receive a fabricated Isolate pointer, NAPI tuple or decoded counter as that association.

Exact newly retained isolate.cc blobc2cc0458bb644ca362e848a50935c458621475fa IncreaseTotalRegexpCodeGenerated adds code->Size(cage_base) to the original counter. Original Assemble invokes it after GetCode produces the actual original ByteArray/Code. A genuine current Core-isolate sample therefore establishes the actual native runtime counter at that time; it does not automatically supply the reference counter changes for source-port compilations whose code is represented as compressed native history rather than that original heap ByteArray. Counter size includes the original heap object's representation/rounding, not just pattern bytes or virtual unfused bytecode length.

The complete native port must join actual original baseline/runtime/cache samples with its exact source-derived compile-miss, original post-peephole object-size and width-version history. Any reference-semantic derived history must be explicitly typed as internal algorithm state, distinct from genuine runtime observations and from source/admission authority; it cannot masquerade as an actual heap allocation, native read receipt or approval. Resetting the genuine counter or calling the original increment with a fabricated heap code object is not selected. Complete object-size ABI, cache/recompilation and interleaving/lifetime relation remain part of the amended whole source proof. No source-private counter hook or positive factory was authored.