rhino.compute: /activechildren reports ready children; no longer spawns

- /activechildren + /active-children report ComputeChildren.CurrentChildCount
  (children READY TO SERVE: port open) instead of the raw OS process count.
  Identical in steady state; differs only while a child is loading.
- Still always 200 with the integer body (0 is a valid answer, not a failure).
- Removed the ?initialize param: no longer spawns. Launching is POST
  /launch-children (fill to SpawnCount) / POST /launch-child.
- Removed the separate /childrenready endpoint (added in 1776326).

Author: fraguada

CHANGELOG.HOPS.md

@@ -4,6 +4,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.17.1] - 2026-08-24
+
+### Added
+
+- Added a configurable child-process startup timeout on rhino.compute: a new `--child-startup-timeout` CLI flag and a matching `RHINO_COMPUTE_CHILD_STARTUP_TIMEOUT` environment variable (clamped to 5-3600 seconds), so the value can be changed on an already-deployed server without editing `web.config`. A child compute.geometry process does not open its port until Rhino, Grasshopper and the compute plug-ins have all finished loading; on a freshly created cloud instance that first load is dominated by on-demand reads of the Rhino + Grasshopper file set from a snapshot-backed volume and can take well over a minute. (The previous fixed 60-second cap is now raised - see Changed.)
+- Added a `RHINO_COMPUTE_CHILDCOUNT` environment variable, equivalent to the existing `--childcount` flag, so the child pool size can be set on an already-deployed server without editing `web.config`. As with the flag, the value is clamped to the `MaxChildren = 64` ceiling.
+- Added a `RHINO_COMPUTE_IDLESPAN` environment variable, equivalent to the existing `--idlespan` flag (clamped to 60-86400 seconds), so the child idle-shutdown period can be set on an already-deployed server without editing `web.config`.
+
+### Changed
+
+- Raised the default child-process startup timeout on rhino.compute from 60 to 300 seconds. The previous value dated from 2021 and was chosen for child processes launched locally by Hops on a developer workstation; on a fresh cloud instance the first child's cold load routinely exceeds 60 seconds, so the first request to every newly provisioned server would fail until a retry warmed the OS file cache. 300 seconds is roughly 2.5x the measured worst-case cold load, with headroom for smaller/burstable instance types and user-installed Grasshopper plug-ins. Override with `--child-startup-timeout` / `RHINO_COMPUTE_CHILD_STARTUP_TIMEOUT`.
+- On a cold-start bootstrap, concurrent first requests that arrive while the first child compute.geometry is still loading now wait for that single in-flight spawn instead of each starting another child. Previously a client that timed out and retried during the (slow) first load could trigger several parallel Rhino + Grasshopper loads that contended for the same first-touch disk reads and slowed each other down. The pool still fills to `--childcount` afterward via the normal background top-up.
+- The `/activechildren` and `/active-children` endpoints now report the number of child compute.geometry processes that are **ready to serve** (their port is open and they are in the pool) rather than the raw count of child OS processes, which previously included children still loading. The endpoints also no longer spawn children: the `?initialize` query parameter (added in 0.17.0) has been removed, and each is now a pure, side-effect-free report that always returns HTTP 200 with the integer count (a count of `0` is a valid answer, not a failure). To launch children, use `POST /launch-children` (fill the pool to the configured `--childcount`) or `POST /launch-child` (add one). This supersedes the `?initialize` behavior described under 0.17.0.
+
 ## [0.17.0] - 2026-06-05
 
 ### Added

src/rhino.compute/ReverseProxy.cs

@@ -125,27 +125,25 @@ await res.WriteAsJsonAsync(new
             app.MapPost("/{*uri}", (HttpRequest req, HttpResponse res) => ProxyRequest(req, res, HttpMethod.Post));
         }
 
