Use SpeckleSharp in a Grasshopper C# node

// Grasshopper C# Script — structural layout enrichment
#r "nuget: Speckle.Sdk, 3.21.1"
#r "nuget: Speckle.Objects, 3.21.1"

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Extensions.DependencyInjection;
using Rhino.Geometry;
using Speckle.Objects.Data;
using Speckle.Objects.Geometry;
using Speckle.Sdk;
using Speckle.Sdk.Api;
using Speckle.Sdk.Common;
using Speckle.Sdk.Models;
using Speckle.Sdk.Models.Collections;
using Speckle.Sdk.Models.Extensions;

static class SpeckleBootstrap
{
    static readonly ServiceProvider Provider = new ServiceCollection()
        .AddSpeckleSdk(
            new Application("GH Enrichment", "gh-enrichment"),
            "1.0.0",
            typeof(Point).Assembly
        )
        .BuildServiceProvider();

    public static IOperations Operations => Provider.GetRequiredService<IOperations>();
}

private void RunScript(
    List<Point3d> pts,
    List<Line> gridLines,
    double capacity,
    ref object elementCount,
    ref object summary,
    ref object status)
{
    if (pts == null || pts.Count == 0)
    {
        status = "Provide at least one point.";
        elementCount = 0;
        summary = "";
        return;
    }

    var origin = Point3d.Origin;
    var dataObjects = pts.Select((pt, i) => BuildFooting(pt, i, origin, gridLines, capacity)).ToList();
    var root = BuildRootByQuadrant(dataObjects);

    var flat = root.Flatten().ToList();
    elementCount = flat.Count;
    summary = BuildSummary(dataObjects);
    status = "OK";
}

static DataObject BuildFooting(Point3d pt, int index, Point3d origin, List<Line> gridLines, double capacity)
{
    var dx = pt.X - origin.X;
    var dy = pt.Y - origin.Y;
    var distance = pt.DistanceTo(origin);
    var bearing = Math.Round(Math.Atan2(dy, dx) * (180.0 / Math.PI), 1);
    var demand = distance * 10.0; // stand-in; pipe real analysis from upstream when available
    var utilization = capacity > 0 ? Math.Round(demand / capacity, 3) : 0;

    var specklePoint = new Point(pt.X, pt.Y, pt.Z, Units.Meters);

    return new DataObject
    {
        name = $"Footing {index + 1}",
        properties = new Dictionary<string, object?>
        {
            ["distanceFromOrigin"] = Math.Round(distance, 3),
            ["quadrant"] = Quadrant(dx, dy),
            ["bearing"] = bearing,
            ["utilization"] = utilization,
            ["nearestGridLine"] = NearestGridLineIndex(pt, gridLines),
        },
        displayValue = new List<Base> { specklePoint },
    };
}

static Collection BuildRootByQuadrant(List<DataObject> footings)
{
    var root = new Collection { name = "Structural layout" };

    foreach (var group in footings.GroupBy(f => f.properties["quadrant"] as string ?? "Unknown"))
    {
        var quadrantCollection = new Collection { name = group.Key };
        quadrantCollection.elements.AddRange(group.Cast<Base>());
        root.elements.Add(quadrantCollection);
    }

    return root;
}

static string Quadrant(double dx, double dy)
{
    if (dx >= 0 && dy >= 0) return "NE";
    if (dx < 0 && dy >= 0) return "NW";
    if (dx < 0 && dy < 0) return "SW";
    return "SE";
}

static int NearestGridLineIndex(Point3d pt, List<Line> gridLines)
{
    if (gridLines == null || gridLines.Count == 0) return -1;

    return gridLines
        .Select((line, i) => (i, line.DistanceTo(pt, true)))
        .OrderBy(x => x.Item2)
        .First().i;
}

static string BuildSummary(List<DataObject> footings)
{
    var sb = new StringBuilder();
    sb.AppendLine($"Footings: {footings.Count}");
    sb.AppendLine($"Avg utilization: {footings.Average(f => (double)f.properties["utilization"]):F3}");
    sb.AppendLine("By quadrant:");
    foreach (var g in footings.GroupBy(f => f.properties["quadrant"]))
        sb.AppendLine($"  {g.Key}: {g.Count()}");
    return sb.ToString();
}