Agoric SES, 27 Apr 2022

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: SES Meeting: Property Override Allowance

Description

Mathieu presents an idea of how to overcome the property override mistake.

A

Now welcome to the assess meeting, it is april, 27th, 2022 and our agenda and attendance is light today, but we do have enough people to talk about.

A

Is frozen, making that faster and maybe um getting the uh avoiding the property override hazard in the language and matthew has the floor.

B

All right, um so, uh while I I had an idea, let me actually share my screen.

B

So I had a potential idea on how um to allow. So let me let me first by start by explaining or recapping what my understanding of the override mistake is.

B

When you do a set, so fu dot tostring equals something and something on the prototype chain of the objects.

B

Has that property to string as non-writable?

B

Then you cannot do an assignment with equal. You have to do a defined property. um This is very cumbersome. A lot of code out in the in the wild does equal for convenience.

B

Nobody wants to call defend property everywhere, and this is a problem for frozen intrinsics, because um or or hardening things, because now a new prototype chain has those completely frozen and dust non-writable uh properties that can no longer be assigned in uh through equal.

B

Did I did I capture that right? uh Anyone was that clear enough for what the override mistake is.

C

I think that would correct yeah.

B

Okay, so um the issue is.

B

The issue with addressing the override mistake is that uh some code actually relies on this behavior. It's been like that for years now, so anything that uh existing code does uh shouldn't be able to trigger. It should keep continue, triggering this behavior.

B

um However, that doesn't prevent us from introducing a new api that would put the object in a certain mode.

B

Put the prototype object in a certain mode where uh now, when you do an assignment through an object that has that uh pro that has that frozen object on the prototype does not trigger the uh the the prevention of sets and can and ends up doing a define on the target itself.

B

um The idea that I had was to introduce a sort of uh a private field on objects to cache the integrity level uh of the uh of an object. So the idea is that you would freeze object.prototype, for example, asking for the integrity level to be cached in a in a private slots on uh on the object. So I I in something, for example, like I named it cache integrity that allows you to do two things.

B

um First, that allows you to do the when you do a nest frozen check instead of checking um uh calling is uh prevent. What is it again uh is extensible and uh check all that all the old keys um descriptors are all non-configurable. So basically, it's frozen currently walks the uh prototype chain and the object verified that nothing is extensible and nothing is um it doesn't.

C

Walk the prototype chain, it just it looks at the right.

B

It doesn't, it works all the proper properties heard in those frozen. It's frozen checks. uh The object checks that the prototype um check, that it's not extensible and checks that all property descriptors are non-configurable and non-writable.

C

So I have a question about the proposal already, um which is uh just taking that part of your proposal by itself. uh Isn't that already an optimization that uh engines can do and probably.

B

Regular objects, yes, as I said like this, would actually only be observable for proxy objects.

B

This I I actually write it here. This is only relevant in the case of exotics, like proxies, uh because an implementation can already do this, uh because it would be non-observable for regular objects. The regular objects would not be able to observe this.

C

C

B

um Now the second step is now that we have a flag on the object. That is the result of a new path uh in the execution. um We can check that flag, which is the cash integrity level uh during the ordinary set with own descriptor uh and maybe I'll go uh uh to expect, but in the own set ordinary set within descriptor it uh recurses into the sets of the uh prototype until it reaches uh um the prototype object where that property is defined.

B

At that point, it checks if it's a data uh property or if it's a setter or getter and or problem, has always been with the data property.

B

So, instead of doing this simple check here is data descriptor and indescribable false um there would be. A preliminary check is the cash integrity? um Is there a cash integrity uh that is uh not frozen, then? Do the writable check if it's not uh if it is set as frozen, we basically fall through and following through means uh defining uh on the on the target objects.

C

Another question um so uh in order for since this creates two observable differences, uh the proxy one that I and and this one, the implementations that do uh the optimization for regular objects currently could not use this flag as the state further optimization. This flag would have to be distinct from any internal optimization they're, currently already doing, because the current optimization does not have this observability.

