@vantageos/mcp-boilerplate 0.6.2 → 0.7.0

package/dist/toolRoles.d.ts

@@ -0,0 +1,57 @@
+import type { ToolRole, ToolRoleLookup } from "@vantageos/cloud-identity";
+/**
+ * Agent tool roles (mcp-server-standard "Agent tool roles"): which tools exist for the calling agent.
+ *
+ * The decision is @vantageos/cloud-identity's (`decideToolRole` / `filterGrantedTools`); this module only supplies its
+ * input, the role the caller holds, through ONE seam: a `RoleProvider`. The boilerplate ships a data-backed provider
+ * (roles in a JSON file named by `MCP_ROLES_FILE`, no business value in code); the Convex agent-roles component plugs
+ * into the same seam.
+ *
+ * Where roles apply (Pi's ruling on task k17103j933e6en0aqyws2v1twx8hc0s3):
+ *   - the OAuth tier: a provider is REQUIRED. No `MCP_ROLES_FILE`, an unreadable one or a malformed one stops the
+ *     server at start, naming the variable. An absent store never widens access.
+ *   - the public HTTP tier and stdio have no caller: roles are NOT APPLICABLE there, said at start and in the identity
+ *     tool (`rolesApplicable: false`), never a silent pass.
+ */
+/** The verified caller a provider reads its role from: what the identity layer resolved, never a claim read here. */
+export interface RoleCaller {
+    /** The verified subject (the person or agent behind the credential). */
+    subject: string;
+    /** The organisation's permanent ID, as resolved by the identity layer. */
+    orgClerkId: string;
+}
+/** The role store seam: the role the caller holds, or why there is none. A thrown error is read as unresolved. */
+export type RoleProvider = (caller: RoleCaller) => Promise<ToolRoleLookup>;
+/** A role as the roles file holds it: cloud-identity's `ToolRole` plus a display name for the identity tool. */
+export interface NamedToolRole extends ToolRole {
+    name: string;
+}
+/** The roles file: the roles, and the binding of each verified subject to exactly one role. */
+export interface RolesFile {
+    roles: NamedToolRole[];
+    agents: Record<string, string>;
+}
+/** Where roles apply, decided once at start. */
+export type ToolRolesConfig = {
+    applicable: true;
+    provider: RoleProvider;
+    roleName: (roleId: string) => string | undefined;
+} | {
+    applicable: false;
+};
+/** Thrown at start when the OAuth tier has no usable roles file. */
+export declare class ToolRolesConfigError extends Error {
+    constructor(message: string);
+}
+/** Every problem with a parsed roles file; empty when sound. A malformed file is refused whole, never half-used. */
+export declare function checkRolesFile(value: unknown): string[];
+/**
+ * The provider over a roles file already read and checked. A subject with no binding -> absent ("unassigned"); a
+ * binding to a role the file does not hold -> absent ("deleted"). Both deny, by the decision function.
+ */
+export declare function fileRoleProvider(file: RolesFile): RoleProvider;
+/**
+ * Where roles apply, read at start. OAuth: `MCP_ROLES_FILE` is required and must hold a sound roles file, else the
+ * start is refused naming the variable. Public HTTP and stdio: not applicable.
+ */
+export declare function loadToolRoles(authMode: "oauth" | "public" | "stdio", env?: NodeJS.ProcessEnv): ToolRolesConfig;

package/dist/toolRoles.js

