Static protogen site: WASM core plus TypeScript UI

Replaces the ASP.NET-hosted site in the protobuf-net repo, which was stranded
on netcoreapp3.1/netstandard2.1 by changes to how Blazor projects work.

The .NET side targets net10.0-browser through Microsoft.NET.Sdk.WebAssembly
rather than Blazor, so it is coupled only to the WASM runtime. It exposes
three [JSExport] methods and nothing else; the UI is plain TypeScript with
CodeMirror 6 for both editors. Publish output is a folder of static files,
which is what moves this off active hosting.

Schema parsing and code generation come from the published
protobuf-net.Reflection package. Imports of google/** and protobuf-net/**
resolve from resources embedded in it, so the old server round-trip for
import resolution is gone.

Payload decomposition is new (WireWalker.cs) and does not use ProtoReader.
An analysis tool needs exact byte offsets per component and partial results
on malformed input; walking the span directly gives both. Length-delimited
fields are ambiguous on the wire, so each field leads with a best guess and
keeps the alternatives behind a disclosure, with heuristics to suppress the
readings that are technically valid but almost always wrong.

C# and VB.NET only. The protoc-backed languages needed a server-side native
executable; protoc-as-WASM was investigated and parked, with the reasoning
recorded in the README.

Author: mgravell

.gitattributes

@@ -0,0 +1,6 @@
+* text=auto eol=lf
+
+*.png binary
+*.ico binary
+*.woff binary
+*.woff2 binary

.github/workflows/deploy.yml

@@ -0,0 +1,60 @@
+name: Build and deploy
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: pages
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: npm
+          cache-dependency-path: web/package-lock.json
+
+      - name: Install
+        working-directory: web
+        run: npm ci
+
+      # publishes the WASM project, copies _framework into public/, typechecks, then bundles
+      - name: Build
+        working-directory: web
+        run: npm run build
+
+      - name: Upload artifact
+        if: github.event_name != 'pull_request'
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: web/dist
+
+  deploy:
+    needs: build
+    if: github.event_name != 'pull_request'
+    runs-on: ubuntu-latest
+    permissions:
+      pages: write
+      id-token: write
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - id: deployment
+        uses: actions/deploy-pages@v4

.gitignore

@@ -0,0 +1,13 @@
+# .NET
+bin/
+obj/
+*.user
+
+# node
+node_modules/
+
+# build output
+web/dist/
+
+# generated by web/scripts/build-wasm.mjs from the .NET publish; never commit
+web/public/_framework/

LICENCE.txt

@@ -0,0 +1,23 @@
+The core Protocol Buffers technology is provided courtesy of Google.
+At the time of writing, this is released under the BSD license.
+Full details can be found here:
+
+http://code.google.com/p/protobuf/
+
+The protobuf-net logo is Copyright 2021 onwards Marc Gravell; you must
+not use this logo (or any derivative) in your own works without explicit
+permission.
+
+This .NET implementation is Copyright 2008 onwards Marc Gravell
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,81 @@
+# protogen site
+
+The site behind **[protogen.marcgravell.com](https://protogen.marcgravell.com)**: generate C# and
+VB.NET from `.proto` schemas, and pull apart raw protobuf payloads without a schema.
+
+Everything runs in the browser. There is no server, no API and no upload — schemas and payloads
+never leave the machine they were pasted on. The site is a folder of static files.
+
+This replaces the older ASP.NET-hosted site that lived in the
+[protobuf-net](https://github.com/protobuf-net/protobuf-net) repo under `src/protogen.site`.
+
+## How it works
+
+| Layer | What it is |
+| --- | --- |
+| `src/ProtoGen.Wasm` | .NET 10 targeting `net10.0-browser` via `Microsoft.NET.Sdk.WebAssembly` — **not** Blazor. Exposes three `[JSExport]` methods and nothing else. |
+| `web` | Plain TypeScript + Vite. CodeMirror 6 for both editors. No UI framework. |
+
+The schema work is done by the published [`protobuf-net.Reflection`](https://www.nuget.org/packages/protobuf-net.Reflection)
+package — the same parser and generators as the `protogen` command-line tool. Imports of
+`google/**` and `protobuf-net/**` resolve from resources embedded in that package, so the common
+cases need no network access.
+
+The payload decomposition is local to this repo (`WireWalker.cs`). It deliberately does not use
+`ProtoReader`: an analysis tool needs exact byte offsets for every component and partial results on
+malformed input, neither of which a serializer's reader is built to give.
+
+Total download is roughly 1.7 MB brotli-compressed, most of which is the .NET runtime, cached
+after first visit.
+
+## Building
+
+Requires the .NET 10 SDK and Node 20+.
+
+```sh
+cd web
+npm install
+npm run dev      # publishes the WASM project, then starts Vite on :5180
+npm run build    # -> web/dist, ready to serve as static files
+```
+
+`npm run wasm` alone re-publishes the .NET side into `web/public/_framework`. That folder is
+generated and git-ignored; it is copied verbatim rather than bundled, because the .NET boot process
+resolves its own content-hashed filenames.
+
+## Deployment
+
+GitHub Actions builds on push to `main` and publishes `web/dist` to GitHub Pages
+(`.github/workflows/deploy.yml`).
+
+Two details that matter for Pages:
+
+- `web/public/CNAME` carries the custom domain. DNS needs a `CNAME` record for `protogen`
+  pointing at `protobuf-net.github.io`. Delete the file to test on the default
+  `*.github.io` URL first.
+- `web/public/.nojekyll` stops Jekyll stripping the `_framework` directory, which would otherwise
+  be ignored for starting with an underscore. The artifact-based deploy does not run Jekyll, but
+  the file guards against a future switch to branch-based publishing.
+
+## Scope
+
+**C# and VB.NET only.** The old site also offered C++, Java, JavaScript, Objective-C, PHP, Python
+and Ruby by shelling out to `protoc` on the server. `protoc` is a native executable and cannot run
+client-side, so those targets are gone rather than quietly broken.
+
+Compiling `protoc` itself to WebAssembly was investigated and parked. There is no maintained build:
+`kwonoj/protobuf-wasm` and `mjz20/protobuf_wasm` patch the protobuf *runtime* for Emscripten and
+explicitly do not build the compiler, and the one recent attempt at the compiler proper
+([protobuf#20819](https://github.com/protocolbuffers/protobuf/issues/20819)) produces a `protoc.js`
+that builds but fails code generation on path resolution. The real work is MEMFS plumbing for
+`--proto_path` and generated outputs, unmaintained upstream, on top of a C++ binary that links
+every language generator and would likely dwarf the .NET runtime.
+
+If a target language is ever worth restoring, JavaScript/TypeScript is the cheap one: `protobufjs`
+and `@bufbuild/protobuf` generate it in pure JS with no `protoc` involved.
+
+See [`docs/trimming.md`](docs/trimming.md) for why the build suppresses `IL2104`.
+
+## Licence
+
+Apache-2.0, matching protobuf-net.

docs/trimming.md

@@ -0,0 +1,53 @@
+# Trimming and the `IL2104` suppression
+
+`ProtoGen.Wasm.csproj` publishes with `PublishTrimmed` and `TrimMode=full`, and suppresses
+`IL2104` ("assembly produced trim warnings"). This note records what was checked, so the
+suppression is a decision rather than a shrug.
+
+## What warns, and why it does not matter here
+
+The warnings come from `protobuf-net.Core`, and every one of them is on the *reflection-based
+serializer* — the machinery that builds a serializer for an arbitrary `[ProtoContract]` type at
+runtime:
+
+| Location | Warning | Path |
+| --- | --- | --- |
+| `Internal/DynamicStub.cs` | `IL2055`, `IL2067`, `IL2070` | `MakeGenericType` / `Activator.CreateInstance` for runtime-built serializers |
+| `Helpers.cs` | `IL2070` | `Type.GetConstructor` |
+| `Internal/TypeHelperT.cs` | `IL2070` | `Type.GetInterfaces` for collection discovery |
+| `Meta/TypeModel.cs` | `IL2067` | `Activator.CreateInstance` for list and auxiliary types |
+| `ProtoWriter.State.WriteMethods.cs` | `IL2098` | a `DynamicallyAccessedMembers` attribute on a non-`Type` parameter |
+
+This site never reaches that code. It uses two things from the package graph:
+
+1. **`protobuf-net.Reflection`'s parser and code generators** — plain object-graph work over the
+   descriptor model, no runtime type resolution.
+2. **`CustomProtogenSerializer`** — for reading protobuf-net's own custom options out of a
+   descriptor. That is a hand-written `TypeModel` with explicit `ISerializer<T>` implementations
+   for every descriptor type, so it resolves serializers statically and never consults the
+   reflection path above.
+
+The site does not serialize user types, so `RuntimeTypeModel` is never touched.
+
+## The one warning that is on our path
+
+`protobuf-net.Reflection/TokenExtensions.cs` raises `IL2090`: `EnumCache<T>` calls
+`Type.GetFields` on `T` without a `[DynamicallyAccessedMembers(PublicFields)]` annotation. This
+*is* on the parse path — it backs enum parsing in the `.proto` DSL.
+
+It survives today because the trimmer keeps enum fields in practice, and the enums in question are
+referenced directly from code the trimmer can see. It is nonetheless an annotation gap in the
+library rather than something this repo can fix locally; the proper fix is a one-line attribute
+upstream in protobuf-net.
+
+**If enum-valued options in schemas ever start failing to parse in a published build, look here
+first.**
+
+## How to re-check
+
+```sh
+dotnet publish src/ProtoGen.Wasm -c Release 2>&1 | grep -E "IL[0-9]{4}"
+```
+
+If a warning appears from an assembly or a code path not listed above, do not extend the
+suppression — work out whether the new path is actually reachable first.

global.json

@@ -0,0 +1,7 @@
+{
+  "sdk": {
+    "version": "10.0.100",
+    "rollForward": "latestFeature",
+    "allowPrerelease": false
+  }
+}

src/ProtoGen.Wasm/Codegen.cs

@@ -0,0 +1,89 @@
+using Google.Protobuf.Reflection;
+using ProtoBuf.Reflection;
+
+namespace ProtoGen.Wasm;
+
+/// <summary>
+/// Wraps protobuf-net.Reflection's parser and code generators.
+/// </summary>
+/// <remarks>
+/// Imports of <c>google/**</c> and <c>protobuf-net/**</c> resolve from resources embedded in
+/// protobuf-net.Reflection, so the common cases need no network access and no server. Any other
+/// import fails with protobuf-net's own "unable to find" diagnostic, which is the honest answer:
+/// there is no filesystem here to find it on.
+/// </remarks>
+internal static class Codegen
+{
+    public static GenerateResponse Generate(GenerateRequest request)
+    {
+        var response = new GenerateResponse();
+        try
+        {
+            var set = new FileDescriptorSet();
+            string fileName = string.IsNullOrWhiteSpace(request.FileName) ? "my.proto" : request.FileName.Trim();
+            set.Add(fileName, includeInOutput: true, new StringReader(request.Schema ?? ""));
+            set.Process();
+
+            bool fatal = false;
+            foreach (var error in set.GetErrors())
+            {
+                response.Errors.Add(new SchemaError
+                {
+                    IsError = error.IsError,
+                    LineNumber = error.LineNumber,
+                    ColumnNumber = error.ColumnNumber,
+                    Length = error.Text?.Length ?? 0,
+                    Message = error.Message,
+                    ErrorNumber = error.ErrorNumber,
+                    File = error.File ?? "",
+                });
+                if (error.IsError) fatal = true;
+            }
+
+            // warnings are worth showing alongside output; errors mean there is no output to show
+            if (fatal) return response;
+
+            var generator = ResolveGenerator(request.Language);
+            var normalizer = ResolveNormalizer(request.NamingConvention);
+            foreach (var file in generator.Generate(set, normalizer, BuildOptions(request)))
+            {
+                response.Files.Add(new GeneratedFile { Name = file.Name, Text = file.Text });
+            }
+        }
+        catch (Exception ex)
+        {
+            response.Exception = $"{ex.GetType().Name}: {ex.Message}";
+        }
+        return response;
+    }
+
+    private static CodeGenerator ResolveGenerator(string? language) => language?.ToLowerInvariant() switch
+    {
+        "csharp" or "c#" or null or "" => CSharpCodeGenerator.Default,
+        "vb" or "vbnet" or "vb.net" => VBCodeGenerator.Default,
+        _ => throw new ArgumentException(
+            $"'{language}' is not supported. This tool generates C# and VB.NET via protobuf-net's own " +
+            "generators; the other languages protoc supports need protoc itself, which cannot run in a browser."),
+    };
+
+    private static NameNormalizer ResolveNormalizer(string? convention) => convention?.ToLowerInvariant() switch
+    {
+        "original" or "none" => NameNormalizer.Null,
+        "noplural" => NameNormalizer.NoPlural,
+        _ => NameNormalizer.Default,
+    };
+
+    private static Dictionary<string, string> BuildOptions(GenerateRequest request)
+    {
+        var options = new Dictionary<string, string>();
+        if (!string.IsNullOrWhiteSpace(request.LanguageVersion)) options["langver"] = request.LanguageVersion!;
+        if (request.Services) options["services"] = "yes";
+        if (request.OneOfEnum) options["oneof"] = "enum";
+        if (request.ListSet) options["listset"] = "yes";
+        if (request.DisableNullWrappers) options["nullwrappers"] = "false";
+        if (request.DisableCompatLevel) options["compatlevel"] = "false";
+        if (request.NullableValueType) options["nullablevaluetype"] = "yes";
+        if (request.RepeatedAsList) options["repeatedaslist"] = "yes";
+        return options;
+    }
+}