B

um Why can't the optimization, based on uh this flag for is frozen, optimization right.

C

Yeah, the the any existing is frozen. Optimization that implementations are doing that might make use of some hidden state variable that state that hidden state variable would have to be distinct from.

B

Array, the one plus the other uh not still correct the the new, my cash integrity slots would imply uh cashing, but internal cashing would not imply uh cash integrity.

C

Okay, so when you say so, caching is a little bit of a it's a misnomer, yeah.

B

C

Right, because, if you just if the implementation is just you know doing a internal caching of the result of an is frozen check, uh it would not be using this cache.

B

Yes, we we can, by shed the name.

C

Okay, just trying to get clarity, yeah.

B

We can backshade the name, but the idea it's like it's cash integrity level. Plus uh I opt-in uh for um fixing the uh the return, the property they have. The override mistake to many overrides.

C

So so what is the? What is the new? The new way you say, freeze in the code that triggers all this.

B

uh You say freeze and then you pass a uh second argument with an options bag which has something to be um like shed here. I put it cache integrity, but we can like shift exactly.

C

Okay, so so so it's okay, and uh if you do this on an object that is already frozen.

B

It will do the existing uh its frozen checks and then remember it.

C

Okay- uh and I.

B

Mean I actually doesn't do the use frozen check. It goes through the freezing mechanism again, because freezing an object again is perfectly fine.

C

uh That's a good point um and.

B

And would be observable by a proxy.

C

Okay, yeah right right.

B

And the thing is now once you've done, that uh the proxy will not be able to observe it being frozen again or checked for freezing.

C

Okay, so uh so two two further questions one is: do you imagine that harden would be doing this? Their harden is a deep application of this variety of fruits.

C

Okay, the other thing is that it's introducing new, observable mutable state on objects that, in the current version of the spec, would have been considered to not be mutable.

C

So um so, given that harden is, is is doing this variety recursively. Anything that's freezing by hardening would actually remain safe.

B

C

Anything, it's really.

D

B

It's it's! It's not really observable, because a proxy wouldn't so the only case where it matters is a proxy and the proxy traps wouldn't trigger anymore. um So so you already need a side channel for communicating that the proxy traps were triggered to verify that the proxy traps were triggered.

C

No, that's not the one I'm concerned about, because that's one on the implementation of the object rather than clients, of the object, communicating with each other.

C

It's the change in override behavior, if um the one click alice and bob both share a a frozen data, object that that, in today's spec is immutable and therefore does not enable them to communicate.

B

Yes, they can flip one bit uh once and uh and communicate through that you're right. um Well, we.

C

I'm not saying this is a fatal problem, but it's definitely a problem.

B

I see um I did not see that um right. There is, you can pass an object and you can test it for whether it triggers.

C

B

Mistake and then you can see when that changes huh interesting.

C

I mean I'd be willing to see this go ahead, despite that, because the all the code that we're aware of that counts, on freezing frozen, plane objects being pure are using harden to do that.

B

Yeah and we could uh we could tame object.freeze to always include uh this flag.

C

Oh, I see the the the hardened javascript object that phrase. Oh that's interesting. Oh that's very interesting.

C

Oh, that's really, nice, so.

D

I'm still behind on these conversations, so that is the goal: to provide developers a way to free certain objects that will short-circuit the internals of determining where to do a set.

B

It will not short-circuit it will it will. um It will prevent this flag in case that object has been frozen, uh that certain way, so, instead of just checking, is that description. I found uh writable uh and just the board right away uh it will. um It will only consider that, if that object has been frozen, if that prototype object has been frozen in that way,.

C

Oh, is there any reflective query? Behavior right I mean is extensible uh is a reflective operation for querying whether the object is extensible right? It.

B

Would simply return the cash value.

C

But what would return the cash value.

B