@@ -0,0 +1,113 @@
+import { readFileSync } from "node:fs";
+import { tBoth } from "./i18n.js";
+const ROLES_FILE_VARIABLE = "MCP_ROLES_FILE";
+/** Thrown at start when the OAuth tier has no usable roles file. */
+export class ToolRolesConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ToolRolesConfigError";
+    }
+}
+const isStringList = (v) => Array.isArray(v) && v.every((x) => typeof x === "string" && x.length > 0);
+/** Every problem with a parsed roles file; empty when sound. A malformed file is refused whole, never half-used. */
+export function checkRolesFile(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return ["not a JSON object"];
+    const { roles, agents } = value;
+    const problems = [];
+    if (!Array.isArray(roles))
+        problems.push("`roles` is not a list");
+    if (!agents || typeof agents !== "object" || Array.isArray(agents))
+        problems.push("`agents` is not an object");
+    if (problems.length > 0)
+        return problems;
+    const ids = new Set();
+    roles.forEach((r, i) => {
+        const role = r;
+        const at = `roles[${i}]`;
+        if (!role || typeof role !== "object")
+            return void problems.push(`${at} is not an object`);
+        for (const key of ["roleId", "orgClerkId", "name"])
+            if (typeof role[key] !== "string" || role[key].trim() === "")
+                problems.push(`${at}.${key} is missing`);
+        if (typeof role.roleId === "string") {
+            if (ids.has(role.roleId))
+                problems.push(`${at}.roleId ${role.roleId} is declared twice`);
+            ids.add(role.roleId);
+        }
+        if (!Array.isArray(role.domains))
+            problems.push(`${at}.domains is not a list`);
+        else
+            role.domains.forEach((d, k) => {
+                if (typeof d?.domain !== "string" || d.domain.trim() === "")
+                    problems.push(`${at}.domains[${k}].domain is missing`);
+                if (typeof d?.read !== "boolean" || typeof d?.write !== "boolean")
+                    problems.push(`${at}.domains[${k}] needs boolean read and write`);
+            });
+        if (!isStringList(role.add ?? []))
+            problems.push(`${at}.add is not a list of tool names`);
+        if (!isStringList(role.remove ?? []))
+            problems.push(`${at}.remove is not a list of tool names`);
+    });
+    for (const [subject, roleId] of Object.entries(agents))
+        if (typeof roleId !== "string" || roleId === "")
+            problems.push(`agents["${subject}"] is not a role ID`);
+    return problems;
+}
+/**
+ * The provider over a roles file already read and checked. A subject with no binding -> absent ("unassigned"); a
+ * binding to a role the file does not hold -> absent ("deleted"). Both deny, by the decision function.
+ */
+export function fileRoleProvider(file) {
+    const byId = new Map(file.roles.map((r) => [r.roleId, r]));
+    return async ({ subject }) => {
+        const roleId = Object.hasOwn(file.agents, subject) ? file.agents[subject] : undefined;
+        if (roleId === undefined)
+            return { status: "absent", cause: "unassigned" };
+        const role = byId.get(roleId);
+        if (!role)
+            return { status: "absent", cause: "deleted" };
+        return {
+            status: "resolved",
+            role: {
+                roleId: role.roleId,
+                orgClerkId: role.orgClerkId,
+                domains: role.domains,
+                add: role.add ?? [],
+                remove: role.remove ?? [],
+            },
+        };
+    };
+}
+/**
+ * Where roles apply, read at start. OAuth: `MCP_ROLES_FILE` is required and must hold a sound roles file, else the
+ * start is refused naming the variable. Public HTTP and stdio: not applicable.
+ */
+export function loadToolRoles(authMode, env = process.env) {
+    if (authMode !== "oauth")
+        return { applicable: false };
+    const path = env[ROLES_FILE_VARIABLE]?.trim();
+    if (!path)
+        throw new ToolRolesConfigError(tBoth("toolRoles.configMissing", { variable: ROLES_FILE_VARIABLE }));
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (e) {
+        throw new ToolRolesConfigError(tBoth("toolRoles.configInvalid", {
+            variable: ROLES_FILE_VARIABLE,
+            path,
+            problem: e.message,
+        }));
+    }
+    const problems = checkRolesFile(parsed);
+    if (problems.length > 0)
+        throw new ToolRolesConfigError(tBoth("toolRoles.configInvalid", {
+            variable: ROLES_FILE_VARIABLE,
+            path,
+            problem: problems.join("; "),
+        }));
+    const file = parsed;
+    const names = new Map(file.roles.map((r) => [r.roleId, r.name]));
+    return { applicable: true, provider: fileRoleProvider(file), roleName: (id) => names.get(id) };
+}

package/dist/ui/sandboxDomain.d.ts

@@ -0,0 +1,13 @@
+/** The suffix of every Claude MCP Apps sandbox origin. Half of the derivation, never a whole domain. */
+export declare const CLAUDE_SANDBOX_SUFFIX = ".claudemcpcontent.com";
+/**
+ * The sandbox domain Claude serves this server's widget from (mcp-app-standard A-11): the first 32 hexadecimal
+ * characters of SHA-256 of the served MCP URL, followed by `.claudemcpcontent.com`. Computed at start from the URL
+ * the server is reached at, never written as a literal: a typed domain is wrong as soon as the URL changes.
+ */
+export declare function claudeSandboxDomain(servedMcpUrl: string): string;
+/**
+ * The served MCP URL: `PUBLIC_BASE_URL` (the public origin, a path prefix allowed) joined to the `/mcp` endpoint.
+ * Unset, there is no served URL to derive from and the widget declares no domain (development).
+ */
+export declare function servedMcpUrl(env: NodeJS.ProcessEnv): string | undefined;

