fix(terrain): keep cold height requests within the browser deadline (#348)

Use 64-point browser and upstream terrain batches to reduce cold-cache timeouts. Preserve successful chunk results, distinguish absent readings from malformed responses, and reject fabricated zero heights.

Original terrain resilience contribution by ItzDESTAQ, with browser batching, validation and regression follow-up by Sameh Khamis.

Validated with unit/build/format/boundary checks, 108 tracking checks, 5 terrain-outage checks, controlled slow-upstream comparison and live browser checks.

Co-authored-by: ItzDESTAQ <[email protected]>
Co-authored-by: Sameh Khamis <[email protected]>

src/tooling/environmentProviders.test.mjs

@@ -88,18 +88,22 @@ test('terrain middleware chunks missing points and reconstructs repeated/reorder
   const points = Array.from({ length: 257 }, (_, i) => `${i / 100},1`);
   const res = await request('/?points=' + points.join(';'));
   assert.equal(res.status, 200);
-  assert.deepEqual(sizes, [256, 1]);
+  // Tracks UPSTREAM_CHUNK in server/providers/terrain.js (64): 257 points
+  // split into four full chunks and a remainder.
+  assert.deepEqual(sizes, [64, 64, 64, 64, 1]);
   const reordered = await request('/?points=2.56,1;0,1;2.56,1');
   assert.deepEqual(json(reordered), {
     results: [{ ellipsoid: 102.56 }, { ellipsoid: 100 }, { ellipsoid: 102.56 }],
   });
-  assert.equal(calls, 2);
+  // Five chunks for the first batch; the reordered request is fully cached.
+  assert.equal(calls, 5);
   assert.equal((await request('/?points=invalid')).status, 400);
   assert.equal(
     (await request('/?points=' + Array(2001).fill('0,1').join(';'))).status,
     500,
   );
-  assert.equal(calls, 2);
+  // Rejected requests add no upstream calls: still the five from the first batch.
+  assert.equal(calls, 5);
 });
 
 test('terrain middleware migrates valid legacy disk points without fabricating omitted heights', async (t) => {
@@ -254,3 +258,40 @@ test('GBFS keeps host/path/method guards, response caps and distinct information
   );
   assert.equal((await request(target('station_status.json'))).status, 502);
 });
+
+test('terrain middleware retains successful chunks around a failure and retries only missing points', async (t) => {
+  isolate(t);
+  const requests = [];
+  let fail = true;
+  t.mock.method(globalThis, 'fetch', async (raw) => {
+    const points = new URL(raw).searchParams
+      .get('points')
+      .split(';')
+      .map((p) => p.split(',').map(Number));
+    requests.push(points);
+    if (fail && points[0][0] === 0.64) return new Response('', { status: 400 });
+    return Response.json({
+      results: points.map(([lon]) => ({ ellipsoid: lon + 100 })),
+    });
+  });
+  const request = install(terrainHeightsProxy());
+  const points = Array.from({ length: 130 }, (_, i) => `${i / 100},1`);
+  const url = '/?points=' + points.join(';');
+  assert.equal((await request(url)).status, 502);
+  assert.deepEqual(
+    requests.map((p) => p.length),
+    [64, 64, 2],
+  );
+  fail = false;
+  const recovered = await request(url);
+  assert.equal(recovered.status, 200);
+  assert.deepEqual(
+    requests[3],
+    Array.from({ length: 64 }, (_, i) => [(i + 64) / 100, 1]),
+  );
+  assert.deepEqual(
+    json(recovered).results,
+    Array.from({ length: 130 }, (_, i) => ({ ellipsoid: i / 100 + 100 })),
+  );
+  assert.equal(requests.length, 4);
+});