Reflect is extensible, I said the reflective sensible just triggers the is extensible. uh So sorry, yes, it would. The the ch is extensible check would be uh test integrity level. So this is the one that would be changed um test. Integrity level is the one that is triggered. So um is.

C

That a user level operation.

B

C

Is that it's test integrity level, I'm assuming it's an internal procedure, yeah.

B

Testing degradation: it's an abstract operation that is uh used by uh it's frozen is sealed, and um I am so much surprised that it is not used by reflects that is.

B

Is it sensible.

B

Interesting yeah that one might need to be.

C

But but in terms of what's exposed in the roof as a reflective operation, the api, would you have a reflect.test integrity level? Would you have a reflect dot.

B

No, I I don't think I don't think this should be testable.

C

uh How do you maintain transparencies to your proxies.

B

C

If you inherit from a proxy emulating a normally frozen object,.

B

You don't when you, when you freeze, when you freeze your proxy slot, gets added to the proxy and the proxy will not never get probed anymore.

C

No! No, if you, um if the target of the proxy is frozen versus specially us.

C

Right if the proxy is trying to emulate a target.

B

Okay, so you're concerned that a target has been already frozen in the in that mode um and we're creating a proxy for that objects and you're, saying that the uh the proxy should behave the same way instead.

A

We have a question from alex: yes, um matthew, I'm thinking of this as a counting problem in a sense or a counting problem. um I'm thinking about it in the case where somebody uh basically does um object.

A

Dot, set property descriptor, I'm sorry reflect that define property and the set is configurable to false and is writable to false, and they do that repeatedly and then they implement the other steps that freeze does, but they don't directly call freeze, um I'm thinking that, every time that a property is set to not configurable and not writeable, you might have basically a counter that decrements one to say: hey.

A

We have this many properties that are available, I'm sorry that are configurable, slash, writable and including that count um whether the object is extensible and whether the object has the ability to have the prototype set um and once the counter reaches zero you're frozen.

A

So I'm wondering if uh cached integrity might be a simple counter structure of some kind.

B

um The problem is to make sure we set that flag on the object, through only a new mean, uh a new api or an existing api's extension. If you go in and.

B

Prevent extensions on the object and and go and manually freeze manually sets all the properties as non-writable non-uh configurable. This shouldn't trigger uh this new behavior.

B

It has to be an explicit action that existing code cannot ever undertake.

A

I guess the case I'm thinking about is sort of a really oddball case. I mean it's definitely anti-optimization what I'm thinking of so maybe it doesn't even count, never mind.

D

I'm still having a very hard time understanding this.

B

The motivation was for me to find a way to set a flag on the object saying it is okay, uh when you, if you encounter a property on uh on on an object that has this flag, uh do not trigger the uh override mistake, um and this has to come from a new api service, because the existing code cannot uh cannot trigger it. Well,.

D

I I get, I get the mechanics of it, I still don't get.

D

Where are we going to use this like sure there isn't override mistakes, but.

C

The the main place that I know I'm going to use it is to simply have harden, be the recursive application of this operation so that all objects frozen by harden are not triggering of the override mistake and, in particular that lockdown in hardening all the primordials pardons the primordials in such a way that it does not trigger the override mistake right.

B

And node frozen in string6, for example, would be able to use this mechanism as well.

B

um So I take note of the misnaming. um I also I'd like to go back for a second to mark's point about um what to do about a proxy which has such a frozen object as targets.

B

I think I have to think about this one a little bit.

C

B

C

B

Bit to say that it shouldn't be, uh it shouldn't automatically be uh transparent. um That.

B

B

You would have to you would have to freeze the proxy object explicitly uh that way for for it, for the proxy object to behave. That way.

D

Yeah but you, but but in order for you to do that, you need to understand.

D

That the target that you are creating a proxy for has that that black on it.

B

C

