W3C

VCWG Recognized Entities

10 November 2026

Attendees

Present
benjamin_young, Dave Longley, kayode_ezike, kevin_dean, manu_sporny, nate_otto, patrick_st-louis, paul_dietrich, phil_archer, Phillip Long
Regrets
-
Chair
-
Scribe
transcriber

Meeting minutes

VCWG Recognized Entities Call

Manu_Sporny: All right, let's go ahead and get started. I think a couple other people might trickle in. Um, welcome everyone to the recognized entities uh call. Uh, this is our first call after uh W3C uh TAC. A reminder to everyone that the calls are recorded in autoranscribed. Please let us know if you have a concern about that. Um, we uh have uh kind of our standard agenda. um for each week uh which includes uh processing pull requests um uh and then processing issues. We'll talk about you know any other items we should cover at the beginning of the call uh largely around TAC and what our kind of next steps are.

Manu_Sporny: Um so the agenda is you know introductions, reintroductions, uh W3CT pack outcomes, pull requests and then any issues that we h have after that. Um let me see if there are any updates or updates or changes to the agenda. Anything else that we'd like to discuss today? Y Patrick.

Patrick_St-Louis: Uh yeah, just wanted to say hi. Uh I've been following the spec, not attending the call, but I'm going to start to be uh a bit more involved more specifically on the test suite side. Uh for those that don't know me, my name is Patrick. I've been working on different uh digital identity projects for the last uh five, six years. uh this includes some UNP work, some citizenship work, wallet uh you know credential management system uh across various technology. Uh so hi everyone. Uh don't think I see anyone that I haven't seen before here although certainly a few person I've not directly interacted with. Uh so I would like to bring the topic uh of the test suite and say a bit uh where I'm at with this.

Patrick_St-Louis: And there's also two issues I'd like to discuss which are what I can at the moment uh label as some inconsistencies when it comes to behavior in the spec. There are two very simple thing but uh currently there's uh it's not very clear what behavior should be for these. Uh so I'll give more information once we dive into it. Thank you.

Manu_Sporny: Awesome. Thank you, Patrick. Uh, welcome to the call. Wonderful to have you here. Uh, thank you very much for starting to work on the test suite. Um, and yeah, we'll, uh, dive into those, uh, items, um, as we can. Um, did you want to cover any of that at the beginning of the call? my we have like 13 PRs that we should probably get to uh and we should probably talk about TAC. Is it okay if we put your items towards the end after PRs? Okay. And we'll try to try to get to those. Uh I don't think we're going to be able to merge the vast majority of the PRs today. So, um we should be able to get to it. All right. Any other updates or changes to the agenda before we get started? All right.

W3C TPAC Outcomes

Manu_Sporny: Um with that uh let's uh talk about uh W3CTPAC um uh just outcomes. Uh so uh W3CTPAC uh was in Dublin uh two weeks ago now I forget. Um uh uh it was wonderful to see a number of you there. Uh thank you for the rest of you for waking up in the middle of the night uh to be there. Um uh it was a good good event, good good outcomes. Um uh I think everything more or less went smoothly in the verifiable credential working group across all the work items. Uh when it comes to the recognized entities stuff specifically, uh we were able to meet with the technical architecture group of the W3C. Uh they have they had some concerns around, you know, our reference to Jason. Uh we had some discussions with them.

Manu_Sporny: um about you know outcomes uh that we could kind of uh uh look to um and then the other kind of general thing that that came out of W3CTPAC was um I think a desire to go to candidate recommendation with the specification uh as long as we have addressed you know all the uh security privacy whatever uh items um uh the so I think in in general eneral, that was the the vibe of the uh recognized entities uh meeting. Um we'll go into kind of some of the details uh through looking at some pull requests. Uh but let me pause here and see if anybody else has any other reflections on TAC or outcomes for recognized entities or anything of that nature.

Manu_Sporny: Finn, go ahead,

Phil_Archer: I don't really um have anything specific to say other than um it's become apparent to me during TPAC and the conversations going on around um our topic that recognized entities is a really important piece of the work and I think what this group is doing is um very well very much appreciated. Um it's fantastic that we're heading towards CR before the end of the year. Um, and I think it's it's doing us doing doing us a lot of good, the whole group a lot of good. So, thank you. And while I'm on the while I'm on the microphone,…

Manu_Sporny: Yes. Um,…

Phil_Archer: Patrick, I'm so pleased you're doing the test suite. Thank you. That's really important.

Manu_Sporny: plus one to that as well. Um, yeah, I think it's uh interesting how recognized entities has turned into a more critical central thing that I think at least I I had imagined uh in the beginning. I thought it was going to be nice little sides spec and we were going to move on. Um, okay. Let's uh any any other reflections on W3CTP pack before I jump into uh pull requests. All right, then let me pull up the poll requests. There are 13 open poll requests.