-        // GET /activechildren and GET /active-children — return the count of active compute.geometry
-        // child processes. ?initialize=true (default) spawns up to SpawnCount children if none are
-        // running, then returns the count. ?initialize=false just reports the count without spawning,
-        // useful for passive monitoring that shouldn't trigger billing.
+        // GET /activechildren and GET /active-children — report the number of compute.geometry
+        // children READY TO SERVE (port open, in the pool) as a plain integer body. Always 200:
+        // this is a query that always succeeds and "0" is a valid answer (no children ready yet),
+        // so a 503 would wrongly imply the endpoint itself failed. Callers treat > 0 as ready.
+        // Pure report, NO side effects: it never spawns a child, so polling it can never start
+        // the metered software charge. To launch children use POST /launch-children (fill to
+        // SpawnCount) or POST /launch-child (add one).
+        //
+        // NOTE: the count is the READY pool (ComputeChildren.CurrentChildCount), not the raw OS
+        // process count — a child still loading Rhino is not counted until its port is open.
         static async Task ActiveChildrenEndpoint(HttpContext context)
         {
-            bool initialize = true;
-            if (context.Request.Query.TryGetValue("initialize", out var initValue)
-                && bool.TryParse(initValue, out var parsed))
-            {
-                initialize = parsed;
-            }
-            if (initialize)
-                InitializeChildren();
-            await context.Response.WriteAsync($"{ComputeChildren.ActiveComputeCount}");
+            await context.Response.WriteAsync($"{ComputeChildren.CurrentChildCount}");
         }
 
         // POST /shutdown-children — gracefully shut down children. No params = all; ?port=N
         // = just that one. Does not respawn. After shutdown-all, the next /grasshopper request
-        // triggers an auto-spawn back to SpawnCount; to confirm count without re-spawning, poll
-        // /activechildren?initialize=false.
+        // triggers an auto-spawn back to SpawnCount; to confirm the ready count, poll
+        // /activechildren (it never spawns).
         static async Task ShutdownChildrenEndpoint(HttpRequest req, HttpResponse res)
         {
             if (!TryParsePortFilter(req, out int? portFilter, out string parseError))

src/rhino.compute/Startup.cs

@@ -70,7 +70,6 @@ public void Configure(IApplicationBuilder app)
             {
                 builder.MapHealthChecks("/healthcheck");
                 MapValidateEndpoint(builder);
-                MapChildrenReadyEndpoint(builder);
                 ReverseProxyModule.MapEndpoints(builder);
             });
         }
@@ -111,33 +110,5 @@ static void MapValidateEndpoint(Microsoft.AspNetCore.Routing.IEndpointRouteBuild
             });
         }
 
-        // Children-ready probe. Returns 200 once at least one compute.geometry child has
-        // finished loading and can solve geometry; 503 while the pool is still empty or warming.
-        // Unlike the catch-all proxy it does NOT call GetComputeServerBaseUrl, so polling
-        // /childrenready never spawns a child (and never starts the metered software charge).
-        //
-        // Distinct from /activechildren, deliberately: /activechildren counts child PROCESSES
-        // (including ones still loading, whose port is not open yet) and its default can spawn.
-        // /childrenready reports only children READY TO SERVE, as a plain 200/503 so a health
-        // probe can key on the status code. Pair with /healthcheck: healthcheck = the front end
-        // is up; childrenready = geometry can be solved now. (Behind ApiKeyMiddleware when a key
-        // is configured, same as /healthcheck.)
-        static void MapChildrenReadyEndpoint(Microsoft.AspNetCore.Routing.IEndpointRouteBuilder builder)
-        {
-            builder.MapGet("/childrenready", async ctx =>
-            {
-                int ready = ComputeChildren.CurrentChildCount;
-                if (ready > 0)
-                {
-                    ctx.Response.StatusCode = 200;
-                    await ctx.Response.WriteAsync($"Ready ({ready} child process(es) ready to serve)");
-                }
-                else
-                {
-                    ctx.Response.StatusCode = 503;
-                    await ctx.Response.WriteAsync("Not ready (no compute.geometry child ready to serve yet)");
-                }
-            });
-        }
     }
 }