package/dist/ui/sandboxDomain.js

@@ -0,0 +1,23 @@
+import { createHash } from "node:crypto";
+/** The suffix of every Claude MCP Apps sandbox origin. Half of the derivation, never a whole domain. */
+export const CLAUDE_SANDBOX_SUFFIX = ".claudemcpcontent.com";
+/**
+ * The sandbox domain Claude serves this server's widget from (mcp-app-standard A-11): the first 32 hexadecimal
+ * characters of SHA-256 of the served MCP URL, followed by `.claudemcpcontent.com`. Computed at start from the URL
+ * the server is reached at, never written as a literal: a typed domain is wrong as soon as the URL changes.
+ */
+// allow-local-identity: hashes the PUBLIC served MCP URL to name a sandbox origin; no credential, no caller, no tenant
+export function claudeSandboxDomain(servedMcpUrl) {
+    const label = createHash("sha256").update(servedMcpUrl).digest("hex").slice(0, 32);
+    return `${label}${CLAUDE_SANDBOX_SUFFIX}`;
+}
+/**
+ * The served MCP URL: `PUBLIC_BASE_URL` (the public origin, a path prefix allowed) joined to the `/mcp` endpoint.
+ * Unset, there is no served URL to derive from and the widget declares no domain (development).
+ */
+export function servedMcpUrl(env) {
+    const base = env.PUBLIC_BASE_URL;
+    if (!base)
+        return undefined;
+    return new URL("mcp", base.endsWith("/") ? base : `${base}/`).href;
+}

package/dist/upstream/paginatedClient.js

@@ -133,6 +133,7 @@ function canonicalJson(value) {
     }
     return JSON.stringify(value) ?? "null";
 }