Addressing Pull Requests

Manu_Sporny: Now, uh, a number of these, uh, were raised this past weekend as a, uh, result of the discussions at W3CTPAC. So, the the primary goal for these PRs was to address uh, all of the security interest group, all of the Singh feedback. I did talk with Simony a bit Simony a bit uh from Singh about what you know we could do to kind of move things forward. Um we came up with kind of like a just a brief plan which was basically like please respond to all the issues and let's see what it looks like um uh after that. So I was able to get some guidance from him on what to put together and that's what the PRs that are raised uh are uh currently.

Manu_Sporny: Uh the other uh PR that's been raised is the response to the W3C tag um uh request. It's the JavaScript validator part of it. They had concerns around JSON auda and I think uh I suggested like well why don't we just do JSON and JavaScript and put both of them at risk and enter CR and get implement feedback on them. there didn't seem to be much objection to that approach and so now we're going to try to execute on that and see uh you know how the group uh does. Um okay uh with that in mind um the other thing that we need to make sure that we do is we get reviews on all of these things. Um there are a lot of PRs and a fair bit of content.

Manu_Sporny: is very important for us to get kind of independent reviews on uh all of these things. Um I'll note that before TAC, we sat out there for about five weeks waiting for reviews uh from folks. So I've tagged as many of you as I could on a variety of these. I'm seeing a lot of comments coming in. That's great. Um, but having multiple reviews uh is is will will help um the editors merge these things more rapidly. Um, go ahead, Patrick. You've got your hand up.

Patrick_St-Louis: Uh Yeah, I I did start to have a look. I did I think I posted only one review on one of them, but I did have this as a ongoing thing. I did sort of start uh batch reviewing these. So, I'll be uh refining my thoughts on it. Uh obviously, I'm new like I've been looking outside, but I I just want to make sure I get a bit more context of the thing discussed, but I'll I'll be able to post some thumbs up or some reviews. I think I put a few thumbs up on the ones that,…

Manu_Sporny: Okay, excellent.

Patrick_St-Louis: you know, were smaller.

Manu_Sporny: Uh, thank you very much. And yes, uh, thank you for doing that. And always, uh, more viewers the the better. Um, I think I'm going to just call out some of the ones that are stuck right now or are delayed. Um, the uh the CE marking um uh uh product conformity example, I don't know if anyone uh can can chat with Ingo. Uh it's still in draft state uh and it's got merge conflicts. I was going to try and um I was going to try and merge this like I think you know it's if this is this is what Ingo wants. It looked pretty good at a high level. Uh I think we were going to try and merge it in. Uh and then there's this proposal to branch it off into another note.

Manu_Sporny: Um, but I don't know if there's anyone that has objections uh to this um uh PR, but getting Ingo to, you know, uh re rebase it would be great. Um, and I see Phil, you've said that you're going to uh talk with Ingo, which would be uh great. Uh, Patrick, you're up.

Patrick_St-Louis: I think this is the one that had the new type for the credential that was like not it was like something about a scope uh in one of the examples.

Manu_Sporny: Yeah, it's scope recognized.

Patrick_St-Louis: Um, and I just want to make sure uh maybe um this one. Yeah, this one. So, uh scope recognized action. I believe this is not defined by the VC recognized entity, but this would be like an extension or is it okay? Okay.

Manu_Sporny: It was it's not clear. So I think maybe Phil when you contact Ingo maybe have him take a look at the new shape of everything and see if he still wants to approach it this way. He and I spoke a bit at W3CT and it wasn't quite clear if this was the path he wanted to go down. So I think this is largely a proposal. Maybe maybe what we should say is it would be good to have Ingo on the call so that we can work through this uh with him and then not you know try and…

Phil_Archer: Sure. I'll I'll give him I'll I'll try and…

Manu_Sporny: merge merge um or have a separate call with them uh just to try to get this into the right shape.

Phil_Archer: get hold of him in the week um and encourage him if he's willing to join this call next week. Uh bear in mind it is 10:15 uh in u Germany right now. Um so it is quite late to get someone on the call but I will ask him to. Um, also on the scope issue, by next week, uh, if I'm here, there's a question mark over that because I may have to do No, I know I know I'm not in next week. Um, but on the scope issue, that's something that comes up a lot in the metrology case as well. And um, one of the things I need to do this week is to prepare for the fact that I'm speaking to the metrology community on Sunday. Yes, Sunday. Um, so I may well be able to come back to this group after the weekend with some direct feedback from that community. That's certainly my hope.

Manu_Sporny: Great. Thank you, Phil, for um engaging with that community and and moving that forward. Um go ahead, Patrick. You're a plex.

