@techspokes/typescript-wsdl-client 1.1.5 → 1.1.8

package/docs/content-model-s06-re-01-scalar-witnesses.md

@@ -1,1423 +0,0 @@
-# S06 RE01: Scalar Witness Construction
-
-Bounded scalar endpoint selection and the remaining full-construction obligations. See the root [README](../README.md).
-
-## Status and ownership
-
-The same sole nonauthor independently accepted this supplied fixed-anchor endpoint-tuple decision and witness theorem within the [RE01 continuation](content-model-s06-re-01.md).
-It is not an implemented endpoint solver or a complete scalar/RE01 witness producer.
-The existing [scalar owners and selected P1/F2 rules](content-model-s06-re-01-resolver-implementation.md#selected-scalar-comparison-policies) retain their contracts.
-General helper coverage, native/evidence adequacy, complete negatives, mathematical termination and dated correspondence remain open.
-
-The [RE01-A sufficient-class construction](content-model-s06-re-01-support-reconstruction.md#re01-a-private-scalar-construction-theorem)
-now derives separate new Boolean/retained LIST choices for closed input classes S0/S1, with complete native evidence.
-It preserves inherited ITEM identity and funds each new enumeration through its own real immediate L0.
-Equal words in distinct ordinary consumers may select different tags; actual shared readers remain binding.
-This removes the global shared-ITEM assumption for those classes, not for arbitrary future owners or recursive programs.
-
-The [grounded binary WORD construction](#grounded-binary-word-bounds) derives a finite encoding bound without a supplied TOKEN count. Its [joint-constructor prerequisites](#remaining-joint-constructor-and-evidence-gates) remain open; the construction is a reviewed mathematical ingredient, not an implemented general solver.
-
-The [enumeration-introduction correction](content-model-s06-re-01.md#enumeration-retention-and-new-introduction) separates equal value-set coverage from genuine component retention.
-An enum producer must either establish same component/equal complete annotation or prove every newly introduced value belongs to its immediate base.
-Unknown annotation equality cannot silently supply retention, and a failed new-introduction attempt cannot reject a still-possible retained component.
-This owner correction does not establish the general enum lexical-map producer or a complete scalar materializer.
-
-The [raw-group authority correction](content-model-s06-re-01.md#raw-facet-groups-and-identity-authority) separately prevents caller-added identity fields from entering internal facet comparison evidence.
-Literal input equality or object sharing never supplies an authenticated inherited component selector.
-The [qualified immediate-base selector](content-model-s06-re-01.md#authenticated-current-source-component-retention) preserves its earlier RAW and SOURCE ordinal conventions, including pure SOURCE QName ancestry and the stated singleton-DECIMAL union sector.
-The [complete formed-inventory fallback](#complete-current-component-replay) also supplies current BASE components outside those earlier sectors.
-The [atomic GSC1 controls](#actual-atomic-gsc1-component-replay) retain the original generated-scalar example.
-Complete scalar recipe reconstruction remains a separate adequacy obligation, with no general negative answer inferred from an unproved literal copy.
-
-## Complete current component replay
-
-The immediate-BASE selector can export a complete determinate inventory from formed SOURCE, GSC1 and RAW scalar descriptions, including LIST, ordered UNION and genuine intrinsic components without a source layer.
-The existing exact component-set and earlier SOURCE tables retain their ordinals; the fallback orders reduced scalar kinds before their actual repeatable components.
-An unresolved legacy reduction does not become a complete inventory.
-
-The scalar owner retains actual component identity, opaque annotation information, typed operands, formation debts and semantic dependencies.
-Only genuine compiler-owned intrinsic introductions retain intrinsic pattern authority; caller expressions and shared Facet objects cannot create it.
-Legacy RAW layers expose their completed normal form rather than every unreduced conjunct as a new component.
-Private occurrences belong to immutable rows and their reduced kind or layer position, so inherited rows preserve annotation correspondence while their values and debts are reformed in each context.
-
-All selected recipes still require ordinary F2, complete enum/pattern retention and the applicable constituent checks.
-A wholly NEW bound kind may contain multiple tuples when ordinary F2 checks every tuple; this does not permit mixing KEEP and NEW within that kind or reduce a hard PROPERTY template to one endpoint.
-No property-equal sibling supplies another BASE's retention authority.
-
-Retaining authentic BASE components also permits changed LIST items when actual ITEM derivation and ordinary facet duties succeed.
-Changed earlier ordered UNION members additionally invoke their actual selected-image containment check.
-The [native LIST preparation record](#native-list-preparation-and-actual-union-image-duties) distinguishes these obligations.
-Equal constituent identities are a sufficient special case, not an additional qualification requirement.
-The [changed-constituent controls](../test/research/re01/changed-scalar-constituents-retention.test.ts) use a QName guard to select a required STRING value at a later namespace map while retaining the BASE's opaque pattern component.
-The complete forest checks the actual head memberships, required consumer restriction and every fresh root.
-Wrong guard namespaces, an unqualified NEW STRING enum and an incompatible LIST item still fail their ordinary owners; an unchanged-member alias remains FULL but fails the required consumer mapping.
-
-The [native controls](../test/research/re01/current-scalar-component-retention.test.ts) cover a proper SIMPLE restriction role over a SOURCE NCName scalar with an opaque enum and intrinsic patterns, plus a new enum over its actual BASE.
-The selected GLOBAL role has different effective membership at its two existing heads; reusing the exact BASE violates the retained choice's UPA.
-That control demonstrates the chosen role constructor, not that every root witness must introduce that GLOBAL.
-Further controls retain opaque legacy RAW components through a complete required child, preserve a hard multi-NEW-bound inventory, and reject invalid selectors or new values.
-
-These owner repairs supply current component authority and ordinary formation, not a general scalar catalogue.
-General private alias endpoint bounds, a complete changed-member UNION VALUE catalogue, typed VALUE/map representatives, coverage and mathematical termination remain separate proof obligations.
-
-## Empty name inverses in the actual lexical context
-
-A QName or NOTATION value has no lexical spelling when its namespace has no binding in the actual word context.
-That is a proved empty inverse, which the existing scalar owner distinguishes privately from an unsupported inverse representation.
-It constructs the empty language directly; an empty expression would instead admit the empty word.
-
-An inverse for a LIST is empty if any item inverse is empty, including after an unsupported item.
-Without an empty factor, unsupported remains unsupported; the zero-item LIST still has the empty word as its inverse.
-Absent and explicitly empty default bindings preserve the empty namespace, and named prefixes retain their actual map entries.
-
-The [native controls](../test/research/re01/scalar-empty-name-inverse.test.ts) check six complete forests for QName, NOTATION, LIST and the default/named-prefix cases at the normal configured budget.
-They retain every original and fresh root, reject an unbound spelling, and accept the same typed value with a genuine later binding.
-A separate changed-member contrast still rejects a STRING value exposed outside the immediate BASE image through ordinary F2.
-Complete empty inverses can establish that containment failure before the later enumeration-introduction check.
-
-This repair supplies the existing inverse authority without adding namespace bindings, transporting receipts or weakening component formation.
-The complete changed-member catalogue, finite simultaneous qualifier stock and general acceptance gates remain open.
-
-## Actual atomic GSC1 component replay
-
-The original atomic GSC1 case uses a complete supported inventory from its actual formed slot.
-The scalar owner derives that inventory from its actual current scalar tuples and repeatable layers, preserving component identity, opaque annotation identity, assessed values and source obligations.
-It returns unresolved when any component lacks a supported replay introduction; it does not publish a partial inventory.
-
-The [source fixture](../test/conformance/fixtures/xsd/recovery/generated-scalar-component-retention.xsd) has distinct A1/A2 slots with equal facet values, inherited enumeration `{1,2}` and a later minimum-exclusive bound of one.
-The inherited enumeration still exists although one is outside the current value image.
-A new scalar over exact A1 can retain that actual component and introduce enumeration `{2}`, matching sibling Y's facet values without borrowing Y's distinct annotation component or authority.
-
-The [native controls](../test/research/re01/generated-scalar-component-retention.test.ts) supply a complete finite forest and retain every fresh root.
-An exact A1 binding completes but has different facet properties; a sibling Y binding or literal inventory can match the properties while leaving F2 unresolved.
-Missing KEEP, an invalid ordinal and introduction of a new enumeration value one are rejected independently.
-
-Inherited and chained selectors retain their actual typed operands and dependencies.
-A genuine intrinsic pattern with a replayable layer keeps its private compiler mark through the selected successor; caller data cannot create that mark or a component identity.
-Existing SOURCE and RAW ordinal tables keep their order, and all new components still undergo the existing P1/F2 checks.
-
-This closes the displayed atomic generated-scalar representation gap; the complete current-inventory owner above extends its representation support.
-General scalar coverage, native evidence adequacy, encoded bounds, complete negatives and mathematical termination remain open.
-
-## Free ordinary UNION qualification reductions
-
-These reductions concern a new proper UNION alias before birth whose required ordinary typed values form a finite set V.
-Exact TYPE, component, WORD/map, source and PROPERTY observations remain protected input boundaries.
-They do not authorize rewriting an inherited row or transferring a receipt between contexts.
-
-### Removing a later top enumeration
-
-Every enumeration component retained by the final alias contains every value in V, since ordinary assessment checks each component.
-At the first genuinely NEW top enumeration on its restriction path, each value in V therefore had an actual immediate-BASE lexical representative, with its own qualified facet word and map.
-The prefix immediately before that introduction already serves V; an authentic same-members KEEP restriction can preserve a required proper named restriction role.
-
-An inherited input component or an annotation-retained equal component is not a NEW introduction for this argument.
-The reduction stops at an exact later identity, BASE, PROPERTY, component or WORD/map observation.
-It removes unnecessary top-enumeration qualification chains, while member-guard formation remains a separate obligation.
-
-### Input QName image without an extra witness variable
-
-Fix an authentic input BASE and one actual namespace map.
-Restrict raw words to those whose collapse normalization is a single QName token.
-On this scope the supported input atomic admission masks are regular; the IEEE overlap consists of INF and NaN, and an earlier LIST alternative has exactly one token with its actual ITEM, length, enumeration and conjunct checks.
-
-Compile each actual first-selected QName branch with all earlier admissions excluded and every top filter using the selected result's normalization.
-Project collapse normalization and quotient each bound prefix to obtain a regular local-name language for each namespace.
-A proposed QName interceptor belongs to the input selected image exactly when its namespace and local part satisfy these languages.
-
-NOTATION also retains its actual registry and qualified enumeration restrictions.
-Reserved xml and unbound named prefixes retain their existing meanings.
-Absent and empty default bindings both give an unprefixed QName namespace ''; an unbound nonempty prefix fails.
-This eliminates the alternative QName witness word by concrete regular operations; it does not assert that every datatype image has a regular raw preimage.
-
-### Remaining closure obligation
-
-A QName qualifier preserves its local part while changing only the prefix spelling and map.
-For a positive duration spelling that is also a QName token, STRING and URI preserve its nonspace characters, a QName prefix prevents duration parsing, and an admitted unpadded base64 spelling fixes the same nonspace encoding.
-Thus alternative atomic qualifiers in this component preserve one duration value; finitely many correlated spellings can use the shared finite-k endpoint theorem.
-
-This atomic observation does not cover multi-token LIST bridges or bound the number of required qualifier profiles.
-The remaining proof must extract an input-bounded, qualifier-complete observation stock and reconstruct genuine F2 steps over exact prior member identities.
-Finite traces alone do not establish that extraction, a complete scalar catalogue, general negative answers or mathematical termination.
-
-## Why a new endpoint operation is required
-
-Literal complete-payload copying is not always a legal restriction under selected F2.
-For an exact DECIMAL base with fixed minimum one, nonfixed minimum zero and enumeration one, a proper successor retaining only fixed minimum one and enumeration one forms, but the complete copied set violates the universal fixed duty.
-Empty result patterns do not waive that duty.
-
-Choosing only existing input facet components is also incomplete.
-Take c with maximum-inclusive two, then a retaining that component and adding maximum-exclusive one.
-A proper successor can retain exclusive one and replace inclusive two by inclusive zero, whose endpoint genuinely belongs to a.
-Every subset of a that represents both inherited upper kinds retains inclusive two and fails its cross-base comparison to exclusive one.
-A new admitted endpoint is required in this displayed case; it does not prove the absence of a finite endpoint producer.
-
-Source binding is a separate representation.
-For b with maximum-exclusive one and source a adding maximum-inclusive zero, the nonexact original-bound route normalizes its effective property view to inclusive zero.
-The public facet comparison distinguishes that view from a's two-kind source property view even while both enforcement layers remain.
-Native clearance of that normal form does not prove preservation of the same complete effective tuple set.
-The earlier unconditional alias-completion premise is withdrawn; the original-bound full-tuple and finite flat-sector proposals remain held pending their precise semantic proof.
-The [independently reproduced baseline](https://github.com/TechSpokes/typescript-wsdl-client/issues/234#issuecomment-6302941731) records complete forests and exact limitations.
-
-## Supplied shared endpoint tuple theorem
-
-The input supplies a finite number k of endpoint roles, at most four in the intended F2 application, one or finitely many exact fixed formed atomic descriptions a, and finitely many authentic constant operands.
-The unbounded primitive families covered directly are decimal, duration and the eight selected DT A calendar families dateTime/date/time/gYear/gYearMonth/gMonthDay/gDay/gMonth.
-Float/double have a separate finite-value case below.
-Every effective pattern, facet, whitespace mode, base recipe and typed input constant is finite qualified input data, interpreted by the current scalar owners.
-This does not synthesize an input scalar description or decide whether its source authority exists.
-
-Each endpoint x_i must either belong to Image(a_i), meaning it has a genuinely admitted lexical representative in that exact a_i, or equal one of a specified finite list of inherited exclusive-endpoint constants.
-The finite branch tag distinguishing those alternatives is retained for later facet formation.
-The input constraint is any finite Boolean combination of actual sameValue/fixed-property equality and values.compare outcomes less/equal/greater/undefined, between the x_i and between them and fixed input constants.
-Actual primitive-family, calendar timeline and native comparison conventions are retained; undefined is not silently replaced by inequality.
-
-There is an effective TOTAL decision procedure for this supplied finite tuple problem.
-On success it constructs one coherent tuple of exact values, a genuine lexical witness in a_i for each Image branch, and finite encodings of the exceptional constant branches.
-It gives a computable encoded bound from the WHOLE supplied input, including patterns, constants, families, k and the formula.
-No fresh bound is inferred from concrete pair-comparison APIs alone.
-No F2 component-set constructor, type-count bound, current-H forest lift or source/materializer adequacy is concluded by the tuple decision.
-
-### Unary membership is compiled, not asked of a new oracle
-
-For every Image branch introduce one lexical-word recipe whose primitive assessment yields x_i.
-Use the exact qualified input pattern-language conjunction, actual whitespace preimage and primitive lexical grammar.
-For EACH layer/conjunct apply exactly the normalization and normalized operand string observed by that owner before pulling its pattern mask back to the common raw word.
-Do not replace several owner-specific masks by one parser-trim condition or silently test a pattern on the final canonical value string.
-Each input scalar value facet is also compiled: bound facets use the same order outcomes as the formula below, an enum is a finite disjunction of actual equalities, and applicable decimal precision facets have regular digit predicates.
-Retained conjunct descriptions and inherited pattern layers are all included.
-Formed input annotation, final, source and facet-property qualifications stay input facts; they are not inferred from this word test.
-
-For calendar/duration, applicable value facets are patterns, enum and bounds, with their actual whitespace behavior; no unbounded value-length or precision predicate is invented.
-For decimal, the existing exact fixed-bound and fixed-precision spelling languages give the corresponding regular unary tests.
-Alternatively these regular predicates can be derived by a finite scan of sign/zero/significant-digit/trailing-zero classes and fixed input counters.
-No IEEE lexical fiber is asserted regular by this step.
-
-The field decomposition below can include regular outer-whitespace blocks whenever the actual selected normalization/parser permits them.
-It never removes a raw whitespace distinction merely because a calendar parser internally trims a token.
-The proper semantic numeric whitespace mode is collapse, but the construction uses the supplied qualified owner's actual language rather than a new whitespace policy.
-
-The existing internal admissionLanguage/calendar/duration bound and temporal-alias owners can supply the same unary regular mask for these families.
-The construction does not require their public API to expose an Image(a) oracle: their finite equations, or the direct word-and-value construction here, are sufficient.
-
-### Finite field cases preserve whole-word pattern coupling
-
-The actual decimal/calendar/duration lexical grammars have finitely many delimiter/presence/sign/fixed-field cases.
-Calendar month/day/hour/minute/timezone and integral-second cases are finite; unbounded fields are the signed year magnitude and an optional finite fractional-second digit string.
-Duration has one global sign and optional Y/M/D/H/M/S fields, with unbounded nonnegative integer digits and an optional seconds fraction.
-Year-zero exclusion, extended-year leading-zero rules, valid dates, hour24/second60 overflow and legal timezone offsets use the exact source cases.
-Reduced families use their actual fixed reference date and time normalization.
-
-For one case write its lexical word as c0 u1 c1 ... ut ct, where the c_j are fixed separators/finite fields and the u_j are variable digit or whitespace blocks.
-Take a complete DFA for ALL whole-word regular masks of that endpoint.
-Guess its finitely many states before and after each u_j; check each fixed c_j by its literal transition.
-Then u_j ranges over the regular path language between those states, intersected with its exact block grammar.
-The union of these finite cases is EXACT in both directions.
-This is a factorization of one whole-word DFA, not independent image-nonemptiness reasoning.
-
-Thus each case has finitely many independent regular digit tracks and fixed sign/shape flags, while retaining every cross-field correlation encoded by the input regex through the chosen boundary states.
-Zero-valued omitted fields are literal zero constants, not compulsory new lexical fields.
-Leading and trailing zeros in actual fields are retained whenever the input masks require them.
-
-### Exact value coordinates are piecewise affine
-
-For decimal the coordinate is sign*(integer part + finite fractional part).
-All values are terminating base10 rationals, without floating approximation.
-
-For a calendar lexical field year y, write y-1=400q+r with 0<=r<400.
-The actual ordinal source equation is
-
-`ordinal(y,m,d)=146097q +365r+floor(r/4)-floor(r/100)+(y<0?366:0)+before(y,m)+d-1`.
-
-The input year is nonzero, sign is a finite case and month/day are finite.
-Leap status is determined by y mod400, so before(y,m) is constant in that case.
-The exact timeline coordinate is then 86400*ordinal plus bounded clock/timezone constants plus the finite decimal fraction.
-For reduced families insert the source's fixed reference fields.
-For time, its final modulo-day normalization is split into finitely many bounded day-carry cases, imposed by linear inequalities.
-The local/zoned flag is kept as a genuine finite value coordinate.
-
-For duration the actual value is the PAIR (M,S), with one lexical sign:
-
-`M=sign*(12*Y+month)` and `S=sign*(86400*D+3600*H+60*minute+secondsInteger+fraction)`.
-
-Write M=4800q+r with 0<=r<4800.
-For each of the four FIXED comparison anchors, its shifted continuous year is 400q+t_r for a computable integer t_r, and its target month is fixed by r.
-Split further by the sign of that continuous year, because Option A converts it to year C>=0?C+1:C and omits year zero.
-Month-length clipping of the fixed anchor day is then a finite residue/sign case.
-The source ordinal equation therefore gives an anchor instant
-
-`A_j(M,S)=12622780800q + S + c_(j,r,sign)`.
-
-Here12622780800=146097*86400; all c values are computed exactly by the pinned calendar source law.
-If needed the finite branch also records the target-year sign boundary explicitly by linear inequalities in q.
-No literal infinity, approximate month length or assumption of a universal raw calendar identity is used.
-
-Every parsing/coordinate condition is consequently a finite Boolean combination of linear equations, strict/non-strict inequalities and congruence cases on integers and finite decimals.
-The quotient variables q are ordinary existential integer tracks, with their defining linear equations and finite residue cases.
-
-### Actual equality and partial orders
-
-For same-family decimal, equality and order use the exact decimal coordinate.
-Different primitive families follow the actual values.compare/sameValue guards and can be evaluated as finite false/undefined cases rather than coerced.
-
-For calendar values, sameValue requires the same family AND local/zoned flag AND timeline coordinate.
-On equal flags values.compare compares the coordinate.
-On different flags it compares the certain coordinate to the uncertain coordinate minus/plus50400seconds, with STRICT exterior inequalities.
-The remaining interval, including endpoints, yields undefined; equal coordinates across different flags never become value equality.
-
-For duration, sameValue and compare-equal mean BOTH M and S are equal.
-Otherwise compare-less means all four A_j values are STRICTLY less, and compare-greater means all are strictly greater.
-Every other case is undefined, including any equal sampled instant or opposed signs between samples.
-In particular equality of the four sampled instants does not establish duration equality: P400Y and P146097D retain different(M,S).
-These are finite Boolean linear formulas after the residue/sign split.
-
-An inherited exclusive endpoint can remain outside Image(a) only through its explicitly selected allowed branch.
-It is never manufactured by an unproved ordinary-membership shortcut.
-
-### One common decimal-point track encoding
-
-For a finite case encode ALL unsigned integer and fractional fields, quotient magnitudes, fixed constants and linear auxiliary values as one finite word of digit columns with one common decimal-point marker.
-Signs are finite external flags, so negative quantities are signed linear combinations of unsigned tracks.
-Integer field digits occupy the integer side and receive arbitrary LEFT padding with a distinguished padding symbol.
-Fractional field digits occupy the fractional side and receive arbitrary RIGHT padding.
-Padding has arithmetic value zero but is distinct from a raw digit0, so removing padding recovers the original field spelling, including leading/trailing zeros.
-Missing fraction fields have only padding there.
-
-All tracks have the SAME integer width and the SAME fractional width, chosen existentially large enough for their finite strings.
-No assertion that independently chosen fractional lengths were originally equal is made.
-Each field's padding discipline and unpadded regular language are regular constraints on this common word.
-Integer-only auxiliary tracks are forced zero/padding to the right of the marker.
-Fixed constants have their exact finite-decimal encodings modulo padding; fixed0 is treated explicitly.
-
-Every actual finite collection of fields has such a common rectangular padding.
-Conversely an admitted padded word decodes to exactly those finite raw fields and values.
-The marker is a synchronization device, not a new field in any submitted lexical value.
-Any nonnumeric variable whitespace block has its own regular word track with right padding and ignores the common marker.
-Its characters have arithmetic contribution zero, and extra leading arithmetic padding columns provide enough total positions to hold that block.
-Its exact unpadded word is still checked by the selected whole-word DFA path language.
-
-### Finite carry automata for the whole conjunction
-
-Consider one linear equation sum(c_j*v_j)=0 with integer coefficients; finite-decimal constants can be additional fixed tracks.
-Read the padded digit columns RIGHT TO LEFT, ignoring the common point marker.
-Start carry h=0, require h+sum(c_j*d_j) divisible by10 at each column, and update h to that quotient.
-Accept exactly when h=0 at the far left.
-Padding contributes digit0.
-
-Let B=max(1,sum|c_j|).
-Whenever |h|<=B, the updated magnitude is at most(B+9sum|c_j|)/10<=B.
-Starting at0 therefore keeps the carry in the FINITE set[-B,B].
-The standard base10 recurrence proves acceptance iff the represented finite rationals satisfy the equation; multiplying by the common10^fractionWidth gives the usual exact integer-column identity.
-
-For sum(c_j*v_j)>=0 add an existential nonnegative finite-decimal result track z and the equation sum(c_j*v_j)-z=0.
-Strict positivity additionally requires z's digit word nonzero; negativity reverses signs.
-If the inequality is true, its finite-decimal difference has a finite padded encoding, so this translation is exact both ways.
-The added integer width can always be enlarged by more left-padding columns.
-No multiplication of two variable values or variable denominator bases occurs.
-
-First expand the finite Boolean formula into finite cases of positive equations and strict/non-strict inequalities.
-Negated equality becomes a less/greater split; each negated comparison outcome is replaced by the other explicitly defined outcomes, and finite residue/sign guards are split likewise.
-Only THEN introduce fresh existential slack tracks for the inequalities in each positive conjunction.
-Intersect those machines on the common tracks and union the finite cases; auxiliary tracks are existentially projected last.
-Do not complement a language with a chosen slack witness and then existentially project it, which would not negate the original inequality.
-All occurrences of x_i share the SAME lexical/value tracks, so equality/order constraints do not pick incompatible per-pair witnesses.
-This is ONE synchronized finite-automaton product, not an arbitrary intersection of rational relations or independent unary state summaries.
-
-### Decision, witnesses and a genuine encoded bound
-
-Combine the finite field/residue/sign/Boolean cases, regular field masks, exact parsing/coordinate equations and carry automata.
-The result is an effectively constructed finite automaton over a FINITE column alphabet, including all auxiliary tracks.
-Finite graph reachability decides emptiness, hence both successful tuples and complete negatives for this LOCAL supplied problem.
-
-Eliminate epsilon transitions, or take the exact epsilon-closure transition graph, before defining Q.
-For an accepting epsilon-free case with Q states, a shortest accepted column word has at most Q-1 consuming columns, counting the point marker.
-Decode its raw fields, separators, signs and finite whitespace blocks to obtain every lexical witness directly.
-No fixed-value API is being used as an existential tuple oracle, and no positive-only unbounded search supplies a negative answer.
-Each variable block has length at most Q-1; fixed separators and finite fixed-field text have an input-computable total length.
-An input-computable bound on all raw words is therefore t*(Q-1)+fixedText for the finite number t of blocks, with the analogous finite tuple bound.
-Computed coordinate records have finite decimal numerators/denominators and integer quotients of size bounded by these decoded digits and fixed coefficients.
-Take the maximum of the explicit bounds over the finitely many compiled cases.
-
-The actual primitive parser and scalar assessor can recheck each decoded value/word in its intended H.
-The equations ensure those checks have the required semantic results; this recheck is not used as an unexplained completeness oracle.
-Engineering work/node budgets remain finite resource policies and may require resource-limit results; the mathematical algorithm uses sufficiently large finite resources computed from the finite construction.
-
-### Finite IEEE case and precise exceptions
-
-For float/double, the actual value universe is finite after the owner's zero/NaN normalization.
-Enumerate those exact value classes plus the finite exceptional input endpoints and evaluate their pair comparisons directly.
-For each membership branch use the accepted ONE-WORD concrete-value inverse/admission construction, including exact IEEE numeric guards, to decide whether a lexical representative exists and to obtain one.
-That existing total fixed-pair word procedure, not merely an assess/compare API or a claim that IEEE fibers are regular, is the explicit dependency.
-The finite maximum over these finitely many word constructions is a computable bound.
-If that accepted fixed-pair authority is unavailable for a selected pattern/profile, this IEEE extension remains conditional rather than narrowing the input silently.
-
-No list/union selected-member synthesis, QName/NOTATION census, simultaneous unknown anchor properties, generic cross-family parse join, unbounded number of endpoints or new source-authority extractor is asserted.
-The tuple may share actual VALUES; an extra requirement to reuse one literal lexical word in several different parsers must be added to the same word grammar and is outside the stated independent-witness interface.
-The intended F2 application must separately prove its finite endpoint reduction, correct fixedness filters, enum/base membership and every component-property/annotation obligation.
-Empty new patterns do not waive any of those duties.
-
-
-## Native capacity for private-alias endpoint words
-
-The existing scalar kernel supplies `privateAliasEndpointWordCapacity(reference, owner)` in the actual H.
-It derives the formed CURRENT component inventory, existing bound kinds, assessed constants and admission masks privately; callers provide no descriptions, regular languages or formula-size estimates.
-Its scope is the private-alias catalogue below: at most one replacement per existing bound kind, with absent kinds remaining absent.
-
-For decimal, duration and the eight calendar families, the result contains a finite arithmetic expression bounding the combined primitive and membership word lengths.
-The compiler bounds the complete finite field/carry case inventory from the actual mask states and constants, without exploring the carry graph or expanding the expression's potentially enormous numeral.
-The pure [capacity builder](../src/compiler/schemaEndpointWordCapacity.ts) reserves its fixed expression topology before construction.
-
-Float and double instead use their genuine finite format and existing inverse-word owner, with a finite current enumeration supplying a smaller value superset when present.
-Their maximum also includes primitive spellings of actual bound constants independently of CURRENT admission.
-This preserves a same-kind exclusive-repeat endpoint even when the anchor's whole admitted image is empty.
-
-The normal scalar capture retains formation obligations, original lexical contexts, dependencies and the actual H identity.
-An exact native spelling contradiction can establish an empty admission mask after those duties are captured; other masks use the existing admission compiler.
-Unresolved qualification and sticky resource limits remain separate from a checked capacity; neither establishes an empty solution set.
-
-The [native controls](../test/research/re01/private-alias-endpoint-capacity.test.ts) cover SOURCE, GSC1 and RAW inventories, inherited child-H reassessment and the empty-anchor exclusive exception.
-The operation supplies an encoding bound, not endpoint production, a formed alias or an F2 certificate.
-It does not cover arbitrary hard multi-NEW tuples, the general finite-k VALUE product or the full RE01 witness bound.
-
-## Relation to full F2 construction
-
-The endpoint theorem supplies a local decision for any supplied finite tuple, with at most four shared bound roles in this private-alias application.
-A prospective strict alias may enumerate KEEP of each complete input bound kind versus REPLACE by one endpoint, subject to every fixed, inherited cross-kind, local-upper-pair, endpoint-membership and internal consistency duty.
-The [semantic catalogue](#finite-semantic-private-alias-catalogue) below supplies this extraction for a qualified private proper-alias sector using hypothetical authentic component selection.
-A source/nonexact normal form or a locally productive candidate does not establish its premises, and whole-forest reconstruction remains separate.
-
-KEEP of a component includes its annotation and authentic component authority where required.
-An unknown annotation on an inherited immutable row must not be converted into an input-domain prohibition or inferred equal on a separately assembled alias.
-Known property copying and an authenticated immediate-base component selector are different possible materializers; this theorem alone supplies neither.
-The earlier [raw-exact selector](content-model-s06-re-01.md#authenticated-immediate-base-component-retention) covers its printed whole-KEEP sector with actual current-H replay.
-The [complete current selector](#complete-current-component-replay) also supplies determinate SOURCE and generated inventories.
-The native private-alias capacity operation bounds endpoint words; it does not produce the endpoints or a formed alias.
-Inherited pattern and enumeration components, proper-ancestor length witnesses, whitespace coverage, ordered members, NOTATION qualification and every current-context scalar/source duty remain separate.
-
-After all earlier F2 construction duties are clear, two separate disjoint singleton pattern components prove an empty value image.
-Their emptiness does not clear a failed or unresolved formation duty.
-This is not a general permission to omit inherited kinds, fixedness, endpoints, annotations or required child evidence.
-
-## Empty main pattern certificate
-
-Every main pattern layer tests the same selected normalized result.
-Its alternatives form a union; the different layers are conjunctive.
-If the intersection of these authentic languages is empty, no normalized result can pass them all, so the whole value image is empty independently of base whitespace.
-The same argument applies after an ordered union has selected its main result.
-
-The [scalar owner](../src/compiler/scalarSchemaAssessment.ts) checks this sufficient certificate after all scalar formation prechecks and its ordinary coverage fast path.
-It uses the existing private pattern and regular-language owners and returns the existing `complete` flag.
-It does not merge patterns found only in separately normalized conjunct descriptions, use an approximate primitive grammar, or weaken the existing whitespace guard for nonempty containment.
-Raw component coverage and enum formation, source/constituent/NOTATION duties, typed dependencies and every complete current-H root remain outside this containment certificate.
-
-The diagnostic base has fixed replace and nonfixed collapse whitespace components.
-A result retaining only replace and adding two disjoint main singleton pattern components meets selected existential same-kind compatibility and universal fixedness, and has an empty semantic image.
-The old sufficient containment guard W nevertheless fails on the base's collapse component.
-The [controls](../test/research/re01/empty-main-pattern-certificate.test.ts) preserve complete baseline/current-H evidence and the fixed-value and missing-child failures.
-
-Universal whitespace-rank coverage does not follow from selected existential same-kind matching.
-The earlier attempted inference is withdrawn; direct result emptiness supplies the needed containment proof without a new whitespace policy.
-Authentic retention also does not waive current-base membership for a changed whole bound kind's local S contribution.
-
-## Finite semantic private-alias catalogue
-
-### Supplied premises and exact conclusion
-
-Fix one authentic H and a finite fully formed proper SIMPLE anchor a with an authenticated complete exact component inventory.
-Its variety is atomic, list or union; the simple ur-type constructor case is excluded.
-All base, constituent, typed-value, source and relevant NOTATION-use duties are supplied, together with the applicable complete word/value authorities.
-Own-type formation alone does not supply a missing NOTATION enum/use qualification.
-
-Assume some semantic proper restriction of a satisfies the full selected F2 rules, including its genuine c-fr decomposition and current local-S endpoint duties.
-The replacement alias is private before birth: no required value, fixed WORD/source tuple, exact facet/TYPE identity, IC or foreign payload observation fixes its recipe.
-Required namedness, a legal fresh identity, an expressible base reference and an already available operand owner are explicit parameters.
-
-Assume a hypothetical representation can select actual components of this immediate base in H, retaining their identity, values, fixedness, annotation, parser/source authority and dependencies.
-This is a representation premise; the separate raw-exact selector implements only its stated sector and accepts no caller identity hints.
-Every current F2 duty still applies; selecting part of a bound kind does not turn its local S into empty S.
-
-Under these premises a finite computable catalogue contains a fully formed proper alias with empty whole value image.
-This preserves existence in the stated private sector, not the old alias's language or arbitrary outside observations.
-It supplies neither a native materializer nor a bound on how many anchors, TYPEs, owners or contexts an RE01 forest needs.
-
-### Finite choices and endpoint extraction
-
-Keep a's variety, primitive and identical list item or ordered union member references.
-Genuine old success supplies permission to restrict a; identical constituents use identity derivations and avoid a changed-earlier-member containment duty.
-Flags and required namedness remain finite explicit interface choices.
-
-For each inherited bound kind enumerate KEEP of its entire actual component set or REPLACE by one genuinely new endpoint, a Boolean fixed flag and known-absent annotation.
-Absent bound kinds stay absent.
-For each inherited nonbound scalar kind enumerate its nonempty actual component subsets.
-Retain every actual input enum and pattern component; no new enum or enum-word reconstruction is needed.
-
-In a genuine old c-fr witness, a bound kind absent from local S is wholly retained, so KEEP is valid.
-For a kind present in local S, select one of its old effective tuples for REPLACE.
-It has a compatible input prior, equals every applicable fixed input value and obeys every inherited cross-kind prohibition.
-Its endpoint has current-a membership or the actual same-kind exclusive-repeat exception, even if local S overlaps an old component.
-
-Every new internal bound pair occurs among old effective pairs.
-Selecting fewer old local kinds preserves the prohibition on introducing both upper kinds, and old full validity supplies the whole-datatype lower-pair rule.
-Extra old bound kinds absent from a can be omitted in this private recipe; emptiness later supplies containment but waives none of these checks.
-
-Compile all compatible-prior disjunctions, universal fixed/cross-kind tests, internal pairs, local upper-kind rules and endpoint membership/exception tests together.
-There are at most four new endpoints of one bound-capable primitive family.
-The [shared endpoint theorem](#supplied-shared-endpoint-tuple-theorem) decides each finite mode and produces genuine words while preserving less/equal/greater/indeterminate outcomes.
-Primitive operand words and current-a membership words may differ; no artificial shared-WORD requirement is imposed.
-That mathematical endpoint operation remains unimplemented.
-
-### Nonbound selection and direct emptiness
-
-For a nonbound kind with no fixed input value, keep the whole actual kind.
-If fixed input components exist, old full success forces their actual values to agree; choose the nonempty input subset equal to every fixed value.
-Each selected tuple has its identical compatible input prior and satisfies universal fixedness.
-Length/precision tuples are subsets of a's consistent inventory, and a's required no-length proper ancestor remains a proper ancestor of the new alias.
-
-Actual selection preserves unknown annotation and source authority instead of guessing it.
-The whole input enum/pattern inventory is retained with no enum contribution to S.
-This does not settle partial same-value/different-metadata replacement or let one selected occurrence authenticate another.
-
-If a has p pattern components, choose one literal expression among a, aa, ..., a repeated p+1 times whose P1 property differs from every input pattern property.
-Choose another among b, bb, ..., b repeated p+1 times under the same rule.
-Each finite list has p+1 distinct properties, so at least one escapes the p input properties.
-They denote disjoint singleton languages and become separate ordinary components, each with absent annotation and fixed=false.
-
-All earlier c-fr, fixed, cross-kind, local-S, endpoint, length, whitespace, typed-value, enum, parser and constituent checks remain mandatory.
-After they hold, these two new main components make the semantic whole image empty directly.
-No universal inherited whitespace-rank condition W is inferred, and no nonempty containment rule changes.
-
-### Bound and remaining implementation gates
-
-The mode set, flags, input subsets, component ordinals and constituents are finite.
-Each endpoint decision terminates with bounded finite output, so the maximum of its successful decoded recipe lengths is computable from the supplied inputs and interface parameters.
-At most the input component count plus four new bound components and two new pattern components is needed.
-Opaque metadata remains an authenticated input reference rather than a guessed value.
-
-This theorem has independent scoped acceptance and does not depend on a new numeric enum witness or lexical-map normalization theorem.
-The complete current selector supplies immediate-BASE authority where its formed inventory is determinate, and the private-alias capacity operation supplies its endpoint-word bound.
-Endpoint production, remaining unresolved original inventory qualifications, complete native scalar materialization, cross-context reconstruction, anchor/TYPE counts and general forest bounds remain open.
-The empty-main-pattern certificate supplies its local containment part only; it does not complete those other gates or establish general RE01 negatives or termination.
-
-## Input scalar observations and their exact cuts
-
-Fix the immutable input SIMPLE reference closure A, including actual original/generated selectors and the complete admitted builtin BASE/ITEM/MEMBER dependencies.
-An old fresh selector does not become an input merely because a supplied successful forest uses it.
-Original/inherited raw SIMPLE correspondence preserves its literal BASE, ITEM and every ordered MEMBER identity.
-
-For input SIMPLE alpha and genuinely fresh atomic or LIST target T, nominal `typeDerivation(alpha,T)` is false.
-The reader follows alpha's immutable literal BASE path; it does not add a LIST ITEM or derived UNION MEMBER as another ancestor.
-A genuinely fresh RAW UNION target has one exception: a successful target-member alternative must select an input atomic/LIST literal ancestor of alpha.
-Fresh raw UNION members are atomic/LIST, so this exception cannot recurse through another fresh UNION member.
-Matching ITEM alone therefore cannot make an input LIST derive a new LIST, and an input UNION cannot use this atomic/LIST-ancestor exception.
-Restriction exclusions, final checks and authentic full frontier duties remain independent.
-
-A surviving TRUE expanded scalar PROPERTY query against input scalar a supplies a different bound.
-Unfold a's finite property DAG along labelled BASE, ITEM and ordered MEMBER edges, including complete builtin dependencies and all input subtrees below identity cuts.
-Let U(a) be the number of positions in this finite unfolding.
-Builtin selectors are not terminal merely because they are builtin; a distinct-definition property comparison still expands their scalar properties.
-An edge-free boundary is terminal, and an unavailable scalar view cannot create a successful new subtree.
-
-The complete property tableau matches name status/name, namespace, variety, primitive, final flags, facet properties, edge presence and ordered arity at each expanded pair.
-Every first-entry fresh dependency follows a corresponding strictly lower input position; sharing or pair recurrence cannot create an unmatched first-entry child.
-An identity cut is the actual input definition, whose closure is already charged in U(a).
-Thus one such rooted task bounds its fresh BASE/ITEM/MEMBER support by U(a).
-The production `cos-particle-extend` property comparison excludes annotations; this support bound fixes structural positions, not fresh component metadata or its local-S/retention choice.
-Actual annotation correspondence and complete c-fr/F2 formation remain independent duties.
-It does not bound the number of copy roots or their typed facet operands, owners, source backing and foreign SC/TYPE users.
-
-An input ordinary VALUE, a protected physical WORD/source tuple, exact SC contentIdentity and literal SC contentDerivation remain separate observations.
-An empty private alias cannot satisfy a required nonempty value or full property copy merely because it has the same outgoing nominal ancestry.
-The corresponding owners are [type relations](../src/compiler/schemaTypeRelations.ts), [component equality](../src/compiler/schemaComponentEquality.ts), [candidate correspondence](../src/compiler/re01CandidateCorrespondence.ts) and [declaration primitives](../src/compiler/schemaDeclarationPrimitives.ts).
-
-## SC-only support at the first retained scalar boundary
-
-This independently reviewed source/math result bounds one producer class relative to a supplied boundary set A.
-It supplies neither a general bound on A nor a native scalar catalogue.
-Fix a complete qualified finite forest W over finite inherited parent P, with lineage-coherent A closed under actual effective scalar parent, ITEM and ordered MEMBER dependencies.
-A contains the immutable input/builtin/generated closure and every independently retained nominal, source, PROPERTY, VALUE, WORD, owner and evidence cut.
-
-Every scalar outside A to be omitted is post-P and used only by coherently reconstructible new SC rows or by the same closed scalar/scaffold cone.
-Complete whole-future incoming-reference and source/owner audits are required; being an old mandatory fresh root alone is not a retention seed.
-Inherited P records, original typed operands and protected physical words/maps remain exact.
-
-For S in A set rho(S)=S; otherwise follow S's literal effective parent chain to the first definition in A.
-RAW atomic, LIST and UNION constructors install their actual BASE as parent, including the ur constructor case.
-ITEM and MEMBER are support dependencies, not additional SC ancestry steps.
-Full formation gives a finite acyclic parent graph ending at a retained input/builtin boundary.
-
-The actual `contentDerivation` reader ensures both scalar operands and follows this parent chain, with its unchanged builtin relation only when both operands are builtin.
-It does not introduce a fresh target-UNION alternative.
-For an old positive restriction S to T, omitted T is reached before A, so rho(S)=rho(T).
-For retained T, rho(S) starts a suffix of the old successful traversal to T; a retained S cannot reach omitted T because A is parent-closed.
-Thus every SC restriction remains positive by identity or the same literal suffix, without arbitrary scalar transitivity.
-SC extension requires effective scalar identity, which the functional rho preserves.
-
-Keep complex identities, BASE/methods, flags, AUs, wildcards, particle/declaration incidences and global affiliations exact.
-SIMPLE BASE selectors are retained nominal cuts; initial mixed restrictions keep their genuine formal-emptiability duty, and the anyType branch keeps its own scalar formation.
-Raw complex nominal variety remains complex, so this scalar rewrite does not change the complex nominal paths used by affiliation and membership.
-Projected PROPERTY pairs still need actual positive production queries; selecting the same a on both sides is sufficient, while old PROPERTY equality alone is not.
-
-An ordinary-value extension applies only with an actual authorized inverse witness at each selected a and lexical context, available at birth.
-It retains fixed/default kind and actual value, the ordered-UNION/LIST assessment, source and relevant NOTATION/ID/ENTITY duties, and the qualified whole-history argument.
-ENTITY paths additionally require an existing complete immutable authority; an unavailable authority remains outside this transport claim.
-Choose and freeze the new field's word/map before birth; a finite value set or same-owner F2 does not prove admission at another namespace map.
-Protected tuples and an unavailable inverse remain boundary cuts.
-
-Parents exist no later than their children, so rho(S) is available when S or its SC consumer is born.
-Reconstruct each eligible SC selector and unobserved canonical inline/reference backing together before birth, then inherit that same assignment throughout its lineage.
-The zero-extra claim requires retained input/builtin backing or lawful omission of unforced inline backing, with no new SIMPLE proxy.
-An authentic original-generated content selector is directly admitted by the existing RAW SC constructor; its actual owner/dependencies remain, and its complex source owner is not treated as a SIMPLE component.
-An unavoidable placeholder or unresolved canonical incoming reference lies outside this claim.
-
-Every selected boundary retains its relevant declared/SC/item/member use qualifications, including enum-qualified NOTATION where required.
-Own FULL alone does not supply those qualifications or clear a standalone assessed `fixedEqual` prerequisite.
-Reissue source/scalar construction and the full actual current-H frontier, including pending/fatal replay and every retained inherited root; no parent or sibling receipt is transported.
-Only after the complete omission audit may the outside-A cone never be born.
-
-Consequently SC-only parent chains add zero scalar definitions beyond A, independently of their row count or length.
-For A equal to input closure this is an input support bound in the stated sector; with residual roots it is non-amplification only.
-Direct SIMPLE roles, mixed property-template/nominal-cut copies, context-sensitive VALUE roots and protected source/WORD/owner support still need a joint input-derived bound and genuine native materialization.
-General forest adequacy, complete negatives, mathematical termination and dated-XSD correspondence remain open.
-
-## Finite numeric VALUE recipes at a supplied RAW anchor
-
-Fix one authentic H and a supplied fully formed exact proper RAW atomic anchor a with primitive decimal, float, double, an admitted calendar primitive or duration.
-Use the private catalogue's base, formation and authority premises, with its privacy condition extended only to the freely respellable VALUE roles specified here.
-Assume authentic component selection, all actual word/value authorities, and a semantic immediate proper restriction admitting a finite set V of required actual values.
-No full PROPERTY, protected WORD/source tuple, exact facet/TYPE identity, SC identity or foreign caller may fix that restriction's recipe.
-Every respelled ordinary field is chosen coherently before its first birth; original and inherited fields and namespace maps are preserved.
-
-For nonempty V, a finite semantic catalogue contains a proper restriction with whole image exactly V under actual `sameValue`.
-Use the private catalogue's whole-bound KEEP/singleton NEW modes and nonbound fixed-compatible subsets, retaining every actual input enum/P1 component and adding no new enum.
-For each of at most four NEW endpoints add every actual value test requiring every v in V to pass every effective bound, including strictness and determinate-order requirements.
-The shared endpoint theorem decides these finite modes with fixed input-value comparisons and genuine membership/spelling witnesses.
-The old successful restriction supplies a satisfying mode; fixed, cross-kind, local-S, ancestry and all formation duties remain explicit.
-
-For precisely this RAW represented sector, `whitespaceFor(primitive)` initializes the atomic plan at collapse.
-Aggregate whitespace takes the maximum rank, and every atomic conjunct is rewritten to that same mode.
-Thus both a and the recreated alias observe collapse at their main patterns and conjuncts.
-This is a constructor fact, not an implicit primitive facet or a universal fixed-whitespace rule.
-For each v the complete fixed-anchor inverse/image authority returns an admitted word w; set z to collapse(w).
-Idempotence makes reassessment on z use exactly the successful pre-parser strings already observed on w.
-Calendar/duration parsers' private trimming does not change this equality of observed strings.
-No inference that parser success implies a whitespace-free spelling is used.
-
-Construct one ordinary pattern for exactly the finite set of z words, with supported literal escaping and ordered alternatives.
-If a has p P1 components, p+1 distinct redundant-parenthesis spellings supply a P1 property different from every input P1 property while preserving this finite language.
-Every v remains admitted, and every admitted normalized alias word belongs to the whitelist and parses as its selected v.
-This proves both image inclusions without changing atomic value interpretation, source authority or any fixed/formation obligation.
-The catalogue needs at most the selected input component count plus four new bound components and one ordinary pattern component; its successful word lengths are computable from finitely many complete queries.
-For empty V use the empty private-alias catalogue instead.
-
-This theorem is semantic and normalization-qualified: it supplies no generic source/generated/FULL normalization inference or native nonempty-containment shortcut.
-It excludes string, QName/NOTATION, LIST and ordered UNION, protected WORD sharing and arbitrary lexical-map rewriting.
-It bounds one recipe relative to a,V, not the number of anchors, required VALUE roots or complete forest size.
-
-## Free LIST ordinary values and directed forcing
-
-Use a supplied complete represented forest with the reviewed directed ordinary-presence projection and authentic scalar/source/NOTATION history qualification.
-Mark the immutable scalar input closure A and every scalar descriptor connected to it by a complete TRUE scalar PROPERTY tableau.
-These marks are dependency-closed: lifting a BASE/ITEM/ordered MEMBER edge along a property-pair path reaches that same dependency of A.
-Identity cuts and pair recurrence use their complete first expansion rather than omitting a dependency.
-
-A free ur-LIST or ur-UNION has an unmarked post-input literal BASE path of its own variety to `anySimpleType`, with no input/source/generated/property cut.
-Every genuinely new SIMPLE recipe in this represented sector is RAW; authentic source/generated selectors remain input cuts.
-Trace any retained ordinary field backwards through the projection's finite seed path.
-AU effective/source and complete PROPERTY edges preserve the selected scalar state and actual value.
-An RP/AU fixed implication points from base field to derived field, so this backwards trace examines derived-to-base TYPE derivation.
-
-A free LIST reaches a nonunion non-ur target only along its literal LIST ancestry; the nominal reader does not follow ITEM.
-A target-UNION escape selects a LIST member on that ancestry.
-Full corresponding-member formation, followed backwards along that UNION's own BASE path, forces each corresponding member to remain a literal LIST ancestor.
-If the UNION reached an input/property cut, its marked member would mark the original LIST path, contradicting freedom.
-Thus the escape reaches a free UNION.
-A free UNION cannot return to LIST: its literal ancestors are UNIONs, fresh target members are atomic/LIST, and immutable input member closures cannot name unborn ancestors.
-
-SC steps use exact scalar contentIdentity or literal contentDerivation, preserving these free states.
-For a successful nonidentity RP NTO path the complex prefix uses restriction; extension is excluded, so a simple-base extension supplies no escape.
-The permitted SC-to-nonscalar boundary with an ordinary value is an actual STRING assessment, including formally emptiable mixed content and `anyType`.
-Consequently backward transitions are LIST to LIST/UNION/STRING and UNION to UNION/STRING; there is no return from UNION to LIST.
-A protected input seed cannot have a free post-input selector.
-The finite seed path must therefore reach STRING, carrying actual `sameValue` equality throughout.
-A successful LIST value, including the empty LIST, has family LIST and cannot equal STRING.
-No free LIST ordinary field belongs to the retained closure, so the reviewed projection removes its unprotected new physical field coherently before birth.
-The same argument says a retained ordinary value selected by a free UNION is STRING-valued; it does not classify every UNION value.
-
-Protected WORD/source/property ports are input cuts and remain.
-LIST ITEM, corresponding UNION members, SC identity/ancestry, global eligibility and all old mandatory roots still require their own reconstruction or complete closed-cone omission audit.
-The projection's full frontier, new RP-state pending/fatal coverage, effective-AU fallback and complete child replay remain premises.
-This field classification supplies neither a scalar constructor nor a global SIMPLE/root count, native evidence adequacy, complete negatives or mathematical termination.
-
-## Authenticated builtin pattern introductions
-
-An exact RAW facet-component inventory may select a NEW whole builtin pattern component with `builtinPattern: {name, index}`.
-The zero-based index ranges over the selected builtin's complete pattern-component inventory, including inherited pattern properties.
-The existing builtin owner supplies its exact lexical context, annotation, private compiler marks and qualification dependencies; the caller supplies neither expression text nor an intrinsic-authority flag.
-
-The selected group receives a new row-local occurrence, while an actual `baseComponent` selector retains its own immediate-BASE introduction.
-The complete inventory still passes the existing formation, kind-presence, fixedness, corresponding-constituent and ordinary F2 checks.
-Selecting a builtin pattern does not certify another TYPE or promote a source owner's availability to FULL.
-
-The import also publishes authentic component replay when the row contains no BASE selector.
-A later fork can therefore KEEP that actual component with its compiler metadata and debts intact.
-Unknown or patternless builtins, invalid ordinals, mixed builtin-selector/literal entries and annotation overrides retain separate failures; an ordinary caller-written private intrinsic expression remains unsupported.
-
-This closes one concrete template-copy seam.
-A current RAW template can contain authenticated NCName patterns beyond those in its BASE, while a property-equivalent replacement BASE has a different enum annotation introduction.
-Whole foreign facet binding can then require an unqualifiable enum, and KEEP alone omits the required patterns; actual BASE KEEP combined with NEW authenticated builtin patterns supplies the missing recipe.
-
-The [builtin-pattern controls](../test/research/re01/scalar-builtin-pattern-import.test.ts) check all roots, independent PROPERTY and nominal derivation, annotation continuity and a complete three-node evidence forest for that case.
-They also preserve actual GLOBAL builtin-name shadows, their distinction from builtin nominal identity, a complete one-node forest, import-only replay through KEEP and a later fork, and the original failed alternatives.
-No builtin-name collision prohibition or unconditional shadow-contraction theorem is assumed.
-
-This is a representation constructor using existing builtin facts and P1 authority.
-It establishes neither arbitrary scalar template reconstruction nor the general LIST/UNION funding bound, complete negative answers or mathematical termination.
-
-## Proper atomic UNION reconstruction
-
-The reviewed local extraction concerns a free proper ordered UNION cone over one actual input UNION with r atomic members.
-Its input is a finite winning projected R witness, with all immutable Gamma obligations discharged globally under the selected founded relation.
-Protected TYPE, BASE, PROPERTY, WORD/map, component-authority and exact nominal-stop ports remain boundaries; the construction preserves their finite typed VALUE demands.
-
-The theorem supplies a finite input-derived stock and row bound for this sector, independently of the old private R-chain length, pattern size and namespace count.
-At a fresh target first select an already-zero-new-NP winning successor by the accepted final-record theorem, then normalize that successor while preserving that mode.
-This is not a theorem for arbitrary LIST members, hard-boundary joins or a complete native all-domain catalogue.
-
-### Input quantities
-
-Let c count the fixed namespace colors in the actual current interface, including retained enum/NOTATION values and protected maps.
-Let q be the finite product of input DFA boundary transformations at colon, local-part and normalization-fiber boundaries, with the actual parser-branch and whitespace flags.
-Include input member/top P1 and genuinely regular sector masks for enum lexical inverses, STRING/URI, compact binary and selected QName/NOTATION images; new private patterns are not input coordinates.
-General numeric and IEEE inverse constraints stay in their qualified inverse products rather than being assumed regular DFAs.
-
-Let b count protected normalized seed cores, including every retained INPUT/SOURCE enum typed value and qualified operand WORD, ordinary VALUE seeds and protected WORDs.
-Expand the finite hex case variants of fixed hexBinary values and include QName/NOTATION local parts and the actual finite Boolean/IEEE special spellings.
-Close once under taking a QName token's colon-free local part before counting d, the distinct duration values parsed by those cores or explicitly required as duration VALUEs.
-
-The two binary families remain distinct under actual `sameValue`.
-A base64Binary ITEM token has no XML whitespace and has a unique compact encoding for its value; it has no hexBinary inverse qualification.
-These facts prevent an unsupported binary-family transfer without supplying a general LIST closure theorem.
-
-### Same-map QName funding
-
-For the bounded stock of L local parts, enumerate outside namespace profiles as typed admission matrices, with at most m=2^(rL) colors.
-At each retained row and its actual map choose a matrix S for each namespace satisfying E_CURRENT subset S subset E_BASE.
-Start with current typed admission bits and add a producer only for a needed whole QName with an actual BASE witness at that same map; translate all equal namespace bindings together.
-
-The lower inclusion preserves current positives, and the upper inclusion protects a BASE non-QName witness from new preemption.
-Every newly selected whole QName has its displayed same-map BASE witness.
-Installing all realizable static enum colors at birth permits later assessment at another map; it neither transfers a receipt nor broadcasts a value into every producer.
-
-Retain the first actual whole funding WORD per finite channel of profile, local, producer, input prefix class and whitespace phase.
-Enumerate every word of each finite legal prefix class; for an infinite class preinstall a fresh private prefix while retaining its input first winner.
-The fresh prefix may be unbound before activation, but remove its mutable STRING/URI prewinner only in a separate bound activation row after the whole value is funded.
-
-After activation retain that support and keep its own-definition bindings outside protected namespace colors.
-Fixed QName/NOTATION values use separate family/namespace channels: activate the next producer while the previous producer still funds the value, then retire the old fresh TOP word when its producer dies.
-Finite classes, bare/default cells and genuinely protected prefixes retain their exhaustive actual cells instead of assuming an immortal producer.
-
-Native namespace authority governs eligibility.
-In particular an explicitly stored named binding to the empty string is admitted; an undefined named binding rejects.
-Do not add a serialization restriction or rewrite a protected WORD/map.
-
-Proper FULL input NOTATION members have retained finite enum-qualified images, so their outside-profile bits are false.
-This does not forbid new NOTATION declarations in the accepted domain: fresh ur-constructor sectors must bound those recipes separately.
-QName and NOTATION keep distinct typed families even when namespace and local agree.
-
-### Rejected-result shields and genuine rows
-
-Retain complete STRING/URI complement shields outside the finite set Z of chosen normalized words.
-A finite enum containing only a bare STRING is insufficient: deleting its outer-whitespace spellings can expose a QName whose collapsed result passes TOP.
-The outside-Z shields are permanent; only the bounded Z cells follow their actual death schedule.
-
-TOP rejection includes both normalized P1 rejection and typed enum rejection.
-An outside QName rejected by a retained typed TOP enum has no whole-QName BASE funding debt; its atomic positive call still needs genuine qualification.
-Definition maps do not replace the authentic contexts of retained enum operands or later ordinary VALUEs.
-
-Numeric positive projection and the reviewed endpoint bridge contribute at most seven passive metadata rows per strict call event in the one-new-endpoint-per-kind free frame.
-Genuinely NEW endpoint operands remain actual positive calls in their immediate atomic BASE and need not enter the whole UNION stock.
-Unchanged exclusive endpoints may instead use the accepted outside-BASE repeat exception; they are not positive membership calls.
-Every reconstructed row names its exact predecessor members and is checked by the existing owner for inherited kinds, fixedness, authentic components, length ancestry, corresponding members and ordinary F2.
-
-### Explicit finite stock and encoding bound
-
-Put p=1+4r and k_D=2p(b+1)+2qp+1.
-For each fixed duration/input/phase class retain a fresh reserve or every member of a class with fewer than k_D cores, plus its first actual availability witness.
-The leader bound L=2p(b+1)+dqp(k_D+2) covers these choices; new prefixes introduce no duration parameter.
-
-Let a=m+2c+1, G=a(L+1)(r+1)(q+1)p and R be the number of protected prefix strings.
-Let f be the size of the finite legal prefix-language union, computable by the input DFAs and actual namespace authority.
-At most Ga fresh reserves suffice, chosen from pools of Ga+G+f+R+1 representatives per infinite class.
-
-The conservative lexical-role bound is z=3(L+1)(1+f+G+Ga).
-The strict-event bound is E=p(z+1)(r+1)(a+1)(q+1)+3Ga, giving at most 8(E+1) rows plus exact input boundary rows and finite nonbound subset choices.
-First-use induction retains an actual same-map whole witness for each activation and each fixed-value transfer before discarding any unneeded old support.
-
-These counts precede word selection.
-For an s-state DFA having at least k words, k distinct representatives have length at most s(k+1); use the actual fixed-duration inverse/profile languages and finite protected exclusions.
-Bound passive endpoint words with the existing finite-k capacity authority, then compile Z shields and new patterns from the chosen words without feeding their new DFA sizes back into q.
-
-The resulting encoding bound includes component slots, words, namespace maps, regex programs and references.
-It is a semantic extraction for the stated free atomic cone; the all-domain obligation still requires a bounded winning recipe whose complete native checks and contextual child evidence pass.
-An invalid encoding or a configured resource limit supplies no general negative answer.
-
-### Native controls and the remaining LIST question
-
-The [activation-shield controls](../test/research/re01/scalar-union-activation-shields.test.ts) use one shared source fixture and the existing complete verifier.
-They check a definition-TOP-dead QName mask with a later real STRING VALUE, the full regular whitespace shield, and a finite-enum contrast whose required construction fails ordinary F2.
-The fourth control keeps a singleton LIST QName tuple in the definition map and selects a later real duration VALUE under another map, with complete inherited-root evidence.
-
-These controls preserve the failed contrast and establish the stated concrete constructions.
-They do not prove that componentwise positive calls fund a multi-item whole LIST tuple, or bound mutually qualifying numeric/LIST recipes.
-General correlated LIST extraction, hard-boundary joins, checked-recipe adequacy, complete negatives and mathematical termination remain open.
-
-## Source and proof boundaries
-
-The elementary DFA factorization, padding and bounded-carry construction above is self-contained.
-It uses the selected DT A calendar/duration laws and actual comparison conventions, rather than a different primary interpretation or an unspecified arithmetic solver.
-The source baseline is main `77dad394c3fbff66fd1ab08855f8eabdfbf92407`; the subsequent inherited-facet identity repair does not change these numeric equations.
-
-The concrete owners are [calendar arithmetic](../src/compiler/schemaExactCalendar.ts), [datatype values](../src/compiler/schemaDatatypeValues.ts), [scalar formation and F2](../src/compiler/scalarSchemaAssessment.ts), [finite regular languages](../src/compiler/schemaRegularLanguage.ts), [calendar images](../src/compiler/schemaCalendarImages.ts), [integer images](../src/compiler/schemaIntegerImages.ts) and [lexical predicates](../src/compiler/schemaLexicalPredicates.ts).
-The already accepted concrete-forbidden one-word authority supplies only the qualified fixed-value IEEE membership subproblem; the shared variable tuple construction is new.
-
-The dated sources are [Datatypes second edition](https://www.w3.org/TR/2004/REC-xmlschema-2-20041028/) and [Appendix E duration order](https://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#adding-durations-to-dateTimes), interpreted through the accepted DT A decisions.
-No external validator certifies an abstract forest or supplies the missing arbitrary-witness bound.
-Engineering budgets can return resource-limit; neither that event nor exhaustion of a smaller candidate family establishes general nonexistence.
-
-## Native LIST preparation and actual UNION image duties
-
-A proper RAW LIST checks its actual ITEM derivation and ordinary facet formation/correspondence.
-Changing its ITEM does not itself invoke whole selected-LIST image containment.
-The selected-image check in `rawFacetCorrespondence` applies when both BASE and result are UNION and an earlier member definition changes.
-NEW enum operands separately require genuine membership in their actual immediate BASE.
-
-A free LIST can therefore use two stages under explicit premises.
-First prepare a FULL final ITEM `J` genuinely derived from the input ITEM, with every hard shared role preserved.
-Install `J` in a proper LIST `L0` using a legal coherent replayable facet mode; retain authentic inherited components and restore any required length implication with the existing regular-language owner.
-A formed CURRENT table alone does not guarantee a legal child: fixedness, length-ancestor duties and the family/variety shape of retained enum tuples remain checked.
-
-If each demanded tuple has an actual positive WORD/context at `L0`, a second LIST `L1` can KEEP that inventory and the exact same `J`, then introduce a finite enum using those same WORD/context operands.
-Those operands are qualified against actual `L0`; the construction does not assume that the original input LIST already selected them.
-No additional inverse WORD tree is required for this enum operation.
-An enclosing changed ordered UNION still needs its own selected-image check in its actual context.
-
-The [native gate controls](../test/research/re01/scalar-list-formation-gates.test.ts) distinguish these duties.
-Changed-ITEM LISTs with authentic TOP KEEP can be FULL while producing DD/FF tuples outside the input LIST image.
-The bundled alternative has complete evidence; serial ITEM UNION recovery fails its actual selected-image rule.
-A QName/string case checks complete `L0` to `L1` enum qualification and a GLOBAL VALUE, while direct input qualification and a separate enclosing UNION fail independently.
-
-Earlier whole-grid simulations remain sufficient conditional constructions; generic LIST image preservation is not a mandatory native premise.
-These controls and the two-stage lemma do not prove simultaneous bounded ITEM synthesis, arbitrary helper coverage, evidence adequacy, complete negatives or termination.
-
-## Whole bootstrap can require a nonfinal STRING guard
-
-Final atomic images do not by themselves justify moving final atomic lexical programs before the first enclosing ordered-UNION restriction. The following four-position cone gives a counterexample.
-
-Let the actual current A have ordered members STRING, Qp, Qq and FLOAT. The STRING member executes collapse and accepts exactly `INF|[a-z]+:INF`. Qp accepts only QName gamma, whose local is INF, on normalized INF. Qq accepts the same gamma on normalized `[a-z]+:INF`. FLOAT accepts infinity only on normalized INF. All relevant normalizations are collapse. These are ordinary formed atomic restrictions; A can be their UNION constructor.
-
-STRING preempts every possible later member success. Consequently A's whole selected image contains STRING values only, at every namespace map. It contains neither gamma nor FLOAT infinity.
-
-Require an eventual proper descendant in this literal four-position cone to select FLOAT infinity on INF at a caller map where Qp is off. FLOAT must remain live throughout: an atomic numeric restriction cannot delete infinity and later recover it. The final STRING program must reject INF.
-
-If the first whole restriction over A already uses that STRING behavior, its own map selects gamma or FLOAT infinity on INF. Qq cannot accept bare INF. Neither possible selected value belongs to A's whole image at that map. The actual changed-earlier-member check in [selectedUnionContainment](../src/compiler/scalarSchemaAssessment.ts) therefore rejects the step.
-
-A whole P1 guard cannot distinguish these outcomes because both have selected normalized spelling INF. A whole guard removing INF cannot later widen to restore it. A new whole enum permitting the eventual FLOAT call must contain infinity, and its separate immediate-BASE qualification fails over A. No inherited whole enum is available to KEEP. These alternatives do not repair the early-final move.
-
-A valid dynamic route first keeps STRING INF while removing its q:INF spelling. Choose q off at that row's own map, so q:INF rejects; a later q-on caller obtains the first whole gamma witness. A preinstalled r:INF spelling can then be activated at a map where q:INF already supplies gamma in BASE. Only after this funding does STRING INF disappear. The resulting own map can select funded gamma while a separate caller selects FLOAT infinity.
-
-This is a parameter proof about the stated proper cone. It does not assert an unrestricted root-necessity result or refute a finite dynamic catalogue. It shows why a contraction of atomic final snapshots must retain genuinely needed whole bootstrap stages. For LIST members, such a stage must fund a complete tagged tuple, rather than its QName components separately.
-
-## A free ur-parent QName proxy batch
-
-A new free ur-parent can fund a finite batch of LIST values before exposing them on BASE64 words, without an early LIST guard stealing binary inverses. This is a local prebinding constructor, not a rewrite of a fixed INPUT member array or a general FIRST schedule. The actual private rows, identities, owner support and maps must be writable before birth.
-
-Choose nonempty principal WORDs `w_i` that parse as BASE64 and each contain an XMLWS-free TOKEN that is a legal unprefixed QName. Let T contain one chosen TOKEN text per WORD. Choose a nonempty namespace B outside every binding value and default interpretation of the retained hard ROOT maps, and one fresh prefix p. Every helper definition and enum facet uses the same actual own map with default B and `p -> B`; storage target namespaces remain separately valid.
-
-Let pi_i be the tuple selected on `w_i` by ITEM `[QName,STRING]` at that own map, and H the set of distinct pi_i. Each tuple has a QName `(B,t)` with `t in T`, and none has a STRING item whose value is in T. Form auxiliary `a_i` by prefixing every TOKEN in T with `p:` while preserving other TOKENs and order. It denotes the same tuple, contains a colon, and cannot parse as BASE64.
-
-### Nine genuine rows
-
-All rows have permissive final masks and genuine absent private annotations. Primitive STRING has no facet component to select, so its first whitespace component is NEW. P1 T is the disjunction of escaped literal TOKEN texts; separate P1 components are conjoined. The [scalar owner](../src/compiler/scalarSchemaAssessment.ts) supplies the ordinary formation, current-component and selected-image checks.
-
-| Row | Actual constructor |
-| --- | --- |
-| C_T | Restrict builtin STRING with NEW preserve WS and finite literal P1 T |
-| C_empty | Restrict C_T, KEEP its WS/P1, add conjunctive literal-colon P1 |
-| J0 | Facet-free ur-UNION `[C_T,QName,STRING]` |
-| J1 | Restrict J0 with corresponding members `[C_empty,QName,STRING]` |
-| L0 | ur-LIST with ITEM J0 and explicit fixed-collapse component |
-| Lcap | Restrict L0, KEEP collapse, introduce one enum H using provider L0 on `a_i` |
-| Lchange | Restrict Lcap with ITEM J1, KEEP its actual WS and enum components |
-| U0 | Facet-free ur-UNION `[Lcap,base64Binary]` |
-| U1 | Restrict U0 with corresponding members `[Lchange,base64Binary]` |
-
-C_empty is genuinely empty because T contains no colon. At J1's own map its only potentially new values are QName `(B,t)` for `t in T`; J0 already supplies each through the actual WORD `p:t`. Every other selected value is unchanged or removed, so J1's complete image is contained in J0's. QName/STRING admissions, WS preimages and own-map value images are regular, giving the existing guarded atomic image frontend its complete native F2 certificate. This constructor proof is at the actual own map, not at a ROOT query map without that prefix binding.
-
-Every Lcap enum entry is genuinely L0-positive on its auxiliary WORD and saved own map. Lchange has actual ITEM derivation J1 to J0 and unchanged fixed-collapse coverage; its retained enum introduces no new value. If Lcap succeeded on any WORD, C_T cannot have won on a TOKEN: that would return a STRING in T, absent from H. J1 therefore preserves every old successful tuple and normalization on that same WORD. Lchange admission grows while its only values remain H.
-
-### Whole-WORD funding and qualification
-
-Lcap rejects every BASE64 WORD. To return its required QName `(B,t)`, J0 must bypass C_T; the unprefixed TOKEN t would select STRING, so the QName TOKEN needs a prefix colon. BASE64 permits no colon. This holds for the whole raw inverse, even when a binary point has only one feasible collapsed cell.
-
-Every new U1 LIST result belongs to H, and U0 already selects that point on its auxiliary `a_i` through its first member Lcap. If U1 instead selects BASE64, Lchange failed there; old Lcap success would imply Lchange success, so U0 selects the same binary point on that very WORD. This proves whole selected-image containment, rather than independent coordinate funding. The native frontend has only the finite LIST singleton sequences H and regular binary selection/rejection masks, all evaluated at the common actual own map.
-
-At each hard ROOT map B is unreachable by any prefix or default, so neither cap can return a tuple in H on any WORD. Both outer unions therefore retain exactly the same BASE64 result or rejection at those maps. One namespace, one prefix, at most m markers and m enum facets serve m principal roles; no helper or color is allocated per TOKEN. The claim does not bound WORD bytes or tuple arities.
-
-The outer BASE must admit the auxiliary WORDs at this switch. The displayed free ur stage has no outer TOP filter; a protected binary-only P1 would exclude every auxiliary and invalidate the funding. After the switch the original WORDs already carry H, so a later independently valid same-member TOP narrowing can remove the auxiliaries. Fixed INPUT arrays, inherited filters, exact TYPE/component/code/owner readers and other residual member families require their own writer; this construction does not bypass them.
-
-The [maintained native control](../test/research/re01/scalar-qname-proxy-batch.test.ts) uses `TWFu` and `T WFu`, both binary `4d616e`, with different captured LIST arities. It checks SOURCE plus all nine direct FULL constructions with empty obligations, four genuine corresponding derivations, and independent own/ROOT/auxiliary result matrices under the unchanged defaults. These are local native checks, not endpoint correspondence, a complete RE01 forest, input-role extraction or global coverage.
-
-## Auxiliary QName feedback preserves the token parameter stock
-
-Consider one whitespace-free ITEM token and a finite rooted interface of actual VALUEs, protected WORDs and authentic current enum operands. First close protected lexical cores under extraction of a legal QName local. A STRING core `p:P1Y` therefore contributes P1Y before counting fixed duration parameters.
-
-The native [sameValue operation](../src/compiler/schemaDatatypeValues.ts) compares both family and canonical value. In particular `hexBinary` and `base64Binary` remain distinct families. A same-family base64 ITEM inverse fixes its unique compact token. A hex inverse has only the finite A through F case choices. STRING and anyURI ITEM equality fixes the normalized token characters.
-
-QName and NOTATION parsing accepts one NCName or two NCNames separated by one colon. Same-value qualification preserves the local exactly. Decimal words start with a digit, sign or period. All native calendar forms start with a digit or minus; [parseReduced](../src/compiler/schemaExactCalendar.ts) permits gYear as `-?[0-9]{4,}` with an optional zone and no leading plus. None is an NCName. IEEE overlap contributes only INF and NaN, since minus-INF is not an NCName. Boolean overlap contributes only true and false.
-
-The only unbounded QName-compatible arithmetic family is positive P-duration spelling. Its inverse preserves the exact native months and seconds pair, even when leading zeroes, field decomposition or fractional trailing zeroes vary. Negative duration spelling starts with minus and is not an NCName. Native negative zero does not create another duration parameter.
-
-If u is such a duration alias, a QName spelling p:u still has local u. Its colon prevents decimal, IEEE, calendar, duration, hex and base64 parsing. A STRING or URI output pins p:u itself. Returning to a bare QName alias returns u, hence the same duration value. A second prefix cannot nest: q:p:u is rejected. A fixed binary core which is itself a legal QName contributes only its already fixed local and any duration parsed from that local.
-
-Thus auxiliary QName feedback cannot generate a new unbounded numeric or duration parameter. Only actual positive tagged qualification edges create inverse obligations; incidental co-parses do not become new positive families automatically. A positive binary ITEM does not produce positive LIST chunks, and a LIST inverse preserves tagged item values and arity.
-
-This closure does not bound alias multiplicity or prove a simultaneous whole-tuple schedule. A finite IEEE inverse can still produce an incidental unbounded decimal or shared-year parameter. That remains a joint numeric reset batch, with the actual WORD, INPUT masks, equality equations and protected point relations retained.
-
-## Uniform finite capacity of regular decimal inverse fibers
-
-Let D be a genuine S-state deterministic automaton over normalized whitespace-free token words, where S is at least one. For any native decimal q, the intersection of D with its exact same-value inverse is either infinite or contains at most `12*S*S` distinct words. The bound is independent of q's significant-digit length.
-
-The exact decimal branch of [inverseExpression](../src/compiler/scalarSchemaAssessment.ts) has finitely many sign and decimal-point choices. For nonzero q, the significant digit body and the point position are fixed. Only a leading integer zero run and a fractional trailing zero run are freely variable. Integer q may omit the point or append a point followed by zeroes. Zero has three sign choices and the integer-zero, integer-plus-point, or point-plus-fraction branches. There are at most two free zero runs in every branch. Integer subtypes only intersect this grammar with a narrower lexical language.
-
-If one accepted free zero run has length at least S, its DFA path repeats a state inside the run. Pumping that nonempty zero loop produces infinitely many accepted normalized words. Every pumped word still denotes the exact same q. Therefore every run in a finite fiber has length less than S. Each branch has at most S choices for each of two runs, and fewer than twelve fixed sign/point branches suffice. This proves the stated bound.
-
-The fixed significant body may be long, but it merely changes the DFA state transformation between the zero runs. It creates neither another free run nor another branch. The actual product automaton for the complete INPUT profile must be used; the bound is not inferred from an unrelated single-start-state mask.
-
-Refine overlapping lexical predicates into disjoint exact Boolean cells on that product DFA. Each cell has capacity zero through B, or infinity, where `B=12*S*S`. Finite cells can be exhausted; infinite cells supply any finite number of fresh aliases avoiding protected words. Hall demands over overlapping channels reduce to matching over these disjoint cell capacities. No truncation threshold depending on a future tuple or snapshot count is needed in this genuine regular sector.
-
-The result does not make arbitrary scientific IEEE predicates into raw DFAs. Value guards constant on q remain in the qualified numeric predicate. A protected binary or STRING value must contribute its genuine inverse constraint. Unprotected binary and STRING outputs derived from a reset token must be reconstructed coherently from the same chosen token; zero pumping generally changes those derived outputs. Shared normalized WORD equations cannot be pumped independently.
-
-These three results leave the global join open: a bounded common TOKEN pool must still support all actual namespace maps, complete tuples, current BASE witnesses and simultaneous updates. The [symbolic sequence owner](../src/compiler/schemaSymbolicSequences.ts) can check containment for an already finite recipe, but it does not establish that synthesis bound.
-
-## Local duration restriction intervals
-
-For one free duration restriction interval, the endpoint count can be fixed before choosing its WORD profiles. A checked interval with a common nonempty finite positive stock has a reconstruction using at most sixteen proper restriction transactions and 384 genuinely new endpoint values. Exact INPUT endpoint constants are additional finite data.
-
-This result concerns a private interval in one whitespace phase. Its intermediate rows have no protected BASE, identity, PROPERTY, source, component, annotation or WORD reader. Prescribed non-INPUT endpoint occurrences, equations and distinctness ports cut the free interval and are counted separately by the caller. The final code must permit the extra enum components used below; an exact PROPERTY/source component-table endpoint is outside this theorem.
-
-The INPUT scalar inventory is actual and authenticated. The ordinary numeric nonbound/whitespace mode must be coherent and cover the inherited whitespace duties. The result does not assume that an arbitrary formed inventory can self-KEEP. Every unchanged bound kind retains its complete CURRENT components and annotations; every changed kind still satisfies actual fixed, compatibility, cross-kind, endpoint-membership and internal-pair checks.
-
-### Native four-anchor projection
-
-The [duration comparator](../src/compiler/schemaExactCalendar.ts) returns equality only for the same native `(months,seconds)` pair. For different values, less means strictly less at all four Appendix E anchors. A tied anchor gives indeterminate. These outcomes are preserved by the [duration bound language](../src/compiler/schemaDurationLanguage.ts).
-
-Write V(u) for the four anchor coordinates of endpoint u. Native x<=u means either native sameValue(x,u), or strict inequality at all four coordinates. For a finite upper endpoint set U, put m_i=min(V_i(u):u in U).
-
-A maxExclusive conjunction is exactly the strict orthant V_i(x)<m_i. Retaining one actual endpoint attaining each minimum preserves it, using at most four endpoints.
-
-For maxInclusive, if no endpoint has full vector m, four minimum achievers also give exactly that strict orthant: equality to a selected endpoint fails another selected minimum. If an endpoint u0 has vector m, only its exact native value can be an additional admitted corner. Retain u0 alone if every old bound admits it; otherwise retain u0 and one actual rejecting bound. This again uses at most four endpoints.
-
-The native-equality case is essential. P400Y and P146097D have equal four-anchor vectors and different native values. Their inclusive conjunction rejects both endpoint values; choosing one would add an endpoint. Lower projection is the order-dual construction using maxima.
-
-An unchanged kind is never projected. INPUT values remain constants in the point pool, without forcing their components to occur actively in every child. Active presence follows from actual whole-kind KEEP or a genuine retained-component obligation.
-
-### Finite marked transactions
-
-After an exclusive endpoint u is introduced, its value is excluded. Proper same-family restriction cannot later admit it again. An outside-BASE occurrence therefore needs continuous same-kind sameValue-repeat authority. If a later genuine upper-exclusive value v is introduced while u remains, v is strictly below u at every anchor. Hence a final free upper-exclusive projection can choose its non-INPUT essential points from one latest genuine birth batch. The lower-exclusive argument is dual.
-
-Normalize unprotected genuinely local NEW flags to fixed=false at their original births. This does not change the current image or help the current row; it only removes future fixed obligations. It does not relabel a whole INPUT KEEP as NEW. Actual INPUT flags are cleared only by real legal transactions. A required final new flag is installed at the last retained replacement of its own kind, avoiding an invented simultaneous local change of both upper kinds.
-
-Mark the last local replacement of each final changed kind, at most three rows. Mark an essential birth batch if it precedes that final replacement, at most two more rows. Mark the first real clear of each inherited fixed kind in the flag-normalized path, at most three more rows. Coincident marks are one complete transaction, so there are at most eight marks.
-
-At an exclusive birth retain the union of an exact old-kind projection, at most four endpoints, and the selected final batch points, at most four. This preserves the old bound predicate exactly and carries the final outside-repeat authority. Necessary co-NEW clear components remain in that row. Whole-kind KEEP uses the reconstructed CURRENT objects exactly.
-
-### One conditional opposite-upper preparation
-
-The [scalar owner](../src/compiler/scalarSchemaAssessment.ts) permits indeterminate same-kind compatibility, but actual endpoint membership requires determinate bound admission. The proof uses that admission and native-order transitivity, not transitivity of the permissive compatibility predicate.
-
-After a genuine inclusive-upper update, its points are strictly below every CURRENT exclusive bound. A later inclusive update with exclusive KEEP therefore needs an intervening opposite update. Choose the first such old exclusive transaction. Its supplied endpoints cannot be outside repeats above the retained inclusive points, since the universal derived-exclusive versus prior-inclusive guard would reject them. Its genuine endpoints satisfy every earlier retained bound by their old BASE admission.
-
-After an exclusive update with a genuine point, that point is below every CURRENT inclusive bound. A second exclusive update similarly requires the first intervening inclusive transaction. Its genuine points have the required earlier admission. If an exclusive update contains only outside repeats, the derived-exclusive and kept-inclusive cross guards force the relevant pairs to be indeterminate, so that case already has a valid KEEP orientation.
-
-The argument holds for sets because one comparable cross-pair blocks KEEP and every cross-pair is checked. The preceding successful replay row handles mixed-age inventories: its genuine points supply the direct comparisons, while its outside-repeat part supplies the two-guard incomparability case. At most one conditional opposite preparation is needed before each mark. If it would change a kind after that kind's marked last replacement, the same argument would force a later old replacement, a contradiction. Unnecessary preparations are omitted.
-
-### Lower timing and genuine enum support
-
-Let p be any required positive. A selected final lower l and retained upper u satisfy l<=p<=u, strictly whenever the relevant exclusive bound requires it. Never move the final lower earlier than its original last local-kind mark. Its time is the later of that mark and the last bound fixed-clear mark. Co-issue it at that later already counted transaction when legal; a different value necessarily follows its own lower clear.
-
-Before that time keep the reconstructed coherent lower inventory, including its real fixed clear, and omit unneeded temporary lower updates. An essential lower-exclusive birth remains a preparation with unprotected flags false and continuous outside-repeat authority. This avoids installing a mixed final fixed lower set early and thereby invalidating later whole-kind KEEP. Required co-NEW clear components are not serialized.
-
-For each retained row i, let P_i contain the final required positives and all genuine endpoint values whose selected introduction is still later. Omit the current exclusive introduction value after its introduction. Outside-repeat operands are not asserted to be BASE members. Keep every inherited enum component and add one genuine NEW enum with value set P_i. The intersections implement the decreasing positive stock; inherited enum components never disappear.
-
-Future upper points and final positives have old admission through every earlier selected row. The rebuilt bounds preserve that admission. A delayed genuine lower point instead uses a direct canonical check: the retained lower predates its old introduction, every reconstructed upper admits it by l<=p<=u, and its authentic INPUT-qualified spelling is retained. An already outside lower point uses its continuous exception and stays out of P_i. Thus every NEW enum is qualified in the exact reconstructed immediate BASE.
-
-Keep INPUT lexical constraints during preparations and append the final private lexical guard in the last transaction. Bound operands are assessed in BASE, so that final guard does not invalidate their qualifications. The decreasing enums certify containment even when projected bound metadata is weaker. No extra enum-only row is required.
-
-### Bound and limits
-
-Eight marked rows and at most one opposite preparation per mark give sixteen transactions. With no marks, one coherent whole-KEEP guard row suffices. At most three kinds are present, and the conservative birth union has at most eight genuine points per kind per row. Therefore sixteen times three times eight gives 384 new endpoint values. At most sixteen new positive enum components are added, using the required positive stock and at most 384 future endpoint values.
-
-The positive stock's cardinality and WORD lengths are not bounded here. Once their separate finite role bound is established, the [supplied finite endpoint theorem](#supplied-shared-endpoint-tuple-theorem) can treat the finitely many endpoint and qualification roles jointly. The narrow native private-alias capacity operation is not an implementation of this larger construction.
-
-The empty case needs its own accepted alias construction or an exact empty-boundary argument. This theorem establishes no empty hard-end replay, outer ordered-UNION reconstruction, broad PROPERTY-image preservation, WORD-stock bound, scalar J or global g(P). It is a local source-semantic contraction, with no new native execution or public solver API.
-
-## Aggregate mixed-base emptiability
-
-An inherited SOURCE simple-content description can retain the prerequisite `simple-content-base-mixed-emptiable` after its direct complex owner has checked that prerequisite. Generated scalar slots and later scalar consumers must continue publishing the exact component and originating context. Their checked scalar results alone do not discharge the premise.
-
-The finite verifier resolves this known prerequisite with the existing content mapper and authenticated restriction particle view in that originating context. The content must be mixed and its formal `schemaEmptiable` summary must be true. The fact is cached separately from component construction; checking it neither supplies FULL of its named complex type nor schedules that FULL merely from the owner identifier.
-
-When the originating closure is open, the view's actual type dependencies enter its ordinary worklist. A late deferred or correspondence premise uses the already checked originating closure, and uncovered type support remains unresolved. A current-context fact cannot discharge an original-context premise or another candidate's premise. Unknown scalar prerequisites and ordinary F2 retain their existing behavior.
-
-The construction owner can explicitly request a conditional particle restriction comparison that forwards scalar prerequisites from completed fixed-value reads. The default standalone comparison continues to report unresolved when such prerequisites remain. Forwarded obligations retain their originating context and join the existing type and identity-constraint read footprint, including completed reads from an unsuccessful mapping alternative. Actual unresolved scalar calls remain unresolved. Raw simple-content formation still requires its genuine component owner; the mixed-content fact does not certify it.
-
-The [aggregate dispatch controls](../test/research/re01/scalar-mixed-emptiability-dispatch.test.ts) retain local scalar debts while checking complete evidence, nonempty and wrong-variety contrasts, context separation, required children and sticky resource limits.
-
-The [complete simple-content guard controls](../test/research/re01/scalar-sc-fixed-value-dispatch.test.ts) select a fixed BOOLEAN value at the declaration's map while preserving the required literal scalar ancestry and original QName selection at the producer's map. Their exact input-type and restriction-wrapper contrasts fail the required particle comparison. These are supplied constructions and chosen contrasts, not a universal helper-necessity result.
-
-This corrects the demonstrated inherited mixed-base and particle-prerequisite frontiers. It establishes no general reconstruction, late-frontier adequacy, complete negative answer or termination bound.
-
-## Inherited scalar definitions and private arithmetic support
-
-A checked RE01 successor preserves the scalar definition of every inherited complex simple-content type, including the endpoint changing from extension to restriction. The endpoint exception changes its BASE and method; it does not exempt its content from [candidate correspondence](../src/compiler/re01CandidateCorrespondence.ts). An extension first born over an exact input BASE therefore keeps that BASE's scalar-definition port throughout its later retirements.
-
-A genuinely new restriction helper has a different first-birth rule: it may select a new scalar definition with the required literal ancestry. This freedom cannot be applied retrospectively to an inherited endpoint. Inherited RAW SIMPLEs also undergo separate-context metadata, literal BASE/ITEM/ordered MEMBER, facet-property and annotation comparisons. Reassessing a CURRENT provider does not permit a committed facet property to change across a checked step. Context-qualified FULL duties remain actual obligations.
-
-These statements concern scalar identity and compared properties. They do not identify operands from different namespace maps, freeze the active NOTATION registry, supply a first-birth producer or bound the number of private providers. In particular, the remaining scalar contraction problem concerns static private SIMPLE constructor rows and their BASE DAG, rather than inherited scalar programs changing at NP retirements.
-
-### Exact successor portfolio
-
-There is a native arithmetic validation kernel. Let `Qq` and `Qr` be INTEGER singleton providers, `Z` be STRING restricted by the whole pattern `z`, and `J` be INTEGER with `minInclusive q` and `maxExclusive r`. The endpoint operands genuinely use `Qq` and `Qr`, respectively, and separately qualify in INTEGER. Retain the authentic builtin INTEGER components. With empty TOP inventories, form:
-
-```text
-U = UNION[Qq, STRING, INTEGER]
-V = UNION[Qq, Z, J] restricting U
-```
-
-The numeric image of U is `{q}`; V adds every integer in `[q,r)`. Native mixed-bound consistency requires `q<r`, so complete selected-image containment holds exactly when `r=q+1`. The corresponding-member derivations alone do not establish containment. Native controls check all six fresh SIMPLE roots: `(0,1)` passes, `(0,2)` fails V's selected-image restriction, and `(0,0)` fails J's bound order. These are supplied local portfolios, not complete RE01 forests or a compulsory iteration construction.
-
-### Private singleton reissue
-
-In a successful portfolio J accepts exactly every INTEGER lexical spelling of q. Before its birth, reissue the private J with the same identity, name, final set and INTEGER BASE, retaining authentic INTEGER components and adding one genuinely qualified enum q instead of its two bounds. Its actual enum provider is Qq. This preserves J's complete WORD/value behavior and the literal nominal graph, including V's exact MEMBER references and incoming target-UNION identity alternatives. Its constructor no longer reads Qr.
-
-This operation preserves semantic VALUE/WORD clients, including typed facet operands that assess J. It does not preserve the old bound components, annotations, complete scalar PROPERTY or component-replay selectors. Such clients require a coherent reconstruction or an explicit retained boundary. Private peer recipes must use their real newly issued component tables. Qr is omitted only after a complete reference/owner/source/root audit; retaining it for another client is permitted. No actual input row is edited, and no inherited fresh root is discarded after birth.
-
-Separate native controls check the five rebuilt fresh SIMPLE roots, genuine enum qualification, direct J assessments and nominal relations. Reissuing the successful `(0,1)` case preserves its semantics. Rebuilding the failed `(0,2)` case is a repair of that supplied portfolio; its old J value 1 is not preserved, and its failure proves no fixed-root nonexistence.
-
-A weaker replacement of only V's last incidence by a dead INTEGER also preserves V when that incidence is covered by earlier member domains before TOP. It can change incoming nominal queries and direct J clients. Absence from successful final outputs is insufficient: an earlier member can select a value that TOP rejects, preventing a later member from winning. Nor does FULL of an arbitrary BASE guarantee that KEEP-all plus an empty pattern passes cross-kind bound correspondence.
-
-The independent review and native receipts for these source-level results are recorded in the #234 ledger. No general scalar-port bound, private-client closure, complete reconstruction, negative-answer procedure or mathematical termination follows from these local operations.
-
-## First-mode atomic contraction
-
-A checked static atomic restriction path can contract to one proper row in the following scope. Fix one actual context, one non-IEEE primitive and one effective whitespace phase, with authentic BASE B and a genuinely legal first restriction row. The supported predicates are decimal bounds and digits, calendar and duration bounds, and applicable lengths; the final identity's private code is writable before birth.
-
-This is a constructor theorem, rather than a claim that copying the final metadata succeeds. An available description or FULL(B) does not itself supply the authentic first-row producer. Immutable component, annotation, literal ancestry, SOURCE and complete PROPERTY readers require separate protection or simultaneous reconstruction.
-
-### Legal metadata projection
-
-Let n count B's complete nonrepeatable tuples. Preserve every unchanged whole kind through its authentic complete B KEEP inventory. For each changed or introduced kind, select one actual component from the first legal row; also select its actual B coverage witnesses and a component realizing its effective whitespace rank.
-
-A coverage witness in an unchanged whole kind is discharged by the property-equal B tuple. It must not also be added as NEW alongside that whole KEEP kind. There are ten supported nonrepeatable kind names, so the projection has at most `2n+11` positions and at most `n+4` selected new bound points, besides B's existing points.
-
-The projection introduces no kind or newly localizes an unchanged bound kind. Supplied-pair, fixedness and cross-BASE checks remain valid after deletion of extra NEW tuples; each selected tuple retains its genuine BASE and ancestor witnesses. Same-kind exclusive endpoints outside B keep their actual inherited authority and are never presented as B-admitted values.
-
-### Exact lexical reconstruction
-
-Preserve B's authentic pattern and enum components. Reissue private contributing ordinary P1 and enum groups as separate NEW conjunctions; every genuinely NEW enum value uses an actual B inverse WORD at its actual map. Source-only intrinsic patterns outside the ordinary profile retain genuine selector authority or remain a reconstruction boundary.
-
-An inactive value merely carried by B's enum inventory keeps its authentic authority rather than receiving a fictional inverse.
-
-For fixed parameters, the supported non-IEEE final unary predicates have effective regular normalized-WORD preimages. Export these as ordinary P1 guards, including primitive validity where the containment product needs it, and retain the final private TOP conditions. QName binding and NOTATION registry validity remain with their primitive owners; a pattern does not replace map or registry lookup.
-
-The projected first mode relaxes the original first mode. Every original final success therefore passes that projection and the exact final guards; conversely, those guards and the unchanged primitive parser enforce every final value and lexical condition. The rebuilt final identity has exactly the old complete WORD, value and normalization function across maps in the fixed context.
-
-The actual F2 dispatch also completes. B coverage witnesses remain present; missing whitespace coverage retains the old first row's empty main-pattern certificate. Otherwise, finite-enum membership or the supported length, decimal, calendar and duration containment products include the exact guards and primitive validity, so they find no genuine widening value. This uses the [scalar assessment owner's dispatch](../src/compiler/scalarSchemaAssessment.ts), rather than an assumed rule that every semantic subset receives a certificate.
-
-### Native control and remaining gates
-
-A genuine SOURCE decimal B with `maxExclusive 20` admits C with authentic KEEP plus separate NEW `maxInclusive 10`, `11` and `12`. A later D keeps that entire inclusive kind and introduces `maxExclusive 9`. Copying D's final upper inventory directly over B fails `facet-bound-pair`, because both upper kinds become local.
-
-The reconstructed D instead keeps B's exclusive bound, retains one first-row inclusive bound, and adds an exact ordinary P1 for decimal values below 9. Its complete function equals old D's function. The missing-pattern contrast is genuinely FULL and admits 11; its failure to preserve the intended function proves no nonexistence claim.
-
-The [independent review ledger](https://github.com/TechSpokes/typescript-wsdl-client/issues/234#issuecomment-6346694806) records the exact proof and native control fingerprints. That local control checked eight FULL roots, strict typing and default limits; it was scalar-only evidence, not a complete RE01 forest.
-
-FLOAT and DOUBLE scientific-bound preimages need not be regular. Their finite native endpoint alphabet does not make those WORD languages regular. Multiple contexts, guard and enum sizes, WORD lengths, provider closure, mixed LIST/UNION construction and ordinary helper counts remain separate open obligations.
-
-Mixed ordered UNIONs require first-selection observations even for values already available elsewhere. Removing an earlier member can expose a later value under the same WORD without creating a new primitive value. Counting only first-ever values therefore cannot establish general coverage, a terminating negative criterion or mathematical termination.
-
-## One common atomic guard for supplied calls
-
-A supplied finite atomic call interface admits a simpler common guard. Fix one actual context, an old checked atomic restriction phase ending at A with one primitive/whitespace phase, and its authentic first legal projected metadata mode M. The positive calls P must be accepted by both old A and M.
-
-Each selected value must have a genuine immediate-BASE inverse at its actual enum qualification map; neither a later LIST result nor future NOTATION activation supplies that premise.
-
-Let N contain the positives' selected normalizations and E contain their tagged native values. Add one ordinary P1 whitelist of N and one enum E to M, preserving authentic BASE repeatables and the projected whole-kind rules. For empty P, use an empty P1 and no empty enum component.
-
-Every positive survives. Conversely, an admitted call has a normalization from one positive and a value from another; every old private P1 accepts that normalization, and every old private bound, enum, precision or applicable length test accepts that value. The common guard therefore admits a subset of the old atomic function and preserves all its observed negatives across maps in this context.
-
-This combines the observations through normalization and whole tagged value. It does not license mixing individual items from different LIST tuples. Immutable selector, annotation, component-order and literal ancestry clients still require their actual protection or reconstruction.
-
-For nonempty P, put the new enum first in the writable component order. Its entries are genuinely BASE-qualified, so the owner's finite-enum F2 fallback completes without a general inverse-language proof. This also covers supplied FLOAT/DOUBLE positives; it does not make scientific-bound preimages regular or prove exact reconstruction of the entire old IEEE function.
-
-A native FLOAT control starts with genuine SOURCE S restricting builtin FLOAT without explicit facets, and RAW B having separate exclusive upper components 10 and 20. C reissues 20 through the actual inherited same-kind exclusive exception and adds enum `{1,3,5}`; D keeps C's actual components and adds P1 `1e0|3`. A direct D over B instead supplies enum `{1,3}` first, the repeated exclusive 20 and that P1.
-
-Both D constructions accept `1e0` and `3`, but reject canonical `1`. Removing only the P1 leaves a genuinely FULL construction that accepts `1`. E20 does not cover B's stronger E10, and FLOAT takes neither the length nor decimal fallback; the qualified enum completes the actual missing-coverage F2 branch. The repeated endpoint is explicitly outside B and uses its genuine S provider rather than invented B membership.
-
-Independent source/control review accepted these fixed-context observations. Strict typing and the three native cases passed at unchanged default limits with 1,084,342 cumulative work. No complete RE01 forest, finite mixed-call bound, cross-context activation transport or temporal decoder follows; decreasing semantic whitelists alone do not prove literal native KEEP between successive rows.
-
-## Regular admission blockers for ordered UNIONs
-
-Finite positive VALUE enums cannot in general replace an earlier STRING member. A STRING selection which fails the whole UNION pattern still prevents a later member from winning; reconstruction must preserve that admission as well as successful whole outputs.
-
-For example, take exact INPUT `B=[QName,STRING,D]`, where D is DECIMAL enum 1 with pattern `1` and restriction final. A proper V uses a QName enum selecting `(ON,x)`, preserving STRING S, exact D and whole P1 `x|1`. At ON, V returns BASE-funded QName x or STRING 1; at OFF, bare x returns STRING x, which B never selects at any map.
-
-Replacing S by enum `{STRING x,STRING 1}` exposes DECIMAL 1 on raw ` 1`: S now rejects, D collapses to 1 and the whole pattern passes. Instead, an ordinary S pattern `[ \t\r\n]*1[ \t\r\n]*|x` retains the complete whitespace blocker without an enum and preserves V's entire function across maps. The failed enum replacement proves no general nonexistence or necessity of this fixed cone.
-
-### A finite whole normalization guard
-
-At an already checked writable proper RAW UNION birth, append one ordinary P1 recognizing a finite normalization set Z covering every retained successful use of that TYPE. Include genuine BASE inverses and provider calls, rather than only final root VALUE calls. This same-row insertion preserves the other fields, existing component ordinals, all retained positives and all old negatives.
-
-The native F2 certificates remain supported in the qualified atomic/LIST frame: finite-enum fixed-value membership is total there, result-image languages only shrink and earlier member admissions are unchanged. This uses the [scalar owner's actual dispatch](../src/compiler/scalarSchemaAssessment.ts), not a rule that every semantic subset automatically has a native certificate. Descendants must retain the newly issued pattern or be reconstructed with authentic current tables.
-
-A ur-UNION constructor over anySimpleType forbids facets; it cannot receive this insertion. A facetBinding row needs a genuine materializer, and immutable INPUT or complete-inventory clients remain protected or are jointly reissued. These representation and authority conditions are part of the construction.
-
-### One preserving STRING slot
-
-There is a constructive local synthesis for one writable preserving STRING slot S, genuine preserving SOURCE STRING BASE A, finitely many proper UNION clients over exact INPUT BASEs and finite whole normalization guards. Other members and actual maps are fixed. Project the first legal metadata mode and let M be its admission language; the actual upper admission domain is `U=M intersect L_A`, where L_A is A's complete admission language.
-
-Compute regular R of words S must accept to prevent an unfunded later selection, and regular F of words where S acceptance would itself yield an unfunded whole result. Fold each retained direct or whole positive/negative call into those constraints by checking both selection outcomes. A negative whole call may require S acceptance followed by a whole veto.
-
-The conditions are `R subset U`, `R intersect F` empty and consistency of the fixed outcomes. If they hold, emit one ordinary P1 for R with no new enum; otherwise no solution exists within this fixed one-slot problem. Retain authentic repeatables, actual whitespace coverage and the first-mode formation witnesses; the owner's regular length product then certifies any remaining length containment. This scoped failure criterion is not a general RE01 negative answer.
-
-For XML whitespace preserve, replace and collapse, inverses of one literal normalization are effective ordinary regular expressions. Given finite Z, every potential whole success lies in a collapse fiber of Z. Fixed INPUT predicates, the replace/collapse ranges, literal ports and genuine capped multiplicities give an effective finite quotient for the bounded nested STRING equivalence fragment; this does not cover arbitrary nonSTRING donor relations.
-
-### Binary donors remain a separate relation
-
-A genuine changed-UNION image duty can require a BASE64 donor with different token boundaries. Let INPUT `U0=[FLOAT,QName,Sx]`, where Sx is preserving STRING with P1 `x`, `L0=LIST(U0)` and `B=[L0,BASE64]`. A QName restriction G has enum `(ON,x),(OFF,y)` and P1 `x|y`; proper `U1=[FLOAT,G,Sx]` is born at ON, and L1 restricts L0 with ITEM U1.
-
-Put N equal to 1 followed by 41 zeros and z equal to `N x y`. Proper `C=[L1,BASE64]` over B with whole literal P1 z selects binary alpha at its ON definition map, but selects `[FLOAT infinity,STRING x,QName(OFF,y)]` at OFF. B never selects STRING x in a LIST, so that tuple cannot qualify a new whole enum at any map.
-
-B on z selects a LIST, whereas B on `Nx y` selects the same binary alpha as C at ON. The two words have the same 44-character compact BASE64 core, but different collapse normalizations. Thus same-WORD funding and the STRING whitespace quotient do not solve this donor; the binary-scoped INPUT masks give a regular same-core repair. The typed tuple alone does not force the displayed N or z, and this fixed-cone calculation supplies no rooted lower bound or executed FULL receipt.
-
-### Conditional scalar history deletion
-
-Within one fixed actual H and registry world, given closed WORD/value/provider stock, finite actual code, guard, point, map and provider-plan palettes and a bounded total store of old TYPE/owner/component ports, repeated scalar states admit an actual suffix reconstruction in the closed scalar fragment. The stock covers private BASE inverses and endpoint qualification calls. Per-row ITEM/MEMBER arity alone does not establish the store bound; every later direct identity client must be registered or fixed INPUT.
-
-The function alphabet is finite without an equivalence oracle: primitive/whitespace output families and finite guard atoms give formal truth tables, atomic ITEM selectors give finitely many LIST output families and whole selection gives finitely many result tables. Equal tables imply equal complete functions, but native replay additionally keeps current operational descriptors, syntax, constituent graphs and identity/annotation incidences.
-
-At equal states, reconstruct the suffix against the actual earlier BASE tables. Resolve each CURRENT ordinal in that table, let the existing owner issue its real retained identity/annotation incidence and reassess NEW providers and genuine BASE inverses at their actual maps. Separate nominal/literal ancestry matrices and reduced/exact no-length ancestor ledgers retain the native historical queries; removed old receipts are regenerated with the shortened actual dependencies.
-
-This reviewed decoder covers closed scalar constructor/provider duties, not ordinary declaration or complex simple-content owner FULL. General private/private PROPERTY unfolds BASE/ITEM/ordered MEMBER code and needs a synchronized graph rewrite; a current PROPERTY truth bit cannot authorize deletion. The fixed-constituent paired-tower case permits synchronized deletion, while branching copy graphs remain open.
-
-These independently reviewed source results distinguish infinite admission blockers from successful value support. General closed-use WORD/value stock, canonical palette and live-port bounds, private BASE donor reconstruction, general joint PROPERTY/code shortening, complete negatives and mathematical termination remain open.
-
-### One common recipe for paired LIST histories
-
-There is a conditional construction beyond the fixed-constituent paired tower, in one fixed actual H, registry and INPUT world. Supply a closed finite palette of actual WORDs, values, maps, modes and qualification recipes; a finite stock of complete atomic or atomic-UNION ITEM property codes; and a bounded inventory of designated roots and held TYPE, component, annotation and owner ports. This interface is closed: every later literal reference to an old private identity is already held or protected, or is exact INPUT; unrepresented ancestry and code clients are excluded. The supplied provider writers must actually be ready, and each fixed INPUT authority and uncovered SOURCE or generated-scalar selector retains its complete authentic closure.
-
-For each paired proper-LIST code corridor, construct a finite graph of joint CURRENT states. One vertex records all physical copies together, including shared prefix components and annotations, complete operational descriptors and the actual full ITEM-code class. An edge must issue genuine FULL rows against each copy's own immediate BASE table; function equality alone does not create an edge.
-
-The union of the designated unary BASE paths has a finite physical sharing forest. Identifying equal complete unary property codes gives a separate code-prefix forest. Let n count designated paths and a count fixed INPUT code positions; overlaying their forks and protected positions needs at most `16*(n+a+1)^2` corridor endpoints. This counts neither every old row nor every unfolded ITEM occurrence.
-
-Each corridor receives one common row-label word. Physical copies can split while keeping the same property word; retain a persistent split ledger because distinct physical paths cannot later remerge. Live identity equality alone would forget that restriction and could produce a fictitious native replay.
-
-Choose a finite strongly connected component itinerary in each joint graph. Parent states retain their current native profiles, full identity partition, ordered live positions on each common word, protected checkpoints and SAME versus strictly later child requests. A nonrecurrent singleton can occur only once; a changed child at a repeated state needs a genuine positive-length return path.
-
-First choose a shortest accepting path in this finite parent graph. This bounds the requested child checkpoints independently of the old history length. Only then connect those bounded ordered requests inside each selected strongly connected component and issue one shared word for all its property copies. Shortening each copy independently, or starting with an unbounded old request list, would not prove the claim.
-
-Complete ITEM labels and paired BASE edges establish the actual recursive property equality by induction. Every connector row receives its own formation, qualification and inherited-fresh-root checks in the real resulting contexts. Ordinary declaration and complex simple-content clients require their supplied writers or protected ports; this scalar construction does not infer their validity from the common function.
-
-Independent review accepted this conditional decoder. It does not extract the finite ITEM-code stock, closed parameter palette, bounded designated ports, ordinary writers or universally adequate native evidence from an arbitrary successful RE01 construction. Those missing extractions remain necessary before this supplies a general bound or a negative answer.
-
-### Deriving the ITEM-code stock under a closed palette
-
-A further conditional construction derives that finite full ITEM-code stock. Fix one actual H and registry, exact dependency-closed INPUT/SOURCE/generated-scalar authorities, constructor arity W, a bounded closed exterior interface, and the genuine outside-client writers. Supply a finite canonical palette of WORDs, maps, points, predicates, full header/name/namespace labels, occurrence inventories and qualification plans, including a bound on actual table positions. Finite endpoint values alone are insufficient; old fresh names and private expressions cannot simply be added as new input constants.
-
-Writable NEW facet providers can use the proved ready atomic or finite-observation LIST portfolio on the unchanged WORD/map. Uncovered SOURCE/generated providers retain their exact authority closure. Private scalar-only scoped ownership can be reissued injectively under a stable retained owner when no outside scope reader observes it; outside declaration, SC, nominal, ownership and component clients retain their actual protected ports or supplied writers.
-
-The historical-reference census then has explicit owners: literal BASE/ITEM/ordered MEMBER, those ready providers, exact original recipes, and authentic immediate-BASE component replay. KEEP refers to the newly completed current BASE table, rather than a hidden reference to a deleted introducing TYPE. Component/annotation sharing remains in the joint CURRENT state; an externally observed authority remains protected.
-
-The four scalar variety strata and final constituent spines give a bounded lower path scaffold, including a LIST ITEM's possible UNION-to-atomic drop and its actual member witness. Add designated ports, fixed source/parser/whitespace boundaries, physical/code forks and drop witnesses to a bounded protected set P. This does not charge every old transient owner or every unfolded ancestor as a port.
-
-First shorten atomic RAW parser/whitespace corridors. Their complete functions are pointwise nonincreasing and belong to the supplied finite predicate alphabet. Align equal-code copies, mark function changes and P, and use the joint CURRENT product to splice constant-function intervals. One coherent monotone TYPE map fixes protected positions and retargets every writable constituent use to its actual earlier ancestor; no independent register floor map is assumed.
-
-Recheck LIST ITEM changes through their genuine ordinary F2, length-ancestor and nominal owners. All-atomic UNION MEMBER changes use the separate atomic argument. Mixed outer UNIONs additionally need the complete native image frontend: datatype-context fixed-value image scopes, actual LIST tuple and symbolic token fallbacks, the supported guarded atomic scopes and singleton IEEE scopes. Genuine NEW facet formation separately retains its supplied lexical-map qualification. Function equality alone does not prove that native completion, and real identity, final, provider and component authority remain required.
-
-This gives a computable finite atomic code stock K0. Each flat atomic-UNION MEMBER coordinate then moves monotonically through that stock, so a width-W tuple has at most `1+W*K0` successive configurations. Within a fixed tuple, the finite whole-function alphabet bounds decreasing function plateaus. The same joint earlier-table construction gives a finite full flat-UNION code stock K1; affected LISTs and mixed parents receive their actual qualification again.
-
-Atomic and flat atomic-UNION ITEM codes are therefore finite before applying the preceding common-recipe LIST/outer-UNION decoder. The dependency is finite supplied palette/interface, lower scaffold and protected set, atomic stock, flat-UNION stock, then parent/checkpoint histories. It contains no assumed finite old ITEM-code inventory or old history length.
-
-Independent review accepted this composition after finding and repairing an earlier misuse of the all-atomic MEMBER argument for mixed parents. Its fixed-world, ready-provider, complete palette, arity and exterior-writer premises remain supplied. Unknown private negative-property, exact-code and SC observers still require genuine transport, rather than merely a counted root ID. Extracting those parameters from arbitrary RE01 inputs, complete evidence adequacy, general negatives and mathematical termination remain open.
-
-### Deriving constructor width before the history bound
-
-A reviewed extension removes the independent constructor-arity premise from the preceding closed-palette result. It retains one actual H and registry, the realized finite full parameter/header/name palette, READY provider plans, authentic current-component materializers, bounded closed exterior ports and their actual outside-client writers. Its whole-function alphabet is finite independently of MEMBER-array length, using the actual finite decision-table construction.
-
-First shorten nonflat proper UNION corridors using a genuine immediate-BASE CURRENT KEEP bridge that retains the later endpoint's actual MEMBER array. This preserves the following row's actual SAME positions while native mixed-image frontends recheck the new containment. The repeatable-only UNION argument separately justifies legacy-to-exact table replay; it makes no atomic scalar-mode conversion. Bounded retained rows then permit a simultaneous width projection keeping first function occurrences, inactive family-shape witnesses, actual protected slots and the old final-column sentinel.
-
-Those outer arrays expose finitely many LIST roots. Within a LIST phase, delete an unprotected repeated predecessor and replay its actual next row's NEW/KEEP mode against the matching earlier real table. Do not insert a self-KEEP alias. The state retains the actual encoding and ITEM function/parser/shape; native ITEM derivation follows literal UNION ancestry, at most one actual UNION-to-atomic drop, then literal atomic ancestry. Preserve genuine length witnesses for both reduced and exact ledgers, with at most four witnesses per palette length value on each root path.
-
-The distinction from self-KEEP is necessary. A valid LIST can first introduce minLength(1,fixed=true) and minLength(2,fixed=false), clear the kind through a genuine intermediate mode, then restore the old table. A direct KEEP-all alias instead compares the inherited fixed value 1 against supplied value 2 and fails. Replaying the actual next mode retains that fixed-clear operation rather than assuming a repeated table is self-replayable.
-
-The bounded LIST paths now supply finitely many actual ITEM checkpoints for flat UNIONs. Apply the same coordinated height and width reduction there, preserving positive full-code cohorts, real nominal witnesses and authentic CURRENT authority. The dependency order is outer UNION roots, LIST paths, flat ITEM requests, derived constructor width, then the preceding finite-history theorem. It does not assume a finite old ITEM-code stock or mark every old transient request as a port. Generated dependency vectors are re-evaluated against the reconstructed graph, not counted as historical alphabet labels.
-
-Independent review accepted this assembled argument after the fixed-clear counterexample invalidated the earlier LIST shortcut. The result derives conditional scalar constructor width and history, not the input-funded palette, ordinary helper bank, exterior writer or universal executable evidence adequacy. Those extractions, complete general negatives and mathematical termination remain open.
-
-## An original root can require a new scalar function
-
-The maintained [simple-content fixed-value controls](../test/research/re01/scalar-sc-fixed-value-dispatch.test.ts) rule out solving every input with existing scalar functions and fresh aliases alone. This is a necessity statement for that exact finite SOURCE host, rather than a lower bound on arbitrary helper depth or parameter size.
-
-Its original T is the ordered UNION `[QName,BOOLEAN]`. Mixed formally emptiable Z supports simple-content Tau with that scalar; Sigma restricts Tau with retained P1 `true`. Original A has a two-arm CHOICE of optional LOCAL y declarations of exact named TYPE Tau, each fixed to lexical `1`, hence BOOLEAN true. Original I removes that content, and requested t extends I with references to two unrelated abstract GLOBAL heads whose exact TYPE is Sigma.
-
-Every legal middle extending A retains its complete LOCAL fixed-value prefix. A surviving SEQUENCE tail cannot receive t's CHOICE under the selected particle mapping, so a successful middle exposes A's two CHOICE arms. Each original head must supply a participating fresh GLOBAL y member; the GLOBAL-to-LOCAL comparison must preserve the fixed BOOLEAN true value.
-
-Affiliation forces the member's complex TYPE below exact Sigma, while the restriction comparison to Tau excludes extension. Genuine FULL construction on that literal complex corridor preserves simple content. Its scalar selector must consequently have literal scalar ancestry to Sigma's authentic generated scalar; a bare BOOLEAN selector cannot replace that ancestry.
-
-The only existing scalar at or below that anchor is Sigma's own scalar. It selects QName on every admitted collapse spelling of `true`, at every map, while the retained P1 excludes BOOLEAN's alternative lexical `1`. Fresh aliases and unchanged first RAW views therefore cannot supply the required BOOLEAN result. Some genuinely new scalar function is necessary.
-
-The existing positive constructs a QName enum at its actual ON definition map and a proper `[Guard,BOOLEAN]` UNION retaining Sigma's pattern. At the member's OFF map, Guard rejects and BOOLEAN wins. Its complete control checks the original context, actual qualifications, all fresh roots, correspondence and the one-node forest.
-
-Independent review accepted the necessity argument and its distinctions between literal scalar ancestry, nominal UNION fallback and actual VALUE selection. It neither requires this particular enum syntax nor proves that arbitrarily many functions, values, LIST layers or historical rows are necessary. A general procedure must bound permitted new constructions rather than omit them.
-
-## Finite duration bases for hidden VALUE predicates
-
-The [legacy containment controls](../test/research/re01/scalar-legacy-value-containment.test.ts) distinguish public PROPERTY from the complete VALUE function. An exact BASE with maxInclusive `P2M` admits both `P1M` and `P30D`. A legacy child with those two incomparable bounds exports `P1M` while retaining both VALUE predicates. It can match SOURCE scalar properties without admitting every value of that SOURCE scalar. Native reconstruction must retain the physical predicates or prove a valid replacement; equal public code is insufficient.
-
-There is an independently reviewed finite predicate basis for one duration bound kind. At each of the four native Appendix E anchors, choose an actual old endpoint attaining the minimum coordinate for upper bounds, or maximum for lower bounds. These at most four endpoints preserve the conjunction of strict comparisons on every duration value.
-
-An inclusive test also admits exact native equality with its endpoint. The selected basis can have at most one accepted endpoint exception outside the strict conjunction: two distinct accepted endpoints would each have to be strictly below the other at every anchor. If that candidate fails an omitted old test, retain one actual rejecting endpoint. Thus five actual endpoints preserve an inclusive conjunction, even when different durations have identical anchor vectors. Adding the old public representative gives at most six endpoints for an inclusive kind or five for an exclusive kind.
-
-This is a VALUE-predicate lemma. It neither licenses a different effective-map order nor preserves fixedness, annotation, whole-kind, CURRENT or provider rules by itself. The selected endpoints still require actual native issuance and lexical support; their byte lengths are not bounded merely by choosing finitely many old witnesses. A complete scalar writer and the general decision gates remain open.
-
-## Effective SOURCE members in nominal relations
-
-The [local type relation owner](../src/compiler/schemaTypeRelations.ts) uses the effective ordered atomic/LIST members of a SOURCE UNION for target-member fallback. XML Schema 1.0 flattens nested SOURCE UNIONs, including constrained UNION wrappers; a supplied RAW member property remains literal and has its independent FULL formation obligation.
-
-For SOURCE `X=UNION[STRING,BOOLEAN]`, `P=UNION[X]` and A restricting P, X is not itself an effective member of P or A. Both the original context and its authenticated first RAW P view therefore answer `[X derived from A, A derived from P, X derived from P]` as `[false,true,false]`. An inherited SOURCE restriction uses a current RAW view at its constructor stop rather than returning to the old declared member list.
-
-This repairs an adapter disagreement with the scalar component owner; it changes neither P1 nor F2 semantics. The [independent relation controls](../test/unit/schema-type-relations.test.ts) and [complete construction/correspondence controls](../test/research/re01/scalar-source-union-members.test.ts) retain effective order, SOURCE constraints, RAW authority, exclusions, generated scalar components and actual contextual prerequisites. It supplies no general SIMPLE transitivity theorem or global reconstruction bound.
-
-## Grounded binary WORD bounds
-
-There is a finite mathematical decision and reconstruction procedure for the following restricted interface. Supply finitely many physical WORD views of one common canonical BASE64 core, with their actual fixed parser programmes, lexical maps, whole-pattern constraints, fixed ROOT values and membership or nonmembership tests in fixed whole-value images. Conjoin all tests on one physical WORD before projecting its values.
-
-Every programme and image automaton is fixed encoded data. Its encoding may not conceal an unknown endpoint, private enumeration value or unbounded literal guard. SOURCE/GSC execution and foreign saved enum maps retain their actual formation and image authorities. A finite constructed programme can be used only after its genuine formation and encoding bound have been independently established.
-
-This interface excludes equality between unknown whole LIST values on distinct WORD views or distinct cores, and excludes an unknown endpoint shared with a numeric substring. It requires neither a supplied TOKEN-arity bound nor a supplied bound on the number of uppercase `P` characters. Independent review accepted this construction within exactly that interface.
-
-### Whole-value and lexical control
-
-The existing [token image owner](../src/compiler/schemaTokenImages.ts) represents a fixed LIST image as a finite symbolic sequence automaton. Its state retains whole-WORD pattern progress, TOKEN position where a fixed enum requires it, failed earlier LIST alternatives and actual FIRST selection. Its labels constrain complete tagged TOKEN values; they do not independently approximate tuple coordinates.
-
-Pull those labels back to each actual TOKEN before projecting the common core. The actual [symbolic value owner](../src/compiler/schemaSymbolicValueSets.ts) retains Boolean combinations, including negative labels. Complementing a fixed image automaton therefore preserves the same lexical and whole-tuple correlation. Genuine inverse WORDs are reconstructed only after an exact positive whole-image test.
-
-On the BASE64 alphabet, TOKENs contain no dot, minus, colon or XML whitespace. Non-duration fixed image-label tests have effective regular preimages on this alphabet. STRING/URI use text; QName/NOTATION use the actual unprefixed name and registry; DECIMAL removes only optional plus and leading zeroes; HEX and BASE64 retain their actual canonicalization. Positive `gYear` has only its local or `Z` case, with a fixed canonical suffix and the real year grammar.
-
-FLOAT/DOUBLE have finite semantic value alphabets. Separate their exact values mathematically and use the actual unsigned exponential inverse for each fixed value. This does not declare unrestricted signed scientific inverses regular, or propose materializing the IEEE alphabet in an engineering array. Existing numeric conditions must remain conjoined with the regular labels in their supported scope.
-
-### Arithmetic stays within a P block
-
-A duration TOKEN in this alphabet starts with `P`, contains no further `P`, and has whole maximal digit runs separated by its actual unit letters. Cut the core immediately before every `P`. There is an initial P-free segment, followed by P blocks ending before the next `P` or at the end of the core.
-
-Each WORD view has at most one duration TOKEN beginning in one block. Thus a block has at most as many duration roles as there are supplied views. No duration field crosses the block boundary. Overlapping roles beginning at the same `P` share the same complete digit runs, with the same integer place-value alignment.
-
-For each role retain its actual unit-presence and TOKEN-end choices and impose the fixed-coefficient equations:
-
-```text
-months = 12*years + monthsField
-seconds = 86400*days + 3600*hours + 60*minutes + secondsField
-```
-
-Absent fields are zero. Keep the actual canonical output grammar and whole-label automaton state across its month/second separator. The aligned arithmetic construction uses genuine field ends, distinguishing emitted zeroes from arithmetic padding. It does not identify an unknown integer spelling with the fraction `0.x`, or add a cross-token comparison endpoint.
-
-Enumerate the finite relative orders of the block's duration starts, unit boundaries, field ends and TOKEN ends. At these boundaries, factor all shared lexical automata by their actual states. The intervening pieces are regular and may contain arbitrarily many non-duration TOKENs. Solve the joint aligned field equations and their regular constraints before projecting any view's fields.
-
-### Finite block relation and reconstruction
-
-The boundary control contains every actual whole-WORD, FIRST, symbolic-image and partial non-duration TOKEN state. A non-duration TOKEN spanning several P blocks carries its parser and label state continuously. No unknown value, endpoint or arithmetic accumulator may cross a block boundary.
-
-Include canonical BASE64 length residue, padding and low-bit restrictions. Padding permits no later core character. Retain each view's independent XML-whitespace transitions, with gaps assigned consistently when adjoining blocks. Handle the initial P-free segment, a final P block and the completely P-free or empty core explicitly.
-
-For each pair of finite boundary states, the local arithmetic construction decides the existence of one joint block and reconstructs a block when one exists. It yields a finite Boolean relation, not independent choices of the views' arithmetic fields. Negative image labels remain tests on the same local canonical output tracks.
-
-Use those positive relations as edges of a finite outer graph. Every actual feasible WORD family yields an accepting walk. Conversely, adjoining local witnesses with matching complete boundary states reconstructs one common core and its actual WORD views, since no unknown arithmetic data crosses the cuts.
-
-A shortest accepting walk repeats no internal boundary state. Its length bounds the number of P blocks. The finitely many local arithmetic products and regular path languages provide a computable maximum local witness length. Together these bounds give a finite core length and actual WORD lengths, including their whitespace paths.
-
-Every resulting whole tuple now has bounded arity and encoded coordinates. Its positive fixed-image test has already established an inverse. Reconstruct that inverse with its complete owner; a positive-only enumeration may be used after existence is established. Enumerating the finite bounded core/WORD choices and taking the maximum of their proved positive inverse lengths gives a uniform inverse encoding bound.
-
-This proves the restricted mathematical procedure's termination. It supplies no runtime implementation or complete RE01 search. In particular, a common binary core can remain coupled to an unknown whole LIST point at another core. A lawful helper reconstruction must eliminate that relation, or an independently complete joint solver must handle it.
-
-## History and physical VALUE joins
-
-Independent review also accepted conditional prebinding LIST and UNION history bounds. They start from actual fixed constituent programmes, a finite authentic future pattern/enum palette, held identity and annotation ports, and a genuine common table/provider writer. They do not derive constructor width or the constituent graph from an arbitrary successful forest.
-
-For LIST, retain ITEM functions over the entire actual old joint-map family, using one physical map tuple `q` across all required context views `H`. If `K(i,H,q)` is the arity spectrum at physical copy `i`, the barrier is `B = intersection_q union_(i,H) K(i,H,q)`; release outside `B` requires one actual `q` excluding that arity in every required view of every copy. Disjoint intervals use a valid excluded singleton, never an invalid row whose minimum exceeds its maximum.
-
-Finite unary spectral forms and eventual periodicity bound the needed integers and rows without counting old maps, old worlds or later donor WORDs. A per-view choice of a different physical map would not establish the joint release.
-
-For UNION, fixed constituents select the same raw value and normalization while TOP predicates contract. A repeated complete table/authority state can be removed by executing the actual outgoing NEXT over the earlier table. CURRENT clones that earlier table's genuine cached value or literal/provider fields; it need not reproduce a deleted issuer's optional spelling. Each required context generates its own actual cache and debts.
-
-The state count must include actual engine, origin, annotation and shared-group labels. Counting public facet classes alone is insufficient. Keep separate component and annotation identities, complete held vectors and authentic retention generations. Recheck native containment when an identity-based shortcut disappears, using only the qualified RAW/OWN-equivalent frontend. Foreign saved maps and uncovered SOURCE execution remain protected boundaries.
-
-The [correspondence owner](../src/compiler/re01CandidateCorrespondence.ts) preserves an inherited complex type's effective scalar content identity, including at its own cut. Inherited SIMPLE, declaration and AU recipes cannot be replaced. After authentic first mapping, a physical VALUE slot therefore keeps its chosen scalar recipe, WORD and map through descendants where its genuine programme and support are formed.
-
-Usable NOTATION constituents need their actual enum-qualified registration support. A bare facet-only NOTATION parse is not a usable declaration TYPE. Reassess availability, formation, origin and every actual context's obligations; physical function persistence transfers no FULL receipt.
-
-Different PROPERTY peers may choose different inverse WORDs: declaration and AU VALUE equality compares kind and tagged value, not lexical spelling. Choose one inverse per physical writable slot and keep it through its descendants. Hard lexical ports remain literal. AU own VALUE uses its declaration's TYPE, and effective VALUE remains `own ?? declared`; exposing a fixed declaration fallback must preserve that fixed value.
-
-A common finite TOKEN mask has an additional cohort condition. For every TOKEN in the union of all positive portfolios, every copy's complete pre-mask mode must either reject it or admit the same tagged value in that copy's actual BASE. This includes TOKENs unobserved at that copy. Each copy's own positives must pass; its demanded in-mask negatives must fail. A legal first mode in isolation and checks only on demanded negatives do not prove this condition.
-
-## Remaining joint constructor and evidence gates
-
-The [anchored ITEM continuation](content-model-s06-re-01-support-reconstruction.md#anchored-item-template-family-and-inherited-continuation)
-now supplies a finite research recipe family and a material born-child example inside a complete original-root forest.
-Its local preparations retain explicit enclosing-evidence duties. Full joint witness extraction, arbitrary inherited
-parents and complete native catalogue adequacy remain open; the finite verifier's general coverage and negative flags
-are unchanged. The single premise ledger records the precise boundary and independent controls.
-
-### Executable CURRENT admission ingredient
-
-`createSchemaScalarKernel(H).privateAliasEndpointAdmission(reference, owner)` now constructs a genuine CURRENT-admitted
-atomic operand and its membership and primitive WORDs, or reports `empty-current-admission` within exactly that unary
-problem. It reads the authentic completed component table and reuses the existing exact admission, numeric-image and
-regular-language owners. Non-enumerated bounded float and double controls use exact interval/spelling witnesses; they do
-not visit every IEEE rank. All emitted formation obligations, context and type dependencies remain in the scalar receipt.
-
-The positive shortcut tries genuine CURRENT enum spellings through the complete datatype before compiling a larger
-admission product. A rejected proposal never proves emptiness. The general path conjoins actual spelling and numeric
-predicates, and reconstructs both words through the existing CURRENT and primitive operand owners. Shared precharged
-resource limits apply throughout. Unsupported, unresolved, invalid input and exhaustion retain the native result boundary.
-
-The [admission controls](../test/research/re01/private-alias-endpoint-admission.test.ts) cover exact non-enumerated IEEE
-scientific spellings, disjoint masks, adjacent representable gaps, decimal/duration/calendar positives, GSC1 formation
-debt, unsupported input and sticky exhaustion. `EmptyFloat` has empty CURRENT admission while retaining inherited
-exclusive-repeat capacity. An empty unary image is therefore never reported as an empty endpoint-demand tuple.
-
-This operation is an executable ingredient for #347, not its complete tuple producer. Coupled endpoint comparisons,
-exceptional-repeat selection, full native formation discharge and the uniform IEEE capacity bound still need construction.
-The old `privateAliasEndpointWordCapacity` path still enumerates IEEE ranks without an enumeration component; one short
-admission witness cannot replace its maximum. No new capacity theorem or general negative cutoff follows from these tests.
-
-### Executable regular atomic WORD views
-
-`createSchemaScalarKernel(H).regularBinaryWordViews(views, owner)` implements the regular atomic and atomic-UNION
-fragment of #348. Each view supplies its authentic scalar reference, lexical map and optional fixed ROOT assessed through
-the native owner. The result explicitly excludes LIST, duration, numeric guards and whole-value image labels. It is not
-the complete grounded binary WORD producer and does not implement the shared duration P-block arithmetic.
-
-The operation compiles every complete raw-WORD admission and fixed-ROOT test before projection. Atomic UNIONs retain
-FIRST and failed earlier alternatives. It erases exactly XML whitespace from each regular mask, intersects their images
-with the native canonical BASE64 grammar, and finds an accepting core. For a chosen ASCII core `c1...cn`, the regular
-inverse `W* c1 W* ... cn W*`, with `W` exactly XML whitespace, is its complete erasure preimage. Intersecting that inverse
-with each original mask reconstructs one actual WORD per view. The existing operand owner reassesses every WORD, fixed
-tagged ROOT and primitive binary core. This proves local existence or emptiness only for the qualified fixed fragment.
-
-No finite IEEE alphabet is materialized. A predicate containing numeric guards is unsupported rather than projected away.
-Every view and ROOT contributes its actual formation duties and dependencies even when the joint result is empty.
-All products and reconstruction use the existing request budget, and resource exhaustion remains inconclusive.
-
-The [regular WORD controls](../test/research/re01/regular-binary-word-views.test.ts) independently require `QQ==` and
-`Q Q==` to share binary `41`, and reject individually feasible views whose cores disagree. Other contrasts preserve
-QName maps and FIRST, empty and whitespace-only cores, P-free cores, invalid residue/padding and low bits, ROOT formation
-debt on positive and empty results, and unsupported/exhausted outcomes. Reconstructed WORDs become two fixed VALUEs in
-one checked native candidate. Their common-core equation is established by the producer and separately replayed through
-native binary equality; the finite schema candidate does not encode an additional general WORD-sharing relation.
-
-### Executable finite endpoint tuples
-
-`createSchemaScalarKernel(H).privateAliasEndpointTuples({roles,constants,formula}, owner)` solves one joint native
-Boolean value/order circuit. Its exact fragment has bound-capable atomic CURRENT roles with genuine finite enum
-inventories, proved singleton images or proved empty images. A requested exclusive-repeat alternative names a matching
-actual CURRENT exclusive bound component and retains its ordinal and primitive spelling. The operation does not build
-a complete KEEP/REPLACE/fixedness inventory; additional facet-formation duties still belong to their native owner.
-
-For an enumerated role, every admitted value belongs to each genuine enum component. The smallest such component is
-therefore a complete finite candidate stock. Reconstruct each candidate through the full CURRENT fixed-value inverse,
-then reassess its genuine CURRENT and primitive words. A saved enum spelling is a positive shortcut only; a later
-pattern may require a different spelling. For an unenumerated admitted value v, prove the entire admission intersected
-with the complement of v's fixed-value inverse empty before treating v as exhaustive. A second value yields an explicit
-unsupported qualification. Numeric guards remain numeric predicates, including scientific float/double spellings.
-
-The finite Cartesian product evaluates the whole circuit using native `sameValue` and exact partial order, preserving
-`undefined` for calendar/duration comparisons. Exhaustive failure proves only local tuple emptiness in this qualified
-fragment. It never infers emptiness from independently selected unary witnesses. Authentic bound-repeat alternatives
-remain available even when CURRENT admission is empty. Every role/constant contributes formation obligations and type
-dependencies before a local empty result; shared precharged accounting remains sticky.
-
-The [tuple controls](../test/research/re01/private-alias-endpoint-tuples.test.ts) require `1 < 2` after independent unary
-choices both select `1`, reject a contradictory joint circuit with nonempty unary masks, and reconstruct equal values
-with spellings `01` and `1.0`. Other contrasts preserve undefined order, nonenumerated IEEE singleton positives and
-negatives, authentic empty-admission exclusive repeats, native complete-forest consumption and in-flight exhaustion.
-General digit-track tuples, non-singleton unenumerated roles, complete facet-inventory synthesis and uniform practical
-IEEE capacity remain #347 obligations. This operation does not establish the full supplied tuple theorem.
-
-### Executable finite whole-LIST image WORD labels
-
-`createSchemaScalarKernel(H).finiteImageBinaryWordViews(views, owner)` extends fixed regular atomic/UNION programmes to
-regularizable LIST programmes and positive or negative whole-LIST image labels. A label supplies a genuinely formed
-fixed LIST image, its actual saved map and a genuine finite enum component. Unenumerated image labels, duration P-block
-tracks and nonregular numeric joins remain explicit qualifications. Fixed LIST ROOT values are supported.
-
-The scalar owner first compiles complete LIST admission and each expected tuple's ordered token inverses. Intersecting
-the whole-tuple inverse with complete admission preserves LIST length, patterns, enum components and FIRST selection.
-UNION alternatives reject complete earlier-member admissions before applying whole-UNION facet tests. A genuine image
-enum component contains every possible image value; full saved-map image inverses remove unrealizable candidates.
-Each positive label unions complete selected tagged-tuple inverses; a negative label complements that whole union.
-No per-token projection substitutes for a complete tuple label.
-
-Issue #354 repairs the finite stock selection: `layer()` registers an auxiliary enum map for every restriction,
-including restrictions without enumeration facets. Only a layer with a genuine enumeration facet supplies a stock.
-Every admitted image value must belong to that component; the complete image inverse then filters the stock through
-all inherited and local constraints in the saved map. An absent enum remains unsupported, an enum containing the empty
-LIST tuple remains a singleton stock, and a genuine enum whose values have no complete inverse yields an empty image.
-The adjacent endpoint tuple selector already requires a genuine CURRENT enumeration component and does not share this
-map-presence defect. Other nearby stock selectors require nonempty enum maps rather than map presence.
-
-Native regressions ran against unchanged main `f650172c897fb63ed514c2b864691c846a75b72f` with Node 24.19.0,
-npm 11.9.0 and Vitest 5.0.3. `npx vitest run test/research/re01/finite-image-binary-word-views.test.ts --reporter=verbose`
-discovered 15 cases: six failed and nine passed before the repair. Pattern-only and length-only inherited layers each
-produced false positive-label emptiness and false negative-label witnesses; both signs of the unenumerated `OnlySplit`
-image incorrectly returned checked results. Native scalar admission independently established the complete QName LIST
-values before those checks. The corrected controls also compare a negative witness's complete tagged tuple against
-that native operand, pin admitted ROOTs, and distinguish an eliminated enum from the admitted empty tuple.
-
-All constraints are conjoined on each physical WORD before XML-whitespace erasure. The
-[shared reconstruction owner](../src/compiler/schemaBinaryWordReconstruction.ts) intersects their projected languages
-with the native canonical BASE64 grammar, then reconstructs every view through its complete erasure preimage. Native
-reassessment checks the actual parser, ROOT and each whole-value label. Positive labels emit genuine inverse WORDs in
-their saved image maps. Every view, image and ROOT retains native obligations/dependencies, including on local empty
-results. This proves local existence or emptiness only when all complete predicates qualify for this regular path.
-
-The [image WORD controls](../test/research/re01/finite-image-binary-word-views.test.ts) preserve tuple correlation,
-positive/negative labels on one core, saved QName maps, FIRST preemption, fixed ROOT, empty tuples, GSC1 debts on positive
-and empty results, native ordinary VALUE consumers, bounded float token guards and in-flight exhaustion. They reuse
-the regular producer's whitespace, BASE64 residue/padding/low-bit and inverse controls. Shared duration arithmetic,
-nonfinite images, unknown cross-core LIST equality and unknown endpoint/substrings remain open; #348 is not complete.
-
-### Outstanding joint claim
-
-The remaining theorem concerns one actual simultaneous construction. For every successful contextual judgment at authentic `(Gamma,P,target)`, derive a winning direct candidate with complete encoding bounded by a total computable function of that input. The input includes the entire exact inherited P, even historically fresh rows; it excludes arbitrary helper rows selected from an old successful witness.
-
-At a Gamma-fresh target, the same bounded winning candidate must introduce no newly stored nonprimitive identity. This must hold after scalar providers and ordinary owners have been added. Separate bounded-existence and no-new-identity witnesses do not imply their conjunction.
-
-The unresolved construction gates are:
-
-- Derive a finite realized ROLE/BASE/TYPE/SCOPE/SG graph with original-phase and HEAD replay.
-- Realize one shared BODY tuple, including common-arm TYPE, CODE, zero-origin and counted-UPA constraints.
-- Issue compatible private scalar first modes, caps and genuine first-BASE providers on that same graph.
-- Close SC/AU/AW/VALUE/IC assignments and bound any feedback from scalar helpers into ordinary owners.
-- Prove total native local decisions and complete receiving-context evidence frontiers.
-
-Finite response alphabets do not prove that their representatives can exist together. A support-only R-over-ur rewrite needs a closed client argument; imported affiliates can change an original HEAD's UPA. A scalar cap needs actual nominal, BASE, CODE, funding and coactivation preservation. The grounded WORD theorem cannot supply its own missing graph or fixed-programme inputs.
-
-Whole-future enum pooling is not a prerequisite. The required producer may use phase-specific points and genuine derived templates. It must not replace a first-BASE qualification by membership in a later image, or treat public PROPERTY equality as equality of hidden physical functions. Backward support counts apply only after the chronological role, height and width bounds have been established independently.
-
-The evidence frontier needs both directions of adequacy: every semantic duty is discharged in its actual context, and every additional native duty has a winning child or adequate local proof. This includes primitive, scalar, SOURCE, notation and IC obligations, all changed boundaries and all inherited fresh roots. Matching nonprimitive masks alone is insufficient.
-
-Once these joint premises hold, the existing [founded contextual relation](content-model-s06-re-01.md) admits a finite catalogue search. Count unretired original Gamma nonprimitive identities by `q` and all stored Gamma-fresh nonprimitive identities by `n`. An original cut decreases `q`; a fresh cut introduces no stored nonprimitive identity and decreases `n`. The lexicographic rank `(q,n)` then proves termination of the finite contextual AND/OR search.
-
-Gamma-owned backsupport remains in the complete original assessment; it is not a new callback that resets this rank. Evidence nodes retain their actual parent and target, and construction-proof cycles remain forbidden. Configurable budget exhaustion remains inconclusive.
-
-Independent review accepted this implication as a sufficient conditional theorem. The joint constructor and complete native frontier premises remain unproved. General coverage, native evidence adequacy, complete negative answers and mathematical termination over the entire accepted domain therefore remain open, without an impossibility or undecidability conclusion. Production activation and combined downstream qualification remain separate assignments.