No, the thing is, let's say: you've got a yellow proxy for a blue object, that's normally frozen right, and then you have a let's say the so the blue object is blue, alice, the yellow proxy is alice prime and then you have a yellow bob, which is a normal object that inherits from yelp from yellow, alice, prime and um and then somebody tries to assign it to the property foo on yellow bob.

C

uh So that's going to go. Go up to the.

B

So I I tried that and it will it will trip the set strap of the proxy object.

B

So if you uh look in the recursion here, if it's, uh if their own description isn't defined, then you go get the prototype of your. uh You get your parents uh and it's not null. You trigger the set trap, so you will end up triggering the set track of your proxy objects. uh Now you will just.

C

Wrap that that sorry, there's something I'm confused about it. Can't you trigger this. Okay, I'm very confused the set you're, not setting.

C

Except in the accessor case, you're, not setting a, I thought that there was a can set trap or something I mean or a can set operation.

C

I don't understand how this works just in the normal case, so you set the you. Do the the set trap on the parent and if the parent has a writable property of that name, you're not going to set that property on the parent.

B

um So it starts at uh what was the abstract operation name uh where it starts. I think it's define or.

C

Oh, oh, it's because of the receiver argument.

B

D

But, but so what what mark is saying is this is a is the set, what triggers setting something onto ball, which is yellow, so it is start there. You try to set foo into bob, which is yellow, and then you roll from there.

D

You walk us through that process.

C

Yeah, so the set trap is, is so the the sector, the set trap on the parent would be invoked with yellow bob as the receiver.

B

um Does anybody remember where uh the so.

B

Something equals triggers sets correct. Yes, yes,.

D

B

D

We're talking about yes, so.

B

It goes, it would go straight in here, because that your proxy, your object, is actually a.

D

It's not a proxy, it's not a.

C

B

C

Bob is not a proxy bob inherits from a proxy.

B

Okay, bob is not a proxy, then it would go into the ordinary uh sets.

C

Okay, well good looks like that.

B

Ordinary set um gets, the own description, doesn't have.

D

B

Right so ordinary set within descriptor will be called with uh bob um the property name, the value that we want to set the receiver, which is which should also be bob. Both an o and receiver, will be that and own desk will be no right, so own desk is undefined.

B

um So we go into the parents, which is a prototype. Okay, we get the product, um there is a parent, the parent, the proxy object correct correct, so we call parent sets the property so who value whatever and the receiver is still bob right proxy sets.

B

It's called um and uh we assume there's a trap or there's no trap. What is the.

C

Oh, let's assume that there's a trap right, so what we.

B

C

The examine, what's examined in the in the full membrane case, where yellow alice prime, is trying to emulate alice.

B

B

The so we're saying the target here has been uh not.

C

The shadow there's there's the there's a shadow target which is up to the handler to maintain, and then the real target is alice. That is the blue alice that, at this stage, is normally frozen.

B

Right so the real targets.

B

um Okay, so we call the trap, uh we we see that the target would be. uh We get the description of the real target. It is uh actually the shadow target.

D

I'm gonna you're getting six eight you're getting into six eight you're gonna get get get to call the set with the.

B

I I understand, I'm I'm trying to uh figure out what the states of the uh things are. The real targets real alice in uh in in the target world uh is fully frozen right.

C

It's fully frozen, but it's normally frozen normal.

C

When, when we once, we've walked through the normal frozen case, then uh then the next time so with the setting of foo at the point that that we did bob dot foo equals eight al blue alice was normally frozen.

C

Once we've done that and returned, then we're going to set bob dot bar equals nine, but but before we did that somebody in the blue world um uh put blue alice into this new integrity level.

B

Okay, so um blue alice is uh frozen, so uh we will call um the trap the trap. Will, I assume, will try to do something like reflect dot sets. Yes,.

B

All right, where is reflect.

B

It triggers uh the regular sets on the target.

B

um So triggering the regular sets on the target itself uh with the receiver.

C

Okay, so so now we now, we need to be careful because the.

B

The receiver would have been uh what would be the receiver in this case, the.

