2019-01-01
[23:11:55.0000] <annevk>
Happy 2019 everyone!

[09:22:52.0000] <domfarolino>
:)


2019-01-02
[03:23:23.0000] <annevk>
yoav: it seems https://github.com/WICG/webappsec-feature-policy was incorrectly moved

[03:23:30.0000] <annevk>
yoav: old links are now in fact broken

[03:23:57.0000] <annevk>
yoav: my GitHub notifications for instance pointed me to https://github.com/WICG/webappsec-feature-policy/issues/263 and various other issues which are all 404s

[03:25:08.0000] <annevk>
yoav: links from the HTML Standard such as https://wicg.github.io/feature-policy/#policy-controlled-feature are also broken

[03:26:15.0000] <Ms2ger>
\o/

[03:27:14.0000] <annevk>
I'm glad I already said happy new year earlier on 😊

[04:12:07.0000] <yoav>
annevk: hmm

[04:12:36.0000] <yoav>
the issue links were broken because we tried to conserve the gh pages links

[04:13:18.0000] <yoav>
so we created a "redirection repo"

[04:13:56.0000] <yoav>
but that's not ideal...

[04:15:04.0000] <yoav>
it would be great if all redirections were automatically taken care of by GH

[05:15:33.0000] <yoav>
annevk: unrelated, but I'd appreciate a review for https://github.com/web-platform-tests/wpt/pull/9307

[05:21:33.0000] <annevk>
yoav: but the gh pages links are also broken?

[05:22:47.0000] <annevk>
yoav: that PR looks incorrectly rebased, which makes it hard to review

[05:22:47.0000] <yoav>
annevk: there were a couple of renames, one from "feature-policy" to "webappsec-feature-policy" and another to the W3C org

[05:22:47.0000] <yoav>
annevk: you're right. fixing

[05:27:08.0000] <annevk>
yoav: surely the longstanding feature-policy name is the one for which the redirects ought to work

[05:27:08.0000] <annevk>
yoav: in particular as now the HTML Standard is broken

[05:27:08.0000] <annevk>
yoav: and any archived copy thereof

[05:27:08.0000] <yoav>
annevk: Sure. (and not mutually exclusive)

[05:27:08.0000] <yoav>
I'll fix it now

[05:31:12.0000] <yoav>
annevk: Added a redirection repo for the feature-policy name, and it seems to be working

[05:32:09.0000] <yoav>
please verify that you see the same from your end

[05:35:45.0000] <annevk>
yoav: it redirects to https://github.com/WICG/webappsec-feature-policy/issues/263 which fails

[05:35:45.0000] <annevk>
yoav: the non-issue link does work

[05:36:45.0000] <yoav>
annevk: yeah, I'm not sure how to make sure that issues redirection continue to work when we need to create redirection repos (which have the same name)

[05:39:26.0000] <annevk>
yoav: usually there's a separate repo that manages the github.io site, which creates some other problems of course, but...

[05:39:54.0000] <annevk>
yoav: this at least makes me hugely skeptical of taking on dependencies on WICG stuff going forward

[05:42:46.0000] <yoav>
annevk: please don't turn this into a bigger issue than the technical problem that it is. If you have suggestions on better ways to move repos around, we'd be happy to hear them. If there are things in our process that we can do to prevent this in the future, we'd be happy to look into that as well.

[05:45:34.0000] <annevk>
yoav: I'd appreciate if you don't put the burden on me, thanks

[05:47:55.0000] <annevk>
But basically, if the issue of breaking issue links remains, it seems problematic and not just technical in nature, as it'll make it very hard to figure out what actually went on and why things were decided the way they were

[06:04:59.0000] <yoav>
annevk: I'm not arguing that it's not an issue needs resolving (it definitely is). I'm just not sure how to perform any repo migration in GH which supports both issue redirects and anchor redirects. This is a technical problem that we'd need to figure out (e.g. by asking GH to fix redirections, by changing the way migrations are done if our current process is needlessly breaking links that could be preserved, etc)

[06:08:12.0000] <annevk>
yoav: I mentioned one way, which is that you manage your website as a separate repo

[06:08:27.0000] <annevk>
yoav: that works and has been successfully used by other groups

[06:16:19.0000] <yoav>
yeah, we could create an abstraction layer above gh-pages as long as the specs are in incubation, to control the link redirection ourselves, and not need the redirection repos. that would be one option to tackle this

[07:18:07.0000] <Domenic>
It's not an abstraction layer above GitHub pages

[07:18:10.0000] <Domenic>
It's just a single website repo

[07:18:21.0000] <Domenic>
https://gist.github.com/domenic/1f286d415559b56d725bee51a62c24a7

[07:18:24.0000] <annevk>
hsivonen: happy new year, Web NFC might have a UTF-16 encoder (unclear LE/BE) dependency: https://github.com/w3c/web-nfc/pull/186

[08:46:28.0000] <yoav>
Domenic: that seems largely what we do (only we use JS based redirections to maintain anchors in redirected links)

[08:46:39.0000] <yoav>
does that preserve links to issues in your case?

[08:47:30.0000] <yoav>
(as the new repo for the redirection GH pages overrides the name of the moved repo, no?_

[08:47:32.0000] <yoav>
)

[09:01:00.0000] <Domenic>
yoav: yes, because there's no redirection repo per spec

[09:01:09.0000] <Domenic>
So nothing squats on the WICG/feature-policy namespace

[09:01:16.0000] <Domenic>
Letting GitHub handle the redirects as it should

[09:04:12.0000] <yoav>
oh! I wasn't aware of user gh pages. That seems like a better way to go indeed (and simpler to manage)

[09:04:38.0000] <yoav>
I wonder if killing the squating repos will bring back redirections

[09:04:43.0000] <yoav>
(for the issues)

[09:17:17.0000] <Domenic>
My guess is you'll need to do a re-transfer and transfer back, and/or contact GitHub

[10:05:25.0000] <yoav>
Domenic & annevk: redirections restored for both issues as well as spec links/anchors

[10:05:32.0000] <Domenic>
\o/

[10:05:55.0000] <yoav>
Domenic: thanks for pointing our GH user pages. Super helpful! :)

[10:06:05.0000] <Domenic>
:)

[10:06:09.0000] <annevk>
yoav: that’s great, thanks

[10:06:34.0000] <Zegnat>
Out of pure curiosity: did you document how you fixed it, yoav? Did you need to transfer back and forth again?

[10:07:19.0000] <yoav>
Zegnat: Just deleted the squatting repo and redirections were back. No unnecessary transfers needed

[10:09:10.0000] <Zegnat>
That’s good to know! 👍

[11:23:46.0000] <devsnek>
is there any public data on how much usage ajax.googleapis.com gets


2019-01-03
[08:02:05.0000] <annevk>
domfarolino: FWIW, https://github.com/whatwg/html/pull/4048#issuecomment-451187554 sounds good, I was just wondering how it was all fitting together

[08:02:13.0000] <annevk>
domfarolino: the more specific pieces look good though

[08:03:20.0000] <domfarolino>
annevk: Cool, thanks for checking it out. Yeah, the "fitting together" pieces are sort of in limbo currently

[12:25:56.0000] <domfarolino>
Domenic: WRT a "script-blocking style sheet" counter on Documents for #4031, it occurred to me that when a sheet is loaded, we cannot just decrement the counter, because the decremeter needs to know whether or not the conditions to increment the counter when the loading began, were once met (i.e., a "blocking" ss was loaded).

[12:28:19.0000] <domfarolino>
I'm wondering if we should make the conditions under https://html.spec.whatwg.org/multipage/semantics.html#a-style-sheet-that-is-blocking-scripts something callable, so we can increment and decrement explicitly. Let me know what you think of this sketch: https://gist.github.com/domfarolino/3fa29b31800e2203c8ce12b22cf8eba9

