Reconsiliation of default values as state gets more specific

[andrewzhurov]

But now suppose we change one of the default values:

a: int | *1
b: int | *2
a: b
b: a
What should the answer be?
source

As rightfully noted, resolving defaults in such a state is not possible due to contradiction in rules.
So the strategy is to abstain from resolution.
Can it be that we can reconsider resolution of default values when state becomes more specified (e.g., at run-time, when actual values come)?
For the example above it wouldn't make any difference, however for some other cases it may.
E.g.,

a: int
b: int & >a | *1 | *10

In such a state default value for b is not possible to resolve.
However, if at run-time our state becomes more specific.
E.g., as such

a: int & 5
b: int & >a | *1 | *10

Default value for b becomes clearly resolvable as 10.

[mpvl]

The a in b only applies to one of the disjuncts, so it would still not be resolvable.

Perhaps you meant to write:

a: int & 5
b: >a & (int | *1 | *10)

?

In this case it is already working as you expect, though, and it will resolve to:

a: 5
b: 10