C

Receiver, in this case would be would be blue. Bob prime would be a blue proxy for yellow bob.

B

A blue proxy for yellow bob, yes,.

B

Okay, um so now we end up back where we started uh well, we can go back to uh sets ordinary sets ordinary sets with one descriptor. There is a known descriptor this time. uh The receiver, as we said, is the uh blue proxy for yellow bob, and oh uh here is uh blue alice, correct.

B

Okay, uh there is an on descriptor, it's a data descriptor, um the own disk writable is false. Yep, I believe, there's a bug in this in the bug in the spec here. It should only return false if the value is different. It shouldn't it shouldn't cause an error if, uh if it's the same uh value that we're trying to write.

C

I actually don't know, can somebody test that.

D

I believe, doesn't it doesn't throw.

B

Yeah, I believe the spec doesn't represent reality. I actually noted that. um Okay, let's assume the actual behavior here, um I.

D

Yeah, but that that is if there is a descriptor, if there is no descriptor, then it will be set on to the 1c. You know.

B

It is, it is already.

C

Frozen yeah we're only. We only care about the case where blue alice has a a a, not able foo foo property.

B

um So nothing uh here it should. uh It should see that the description uh matches if the stake was correct um and just return true, correct. Okay, so.

C

So, let's, in order to post in order to avoid this question, let's just assume that the value being set is different than the existing value. Okay,.

B

The value being said is difference so.

B

Well, it will throw.

C

What we'll throw it will.

B

C

It it will return false yeah, but it will it's returning false in the middle of the algorithm. So there's no throw yet.

B

Yes, correct: it's, it will return false, um so reflect will return false.

C

And that'll go back and that whole the logic goes back out through the membrane and.

B

C

Yellow set that ends up returning that it's the yellow set ordinary set on bob that ends up thrown.

B

Correct? um Which.

B

uh I don't know where that happens: uh yeah.

C

It would be good to find out.

D

It's on the on that on the dnr set yeah.

B

It's not actually uh set it's. Whoever calls uh sets um uh and that's the place where we actually should.

A

Have started that.

C

B

um On the grammar side, yeah.

D

B

It's on the grammar side and I don't know how to corrupt the grammar side so.

C

Yeah, so we I think we can just assume it but you're correct that does not throw set returns false and the reason we did that by like I can give you the historical perspective on that. The reason we did, that is a sloppy assignment, does not throw, but the set trap should not be able to sense whether the assignment was sloppy or strict.

D

Can you say.

C

That again, the a sloppy assignment that fails does not throw, but the handler trap should not be able to sense whether the assignment was sloppy or strict. I see and therefore the trap always just indicates failure by returning false and it's up to the syntactic construct, whether or not to turn that into a throw, depending on whether the its strict syntax or sloppy syntax.

C

That was another place where we had to refactor the spec to avoid dynamic, scoping.

B

So let's get back- uh and I think this will work from what I already ran into my head um so now or uh blue ls is frozen into that state. uh That happened somewhere on the uh blue side. So yeah proxy is not aware of this correct. um We get through the steps. uh We still don't have a known description for um for bob, um so we get the prototype, which uh is gonna, be the proxy for our list.

B

um We call uh sets, which is gonna, be the proxies set trap again as before the proxy set trap. We'll call reflect.sets on blue alice um reflect.sets on blue alex will end up calling ordinary sets within descriptor, with o being blue alice bar value, whatever receiver blue proxy for yellow bob, correct and unknown description.

D

B

When we get to the is data descriptor, we will get into the new check. The new check alice is.

B

Has this flag set on the blue alice, so it will trigger a um it, will fall through and do a uh the steps here which are um to define own property on the receiver.

C

B

So now we're going to try to do define property on the blue proxy for yellow bob okay, so the proxy will be able to observe this, but should behave normally.

C

Yes, okay, that's very good!

C

