02:37
<sideshowbarker>
annevk: FYI my “Show HTTP status code in CORS messages” patch landed in the WebKit sources https://trac.webkit.org/changeset/285145/webkit
02:41
<sideshowbarker>
so that’ll soon be in a Safari TP release — and then I guess in Safari 15.x in March or April
06:35
<DerekNonGeneric>
congrats! was somewhat expecting to see these error messages localized but no browser vendor does error messages correctly, so not surprised if that's the case. might need to make an account over now that you mention it
06:36
<sideshowbarker>
they are localized in some browsers at least
06:39
<DerekNonGeneric>
there are ways to localize error messages, but that doesn't seem to have happened in that changelog -- maybe they go back over it later? doubt it, but have seen great localization for error messages maybe twice
06:42
<DerekNonGeneric>
the two software projects were Git and TypeScript believe it or not
10:37
<smaug>
why are some tentative openUI tests being mixed with html tests?
10:55
<annevk>
smaug: the intention might be to upstream the feature to HTML?
10:56
<smaug>
I couldn't find any spec-like text for selectmenu
10:56
<smaug>
perhaps I looked at from wrong places
10:56
<annevk>
smaug: are they marked as tentative at least?
10:56
<smaug>
sure
10:58
<smaug>
seeing "the-selectmenu-element" here https://github.com/web-platform-tests/wpt/tree/ca3635d2be104d885837442cc5e7ada030d66b22/html/semantics/forms is a bit surprising.
12:03
<Ms2ger 💉💉>
They're all marked .tentative
12:03
<Ms2ger 💉💉>
Maybe they didn't know you could do that to a complete directory too
13:00
<Noam Rosenthal>

annevk, Jake Archibald: I was thinking re. the controller thingy (https://github.com/whatwg/fetch/pull/1329),

maybe instead of returning a struct that fetch exported functions for, to return a struct with algorithm fields, that are set before returning the controller, kind of like how the different algorithms are kept in fetch params).

This way both fetch-params and the state are truly private, and the only thing returned/exported is terminate/abort/finalize or whatever method is operable after the fetch has started. WDYT?