Patrick_St-Louis: Uh yeah. So I like this PR a lot because it brings like a tangible use case in there. The use case being the UNP. So it it gives a good insight about how other communities would actually use the specification. Uh maybe this is also a good time to reflect like is the VC recognized entities meant to be extendable to specific governance requirements because you know I see this as a solution to the trust registry concern and it defines like some basic things like this entity is recognized there but some some specific use case or frameworks or you know they could have like specific terminology and their own governance framework that they would like to like extend this instead of having a whole other use case. So, I'm I'm kind of curious where what's the current positioning of the spec regarding this?

Manu_Sporny: Yeah, I think I think that the current position is yes, that's that's supported, meaning that you know sub communities should be able to extend uh the spec to meet their use cases. Of course, it's JSONLDD, so you can just expand it, you know, expand it in the direction you want it to go in. Uh I'll also note that if you know if we uh pull in the JavaScript validator stuff then that makes it even easier to do fairly complex um uh you know validation against the extensions that they do. So all that to say I think the answer to your question Patrick is yes.

Manu_Sporny: Um that is certainly uh within scope of what the uh spec is trying to do. Um, go ahead, Phil. You're up next and then Benjamin.

Phil_Archer: Uh yeah um Patrick I I think um Ben has already said it.

Phil_Archer: I mean the the the flexibility of JSON plus we are subject to confirmation and implementation saying hey you and you can stick your own JavaScript in here. I have questions about that which we which we may or may not get to this evening. Um, but yes, that enormous flexibility is important. Um, and Patrick, what you may may not have picked up is that this metrology thing I just talked about that's come directly from Brett Highland, who I know you know well through UNP. Brett's going to be there by the way as well. So, um, UNP has been directly I mean Steve is often on these calls. He's not tonight but he often is. So there's um there is a very good synergy going on between UNP and uh VCs in general, but this recognized entity work in particular. And so yeah, that kind of flexibility um is very much the topic of discussion that I'm going to be having on Sunday.

Manu_Sporny: Excellent. Thank you, Phil. Uh, go ahead Benjamin.

Benjamin_Young: Yeah, I just had a question related to the matching stuff.

JavaScript Validator Proposal

Benjamin_Young: Um, GS1 folks had put forth 121 for a field match option and done some exploration there. I didn't know given that we've got two at risk options on the table if we should put this one on the table since it's a similar uh it's solving for the same need in a simpler um fashion. I know we had the discussion around it and then pivoted to JSON and then JSON taking it on the chin has now got us pivoted to JavaScript but I didn't know if we wanted to come full circle and come back to this other approach. Go ahead.

Paul_Dietrich: I was going to say I'm open to any of those approaches. I think the JavaScript one sounds like to me after I wasn't at TAC so I apologize if I'm misinterpreting what happened but the JSON auto was it was uncomfortable to be in the specification for various reasons. That's where the um JavaScript came from. I think the JavaScript supports relatively natural for us because we're trying to replace a library because it's very hard to ship a library to every verifier in a supply chain. Um, so I think given that it sounds like there's more support for JavaScript than JSON and both will work for us. I'm pretty sure. I haven't finished the examples there, but both will work. I wonder if we want to just push JavaScript and have multiple implementers there rather than try to fragment it between JSON um, and JavaScript.

Paul_Dietrich: I don't know what the thoughts of the group are, but if that's the case, I could withdraw that 144 for issue 142 and just continue with the JavaScript approach.

Manu_Sporny: All right. So, let's uh since we're talking about that one, maybe we should jump to that um um PR next. Um so, without So, we're gonna we're going to jump around, I think, in the in the poll request to make sure that we uh give enough time to talk about this stuff. Um, yeah, let's just jump to let's Let's jump to 150 which is associated with you know um 141 and issue 121 as well. One second let me let me topic this.

Manu_Sporny: So, uh, issue 150 or sorry, pull request 150 basically adds, um, a JavaScript, uh, validator, uh, to the, uh, specification. Um, and it does it in several different sections. Um, there is a new section in the data model that talks about credential validators. So in general a credential validator points to um you know a file or some code of some kind um and it has a media type associated with it which is basically JSON schema or JavaScript. Right now if we added JSON it would be the I forget the media type for JSON but application JSON or uh you know text/JSON.

Manu_Sporny: Um and so the credential validator that you have will run against the credential chain uh that's that's passed into it. Um and the spec defines two uh uh credential validators uh in pull request 150. The JSON schema one and the JavaScript one. And you know if as as you can imagine um the JSON schema one points to a JSON schema file and the media types uh JSON schema and the JavaScript one points to a JavaScript file uh and the media type is uh JavaScript. Uh for this um that's just the data model portion of it. Uh there is also an algorithms uh portion that talks about how you run credential validation uh the the process.

