[OmarAlJarrah]

Summary

A oneOf or anyOf written beside a structural body is kept under validation_only when no branch declares shape the body lacks, and is a degraded lowering otherwise (docs/compilers/openapi.md#union-beside-structure). The verdict followed the spelling rather than the meaning:

• A branch repeating the body's type was held to a closed list of keywords, so minProperties, $comment, deprecated, an x- key, or a description written as the body writes it degraded the union, while the same branch without the type did not (openapi: a restated union branch writing a keyword that declares no shape degrades the union #1394).
• A property the body declares through allOf was never found, so a branch restating it degraded the union (openapi: a branch restating a property the body composes through allOf degrades the union #1395).
• A bare branch writing only items, prefixItems or $dynamicRef was read as validation logic, though each names an element type or a referent the structural picture then lacks (openapi: a union branch writing only items, prefixItems or $dynamicRef is kept as validation logic #1393).
• A bare branch writing readOnly, writeOnly, default, xml, discriminator, format or unevaluatedProperties: false was read as validation logic too, while the same keyword beside a repeated type declared shape. Each sets something the IR holds structurally, so validation_only claimed a complete picture without it; both spellings now declare shape.
• A branch's property was compared with one declaration at a time, and a properties it nests only as written alike, so repeating what two declarations say together, or a nested property the body declares with a bound beside it, degraded the union (openapi: a branch property restating several declarations, or a nested property, degrades the union #1407).
• An allOf in a branch always declared shape, and a branch's $ref restated a declaration only where the declaration wrote the same $ref, so {allOf: [{required: [a]}]} degraded a union {required: [a]} did not, and {$ref: X} did not restate a property declared {allOf: [{$ref: X}], description: d}, the usual way to describe a reference.

These come from one mechanism: a bare branch and a restating one were judged by two different predicates, each comparing less than the body says. This change replaces both with one, so a keyword gets the same verdict whether or not the branch also repeats the body.

How a branch is judged

compilers/openapi/internal/schema/branchshape.go reads each key a branch writes:

• A $ref branch declares shape and a boolean one does not.
• Keywords that document the instance, name the schema, hold schemas it does not apply, say whether it admits null, or only narrow what the body shapes declare no shape, whatever they hold. The narrowing ones are required, the value constraints and collection bounds, and the validation-only keywords of docs/ir/boundaries.md#validation-only-constructs, an unevaluatedProperties other than false among them.
• type, format, enum and const declare none where every value the body admits holds to them. What the body admits is read by admission, the reader allOf refinement already uses, over the body's own keywords and its allOf across $refs, leaving out the body's own unions.
• properties and items declare none where each property, and the element, restates the body's declarations of it: in its own properties or items, and anywhere its allOf composes (admission.declarations). A schema restates its declarations when it is a boolean, when one of them is written alike, when together they admit nothing, or when each key it writes says nothing they do not say together: a shapeless key, a type, format, enum or const held by what they admit together, a $ref landing on a schema they compose through allOf conjuncts and $refs, and its own properties and items restating what those declarations declare in turn. Claims are judged off one stack over the branch's own tree, which the load phase bounds with the source (docs/compilers/openapi.md#source-budgets), and what each restates is read within admission's budget, so no recursion is added.
• An allOf declares none where each conjunct declares none, judged as the schema writing it is. A $ref conjunct of the branch itself declares shape, as a $ref branch does.
• Every other keyword declares shape: prefixItems, additionalProperties, patternProperties, unevaluatedProperties: false, a nested union, $dynamicRef, discriminator, readOnly, writeOnly, default, xml, the content vocabulary, $id, $schema, $vocabulary, and keywords of no vocabulary.
• A reading the admission budgets cut short counts as declaring shape. A value set past the member budget would otherwise read as admitting nothing, which every keyword restates. A union's branches share the budgets, and what the body declares of one property or element is read once however many branches restate it, so repeating a restatement in more branches reads no more of the body. What each branch writes is still read within the shared budgets, an enum's members included: two branches each restating a property with a 2,049-member enum read past the member budget where either alone does not, which two rows of TestOneOf_CoDeclaredUnionReadPastItsBudgetDeclaresShape hold. That reading is linear in what the branches write, so the budget stays shared.

This replaces #1278's lexical comparison (restatesBody, restatesProperty and their two closed lists), so the schema package no longer imports yml and its internal/archtest entry drops it. It also drops #1278's rule that a branch's property and the body's declaration agree on writing a $ref, which rested on OpenAPI 3.0 setting aside what stands beside one. This compiler reads those keywords the same way in 3.0 as in 3.1 (docs/compilers/openapi.md#ref-use-site), so they conjoin with the $ref here too.

Departures from what the issues drafted, each for a reason given:

• openapi: a restated union branch writing a keyword that declares no shape degrades the union #1394 keeps minLength beside a repeated type from reading as validation logic, yet expects minProperties there to read as it. Both are bounds the IR holds on a type, and inside a branch each holds only in that alternative, as required does, so both narrow, in the branch and in a property it declares alike. readOnly, writeOnly and default still declare shape, as its Direction asks, and const and enum do unless the body already says them.
• openapi: a branch restating a property the body composes through allOf degrades the union #1395 drafts comparing with what the allOf merge settles, which is known only once every type has lowered. A branch's property is instead held to what all of the body's declarations admit together, read from the source. A branch repeating the field the merge settles on repeats that too, since the field is one of those declarations or their meet, so this departs from the draft only where the draft would degrade a branch that says nothing new.
• openapi: a restated union branch writing a keyword that declares no shape degrades the union #1394 and openapi: a branch restating a property the body composes through allOf degrades the union #1395 leave openapi: a union branch writing only items, prefixItems or $dynamicRef is kept as validation logic #1393 out of scope, but their expected result, one verdict for the bare and the restating spelling, needs one predicate, and one predicate reading items as narrowing would have turned {type: array, items: …} beside an array body from degraded to validation_only. So openapi: a union branch writing only items, prefixItems or $dynamicRef is kept as validation logic #1393 is closed here.
• openapi: a branch property restating several declarations, or a nested property, degrades the union #1407 left an element compared by refinement's reading, which counts a bound in the element as saying more, out of scope. It is the same mechanism, so items is now a nested restatement like properties, and a bound in a branch's element narrows.

Comparing a schema against one base

Two schemas written alike were treated as the same when they sat in one document. Under an $id naming another URI, the same relative $ref names another schema. A base changes only what a relative $ref or $dynamicRef names, so each site below compares bases only where the text it compares writes one (annotation.WritesReference), and text writing none, or only absolute ones, says the same as on main. Whether a reference is absolute is the resolver's own test, fragment.Absolute, moved there from bind so the two cannot part. Five sites made that comparison:

• admission.sameText, which allOf refinement uses: a property {allOf: [{$ref: names.json}, {type: array, items: {$ref: item.json}}]} under another base kept nothing of its second branch, while the same branch with the $ref spelled absolutely was kept. The new restatement would have read such a branch as a repeat too. sameText now also requires text writing a $ref to read against one base, which the new bind.Table.Base reports. It still requires one document, as on main: a copy in another document is read apart, since its dialect may differ once each document is read in its own (openapi: a schema in another document is read in the root's dialect #839).
• The agreement deciding whether inline allOf branches fold (voices.go, openapi: inline allOf branches under different $id bases fold a keyword they spell alike #1408): two nots spelling one $ref under two bases folded into one entry read at the position, and the other constraint was lost; a lone writer under another base folded onto the position the same way. A branch whose folding keywords write a $ref it reads against another base than the position now folds nothing and joins no agreement. It is kept whole with a report saying why, in a composition and in a refinement. One writing no $ref there, {$id: …, minLength: 1} or a branch whose only $ref is in its properties, folds as on main.
• The fold of a field redeclared across allOf conjuncts (merge): two declarations writing an Unmodeled entry alike were one entry, and two nodes hoisted equal but for where they were declared were one type, so the second declaration's constraint was dropped with no report and no copy. Merger now takes Alike, which the schema package answers from the bindings: such an entry, or such a pair of nodes, keeping a $ref is one only where both read it against one base, and otherwise the later one is kept and reported as one given differently, two nodes overlapping as two types declared apart.
• The same fold where one declaration names a schema and the other writes that schema's text inline: the schema declared elsewhere won over its inline copy under any base. Under an $id at the copy, or at the resource holding the schema, a $ref the two spell alike names two schemas, so the copy's constraint was dropped with no report, on main as well. copies now asks Alike of every pair at least one of which is a copy, at the sites where the two nodes are written, so a schema in another resource or another document is read where it is written. The declaration sites a type judgment compares now sit in a type of their own (declarationSites), which keeps typeJudge within the method cap.

The rule text says so in docs/compilers/openapi.md#allof-refinement, #allof-inline-residue and #allof-redeclared-property.

Cost and reach

A verdict reads the body only as far as its branches need. A $ref branch settles alone, a branch writing only shapeless keywords leaves the body unread, and the declarations of what a schema nests are read only where it nests something; what the body's allOf admits, and every schema it composes, are read once a branch writes a key judged against the body, even where the body's own keywords would settle it (#1423). Besides time, this saves budget, since a reading cut short counts as declaring shape: an eager read could turn a union of narrowing branches beside a large body into one declaring shape. What the body declares of a property is gathered from its schemas only when a branch names it, and kept for every branch restating it. Each restating branch used to read it again, so 257 branches narrowing the body's one property read past the budget and degraded a union that, with 250 branches, was validation logic. Rows in TestOneOf_CoDeclaredUnionReadPastItsBudgetDeclaresShape redden when either read is made eager or a place is read again. No real document reaches the budgets: with both lifted, the 1,840 documents below and the golden spec compile to the same IR as on the branch, bar two cyclic allOf fixtures whose walk only the budget ends. The largest union beside a body there with an inline branch the budget reads has 15 branches. An inline allOf branch looks up bases only where it, or a wrapper holding it, writes an $id, the one way its base can differ from the position's, and only where what it folds writes a $ref. That shortcut changes no output, so no test pins it: a seam would need a hook through the lowering context, which no reader has, and the numbers below show its effect instead.

Instructions retired, /usr/bin/time -l, main at e85202b and the branch at a4dda68 alternating, with no other build or test running:

Input	main (median, range)	branch (median, range)
golden spec, GOMAXPROCS=1 (too large to run uncollected), five runs a side	109.2 B (107.9–109.7)	109.5 B (105.5–120.1)
500 unions beside a 40-deep composed body, GOMAXPROCS=1 GOGC=off, three runs a side for this and below	1,986 M (1,986–2,017)	2,145 M (2,143–2,176)
the same, 1,000 unions	3,774 M (3,771–3,778)	4,081 M (4,078–4,082)
one schema nesting 100 allOfs of two inline branches	482 M (481–482)	482 M (481–482)
the same, 200 levels	1,334 M (1,334–1,336)	1,334 M (1,334–1,335)
one allOf of 1,000 inline branches	1,130 M (1,130–1,132)	1,131 M (1,129–1,132)
the same, 2,000 branches	2,166 M (2,164–2,173)	2,167 M (2,166–2,169)
one allOf of 1,000 wrappers, each writing an $id	1,133 M (1,132–1,133)	1,197 M (1,195–1,197)
the same, 2,000 wrappers	2,169 M (2,168–2,172)	2,298 M (2,295–2,302)

The golden spec's two ranges overlap, the collector's timing being most of the spread. Every generated shape grows linearly on both builds. The $id wrappers there write no $ref, so since 732f682 they look up no base: 1,150 M (1,149–1,152) at 1,000 and 2,197 M (2,196–2,202) at 2,000, against 1,201 M and 2,311 M for a4dda68 run beside them, and 1,135 M and 2,173 M for main: 12 to 15 K instructions a wrapper more than main. Every other shape and the golden spec stayed within the spread of a4dda68 run beside them (golden spec 107.0–120.5 B for a4dda68, 107.0–120.2 B for 206ec17, three runs a side); those runs shared the machine with a test run. The union verdict adds about 0.31 M instructions per union over a 40-deep composition, linear in the number of unions, where main read nothing because it degraded them all. Before the base shortcut and the lazy reads, the 200-level spine cost 1,761 M and the unions 4,954 M at 1,000; before places were read once and gathered by name, the unions cost 4,126 M.

Integration: each of 1,840 OpenAPI 3 documents from public generator test suites, compiled on main and the branch, gives the same exit code and the same error set, with no crash; rerun at 1855a63 against main at da6c9f1 with the 3.x specs under testdata/ added, 2,072 in all, the IR changes only in that spec and in the two conformance fixtures this branch extends. One IR changes: GitHub's PATCH /gists/{gist_id} body writes anyOf: [{required: [content]}, {required: [filename]}, {type: object, maxProperties: 0}] beside a nullable object, which moves from degraded_lowering to validation_only. A model in another document and a declaration an overlay writes merge as on main, and a union in another document is judged as one in the source.

Decisions, not limits

readOnly, writeOnly, default, xml and discriminator declare shape, alone or beside a repeated type: each sets what the IR says of a node's values or wire form (visibility, a default, XML naming, routing), which a branch could hold only conditionally. A description or a deprecation is held on a node too, but documents it, so it declares none, and so does a redaction request, format: password or x-sensitive, which docs/compilers/openapi.md#password makes an annotation; an SDK reads no union entry under either reason, so a secret one branch alone writes is lost to it either way. A shape keyword with no reading here, such as additionalProperties or prefixItems, restates only within a declaration written alike. Both are stated in docs/compilers/openapi.md#union-beside-structure.

Stated limits

• A union beside a composition the reading bounds cut short degrades even where each branch restates only what the body itself writes, which the check this replaces read without the composition: from about 100 links of allOf for a restated property, and 130 for a restated type, and from five diamonds, 18 schemas, where the composition is diamond-shaped, since the walks read a schema two paths reach once a path. No union in the golden spec or the reference corpora comes near the bounds. openapi: a union beside a long composition degrades though its branches restate only the body's own keywords #1423 drafts reading the body's own keywords first, which no verdict a complete reading gives can contradict.
• Comparing a nested schema's text renders it again at each level, so restating a property 160 levels deep costs 6.0 B instructions, against 0.6 B on main, and about the cube of the depth beyond; allOf refinement of nested items already costs as much on main. The nesting bound of openapi: a schema nested thousands of levels deep costs seconds and gigabytes before the depth bound applies #905 caps it at several seconds. openapi: judging a deep schema level by level renders it once a level, costing the cube of its depth #1424 tracks rendering a mapping without re-encoding its members, which fixes both.
• bind.Table.Base walks from its document's root on every call, so a reader asking it at each level of a deep schema pays the square of the depth: a spine of 250 levels, each comparing a $ref under a base, costs 2,996 M instructions against 2,718 M on main. The lowering's bounds end such a spine there, and real documents ask at few levels. openapi: each base lookup walks from the document root, quadratic over a deep spine #1431 tracks answering a base from the nearest $id above.
• The union-beside-structure rule's status and the two places in branchshape.go that spend the budget and render the text cite openapi: a union beside a long composition degrades though its branches restate only the body's own keywords #1423 and openapi: judging a deep schema level by level renders it once a level, costing the cube of its depth #1424, and Table.Base's comment cites openapi: each base lookup walks from the document root, quadratic over a deep spine #1431.

Cost at 5aea659

Against main at da6c9f1, instructions retired, /usr/bin/time -l, builds alternating, medians with ranges:

• The golden spec, GOMAXPROCS=1, five runs a side: 110.1 B (107.5–119.8) on main, 109.6 B (106.1–111.9) on the branch, inside each other's range; peak memory 4,191 MB and 4,207 MB. GitHub's two specs and Kubernetes', the largest reference specs, GOGC=off too, three runs a side: within 0.03%, each range overlapping, peak memory equal.
• One generated input per path the change adds, at 500, 1,000 and 2,000 copies: every one grows linearly on both builds, the marginal ratio between 1.99 and 2.03. A $ref or required-only branch, and an inline allOf branch under no $id, cost nothing measurable; a restated type 9 K instructions a union; an own, composed, items or $ref-landing restatement 40 to 70 K; a property nested three levels about 210 K, +4.0 to 4.2%; a merge or refinement comparison writing a $ref 20 to 39 K; and an $id branch writing one costs 42 to 50 K less than on main, since it now folds nothing. One union of 2,000 branches, or one branch restating 2,000 properties, costs 30 to 35 K a branch or property.
• Allocations, counted around one compile: the golden spec 42.02 M on both builds (+0.01%), with 0.03% fewer bytes; an allOf position two more, an $id wrapper map and a slice; a union restating its body's property about 83 more, and one nested three levels about 220.
• Without the $id shortcut, an input of 2,000 inline allOf positions costs 1.6% more, so the shortcut stays, though no test pins it.

Closes #1393
Closes #1394
Closes #1395
Closes #1407
Closes #1408

Test plan

• Each issue's spec, compiled with morphic compile --verify on main and on the branch: Pair, Tuple and Dyn (openapi: a union branch writing only items, prefixItems or $dynamicRef is kept as validation logic #1393) move from validation_only to degraded_lowering; Bounded, Annotated and Described (openapi: a restated union branch writing a keyword that declares no shape degrades the union #1394), Render (openapi: a branch restating a property the body composes through allOf degrades the union #1395), and Joint and Nested (openapi: a branch property restating several declarations, or a nested property, degrades the union #1407) move to validation_only, as their bare forms already lowered; openapi: inline allOf branches under different $id bases fold a keyword they spell alike #1408's S now keeps its nested branch whole under openapi:allOf/0/allOf/0 and folds only the outer not, as T does.
• A bare and a restating branch narrowing beside the body's type, and a bare and a restating branch over a composed body, at a component, a property, an items, a parameter, a request body and a response body. On main each restating spelling degrades at all six and each bare one is validation_only; on the branch all four are validation_only at all six, and a branch writing items degrades at all six.
• TestOneOf_CoDeclaredBranchKeywordIsJudgedAloneAsBesideTheType compiles every keyword of the 2020-12 vocabularies, and OpenAPI's own, in a branch alone and beside the body's type, and requires one verdict for both and the expected one for the keyword.
• A generated grid of 2,988 specs: 49 keyword spellings, in a branch alone and beside the body's type, at a component, a property, an items, a parameter, a request body and a response body, over a body with its own properties, one composing them through allOf and one doing both, in 3.0.3 and 3.1.0. On the branch the two spellings agree in all 1,494 pairs, and every verdict is the keyword's class. Against main at da6c9f1, 960 move to validation_only, each for a keyword declaring no shape, and 306 to degraded_lowering, each for a bare branch writing one of the keywords the summary names. morphic-harness passes all 2,952 that are valid (3.0.3 has no boolean schema), the order-invariance and idempotence oracles included.
• The rows of fix(compilers/openapi): treat a restated union branch as bare #1278's tables are all kept with their inputs. Those whose verdict this change flips (a constraint, not or nested property in a restated property, a nullability difference, a wider type, a true property, a branch typed only null, a type the body's $ref already holds, a $ref whose siblings admit nothing, a branch's allOf repeating the body's property, and the rows openapi: a restated union branch writing a keyword that declares no shape degrades the union #1394 and openapi: a branch restating a property the body composes through allOf degrades the union #1395 named) move to TestOneOf_CoDeclaredRestatingBranchDeclaresNoShape, renamed where the old name said the branch says more.
• Planted defects, each reddening at least one test: dropping the budget check, reading only the body's own properties, leaving the allOf out of what the body admits, dropping the null-only type case, the boolean, written-alike and admits-nothing shortcuts, the null-keyword and extension cases, either reading of unevaluatedProperties, moving items, prefixItems, format, readOnly or default into the shapeless list, removing the value constraints or the documentation keywords from it, dropping the nested allOf or the $ref step from declare, gathering no element declarations, comparing with the first declaration only, leaving nested properties unread or items to holds, landing any $ref, giving a nested claim no declarations, reading a property the body never declares as restated, restoring sameText's document-only check, in voices.go treating every branch as read at the position, letting a rebased branch join the agreement, or reporting it as disagreeing, and in the merge ignoring the base for an Unmodeled entry or for two hoisted copies, or answering Alike true for every pair, and reading the body, its declarations or what a property nests eagerly, or never looking up a base under an $id the branch or a wrapper writes; and reading a place again for each branch restating it, at the top or nested, gathering a property from the first of the body's schemas only, keeping no schema in the set, matching a property written alike against the first declaration only, which the two PropertyWrittenAs…OfTwoDeclarations rows now hold, or charging a value set nothing; and reading allOf as shape again, judging a conjunct against the body whole, against nothing, or not at all, letting a branch's own $ref conjunct land, landing only on the first schema the declarations compose or on none, judging a boolean conjunct as shape, leaving a $ref unjudged, giving the branch itself no declarations, or dropping the boolean shortcut before a property's declarations are read, which the BooleanPropertiesReadNoDeclarations row now holds. All 55 were planted again on a4dda68, each reddening at least one test. For 732f682, 28d9ca3 and 206ec17, 27 more were planted on the final code: dropping the $ref gate at each site or answering it for every text, dropping sameText's document check, reading a component pair as before, comparing the declarations' sites rather than the nodes', WritesReference miscounting a name, a nesting, an error or $dynamicRef, answering sameText, readsAtPosition or Alike true for every pair or for an unknown base, Alike reading a site in another document as the source's, Table.Base answering an unknown base as known, and keeping one element declaration of two. 26 redden a test. The one that does not reads only the first node's Unmodeled for a $ref, which is equivalent wherever two nodes are held alike, since both keep the same entries.
• The conformance cases union-restated-branches (adding RenderBounded, RenderDescribed, RenderComposed, RenderSizes, RenderJoint, RenderLinks and RenderConjoined) and allof-inline-residue (adding Rebased) only gain types: no existing type's IR changes in either golden. The binding canary lists Rebased's two $refs under id-base, the reason for every reference the compiler reads against an $id and the parser library refuses.
• Golden spec (cloudflare/api-schemas openapi.json at 4c8edd11), main at e85202b against the branch at a4dda68: jq -S 'del(.diagnostics, .sources)' differs in five reason values and nothing else. Four parameter items written {type: string, anyOf: [{type: string, pattern: …}, …]} under /accounts/{account_id}/gateway/{lists,locations,proxy_endpoints,rules} move from degraded_lowering to validation_only, with their diagnostic: a pattern beside a repeated type narrows, as the bare pattern already did. alexandria_create_application_request's anyOf, requiring at least one of hostnames and ip_subnets, moves the same way: each branch writes its property as an allOf of the declaration's own $ref and bounds on it and its element. Each of the 27 inline-branch degradations left writes shape: a property the body does not declare, a catch-all, an allOf composing a $ref, a nested union, an enum narrowing a property, a type the body contradicts, or items beside an object body. The spec writes no $id.
• Each of the five sites probed on main and the branch with two declarations or branches written alike under two $id bases, once with the $ref spelled absolutely, and once writing no $ref: on main the alike spelling loses a constraint the absolute one keeps; on the branch both lower alike, nothing lost, and text writing no $ref lowers as on main. At a4dda68 the last spelling did not: {$id: …, minLength: 1} kept its bound out of Constraints, a branch whose $ref sat in its properties lost its description, a refinement whose target sat under another $id kept a branch restating it, and two declarations writing {type: string, not: {const: q}}, or an equal enum or list, were reported as conflicting and the second kept verbatim. 732f682 fixes those, with a test at each site, and 28d9ca3 covers the component site, in one document and across two.
• The golden spec, the 1,840 documents above and the 3.x specs under testdata/ (2,072 in all, 8 writing an $id) compile to the same IR, diagnostics and exit code on a4dda68 and 206ec17.
• A rule program written from docs/compilers/openapi.md#union-beside-structure alone, without the code, judged 4,500 random unions beside bodies of own, composed and typeless properties, with restating, narrowing and shape-declaring branches, allOf wrappers and $refs: it agrees with the branch on every one. Run against main it disagrees on 168 of 1,500, and against the branch with readOnly planted as shapeless on 30, so the comparison sees a wrong rule.
• Two-order diffs of the merge's component, copy and entry cases give one verdict in both conjunct orders, the first declaration's type kept as the rule says. Merge keys and aliases in a branch or a body, an overlay adding an $id or writing the union, a body composing another document's schema and an $id branch in that document, and 3.0.3 and 3.2.0, each lower as the rule says; 3.0.3's resolver honours $id as the base check does.
• An absolute $ref under another $id was read as base-dependent: {$id: …, description: d, not: {$ref: 'https://ex.test/b/n.json'}} folded nothing and lost its description, and two declarations writing it alike were reported as conflicting, where main lowered each as written. f5db471 counts only a relative reference, with a row at each site; the corpus and the golden spec compile alike before and after it.
• The rule program, run over the golden spec's own unions, gives the compiler's verdict at all 120 beside structure, 25 validation_only and 95 declaring shape.
• Malformed and hostile inputs around the change, empty and non-schema branches, mistyped properties, required, items and allOf, odd $ids, a $ref that is no string, a property named $ref, self-referential and cyclic compositions and escaped names, exit as on main with no panic; FuzzCompile and FuzzLowerSchema, seeded with these and the grid, ran 2.8 M inputs clean. Relative, fragment, dot-segment and case spellings of the position's own $id fold as the position does. A body whose allOf names itself degrades where main kept its union as validation logic, the cut-short reading of openapi: a union beside a long composition degrades though its branches restate only the body's own keywords #1423, which records it.
• Each issue's spec gives its Expected result on the final head: openapi: a union branch writing only items, prefixItems or $dynamicRef is kept as validation logic #1393's three degrade, openapi: a restated union branch writing a keyword that declares no shape degrades the union #1394's, openapi: a branch restating a property the body composes through allOf degrades the union #1395's and openapi: a branch property restating several declarations, or a nested property, degrades the union #1407's restating spellings are validation_only as their bare forms are, and openapi: inline allOf branches under different $id bases fold a keyword they spell alike #1408's S lowers as T does. Every example the union-beside-structure rule writes compiles to the verdict it states, and a shapeless union is validation_only at a component, a header, an additionalProperties value, a prefixItems element, a parameter's content, a callback and a webhook as well as the five positions its test compiles.
• CI's gate passed on a4dda68, on 206ec17, on 5aea659, on f5db471 and on 7ffeebb, both jobs, coverage at 100% included. On each of 732f682, 28d9ca3 and 206ec17 the annotation, bind, merge, schema, e2e and archtest packages pass on their own. main at 50412aa is merged in; the gate on the final head, 9ded526, runs in CI.

[OmarAlJarrah]

This change also fixes a spelling dependence the restated-branch check has on main, and no test here pins it.

On main, restatesProperty compares a branch's property with the body's declaration through yml.EqualNodes. That function compares keys in the order written and scalars as spelled, and it reads << as an ordinary key. So a branch restating the body's property degrades the union whenever either side is spelled differently from the other, though the parser reads the two alike. With this spec, filling in the property a in the body and in the branch:

openapi: 3.1.0
info: {title: t, version: v}
paths: {}
components:
  schemas:
    S:
      type: object
      properties:
        a: <body>
        b: {type: integer}
      oneOf:
        - properties:
            a: <branch>
          required: [a]
        - required: [b]

body a	branch a	main (e85202b)	this PR (cf9dcca)
{type: string, description: d}	{type: string, description: d}	validation_only	validation_only
{<<: {type: string, description: d}}	{type: string, description: d}	degraded_lowering	validation_only
{type: string, description: d}	{<<: {type: string, description: d}}	degraded_lowering	validation_only
{type: string, description: d}	{description: d, type: string}	degraded_lowering	validation_only
{type: integer, maximum: 10}	{type: integer, maximum: 10.0}	degraded_lowering	validation_only

Each cell is the reason on the one Unmodeled entry morphic compile gives S's oneOf. Where the whole nodes differ, main falls back to comparing $ref, type, format and nullable one at a time through nodeview, so a merge or a reordering that writes only those keywords lowers validation_only there too ({type: string, format: date} against {format: date, type: string} does). A description or maximum beside them is what reaches the EqualNodes comparison.

MergedKeyword merges into a restated property, but its branch writes only type, which that fallback already reads alike, and MergedBranchNarrowing merges a keyword into the branch itself. So no test here holds the four rows that move. A case for each beside them in TestOneOf_CoDeclaredRestatingBranchDeclaresNoShape would keep a later comparison from bringing the dependence back.