+// allow-local-identity: cache key of an upstream request (path + params); no credential, caller or tenant
 function fingerprint(path, params) {
     return createHash("sha256")
         .update(canonicalJson({ path, params }))

package/dist/verifiedPerson.d.ts

@@ -77,6 +77,12 @@ export interface PersonContext {
 export type PersonRefusalResult = CallToolResult & {
     isError: true;
 };
+/**
+ * The identity layer's refusal for a caller it did not resolve (no resolution in the context = no_verified_session),
+ * or undefined when the caller is resolved. The agent-roles gate answers with it before deciding a role, so an
+ * unresolved caller gets the precise, stable identity code rather than a generic role denial — a refusal either way.
+ */
+export declare function callerRefusal(caller: CallerResolution | undefined, locale: McpLocale): PersonRefusalResult | undefined;
 /**
  * Declares that a tool needs the verified person: the handler runs only with one, and receives it
  * as its second argument. No caller resolution in the context (stdio) is `no_verified_session`.

package/dist/verifiedPerson.js

@@ -98,6 +98,15 @@ function personRefusal(caller, locale) {
         isError: true,
     };
 }
+/**
+ * The identity layer's refusal for a caller it did not resolve (no resolution in the context = no_verified_session),
+ * or undefined when the caller is resolved. The agent-roles gate answers with it before deciding a role, so an
+ * unresolved caller gets the precise, stable identity code rather than a generic role denial — a refusal either way.
+ */
+export function callerRefusal(caller, locale) {
+    const resolution = caller ?? unresolved("no_verified_session");
+    return resolution.ok ? undefined : personRefusal(resolution, locale);
+}
 /**
  * Declares that a tool needs the verified person: the handler runs only with one, and receives it
  * as its second argument. No caller resolution in the context (stdio) is `no_verified_session`.

package/docs/releasing.md

@@ -0,0 +1,19 @@
+# Releasing
+
+A release is cut from `main`, in one pull request, after every change in it has merged.
+
+1. **Fold the changelog.** `npm run changelog:release -- --version <x.y.z>` (optionally `--date YYYY-MM-DD`)
+   inserts `## [x.y.z] - <date>` below `## [Unreleased]`, with every fragment of `changelog.d/` grouped by
+   section, and deletes the folded fragments. `## [Unreleased]` stays, empty. Then add the version's link line
+   at the bottom of `CHANGELOG.md` (`[x.y.z]: <url>`, the npm page of the version when it is published without
+   a git tag); `tests/changelogLinks.test.ts` refuses a version heading with no link line.
+2. **Bump the version** in `package.json` and `mcp-server.json` (they must be equal; `npm run build` refuses
+   a difference), then `npm install --package-lock-only` so the lockfile carries it.
+3. **Build and test**: `npm run build && npm run build:ui && npm test`. `prepublishOnly` runs the same chain,
+   plus the evals, before any publish.
+4. **Open the release PR** through the review flow. Publication happens only from the merged `main`, after
+   the reviewer's npm verdict, and is proven at the registry (full and abbreviated documents, then a fresh
+   consumer install), never by the publish command's output.
+
+Between releases, every pull request adds one fragment to `changelog.d/` (see `changelog.d/README.md`) and
+never touches `CHANGELOG.md`, so parallel pull requests do not conflict on it.

package/mcp-server.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-boilerplate",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "capabilities": {
     "tools": {},
     "resources": {}
@@ -10,5 +10,6 @@
     "streamableHttp": { "path": "/mcp", "stateless": true }
   },
   "features": {},
-  "contextCeiling": { "global": 1200, "perTool": 700 }
+  "contextCeiling": { "global": 1400, "perTool": 700 },
+  "distribution": { "targets": ["claude", "claude-code", "vscode", "cursor", "chatgpt"] }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vantageos/mcp-boilerplate",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "description": "Clonable MCP server skeleton on the official @modelcontextprotocol/server SDK v2 (protocol 2026-07-28 + 2025 legacy, stdio + stateless Streamable HTTP), with its own OAuth 2.1 authorization server (Clerk person + organisation, cloud-identity), MCP Apps UI, tenant scoping, FR/EN i18n and a declarative eval harness.",
   "description_fr": "Squelette de serveur MCP clonable sur le SDK officiel @modelcontextprotocol/server v2 (protocole 2026-07-28 + héritage 2025, stdio + Streamable HTTP sans état), avec son propre serveur d'autorisation OAuth 2.1 (personne + organisation Clerk, cloud-identity), UI MCP Apps, scoping tenant, i18n FR/EN et un harnais d'évaluations déclaratif.",
   "type": "module",
@@ -53,11 +53,15 @@
   "homepage": "https://github.com/elpiarthera/vantage-mcp-boilerplate#readme",
   "author": "ElPi Corp / Laurent Perello",
   "scripts": {
-    "build": "node scripts/clean-dist.mjs && tsc && mkdir -p dist/locales && cp src/locales/en.json src/locales/fr.json dist/locales/ && node scripts/sync-plugin-version.mjs",
+    "build": "node scripts/clean-dist.mjs && tsc && mkdir -p dist/locales && cp src/locales/en.json src/locales/fr.json dist/locales/ && node scripts/sync-plugin-version.mjs && node scripts/listing-kit.mjs --check",
+    "listing:write": "node scripts/listing-kit.mjs",
+    "changelog:check": "node scripts/changelog-assemble.mjs --check",
+    "changelog:release": "node scripts/changelog-assemble.mjs",
     "prepack": "node scripts/check-dist-orphans.mjs",
     "build:ui": "vite build && mv dist/ui-bundle/index.html dist/ui-bundle/widget.html",
     "pretest": "npm run build && npm run build:ui",
     "test": "vitest run",
+    "test:a11y": "vitest run tests/widgetAxe.test.ts",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit",
     "start:http": "node dist/http.js",
@@ -83,7 +87,7 @@
   "dependencies": {
     "@modelcontextprotocol/ext-apps": "^2.0.3",
     "@modelcontextprotocol/server": "^2.3.1",
-    "@vantageos/cloud-identity": "^0.20.2",
+    "@vantageos/cloud-identity": "^0.34.1",
     "@vantageos/mosaic-i18n": "^0.1.1",
     "hono": "^4.13.13",
     "jose": "^6.2.7",
@@ -100,11 +104,14 @@
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
     "@modelcontextprotocol/client": "^2.3.1",
+    "@types/jsdom": "^30.0.0",
     "@types/node": "^20.14.0",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
     "@vitejs/plugin-react": "^4.3.0",
+    "axe-core": "^4.14.0",
     "convex": "1.46.0",
+    "jsdom": "^30.1.3",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "typescript": "^5.7.2",

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "vantage-mcp-boilerplate",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "description": "Clonable MCP server template: SDK v2 on protocol 2026-07-28 (stdio + stateless Streamable HTTP), its own OAuth 2.1 authorization server (Clerk person + organisation), MCP Apps UI, FR/EN i18n and a declarative eval harness. Scaffold, extend, publish.",
   "author": {
     "name": "ElPi Corp / Laurent Perello"

package/scripts/plugin-manifest.source.json

@@ -31,5 +31,24 @@
   "openai": {
     "auth": { "type": "oauth", "client": { "mode": "cimd" } },
     "capabilities": ["Read"]
+  },
+  "listing": {
+    "testPrompts": {
+      "positive": [
+        "tools-call-ping-happy-path",
+        "tools-call-ping-default",
+        "tools-call-list-items-public-tier-unscoped",
+        "tools-call-list-items-page-truncated",
+        "tools-call-list-items-ui-link"
+      ],
+      "negative": [
+        "tools-call-ping-message-too-long-failure",
+        "tools-call-list-items-requires-tenant-refusal-failure",
+        "tools-call-list-items-invalid-cursor-failure"
+      ]
+    },
+    "reviewerAccount": {
+      "howToObtain": "Sign in at the server's /authorize page with any Clerk account; a reviewer organisation is created on request to the maintainers (README, 'Own authorization server'). No credential is stored in this repository."
+    }
   }
 }

package/scripts/readme-fr.mjs

@@ -27,7 +27,9 @@ import { fileURLToPath } from "node:url";
 export const BANNER =
   "<!-- Généré depuis README.md par mcp-readme-fr (@vantageos/mcp-boilerplate) : ne pas modifier à la main. -->";
 
-const MARKER = /^\s*<!--\s*(lang:([A-Za-z-]+)|\/lang)\s*-->\s*$/;
+// A marker sits at the start of a line with at most 3 spaces of indent (CommonMark): 4 or more spaces, or a tab, make
+// the line an indented code block, so such a "marker" is text, copied with the part it sits in, like a fenced one.
+const MARKER = /^ {0,3}<!--\s*(lang:([A-Za-z-]+)|\/lang)\s*-->\s*$/;
 const FENCE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
 
 /** README.md text -> { fr, errors }. `fr` is the README.fr.md content (banner first). */

package/dist/oauth/clientAssertion.d.ts

@@ -1,28 +0,0 @@
-import { type CimdOptions } from "./clientRegistry.js";
-export declare const JWT_BEARER_ASSERTION_TYPE = "urn:ietf:params:oauth:client-assertion-type:jwt-bearer";
-export declare const ASSERTION_SIGNING_ALGS: readonly ["RS256"];
-export type AssertionResult = {
-    ok: true;
-    clientId: string;
-} | {
-    ok: false;
-    reason: string;
-};
-/** Bounded set of accepted jti values, each held until its assertion expires. */
-export declare function createJtiStore(maxEntries?: number): {
-    /** True when the jti is new (and is now recorded); false on a replay or when full. */
-    accept(clientId: string, jti: string, exp: number, nowSeconds: number): boolean;
-};
-export interface AssertionVerifierOptions extends CimdOptions {
-    now?: () => number;
-    jtiStore?: ReturnType<typeof createJtiStore>;
-}
-export declare function createClientAssertionVerifier(options?: AssertionVerifierOptions): {
-    verify(input: {
-        assertionType: string | undefined;
-        assertion: string | undefined;
-        /** The `client_id` request parameter, when sent. */
-        clientId: string | undefined;
-        audiences: string[];
-    }): Promise<AssertionResult>;
-};

package/dist/oauth/clientAssertion.js

@@ -1,106 +0,0 @@
-/**
- * private_key_jwt client authentication at `/token` (RFC 7523 / OIDC Core 9).
- *
- * A presented assertion is VERIFIED, never ignored and never trusted unverified:
- *  - the key set comes from the `jwks_uri` of the client's CIMD document, fetched through the
- *    same SSRF guard as the document itself;
- *  - alg is pinned to RS256 (a document declaring another signing alg is refused), so `none`
- *    and HMAC assertions cannot verify;
- *  - `iss` and `sub` equal the client_id; `aud` is this token endpoint or this issuer; `exp`
- *    is required (30 s skew); `jti` is required and accepted ONCE.
- */
-import { createLocalJWKSet, decodeJwt, jwtVerify } from "jose";
-import { fetchGuardedJson, isUrlShapedClientId, resolveCimdDocument, } from "./clientRegistry.js";
-export const JWT_BEARER_ASSERTION_TYPE = "urn:ietf:params:oauth:client-assertion-type:jwt-bearer";
-export const ASSERTION_SIGNING_ALGS = ["RS256"];
-const SKEW_SECONDS = 30;
-const MAX_JWKS_BYTES = 64 * 1024;
-/** Bounded set of accepted jti values, each held until its assertion expires. */
-export function createJtiStore(maxEntries = 10_000) {
-    const seen = new Map(); // `${clientId}\n${jti}` -> exp (epoch seconds)
-    return {
-        /** True when the jti is new (and is now recorded); false on a replay or when full. */
-        accept(clientId, jti, exp, nowSeconds) {
-            for (const [k, e] of seen)
-                if (e + SKEW_SECONDS <= nowSeconds)
-                    seen.delete(k);
-            const key = `${clientId}\n${jti}`;
-            if (seen.has(key))
-                return false;
-            if (seen.size >= maxEntries)
-                return false; // fail closed: never evict a live jti
-            seen.set(key, exp);
-            return true;
-        },
-    };
-}
-export function createClientAssertionVerifier(options = {}) {
-    const now = options.now ?? (() => Date.now());
-    const jtiStore = options.jtiStore ?? createJtiStore();
-    const fetchOpts = {
-        fetchImpl: options.fetchImpl,
-        resolveHost: options.resolveHost,
-        maxBytes: MAX_JWKS_BYTES,
-        ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),
-    };
-    return {
-        async verify(input) {
-            const fail = (reason) => ({ ok: false, reason });
-            if (input.assertionType !== JWT_BEARER_ASSERTION_TYPE || !input.assertion) {
-                return fail("unsupported client assertion");
-            }
-            // The unverified iss only LOCATES the key set; it is re-checked against the verified claims.
-            let claimedIss;
-            try {
-                claimedIss = decodeJwt(input.assertion).iss;
-            }
-            catch {
-                return fail("malformed client assertion");
-            }
-            if (!claimedIss || !isUrlShapedClientId(claimedIss))
-                return fail("unknown client");
-            if (input.clientId !== undefined && input.clientId !== claimedIss) {
-                return fail("client_id does not match the assertion issuer");
-            }
-            const clientId = claimedIss;
-            const cimd = await resolveCimdDocument(clientId, options);
-            if (!cimd?.jwksUri)
-                return fail("client has no verifiable key set");
-            if (cimd.signingAlg !== undefined &&
-                !ASSERTION_SIGNING_ALGS.includes(cimd.signingAlg)) {
-                return fail("unsupported signing algorithm");
-            }
-            let jwksUrl;
-            try {
-                jwksUrl = new URL(cimd.jwksUri);
-            }
-            catch {
-                return fail("invalid jwks_uri");
-            }
-            const jwks = (await fetchGuardedJson(jwksUrl, fetchOpts));
-            if (!jwks || !Array.isArray(jwks.keys))
-                return fail("key set unavailable");
-            let payload;
-            try {
-                const verified = await jwtVerify(input.assertion, createLocalJWKSet(jwks), {
-                    algorithms: [...ASSERTION_SIGNING_ALGS],
-                    issuer: clientId,
-                    subject: clientId,
-                    audience: input.audiences,
-                    clockTolerance: SKEW_SECONDS,
-                    currentDate: new Date(now()),
-                    requiredClaims: ["iss", "sub", "aud", "exp", "jti"],
-                });
-                payload = verified.payload;
-            }
-            catch {
-                return fail("client assertion rejected");
-            }
-            const exp = payload.exp;
-            if (!payload.jti || !jtiStore.accept(clientId, payload.jti, exp, Math.floor(now() / 1000))) {
-                return fail("client assertion replayed");
-            }
-            return { ok: true, clientId };
-        },
-    };
-}