Manu_Sporny: So you have like a chain an action an evaluation daytime um and then there's an algorithm uh that you basically run uh no matter what validator you're using and then there's validator specific processing like JavaScript validator processing um and the general idea here is that you will get in a recognized entity a credential um uh or you'll get in a VC and you you may build a recognized entity credential chain from that and then you will be able to run these validators these credential validators on the VC that you got uh as well as the chain that's associated uh with that VC and that lets you do very complex matching and querying and um everything that you can do in a touring complete language. The downside is that

Manu_Sporny: for the JavaScript validator. It's complex. Um JavaScript uh you know uh you have to put it in a sandbox. It can't have network access. You have to put memory and uh compute um uh limits on it. Um all of those things need to basically be um in play for you to kind of run this thing. Um but the upside is that I believe it addresses just about every single use case we've thought of um uh in the group. Um it's very heavyweight. Um but the W3C tags feedback was we feel nervous about JSON and the community around it and the governance around it and you know the the stability of the spec.

Manu_Sporny: Um, yes, JavaScript's big and unwieldy and uh, you know, a a giant sledgehammer for the problem that you have. Uh, but we are the web and we are familiar with JavaScript and how to reference it and how to limit um, you know, um, uh, runtime and how to sandbox it and all that kind of stuff. So that's where this came from. The PR basically adds the concept of being able to have different credential validator types. Um, and it creates the algorithms that you need to to run generic credential validation and…

Manu_Sporny: then execute specific validators uh on that chain. Let me stop there and uh go over to you,

Phil_Archer: Um, just to say thank you first of all um,…

Phil_Archer: Manu for taking the time to write this. It was a lot of work and it's generated a lot of comments since. Um, I reviewed it. I would like to see this merged. I don't think it's finished, but I definitely want to see it merge because um there is so much of it and a lot of things to think about. I don't know whether this is something you want to get into now or not. Um but um one of the comments that Ivan made about this pull request was that um he feels this may not be because this is about validating a VC maybe it doesn't belong specifically in recognized entities.

Phil_Archer: Um, at first I agree with him and then I thought about it as I went through reviewing it today and I thought no I don't I think this is only this can only be in the recognized entity spec because that powerful um very flexible mechanism that we're putting in here only makes sense when you are validating more than one VC which is where the complexity comes from. Uh, and if you take it out and say, "Oh, yes, a standalone VC can link to a JavaScript library that you can use to validate it." Well, that's pretty darn pointless because of course the script that one VC points to is going to give you the right answer because the two things are tied together. It's pretty much meaningless if if the if the person

Phil_Archer: offering you the code that validates the credential they're offering is the same person that issued the credential. Well, big whoopdoo. You've given yourself a gold star. Well done. I think it has to be that the script has to apply to more than one credential. And we may or may not decide to put in things that say only do this if you've got more than one issuer. Only do this if you're looking at a chain of at least two, possibly more. Thank you.

Manu_Sporny: Good points. Thank you, Phil.

Kevin_Dean: Yeah, I don't normally find myself disagreeing with with Phil, but um I'm not entirely sold in the idea that this is uh something that could be exclusive to um to verified entities. I think there you know as um even even though you may have a uh credential of type X and there's a well- definfined validation library that your uh that your verifier is using uh for it. There may be um extensions to it that require might require additional u validation.

Kevin_Dean: And so there might be value in having in having something like this um available in a more general sense. However, that's going to take a lot more work than I think is we have time for or the the appetite for and and there's nothing that would prevent us from promoting this from recognized entities to the larger specification at a later date. If we do indeed determine that this is something that has more general applicability and by promoting it to the larger spec, we won't um we won't end up deprecating anything in this one. We'll just be shifting where it's defined. So uh I think we're we're safe in keeping it where it is and we can we have lots of time to give it further thought.

Manu_Sporny: Yeah, I largely agree with what uh Kevin said. Um to devil's advocate just a tiny bit though. Um there is a use case where it might be useful. So I agree with you, Phil. Like I I never understood I I still don't understand why we have JSON schema in credential schema in the VC data model because the issuer is going to issue the thing and they're probably not going to issue a a credential that violates their own schema,…

Phil_Archer: right?

Manu_Sporny: right? Like that I think that's the base of your argument and I totally agree with that. um uh the validators come into play when you have a chain of credentials as you said, but I think there's another another use case that matters here and that is the ability to publish a credential validator that is generally useful within a a smaller ecosystem.

Manu_Sporny: So this is not something that is that is published by the credential validator is not something that is necessarily published by the issuer. It can be packaged up by a third That's third party and provided to the ecosystem and you can take those credential validators and you can plug them into your uh credential workflows. So there you know when you have a workflow this is I'm talking about like BCOM uh in your exchanging credentials back and forth um there is the potential where you could package up uh credential validators for a for an ecosystem um where the code itself goes into depth on like you know every uh you know every for whatever reason every Monday and Wednesday these are the legitim these are the legitimate uh you know credentials

