@groma/scanner-csharp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alex Gavrilescu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,55 @@
+# C# scanner
+
+The optional `@groma/scanner-csharp` package uses a prebuilt Roslyn worker and the project's installed .NET SDK. Install the package in Groma, select the project, restore it with normal .NET tooling, then scan. Scanning never installs an SDK, builds the worker, or restores packages.
+
+## Tooling and preparation
+
+The worker requires the .NET 10 runtime. Its Roslyn dependencies are 5.9.0 and MSBuild Locator is 1.11.2. The project separately requires the SDK and reference packs selected by its `global.json`. Both may be installed together: running the worker on .NET 10 does not select SDK 10 for the project.
+
+Use `dotnet` on PATH, or set `DOTNET_HOST_PATH` to the installed dotnet executable. The scanner uses the selected input directory for SDK lookup. [Microsoft's SDK selection documentation](https://learn.microsoft.com/en-us/dotnet/core/versions/selection) explains how `global.json` is found. An unavailable pinned SDK fails instead of using a different SDK.
+
+For a nested project, set `settings` on the existing `csharp` entry in the
+shared `scanners.json` inside `groma/` or `.groma/`. Preserve its installed source:
+
+```json
+{
+  "id": "csharp",
+  "source": "./tools/csharp-scanner-package",
+  "settings": { "input": "src/Library/Library.csproj" }
+}
+```
+
+When `input` is omitted, the scanner selects a single root solution, or a
+single root project when no solution exists. Multiple candidates require an
+explicit `settings.input`. Paths are relative to the repository root. Run a
+new scan or restart the active viewer or watch session after editing settings.
+See the [shared configuration contract](../creating-a-plugin.md#scanner-settings).
+
+Run `dotnet restore Library.csproj` from that input directory, then run `groma scan` from the repository root. Restore uses the project's normal NuGet settings and credentials. On macOS, use a relative restore input from its directory so `/var` and `/private/var` aliases do not enter one restore graph as separate project paths.
+
+Install a prepared local package with `groma scanner add /path/to/csharp-scanner-package`. Release publication is separate from local qualification. The package also exports `checkCSharpReadiness(repositoryRoot, settings)`, used through the same input/tool checks as scanning. It returns the selected input and SDK version; successful readiness does not prove dependency restore or compilation. A missing worker means the package needs preparation; missing tooling or compilation errors must be fixed before scanning can replace architecture evidence.
+
+## Supported input and evidence
+
+The selected qualification example is FluentValidation 12.0.0, commit `5365d9294812c8a5c5a7f4d7447c9a65b79a025b`, selecting `src/FluentValidation/FluentValidation.csproj` with its original SDK selection. Minimal fixtures also exercise in-repository project references and the standard Web SDK header.
+
+Inputs are SDK-style `.csproj`, `.sln`, and `.slnx` files. When input is omitted, one root solution takes precedence over root projects. Multiple candidates require explicit selection. Standard .NET, Web and Worker SDK project headers are accepted, but this is not general framework qualification. Mixed-language graphs, legacy project formats, multiple target-framework contexts, and a file shared by multiple loaded project contexts are rejected.
+
+Each physical C# source has one inventory record. Generated `bin` and `obj` sources are excluded. Roslyn resolves overloads, generic methods, extensions, partial implementations and direct calls. Virtual, interface and delegate dispatch retain uncertainty where the runtime provider is not established. Implicit calls, initializers, generated operations, receiver/delegate value flow, dependency injection and network protocols are not resolved.
+
+Solutions and projects are source roots, with each project linked to its solution
+when a solution is selected. File records identify their project root. A directly
+selected project and its loaded project references are top-level source roots.
+Root membership and operations are temporary evidence. They are not C4 components or proof of business collaborations. Core owns curated source membership and relationship selection; ordinary Markdown readers retain readable descriptions and links under the existing OKF application profile. This plugin introduces no architecture metadata or map level.
+
+`settings` also accepts `configuration` (default `Debug`), `maxProjects` (128), `maxFiles` (20000), and `timeoutSeconds` (120). Exceeded limits fail the scan; they never publish truncated evidence. Any enabled scanner failure prevents reconciliation and preserves the prior map.
+
+## Contributor package build
+
+With .NET 10 SDK installed, restore `plugins/scanners/csharp/dotnet/Groma.CSharpScanner.csproj`, then run:
+
+```sh
+bun scripts/package-csharp-scanner.ts
+```
+
+The build bundles the adapter and publishes a framework-dependent worker into the package. It has no installation scripts and does not include a private SDK. Run the Roslyn tests with `dotnet test plugins/scanners/csharp/dotnet/test/Groma.CSharpScanner.Tests.csproj`.

package/dist/index.js

@@ -0,0 +1,458 @@
+// @bun
+// plugins/scanners/csharp/src/adapter.ts
+import { access } from "fs/promises";
+import path2 from "path";
+import { fileURLToPath } from "url";
+
+// packages/scanner/src/index.ts
+function compare(...values) {
+  return values.join("\x00");
+}
+function uniqueBy(values, key, label) {
+  const seen = new Set;
+  for (const value of values) {
+    const id = key(value);
+    if (seen.has(id))
+      throw new Error(`duplicate ${label}: ${id}`);
+    seen.add(id);
+  }
+  return [...values].sort((left, right) => key(left).localeCompare(key(right)));
+}
+function createScanObservation(input) {
+  const roots = validateRoots(input.roots);
+  const rootIds = new Set(roots.map((root) => root.id));
+  const files = uniqueBy(input.files.map((file) => ({
+    ...file,
+    roots: [...new Set(file.roots)].sort(),
+    symbols: [...new Map(file.symbols.map((symbol) => [
+      compare(symbol.id, symbol.kind),
+      symbol
+    ])).values()].sort((left, right) => {
+      return compare(left.id, left.kind).localeCompare(compare(right.id, right.kind));
+    })
+  })), (file) => file.file, "file path");
+  const filePaths = new Set(files.map((file) => file.file));
+  for (const file of files) {
+    if (file.roots.length === 0)
+      throw new Error(`file has no root: ${file.file}`);
+    for (const root of file.roots) {
+      if (!rootIds.has(root))
+        throw new Error(`file references unknown root: ${root}`);
+    }
+  }
+  for (const diagnostic of input.diagnostics)
+    diagnosticLocation(diagnostic);
+  return {
+    schemaVersion: 1,
+    scanner: input.scanner,
+    roots,
+    files,
+    ...operationEvidence(input, filePaths),
+    diagnostics: [...new Map(input.diagnostics.map((diagnostic) => [
+      diagnosticKey(diagnostic),
+      diagnostic
+    ])).values()].sort((left, right) => {
+      return diagnosticKey(left).localeCompare(diagnosticKey(right));
+    })
+  };
+}
+function validateRoots(input) {
+  const roots = uniqueBy(input, (root) => root.id, "root id");
+  const byId = new Map(roots.map((root) => [root.id, root]));
+  for (const root of roots) {
+    const visited = new Set([root.id]);
+    let parent = root.parent;
+    while (parent !== undefined) {
+      if (visited.has(parent))
+        throw new Error(`root hierarchy contains a cycle: ${parent}`);
+      visited.add(parent);
+      const ancestor = byId.get(parent);
+      if (ancestor === undefined)
+        throw new Error(`root references unknown parent: ${parent}`);
+      parent = ancestor.parent;
+    }
+  }
+  return roots;
+}
+function diagnosticKey(diagnostic) {
+  return compare(diagnostic.severity, diagnostic.code, diagnostic.message, diagnostic.file ?? "", String(diagnostic.line ?? ""));
+}
+function diagnosticLocation(value) {
+  if (value.line !== undefined && (!Number.isInteger(value.line) || Number(value.line) < 1)) {
+    throw new Error("diagnostic.line must be a positive integer");
+  }
+  return {
+    ...value.file === undefined ? {} : { file: string(value.file, "diagnostic.file") },
+    ...value.line === undefined ? {} : { line: Number(value.line) }
+  };
+}
+function object(value, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function string(value, label) {
+  if (typeof value !== "string")
+    throw new Error(`${label} must be a string`);
+  return value;
+}
+function array(value, label) {
+  if (!Array.isArray(value))
+    throw new Error(`${label} must be an array`);
+  return value;
+}
+function parseScanObservation(source) {
+  const value = object(JSON.parse(source), "observation");
+  if (value.schemaVersion !== 1)
+    throw new Error("unsupported scanner schema");
+  const scanner = object(value.scanner, "scanner");
+  return createScanObservation({
+    scanner: {
+      id: string(scanner.id, "scanner.id"),
+      technology: string(scanner.technology, "scanner.technology"),
+      engine: string(scanner.engine, "scanner.engine"),
+      engineVersion: string(scanner.engineVersion, "scanner.engineVersion")
+    },
+    ...parseOperations(value),
+    roots: array(value.roots, "roots").map((entry) => {
+      const root = object(entry, "root");
+      return {
+        id: string(root.id, "root.id"),
+        kind: string(root.kind, "root.kind"),
+        name: string(root.name, "root.name"),
+        ...root.file === undefined ? {} : { file: string(root.file, "root.file") },
+        ...root.parent === undefined ? {} : { parent: string(root.parent, "root.parent") }
+      };
+    }),
+    files: array(value.files, "files").map((entry, index) => {
+      const file = object(entry, `files[${index}]`);
+      return {
+        file: string(file.file, `files[${index}].file`),
+        roots: array(file.roots, "file.roots").map((root) => string(root, "file.root")),
+        symbols: array(file.symbols, `files[${index}].symbols`).map((entry, symbolIndex) => {
+          const symbol = object(entry, `files[${index}].symbols[${symbolIndex}]`);
+          return {
+            id: string(symbol.id, "symbol.id"),
+            name: string(symbol.name, "symbol.name"),
+            kind: string(symbol.kind, "symbol.kind")
+          };
+        })
+      };
+    }),
+    diagnostics: array(value.diagnostics, "diagnostics").map((entry, index) => {
+      const diagnostic = object(entry, `diagnostics[${index}]`);
+      return {
+        severity: string(diagnostic.severity, `diagnostics[${index}].severity`),
+        code: string(diagnostic.code, `diagnostics[${index}].code`),
+        message: string(diagnostic.message, `diagnostics[${index}].message`),
+        ...diagnosticLocation(diagnostic)
+      };
+    })
+  });
+}
+function parseOperations(value) {
+  if (value.operations === undefined) {
+    if (value.invocations !== undefined)
+      throw new Error("invocations require operation declarations");
+    return {};
+  }
+  const operations = array(value.operations, "operations").map((entry) => {
+    const operation = object(entry, "operation");
+    return {
+      id: string(operation.id, "operation.id"),
+      file: string(operation.file, "operation.file"),
+      name: string(operation.name, "operation.name"),
+      ...sourcePosition(operation.position),
+      ...operationTokens(operation)
+    };
+  });
+  const invocations = array(value.invocations, "invocations").map((entry) => {
+    const invocation = object(entry, "invocation");
+    if (typeof invocation.unresolved !== "boolean")
+      throw new Error("invocation.unresolved must be a boolean");
+    if (!Number.isInteger(invocation.line) || Number(invocation.line) < 1)
+      throw new Error("invocation.line must be a positive integer");
+    const binding = invocation.binding === undefined ? undefined : object(invocation.binding, "invocation.binding");
+    if (binding && (!Number.isInteger(binding.line) || Number(binding.line) < 1))
+      throw new Error("binding.line must be a positive integer");
+    return {
+      source: string(invocation.source, "invocation.source"),
+      targets: array(invocation.targets, "invocation.targets").map((target) => string(target, "invocation.target")),
+      unresolved: invocation.unresolved,
+      line: Number(invocation.line),
+      ...sourcePosition(invocation.position),
+      ...invocation.member === undefined ? {} : { member: string(invocation.member, "invocation.member") },
+      ...binding === undefined ? {} : { binding: { file: string(binding.file, "binding.file"), line: Number(binding.line), ...sourcePosition(binding.position) } }
+    };
+  });
+  return { operations, invocations };
+}
+function operationEvidence(input, files) {
+  if (input.operations === undefined && input.invocations !== undefined)
+    throw new Error("invocations require operation declarations");
+  if (input.operations === undefined)
+    return {};
+  const operations = uniqueBy(input.operations, (operation) => operation.id, "operation id");
+  const ids = new Set(operations.map((operation) => operation.id));
+  for (const operation of operations) {
+    if (!files.has(operation.file))
+      throw new Error(`operation references unknown file: ${operation.file}`);
+    sourcePosition(operation.position);
+    validateOperationTokens(operation);
+  }
+  const invocations = input.invocations ?? [];
+  for (const invocation of invocations)
+    validateInvocation(invocation, ids, files);
+  return { operations, invocations };
+}
+function operationTokens(operation) {
+  if (operation.tokens === undefined) {
+    if (operation.startLine !== undefined || operation.endLine !== undefined) {
+      throw new Error("operation range requires tokens");
+    }
+    return {};
+  }
+  if (operation.startLine === undefined || operation.endLine === undefined) {
+    throw new Error("operation tokens require a source range");
+  }
+  if (!Number.isInteger(operation.startLine) || Number(operation.startLine) < 1) {
+    throw new Error("operation.startLine must be a positive integer");
+  }
+  if (!Number.isInteger(operation.endLine) || Number(operation.endLine) < 1) {
+    throw new Error("operation.endLine must be a positive integer");
+  }
+  const startLine = Number(operation.startLine);
+  const endLine = Number(operation.endLine);
+  if (endLine < startLine)
+    throw new Error("operation.endLine must be at or after startLine");
+  return {
+    startLine,
+    endLine,
+    tokens: array(operation.tokens, "operation.tokens").map((token) => string(token, "operation.token"))
+  };
+}
+function validateOperationTokens(operation) {
+  operationTokens({
+    tokens: operation.tokens,
+    startLine: operation.startLine,
+    endLine: operation.endLine
+  });
+}
+function validateInvocation(invocation, ids, files) {
+  sourcePosition(invocation.position);
+  sourcePosition(invocation.binding?.position);
+  if (!invocation.targets.length && !invocation.unresolved)
+    throw new Error("an empty target set must be unresolved");
+  if (!ids.has(invocation.source) || invocation.targets.some((target) => !ids.has(target))) {
+    throw new Error("invocation references unknown operation");
+  }
+  if (invocation.binding && !files.has(invocation.binding.file))
+    throw new Error("invocation binding references unknown file");
+}
+function sourcePosition(position) {
+  if (position === undefined)
+    return {};
+  if (!Number.isInteger(position) || Number(position) < 0)
+    throw new Error("source position must be a non-negative integer");
+  return { position: Number(position) };
+}
+
+// plugins/scanners/csharp/src/config.ts
+import { readdir, stat } from "fs/promises";
+import path from "path";
+var defaults = { configuration: "Debug", maxProjects: 128, maxFiles: 20000, timeoutSeconds: 120 };
+var configName = "csharp scanner settings";
+function positiveInteger(value, key, fallback) {
+  if (value === undefined)
+    return fallback;
+  if (!Number.isSafeInteger(value) || Number(value) < 1)
+    throw new Error(`${configName}: ${key} must be a positive integer`);
+  return Number(value);
+}
+function optionalText(value, key) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "string" || !value.trim())
+    throw new Error(`${configName}: ${key} must be nonempty text`);
+  return value;
+}
+function parseCSharpSettings(config = {}) {
+  for (const key of Object.keys(config)) {
+    if (!["input", ...Object.keys(defaults)].includes(key))
+      throw new Error(`${configName}: unknown setting ${key}`);
+  }
+  const input = optionalText(config.input, "input");
+  const configuration = optionalText(config.configuration, "configuration");
+  return {
+    ...input === undefined ? {} : { input },
+    configuration: configuration ?? defaults.configuration,
+    maxProjects: positiveInteger(config.maxProjects, "maxProjects", defaults.maxProjects),
+    maxFiles: positiveInteger(config.maxFiles, "maxFiles", defaults.maxFiles),
+    timeoutSeconds: positiveInteger(config.timeoutSeconds, "timeoutSeconds", defaults.timeoutSeconds)
+  };
+}
+async function findCSharpInput(root, selected) {
+  if (selected !== undefined)
+    return validateInput(root, selected);
+  const files = (await readdir(root, { withFileTypes: true })).filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
+  const solutions = files.filter((file) => /\.slnx?$/i.test(file));
+  const candidates = solutions.length ? solutions : files.filter((file) => /\.csproj$/i.test(file));
+  if (candidates.length > 1)
+    throw new Error(`Several C# scan inputs exist; set settings.input on the csharp entry in scanners.json: ${candidates.join(", ")}`);
+  return candidates.length ? path.resolve(root, candidates[0]) : undefined;
+}
+async function validateInput(root, selected) {
+  const full = path.resolve(root, selected);
+  const relative = path.relative(root, full);
+  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+    throw new Error("C# scan input must stay inside the repository");
+  if (!/\.(?:csproj|slnx?)$/i.test(full) || !(await stat(full)).isFile())
+    throw new Error("C# input must be an existing .csproj, .sln, or .slnx file");
+  return full;
+}
+
+// plugins/scanners/csharp/src/process.ts
+import { spawn } from "child_process";
+function stopTree(child) {
+  if (child.pid === undefined)
+    return;
+  if (process.platform === "win32") {
+    const killer = spawn("taskkill", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+    killer.on("error", () => child.kill());
+    return;
+  }
+  try {
+    process.kill(-child.pid, "SIGKILL");
+  } catch {
+    child.kill("SIGKILL");
+  }
+}
+function run(command, args, options) {
+  return new Promise((resolve, reject) => {
+    const script = /\.[cm]?js$/.test(command);
+    const child = spawn(script ? process.execPath : command, script ? [command, ...args] : [...args], {
+      cwd: options.cwd,
+      env: { ...process.env, DOTNET_CLI_TELEMETRY_OPTOUT: "1", DOTNET_CLI_WORKLOAD_UPDATE_NOTIFY_DISABLE: "1", ...options.env },
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: process.platform !== "win32",
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    let size = 0;
+    let failure;
+    const fail = (error) => {
+      if (failure)
+        return;
+      failure = error;
+      stopTree(child);
+    };
+    const timer = setTimeout(() => fail(new Error(`C# command exceeded ${options.timeoutSeconds ?? 120} seconds`)), (options.timeoutSeconds ?? 120) * 1000);
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      size += Buffer.byteLength(chunk);
+      if (size > (options.maxOutputBytes ?? 128 * 1024 * 1024))
+        fail(new Error("C# command exceeded the output limit"));
+      else
+        stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      if (Buffer.byteLength(stderr) + Buffer.byteLength(chunk) > 1024 * 1024)
+        fail(new Error("C# command exceeded the diagnostic output limit"));
+      else
+        stderr += chunk;
+    });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (failure)
+        reject(failure);
+      else if (code !== 0)
+        reject(new Error(stderr.trim() || stdout.trim() || `${command} exited ${code}`));
+      else
+        resolve({ stdout, stderr });
+    });
+  });
+}
+
+// plugins/scanners/csharp/src/adapter.ts
+var workerDll = fileURLToPath(new URL("../dist/worker/Groma.CSharpScanner.dll", import.meta.url));
+async function requireWorker(file = workerDll) {
+  try {
+    await access(file);
+  } catch {
+    throw new Error("C# worker is not prepared. Install a prebuilt scanner package; contributors run bun scripts/package-csharp-scanner.ts.");
+  }
+}
+async function prepareCSharpScan(repositoryRoot, settings, dotnet, worker) {
+  const root = path2.resolve(repositoryRoot);
+  const config = parseCSharpSettings(settings);
+  const input = await findCSharpInput(root, config.input);
+  if (!input)
+    throw new Error("No C# input was selected. Set settings.input on the csharp entry in scanners.json or disable the csharp scanner.");
+  await requireWorker(worker);
+  const options = { cwd: path2.dirname(input), timeoutSeconds: config.timeoutSeconds };
+  let sdkVersion;
+  try {
+    sdkVersion = (await run(dotnet, ["--version"], options)).stdout.trim();
+  } catch (error) {
+    throw new Error(`C# project SDK is unavailable. Install the SDK selected by global.json and ensure dotnet is on PATH (or set DOTNET_HOST_PATH). ${String(error)}`);
+  }
+  const runtimes = (await run(dotnet, ["--list-runtimes"], options)).stdout;
+  if (!/^Microsoft\.NETCore\.App 10\./m.test(runtimes))
+    throw new Error("The C# scanner worker requires the .NET 10 runtime alongside the project SDK.");
+  return { root, config, input, sdkVersion };
+}
+async function checkCSharpReadiness(repositoryRoot, settings = {}, dotnet = process.env.DOTNET_HOST_PATH ?? "dotnet", worker = workerDll) {
+  const { input, sdkVersion } = await prepareCSharpScan(repositoryRoot, settings, dotnet, worker);
+  return { input, sdkVersion };
+}
+async function scanCSharpSource(repositoryRoot, settings = {}, dotnet = process.env.DOTNET_HOST_PATH ?? "dotnet", worker = workerDll) {
+  const { root, config, input } = await prepareCSharpScan(repositoryRoot, settings, dotnet, worker);
+  const { stdout } = await run(dotnet, [
+    worker,
+    input,
+    "--root",
+    root,
+    "--configuration",
+    config.configuration,
+    "--max-projects",
+    String(config.maxProjects),
+    "--max-files",
+    String(config.maxFiles)
+  ], { cwd: path2.dirname(input), timeoutSeconds: config.timeoutSeconds });
+  return parseScanObservation(stdout);
+}
+
+// plugins/scanners/csharp/src/index.ts
+var scanner = {
+  id: "csharp",
+  watch: {
+    include: [
+      "**/*.cs",
+      "**/*.csproj",
+      "**/*.sln",
+      "**/*.slnx",
+      "**/*.props",
+      "**/*.targets",
+      "**/global.json",
+      "**/nuget.config",
+      "**/packages.lock.json"
+    ].map((pattern) => pattern.replace(/[a-z]/g, (letter) => `[${letter}${letter.toUpperCase()}]`)),
+    exclude: ["**/[bB][iI][nN]/**", "**/[oO][bB][jJ]/**"]
+  },
+  checkReadiness: async (root, settings) => {
+    await checkCSharpReadiness(root, settings);
+  },
+  scan: scanCSharpSource
+};
+var src_default = scanner;
+export {
+  checkCSharpReadiness,
+  src_default as default
+};

package/dist/worker/BuildHost-net472/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.exe.config

@@ -0,0 +1,68 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <startup>
+    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
+  </startup>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Build" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-15.1.0.0" newVersion="15.1.0.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Build.Framework" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-15.1.0.0" newVersion="15.1.0.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Build.Utilities.Core" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-15.1.0.0" newVersion="15.1.0.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Build.Tasks.Core" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-15.1.0.0" newVersion="15.1.0.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Bcl.AsyncInterfaces" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-10.0.0.1" newVersion="10.0.0.1" />
+      </dependentAssembly>
+    </assemblyBinding>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.IO.Redist" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.1.0.0" newVersion="6.1.0.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="System.Buffers" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.5.0" newVersion="4.0.5.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="System.Memory" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.5.0" newVersion="4.0.5.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="System.Text.Json" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-10.0.0.1" newVersion="10.0.0.1" />
+      </dependentAssembly>
+    </assemblyBinding>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="System.Threading.Tasks.Extensions" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.2.4.0" newVersion="4.2.4.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+</configuration>