Skip to content

full pass at DID URL dereferencing algorithm (isolated)#344

Open
jandrieu wants to merge 19 commits into
w3c:mainfrom
LegReq:feature/dereferencing-algorithm
Open

full pass at DID URL dereferencing algorithm (isolated)#344
jandrieu wants to merge 19 commits into
w3c:mainfrom
LegReq:feature/dereferencing-algorithm

Conversation

@jandrieu

@jandrieu jandrieu commented Jun 30, 2026

Copy link
Copy Markdown
Collaborator

Per our last working group call (that I was on). Here's a proposed top-level dereferencing algorithm with flow chart illustration.


Preview | Diff

Comment thread index.html
Comment thread index.html
that property. For example, the
<code>linkedResourceMetadata</code> property uses its own
handling strategy as described in the <a
href="https://w3c-ccg.github.io/did-linked-resources">DID

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Should we reference this as an example? I can see the value of it, but as it is not a formal spec, perhaps we can't?

Comment thread index.html
<code>linkedResourceMetadata</code> property uses its own
handling strategy as described in the <a
href="https://w3c-ccg.github.io/did-linked-resources">DID
Linked Resource</a> specification. If the did document

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Suggested change
Linked Resource</a> specification. If the did document
Linked Resource</a> specification. If the DID document

Comment thread index.html
Comment on lines +2318 to +2322
The group is currently debating how to handle DID Query
parameters during dereferencing. It is likely that query parameters
will be included as a legacy fallback for any query Parameters
that may affect dereferencing, in the same manner that document
properties, metadata, and method-specific strategies are supported.

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I like this call out that we still need to figure this out. But the notion of legacy fallback feels weird to me.

Query parameters are a point of extension, this is like saying all extensions are treated as legacy fallbacks isn't it.

E.g. if I define the query parameter linkedResource which works like service but for the Linked Resource property, I would hope that is would be processed first (or at least after service if that is present)

Comment thread index.html
<code><pre>RetrievalUrl = https://example.com/didimages/image.png</pre></code>
</li>
<li>
<strong>Retrieve URL</strong> Perform an HTTPS GET operation

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I like that you have defined a default handler strategy. But I am unsure about defaulting to HTTPS GET.

Why not just return the service endpoint and let the client figure it out?

E.g. if it is a BTCR2Beacon with a bitcoin: service endpoint, this is going to fail until a handler strategy is defined.

I am sure there are other similar cases.

Also, what about the case where a serviceEndpoint is a Map?

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Agree that this should not be constrained to HTTPS but should be based on the protocol defined by the serviceEndpoint.

Comment thread index.html
When invoking this handler, simply return the DID Document retrieved
from Resolve.
</p>
</section>

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I think you are missing a closing , but probably best to check on your local.

The TOCs are all messed up from section 6. https://pr-preview.s3.amazonaws.com/LegReq/did-resolution/pull/344.html#dereferencing-provisional

@wip-abramson

Copy link
Copy Markdown
Contributor

Thanks @jandrieu for this. I think this is a great effort to define the DID URL Dereferencing algorithm. It is clear and easy to read and I think captures most of what the group has been discussing over the last few weeks.

Interested to see how it lands for others.

However, I do still stand by the strategy of focusing the groups attention on getting into CR with DID URL Dereferencing marked as at risk. That means:

  • The DID vs DID URL discussion as resolution inputs
  • Addressing the last TAG issues.

I think we could be ready to do this in the next week or two.

Then, when in CR we can turn our attention back to this PR and ironing out the last few pieces for the DID URL Dereferencing algorithm. Once complete and horizontal reviewed, we can create a new CR snapshot.

We can discuss on the call this week, but the route I outlined feels like the safer option.

Co-authored-by: Will Abramson <wip.abramson@gmail.com>
@peacekeeper

Copy link
Copy Markdown
Collaborator

The section nesting seems to be messed up somehow..

Screenshot From 2026-07-03 09-39-50

Comment thread index.html
continue processing if the response provided enough
information to do so.</li>
<li>
<strong>Repeat</strong> as necessary until the final

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I don't find this guidance particularly clear and question if it should be here at all. I gather from previous conversations that this is something about did:btcr2 (and therefore, perhaps other DID Methods), but am not sure, nor do I understand that use case. I definitely don't understand this "repeating" in the context of "point in time" DID Docs. versionTime is the known way to ask for a point in time DIDDoc, and how that is accomplished is DID Method specific, and so need not surface here. I can also imagine cases where a caller invoking DID URL dereferencing gets a results and decides to dereferencing another DID URL, but IMHO, that would be a separate invocation, not a "repeat as necessary".

I suggest that either a concrete example of what this means be added so it is clear why/when this might be needed, or we remove this.

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I agree with @swcurran . While I understand the intention of this (cases like did:btcr2 that sometimes require additional input), the language will be very confusing for non-experts and could lead to problematic implementations.

Comment thread index.html
a [[local resolver]], which does not (likely a local
resolver will be
invoked using standard linked library or interprocess
communication). Implementers MUST enable users to choose the

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I'm not sure about what the last line ("Implementers MUST...") means and why it is needed. Does that mean an Implementer MUST offer multiple "did:web" resolvers (to pick one at random -- although perhaps blockchain-based DID methods might have different resolvers...) that the a caller to the implementation can choose? If so, what mechanism is suggested for that choice? If not selecting from multiple resolvers for the same DID Method, the DID in the DID URL being dereferenced specifies the DID method. Is that not sufficient, given that the caller invoked the DID URL dereferencer?

I propose this be expanded to make it clear why this is relevant or remove it.

Comment thread index.html
<li>
<strong>PathHandler Typed Properties</strong>
<p>
If the DID document, DID Document Metadata, or DID Resolution

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The "IF" should include that a Path segment be present in the DID URL for any PathHandler properties be considered in this way. For example, a DID URL being dereferenced that is a bare DID with no parameters and no path should not care about the presence or not of PathHandling properties.

The same change is needed in the flowchart.

Comment thread index.html
<li>
<strong>Document Properties</strong>
<p>
If the DID document contains any properties known to affect

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Less obvious, but with a similar argument from my last comment, I don't think that the mere presence of a property in a DIDDoc or DID Metadata should automatically trigger an impact on DID URL Dereferencing without some sort of trigger in the DID URL. Using the same example as my last comment, if I have DID URL that is bare DID that I'm dereferencing, the fact that there is a DID Linked Resource in the DID Metadata should not impact the result of just returning the DIDDoc.

This does raise the question of serves as a trigger? For path-like things (e.g. Linked Resources, DID Linked Resources, Path services), the path is an obvious. Extension parameters comparable to service are likewise useful triggers.

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Yes, I think this is a good point.

A DID URL that is just a DID without any other trigger, but with a DID document containing properties known to affect dereferencing should IMO dereference to the DID document.

Comment thread index.html
</p>
<ol>
<li>
<strong>Services</strong>

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I think there is a need somewhere in the algorithm for extensions that define a property that is process in the same way that service is used. serviceType is being demoted to an extension AFAIK, but it is the obvious example. Where do you see in the overall algorithm does it gets processed? Likewise I can envision someone wanting to have a linkedResources parameter that is used to identify a specific linked resource in a DID Doc.

How much any of these parameters will be used in practice (including service) is an open question, but I struggle with seeing service being a wholly unique instance of a parameter vs. a member of a category of parameters that might be defined in the future in the spec or (more likely) as extensions.

Comment thread index.html
<li>
<strong>Select Service Endpoint</strong> Pick one of the
service's
<code>serviceEndppoint</code> values. Implementations SHOULD use

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I think having this be normative is too high a bar for implementations. This forces implementations to be stateful, which (AFAIK) they don't otherwise need to be -- remembering the order that they picked each time they process this particular DID URL (assuming it hasn't been updated over time). My preference is that any statement on this be non-normative. If we do want to be normative, then I suggest that we say that end point be chosen at random.