Manu_Sporny: But on Tuesday, Tuesdays and Thursdays, they're not for whatever reason, right? Arbitrary business rules. Um, but I think in use cases like that where you want kind of pluggable code um, and you want that plug pluggable code digitally signed um, uh, and published separately. Uh, I think they're use useful uses there. That said, completely agree with Kevin, like let's just get this into the spec right now uh and get it to solve this use case and then as Kevin said, we have plenty of time to generalize it if if that generalization is is useful later. Um I would be kind of sad if you know we turns out that it was a general solution and it takes us two and a half years to generalize it into the VC data model. Uh, that would that would be a little sad, but not the end of the world as as Kevin mentioned. Um, go ahead, Patrick.

Patrick_St-Louis: Uh yeah. So two two things both. Uh so the first thing that this made me think of was the credential schema. Uh at first glance this just seems to be redoing credential schema as a new thing. Uh I see values in the credential schema. uh for some use case like we see an open badge uh UNP where issuers reuse a schema right like a publish schema from some kind of schema authoring registry uh this is also similar to ouron cred's work right different issuers could uh publish credential definitions based on the SK shared schema uh I'm curious as to why this credential validator was defined

Patrick_St-Louis: uh as opposed to just create a new credential schema type called credential validator and reusing this uh which seems to me like there's a lot of overlap in what it's trying to do.

Dave Longley: So, I put this in the chat uh so I also wouldn't forget what I was going to say, but um if there's some VC plus a chain optional or otherwise that passes validation with some validator X, what does that mean? Like that's the piece that's missing. Like we could fine, here's a way to do JavaScript validation with a sandbox and leave it like that. That that piece on its own, it might be a reusable primitive in places, but if you don't connect it to anything else, it's it it is it's self not usable. And so what does it mean to pass validation? Well, that's what the recognize entity spec provides. It it provides a machine readable way to express what it means if you pass validation. And what it means is you're recognized. this VC is recognized by this party. That's that's what it means to pass validation. And without that um you don't have a complete solution.

Dave Longley: So that's kind of how I see the the different pieces fitting

Manu_Sporny: Plus one of that. Uh, go ahead, Paul.

Paul_Dietrich: Yeah, I just want to say I think that also the this is different than the credential status because this is a recognized action to validate um a party that you that the recognized entity has issued a credential to. So it's recognizing them to perform some action and that action is not in the credential that the recognized issuer issued. It's in the credential that the other party issues that the recognizer recognizes. So it's one step removed and I think that adds a lot of value in the validating of these complex chains. U Manu before um I drop I just had one comment about the JavaScript validator. I think in our case we would probably still use JSON schema and JavaScript. And so when you combine two of those I want to make sure that it's still very clear in the spec that those are and or operations. Fantastic.

Manu_Sporny: Yeah, in the in the I think in the PRs they both have to pass is what we have right now. All right. Um All right. Thank you everyone for all all that uh input. Um uh I think so so to just to reenter us on this pull request. Um uh 150 is about adding the JavaScript validator and restructuring this so that we could talk about JSON schema validators that are JSON schema, JSON, JavaScript and anything else we want to put in here in the in the future.

Manu_Sporny: Uh it would also allow people to extend just based on media type like you may uh you know create a totally different validator language if you want. Um uh but that's the extent and and the hope then is well if if we get if this passes and if it comes into the spec then Paul you're you would have the ability to put Jason in here as well. I'm interested to hear from Dave Lonley if you know if he feels like the Jason stuff should go in here as well and what other people think. Um but I think there are some remaining questions that we need to kind of cover but by and large the general shape of it there and we need to decide if this is something that We

Manu_Sporny: want to pursue, right? So, that's kind of the open question right now. I don't know. I think I heard Phil you say yes, let's merge it and and try to try to fix it up. Um, you know, the other things uh fix it up. Uh, I think Paul, you said you're okay with this. Um, Kevin, I don't know if yours was in support or, you know, uh, or or indifferent or whatever. Interested to hear from,…

Kevin_Dean: Yeah, I'm in support. Manu Sporny:

Manu_Sporny: you know, everyone else on the call. Is this a is this a an approach that we want to pursue uh as an at risk feature? All right. Any any objections to that? We're not going to merge this until the 7-day periods up.

Nate_Otto: Uh no objection here and I think u an at risk feature might be the sort of best that I would support here. I am curious about the approach um and also cautious because it potentially has high implementation costs if it's a required thing that someone must do at some point run all the validation scripts you find in a chain. um uh you know there there's a lot of security work that you got to do to be able to run any of these these well and um and potentially you've got chains that have sections of them that aren't trusted and then are you really validating the everything that you need to do uh maybe some unclarity around that but I have some you know especially working in open badges I have some skepticism that schema based validation is enough and this gives us the firepower to do a lot more um within the scope of the spec