So there's only one remaining problem that I can see in this scenario, but I'm very pleased that where we are uh the remaining problem is that uh you want to- and I presume that you would like to add to the object in variants that wants a no. I suppose you don't need to. No you don't it's not a it's, not a stability commitment, it's just a behavior which means that the proxy could act like it's specially frozen at one point and then go back to acting like it's normally frozen. That's weird!

C

Oh no, then you've got a communications channel. That's not good!.

C

um No, I think I think I think you need to. I think there needs to be a stability commitment here.

D

Can you elaborate more on these.

C

Yeah, so so right now we're doing all the bookkeeping um uh to enforce that the handler cannot violate the stability commitments by saying that the that, in order to act in such a way as to be consistent with the stability commitment, you have to make the shadow target stable in that way.

C

And but if this is not a stability commitment, it's just a handler behavior.

B

That's the thing, the shadow, the shadow target.

C

So would the proxy ever have enough information to to say that the shadow target must be specially frozen.

B

So the shadow target has never been especially frozen at this point.

C

That's correct.

B

And if we trigger freeze on um if we trigger freeze uh special on the proxy object itself, we flag the proxy object itself and then this the proxy will not be able to. uh We will not go through this mechanism anymore.

C

So that that's not the case, I'm concerned about the case, I'm concerned about, is, um if alice is now specially frozen.

B

C

um The proc and but there's a shadow target alice, um which is uh the shadow targets, are yellow. uh The shadow target from blue object is itself yellow, so there's a shadow target, yellow alice, alice, double prime or alice shadow target. Let's just say, aloe shadow shadow out, so shadow alice is um not specially frozen uh in order to represent you know.

C

The proxy did know enough that when it saw that that real alice was frozen, um that the proxy would normally freeze shadow alice, but when the real alice is specially frozen, the proxy never knows enough to specially freeze alice, and maybe that doesn't matter.

B

I don't think it matters we. I guess we could imagine passing the special freeze request in uh the prevent extensions trap.

B

um So I don't remember uh what the like, I don't think, that's necessary, but.

C

So the prevent extensions isn't the interesting point here. The interesting point here is the is extensible the right.

C

Now, the proxy, um the proxy is able to find out what the stability properties are of the real alice, not by causing the real alice to be stable, but but just asking how is real, alice, stable and then making shadow alice stable in the same way that real alice is stable, but when real analyst is specially frozen, that's an additional degree of stability that the proxy cannot ask about and because the proxy cannot ask about it, never knows that it should make shadow alice specially frozen and like I like, and- and you know and and it sounds like- maybe that's- okay, because we're not making this additional level of stability into an object invariant that needs to be enforced and therefore the proxy we're allowing it to act at one moment in time like an object, that's specially frozen and then act at a later moment in time like an object.

C

That's not specially formed.

B

And it always could it always could decide to do whatever it wanted. On uh on the sets um like the only requirement that was on existing on the sets was that if the set would fail it has to fail, it doesn't say that if the set was to succeed, it had to succeed.

C

Yeah, so let's just make sure this, the um in the part of the spec, where the proxy checks the handler response against the shadow target to enforce invariants. If the set trap returns false.

C

I presume that there's no double checking of that that the that the set trap is just always allowed to return false and there's no there's no consistency check against the target. In that case,.

B

C

Against the shadow target.

B

Correct, I believe there is no invariance there.

C

Okay, in that case, I'm satisfied we're not introducing a problem here.

B

um Where are the insurance.

C

The proxy set trap, behavior, invokes the handler and then does some post checking. That's property.

B

Invariant the result of set is a boolean value, cannot change the value of property to different from the value of the corresponding target object. Property of the corresponding period is non-available. Okay, so, basically can't.

C

Yeah, so it's always allowed to return false, so, in other words the it is the case even today that a proxy for a frozen object, the proxy could emulate.

B

The proxy can emulate this behavior already. Yes,.

D

Couple of notes on this, so this will break us. The reason why we break us is just because it's a new feature: um we we do not in some.

