Consider moving the workflow package/listing builds to powershell script files.

[AraHaan]

I feel like the github actions workflow files should instead be converted to powershell scripts.

Why? Because I want to have my packages hosted somewhere other than GitHub such as using bitbucket for the listing website (<username here>.bitbucket.io) for example.
Plus it would allow me to test if building the packages locally on my machine is broken or not when I make changes later to the content of the packages I make as well. Being able to do this without needing to push the updates first and pray that the CI works is a must for me.

[AraHaan]

I think I managed to replace release.yml with a simple .NET 11 console tool (Note: Requires the Preview .NET SDK with dotnet/runtime#123407 merged into the runtime which can be acquired via downloading and installing the daily .NET SDK builds: http://aka.ms/dotnet/11.0.1xx/daily/dotnet-sdk-win-x64.exe or http://aka.ms/dotnet/11.0.1xx/daily/dotnet-sdk-win-x86.exe)

With that I was then able to very closely implement something similar for packing unity packages:

UnityPackageMaker.cs

// namespace here.

internal class UnityPackageMaker
{
    internal static void CreatePackage(string packageFolder, string packagesFolder, string packageName)
    {
        if (Directory.Exists("pkg_tmp"))
        {
            Directory.Delete("pkg_tmp", true);
        }

        foreach (var file in Directory.EnumerateFileSystemEntries(
            packageFolder, "*.meta", SearchOption.AllDirectories))
        {
            var metaLines = OpenAssetMetaFile(file);

            // Extract the guid from the .meta file, which is used by Unity to identify assets.
            var guid = GetAssetGuid(metaLines);

            // Ensure that the full filesystem path is not included in the asset path, and that the path uses forward slashes.
            // Also, remove the .meta extension from the asset path.
            var assetPath = file[..file.IndexOf(".meta")].Replace(packagesFolder, string.Empty).Replace(Path.DirectorySeparatorChar, '/');
            var unityPackageEntryPath = $"pkg_tmp{Path.DirectorySeparatorChar}{guid}";
            Directory.CreateDirectory(unityPackageEntryPath);

            // This is for when the asset is not a folder, as Unity does not include the actual asset file for folders in the .unitypackage,
            // but it does include the .meta file.
            // For non-folder assets, we need to include the actual asset file in the package.
            if (!IsFolderAsset(metaLines))
            {
                File.Copy(file[..file.IndexOf(".meta")], Path.Join(unityPackageEntryPath, "asset"));
            }

            File.Copy(file, Path.Join(unityPackageEntryPath, "asset.meta"));
            File.WriteAllText(Path.Join(unityPackageEntryPath, "pathname"), assetPath);
        }

        TarFile.CreateFromDirectory("pkg_tmp", "archtemp.tar", false, TarEntryFormat.Gnu);
        PackageTarIntoUnityPackage(packageName);
    }

    private static void PackageTarIntoUnityPackage(string packageName)
    {
        Directory.Delete("pkg_tmp", true);
        using (var outputPackage = File.Create($"{packageName}.unitypackage"))
        using (var tarStream = File.OpenRead("archtemp.tar"))
        using (var gzipStream = new GZipStream(outputPackage, CompressionLevel.Fastest))
        {
            tarStream.CopyTo(gzipStream);
        }

        File.Delete("archtemp.tar");
    }

    private static string[] OpenAssetMetaFile(string metaFile)
    {
        var metaFileContent = File.ReadAllText(metaFile);
        return metaFileContent.ReplaceLineEndings().Split(
            Environment.NewLine,
            StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
    }

    private static bool IsFolderAsset(string[] metaLines)
    {
        var result = false;
        foreach (var line in metaLines)
        {
            if (line.Equals("folderAsset: yes"))
            {
                result = true;
                break;
            }
        }

        return result;
    }

    private static string GetAssetGuid(string[] metaLines)
    {
        var result = string.Empty;
        foreach (var line in metaLines)
        {
            if (line.StartsWith("guid: "))
            {
                result = line[6..];
                break;
            }
        }

        return result;
    }
}

Program.cs

global using System.Formats.Tar;
global using System.IO.Compression;
global using System.Text.Json;
// using the namespace for UnityPackageMaker here.

if (args.Length is > 0 and < 2)
{
    if (Directory.Exists("Packages"))
    {
        if (Directory.Exists($"Packages{Path.DirectorySeparatorChar}{args[0]}"))
        {
            var srcDirectory = $"Packages{Path.DirectorySeparatorChar}{args[0]}{Path.DirectorySeparatorChar}";
            var packageJson = JsonDocument.Parse(
                File.ReadAllText($"{srcDirectory}package.json"),
                new JsonDocumentOptions
                {
                    CommentHandling = JsonCommentHandling.Skip,
                    AllowTrailingCommas = true,
                });
            var version = packageJson.RootElement.GetProperty("version").GetString();
            var zipFileName = $"{args[0]}-{version}.zip";
            ZipFile.CreateFromDirectory(srcDirectory, zipFileName);

            // Create a *.unitypackage file for Unity users.
            UnityPackageMaker.CreatePackage(srcDirectory, Path.Join(Environment.CurrentDirectory, "Packages"), $"{args[0]}-{version}");
        }
        else
        {
            Console.WriteLine($"Package folder 'Packages{Path.DirectorySeparatorChar}{args[0]}' does not exist.");
        }
    }
    else
    {
        Console.WriteLine("Packages folder does not exist in the current directory.");
    }
}

Result: all of release.yml reduced to a .NET Console application that can run on Windows, Linux, and MacOS without needing to depend heavily on GitHub Actions so one can say upload their vpm packages to other git services such as bitbucket instead of to just GitHub.