Nate_Otto: then could be covered reasonably well by a schema. You know, especially with the type of val variations that occur in across different open badges credentials, it's really hard to express in a schema which variations you might accept as like a representation of a a competency that you expect the organization to be competent at assessing versus one that is not. And so perhaps uh with some more tooling you'd be able to do do something like that. And it's it's interesting to dive into those birches.

Manu_Sporny: Great. Thank you. Uh Nate, uh Dave, you're

Dave Longley: Yeah, I I think um something we will need to we will need to figure out what we're going to normally normatively say about this and we do need to say something but um just the fact that JavaScript is you know turning complete and let you do anything you want does not mean you can do that with this spec because we're going to need to put clear boundaries or at least suggest clear boundaries uh around like you were saying earlier, Manu, memory usage, time, you know, CPU usage, how long these validators might take to run, uh, and prohibiting network access, for example. Each one of those things is going to create restrictions. probably not restrictions that are

Dave Longley: uh you know too uh too ownorous for anybody to be able to do most of pretty much whatever they want. But uh the implementer side whoever is going to be running this is going to already have set those boundaries. They're going to say you get this much time, you get this much memory, you go don't get a network. So if you create a script that doesn't work in there, it's never going to pass. So th those restrictions are going to be there and people do need to understand that and um we should probably keep them pretty tight and then do some analysis around you know if you're doing a a chain of these uh and you've got you know what does this look like in the average case for the average chain what does it look like for the worst case chain that anyone wouldn't just throw out. Um and we we should try to understand

Manu_Sporny: Yeah, plus one to that. Um, there is a write up on the limits for the sandbox in the spec right now. They're expressed as a should and not a must. Um, because you know I was unsure about how hard of limits we should put on these things. So, um, there's also an argument that like uh maybe JavaScript the JavaScript validator isn't a must. Um, I think that would be problematic, you know, for the GS1 use case. Um but if you've got multiple implementations and the GS1 ecosystem requires JavaScript um you know that those are the validators that are going to be uh the implementations that are going to be used as the ones that support that.

Manu_Sporny: So there are there are a number of open questions here but I'm not hearing any objections uh to the to the PR uh meaning we can you know please do take a look at it a detailed look at it um but uh conceptually it doesn't seem like people are opposed to um doing it as an at risk feature and then seeing where we get in uh uh in in the candidate wreck uh from implementers. All right. I think unless there's more discussion that folks want to have here, there are a number of other PRs that we should take a look at today. I also want to give some time uh Patrick to the items you mentioned. So maybe the last 15 minutes.

Manu_Sporny: Um uh and given that we only have about uh 3 minutes, I'm going to just point out um the va the vast majority of the new PRs are to address the sing uh the security interest group uh uh uh use cases. I have talked with Simone after raising these PRs and he said uh we are fine to close the Singh request meaning like we have met their requirements because we have raised PRs and as long as we continue to prosecute these PRs they're fine with saying like your security review is done on the spec uh which would be great um which means that the only one that we don't have complete I believe is the accessibility one uh I did write into them and say like Eight.

Manu_Sporny: we intend to go to CR in December. Please let us know uh if that's acceptable to you or or not. I don't think that there are many accessibility requirements in the spec, but we'll see. Um so, um all that said, PR 138, this one uh is related to the Singh review. Um this one uh 151 is related to the um u compromise that uh was made with about the uh digest properties. Um and then 152, 153, 154, 155, and 156 are all responding to editorial requests from Singh.

Manu_Sporny: So, these were things where they were like, "You don't have to change it, but please think about it. We have made an attempt at all of them." Simone has signed off on all but one of them. Uh where I'll take another pass at it. So, it it needs more reviews. So, please, if you're tagged on it, or even if you weren't, uh please do a review. Um uh the other items are largely uh editorial uh stuff. Avon and I are working through updating the GitHub actions. Avon added the registration term to the vocabulary and then once we're through all of those uh Paul hopefully you can then build on top of the existing thing and adding JSON should not be too difficult of a task as long as you kind of point an LLM at at it, right? Um uh go ahead Paul.

Paul_Dietrich: Yeah, my thought there, Manu, is if JavaScript's available, I would just do our examples in JavaScript and not use JSON. Um, originally what we need is a regular expression matching. And I think that's just as easy in JavaScript, probably easier than JSON because more people know JavaScript. So I would think if you want to close this issue as long as no one else is using JSON um I'd support closing this and I'll just implement on the JavaScript validation.

Manu_Sporny: Okay. Um, are there concerns about that? I I Dave Longley, I'm looking at you. I I don't know if we have strong opinions there.

Dave Longley: We don't have strong opinions yet. We haven't done our own sandbox uh implementation here for JavaScript. Um there and I have not deep dived on the uh algorithm that's in the spec. Uh as noted in chat, we're going to need a very clear interface for using this. Um and you know, I just haven't come into implementation contact with it yet. So unknown. I think if we have JavaScript and that's what's going forward, I do not see why we would use JSON auto if that's, you know, something that has to be implemented to use this part of the spec. Uh,