B

D

We do not call this set across the membrane to complete the operation on the other side, which in this case was from from when you walk from bob to his prototype, and then you do a set on that prototype a reflector set. We don't do that. We actually emulate the algo that you were showing they. They are able to set the ordinary, um the.

D

I don't remember the name of it, but we emulate that album, because we we have certain restrictions in terms of what can be observed by the other side, specifically what we call the the prevent mutations on the other side. So basically saying bob has no ability to ever change anything on on the blue side.

D

um He can only change its reflection of what the blue side looks like and uh and because we wanted to make sure that the operation happens on on the yellow.

B

D

In this case, because that's what triggers it said uh never seen by the blue side, we we emulate this algorithm.

C

That's a non-transparency right. You've introduced the distortion.

D

Right right, so the distortion plays a role there, but I think, even if you don't have distortions you're, just saying whatever uh bob is trying to do, only bob can see and he'd never get to reflect to alice. So alice will never see what bob is trying to do.

C

But that's definitely not a trend. That's definitely a distortion that that breaks down is a distortion mechanism.

D

To avoid uh bob to be able to do any kind of poisoning or any kind of mutation that can affect alice integrity, but um regardless of that, the this protection mechanics that we use in some scenarios and we don't use it in knowledge and others.

D

We use it in some scenarios, um has these um algo being implemented manually by our membrane, so it basically goes all the way up to the protochain and finding if there is a descriptor or not and then determine what, where to what to do with the operation that you're trying to do, and so on, on the yellow side, never cross into the blue side only to check for things on the blue side. So that would be a problem for us.

D

So I have to think more about it. What the implications of that will be, but.

B

I think, in your case, if someone calls, the problem is really if someone calls uh freeze uh on that prototype objects uh with this special mode and.

D

Well, not even that I mean assuming that no one used this new feature, um but then alice.

D

B

If, if the real alice has been frozen in that mode, it wouldn't matter in the first place, because you wouldn't be trying to touch alice, you would only be modifying uh your version.

B

In the yellow realm.

D

The the general realm does preserve the uh ali's uh or reflects alex at his uh behavior. So if alice has anything that is frozen, whether that's a regular frozen or the new one, it needs to reflect it.

B

I I guess my question is today with your distortion, what happens.

B

B

I assume you're checking if alice is frozen or if, if that property is uh writable or not,.

D

I think it's it's just a matter of trying to understand. If you have that new step into 2a, that's what you're proposing. Yes, you add a new one to a um what will be the implications of running code that does not have that check.

B

um It will be like today it will trigger uh the override mistake and return false, ultimately and throw.

D

Right, but if, if someone used the intrinsic operation on the new, the new operation on an object, whether that's a blue or a yellow object, and then we hit that algo again, what happened? That's where I'm not sure. Well, that's the thing! If your.

B

Blue object is a is an ordinary object, um so that doesn't matter the case really matters. If your blue object is a proxy.

B

In which case these steps are not triggered they, it would be your custom implementation that would be triggered and your custom implementation would be unaware of this flag.

B

D

I have to think more about that.

B

D

um And then the reason, by the way, the reason why we do that is like uh when we have code running in yellow that is attempting to modify anything in the object graph of blue, whether that's uh modifying a proto, um a prototype of an object or modifying a anything on that object, grab that that only that that operation will succeed, but it will never modify blue. It will only modify yellow so all the prototypes that are shared, whether that's dom apis or language apis or whatever it doesn't matter.

D

You will not be able to affect the blue side by by any means.

B

B

So really, in this case, you would end up with a something previously that froze sorry.

C

No, no, it was just. um I was unmuted while there was sound here. Sorry.

B

Well, I guess anyway we're out of time. I I I guess we need to just think about uh what it would mean in the case of distortions uh um like this.

A

All right, yeah, that's a meeting. Thank you very much for this conversation, matthew um and uh and see some of you at the endo meeting have a good day.