Fix .NET build break and float hook timestamps for hooks.invoke

CLI 1.0.71 promoted hooks.invoke to an internal client-global RPC method.
The C# codegen still emitted its internal request/result DTOs behind a public
IHooksHandler surface, producing CS0050/CS0051 inconsistent-accessibility
errors that broke the entire .NET build. It also registered a second, unwired
hooks.invoke handler that would shadow the working handwritten one.

Filter internal client-global and client-session methods in the C# code
generator so no generated interface, handler property, or RPC registration is
emitted for internal methods like hooks.invoke. The handwritten
SetLocalRpcMethod(hooks.invoke, ...) registration continues to serve hooks.
This mirrors, for .NET's static typing, the routing fixes already applied to
Node, Python, and Go.

Also tolerate hook timestamp epoch milliseconds encoded as either JSON
integers or floats in UnixMillisecondsDateTimeOffsetConverter, covering the
CLI 1.0.71 float serialization (matching the Rust fix).

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 94a20428-6b0e-4733-a354-0abf2d186320

Author: stephentoub

dotnet/src/Generated/Rpc.cs

@@ -13,8 +13,14 @@ namespace GitHub.Copilot;
 public sealed class UnixMillisecondsDateTimeOffsetConverter : JsonConverter<DateTimeOffset>
 {
     /// <inheritdoc />
-    public override DateTimeOffset Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) =>
-        DateTimeOffset.FromUnixTimeMilliseconds(reader.GetInt64());
+    public override DateTimeOffset Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        // The CLI may serialize the epoch-millisecond timestamp as a JSON integer
+        // or as a floating-point number (e.g. 1700000000000.0). GetInt64 throws on a
+        // fractional token, so fall back to reading a double and truncating.
+        long milliseconds = reader.TryGetInt64(out long value) ? value : (long)reader.GetDouble();
+        return DateTimeOffset.FromUnixTimeMilliseconds(milliseconds);
+    }
 
     /// <inheritdoc />
     public override void Write(Utf8JsonWriter writer, DateTimeOffset value, JsonSerializerOptions options) =>

dotnet/src/UnixMillisecondsDateTimeOffsetConverter.cs

@@ -27,6 +27,7 @@ import {
     findSharedSchemaDefinitions,
     postProcessSchema,
     propagateInternalVisibility,
+    filterNodeByVisibility,
     resolveRef,
     resolveObjectSchema,
     resolveSchema,
@@ -2490,11 +2491,23 @@ function generateRpcCode(
     let sessionRpcParts: string[] = [];
     if (schema.session) sessionRpcParts = emitSessionRpcClasses(schema.session, classes);
 
+    // Client handler surfaces (interfaces, handler properties, RPC registration)
+    // are only generated for public methods. Internal client methods (e.g.
+    // `hooks.invoke`) are runtime transport plumbing and must not surface any
+    // generated code — including their request/result DTOs, which would
+    // otherwise leak as `internal` types referenced by a `public` handler
+    // interface (CS0050/CS0051 inconsistent accessibility).
     let clientSessionParts: string[] = [];
-    if (schema.clientSession) clientSessionParts = emitClientSessionApiRegistration(schema.clientSession, classes);
+    if (schema.clientSession) {
+        const publicClientSession = filterNodeByVisibility(schema.clientSession, "public");
+        if (publicClientSession) clientSessionParts = emitClientSessionApiRegistration(publicClientSession, classes);
+    }
 
     let clientGlobalParts: string[] = [];
-    if (schema.clientGlobal) clientGlobalParts = emitClientGlobalApiRegistration(schema.clientGlobal, classes);
+    if (schema.clientGlobal) {
+        const publicClientGlobal = filterNodeByVisibility(schema.clientGlobal, "public");
+        if (publicClientGlobal) clientGlobalParts = emitClientGlobalApiRegistration(publicClientGlobal, classes);
+    }
 
     const lines: string[] = [];
     lines.push(`${COPYRIGHT}