[12:29:03.0000] <Domenic>
domfarolino: what about having a set, instead of just a counter? Then removing (if it's not present) is a no-op

[12:29:28.0000] <Domenic>
Your version seems good to though at first glance, reading in more detail now...

[12:30:29.0000] <domfarolino>
I don't know how my counter version^ integrates with XML style sheets at all though, since it seems their processing would have to explicitly try and increment said counter, which it does not do currently.

[12:31:32.0000] <domfarolino>
RE a set, I was thinking about something similar, however we can't have a set of style sheets, because as per spec, the style sheet isn't "Created" (and added simultaneously) until it is finished loading, and we want scripting to be blocked before then. That brought be back to the counter idea

[12:32:12.0000] <Domenic>
Set of elements?

[12:32:36.0000] <Domenic>
(Refreshing myself on what XML stylesheets do :-/)

[12:33:45.0000] <domfarolino>
Oh duh, set of elements might be nice.

[12:34:09.0000] <Domenic>
Or a set of "things" if we need to handle XML stylesheets/Link headers...

[12:34:21.0000] <Domenic>
It does seem like we'll need to have something hand-wavey for those two

[12:34:25.0000] <domfarolino>
Yeah I started thinking about how to handle Linke headers in the future too

[12:34:39.0000] <Domenic>
I'm just concerned about not regressing the current vague text into precise but incorrect text

[12:34:51.0000] <Domenic>
So I think we want to have precise for link + style, plus vague for Link + XMLSS

[12:35:30.0000] <Domenic>
So either the counter or set versions, plus a sentence that says like "when you see an XMLSS or Link header, increment the counter/add to the set; when X happens, decrement/remove from the set"

[12:37:42.0000] <Domenic>
Medium-term we should investigate whether browsers actually allow Link or XMLSS style sheets to block script

[12:37:54.0000] <domfarolino>
That makes sense, I can add that to the interactions of styling and scripting section

[12:37:55.0000] <Domenic>
But right now I'm just aiming for minimum work to maintain current text's normative requirements

[12:38:42.0000] <domfarolino>
SGTM

[12:38:43.0000] <Domenic>
(although as you note the current requirements are pretty iffy, e.g. "the element" is often referenced but that doesn't make sense for Link headers)

[12:41:02.0000] <domfarolino>
Maybe longer-term we'd want "contributes a script-blocking style sheet" to be called not with an element, but with some abstract "Link properties" obj is produced by `Link` headers, `<style>`, and `<link>` elements. Not sure yet though

[12:42:34.0000] <domfarolino>
But yeah for now I can go with a counter or set approach and add a sentence to sort of hand-wave over XMLSS+Headers interacting with said construct

[12:42:37.0000] <Domenic>
My hope is that nobody bothered to implement blocking for XMLSSs and Link headers...

[12:42:51.0000] <domfarolino>
That would be nice

[12:43:08.0000] <domfarolino>
Will check

[12:44:50.0000] <annevk>
We could just put those into the set no? No need to make it a set of elements per se

[12:47:21.0000] <domfarolino>
annevk: Could you elaborate what "those" is?

[12:47:47.0000] <annevk>
domfarolino: Link header and PI node

[12:54:10.0000] <domfarolino>
Ok, can we insert the XSLT PI nodes in via HTML spec, or would updating the XSLT spec be necessary if that’s even an option

[14:11:39.0000] <domfarolino>
Domenic: FWIW it appears that xml style sheets and link headers support blocking styles

[14:27:04.0000] <Domenic>
:(

[14:44:21.0000] <domfarolino>
Oddly enough Chrome won't even fetch a style sheet that appears as a `Link` header unless it is rel=preload

[14:44:51.0000] <domfarolino>
I guess Safari too: https://crbug.com/19237 + https://bugs.webkit.org/show_bug.cgi?id=20018

[14:54:43.0000] <Domenic>
Ah right, I forgot that that feature was only on Firefox

[14:54:55.0000] <Domenic>
I think it was annevk who uses that to make their page's CSS/JS files look pretty

[14:54:59.0000] <Domenic>
Or something like that

[14:56:02.0000] <Domenic>
(Cannot reproduce, but I swear I saw it at one time.)

[14:56:12.0000] <Domenic>
(Also https://annevankesteren.nl/js/global is a funny file)

[14:59:41.0000] <domfarolino>
Lol


2019-01-04
[00:10:25.0000] <annevk>
FWIW, I had that set up on some other domains, but I decided to stop paying for them

[00:10:55.0000] <annevk>
I guess I can use shadow trees these days

[02:34:50.0000] <pak0s>
Hello everyone, I am new to WhatWG and like to contribute. I have suggestion for a new request header and want to know under which repository on github should I open issue?

[02:36:54.0000] <annevk>
pak0s: hey, welcome

[02:37:02.0000] <annevk>
pak0s: it's probably a good idea to read https://whatwg.org/faq#adding-new-features

[02:37:56.0000] <annevk>
pak0s: I suspect that either whatwg/html or whatwg/fetch would be the place, depending on what kind of header we're talking about, though note that user agents are very reluctant to simply add request headers without some kind of opt-in, as increasing the number of bytes per request is rather sensitive

[02:41:18.0000] <pak0s>
It should be a forbidden header and covers every xhr, dom and fetch request. Still figuring out if should be html or any else

[04:44:52.0000] <pak0s>
Just submitte my proposal https://github.com/whatwg/html/issues/4273

[04:44:59.0000] <pak0s>
comments are welcome :)

[10:17:08.0000] <TabAtkins>
Domenic: I'm angry at old-annevk's use of escaped-doublequote rather than just using singlequote inside the string. ^_^


2019-01-05
[20:53:32.0000] <MikeSmith>
\x~ 还没普及                                                            ntg                                                                                                                                                              uii；破溃皮

[20:53:38.0000] <MikeSmith>
                                                                                                                                                                                                                                             -

[20:53:56.0000] <MikeSmith>
oofs

[14:36:04.0000] <MikeSmith>
FYI for anybody interested in adding further comments: https://github.com/mdn/kumascript/issues/1019 “Consider linking to latest published versions instead of Editor's Drafts”


2019-01-06
[00:03:25.0000] <annevk>
TabAtkins: you don’t find two types of quotes confusing? I kinda like that JSON and HTTP only have double quotes

[09:45:48.0000] <Domenic>
Nice one MikeSmith, commented.


2019-01-07
[16:35:02.0000] <Krinkle>
Domenic: btw, fully on-board with linking to living standards; one thing I do find though, is that I'm often drawn to the field stating which version fo a spec the thing was introduced in (I don't click the link though). I suppose it's an old habit that is perhaps a bad one, given that even for ecma script specs (which still have a version), implementors cherry-pick out of order, so the support tables is where I should look!

[16:35:42.0000] <Domenic>
Agreed, support tables are the best.

[18:20:04.0000] <TabAtkins>
annevk: No, most languages allow both quotes. ^_^ I find escapes much more confusing and prefer to avoid them if possible.

[22:26:50.0000] <Krinkle>
Is there a draft spec for MemoryInfo? After googling for a few minutes, surprised to be empty handed for anything relating to performance.memory, MemoryInfo and/or totalJSHeapSize etc.

[22:27:02.0000] <Krinkle>
It's in chrome and no longer behind a flag.

[22:27:50.0000] <Krinkle>
was or is in Safari behind a flag.

[22:32:12.0000] <Krinkle>
Ah, found it. https://github.com/WICG/performance-memory/blob/master/explainer.md#-appendix-a---chromes-current-implementation-of-performancememory

[22:32:13.0000] <Krinkle>
https://github.com/WICG/performance-memory/issues/19

[22:32:22.0000] <Krinkle>
https://github.com/w3c/strategy/issues/144

[22:32:26.0000] <Krinkle>
Too bad.

[02:17:45.0000] <zcorpan>
Hello whatwg

[02:24:59.0000] <MikeSmith>
howdy zcorpan

[03:08:07.0000] <nox>
TabAtkins: Most languages allow both quotes? Citation needed.

[03:12:32.0000] <jgraham>
Most seems impossible to quantify. "Most weighed by usage" seems much more plausible to to compute and also to be true

[03:12:46.0000] <jgraham>
Although I wouldn't want to bet one way or another

[03:13:30.0000] <gsnedders>
most higher level languages allow either; most lower level don't?

[03:13:38.0000] <jgraham>
"most 'dynamically typed scripting languages, weighed by usage'" seems clearly true since just JS + Python

[03:14:20.0000] <jgraham>
Yeah, I think usually langauges that differentiate between char and str use different quotes for each and languages that don't don't

[03:31:49.0000] <nox>
Plot twist: TabAtkins was talking about human languages. :p

[03:48:21.0000] <MikeSmith>
hehe

[04:30:44.0000] <hsivonen>
annevk: :-( Is there some characterization of the overall vendor buy-in status for Web NFC?

[04:43:04.0000] <gsnedders>
hsivonen: nothing from MS or Apple; given Apple don't allow any third party access to NFC in iOS it seems unlikely they'll allow Web NFC

[04:53:17.0000] <annevk>
gsnedders: I think Apple now has some NFC APIs (perhaps readonly), but yeah, I wouldn't expect Web NFC to follow fast

[04:53:50.0000] <annevk>
https://developer.apple.com/documentation/corenfc

[05:00:08.0000] <gsnedders>
oh, somehow I'd missed that; that's big news for many things!

[05:00:35.0000] <gsnedders>
as long ago as iOS 11, seemingly


2019-01-08
[17:30:53.0000] <jwalden>
huh

[17:31:09.0000] <jwalden>
never seen a "Translations (non-normative):" section at head of a spec before https://streams.spec.whatwg.org/

[17:31:15.0000] <jwalden>
neat

[00:24:05.0000] <annevk>
JakeA: so in a way I see the appeal of using many objects, but on the other hand it's not really something we have precedence for

[00:24:13.0000] <annevk>
JakeA: is this how they do it in Node.js et al?

[00:24:32.0000] <annevk>
precedent*

[00:27:55.0000] <JakeA>
annevk: in node the conditions & handlers are JS, with maybe a function that returns a function. Eg decodeBody() would return a function that looks at the request and parses form data. Routers aside, React's props/state model has made plain objects pretty popular, and TypeScript makes them not-too-hard to create typings for. Not sure it's possible in WebIDL as it stands.

[00:29:11.0000] <JakeA>
annevk: I built https://github.com/jakearchibald/sw-routes/blob/master/README.md as an experiment a few months back. It's closer to how Express works

[00:30:50.0000] <annevk>
JakeA: what you sketched seems doable in IDL?

[00:32:31.0000] <annevk>
JakeA: library looks quite nice

[00:32:43.0000] <annevk>
JakeA: really wonder how builtin modules will shake things up going forward

[00:43:09.0000] <annevk>
/me notices Domenic made a similar comment some 10h ago

[00:45:49.0000] <JakeA>
annevk: I'll sketch something out. The thing I hit is: What do those functions return? If it's a special kind of object, why not have a constructor? If it's a plain object, why have the function?

[00:46:05.0000] <JakeA>
But I'll sketch an alternative and see how it goes

[00:49:14.0000] <annevk>
JakeA: I think it's important to realize that you need the functions for the polyfill, for something declarative you only need to pass instructions in some manner and ensure those instructions are not more powerful than the low-level API

[00:51:12.0000] <annevk>
Or alternatively, this would be a little higher-level still in that you need something that parses this and returns the necessary functions

[00:51:43.0000] <annevk>
s/parses/processes/ ... same same

[07:05:00.0000] <Domenic>
JakeA: FWIW I agree with the logic "What do those functions return? If it's a special kind of object, why not have a constructor? If it's a plain object, why have the function?" I just think the plain object route is worth exploring a bit more.

[07:47:50.0000] <JakeA>
Domenic: Yeah, thanks for prompting me to explore it more. I'm much happier with the plain object for the conditions. I'm not convinced about the sources, but it might not be a big deal if an enum can be used in the cases where options aren't needed

[07:48:05.0000] <Domenic>
Yeah I agree the sources are less obvious

[07:50:02.0000] <JakeA>
Domenic: How do you feel about the mix of enums and classes. Eg: `router.add(conditions, ['network', new RouterSourceCache('/offline.html')])`. The idea is you'd use `'network'` as a shorthand for `new RouterSourceNetwork()`, but if you needed to provide options, you'd need to use the constructor.

[07:51:25.0000] <Domenic>
I guess I still don't see why `new RouterSourceCache('/offline.html')` is better than `{ type: 'cache', url: '/offline.html' }`

[07:51:41.0000] <Domenic>
Assuming that the `RouterSourceCache` is just a dumb holder for precisely that `{ type, url }` data

[07:52:50.0000] <JakeA>
The problem is defining "url is a valid key of this object if the object also has key 'type' and its value is 'cache'"

[07:53:58.0000] <annevk>
JakeA: you could also put all the members in a dictionary and then throw for certain combinations

[07:54:00.0000] <Domenic>
Web IDL's constraints should not drive API design though. API design should drive us to expand Web IDL (if it happens more than once) or use prose (the first time)

[07:54:27.0000] <Domenic>
Yeah that's what MutationObservers do IIRC

[07:54:33.0000] <annevk>
uhuh

[07:55:30.0000] <JakeA>
Fair. I'm been thinking for a while that I should provide TypeScript definitions along with specs. This would be a case where I'd want to do that, as I'd like the TypeScript typings to be stricter than the WebIDL

[07:56:01.0000] <annevk>
The TypeScript community would probably like that

[07:58:21.0000] <JakeA>
annevk: Domenic: If I'm going down the all-object path, it really feels like we'd need a method to test if a condition/source is supported. Any objections?

[07:58:42.0000] <JakeA>
`router.supportsCondition('date', { to: Date.now() });`

[07:59:04.0000] <Domenic>
Seems reasonable I suppose; haven't thought too hard.

[07:59:33.0000] <annevk>
JakeA: the dictionary path you mean? I'd say only add it once you add something that needs it

[07:59:49.0000] <annevk>
JakeA: because for v1 presumably all UAs will implement the v1 version

[08:00:53.0000] <JakeA>
annevk: Fair enough. As long as we could add it later, else we kinda lock ourselves into the V1 set.

[08:01:37.0000] <annevk>
Hopefully we'll always be able to add stuff 😃

[08:01:51.0000] <annevk>
And if we can't then I suppose it doesn't matter anyway


2019-01-09
[01:45:35.0000] <zcorpan>
MikeSmith: https://checker.html5.org/ gives me 502. maybe set up statuscake or something?

[01:46:55.0000] <zcorpan>
or is it just me?

[01:51:39.0000] <zcorpan>
seems like "down for everyone?" services don't care about http response code

[02:14:04.0000] <annevk>
zcorpan: I also get a 502

[04:17:43.0000] <MikeSmith>
https://checker.html5.org/ is back now. restarted the server

[04:18:00.0000] <MikeSmith>
*restarted the validator process

[04:18:23.0000] <MikeSmith>
the reason it was down was the somebody from the systems team had restarted the machine without letting me know

[04:18:42.0000] <MikeSmith>
the validator process never goes down otherwise

[04:19:20.0000] <MikeSmith>
so I just need to add a script that will automatically restart it at boot time when the machine’s restarted

[05:58:54.0000] <hsivonen>
annevk: is https://github.com/whatwg/encoding/issues/115#issuecomment-447773485 on your radar? Should I send my feedback to the Unicode Consortium as drafted?

[06:03:31.0000] <annevk>
hsivonen: I asked somewhere what exactly the middle ground meant

[06:04:18.0000] <hsivonen>
annevk: the middle ground fixes the pressing issue without security benefit and leaves the door open toward later movement toward either extreme

[06:04:31.0000] <annevk>
hsivonen: I'm fine with either more principled generation of U+FFFD or removing the state member we currently have

[06:04:42.0000] <annevk>
hsivonen: okay, that's fine with me

[06:05:05.0000] <annevk>
hsivonen: I should have mentioned it in the issue after the lack of reply, but I forgot

[06:05:08.0000] <hsivonen>
annevk: i.e. it would remove U+FFFD generation only in the case where the first of the two transitions with nothing in between is a transition to the ASCII state

[06:05:24.0000] <hsivonen>
annevk: sorry about missing your question

[06:07:12.0000] <hsivonen>
researching the feasibility of end state 2 requires an archive of a lot of real-world Japanese email new and old, and my own mailbox isn't like that

[10:33:50.0000] <annevk>
So let { x } = y(); { x } = y(); throws, that's unfortunate

[15:30:20.0000] <Domenic>
I think you need `({ x }) = y();` or `({ x } = y());`


2019-01-10
[00:38:04.0000] <annevk>
Ah, thanks, I should try that

[03:06:26.0000] <annevk>
The latter worked

[11:35:31.0000] <zcorpan>
foolip: it'd be nice to be able to filter this list https://www.chromestatus.com/metrics/feature/popularity

[11:41:03.0000] <zcorpan>
/me filed https://github.com/GoogleChrome/chromium-dashboard/issues/583

[12:45:37.0000] <foolip>
zcorpan: Good idea

[14:49:49.0000] <Domenic>
"This version: <the url in your address bar>" is such a waste of space :(

[14:53:43.0000] <Mek>
not wlays for /TR/ versions, where "This version" is a permalink for this specific version, while the actual URL in your address bar could just be the generic TR URL for that spec...

[14:53:59.0000] <Mek>
(I know, TR versions are such a waste of space :P)


2019-01-11
[16:25:23.0000] <mattyp>
I have a question about the web-streams api

[16:25:34.0000] <mattyp>
is anyone here knowledgable?

[01:58:13.0000] <yoav>
annevk: if you're around, I'd appreciate your comments on the note in https://github.com/w3c/resource-timing/pull/172 and if it's still necessary given the (handwavy) https://github.com/w3c/resource-timing/pull/196

[02:01:21.0000] <yoav>
I'd also love bz's review on https://github.com/web-platform-tests/wpt/pull/13823, but not sure how to grab his attention...

[02:02:10.0000] <annevk>
yoav: I thought I left a comment this morning?

[02:02:14.0000] <annevk>
/me looks

[02:02:28.0000] <annevk>
yoav: there's a comment there from me

[02:02:32.0000] <yoav>
you did!

[02:02:45.0000] <yoav>
but GH didn't show it without a reload...

[02:03:08.0000] <annevk>
bz hangs out in Mozilla IRC, but generally not before 5PM our time

[02:04:00.0000] <annevk>
yoav: having said that, I'd recommend reaching out to Markus Stange for anything you want bz for, he should be handling most Web Performance stuff these days

[02:04:02.0000] <yoav>
OK, I'll try to catch him there

[02:04:12.0000] <yoav>
ok

[02:04:30.0000] <annevk>
yoav: mstange btw (also email)

[02:04:48.0000] <yoav>
regarding your comment, I don't understand the scenario of the attack you're describing

[02:05:27.0000] <yoav>
if attacker adds TAO, it exposes information about itself to EXAMPLE

[02:05:44.0000] <yoav>
that is true, but not sure what attack/leak that enables

[02:05:52.0000] <annevk>
yoav: the idea is that if the attacker manages to be somehow in the middle they can confuse example

[02:06:20.0000] <annevk>
yoav: this is probably more true with CORS due to it encompassing much more data, but it seems good to keep the same kind of check

[02:07:05.0000] <annevk>
yoav: the idea is that once you've gone cross-origin stuff is tainted, and you better explicitly opt into that

[02:08:33.0000] <yoav>
can you point me to the related CORS discussion? I want to better understand the rational

[02:09:12.0000] <annevk>
Not easily

[02:09:39.0000] <annevk>
"confused deputy" might be a good search term (and that coupled with security might give you some insight into the theoretical background)

[02:09:43.0000] <yoav>
(I don't immediately see the damage in making EXAMPLE think that the resource is CORS-enabled/passes TAO)

[02:11:15.0000] <yoav>
I'm familiar with that, but not sure how that applies here. What is ATTACKER convincing the confused EXAMPLE to do?

[02:15:28.0000] <annevk>
That really depends on what EXAMPLE does with the readouts, e.g., perhaps ATTACKER could cause some kind of overflow

[02:17:10.0000] <annevk>
And it applies precisely because EXAMPLE thinks it's in control but actually ATTACKER could have influenced the results, that's a confused deputy

[02:39:31.0000] <yoav>
annevk: OK, so if I apply this specifically to TAO, if EXAMPLE reads timing values, ATTACKER can make those values arbitrarily higher. That doesn't seem particularly risky, and EXAMPLE should know that this is true, as it has put ATTACKER in its redirection path

[02:40:27.0000] <annevk>
It doesn't have to know if it's XSS or some such

[02:41:47.0000] <annevk>
Also, I don't think it makes sense to use a different model for TAO

[02:41:54.0000] <yoav>
in the XSS case, I think EXAMPLE has bigger problems

[02:42:16.0000] <annevk>
Not a good enough argument against this imo

[02:42:35.0000] <annevk>
I also don't see the problem with adopting a model that's equivalent to CORS, I thought we agreed on that long ago actually

[02:42:40.0000] <yoav>
OK, that seems like it's worth while to open a separate issue other than 152 on that, discuss it and reach conclusions in a wider forum

[02:42:52.0000] <annevk>
I thought this was that issue?

[02:43:14.0000] <annevk>
I explained this exact scenario several times in GitHub too...

[02:43:49.0000] <yoav>
It wasn't clear to me that this was the issue (as TAO handling was also lacking definition around redirections that don't include TAO)

[02:44:17.0000] <yoav>
I agree that aligning the model with CORS would be good

[02:44:40.0000] <yoav>
but want to discuss this extra restriction in a wider forum

[02:46:35.0000] <annevk>
yoav: I guess you can, but we already did

[02:46:40.0000] <annevk>
yoav: this is example 5 of https://github.com/w3c/resource-timing/issues/173#issuecomment-448450346

[02:47:08.0000] <annevk>
yoav: sorry, example 2

[02:48:27.0000] <yoav>
For the CORS case, is there an alternative mechanism for EXAMPLE to opt into CORS with a cross-origin redirect?

[02:48:57.0000] <annevk>
yoav: I don't understand

[02:49:07.0000] <yoav>
basically to say "I know I have a cross-origin redirect and I'm not confused about it"

[02:49:17.0000] <annevk>
yoav: yeah, set CORS headers

[02:49:44.0000] <yoav>
oh, ok

[02:50:31.0000] <yoav>
example 3 in the above issue

[02:50:48.0000] <annevk>
yes

[02:50:50.0000] <yoav>
fair enough

[06:16:22.0000] <yoav>
annevk: other than the algo refactoring,  https://github.com/w3c/resource-timing/pull/197 looks fine?

[06:16:46.0000] <annevk>
yoav: yeah, I think so

[06:16:59.0000] <yoav>
awesome, thanks! :)

[12:13:45.0000] <zcorpan>
Does gecko have some hack to "support" the safari max(2em, env(safe-area-inset-left)) thing?

[12:14:11.0000] <zcorpan>
i try foo(bar, env(baz)) and it gives 0 in gecko

[12:15:16.0000] <zcorpan>
but change "env" to something else makes the declaration be ignored

[12:32:50.0000] <zcorpan>
https://bugzilla.mozilla.org/show_bug.cgi?id=1519519

[13:33:41.0000] <TabAtkins>
Domenic: Jeez, looking at the "interfacing with IDB" example, I'm even angrier that we shipped IDB 1 without including a friendly version.

[13:33:52.0000] <Domenic>
^_^

[13:34:12.0000] <TabAtkins>
The only upside to that debacle is that you can now promise-ify the friendly version and it's automatically attractive solely from the friendliness.

[13:39:24.0000] <Domenic>
I still remain quite pleased with the example in https://wicg.github.io/kv-storage/#storagearea-backingstore

[13:43:58.0000] <TabAtkins>
this is v v good


2019-01-12
[03:43:07.0000] <smaug____>
Hmm, how would I check in web page when an image gets painted

[03:43:50.0000] <smaug____>
I'm forgetting some state related to it

[04:51:30.0000] <annevk>
smaug____: don’t think that’s exposed


2019-01-14
[01:11:27.0000] <nox>
Was it ever considered to change [Constructor] to the constructor syntax of ES classes? So that constructors can themselves have WebIDL extended attributes without nesting them?

[01:46:59.0000] <annevk>
nox: there’s an issue on that

[06:05:28.0000] <Ms2ger>
Is there a way to write `new x(...args)` without ...?

[06:06:42.0000] <jgraham>
does .call work here?

[06:07:08.0000] <gsnedders>
no, it doesn't

[06:07:34.0000] <gsnedders>
(because .call calls [[Call]], not [[Construct]])

[09:28:57.0000] <Domenic>
Reflect.construct()

[09:41:26.0000] <Domenic>
Yay, blob: URLs continue to get better... that was like five issues closed.

[10:48:51.0000] <Domenic>
annevk: starting to go through my review backlog... it looks like https://github.com/whatwg/html/pull/4284 has a front-line reviewer, so ping me when that's ready for a pass from me.

[11:30:45.0000] <Domenic>
domfarolino: is https://github.com/whatwg/html/pull/4031 ready for another round of review? Seems possible but the commit message is just about "low-hanging fruit" :)

[11:58:15.0000] <domfarolino>
Domenic: Ah, I think not quite yet, there should be a bit more I can do wrt moving some steps around; will let you know asap

[11:59:02.0000] <Domenic>
Great, no rush

[13:15:57.0000] <TimothyGu>
annevk: by https://github.com/tc39/ecma262/pull/1401#issuecomment-454012277 do you mean like the platform objects in Web IDL

[13:16:46.0000] <TimothyGu>
also "I think even has some dynamic slots" do you have examples?

[13:20:03.0000] <annevk>
TimothyGu: ah, I was thinking of serializing/deserializing Records, not objects

[13:20:34.0000] <annevk>
TimothyGu: for where we add slots on the fly

[13:20:42.0000] <TimothyGu>
yeah Records can do that

[13:21:01.0000] <annevk>
TimothyGu: with the other thing I meant platform objects but also deserializing prose

[13:21:10.0000] <annevk>
TimothyGu: oh really?

[13:22:29.0000] <TimothyGu>
annevk: yeah. like a lot of times Property Descriptor Records are not actually completely filled

[13:22:50.0000] <TimothyGu>
and they get filled later

[13:23:26.0000] <TimothyGu>
But I feel like that change is just a ECMA-262 consistency improvement; nothing is really changed changed for IDL objects

[14:02:35.0000] <Domenic>
+1, I think it's fine to land as-is instead of scope-creeping to a larger HTML/Web IDL cleanup project :)


2019-01-15
[19:03:31.0000] <domfarolino>
Domenic: So if the full response is not available at this point (https://github.com/whatwg/html/pull/4031#discussion_r245259907), is it unnecessary to Fetch in parallel? Also, is it possible that we might not be able to determine if response is a network error until later on (since response isn't done yet)?

[19:04:02.0000] <Domenic>
You have to fetch in parallel; it does network I/O which you can't do on the main thread

[19:04:29.0000] <Domenic>
Otherwise it's similar to JS. The `response` variable does not have a full body, but it has headers, you'll know if it's a network error, etc.

[19:05:20.0000] <domfarolino>
Ah ok gotcha

[19:35:06.0000] <domfarolino>
Uh, is https://drafts.csswg.org/ down for anyone else?

[19:40:05.0000] <Domenic>
Works for me

[19:42:32.0000] <domfarolino>
:(

[11:09:53.0000] <Domenic>
domfarolino: I don't really understand your proposal at https://github.com/whatwg/html/pull/4031/files#r247760518

[11:12:38.0000] <domfarolino>
Domenic: My impression was you wanted all of the steps from "Let <var>success</var> be true" and down, moved to the process response task, which in the current state, seems analogous to the process the linked resource steps

[11:13:27.0000] <Domenic>
Oh, no, I gave the wrong impression then

[11:13:45.0000] <domfarolino>
I was thinking of moving said steps into that algorithm, but moving the "fetch/wait for critical subresources" into link stylesheet's override of process the linked resource

[11:13:48.0000] <domfarolino>
Ah ok

[11:13:56.0000] <Domenic>
I think it's fine as-is, it's just worth noting that you don't get the response body unless you explicitly use the phrase "process response body" or something like that. And we need the response body for the critical subresources.

[11:14:03.0000] <Domenic>
But I think that's all details we don't need to fix right now.

[11:14:46.0000] <Domenic>
Although, hmm, this might all be simpler if you just set the synchronous flag

[11:15:12.0000] <domfarolino>
Was wondering if that would be reasonable since we're in parallel

[11:15:19.0000] <Domenic>
Yeah let's do that

[11:16:43.0000] <domfarolino>
Ok, I'll do that and add a warning about critical subresource fetching being underdefined, and maybe mention how it should be taken care of by another spec (CSS for example I guess).

[11:17:44.0000] <domfarolino>
Although, that seems to imply that load/error events won't be fired until the entire response is available right?

[11:18:50.0000] <domfarolino>
Oh, I guess that's how it is defined currently too "Once the attempts .... are complete"

[11:20:02.0000] <domfarolino>
Using process response would be nice eventually though I think

[11:25:03.0000] <Domenic>
I'm not sure there's a difference between async + process response vs. sync flag + just do the steps, besides a level of indentation

[11:31:32.0000] <domfarolino>
Right, I do like the idea of using process response though mostly just because it exists

[13:03:46.0000] <domfarolino>
Domenic: OK I'd say 4031 is ready for re-review now

[15:53:46.0000] <devsnek>
mfw the html spec is almost 6mb


2019-01-16
[16:26:03.0000] <domfarolino>
Hm my generated single page index.html is 10mb

[16:27:33.0000] <domfarolino>
Domenic: Do you think we can just get rid of this: https://github.com/whatwg/html/pull/4031#discussion_r245355186 I honestly don't quite get what it means, is it just saying the element must still exist in the DOM even if its resource doesn't get applied?

[16:28:06.0000] <domfarolino>
It almost sounds more like it is saying something like a style sheet will still be available via DOM apis even if it is not applied maybe?

[16:28:29.0000] <domfarolino>
Yeah that might be it

[16:29:35.0000] <Domenic>
I think getting rid of it would be goos

[16:30:41.0000] <Domenic>
I think it's saying either "even if the stylesheet is disabled, document.styleSheets should still contain it" or "even if the resource is never fetched, the link element must still be accessible via the DOM".

[16:30:52.0000] <Domenic>
Neither are very useful

[16:31:09.0000] <domfarolino>
yeah

[17:40:21.0000] <Domenic>
domfarolino: maybe we should move the "Queue a task on the networking task source" out of the "process this type of linked resource" steps? I.e. make the default fetch-and-process step 12.5 be "Queue a task on the networking task source to process the linked resource given el, success, and response."

[17:47:06.0000] <domfarolino>
I like that idea. As long as it wouldn't be a problem performing the content-type metadata check in the task and not earlier (seems fine)

[17:47:47.0000] <Domenic>
Yeah the response can't change in such a way

[17:49:34.0000] <domfarolino>
👍

[22:23:05.0000] <TimothyGu>
annevk: is there a reason why we are suddenly trying to remove [NoInterfaceObject] from everywhere? I feel like it was just something on the backlog

[23:38:05.0000] <annevk>
TimothyGu: Ms2ger filed a PR which made me go through the backlog a bit

[23:38:14.0000] <TimothyGu>
ah I see

[05:43:34.0000] <Ms2ger>
annevk, do you still feel the same way about https://github.com/heycam/webidl/issues/236 ?

[05:46:49.0000] <annevk>
Ms2ger: yeah, pretty much, DOMString -> JavaScript string and USVString -> scalar value string, too

[05:47:07.0000] <annevk>
(and also have that conversion on the way out)

[05:47:28.0000] <annevk>
So I can return a byte sequence, and ByteString ensures JavaScript gets a DOMString

[05:48:15.0000] <annevk>
(This again makes me wonder why Domenic thinks that return values are useless. It seems they're quite necessary at times.)

[12:38:02.0000] <a-ja>
i know there's been fieldset/legend work underway recently.  is this up to date with that work? https://html.spec.whatwg.org/multipage/rendering.html#the-fieldset-and-legend-elements

[12:39:41.0000] <a-ja>
been pondering whether legend should align right in rtl

[14:42:28.0000] <Domenic>
TabAtkins: no good linking syntax for slots, right? [=StorageArea/\[[DatabaseName]]=] doesn't work

[14:42:41.0000] <Domenic>
a-ja: that is up to date as far as I know

[14:42:59.0000] <TabAtkins>
{{StorageArea/[[DatabaseName]]}}

[14:43:19.0000] <TabAtkins>
slots are just a private part of the interface, they live in the idl attr namespace

[14:43:40.0000] <Domenic>
Ah for some reason I thoguht that gave me the biblio error but on trying it again it does not.

[14:43:59.0000] <a-ja>
tks Domenic

[14:44:08.0000] <TabAtkins>
You still need to escape the [ when you define the slot, but not when you link it

[14:44:38.0000] <TabAtkins>
(and as soon as IDL grows a slot syntax (/ implicit backing slots), you won't generally need to do that anyway

[14:48:05.0000] <Mek>
(calling something storage area when the local storage/session storage specs already extensively talk about storage areas seems like it might be confusing btw, although I guess at least in that case it isn't ever formally defined as a term, and certainly isn't a IDL interface (although in blink the implementation of the Storage IDL interface is called StorageArea...))

[15:44:58.0000] <domfarolino>
Domenic: one thought I had for testing task sources was to perform two operations that would definitely queue tasks on the same source and assert their order is correct. That would at least catch impls that queue the tasks on different sources AND prioritized the sources in a way that doesn’t jive well with the test. Would not catch impls that queue them on different sources but happen to prioritize them in a way that

[15:44:58.0000] <domfarolino>
the test accepts. But in general it’s pretty pedantic yeah

[15:45:02.0000] <Domenic>
Anyone have an opinion on the right fix for https://github.com/WICG/kv-storage/issues/45 ? I am feeling indecisive.

[15:46:26.0000] <Domenic>
domfarolino: yeah I guess that's a pretty simple stochastic test. I'd be worried about impls that don't explicitly prioritize the task sources against each other, or not in any principled way, so that you'd end up passing half the time and failing half the time depending on which task source it decided to pick. Still might be worthwhile though.


2019-01-17
[16:56:55.0000] <domfarolino>
Domenic: yeah that’s a good call indeed

[00:05:41.0000] <annevk>
Domenic: why is the normal caching approach not good?

[02:06:38.0000] <Ms2ger>
In https://heycam.github.io/webidl/#legacy-platform-object-set , what's the "If O and Receiver are the same object, then:" check for?

[02:12:43.0000] <annevk>
I keep forgetting what Receiver is, sorry

[02:17:48.0000] <annevk>
Having read up on it, I'm not quite sure, but it seems easy enough to test with Reflect.set() or some such?

[02:18:00.0000] <annevk>
That is, to see if it's what implementations do

[06:36:37.0000] <Domenic>
MikeSmith: what do the w3c.json files do? I cargo-culted one at https://github.com/WICG/kv-storage/blob/master/w3c.json but am unclear why I did that

[06:37:00.0000] <Ms2ger>
annevk, shouldn't the "UTF-8 decode" algorithms return one of the Infra string types rather than a tream?

[06:37:03.0000] <Ms2ger>
stream

[06:38:28.0000] <annevk>
Ms2ger: https://github.com/whatwg/encoding/issues/128 handles some of that

[06:38:53.0000] <Domenic>
I feel like I had a large-ish issue about my confusion about how to use those algorithms

[06:39:02.0000] <annevk>
Ms2ger: in general I hope we can also say that Encoding stream and scalar value string autocast

[06:39:03.0000] <Domenic>
Like how most call sites seem to expect them to return a string but they return a stream

[06:39:15.0000] <Domenic>
Ah, there it is. https://github.com/whatwg/fetch/issues/661

[06:39:20.0000] <annevk>
Ms2ger: since it mostly doesn't matter

[06:39:55.0000] <Domenic>
(My issue is not really the same thing, but is impacted.)

[06:40:33.0000] <annevk>
Generally we handle not-directly exposed streams in a rather hand-wavy way

[06:40:58.0000] <annevk>
And it's also not clear to me we want all the complexity of encoding_rs in standards, where we end up with synchronous and asynchronous algorithms and such

[06:41:34.0000] <Domenic>
I think ideally we'd confine the hand-waviness to some specific operations

[06:41:48.0000] <annevk>
I guess this is a long way of saying that I wouldn't mind improvements, if someone were to offer them

[06:42:04.0000] <Domenic>
It's really confusing that you can synchronously read from a fetch body by treating it as an Encoding Standard byte stream, but it might be asynchronously filled by JS code.

[06:42:31.0000] <Domenic>
I'm not sure how to improve things though, it's just too big.

[06:42:39.0000] <annevk>
Well, I'd expect that you'd wait for it to be done streaming in that case first though

[06:42:59.0000] <annevk>
Fetch has some primitives around waiting for things, but it's been a while

[06:43:42.0000] <Domenic>
I guess one improvement I suggest in my thread is to have versions of the Encoding Standard algorithms that operate only on static byte sequences / strings, and use those wherever we can. Then we can see what the problematic cases are, where we're actually operating on something that could change over time, and get a better idea of what we need to do there.

[06:44:38.0000] <Domenic>
There are probably less disruptive ways to accomplish that though.

[06:52:42.0000] <annevk>
I'd be happy to review patches, but it's not really a priority for me

[12:00:07.0000] <annevk>
Domenic: another look at https://github.com/whatwg/html/pull/4214 would be great

[12:00:22.0000] <Domenic>
Oh, right...

[12:00:42.0000] <Domenic>
How does this help with BC groups?

[12:01:13.0000] <annevk>
Domenic: currently we tie event loops to browsing contexts at times

[12:01:31.0000] <annevk>
Domenic: doesn’t really make much sense

[12:01:52.0000] <Domenic>
I guess that is bad

[12:02:56.0000] <Domenic>
It seems like it might be possible to make the association be with agents without it being 1:1

[12:03:00.0000] <Domenic>
I.e. allow many agents -> 1 event loop

[12:03:07.0000] <Domenic>
You mostly want to go agent -> event loop

[12:08:25.0000] <annevk>
But why though? Wouldn’t that also go against ECMAScript’s requirements on agents?

[12:09:41.0000] <Domenic>
A smaller delta from the existing spec would make me more comfortable. Let me check the ES requirements.

[12:10:30.0000] <Domenic>
No, ES requirements are not relevant because [[CanBlock]] is always false for window agents

[12:10:49.0000] <Domenic>
https://tc39.github.io/ecma262/#sec-forward-progress second para

[12:12:19.0000] <Domenic>
bbiab

[12:12:28.0000] <annevk>
Hmm so we’d have diff relationship reqs for diff agents? Hmm

[12:12:55.0000] <annevk>
User agents are pretty close to this being 1:1 too

[12:34:14.0000] <Domenic>
We already have different relationship requirements for different agents

[12:34:31.0000] <Domenic>
I thought UAs did pretty serious coalescing

[13:37:31.0000] <annevk>
Maybe same-site across BCGs, but that’s not observable so I’d rather have stronger guarantees in the spec

[13:37:54.0000] <annevk>
Also to ensure it does not become observable

[13:38:24.0000] <annevk>
I might be okay with allowing some coalescing though if impls want that

[14:18:35.0000] <MikeSmith>
Domenic: about the w3c.json file, it’s documented at https://w3c.github.io/w3c.json.html but I don’t know myself what tools if any actually do anything with it. It’s something Robin came up with a long time ago.

[14:20:51.0000] <Domenic>
I guess in the future I'll omit it until someone tells me what tools use it


2019-01-18
[17:54:19.0000] <devsnek>
is there a first class name for `document.body.parentElement`

[18:10:00.0000] <MikeSmith>
devsnek: the document element? the root element? document.documentElement?

[18:10:34.0000] <MikeSmith>
or otherwise is “first class name” some specific term of art?

[18:10:49.0000] <devsnek>
MikeSmith: yeah i meant `document.documentElement`

[18:10:51.0000] <devsnek>
thank you

[18:13:45.0000] <MikeSmith>
ah OK

[18:13:52.0000] <MikeSmith>
cheers

[19:21:59.0000] <Domenic>
annevk: we forgot to pick up the review drafts after the holidays

[21:10:05.0000] <annevk>
Domenic: ah I can do some today

[02:53:49.0000] <MikeSmith>
big +1 to the new official slogan the nginx project chose for itself

[02:54:08.0000] <MikeSmith>
quoted in https://lists.w3.org/Archives/Public/www-tag/2019Jan/0001.html

[02:54:38.0000] <MikeSmith>
“Nginx does not comply with HTTP/1.1, let alone TAG findings.”

[03:56:30.0000] <jgraham>
That mail is from 2019? It suddenly feels like 2004 again.

[05:04:12.0000] <yoav>
Hey y'all! A Bikeshed question. I'm hitting validation issues at https://travis-ci.org/whatwg/fetch/builds/480969414?utm_source=github_status&utm_medium=notification as part of https://github.com/whatwg/fetch/pull/773. I have two <dfn>s with the same name and I'm not sure how to disambiguate them...

[05:07:50.0000] <annevk>
yoav: you need to use <a for=/> or <a for=request> explicitly

[05:08:08.0000] <annevk>
yoav: <a>s are the problem, not <dfn>s from a quick glance

[05:08:49.0000] <yoav>
oh, so when referring to one of them I need to say which one. Makes perfect sense!

[05:08:55.0000] <yoav>
annevk: thanks! :)

[07:16:23.0000] <Domenic>
annevk: note that if by "fast back" you mean bfcache, it looks like soon we'll have 3/3 browsers implementing it, so we may want to tighten the spec around that

[07:19:27.0000] <annevk>
Domenic: yeah, I heard in the last meeting around COOP

[07:19:47.0000] <Domenic>
I mainly wonder if making it mandatory will decrease complexity

[07:19:57.0000] <annevk>
Domenic: nobody was super rushed to make it work for COOP scenarios though, as that would be a lil more involved (though on reflection it's not that complicated from an HTML Standard perspective)

[07:20:05.0000] <Domenic>
Gotcha

[07:20:50.0000] <annevk>
I have never really worked with it myself. I suspect jgraham and zcorpan have some experience writing tests around it, but that's quite a while ago now

[07:22:33.0000] <zcorpan>
bfcache? Yeah I recall writing some test to make sure that an open websocket caused the doc to be discarded or so

[07:22:57.0000] <zcorpan>
Haven't tested bfcache itself in detail though

[07:23:15.0000] <annevk>
It's so weird how this feature has no real standardized name. At least as far as I know bfcache is a Gecko term

[07:23:35.0000] <Domenic>
"the way that sometimes history state entries have a Document still and sometimes they don't"

[07:41:59.0000] <annevk>
🎉

[07:52:29.0000] <Domenic>
Gosh the iframe section just has so many random unconnected normative requirements and notes in a row

[08:07:54.0000] <Ms2ger>
I see you're very excited to rewrite it all :)

[08:11:48.0000] <annevk>
Could really use some nested browsing context container abstraction…

[10:04:18.0000] <Domenic>
annevk: why is "Sharing it within an agent cluster is not allowed by JavaScript."?

[10:08:50.0000] <annevk>
Domenic: then a worker/worklet would not have independent forward progress?

[10:09:06.0000] <Domenic>
annevk: sure, for workers and worklets, but those have their own 1:1 agent/event loop already

[10:09:11.0000] <Domenic>
It's the window case we're discussing

[10:09:32.0000] <annevk>
Domenic: you cannot have multiple of those in one cluster

[10:09:51.0000] <annevk>
Domenic: and that was not clear from your phrasing

[10:09:57.0000] <Domenic>
Ah, right.

[10:10:16.0000] <Domenic>
I'm still working on this

[10:10:38.0000] <Domenic>
I asked internally and then learned that agents and threads are not 1:1 (makes sense in retrospect)

[10:11:23.0000] <Domenic>
So now I need to think harder about what the spec is communicating, both in the agents section generally and in your proposed change vs. the slight-update-to-the-status quo that I am somewhat advocating for.

[10:11:29.0000] <annevk>
Yeah, I guess there is some sharing, but it’s not required or observable

[10:11:55.0000] <Domenic>
I think it's observable that you can starve other pages

[10:12:36.0000] <Domenic>
a.com can busy-loop to stop b.com's tasks from executing, even though they're different agents. So I think that leans toward them sharing an event loop.

[10:12:53.0000] <Domenic>
I think it's even testable using postMessage

[10:13:04.0000] <Domenic>
Although not in a very deterministic fashion

[10:13:18.0000] <Domenic>
Gotta lunch now though, so haven't thought as hard as I need to

[10:13:33.0000] <annevk>
If they are in the same process you have Sectre problems though

[10:13:55.0000] <annevk>
So not particularly compelling longer term

[10:14:08.0000] <annevk>
Spectre

[10:14:18.0000] <Domenic>
I don't think anyone is signed up for guaranteeing that every origin gets its own process, no matter how many tabs you have open.

[10:14:32.0000] <Domenic>
But regardless, consider two same-origin pages that aren't in the same URSOBC.

[10:16:26.0000] <annevk>
Yeah, but then how do you proof it? Timers and BroadcastChannel? Shared worker maybe?

[10:17:14.0000] <annevk>
Also, separate event loops does not mean much, UA could still interleave them as spec does not put reqs on them

[10:19:26.0000] <annevk>
We want process per site long term, with some guarantee as I understand. Perhaps by paging background tabs to disk or some such

[10:19:37.0000] <Domenic>
Separate event loops per spec require you to drain them all in parallel

[10:19:56.0000] <Domenic>
There's no provision for blocking indefinitely on another event loop

[10:21:22.0000] <Domenic>
I realize it may be hard to write tests for, especially deterministic ones, but it's still "observable", especially to users.

[10:21:39.0000] <annevk>
I guess, ok, it prolly does not matter much anyway as tasks already have an owner, but sharing same-site window agents we could do

[10:22:03.0000] <annevk>
Allowing that, anyway

[10:22:58.0000] <annevk>
I’d also love to clarify the task record snd how it differs between event loop types

[10:23:05.0000] <annevk>
and*

[10:24:26.0000] <annevk>
Draining them in parallel is a pretty good point, although UAs could in theory halt on every step of course and all we could claim is that perf is bad, which isn’t a thing standards care about…

[10:25:13.0000] <Domenic>
Lol I guess. Just would rather have something more like the implementation

[10:25:30.0000] <Domenic>
The task struct definitely could use cleanup

[10:32:03.0000] <Domenic>
I also will PR something to make it clear agents and threads are not 1:1 (it's more likely event loops and threads will be). I think the current non-normative text is a bit misleading.

[13:49:13.0000] <devsnek>
is anyone here experienced with EME

[13:57:03.0000] <Domenic>
https://blog.whatwg.org/drm-and-web-security

[14:00:05.0000] <devsnek>
oh its w3c not whatwg

[14:00:20.0000] <devsnek>
(and btw i hate eme, but i'm trying to use a stream that has widevne)

[14:02:33.0000] <Domenic>
Basically, probably not a lot of people around here have much expertise in the area, given sentiments like the above ;)

[14:02:58.0000] <devsnek>
yeah

[14:03:06.0000] <devsnek>
as far as i can tell no one on the internet has experience with eme

[14:03:24.0000] <devsnek>
except the developers at the companies that pushed eme

[14:04:45.0000] <Domenic>
This seems plausible


2019-01-20
[17:09:40.0000] <domfarolino>
I'm sure there exists more that I can't quickly find, but does anyone know of any interface methods that return dictionaries, other than TextEncoder's encodeInto (https://encoding.spec.whatwg.org/#ref-for-dom-textencoder-encodeinto) ?

[22:53:30.0000] <domfarolino>
annevk: https://encoding.spec.whatwg.org/#utf-8-encoder doesn't use `stream` at all right? Or is there a reason it is passed in?

[22:57:49.0000] <domfarolino>
Oh I guess it is because some handlers do indeed use the stream, and we seem to reference all handlers by "some encoder/decoder instance's "handler", nvm

[01:08:22.0000] <annevk>
domfarolino: getAttributes() or some such in WebGL returns a dict iirc


2019-01-21
[16:44:10.0000] <atrigent>
hello! apologies if there's a better place to ask this, but I'm unsure about this: https://html.spec.whatwg.org/multipage/images.html#images-processing-model:concept-microsyntax-parse-error - what would the difference be between fatal and non-fatal in this context?

[19:29:02.0000] <MikeSmith>
atrigent: “non-fatal” in that context means that parsing does not fail. It means the parser doesn’t stop but continues on despite the error in the input.

[19:34:01.0000] <atrigent>
MikeSmith: so here: https://html.spec.whatwg.org/multipage/images.html#parsing-a-srcset-attribute:concept-microsyntax-parse-error for example, the commas would set there as having been a parse error, but otherwise they would basically just be ignored?

[19:40:40.0000] <MikeSmith>
atrigent: right

[19:40:52.0000] <atrigent>
ok, thank you

[19:41:56.0000] <MikeSmith>
if you look at https://html.spec.whatwg.org/multipage/images.html#image-candidate-string you see that the definition of “image candidate string” says whitespace is valid there but says nothing about commas

[19:42:35.0000] <MikeSmith>
but the parser is required to accept commas in there if an author makes a mistake and puts any in despite it not being valid

[19:42:52.0000] <atrigent>
well it does say "A valid non-empty URL that does not start or end with a U+002C COMMA character (,)"

[19:43:41.0000] <MikeSmith>
ah yeah OK

[19:45:07.0000] <atrigent>
but yeah, I guess the actual implementation is supposed to be a little more permissive

[19:46:02.0000] <MikeSmith>
anyway FWIW the HTML checker at https://validator.w3.org/nu/ will still report an error for those cases ー even though browsers will accept that input, the checker still reports it, since the checker’s purpose is to inform authors about cases that don’t match the spec requirements

[19:46:37.0000] <atrigent>
ok, interesting

[20:35:21.0000] <domfarolino>
Domenic: If I understand https://github.com/whatwg/html/issues/4267 correctly, https://null-referrer-script.glitch.me/ is a good demonstration of the path-dependence?

[20:35:38.0000] <domfarolino>
(I made it because I believe Chrome + Safari 12 behave as if all event handler fn's have null [[ScriptOrModule]], while FF seems OK)

[04:04:46.0000] <jgraham>
gsnedders: Not pteradactyl, but ptarmigan, c.f. https://en.wikipedia.org/wiki/Lagopus

[05:21:06.0000] <Ms2ger>
> The p- was added due to a mistaken belief in a Greek origin

[05:21:11.0000] <Ms2ger>
lol English

[06:03:27.0000] <annevk>
yoav: I don't think you want to use for=/ on a <dfn>

[06:03:45.0000] <Ms2ger>
That was probably my suggestion, sorry

[06:03:57.0000] <annevk>
yoav: not entirely sure if that is what's going amiss on https://travis-ci.org/whatwg/fetch/builds/481359853 though, but if it is, maybe ask Bikeshed for a better error message

[06:04:30.0000] <annevk>
yoav: either way, I've never used for=/ on a <dfn> so I'd ask for removal anyway 😃

[06:05:21.0000] <yoav>
OK, how should I define a general concept, compared to one owned by a specific object type?

[06:05:32.0000] <yoav>
just remove the `for`?

[06:06:25.0000] <annevk>
yoav: yeah

[06:06:57.0000] <yoav>
will do!

[06:07:22.0000] <yoav>
Regarding "client-hints" vs. "client hints", I don't really care if it's one or the other

[06:07:27.0000] <annevk>
yoav: <dfn export>i am generic</dfn>; <dfn for=something>i am generic</dfn> holds a <a for=/>i am generic</a>; <a for=/>something</a>'s <a for=something>i am generic</a> is the best

[06:07:33.0000] <yoav>
I got the feeling you prefer "client hints"

[06:07:41.0000] <yoav>
should I switch to that?

[06:08:17.0000] <annevk>
yoav: I mostly want consistency, ideally grounded in something

[06:10:26.0000] <yoav>
"grounded in something" - is there some convention that indicates we should take one route over the next?

[06:10:55.0000] <annevk>
yoav: I'm not sure, I'm not a native speaker, so I guess I'd defer to the client hints RFC

[06:11:38.0000] <yoav>
OK

[06:12:57.0000] <annevk>
JakeA: you around? Why does cache.put clone the response?

[14:54:00.0000] <Bnaya>
Hey all :)

[14:55:02.0000] <Bnaya>
I was thinking today that im missing the ability to abort fetch response.json() and other async tasks

[14:57:51.0000] <Bnaya>
or the signal that was passed to the fetch() also controls all the async calls on the response obejct


2019-01-22
[16:00:13.0000] <domfarolino>
sounds more like cancellable promises than just an extension of abortable fetch

[16:59:10.0000] <fantasai>
Would someone mind reopening https://github.com/whatwg/html/issues/284 for me, please?

[17:05:18.0000] <domfarolino>
reopened

[21:34:36.0000] <domfarolino>
annevk: If you wouldn't mind giving https://github.com/whatwg/html/pull/4048 a look now that I've rebased it that would be great. It should be done now

[23:51:02.0000] <annevk>
I think the signal propagates?

[23:51:35.0000] <annevk>
domfarolino: k, should have time

[01:45:10.0000] <annevk>
oh wow, a source set is not an actual set

[01:45:20.0000] <annevk>
it's a struct consisting of a set and some other field

[01:46:25.0000] <annevk>
I guess it's already somewhat questionable practice to name the type in a name, but getting it wrong is another level 😊

[01:46:53.0000] <annevk>
Although I tend to make an exception for lists/sets/maps, they somewhat make sense to name at times

[06:50:38.0000] <JakeA>
When specs "rethrow any exceptions", what's the purpose of that? I thought rethrowing would be the default unless exceptions were caught

[06:51:01.0000] <annevk>
JakeA: old-style

[06:51:15.0000] <annevk>
JakeA: aka pre-Infra-making-it-better

[06:51:19.0000] <JakeA>
ahaaaa thanks

[07:54:47.0000] <annevk>
So Glitch is pretty great, should have tried that sooner

[07:55:38.0000] <annevk>
Basically avoids all the issues that Live DOM Viewer has due to the nested frames, though you'll need to use developer tools for the remaining features, which is okayish

[07:56:12.0000] <annevk>
One problem I ran into is that they name the Preview window, which tainted my test, but that's easy enough to work around once you know it

[09:57:30.0000] <jyasskin>
https://w3c.github.io/network-error-logging/#generate-a-network-error-report creates a "new ECMAScript object" for the primary purpose of calling JSON.stringify() in https://w3c.github.io/reporting/#try-delivery. I feel like bz won't like this setup. Would y'all suggest building a big WebIDL structure and JSON'ing it manually, or something else?

[10:34:32.0000] <annevk>
jyasskin: we lack good infrastructure around JSON

[10:35:20.0000] <annevk>
jyasskin: so I suspect that approach is fine as long as serialize is the intrinsics method and not a potentially modified one

[10:37:00.0000] <jyasskin>
annevk: If you're happy with it, I'm happy with it. The wording is "executing the JSON.stringify() algorithm on collection [ECMA-262]", which looks like an attempt to avoid any modifications.

[10:37:46.0000] <annevk>
You prolly want something similar to what Infra does for parse, but that’s WIP

[11:31:24.0000] <Domenic>
We have serialize

[11:31:34.0000] <Domenic>
https://infra.spec.whatwg.org/#serialize-json-to-bytes

[12:01:02.0000] <Domenic>
jyasskin: in general that looks OK, the only question being types. Like, I have to infer that IP addresses are probably stored as strings because of the "Otherwise, the empty string"

[12:08:53.0000] <jyasskin>
Domenic: Yes, types are fuzzy throughout.

[12:23:53.0000] <annevk>
Aaah forgot Jeff landed that

[12:24:07.0000] <annevk>
So yeah, it should use that


2019-01-23
[16:31:36.0000] <devsnek>
was there ever any discussion on an api to grab pending messages from a message port instead of using the message event

[16:57:21.0000] <Domenic>
Hmm, sounds familiar, but I don't know off hand

[16:57:50.0000] <Domenic>
We've talked vaguely about making ReadableStream/WritableStream interfaces around them as well

[17:18:27.0000] <devsnek>
i couldn't find anything specific on github

[17:32:33.0000] <Domenic>
Yeah it'd probably be from the Bugzilla or mailing list days

[17:34:03.0000] <devsnek>
/me backs away slowly

[18:07:52.0000] <devsnek>
Domenic: whatwg/html is the correct repo for this right?

[18:41:21.0000] <Domenic>
Yeah

[05:04:31.0000] <annevk>
JakeA: do you know how https://github.com/whatwg/html/issues/2687 got solved?

[05:04:36.0000] <annevk>
JakeA: or is solved, rather

[08:20:06.0000] <Ms2ger>
annevk, do you have time available for WebIDL reviews?

[08:22:07.0000] <Ms2ger>
Domenic, same question for you ^

[08:22:13.0000] <annevk>
Ms2ger: not anymore this week I'm afraid

[08:24:19.0000] <annevk>
Ms2ger: I put a reminder in for next Wednesday. I'd like to mostly work on browsing context stuff and Cross-Origin-Opener-Policy and friends among some other Mozilla things until then

[08:24:34.0000] <Ms2ger>
annevk, okay, thanks

[09:25:12.0000] <Domenic>
Ms2ger, in case you read the logs: I can try but this week I have a summit, so it'd be during the rare downtime. I would like to in general help with reviews though, it's just this week is hard.


2019-01-24
[05:33:29.0000] <annevk>
Is it known that wattsi's error information is completely off?

[05:33:37.0000] <annevk>
I cannot find the line where there is a parse error anymore

[05:47:40.0000] <annevk>
Sigh, cleaning up mess other folks left behind with half-defined features is really frustrating

[05:48:04.0000] <annevk>
window.open(..., frameName, 'noopener');

[05:48:13.0000] <annevk>
new window in Chrome/Firefox, navigates frame in Safari

[05:48:48.0000] <annevk>
Note that what Chrome/Firefox do here is the opposite what they do for <a>

[06:23:22.0000] <Soni>
what can I pass off as a web browser?

[06:24:02.0000] <Soni>
is "a script that extracts forms from the HTML and lets you fill and submit them" a web browser?

[06:26:36.0000] <Soni>
well I'm gonna try to pass it off as one

[07:08:01.0000] <bradleymeck>
is newline delimited JSON used anywhere in web specs...?

[07:32:12.0000] <annevk>
bradleymeck: don't think so

[08:40:57.0000] <annevk>
Domenic: if you manage to do a pass on the refactor browsing context that'd be great, but I suppose between tests and event loops I have something else I can do as well (among a myriad of even more things I'm trying to ignore)

[08:41:35.0000] <annevk>
Domenic: I guess the main thing with the browsing context thing is that it's such a blocker for so much other work

[08:42:08.0000] <Domenic>
bradleymeck: we've contemplated adding a built-in stream thingy for it, but not very much

[08:42:12.0000] <Domenic>
annevk: yeah, will try!

[08:43:10.0000] <bradleymeck>
Domenic: yea, was more a curiosity of Response -> streaming async iterator of some kind for events

[08:43:27.0000] <bradleymeck>
not really required but mild convenience

[08:45:43.0000] <annevk>
bradleymeck: is this http://jsonlines.org/ btw? Does it have a MIME type?

[08:46:53.0000] <annevk>
/me finds https://github.com/wardi/jsonlines/issues/9

[08:48:42.0000] <bradleymeck>
https://www.iana.org/assignments/media-types/application/json-seq is the only official one I see

[08:50:00.0000] <annevk>
Ah, so https://tools.ietf.org/html/rfc7464 defines it and references IETF JSON

[08:50:29.0000] <annevk>
I guess that's mostly equivalent to TC39 JSON these days so maybe it's too early to grab popcorn

[08:51:51.0000] <bradleymeck>
IETF JSON says all the specs should agree on the syntactic elements

[08:56:35.0000] <annevk>
That sequence RFC is no good for browsers though, the parser doesn't require whitespace, but the security considerations do

[08:56:55.0000] <annevk>
Not that it would be hard to define a more robust parser, but that would have to happen if this became a thing in browsers

[08:59:51.0000] <annevk>
I guess if you view section 2.4 as monkey patching section 2.1 it might be okay, but the whole setup is rather weird in that case

[09:00:23.0000] <annevk>
IETF documents would be a lot clearer if they adopted algorithms


2019-01-25
[08:40:26.0000] <annevk>
Domenic: so update; there's a couple tests now and I think I addressed all of the feedback you gave

[08:40:48.0000] <annevk>
Domenic: thanks again for the feedback, it's been really helpful getting this done

[08:41:23.0000] <annevk>
Domenic: I left out the yak-shaving that would have involved rewriting the entire object element algorithm, but otherwise addressed most

[08:41:55.0000] <annevk>
Domenic: also, if you know a good term for a top-level browsing context that's not an auxiliary browsing context...

[08:42:04.0000] <Domenic>
Sounds good, I didn't look at the context too much so it's understandable. Lots of cleanup on the iframe/object/embed business to do eventually anyway. Will try to re-review today.

[08:43:29.0000] <annevk>
I think with these incremental refactorings to those elements we're getting closer to a fuller picture, which is nice

[08:44:12.0000] <annevk>
That is, it looks more doable the more things are turned into algorithms with clear steps and expectations

[08:46:04.0000] <Ms2ger>
Domenic, if you have time to look at WebIDL PRs, that'd be appreciated :)

[08:46:13.0000] <Domenic>
Oh right

[08:46:33.0000] <Ms2ger>
/me disappears into the night


2019-01-29
[05:08:59.0000] <hendry>
an HTML document is living and needs to be maintained over time

[05:09:22.0000] <hendry>
though how is one supposed to express the "birth time", the original publication date of a document?

[05:09:44.0000] <hendry>
bbc news regularly runs into this problems since their URLs are pretty opaque

[05:17:55.0000] <Ms2ger>
<p>Original publication date: 1 January 1953.</p>

[05:22:32.0000] <hendry>
Guess meta date didn't take off for some reason or another

[05:26:50.0000] <annevk>
Yeah, that seems like the kind of thing you'd mention inline, perhaps using <time> if you're having a good day

[06:09:49.0000] <Soni>
does WHATWG define any algorithm to derive a name from/for a form?

[06:10:03.0000] <Soni>
for the purposes of text browsers/screen readers/etc?

[06:10:34.0000] <Soni>
(and my attempt at making a feature to quickly find the right form)

[06:11:34.0000] <Ms2ger>
There's the "name" attribute, but that's not really intended for humans

[06:11:40.0000] <Ms2ger>
I'm not aware of anything else

[06:13:10.0000] <Soni>
can form elements be outside the form?

[06:13:21.0000] <Ms2ger>
Sure

[06:14:21.0000] <Soni>
uh what

[06:14:43.0000] <Soni>
;_;

[06:16:58.0000] <Soni>
is there an algorithm for collecting form elements and attaching them to forms?

[06:22:20.0000] <Ms2ger>
https://html.spec.whatwg.org/multipage/forms.html#dom-form-elements is relevant

[06:24:08.0000] <Soni>
idk what I'm looking at

[06:24:11.0000] <Soni>
;_;

[06:34:05.0000] <Jessidhia>
"A form-associated element is, by default, associated with its nearest ancestor form element (as described below), but, if it is listed, may have a form attribute specified to override this."

[06:35:19.0000] <Jessidhia>
<form id="foo"></form> can be referenced from outside by, say, <button type="submit" form="foo"></button>

[06:35:23.0000] <Soni>
so just grab the element and find the parent <form>?

[06:35:33.0000] <Jessidhia>
but otherwise yeah, just looks for the parent <form>

[06:35:36.0000] <Jessidhia>
or the closest one at least

[06:36:26.0000] <Soni>
when I say "parent" I'm including grandparent etc, sorry

[06:59:42.0000] <annevk>
Soni: you have to walk the entire tree effectively to see if elements have a form attribute set

[07:00:27.0000] <annevk>
Soni: it's not just ancestors

[07:00:56.0000] <Soni>
yeah it's parents and ids

[07:00:58.0000] <Soni>
right?

[07:01:31.0000] <annevk>
depends on what you mean, but sure, sounds about right

[07:18:06.0000] <Soni>
basically for input/textarea/etc in document: if element has form: form = element.form if not form: form = find nearest <form> ancestor?

[07:18:39.0000] <Soni>
(what happens if the id pointed to by the form attribute doesn't exist or isn't a <form>?)

[07:25:03.0000] <annevk>
Soni: https://html.spec.whatwg.org/#association-of-controls-and-forms describes the processing model in detail

[07:26:00.0000] <annevk>
Soni: iirc in that case it would fallback to ancestor search

[07:47:49.0000] <Soni>
okay

[07:47:59.0000] <Soni>
what happens if there are duplicated id?

[07:50:37.0000] <annevk>
Soni: I recommend reading the algorithms as it's likely using me as proxy will lead to mistakes

[07:51:16.0000] <Soni>
the algorithms?

[07:51:37.0000] <Soni>
they appear to be all over the place

[07:57:24.0000] <Soni>
annevk: idk where you found these algorithms I can't seem to find them

[08:08:14.0000] <imacinto>
is the "fr" unit explicitly defined anywhere? I'm assuming "fraction" but it seems like saying something is "2 fractions wide" or "2 fractional units wide" is imprecise. if that's just the way it is, that's fine, but this seemed like the right place to confirm :)

[08:10:05.0000] <annevk>
imacinto: https://drafts.csswg.org/css-grid/#fr-unit

[08:17:25.0000] <imacinto>
annevk: thank you! this is as close as I came to a definition. would it be accurate to say "fr" is an abbreviation for "flexible length"? my interpretation was different; that flexible lengths are measured in "fr"s, just like my pants inseam is measured in inches

[08:18:21.0000] <annevk>
imacinto: per the definition there I suspect it literally stands for fraction

[08:19:44.0000] <annevk>
imacinto: I don't really know grid layout though

[08:22:23.0000] <imacinto>
annevk: right on. I appreciate it, I'm clearly going a little crazy trying to find it spelled out explicitly, but I think this is as good as I'll get. I got to this spot before and scratched my head thinking "1 fraction" vs "2 fractions" but I suppose if you consider it "fraction of the leftover space in the grid container" things are a little clearer (although way wordier!)

[08:24:23.0000] <annevk>
imacinto: irc.w3.org's css channel can prolly provide more context

[08:24:48.0000] <imacinto>
annevk: I didn't know there even was one! that's great, thank you

[08:25:22.0000] <imacinto>
I looked at the editor contact info and got to tabatkins mentioning this room. I'll check over there

[08:28:08.0000] <annevk>
I see, Tab would know the answer though 😃

[08:28:35.0000] <imacinto>
hehe, yeah, I feel like the answer is in an email thread someplace

[08:30:13.0000] <annevk>
So revamping event loops is the only blocker for browsing context groups at this point \o/

[08:32:23.0000] <gsnedders>
annevk: just a small blocker!

[08:34:35.0000] <annevk>
gsnedders: I have a half-baked patch with lots of good input from Domenic; [it's-happening.jpg]

[08:34:55.0000] <annevk>
But yeah, fixing that up will take a bit of time

[08:51:40.0000] <Soni>
irc.w3.org is awful

[08:52:09.0000] <devsnek>
its kinda empty

[08:56:48.0000] <Soni>
it's plaintext

[09:14:14.0000] <TabAtkins>
Argh, people leaving quickly before I can respond. :(

[10:42:49.0000] <annevk>
TabAtkins: tell me 😊

[11:19:32.0000] <TabAtkins>
It's just "fraction of the free space", like the spec says.


2019-01-30
[18:21:38.0000] <saschanaz>
Hello people, I want to replace the old mixin syntax in https://wiki.whatwg.org/wiki/DOM_XPath but I don't have a wiki account. Can I request one?

[19:21:32.0000] <terpri>
saschanaz, yes, ask someone from this list: https://wiki.whatwg.org/index.php?title=Special:ListUsers&group=autoconfirmed

[19:37:35.0000] <MikeSmith>
saschanaz: I had the system send you some mail

[19:38:47.0000] <MikeSmith>
we really need to just migrate all that wiki content to github. The need-to-request-a-wiki account dance is a waste of time for all parties

[19:57:33.0000] <saschanaz>
I got my account, thanks! 👍

[20:02:41.0000] <MikeSmith>
saschanaz: cheers

[21:11:56.0000] <annevk>
saschanaz: thanks for updating that

[22:16:11.0000] <saschanaz>
annevk: 😎

[04:19:31.0000] <annevk>
Ms2ger: it seems I might not have much time today after all

[07:06:42.0000] <annevk>
Domenic: so I think one reason I went for one event loop per agent is because the alternative is rather hard to pin down

[07:07:14.0000] <annevk>
Domenic: it's basically 1:1, but similar-origin window agents may share an event loop if they happen to be same-site and same-scheme

[07:14:54.0000] <Domenic>
annevk: that sounds about right

[07:25:27.0000] <annevk>
Domenic: and with this high-res enabler it’ll be even more involved

[07:25:52.0000] <annevk>
Domenic: I’m still not really convinced it’s worth the effort

[07:25:58.0000] <Domenic>
I mean, reality is indeed pretty complex. Seems like it's our job to spec it :)

[07:26:14.0000] <annevk>
When it’s observable

[07:26:32.0000] <Domenic>
Yes, and I think this is extremely observable, although not easily from tests you can write in JS.

[07:26:59.0000] <annevk>
It’s not, not anymore than anything else perf-related

[07:27:26.0000] <annevk>
And we don’t define those either

[07:27:30.0000] <Domenic>
Right, I think it's abuse of the perf loophole to say "oh your stuff just got slow for no reason; while true actually means pause whenever you want"

[07:27:45.0000] <Domenic>
I would rather spec an architecture that relates to what can be feasibly implemented.

[07:28:24.0000] <annevk>
One process per cluster is feasible in theory

[07:28:48.0000] <Domenic>
I don't think it's a good idea to spec things based on what's feasible in theory.

[07:30:54.0000] <annevk>
Sure, but is this a big enough problem to block a whole bunch of improvements on?

[07:31:23.0000] <Domenic>
Yes, I think this would be a big regression.

[07:31:23.0000] <annevk>
If we cannot even test it

[07:31:39.0000] <Domenic>
I can make a lot of untestable regressions to how the spec describes the web architecture.

[07:31:46.0000] <Domenic>
But I don't think we should, even if it simplifies the spec.

[07:32:50.0000] <annevk>
The current model cannot be implemented, hard to regress

[07:33:27.0000] <Domenic>
The current event loop <-> agent mapping can be.

[07:33:59.0000] <annevk>
It’s not even defined

[07:34:36.0000] <Domenic>
I'm not really sure how to make progress here; it seems like we have a lot of disagreements on the state of the world and the desireability of speccing something implementable. But I'm really not comfortable committing a 1:1 mapping to the spec.

[08:22:46.0000] <annevk>
I think I would have more sympathy for your concern if we consistently applied these principles. But I guess I will try to meet this req as you’re effectively gatekeeping everything on this

[08:46:31.0000] <Domenic>
I think we try to apply the priority of constituencies pretty consistently.


2019-01-31
[18:55:54.0000] <devsnek>
the multipage spec comes from splitting up the single page spec right?

[18:56:02.0000] <devsnek>
like not the other way around

[20:01:12.0000] <MikeSmith>
devsnek: it’s a matter of the one version being split from another

[20:01:47.0000] <MikeSmith>
they are both generated separately from the same single source

[20:01:50.0000] <devsnek>
MikeSmith: yeah i found the pascal builder thing

[20:01:53.0000] <MikeSmith>
yeah

[20:02:09.0000] <MikeSmith>
so that does multiple passes through the source to build the different versions

[20:02:12.0000] <devsnek>
don't feel like learning pascal rn so i won't be using this as a resource :(

[20:02:19.0000] <MikeSmith>
heh

[20:02:57.0000] <MikeSmith>
it is actually an amazingly great and fast tool

[20:03:20.0000] <devsnek>
i'll take your word for it

[20:04:14.0000] <MikeSmith>
I have not great love for pascal either but in the end it’s all just code

[20:05:44.0000] <MikeSmith>
would be nice if it were rust but rust wasn’t really ready at the time Ian wrote that tool

[20:05:47.0000] <MikeSmith>
and anyway he

[20:06:04.0000] <MikeSmith>
Ian has some eccentric tastes in languages

[20:06:30.0000] <devsnek>
lol

[00:25:26.0000] <Ms2ger>
annevk, fixed https://github.com/heycam/webidl/pull/625

[00:26:11.0000] <annevk>
Ms2ger: ah you've appeared

[00:26:20.0000] <annevk>
Ms2ger: I wanted to tell you I finished PR triage

[00:27:42.0000] <annevk>
Ms2ger: do you know why Travis is failing?

[00:27:53.0000] <Ms2ger>
No, I was wondering the same thing

[00:28:29.0000] <annevk>
I restarted it

[00:30:30.0000] <Ms2ger>
Passes now

[00:32:00.0000] <annevk>
Ms2ger: so one thing, we're pretty particular about commit messages

[00:32:13.0000] <annevk>
Ms2ger: in that there's a title and a body and the title doesn't end with a period

[00:32:41.0000] <Ms2ger>
annevk, please put the requirements in the README or a CONTRIBUTING doc

[00:33:02.0000] <annevk>
Ms2ger: https://github.com/whatwg/meta/blob/master/COMMITTING.md#structure-and-conventions

[00:33:13.0000] <annevk>
Ms2ger: but that's fair

[00:33:43.0000] <Ms2ger>
Especially since this isn't even a whatwg repo :)

[00:34:02.0000] <annevk>
I'll add a link, PR coming up shortly

[00:35:20.0000] <Ms2ger>
Thanks

[05:37:50.0000] <annevk>
Domenic: so are all worklets concurrent? They seem to use their own event loop, but I don't think that's reality...

[05:38:27.0000] <annevk>
(but they also can't share a window event loop, as their tasks won't have documents)

[05:39:06.0000] <annevk>
Domenic: maybe you can volunteer to write this part?

[06:48:48.0000] <Ms2ger>
annevk, I don't understand your comment at https://github.com/heycam/webidl/pull/635#discussion_r252688116

[06:49:56.0000] <annevk>
Ms2ger: assert that the interface's global attribute matches the realm it's created in

[06:50:05.0000] <annevk>
[Global] attribute*

[06:50:49.0000] <annevk>
Ms2ger: it seems that information went missing, which is somewhat reasonable, but it might be nice to retain it in this way?

[06:53:20.0000] <Ms2ger>
annevk, sorry, I can't see what went missing

[06:55:16.0000] <Ms2ger>
annevk, though an assertion about [Exposed] might be useful?

[06:55:46.0000] <annevk>
Ms2ger: my bad, yes

[06:56:43.0000] <annevk>
Ms2ger: so are mixins handled earlier now? It seems that step is still talking about all interfaces being implemented somewhere

[06:57:11.0000] <annevk>
Ms2ger: and you replaced that implemented by with a loop over the inheritance chain

[06:57:36.0000] <annevk>
Ms2ger: which I don't think makes sense?

[06:57:51.0000] <Ms2ger>
annevk, there's a statement somewhere that all members of a mixin are also considered members of the interface they're mixed into

[06:58:14.0000] <annevk>
Sorry for misreading some bits here initially, I should have compared the removed text with the added text a lil more

[06:58:22.0000] <annevk>
Ms2ger: okay

[07:33:27.0000] <nox>
I lost myself in Servo and started wondering how inserting a script in a document interacts with document.getElementById and custom element callbacks

[07:33:28.0000] <nox>
https://gist.github.com/nox/37e4efa909f3fabdaf13f32563967b4c

[07:33:41.0000] <nox>
This logs BIT DISCONNECT in both Safari and Firefox,

[07:34:00.0000] <nox>
but only Firefox logs that document.getElementById('foo') is an HTMLElement, Safari says that's null.

[07:34:12.0000] <nox>
Not sure where to file an issue about that, if anywhere at all.

[07:40:34.0000] <Ms2ger>
nox, file on html and see what happens, I guess

[07:41:19.0000] <nox>
Ms2ger: Ok

[09:09:13.0000] <Soni>
idk how to parse HTML forms

[09:09:23.0000] <Soni>
even reading the algorithms