Dave Longley: The reason for using JSON is you might get better uh you know it's it's a simpler thing and you don't have to worry perhaps as much on you know all these memory constraints and processing constraints um it's slightly different model but it does feel um duplicative so I imagine we would only implement the sandbox piece

Manu_Sporny: All right, got it. Um, I'm feeling a little uneasy of t about taking Jason out and not at least putting it as risk. Um, but that's just,…

Manu_Sporny: you know, uh, leave it as in Jason isn't in the spec yet.

Dave Longley: Let's just I mean we can just leave it.

Dave Longley: Let's leave it where it is and get some implementation experience with the JavaScript. See what dragons are there. Oh well I'm my understanding is tack was put it in there put it at risk. That's I don't think that's very much I don't think that's a big ask…

Manu_Sporny: Yep. Okay.

Dave Longley: but you know you're the one doing it. Um and and it can just sit there and that risk means you know if nobody ends up implementing it we just take it out. Um so I I think it's good to have a placeholder for it and…

Manu_Sporny: Okay. Yeah,…

Dave Longley: while we collect uh more experience

Manu_Sporny: I'd prefer to do that just because, you know, we don't want to get it in CR and then find out like, oh yeah, we definitely needed Jason Auto. Um, go ahead,

Phil_Archer: Am I wrong in thinking that…

Phil_Archer: if you can run JavaScript then one of the JavaScript libraries you might use is JSON. So you could have if if you allow JavaScript and you are are you not also allowing JSON because it works with it or am I mistaken?

Dave Longley: While you can certainly do that, that I don't think that makes much sense. Having JSON is is a point of interoperability. It's not about a implementation detail you'd hide behind your own JavaScript. It's about um having issuers give you a JSON template. So it really was uh interoperability on that language as a you know different data format. Uh so of course you can run you know you could run JSON inside your own JavaScript validator if you needed it for some reason. Um and I expect maybe people will and maybe they'll also run JSON schema. Um, but that's behind the curtain, so to speak, as opposed to up at the front door where where you need other people to agree to express their information using a certain format.

Phil_Archer: All right. Thank you.

Manu_Sporny: All right, with that uh sorry that's uh we're 3 minutes over. Um but thank you everyone uh very much for the input. Uh I think we the presumption here is that you know we'll merge the JavaScript validator as long as soon as it gets enough reviews um and and hits the timeout uh period. Um, go ahead Paul.

Paul_Dietrich: Yeah, just a quick question about Tacmon. What I heard was that um the examples are growing big and…

Paul_Dietrich: these might split out to a se document and I think that's relevant because we want to submit GS1 examples but I don't know if they should go in to this document or if we should wait for another document to appear.

Manu_Sporny: Go ahead and…

Manu_Sporny: put them wherever makes sense for right now. And I think if we move it out, they'll all move out together.

Manu_Sporny: Um, yeah,…

Paul_Dietrich: Okay, thanks.

Manu_Sporny: just just put them in the document for now and we can we can move it around later as an editorial uh thing. All right. Um, I want to make sure that we get over to Patrick's uh items. So, um, over to you Patrick um to to share uh info about test suite and…

Manu_Sporny: other related things.

Test Suite Development

Patrick_St-Louis: Uh okay yes thank you.

Patrick_St-Louis: Um yes I'll go over the test suite discussion uh first. So there was an issue already open. There was some discussion around the test suite or at least like an initial implementation. Uh so I did have a look at this issue had a look at the spec and came up with like a phased approach uh of how to go about testing. Uh so the first thing is well what is going to be tested. So in the conformance section there's test that needs to be done about a conforming documents and a conforming processor.

Patrick_St-Louis: Um for the conforming processor the mechanism I believe the test suite will take is that it will look for a configured endpoint at which it will send a verifiable presentation and then evaluate the response uh from that endpoint. uh it will be first uh evaluating the credentialbased discovery as well as the recognition validation uh based on the response. Uh for the identifierbased discovery, I'm not too sure at the moment. This is what I'm going to think about next. Uh but for the credentialbased discovery, it's going to be a did keybased issuer um test.

Patrick_St-Louis: So the test client will look at an endpoint, send a post request with a verifiable presentation key containing a verifiable presentation. Uh so this makes it that implementers can just put a very simple API uh available that the test client will be able to call. Uh the test suite will provide instructions. it will be expected that this endpoint has preconfigured a list of um you know trusted issuers if the if it's needed. So there there's a couple configuration items possible in the in these algorithms. So there will be instructions for this endpoint to have these preconfigured and these will be like hosted uh on GitHub. Um yeah so that's the first part. Uh is there any kind of feedback towards this approach? Uh, do we think this is a good approach?