Comment thread index.html
<code><pre>RetrievalPath = /didimages/image.png</pre></code>
</li>
<li>
<strong>Construct Retrieval URLs</strong> Replace the path part

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I think this should reference the RFC 3986 processing. First because there is a lot of nuance of "replacing the path part...", and second and most importantly, implementers will almost certainly use URL handling libraries (e.g. Python's https://docs.python.org/3/library/urllib.html) that implement RFC 3986 handling. Likewise if there is a WhatWG URL reference, that could be used as well -- as I recall we have a To Do for that.

Comment thread index.html
<section id="pathHandler-path-matching-algorithm-provisional">
<h2>PathHandler Path Matching Algorithm</h2>
<p>
When a DID Document contains one or more objects with a type of

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Per earlier comment -- "When a DID Document contains and path and one or more..."

Comment thread index.html
<section id="return-did-document-dereferencing-algorithm-provisional">
<h2>Return DID Document Handling Strategy</h2>
<p>
When invoking this handler, simply return the DID Document retrieved

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

There are extensions currently defined that I think (although arguable) are intended to be processed at this time. Notably:

  • signedIetfJsonPatch (or perhaps at DID Resolution time?)
  • transformKeys

Should there be a place for extensions to impact the resulting DIDDoc at this point in the algorithm?

@swcurran

swcurran commented Jul 6, 2026

Copy link
Copy Markdown
Collaborator

A comment about the ReSpec style of this PR. In the majority of the document, we've used the style of tags being indented to their appropriate level, and the text being left justified starting in column 1 (or column 0 if you think that way...). This PR should be updated at some point to match that formatting. Given the comments that are now associated with line numbers I suspect it is too late now for that, but it should be done as soon as the PR is merged.

@swcurran

swcurran commented Jul 7, 2026

Copy link
Copy Markdown
Collaborator

One other thing to mention from my various closed PRs. In the one that was only about adding a standard way for DID URL Path Handling, a part of the PR added the "PathService" service type to the specification, defining how that works. This PR does not include that. The request from (at least a part of) the Working Group was to standardize as much of the path handling in the DID Resolution spec as possible. As such, I think we should be considering adding that into either this PR or a follow on.

@w3cbot

w3cbot commented Jul 8, 2026

Copy link
Copy Markdown

This was discussed during the #did meeting on 08 July 2026.

View the transcript

w3c/did-resolution#344

Will Abramson: So it's issue 3, 4, I mean, PR 3, 4, 4, sorry...
… Yeah, I don't know how it's best to go to this. I don't know, Joe, if you have things you want to, like, lead the group through, or we can just go over it. Maybe I can share my screen and we can review the comments. I'm not sure. Or does anybody?

Joe Andrieu: Yeah, I would just… I would just review the comments. I don't… I… Don't have a better way to go through it...

Will Abramson: Good. Uh, excuse me...
… So… this
… You should see my screen, although, also, I'm not looking at the queue, so maybe you could do the queue

Otto Mora: Yeah. Yeah, I got you...

Will Abramson: Yeah, so this is… let me look at the preview, um...
… First, maybe we can just ask, has everybody had a chance to review this algorithm from Joe? Or are there folks who still haven't had a look at the spec text that Joe's proposing yet?

Manu Sporny: I've glanced at it briefly, but have not had a chance to look at it in detail...

TallTed // Ted (he/him) Thibodeau Jr (OpenLinkSw.com): I have definitely not reviewed it, but that's not a blocker...

Will Abramson: Yeah, well, that's fine, but I wonder if maybe it is worth, you know, you just sort of walking through the steps. I mean, I can have a go, but you probably know a bit more intimately than me...

Joe Andrieu: Uh, through the content? Yeah, I could walk… yeah, we could do that. Um...

Will Abramson: It's here, right? Section 365. Oh, it's actually the whole...

Joe Andrieu: Well, go ahead and go up to the first one because those are also edits. Um...
… There was a there was a different style than what I had written before. So and there were some elements missing about prepare for resolution. So those are changes
… For example, and prepare for resolution, we validate
… And that did URL. Then we select a resolver. So that's something that hadn't been in the current documentation. And then remove the fragment. That's currently what we do. Um

Will Abramson: Yeah, so this will have to be updated, right, to be just a DID, I think...
… Yep, yep. Yeah, yeah, yeah
… Right. Yeah, yeah, yeah, sure

Joe Andrieu: Correct. Based on current, like, right, so these have all been things that have happened since IPR. Um, I'll also have to pull in the at-risk markers, right? So there's… there are some just logistical edits that...
… if if if people have easy edits, I'm happy to take them as suggestions. But just yes, I'm aware that those those things need to be updated. But the the main difference in that 1st one is explicitly saying, selecting a resolver is part of that process. Um, but
… And then the second one is you resolve the did by calling, and interpreting the response repeat as necessary. The reason I know there's a comment from, Stephen about why are we repeating? And that's because for some algorithms
… Um, for some DID methods, we know that, in fact, it is an iterative process. Um, DIDBCCR2 is this way. Um
… Because you may not know what data is needed to resolve until you're doing the resolution and you may not know all of it until you go through the entire process. So you have to look at the response and resolve and see if there's a next step or not. And if there is a next step, you have to keep going. Keep going on it
… Um, so

Will Abramson: Yep, great...

Joe Andrieu: happy to get changes to make that clearer if the language is unclear, but I just wanted to speak to the question Steven had, um, even though he's not here, we'll...
… I sort of socialize why that difference is there
… Okay, determined handling strategy. So this was updated to address
… What I think our current consensus might be, there are issues around query parameters, and so I do not include that here. But I embrace the group having a conversation about how do we want to deal with query parameters in the DID URL
… and whether or not they should be how they should affect determining the handling strategy beyond services. So the the 1st one and I wish we could see the diagram. Um

Will Abramson: Uh… Or maybe I can...

Joe Andrieu: I put those in for you, Ted. Uh, you had mentioned how useful that is, and I don't disagree as a requirements guy. I'm like, hey, I've got tools that could make that...

Will Abramson: This one, uh, this one, this one. Uh...

Joe Andrieu: So that's the easy one This is the more complicated one but, there is an effort to try and give a visual explanation of what I'm about to walk through...

Will Abramson: Well, maybe I can...

TallTed // Ted (he/him) Thibodeau Jr (OpenLinkSw.com): Yeah, I appreciate the effort. I'm just looking at these quickly and noticing contrast definitely needs to be checked with the tool. I'm pretty sure that the top two colors will want white text if they're going to stay those colors. The other thing is these seem to have colors...
… That are meant to be interpreted as something, and that being the only difference, and that's… That cool

Joe Andrieu: They only indicate for the eye to follow that line...

TallTed // Ted (he/him) Thibodeau Jr (OpenLinkSw.com): Okay...

Joe Andrieu: There's no semantic difference...
… So I… and I appreciate the accessibility point, and… Let me… yeah, let me see if I can recolor
… They're intended to be pastels, but I agree. We should check it with a tool

Will Abramson: Yep...

TallTed // Ted (he/him) Thibodeau Jr (OpenLinkSw.com): We don't have to hammer on that right now. It's just a thing to have in mind...

Joe Andrieu: Yep, I appreciate that...

Will Abramson: I mean, is it worth going over the algorithm through this diagram, or do you want to go back to the text?...

Joe Andrieu: Sure. This may be easier. So first of all...
… Um we check if there's a service query And if there is, that's what we use. Um so if there's multiple service parameters then that exits to an error
… So we produce some kind of error, and I just have raise errors or the exit for any of these that hit an error
… And then second, as you use a service selection algorithm
… Um
… And that basically says match to the service algorithm that has the same ID as the value of the parameter, right? It's a very simple algorithm. Um, and
… And if that selection algorithm has a handler strategy. Um, then we use it
… If it does not, I created a default service handler strategy, which deserves debate and input
… It was an attempt to say, Hey, we've got a bunch of services out there that didn't realize that they should be defining a handler strategy. Btcr. 2 is one of them. And so if someone attempts to access a service that's in a Btcr. 2. That's really meant to just be a beacon
… and not be dereferenced, well, then what do we do? And I… so we came up with a strategy, we can look at that strategy, and argue about it if we like. Um, but that's… both of those, then, you're done with the service, uh, loop
… So if there isn't a service query parameter, then we look to see if there's a path handler. And that basically means seeing if there are any objects in the did document, and I believe we should include the two metadata documents
… to look, and I think that's what's in the text, um, to see if any of them have a type of path handler. So if they have a type of path handler, they're saying, yes, we are a path handler. Um… And then we use the path value in the path handler
… Um, to pick one of them. Um, and hopefully there's only one. If there are two, that creates an error. Um
… We can talk about that path handling path matching algorithm, but it was designed to hopefully work with how, Steven was thinking about it as well
… If there are no multiples, then does the path handler have a type definition? That would explain how you do the path handling. For example, is it a path handler and a path service? Then you
… would use the past service handling strategy. Um, if it doesn't have a secondary type that explains how you would do the handling. Then, we raise an error
… Um, because we… although we have identified it as a path handler, it didn't identify how you actually do the handling
… But if it does, we set the handler to that and that gets us to the inbox there. Sure. No, no

Will Abramson: Is it a good time? I have a question, but maybe we'll let you go through it all. I don't know what's best...

Joe Andrieu: By all means...

Will Abramson: Yeah, so my question is really… I think it was Steven that raised this in the issues, um… in the comments, rather, and he's saying… so say we go… like, we just… we have a DID URL, but really that DID URL is just a DID, right? We're starting this DID URL...
… did your LD referencing process, and the DID document that's returned from Resolve contains a path handler

Joe Andrieu: Yep...

Will Abramson: uh, like, contains this… a service, for example, with a path handler type. What… what should happen?...
… Right

Joe Andrieu: Um, so there is a path handler. You would use a path handler, path matching algorithm...
… And if there is a path handler that matches on an empty path, you would use that path handler object

Will Abramson: Okay...

Joe Andrieu: To continue, and if that path handler object has a handler strategy. Um, then you would use that...

Will Abramson: Yep. Right, but if there isn't a match...
… it's gonna be an error. Like, what I'm saying is, like, that… in that case, or I think what Steven was really saying, in that case, there is no way for that DID to be referenced to just a DID document
… Doesn't seem like it

Joe Andrieu: Um...
… Yeah, that's an interesting, uh, point, and uh… Actually, in my brain, I had… I stopped
… Going through the algorithm to see if he might be wrong, because the easier solution may simply be to identify where, when we raise an error
… Maybe we should always default back to the did documents path handler
… I mean, uh, handler strategy

Will Abramson: Yeah, so, I mean, in this case, it would be effectively if you don't manage to identify a path handler. Um...
… You would fall back to the document, right?

Joe Andrieu: Right. And that may be the right strategy for all of them. So maybe it's raise error and then go to use default document strategy. Maybe that's a better… Strategy...

Will Abramson: uh...
… Yep

Joe Andrieu: Right now, I'm thinking it is better, like, because what else do you do? You raise an error, and then you end, and then you got...

Will Abramson: Yeah...

Joe Andrieu: um...

Will Abramson: Yeah, I agree, actually, because you're gonna have a DID document when you get here, aren't you. So, yeah...

Joe Andrieu: Right...

Will Abramson: Uh, the other question...

Joe Andrieu: So if you fail any of the fancy dereferencing, I think it probably is appropriate. I want to think through that from a security perspective or unexpected consequences, but it feels right on first blush to me...

Will Abramson: Yeah, the other question I had is this path handling matching? Is… is this… like, say, like… is this, like, the… this is the largest path, right? So, like, say if I… I am just this slash path...
… and then I… there's a path service and slash service, or whatever it is, like, would that just match? Because that's the largest… path, like, it's one, and it's the largest one. I don't know

Joe Andrieu: If, if you had, um...

Will Abramson: It's interesting...

Joe Andrieu: Uh, a URL with a slash as the path, and you had a service operative slash service? Um, in the current algorithm, that would match...
… Um, I'm not sure it should
… Um, but that was my interpretation of… of how I thought Steven was trying to do it. Um, I'm happy to revise if we think there's a… if it shouldn't… if it can't match the whole thing

Will Abramson: Great, thanks...

Joe Andrieu: Um, should it match at all, is a reasonable question. Um...
… I'm pretty sure what, um… Steven was imagining… is that you… in your PATH service, you

Will Abramson: Hmm. Okay...

Joe Andrieu: Um, are saying, hey, uh, this… this token is like a folder. And everything below this folder is accessible via this path service...
… Right, so if you have slash images, and slash images is your path in the service object
… then, you know, pathImages slash avatar.png is legitimate, and it would use that service handler, unless there's a specific override for a path handler whose path is services slash avatar.png. Um, but if it's an incomplete match. Maybe that should not be a match

Will Abramson: We'll have something to think through. um...
… So again, I'm not managing the queue auto, so if there are other people who have comments, otherwise

Joe Andrieu: Okay...

Will Abramson: Uh, Joe, just keep going, I guess...

Otto Mora: Uh, I see Ted. I see Ted in the queue...

TallTed // Ted (he/him) Thibodeau Jr (OpenLinkSw.com): Oh, that was old...

Joe Andrieu: Okay...

TallTed // Ted (he/him) Thibodeau Jr (OpenLinkSw.com): Sorry...

Otto Mora: I don't know if it was… that was… oh, okay...
… Okay

Joe Andrieu: So those are the two sort of advocated strategies. I want to be clear that the rest is all fallback. Um...
… For then the next two are explicitly for legacy reasons So are there any document properties that define a handling strategy?
… Such as linked resources. And if there are, then you have to process them. And if there are multiple, then we treat that as an error
… That's sad, but I'm not sure how better to do that other than to put it into some sort of matching algorithm, but we don't know what those strategies are matching on. That's sort of the problem with the legacies. We don't know that they have a path property that we could plug into the path. Matching. Um
… But if there are no multiple effective properties, then you use that defined by the property. So if someone has linked resources, then you should go use the linked resources handler. And if you don't know what that is, that's going to be an error. But the handler is. Uh, should be the linked resource handler

Will Abramson: And just to clarify, multiple affecting properties would be like, I have a DID document with, like, linked resources as a property, and linked objects as a property, right? Like, two separate named properties that...
… I know as a dereferencer both affect dereferencing in different ways
… Is that correct?

Joe Andrieu: That's right. And so, you know, if we think about did linked resources and linked resources...
… Um, this is basically saying, if you mix them, we're gonna error out. Because
… Those two features were independently developed, and it's… it's not clear to me even today which one you would… Try to apply
… I mean, theoretically, you would do some sort of
… Uh… secondary salience question
… For example, with linked resources. We do have a path property. So you could say, hey, if that path matches. That's part of the algorithm. Um
… But I don't know an easy way to bubble that up. Um
… And I don't know for linked resources if it has a similar anchor. In other words, is there a way in did link resources to say, hey I do have a did link resource object but does it apply to this did URL? I don't know if anyone can speak to that
… Um
… But we could potentially put into this algorithm that the
… We are actually, if we find properties, we then check to see if those properties apply. Then we do the test on multiple affecting properties
… Because at least with linked resources, you can know if it applies or not
… So I think that is a constructive addition to this
… So a simple step in there between those two yellow diamonds, that is, add a check for saliency. And I might try and find better language when we write that up. But hopefully that's clear to the group that we're talking with right now
… All right, moving on to the green. Metadata properties. Is checked after did document properties. If the group
… So, we could merge this with the one above it, and say, find any properties in the documents metadocu… metadata and treat them as a single bundle

Will Abramson: Right, because at the moment, this is kind of having a hierarchy, a little bit...

Joe Andrieu: I guess edit...
… That's right. And what was important to me was to have a hierarchy. Um

Will Abramson: Yep...

Joe Andrieu: But I don't...
… I don't know that that's a distinction. Like, I do… I very much want service
… to be a get out of this process. mechanism

Otto Mora: Mm-hmm...

Joe Andrieu: Uh...

Otto Mora: I do see Manuel on the queue...

Joe Andrieu: But I'm curious if people agree that we want to elevate the document properties above metadata document properties. Or should we revise this to put those together? Because they're basically both the same. Um, you know… You've got some properties. Um… do we have multiple properties? Then either use the handler if we have a single

property, or we use… or we do an error...

Manu Sporny: Yeah, just because you asked for an opinion, Joe. It does feel like...

Will Abramson: Yeah, that's interesting...

Manu Sporny: the DID method specific handling strategy might need to take, at least to me, gut says it's more important than the metadata-based one, but I could easily see someone, you know, arguing the opposite...

Joe Andrieu: Oh, interesting. The blue one that I haven't gotten to yet, you think should go before...

Manu Sporny: Yeah, because, I mean, like, it feels like metadata is just stuffing the handling strategy into the kind of, like, you know, deepest, darkest hole in all the choices...

<ottomorac> +1 to the diagram being very helpful

Manu Sporny: Um, but I can see how someone would be like, but no, that's exactly, you know, where it should go, and that's, you know, and, you know, we did that so it doesn't get in the way of anything else. I don't know, there's so many different ways that, you know, this could be done. Um
… I don't think it really matters, so it's not a strong opinion. I mean, the other thing that I was, you know, thinking about… so the diagram's great, thank you very much, Joe, for doing the diagram, thank you, Ted, for suggesting we do it. This is so much clearer than trying to, like, you know, wander through
… tons of text. It's much easier to get a mental model on what's going on with this
… Um, I do have a question on, like, you know, which parts of this, Joe, do you think Marcus or Steven would disagree with? Um, I know we've got a lot of comments to kind of take a look at there. Um, the other concern I have is, you know, folks from the TAG, you know, maybe they look at this and they're like, this is really complicated. Like,

can't you make it simpler?
… And I think the response to that is, like, we are documenting reality. We would all prefer something simpler than this, but this is what, you know, the hundreds of DID methods that have been registered, you know, taking a survey from all of them, this is what we think works for. All of them. Um
… So it's very much the HTML5 based. approach to spec development, which is reflect reality no matter how horrible and ugly it is, versus the XHTML2-based approach, which was try to come up with something that is, you know, fairly theoretically pure, but does not necessarily reflect what's happening out there on the. Uh, on the… on the web.

Um… Just some thoughts. That's it

Joe Andrieu: Let me ask Amanda, you suggested maybe putting the DID method, which is the last one we didn't quite get to, before the green one. Um, yeah...
… So do you like then the hierarchy that separates the did document properties from the metadata document?
… You know, I'm just double checking my bias because, you know, that happens, our own experiences and whatever. This does prioritize linked resources over did linked resources, but that's not my intention
… Um, it also prioritizes the new path handling path service stuff above both of those, right? So I think we are making some priority choices. Um, and I was just looking for some feedback as to whether or not, am I just following my bias, or does that feel like, in fact

Manu Sporny: Don't know if I understood the question. My gut says yes, uh, for the question you asked, but I'm afraid I'm misinterpreting the question you're asking. Yes, ma'am...

Joe Andrieu: You know, going from the more concrete to the more abstract...
… Which is what it feels like to me. Like, there's always did document stuff. Um, did resolution may or may not have interesting things in metadata

Manu Sporny: Mm-hmm, yes...

Joe Andrieu: Um...
… So many processors for dereferencing will never look at the resolution metadata

Manu Sporny: Mm-hmm, yes...

Joe Andrieu: Um, so that's… that's how I came up with the hierarchy. I was just looking for feedback to… to check bi...

Manu Sporny: Yeah, I mean, I feel like, you know, if someone explicitly puts something in the DID document, or they explicitly choose a DID method, a specific DID method, they're expecting...
… those things to take priority, right? Like, I don't know if someone, you know, take two different approaches. If one of them is, like, you're gonna end up using stuff in the, you know, result, you know, metadata
… versus something that someone explicitly put in their DID document, I would expect the person that put that thing explicitly in their DID document would want that thing to take priority over
… Some other, you know, um, things that might be kind of… fairly hidden um
… If that makes sense

Joe Andrieu: Yeah, it does make sense. So a principle of visibility here as a rubric to sort of evaluate. What should we look at first?...

Manu Sporny: That's right, and individual choice, meaning, like, I picked this… me, the human, picked this DID method… may have picked this DID method because I really liked the way it worked, and I have said something very explicit about what I want to happen...
… I don't want something else to, like, come in and, like, override that for some reason
… as the general guiding principle. Like, I mean, there may be good reasons that the metadata overrides or did resolution result
… metadata overrides, you know, what the DID method does, but that, to me, feels backwards. We're trying to create technologies to empower individuals and let the individual state explicitly, this is what I want to happen, and it feels like if something that they don't quite see. comes in and gets in there, they might not like that. I know I

wouldn't… You know, like that

Joe Andrieu: Yeah. Interesting. I I agree. So I like that change...
… I invite folks to chime in if they don't

TallTed // Ted (he/him) Thibodeau Jr (OpenLinkSw.com): Yeah, um...
… Sorry

Joe Andrieu: One note of that, Manu. Sorry, I heard you, Ted, but I wasn't quite done. The, uh...
… There's an interesting sort of attack vector in that… in the current diagram that you just spoke to, Manu, and I want to both speak to it and ameliorate it a little bit, which is that we're trusting a resolver
… To resolve that did method appropriately. So on some level, uh, if we chose a did method, then the resolver should be applying the metadata correctly for that did method. Like, we have to trust them to do that
… Um, but if they were to start putting weird stuff in, then, you know
… Yes, rather, the… the
… Metadata and resolution could be an attack vector
… But I'm ameliorating that because, well, so could the DID document. Like, the resolver themselves could manipulate the whole thing if they were a bad actor. Um
… But it is an interesting challenge. I think the visibility feels like a tighter rubric. Did the users who choose this understand what the consequences were?
… And I'm done. Ted, if you want to chime in

TallTed // Ted (he/him) Thibodeau Jr (OpenLinkSw.com): Uh, yeah, I don't...
… I don't think that we should be doing that much babysitting of people. If they chose the thing, let's assume that they understood what they were doing about it. We can warn them that they should be careful
… But once they do it, let them see what happens. That said. I'm thinking that this
… This last hop out, did method define a method specific handling strategy? That should be the first out
… And it doesn't matter if there's a path handler if the did method says do this
… For instance

Joe Andrieu: How's the queue? Do we have anyone on the que...

Otto Mora: I see, man. Man. I got Manu after that...

Will Abramson: Thank you, Matt...

Manu Sporny: Yeah, I don't agree with that, Ted. I do understand, I think, the philosophy that goes into that, you know, which I can see, right?...
… I think if we do that, though, we, uh, we, we slip down a bad, like, inconsistency path, meaning, like, I think we really want
… this path handler stuff to be the way people use, you know, paths. And if we get, you know, multiple DID methods, potentially a really popular DID method doing something other than that, we fail to achieve that
… kind of unified path handling strategy, uh, approach. That's… that's the only thing I'm concerned about. You know, if we adopt that approach, Ted, then all of a sudden, this… this unified approach
… could fall apart at any point that there's a popular DID method that decides that they want to do something totally different with paths
… That's it

Joe Andrieu: Um, yeah, my take is largely the same as what you just said, Manu. Is it interop, then be...

Otto Mora: Uh, Joe...

Joe Andrieu: Makes us starting with, uh… if we put the DID method bit first. then...
… uh, we're breaking interop across DID methods. Um, we're inviting a broken interop across DID methods. Um, but I think there's also another interesting challenge, which is that. If I choose a did method, and I have the opportunity to impact the did document
… As we expect, most controllers are going to be able to add things to a DID document independent of which DID method, although we know some DID methods simply that's not possible. So there could also be DID methods that make it procedurally not possible or restrict what you can put in a DID document
… But I could put in a linked resource property or a path service property in my DID document that's a DID WebVH or a DID BTCR or a DID whatever, and that gives me interoperability regardless of which particular identification strategy I want to use
… Um so I think it's really valuable that we have these features in the did document that the the controller of the did document can edit and manage
… Um, and I… I wouldn't like that to take a back seat to the scenario where perhaps someone says, oh, it's… it's a… it's a did checked, uh
… um, method, and I understand they use did-linked resources. And so, they stop looking at any other path handlers, they don't look at leaked resources, they don't look at any other data, they're just going on the presumption that because the checked guys developed did-linked resources hand-in-hand with did-checked

Otto Mora: Uh, Will?...

Joe Andrieu: that that is the method handler for all DID checked, uh, DID URLs...

Will Abramson: Uh, yeah, I just wanted to say, like, I completely… I mean, I guess tear hat on off, but I completely agree with what Joe and Manu just said, right? Like, the point… we're talking about the client here who has executed resolution. Like, resolution...
… And the resolver should be the part that handles the DID method-specific stuff, in my view. And they get back this DID document. The DID document should be the point of interoperability that the client has to deal with and handle, in my view. And absolutely, it is right. Like, people
… controllers of DID documents can put whatever they want into that DID document, and obviously, there's some stuff that DID core defines that they expect everybody to be able to understand, and maybe over time, that set of things could grow, but either way
… Like, it is the DID document and the things in there that should be driving, I think, this process. Because the other caveat here is, like, all of this stuff down here, I think, right, like, is legacy stuff
… that really it's not, are there document properties that define a handling strategy? It's, are there document properties that me, as the client, knows to and understands to define a handling strategy, right? So, like, some clients aren't going to understand some properties, and they're just going to ignore them
… And that's fine, but what we do want to have, like, and I think what Path Handler is trying to get to, is most clients will aim to understand Path Handler, and so most
… controllers of DID documents will know that if they want to use a path, a DID URL path, the best way to do that is to include something with a path handler typed in
… That's the direction I think we want to try and get to. Uh, so yeah

Otto Mora: Uh, Steven?...

Stephen Curran: Um, the only thing I, you know, I've said this a couple of times in the past, and I'm concerned about it, I think that...
… If you use the did checked as an example and the resource is on the ledger of did checked. So I realized links resources can work across or did link resources can work across
… methods, and they give examples of that in the spec of a did web that references a did linked resource that thought check. My concern is that if we don't put it a little higher up in the in this flow chart
… you get in an infinite loop. You have no way of actually resolving a
… a chain-based resource like the checked offers. Maybe that's okay, and we leave it to them to figure out what the out is, but I think if you walk through this process
… with an actual example of a DID-linked resource that is pointing to, that is referencing. Hey. An on-chain resource. Um, which is what
… checked was after you get an infinite loop here, and and you never get to the resource. So that's that's my only concern of of
… the method specific handling. But if if we don't, if we ignore that, I think it's not the end of the world. I'm just raising that

Otto Mora: Joe?...

Joe Andrieu: So I think there's a misinterpretation somewhere, Steven. I don't know if we're talking past each other or one or other of us has misunderstanding. But to my analysis of this flow with the linked resources, if there's no path handler, no service, right? So we fall through to the green, check the metadata...
… Um, we're gonna see a DID-linked resource, and we're gonna use a DID-linked resource handler, which knows how to talk to the checked
… Um, chain. And we're done. That resource handler doesn't give you another DID
… It that handler says, hey, here's how you handle a did link resource, which happens to talk to, check

<ottomorac> q>

Stephen Curran: Okay, if you're comfortable that that couldn't get you there, that's fine. That's what I was raising. If you're comfortable with that, that's fine...

Will Abramson: Um...
… Okay, I mean, I see we're kind of getting to time. Uh, I mean, I think this is really useful to just review it. Steven, I think you maybe came in a little late to get the start. We did briefly touch on, uh, your
… uh, question about what happens when it's, like, a… just a DID of the DID URL, and, like, how does it fall through
… Uh, one idea we floated, we didn't, like, get through it, is that if you get to an error state, maybe that the default is from that error state, you are just returning the DID document

Joe Andrieu: Cool, yeah, I...

Will Abramson: Um, because, right, you have a DID document when you go in here. But anyway, I just wanted to update you on that. I see Joe on the queue, but then I think we can close, uh, and we'll revisit this. Yeah, Joe...

Joe Andrieu: I just had a quick question for Steven, because it came up as we were walking through the algorithm...
… Um, I attempted to write the matching algorithm, uh, aligned with what I understood you were trying to do, but I think I missed an element that came up here, which is… if… if you have the… the path part in the service object is, like, slash images. Um, and the URL is just a slash
… Um, and slash images is the longest one
… Is it your desire that that would hit, or should the whole thing have to hit? And then it's the longest one that in… that has an inclusive hit of the path property, which seems like it's more appropriate, but I happen to write it the other way

Stephen Curran: I couldn't understand that from that description. Sorry. Yes. Okay...

Will Abramson: We can revisit tomorrow. I think it's fine, right?...

Joe Andrieu: Yeah, that's… that's fine. I appreciate it. It was a little too confusing to try and get across in 30 seconds...

Will Abramson: Yeah, so maybe tomorrow, you know, we're going to focus on getting to CRR, then if we have time, we'll revisit this, maybe we can just sort of reorient ourselves in this diagram, and then look at the actual text and the comments against the text, and try and process some of them, make some decisions. Great. Thank you, everybody. See

you tomorrow...

Joe Andrieu: Cool. Thanks...

Otto Mora: Perfect. Thank you...


@swcurran

swcurran commented Jul 9, 2026

Copy link
Copy Markdown
Collaborator

Here is a try at concise description of the “infinite loop” question I raised re: Method Specific dereferencing. Not a big concern, but I thought an example might be worth sharing to see if triggers anything with others in the group.

A DID Linked Resource example from DIDDoc Metadata from a live DID available via the Universal Resolver. This is the basis of the following examples:

"linkedResourceMetadata": [
    {
      "resourceURI": "did:cheqd:testnet:55dbc8bf-fba3-4117-855c-1e0dc1d3bb47/resources/398cee0a-efac-4643-9f4c-74c48c72a14b",
      "resourceCollectionId": "55dbc8bf-fba3-4117-855c-1e0dc1d3bb47",
      "resourceId": "398cee0a-efac-4643-9f4c-74c48c72a14b",
      "resourceName": "Eventbrite Logo",
      "resourceType": "image/png",
      "mediaType": "image/svg+xml",

Example 1: Suppose this DIDDoc metadata is from a did:web DID (as the DID Linked Resources spec describes), and the resourceURI is an HTTP URL.

  • Action: the DID URL Dereferencer calls an HTTP dereferencer with the HTTP URL to retrieve the resource.
  • Note that the DID URL Dereferencer must be using a did:web resolver that “understands” how to find and return DID Doc Metadata containing DID Linked Resources. But that is a separate issue…

Example 2: The metadata is again from a did:web DID, and the resourceURI as it is in the example.

  • Action: the DID URL Dereferencer calls a DID URL dereferencer with the did:cheqd DID URL to retrieve the resource.
  • Note that presumably this results in a new DID URL dereferencing activity — independent of the did:web URL we started with. At minimum, the caller might need to invoke a new resolver that handles did:cheqd.

Example 3: Now the metdata is from a did:cheqd DID and the resourceURI as it is in the example.

  • Action: If we repeat the pattern from the first 2: the DID URL Dereferencer calls a DID URL dereferencer with the did:cheqd DID URL to retrieve the resource and we’re in an infinite loop.
  • Per Joe, and I agree — the DLR definition and implementation must detect and stop the loop. It needs some sort of Method Specific/infinite loop escape.

My reason for raising this is that is to ask, does saying “it’s handled by the handler” work in all cases of a DID URL being the only identifier for a given resource?

I don’t have another example to investigate to this level, so while my sense is that we do need an explicit “DID Method exception” at some point in the algorithm, I’m OK without it. I completely agree that if we do put it into the algorithm, we want a caveat that says — “DON’T USE THIS UNLESS YOU HAVE TO”.

@w3cbot

w3cbot commented Jul 9, 2026

Copy link
Copy Markdown

This was discussed during the #did meeting on 09 July 2026.

View the transcript

w3c/did-resolution#344

Will Abramson: So this is 344, which I'll subtopic, and I think it was great yesterday we kind of oriented ourselves on the diagram that Joe has in this PR. Maybe, Otto, would you mind sharing that again? And we can start from there...

Otto Mora: Yeah, that's a great idea to. Yeah...

Will Abramson: Uh, because I think there's definitely a lot more people on the call today, so maybe it would be good just to kind of skate over that again, and then we can dive into any of the comments that either folks have from the discussion or, uh, that are already in this, uh, as comments. Yeah, I think if you… no, no, I think if your

file's changed, you just want to open, uh, this one. Yeah, just open it at the...

Otto Mora: This guy here. Yeah, absolutely. Yeah, this is a very useful diagram, I agree. And also we should credit Ted for suggesting it, which I think makes a lot of sense...

Will Abramson: Yeah. And, uh, so...
… I mean, Joe, do you want to just walk us through this again? Uh, is that… okay?
… Okay

Joe Andrieu: Um, sure. Um, I was taking a quick note of the highlights of what seemed to be some suggested changes tomorrow...
… I got two written down, but let me go ahead and walk through this, and then I'll note those two changes
… As we go. So this this starts with you are after you've gotten your did documents. So you have the did URL and the did document and the metadata that was returned in those processes. And so the first question is, um
… Is there a service query parameter? So if there is, then we check to see if there are multiple. If there are multiple, that's an error. And so we go to raise error. And the first adjustment to this diagram that I think we have consensus on is that in
… uh, instances of an error, what we should do is return the… the, uh, DID document. Um, and there was a… there was a flow through here that… that Steven identified that… that could mean that
… Um, there's a service query, but it doesn't have the right match, and then we don't know what to do. So, the right thing is, I think, uh, whenever we get to this raise error, we're in fact going to go to the use default document strategy. Um

Will Abramson: Yeah, thanks, Joe. And just quickly to jump in, if anyone has comments throughout this, just jump on the queue, and I guess we can take them as we go, Joe...

Joe Andrieu: Yeah, that'd be great...
… Okay, so if there are not multiple parameters, then you use the service selection algorithm, which we've defined
… And that is basically does the, query parameter match the ID of the service? It's a very simple algorithm. It doesn't have, it's not a best match. It's an identical match. Um

Will Abramson: And I see Steven on the queue. Steven?...

Stephen Curran: Yeah, so this comes back to my comment about...
… Um, is service completely a unique
… parameter? Or is it a category of parameter? And
… If it's a category like service type is similar and it's just saying instead of using ID, I'm going to use type and that's going to identify a single service. Um, that doesn't appear to fit. Here
… what's the what's your thought on that? I've raised that. I raised that question in the comments. So I just wonder what your your feedback was on that, Joe

Will Abramson: Yeah, go for it...

Joe Andrieu: Yeah My understanding was that we agreed that we we didn't have a clear use case, for service type being passed in here...

Stephen Curran: Thank you...

Joe Andrieu: and that we were just going to use an identical service property. Because one of the things that happens with service type is depending on how you get back out of it. You you lose some context. So I believe we talked about that maybe a month ago. And so this is...
… an attempt to implement that and say, what we're talking about is service, not service type, and not any other query parameters. So that… that is a
… a big potential addition here, which is… this is the only query parameter, um, that the left-hand side here, uh, of the flow considers. Um
… uh, we… I think we don't have good support for arbitrary query parameters, and I don't know which ones influence the referencing in a way that we should elevate it up here. Um, but I'm open to. Examples, but this was service, not service type

Will Abramson: I put myself on the queue. I mean, I think this is an interesting one, and I kind of am more aligned with Steven here. I mean, you know, uh...
… query parameters, I think, are a point of extension in the spec, and it's hard to know how those
… query parameters are going to be used and defined. But, I mean, one example that I had was, like, imagine, Joe, that we define a query parameter that's, like, linked resource. And it works exactly the same as service, but it's targeting linked resources with an ID. Ah
… like, I think how I read your… you have a note about this, and I think the note is great to flag that, you know, we need more discussion on this, but it kind of was saying that, you know, like, query parameters that aren't service are, like, legacy, or, like, they're not really in this flow, and I think at the moment, you're right, they're

not in this flow, but the question is whether they should be
… Um
… Uh, because it's, you know, like, people are going to want to define query parameters that do impact dereferencing, and if we don't have support for those, then it's not an extension point anymore, and it's kind of… uh… Yeah, not well supported
… Uh, Steven

Stephen Curran: Yeah, pretty much the same point. It's just that the problem is that there's nowhere anymore in the algorithm that would allow for those, which means extensions now become impossible because there's no place for them...
… And that's what I'm concerned about. What we said about service type was we were going to demote it from being referenced in the spec to being an extension. So it's still

Will Abramson: Thanks. Joe?...

Joe Andrieu: Yeah, I agree. If we want to support queries, I think we should...

Stephen Curran: could exist if someone proposed it as an extension. Will gave another one...
… But there's no place for it to be used now, because it can't. You can't. There's no place in the algorithm for extensions, and that's my concern. If we don't want them, that's okay with me, because, um, I don't have particular use cases for them, but the fact that we have an extensions registration

Joe Andrieu: one of the challenges… my position is we should recommend that people don't do that, um, but of course people are going to do it, and we have a decentralized system. So, the question for me would be, in this flow...

Stephen Curran: system, but now we're not gonna use it. That's… that's the concern...

Joe Andrieu: Where would we handle the fallback to query? Because I do still feel that if you have a service query, I want that to dominate. I think that is a clear and unmitigatable signal. And I think it's important and useful that we do that...
… Followed by our preferred option, which is, have
… for extensibility is define a path handler. uh
… And so those are… that's why that's the first two, and then the rest are fallback. So I would be good with adding, you know, query terms, um, somewhere in that loop. Based on our conversation yesterday. It seems like it should probably happen, um… After
… uh, the DID method check, and before… well, it could be before the DID method check or not, uh, but certainly before the metadata. The… one of the things that we did speak about yesterday
… And I think and it helped a lot with clarifying sort of, a metric for which we might consider this hierarchy, which was about visibility
… Who has visibility to control these different elements? And I think putting something in the DID URL is pretty intentional and pretty visible. So I think that should be elevated above
… Um, save metadata. Um, the DID document is something that the… we expect the controller to be able to control, so that's… that's why it's handled first in the fallback session
… Um, and then Manny made a good case for the DID method being before the metadata, because people select specific DID methods for specific reasons
… Um, and I like that. I thought the visibility distinction between those two allowed us to tease it out. So I think it's… for me, it's, you know, where in that flow would… would we process query parameters? Unfortunately, we don't have a way for query parameters to tell us
… that they, um, should affect the referencing, right? We don't have a way to add a type of path handler to a query property. Um, so those are some of the complexities, but… I'll yield the floor

Will Abramson: Yeah, thanks. I mean, that is the thing, it's very… it's a… it's a complex, because it's this open-ended system that we're trying to, like, leave space for, and, you know, maybe that is… well, that's certainly part of the challenge. I think, you know, to your point, like...
… query parameters don't have a way to signal what they're for. I think all of these… I mean, I get why you want to define service at the top, and that makes sense, right? Because we have defined it in our spec, this is how service works. But I think, for me, the rest of the query parameters
… are, you know, you're the deref… you're doing dereferencing, do you understand these parameters? And it's kind of like, and if you understand them, then
… I almost feel like maybe you should, like, they should get to decide where they fit in this flow, because there is some kind of query parameter that might help me select which path handler to use, like, that kind of, like

Stephen Curran: Thank you...

Will Abramson: like, I don't know if it's separate from the path handling… path matching algorithm, but just like service, would… would potentially allow me to select a path handler in the service while ignoring a path… a path handler. that it's in a linked resource or in a did document property...
… But at the same time, like, you know, I don't really have use cases. I think a lot of us don't, you know, like, maybe we're just arguing over these things, just trying to make it work, and it's something that we can revisit when people come back and tell us that

<Zakim> JoeAndrieu, you wanted to say the client can always do crazy things. what we're talking about a standard way to figure out the dereferencing intention of the DID URL Author and DID Controller

Will Abramson: you know, this isn't working because X, Y, and Z… yeah. I… I don't… I don't have good skin in the game, to say, so… Ciao

Joe Andrieu: Yeah, um...

<ottomorac> +1 lets revisit once we get feedback from DID method authors

Joe Andrieu: I wanted to say that… Did you

Will Abramson: I think I can see it, yeah. Right...

Joe Andrieu: Yeah. Right. So the client can always ignore this flow. I mean, that's just reality. If someone's writing a client and they don't want to go through the algorithm, then fine. There's literally no way we can make them...
… But what we can do is define a coherent and consistent way such that a client who wants to do it the standard way can do it in a way that the did URL author and the did document controller are expecting
… Right? I think that's the important thing, is that the… the person resolving this DID URL, they did not… they… they probably did not create it. I mean, often they do, actually, in our… in… in reality, in the systems we build. Um, but we can't presume that the person who's doing the resolution created the DID URL. It could be an attack

vector, it could be whatever
… Um, and we can't presume that they chose the DID method. Um
… So, in both of those cases. ah

Will Abramson: Thanks, Steven...

Joe Andrieu: Um, what we're… what I was trying to do with this was have a rigorous flow that let there be a deterministic, understandable outcome that's consistent for everyone who wants to play a conformant dereferencing game. And people want to customize their thing, they can be non-standard...

Stephen Curran: Um, I… I agree that it's kind of arbitrary. It is somewhat… there's arguments all over of where to put it. I just want to see it put somewhere, so I would say… you know...
… let's… let's pick a place to put it. I sort of get the argument for. Putting the first two first
… I'm a little mixed on that, but again, just because there's arguments multiple ways, I just want to see it put in somewhere. So that's where I would suggest
… what… what I would suggest, and Joe, just pick a spot that you think is right, and… and include… include it

Will Abramson: Thanks...

Stephen Curran: Yes...

Joe Andrieu: Cool. I'll do that in an x-ray. I've got to update this and then, you know, we'll get more feedback...

Stephen Curran: Yep...

Will Abramson: Yeah, I had a last suggestion, which is maybe slightly separate, or, like, different, is maybe we don't put it, like, concretely in this algorithm, but we just have, like, we could capture it in a note, and we could leave it to the extension to...
… sort of define where they think they should slot in. And then it's… because again, it's really about, like, do you support this extension? If you do, then you're gonna
… do it the way the extension tells you, but if not, you're just going to ignore these query parameters and fall back to these sort of standard defined flow. And then over time, if people develop strong use cases and query justification for standardization. We can integrate them into this. Algorithm? Uh, Joe

Joe Andrieu: Yeah, I really don't agree, Will. I think having the client make up the algorithm is us not defining the algorithm. If we don't tell them that this is where you should check to see if there are any query parameters you understand, then they might check them first...

Will Abramson: Okay. Fine, cool...

Joe Andrieu: They might check them last, and that may create a disconnect between what the DID controller was expecting, or what the DID URL author was expecting...
… Um and so that's…that's what I'm trying to create is an algorithm that can be expected from the people who create the DID URLs choose the DID methods, um and start the process and the the downstream can respect that because they're ordering their decisions in the right way. um… So, I think we just need to put it in here somewhere, and I'.

Yeah, I'll take a stab and get some feedback. Okay, shall I continue? Is there anyone else in the queue?

Will Abramson: Yes, I think so. Nope...

Joe Andrieu: I don't think so. Okay. Um, okay, so that was about, um...
… Whether or not there were multiple service endpoints, and then, if the service that was selected, does it have a handler strategy?
… Um, because lots of our services that we have today didn't know that this was something that they should do. Um
… Uh, so if they don't, then, um, we use a default service handling strategy, um, and I took a stab at defining that, and that is
… De novo, it's all new. It's immature. It can use some feedback. But the idea was to try and do basically what I think most of us expect today. If the… If the service type does have a specific handler strategy, because like it's a path service
… Then we would go use that. You would select that as a handler strategy, and then we would be done

Will Abramson: Uh, maybe I have a quick question on that. Like, what do we, uh… what did we imagine? So, like, set handler strategy end, like, what comes out of this end that would then flow into the next...

Joe Andrieu: So that's that top flow when a service query parameter is in the DID URL...

Will Abramson: Um… by the execution...

Joe Andrieu: Okay...

Will Abramson: Right...

Joe Andrieu: Sure. Oh, that… The… the next execution is invoke the handler...
… So if you know what the handling strategy is and you have a handler for it, then you could do it. You might know the handling strategy and not have a handler. And so you can't invoke it. And so both of those are handled in the invoke the handler. Step

Will Abramson: Okay...

Joe Andrieu: Um, um...

Will Abramson: Yeah, and the handle strategy would say what it needs, right? Like, it'd say, like, I need the… I mean, or is it just going to always get the DID document and the DID resolution result and that sort of thing? Right...

Joe Andrieu: Uh, well, it depends on the handler. Like, the strategy… is, um...
… A conceptual definition, not a piece of software. So you may have a library that handles that strategy, but then you will have a signature and understand what the parameters are to call the function in that library. But how that library defines what you hand off to it
… Will depend on what logic makes sense in terms of, I just want these parts of the DID document or I just want these parts of the DID URL. Or they might want everything. Give me the full DID URL, give me the full DID document. That's an implementation choice in terms of the library. And we're not

Will Abramson: Okay...

Joe Andrieu: in this flow, talking about what library we're using. We're just talking about figuring out which...
… Which approach you should use to get to the next step

Will Abramson: Yeah, that makes sense to me. I see the queue. Steven?...

Stephen Curran: I would slightly… I would say it has access to everything that has been collected to this point...

Joe Andrieu: Yep...

Stephen Curran: And… and that can be important, because things like… you don't… you want to make sure that it has access to the path, if there's a path in it. So if you pick a service type...
… and there's a path in it, but you used a service parameter, you might want to use that. So it should have access to everything

Will Abramson: Uh, okay, uh… I don't know if you want to respond, Joe, but otherwise I'll go to Ot...

Joe Andrieu: Oh, I just think it's up to the library. If… if… if you're passing it off to a library… I mean, I agree with… with the… the...
… general perspective that Steven said, is that the… the referencing clients that's performing this algorithm is presumed to have all the data that's generated during this algorithm, and… and the two steps before

Will Abramson: Uh, Otto?...

Joe Andrieu: But a given library may pick and choose what parameters you want to send to it. And you would have to know that when you read the documentation for the library when you integrate it into your code base...

Otto Mora: Yeah, my thing is, it's a minor, Nate. I think it occurred to me as you were asking a question, like, what does the end state here mean, right? To a naive reader, just an external person that is not as familiar with this, maybe just for readability, like, you could say end, and then, like, a little, like...

Joe Andrieu: So, could you...

Otto Mora: You know, invoke chosen handler, like, little wording here, would...

Joe Andrieu: Whoever's controlling the screen, if you could put up the other diagram?...

Otto Mora: Oh, yeah...

Joe Andrieu: This is one step in another diagram...

Otto Mora: Okay, yeah, yeah. So this other one here?...

Joe Andrieu: Right...
… Right. So we're in determined handling strategy

Otto Mora: Using handovers. Uh-huh...

Will Abramson: Yep...

Joe Andrieu: And so, when you're done with that, you go to 4...
… Right

Otto Mora: Invoke handler. OK. OK, so that'll be there for even before the other diagram gets shown, right? This in the reading continuum, this is first, and then this other diagram is shown later. Is that right? Okay...
… Okay

Joe Andrieu: Correct. If you look at the… I don't know if anyone has a preview of that PR. The immediately preceding section has that outline...

Otto Mora: Okay...

Joe Andrieu: Um, if you go up a little bit further...

Will Abramson: That's not me, it's Satya...

Otto Mora: Yeah...

Will Abramson: uh...

Joe Andrieu: Well a little bit more because we have the first two So that image is here in figure four and it's it's again in text Here are the here are the five steps or six steps whatever it is...

Otto Mora: Got it, got it...

Will Abramson: So just a comment, maybe instead of end, it could be continue? I don't know. I don't mind that, it's fine for me, though...

Otto Mora: Or go to step three or four or five, whatever. I don't know. Could be. Either way...

Joe Andrieu: Could be next step, maybe...

Otto Mora: Yeah...

Joe Andrieu: My concern with the linguistics of that is it, or the semantics of it, it feels like that's saying...
… Determining the handling strategy has a next step that didn't fit on this diagram. But we are done with the determined handling strategy algorithm when we get to that point

Otto Mora: Uh-huh, uh-huh. Right...

Will Abramson: Okay, cool...

Joe Andrieu: Okay. Uh, it's an interesting question. Let me… let's… if… if you still have that concern when we get the next revin, um… Let's talk about it some more...

Otto Mora: Yeah, either. That's really awesome. Yep. No, no, it's good that this is here, though. I I wasn't that wasn't in my radar. So that's good. Yeah. Mm-hmm...

Joe Andrieu: Okay, so that was service. So the next one is really our preferred way for folks to use it in my sense, which is check to see if there's a path handler, which is...
… Specifically looking for objects in the in the did documents or the metadata
… Um, that have a type of path handler. That's how those objects indicate that they are path handlers. Um, and we use a path handling matching algorithm, which, um… oh, that's the other update, I think. So current… so the path handling algorithm. Um… was an attempt to get a simplified way to do what we were doing before, Steven, that didn't

sort of entangle the 3986. Um, complexities, um
… Uh, I think it's not quite right
… Because I think it matches right now on the longest match, even if it's not a complete match
… I uh, uh so we'll pointed this out yesterday If if…if we have in the did URL, a path that is simply a slash
… And we have a path property and a path handler that is slash images. That I think the current text would match on that
… Um, but I think the right answer is, um, the entire path must be matched
… And if there are more than one, then the longest one is selected. And so I need to update that. And, you know, Steven, if you want to correct me on that, this is a good time. Otherwise, I'll just keep going on
… So you find the of the path handler. Sure

Will Abramson: I'll see when it's on cue...

Stephen Curran: One second, Joe. One second, Joe. The bigger one I'm concerned, I have to look at the details of what you got again to quite get what, but this, the condition here should be, is there a path? And a cop handler. Um...
… Uh, and… and path handler objects
… So, um, I just want to say the first, uh
… Question mark should say, is there a path in the did URL?
… Because you can't you don't want to go down this path at all if there's no path
… Yes

Joe Andrieu: Yep. I think I think you're right. Unless someone else chimes in, I I think that's a clean update. So it should be, um, is there a service query? No. Is there a path? If there's a yes, is there a path handler?...

Stephen Curran: Yeah, exactly. Yep...

Joe Andrieu: Okay...
… Right. Do we… do we have a default thing that we do? I guess they're… they're

Stephen Curran: Or or just in that same box that that both conditions have to apply...
… Yeah, either way

Joe Andrieu: The path handler algorithm could handle having the default. So if we want to figure that out, I think we can...
… Well, I don't know what we do, so what if there's no path handler?

Stephen Curran: Yeah, concern would be… the concern would be if you… if you have a DID URL that is a bare DID...
… no path, no parameters, you… you want to fall through this, right? You don't want to go down this

Joe Andrieu: Right. No, I'm actually… I meant to probe on a slightly different side of it, which is, if we have a path, but no path handler...

Stephen Curran: Okay...

Joe Andrieu: Is there something intelligent that we can do? I'm not sure that there is. Um...

Stephen Curran: I don't think there is. Yeah, I don't think there is...

Will Abramson: Yeah, uh, I guess I'll put myself on the queue, but I was gonna, uh, say, if it has a path and no path handler, then I think you fall through to these fallback options, and some of those fallback options, if you understand them, might still have path matching in play, right?...

Stephen Curran: Right. Yes...

Joe Andrieu: Yes, that is… that is correct...

Stephen Curran: Yeah...

Joe Andrieu: Um, and that's where a linked resource that's, you know, of the way that Sean Conway's deployed today. That's where that would get caught...
… So, their current, you know, VCs don't have the term path handler anywhere in them. Um… But they do have pads
… Um, so the path would be processed when you pick up the did document property in the next row. So I think that's right. Well

Will Abramson: Mmhm...

Joe Andrieu: Um, okay, so I think we were there on path handling, path matching, algorithm...
… and then are there multiple matches? If there are, then we raise an error, and you know that's gonna say, return the did document so the dereferencing client will know. Hey? There's an error, and they will have all the information they need to to figure out what they might do instead, and what they might report to the user
… And then if you have a path handler object, you have a question of, does it have a handler definition
… And since this is a new architecture, I think if it does not, we should raise an error, um, as opposed to have a default
… But if it does, like path service, then we would set the handler to path service and we would end this stage of the algorithm
… Okay, giving a pause for people to chime in. The next item is, so we've gone through the two sort of advocated approaches, in my opinion, like I think we want to advocate this is how you should do it. The first of the legacy is, well, are there
… Are there document properties? In the did documents. That affect a handling strategy. So linked resources is one of these. People who want to support linked resources would have to know about it
… Um, but that's sort of the necessary loop for all these legacy extensions. Um, so if there is an object, then, um
… uh, are there multiple properties that, uh, that, um, are implicated? And again, we say, hey, if there are multiples, then it's just an error somewhere. Um, but if there's not, then use the property, um
… the handling strategy for that property. And in this case, I believe we can be guaranteed that we know the handler strategy, because the reason we're picking it is because that property has a handling strategy

Will Abramson: That's right. Thanks, Joe. I see Stephen. Yeah...

Stephen Curran: Yeah, so I added a comment on this one that there still needs to be some sort of trigger...

Joe Andrieu: So we set the handler and we're done...

Stephen Curran: Um, for...

Joe Andrieu: See Steven on the queue?...

Stephen Curran: why you would go use one of the objects or an object in there. You can't. It can't just be its existence is good enough to take this path...
… Um, there needs to be some sort of trigger in the URL that would cause you to do that, so I think this is the dangerous one to do
… As you say, if it exists, use it because that doesn't that means that there's no way to pass a bare did to a did URL dereference server
… that has one of these things in it and get back the did doc, which is what I would hope would happen

Will Abramson: Yeah, thanks, Stephen. Joe?...

Joe Andrieu: So, um, I would oppose that quite a bit, um, Steven. I think that this is deployed in the field. We have these properties. They are in our extensions registry. And, uh...
… You can't tell from the DIV URL if this property is in there

Stephen Curran: No, no, I'm not saying that...

Will Abramson: Yep...

Stephen Curran: All right. Okay. Yep...

Joe Andrieu: And so the distinction at literally at this, hold on, hold on, hold on, Steven. At this stage in the algorithm, you have already checked the service query. You've checked the pathfinder...
… Now you are checking what is in the did document. If there was something in the URL, we could have already used that

Will Abramson: So...

Joe Andrieu: Right. So this is for the case where the URL doesn't have anything in it. That's the point of this line in the algorithm...

Will Abramson: So, I'm on the queue, and I just wanted...

Stephen Curran: But if I have… oh, yeah, go ahead, sir. Yep...

Will Abramson: Sorry, Sarah, I just wanted to add, uh...
… I mean, I kind of agree with Steven here, like, I think one of the test cases that we should have, and should absolutely work through this algorithm, is I am dereferencing a DID. That's it, right? The DID URL is a DID, and that absolutely, in my opinion, no matter what the contents of the DID document is. surely should return a DID document
… Like, I don't see why, like, that just feels weird that

<Zakim> JoeAndrieu, you wanted to say that does work

Will Abramson: Uh, I could not do that, but, I mean, maybe there are good use cases, but… uh… Joe

Joe Andrieu: Yeah, so that's interesting. Actually, that speaks to… Um… Another thing I forgot that we had talked about. So, the, um...
… There's a missing question here
… Um, which also, which happens in all of these properties, um, which is, is there an object that is salient
… to this DID URL, and I think this is directly speaking to… to your point, Steven. Um… The thing is, we don't know
… If the extension has a property
… Um, until we know what that… that extension is. Um, like… Um, linked resources happens to use PATH
… And so, when you fall through this
… And you get to the document property for linked resources. The first thing we're really gonna do is we're gonna do a saliency check to see if the did URL applies to that linked resource object. Um, in fact, you're gonna go through all the linked resource objects and see if it matches to the path. Um, and that step is missing in here

Will Abramson: Um, yeah, thanks, Joe...
… Yeah, I put myself in the queue, kind of, to step up, and, you know, I've seen the time, we're at… we're basically at time, and just on that point, you know, some of the things we discussed yesterday, maybe we've fallen through, like, how do we… how do you think, Joey, best keep track of all the things that we've kind of discussed? I think

it's been a great
… as a group, they're all, you know, very much moving towards alignment in the state of what we want this algorithm to look at. Like, I'm just
… are you, Joe, just tracking these, and then gonna do a rev? Like, sounds like that, maybe, is the way, and then we just review again. Uh

<swcurran> All of the things that I've raised are in comments.

Joe Andrieu: Yeah, well, comments in the issue are great. That's a good anchor for me. I will try to address all of them incorporating what we've talked about here in terms of, you know, what's a consensus resolution of some of the different ones in there. Some of them we haven't talked about, which is fine. Um...
… Uh, and then I do have a list of, of several key things, um, that I do think are consensus that probably aren't an issue. So, um, so I will update that diagram this weekend, and by the time we're talking next week, we can, we'll have a, hopefully an incorporation of most of this feedback


ottomorac and others added 7 commits July 10, 2026 10:02
Co-authored-by: Manu Sporny <msporny@digitalbazaar.com>
Co-authored-by: Manu Sporny <msporny@digitalbazaar.com>
Co-authored-by: Manu Sporny <msporny@digitalbazaar.com>
Co-authored-by: Manu Sporny <msporny@digitalbazaar.com>
Co-authored-by: Manu Sporny <msporny@digitalbazaar.com>
Co-authored-by: Manu Sporny <msporny@digitalbazaar.com>

@peacekeeper peacekeeper left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

-1 to sending path and/or fragment to the resolver, for reasons that have been discussed many times now.

-1 to performing an HTTPS GET on a service endpoint as part of the DID URL deferencing algorithm. This can lead to DoS attacks ("fetch this 100 GB file") and makes some existing use cases impossible, such as redirecting to a service endpoint as part of the HTTPS binding (see #306 (comment)).

-1 to not processing "relativeRef" when handling the "service" parameter.

I think I'm also -0.5 at this point to the whole "path handling objects" idea. This has taken hundreds of comments and many hours of discussion, and it still keeps changing. E.g. I don't really understand how example https://pr-preview.s3.amazonaws.com/LegReq/did-resolution/pull/344.html#example-16 would be processed by a dereferencer. I understand the desire of having a universal path handling framework, but all the proposal I have seen so far feel limiting to me. Keep in mind that things like "PathHandler", "PathService", "linkedResources" can also all be perfectly specified in extensions.

Comment thread index.html
<p>
The Working Group is currently exploring this new
DID URL Dereferencing algorithm, which has a more modular
approach than the previous one, based on or "handling strategies".

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Suggested change
approach than the previous one, based on or "handling strategies".
approach than the previous one, based on our "handling strategies".

@w3cbot

w3cbot commented Jul 16, 2026

Copy link
Copy Markdown

This was discussed during the #did meeting on 16 July 2026.

View the transcript

w3c/did-resolution#344

Otto Mora: That would, effectively put us in CR. Oh, sorry
… I think that was from earlier, maybe. That was from before, right, Will? Yep. Okay

Joe Andrieu: Yeah...

Otto Mora: Yeah. Sorry. So the other topic, yes...
… Did you already referencing algorithms? Uh… this one… Uh

Joe Andrieu: Yeah, so I believe I got that change in, so I believe it's propagated, but we should check it...

Otto Mora: I know that Joe has provided some updates on this one, and then there was another...

Joe Andrieu: And someone look at the preview...

Otto Mora: comment here, uh, most recently from...
… Uh… several folks. Uh
… Yeah, and then also Ted had, uh, had pointed out a few things. Um… I… I don't know. I was just sensitive to the fact that Joe is kind of doing work on the fly right now, but I guess the main point being we will be… addressing some of these other comments, right?

Joe Andrieu: Um, but I updated my branch, which is the source of the PR, and that should update and go through. And I just… I just removed that extra bit about, you know, this is likely to be replaced by, or whatever. Um, so, just at risk for that section...

Otto Mora: Uh, yeah, go ahead, Sean...
… Mm-hmm. Yep

Joe Andrieu: Um...

Otto Mora: That sounds fair. Yeah, if you wanna...

Joe Andrieu: uh...
… We can go do that now. I think that would be useful, but let me let me speak to where we're at with this, PR, the other PR

Otto Mora: You just take, like, the last, uh, 10-15 minutes to...

Will Abramson: Yeah, no, that was what I was just gonna say. Let's do that...

Otto Mora: Look at that...

Joe Andrieu: Um, which is, I have an updated document, um, and the updated document should be in the PR. It doesn't preview well, because PR preview doesn't deal with… with local files like that. Um, but I'm… I'm ready to share it if we want to go through the algorithm...

Will Abramson: Okay...
… I thought we already did one, but I guess we could do

Otto Mora: Uh, yeah, that as well, uh, I see Will...

Will Abramson: Let me check...

Otto Mora: Okay, okay. Which...

Joe Andrieu: And I have I have not updated the text. Because I didn't wanna do that for a third time given that if we have changes to this diagram the check text is gonna have to be updated quite a bit. And my intention is...
… Uh, if this diagram, uh, and this algorithm, uh, gets the group's blessing, then I will update the text, and in updating the text, I will also go through all of those comments. Many of them will be addressed

Otto Mora: Oh, okay, okay. So we will. We… Did the one marking it at risk. I mean, essentially, that's what the proposal said...

<Wip> https://www.w3.org/2026/07/09-did-minutes.html#52bd

Joe Andrieu: Because we've been addressing them in the discussion about the algorithm. I just, given that the algorithm's in flux, there were too many things to potentially go and check off. So that was the order I was planning on doing it is, if we can get some blessing on the diagram, then I'll rewrite the prose for the description of the

algorithm...
… Um, and then I'll double check and make sure that I have addressed and responded to all the comments

Will Abramson: Yep...

Otto Mora: Mm-hmm...

Joe Andrieu: Okay, did we want to get this other PR?...

Otto Mora: Okay...

Joe Andrieu: Accepted...

Will Abramson: Yeah, maybe you can draft something, Otto. I just wanted… I just shared the link to the resolution that we did pass, which was publish the DID resolution specification as a candidate recommendation once PR346 has been merged...

Joe Andrieu: Because I think we need a formal proposal for that...

Will Abramson: I think that...

Otto Mora: Oh, okay, okay, okay. So, if you just give me… go ahead, yeah...

Joe Andrieu: To go to CR, I think. That's my understanding...

Otto Mora: One's 3, 4, 6. Yes...

TallTed // Ted (he/him) Thibodeau Jr (OpenLinkSw.com): Sorry, what's up...

Will Abramson: What's wrong?...

Joe Andrieu: Um, the thing we voted on before was the intention to go to CR, but we didn't have specific spec text. In fact, we have now changed it. So what… technically, what we approved before, um, didn't have a… a formal instantiation for people to have… That's why I think we need a resolution for this particular transition document. Oh.

I just… I just did it wrong...
… Um… I'm sorry, I edited the wrong file
… Um… Who's our most senior? Maybe it's Ted. I don't know

Will Abramson: Mm-hmm, mm...

Joe Andrieu: The, um...
… So I'm a little confused about this transition mechanism, and I was even more confused when I went and looked at some other documents transitions
… Um

Otto Mora: Like this index.html on the root...

Joe Andrieu: My understanding was that in the transitions folder you put all the files needed for that spec to be moved into or be finalized and locked into place...
… Um, and so the index.html… in the CR is not updated with the things that are in the transitions documents

Otto Mora: There...

Joe Andrieu: If that makes any sense. Like, there's now a transitions folder, transitions 2026, CR. That has an index dot HTML, and the other file assets that are needed to render that. Um...

TallTed // Ted (he/him) Thibodeau Jr (OpenLinkSw.com): Yeah, just so it's said, I don't have a clue on this. I have not handled the transition in...

Otto Mora: It's probably our best shot, unless somebody else has any ideas...

TallTed // Ted (he/him) Thibodeau Jr (OpenLinkSw.com): A bunch of years...

Joe Andrieu: Ah...

Otto Mora: Mm-hmm...

Stephen Curran: I think you've gotta update both, right? You need, uh...
… index.html that you updated changed, and then you need to make a snapshot

Joe Andrieu: But the… the root folder is not updated. Like… Correct. And so what I… the error I just made is I tried to do this quick change for the at-risk stuff...
… As I updated the index.html at the root and not in the transitions. That was, I mean, I can go fix that right now, but it did raise this question that I had about, am I doing this right?

Stephen Curran: Which is going to use the index.html as source...

Joe Andrieu: Um, and I think I am, but I don't know if anyone has more experience with this...

Stephen Curran: I think… I'm assuming that's the process. I don't know any of the details, I don't know how you created it. I highlighted that. the file in the snapshot is double the size of the index.html, and I assume that's because of… there's some process you ran on it to create it. Is that right?...

Joe Andrieu: Manu has left already, and I think I would make him answer the question. Sure. OK. Fair enough. Thanks. Um...

Otto Mora: Oh...

Joe Andrieu: However, if I go and update the correct document, then I think, we would all be good...

Stephen Curran: Right. Okay...

Joe Andrieu: Um… Um, that is probably correct. The process, I think, that did that is the export. So...

Stephen Curran: See, so this is the tricky part, is you've got to get that into the index.html so that you can then do the export, right? Which is why I'm not sure you can do it all in one… in one PR...

Joe Andrieu: You, in github.io, whenever you have that respec little pill up in the right-hand corner, um, you can click on that, and you export, and it does some pre-processing of the live rendered page...
… And I'm not sure what's happening there, but that's probably where the doubling happened. Um, uh
… So, while we could do it all in one PR, but the process I was anticipating being okay was to get approval on this

Stephen Curran: Okay. Hmm. Okay...

Joe Andrieu: Um, and then I think it's an editorial matter to update. what's in root to reflect what the snapshot was...

Otto Mora: Okay...
… But strangely, so, the part that really confuses me right now, between what you said, like, I see the diff here, where you're effectively doing what Marcus… Uh, was, uh, talking about
… But… What else is not being… I mean, it seems to be that if we merge this, it should be fine

Joe Andrieu: Yes, but look at crindex.html, and it doesn't have it yet. Yes. My understanding is that snapshot in the transitions...

Will Abramson: Mm-hmm...

Joe Andrieu: is what the CR is...

Will Abramson: Yeah, I guess I put myself on the queue to say, like, I mean...
… I'm also not sure if we should be doing it the way Steven is kind of suggesting. I don't know, I mean, maybe it is fine, but

Otto Mora: At least that's my interpretation of this. Oh, the sub...

Joe Andrieu: The rest is still our working repo. Index.html is our working repository. The snapshot is saying this is what we are asking to go into CR...

Will Abramson: It feels like the more normal way is, like, you don't edit, you shouldn't be hand-editing these files in the transition folder at all, and they should just be a snapshot of a published. Back...

Otto Mora: Ahhh… Yes. Mm-hmm. Yes...

Will Abramson: I know this is, uh… a hack, and maybe it's fine, but I don't know if it's some processes, right, that… We might be not understanding and messing up in the process...

Otto Mora: Oh...

Joe Andrieu: Okay. For my part in this quagmire, that is part of the conversation today. I did just update what is now in the transitions index dot HTML...
… Um… So that should bubble up to the PR. And now the snapshot has what we just negotiated with Marcus as to how we can as a group move forward. And so I think we can approve this snapshot for CR

Otto Mora: Go ahead...

Will Abramson: Oh, yeah, I think that was from before, actually, but I do have a comment, which is just… so, just to ask...

Joe Andrieu: Um, and then we… you and me, Steven, I'll… I mean, I'll do it realistically, but the editors can now take it as an editorial to update, um, the repos. Uh, to match the snapshot...

Will Abramson: Do we think there is a proposal that we should pass that is transitioned to VR, to CR? I'm pointing out this. tax...

Joe Andrieu: Which would include updating the version and some other things. Um, but I am still worried about the Echidna stuff as well...

Otto Mora: That's it. 3, 4, 8...

Joe Andrieu: Uh, so I'll follow up with, um, PA about that...

Will Abramson: 58348...

Otto Mora: Okay...
… Yeah, that we can do
… Um
… I just saw one. Okay

Joe Andrieu: I see you did jump on the queue, Will...

Otto Mora: Okay, so...
… It would be
… Um
… Publish the TID resolution, specifications, candidate wants PR number 348. has been merged

Joe Andrieu: Yes. Yeah, I think that would be good to do...

Otto Mora: Yeah, include the one too...
… Oh, okay

Joe Andrieu: Uh, I just drafted something real quick, and I moded it. Um...

Otto Mora: Personally...
… Yeah, that's fine too, right? No problem

<ottomorac> Proposal: Accept PR#348 and advance the snapshot in /transitions/2026/CR to candidate recommendation

Otto Mora: Uh, okay. So
… Personal. Please vote

<Wip> +1

<JoeAndrieu> +1

<markus_sabadello> +1

<JennieM> +1

<swcurran> +1

Otto Mora: Okay

<TallTed> +1

<smccown> +1

RESOLUTION: Accept PR#348 and advance the snapshot in /transitions/2026/CR to candidate recommendation

Otto Mora: Yep, that's it. Well, everybody voted plus one
… Yep. Okay, cool, so… uh, results
… Uh, yeah, so that's… that makes it formal. Ahm. And then, yeah, we just gotta… Get that down
… Let's start. Let's change. Done
… So let's
… If there's anything else, I guess next week we might continue with, uh
… Ah
… The, uh, the 344, which is the, uh… the resolution algorithm in more detail once Joe has had a chance to

Joe Andrieu: Yeah, I think that would be good. The diagram hasn't incorporated everything that I believe we've talked about. Of course, I may have missed some stuff, so I'm welcome to, you know, but I think doing a deep dive in the subtopic call And then hopefully, you know, we can just finalize it on Friday...

Otto Mora: incorporate some of the other aspects, and maybe perhaps even during the work, the special topic, I was thinking, will we dive into that diagram...

Joe Andrieu: And then I'll… I'll put the pros together, um, and get a draft update of that as my last task before, um...

Otto Mora: ah. Just more at our own time...
… Mm-hmm. Yep
… So we have a nice, uh, wedding gift for Will, which is a CR

Will Abramson: Mm-hmm...

Otto Mora: Actually already spec and potentially puzzle resolution algorithm. Cool...
… For sure, uh, as well. Thank you

Joe Andrieu: Uh… I leave for my travel. I think that's how the timing's gonna end up. Many prosperous and healthful years for you and yours well...

Will Abramson: Yeah, I put myself on the queue, actually, to say, uh, maybe in the interest of, like, you know, we're moving to CR, and we want to have a...
… of nice, friendly-looking repo for folks to look at. Could we tidy up some of these? PRs that are… ah
… That we know are not gonna get merged. I know, Joe, you said in the past you'd prefer to keep them open, but it does feel like we're aligning around 3, 4, 4. I don't know if you think there's
… value still in these old PRs. I mean, obviously, closing them doesn't mean they're, like, deleted or anything
… Yeah, that was just my thought. Just so someone comes to our repo and doesn't see all of these
… Right

Joe Andrieu: Well, I… I think… I think it actually explains to someone who's concerned about what are the… why are there 2D referencing sections? Um...
… I mean, I think… I think rather than people seeing us as incompetent, I'd rather see this
… Have them see us as embroiled in deep debate

Otto Mora: Mm-hmm. Mm-hmm...
… Along with that, I know that Steven did do a pass at labeling these issues now. um. Was there anything else? I mean… I know you had mentioned that in the coworking group
… Oh, it didn't

Stephen Curran: I did a path. I didn't label them. I didn't label them. What I did was I did a path to the issues...
… closed a bunch of them, and then I have a spreadsheet of those

Otto Mora: Uh-huh...

Stephen Curran: Um, and I can't… and I will update the labels on them. Uh, concern I had was...
… 2 things. We have many, many labels. I'm wondering if we can. I don't know again what the process is that
… that we're allowed to do, but can we eliminate a pile of labels? Is that just… Right
… stuff we manage, and then a few of the labels are subjective and probably should be removed. In that, they don't
… They're not the basis to to operate on

Otto Mora: Right. Um, I mean, we could probably...

Stephen Curran: Does anyone know the W3C, the W3C rules on those, or is it just totally up to the working group, but we can do what we want?...

Otto Mora: Will's the right person for that. Go ahead, Will...

Will Abramson: Yeah, I don't know, uh, and it would be good to talk to PA, because I know a lot of those labels are just inherited from the W3C, and, like, they have some that do have specific meanings...

Stephen Curran: Hmm. Okay...
… Okay

Will Abramson: uh, people who are going to review us, so, like, that's partly why there's so many. But, you know, if there are ones that you think really should be removed, we can have a conversation, and we can ask the PA as well. Hopefully...

Otto Mora: Mm-hmm. Down...

Joe Andrieu: Yeah. Just just to comment...

Otto Mora: That's fine...

Stephen Curran: I did close, uh, I did close 11 of them, um, that I think were, uh, for, for good reason, um, obviously all with comments so that people can see they've been closed and can reopen them if it's appropriate...

Joe Andrieu: Um...

Otto Mora: Oh, that's… that's commentary, Joe. Okay...

Joe Andrieu: Yeah, I just want to say I'm pretty certain that the repo we can do whatever we want with. I don't think these labels are part of process. I've never seen anything in the W3C process saying you have to do anything with any particular repo in any particular way...
… Um, there are habits and traditions, and so having these be sort of the standard ones makes it easier for people who aren't, you know, embedded in their work to understand what they are. Um… But we're free to curate and edit those labels. To whatever suits our needs

Otto Mora: Okay...

<ottomorac> transcriber-bot, pause


jandrieu and others added 8 commits July 16, 2026 15:15
* created CR transition files`
`

* updated version, changed status to CR, updated editors list

* updated version in html as well as config

* add a use of verification method to fix respec warning

* fixed css style element to avoid respec warning

* Update at risk section in index.html

Removed reference to replacement content from the DID Resolution Threat Model.

* Refactor at-risk section text for clarity

Removed redundant phrase in the at-risk section description.
Co-authored-by: Will Abramson <wip.abramson@gmail.com>
…id-resolution into feature/dereferencing-algorithm
…id-resolution into feature/dereferencing-algorithm
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

7 participants