13:03
<Jake Archibald>
Noam Rosenthal: I think algorithm fields are for cases where the algorithm is set by some other spec, but annevk will know more
13:05
<annevk>
Yeah, generally concepts are "plain" structs and algorithms get everything they need passed as parameters
13:05
<Noam Rosenthal>
... Trying to prevent a situation where by putting the state information inside controller we make it "public", while what we want to publicize is only some methods to manipulate the fetch.
13:05
<Jake Archibald>
Can't the controller just have the public data?
13:05
<annevk>
I think exposing the state of the fetch is reasonable
13:06
<Jake Archibald>
fetch params can have the private data
13:06
<annevk>
Assuming that we're talking about "ongoing" vs terminated
13:06
<Noam Rosenthal>
so it exposes state, and later cacheState and timing info
13:06
<Noam Rosenthal>
... which are needed when finalizing
13:06
<annevk>
Yeah, but we'd only set those on the controller when they are meant to become public (so we might duplicate them there, essentially)
13:07
<Noam Rosenthal>
I guess cacheState can only be set before fetch finale, right?
13:07
<Noam Rosenthal>
which would make this sort of work
13:07
<annevk>
As in, we'd write to those fields on "fetch params", and then at some point copy the whole lot over to the controller
13:08
<Noam Rosenthal>
yea, fetch finale would probably be where this happens, as that's where it's currently copied to the response
13:09
<annevk>
So we'll end up with some duplication, but it also clarifies things in a way
13:09
<Noam Rosenthal>
OK this makes more sense to me. Thanks!
13:09
<annevk>
\o/
13:09
<Noam Rosenthal>
(Done with bikesheeding about this corner, going back to work)
13:11
<annevk>
I wish I had more painted bikesheds to show for it, but I guess that's why it's called that way
13:36
<Noam Rosenthal>
Jake Archibald, annevk : followed your suggestion (https://github.com/whatwg/fetch/pull/1329), hope it's on the right track :)
13:57
<annevk>
Noam Rosenthal: I haven't had a chance yet, but one thing we need to figure out is the interaction of this with service workers
13:57
<annevk>
Noam Rosenthal: I just realized that while writing https://github.com/whatwg/fetch/pull/1343#issuecomment-957631425
13:58
<annevk>
Noam Rosenthal: service workers observe the termination for some things so they might need access to the controller or the state or some such
13:58
<annevk>
Jake Archibald: did you consider that already perhaps?
14:12
<Jake Archibald>
annevk: service worker is hand-waving this in a couple of places, so yeah, it's be great to switch this to an "abort when" based on some state
14:31
<Noam Rosenthal>
Noam Rosenthal: I haven't had a chance yet, but one thing we need to figure out is the interaction of this with service workers
I will get more acquainted with this
15:20
<annevk>
Noam Rosenthal: cool! I think we need to expose the controller, essentially; I guess we only need to read state from it
15:21
<annevk>
Noam Rosenthal: I'm not sure if that means we should stuff the controller on the request or just add an argument to "handle fetch", I guess the latter would be better
15:21
<annevk>
Anyway, this is a bit off the cuff
15:48
<Luca Casonato>

Domenic: In the streams spec, in ReadableStreamPipeTo, the spec says:

If source.[[controller]] implements ReadableByteStreamController, let reader be either ! AcquireReadableStreamBYOBReader(source) or ! AcquireReadableStreamDefaultReader(source), at the user agent’s discretion.

(since the beginning of time: https://github.com/whatwg/streams/pull/512). What does this mean? In what cases should the user agent use which reader type? I can't find any docs in surrounding code snippets.

16:08
<Domenic>
Luca Casonato: this is basically saying that the choice of reader is unobservable, so if you want to use a byte reader because you think you can do smart byte thingies with it while piping, go ahead
16:08
<Luca Casonato>
ah, ok
16:09
<Luca Casonato>
thx
16:16
<annevk>
sefeng: hey welcome! https://github.com/whatwg/html/pull/7285 could use your review I think. And potentially that of emilio.
16:16
<sefeng>
roger, will do
16:50
<annevk>
Domenic: if x in y is false, will y[x] always be undefined?
16:50
annevk
wonders whether to merge https://github.com/web-platform-tests/wpt/pull/31461
16:52
<Luca Casonato>
Domenic: if x in y is false, will y[x] always be undefined?
No (because Proxy)
16:53
<annevk>
Luca Casonato: fair, but that doesn't seem applicable here
16:53
<Luca Casonato>
Oh ok, then idk
16:57
<Ms2ger 💉💉>
Seems fine
16:58
<Benjamin Gruenbaum>
Jake Archibald, annevk : followed your suggestion (https://github.com/whatwg/fetch/pull/1329), hope it's on the right track :)
really nice!
17:51
<Noam Rosenthal>
Noam Rosenthal: I'm not sure if that means we should stuff the controller on the request or just add an argument to "handle fetch", I guess the latter would be better
Definitely the latter. Seems natural to me that SW would get a "fetch controller" as a parameter and would be able to query if it is terminated
17:54
<Noam Rosenthal>
I would try to avoid associating more things with requests/responses, as those are transient serializable beings and when we associate "procedural" beings like fetch controller (or "an ongoing fetch") we make them confusing... (does this controller gets serialized or stored with the request? how?) that's what happened with associating timing info to a response, where it got ambiguous in terms of caching and SW
17:55
<Noam Rosenthal>
adding a parameter to SW's fetch "handle fetch" is a clean solution to this problem
18:14
<Noam Rosenthal>

annevk, Jake Archibald I think one thing that makes SW's "handle fetch" a bit different is that it asynchronously returns a response, rather than receive a processResponse callback algorithm or so.

If we'd change it to be the latter, the SW fetch could return its own controller and the main fetch could terminate it, rather than invert it to where SW has to check whether its caller ("the fetch instance") was terminated.

18:19
<annevk>
I wonder what happens today if the abort happens after the service worker returned a response. Does the service worker still get notified? Perhaps that's just a state check on the service worker side though...
18:20
<annevk>
Making that interaction with the service worker non-blocking sounds reasonable, though I'm not entirely sure I see what it would buy us quite yet.
18:22
<annevk>
I guess having a controller for the fetch event would give an opportunity to not forward signals when it's too late anyway, but realistically you'd have to implement that check on the receiver side as well.
18:23
<annevk>
I should have time to give all this another look at tomorrow
21:53
<Domenic>
annevk: looks like removing "pair" broke Web IDL: https://github.com/whatwg/webidl/runs/4082229137?check_suite_focus=true
22:16
<Domenic>
Kagami is on it