Patrick_St-Louis: not a good approach. Um there's not really a clearly defined uh you know endpoint model to interact with this. Uh and there's not a really clear way for a component to return sort of an an object after this validation. We have uh defined models for verification. We have verification endpoint. Uh but this kind of in process validation is something that's just meant to happen uh and you know prevent a workflow from going to the next step. Uh for the sake of testing uh the easiest way will just to be to evaluate status code returned uh either 200 or 400 for a wrong validation.

Patrick_St-Louis: Eventually, if we want to do more specific testing for um specific things listed in this recognition validation, we could define a a sort of response item, for example, recognized and action recognized, which needs to be booleans. Uh we could add this later on. Is there any uh does that seem like aligning with what was discussed? Basically, is my question.

Manu_Sporny: Yeah, I I think so. At a at a high level, I think we had originally said like, hey, we already have this concept. It's called an exchange, you know, in a in a in a workflow and we could use VCOM for this. I I know that at least Brent said we should not require VCOM for, you know, non non uh VCOM uh task forces. Um, but fundamentally we have to specify like an HTTP endpoint that you send this thing to or some way of like calling out to an external piece of software.

Manu_Sporny: And so, you know, I think the interface you described, Patrick, was basically like there's going to be an endpoint and it's going to look very close to uh what a VCOM exchange looks like and then you're going to get a return value. And that is basically any kind of HTTP based test suite is going to effectively do something like that.

Manu_Sporny: Um, did I understand your proposal correctly, Patrick?

Patrick_St-Louis: Correct. So the endpoint expected could be seen as a participate and…

Patrick_St-Louis: exchange endpoint where a specific uh workflow is awaiting for a verifiable presentation to be sent. Um so you know if someone wants to support exchange we can make the test suite work with this. uh you know we can make sure the test suite is able to kickstart an exchange but also for users who do not want to implement exchange they can just sort of implement this single step as a static end point. Um for the other one so conforming document uh so my approach was in the same principle of a simulating a static exchange.

Patrick_St-Louis: I would propose an endpoint uh to which the test suite sends an empty request body and they get returned a verifiable credential from the implementation which should have their implementation of a recognize entity and then the test suite would you know fetch this list and make sure that it just adheres to the the data model here. Um so this is the same idea. Uh if someone wants to fully implement an exchange mechanism uh they can otherwise they can just have this one static endpoint that will just wait for an empty post request and return a verifiable credential.

Patrick_St-Louis: Uh so in the verifiable presentation case the test suite would host the VC recognized entity list and the um verifiable credential use case which is expected to be returned by the implementation the test suite will simply do data model validation. It will not look at any kind of proof security. it's just going to be focused on the data model since um you know crypto suite test suites are done they already exist so we don't want to test these um so that's to start uh this does not take into account the whole uh credential validation this can come at a later stage and I also need to think about identifierbased discovery here um two thing I wanted to bring up

Spec Inconsistencies and Issues

Patrick_St-Louis: So section 4.1 and 4.2 is credentialbased versus identifierbased and they seem to have different behaviors of what should happen when the verifier is unable to retrieve an entity credential. So in the credentialbased discovery it's it says to raise a retrieval error as in the identifierbased discovery uh it says if there's a retrieval policy uh the verifier should return the chain with no error even if no candidate credential is found.

Patrick_St-Louis: Um, so my question would be uh probably a topic for next week, but is this distinction on purpose or is just a matter of realigning them? Um, and my Yes, Manu. Yeah.

Manu_Sporny: And I was just going to note we've only got three minutes left. So,

Patrick_St-Louis: Okay. Yeah. And the the other one I opened an issue. It's about the specific use case when the issuer is the direct anchor of the trust. What should happen in that situation when the the chain is only one credential long?

Manu_Sporny: Yes, we should definitely uh look into each one of those things. I'm sure there bugs in the spec or whatever. Um that uh you're you're probably hitting uh those bugs. Um okay. Uh with that, that is our call for today. Thank you everyone very much uh for uh the the focus on the PRs today. Please please please uh look at all the PRs and review as many as you can so that we can do clean merges um and and move that stuff into the spec and get ourselves uh into CR sooner than later. Uh all right, that's it. Have a wonderful rest of your weeks uh week. Um I am not going to be here next week. Uh, but my hope is uh either Benjamin, you or Patrick um or Dave or anyone else that wants to run the call can uh can run the call and make some progress uh next week.

Phil_Archer: Thank you everyone. Bye-bye.

Manu_Sporny: right, thanks everyone. Have a good one. Ciao. Meeting ended after 00:58:04 👋 This editable transcript was computer generated and might contain errors. People can also change the text after it was created.

This transcription was generated by a large language model (LLM) and might contain errors. When in doubt, check the audio recording. This page was formatted by scribe.perl version 248 (Mon Oct 27 20:04:16 2025 UTC).