Prompts for your coding agent

You are integrating WayMatrix, an HTTP routing API.

BASE URL      https://api.waymatrix.io
AUTH          the API key raw in the "Authorization" header. No "Bearer " prefix.
              A Bearer prefix is tolerated. On GET you may use ?api_key=<key>.
KEY           read it from an environment variable. Never commit it.

Use only the endpoints named in this prompt. Do not infer others, and do not
guess at parameters — if something you need is not here, say so rather than
inventing it.

THE CONSTRAINT
--------------
An element is one origin paired with one destination, so a request costs
origins x destinations.

THE CAP IS PER TIER, AND IT IS NOT THE SAME NUMBER FOR EVERY KEY.
The service will not accept more than 90,000 elements from anyone
(300 x 300 square), and the smallest published tier cap is
2,500 (50 x 50). Which one applies depends on the key you are
holding, and it changes when the account changes plan.

So DO NOT hardcode a chunk size. Take it as a parameter, default it to
the smaller figure, and let the caller raise it. A splitter sized to the
service ceiling fails every single request on a smaller tier, and the
failure looks like a broken endpoint rather than a chunk size.

Over the cap the request is refused before any work happens, so there
is no partial result to salvage. The rejection names the limit it hit, so
read the cap off the first refusal rather than guessing it.

TASK
----
Write a function that takes any number of origins and destinations and
returns the full matrix, splitting into several requests when it must.

1. Compute origins x destinations. If it fits, send one request.
2. If not, split along DESTINATIONS first and keep origins whole where you
   can — it keeps each response's rows aligned with your origin list and
   makes reassembly a concatenation rather than a join.
3. Send the chunks with limited concurrency, not all at once. Respect 429
   by backing off; see the error-handling prompt.
4. Reassemble into one array of arrays in the original order.
5. Assert the final shape is origins x destinations before returning it.

Billing is per element, not per request, so splitting a job costs exactly
the same as sending it whole. Split for the ceiling, never to save money.

Send each coordinate once: the request takes one "locations" array plus
"sources" and "destinations" arrays of INDICES into it. A point that is
both an origin and a destination does not need to appear twice.

You are integrating WayMatrix, an HTTP routing API.

BASE URL      https://api.waymatrix.io
AUTH          the API key raw in the "Authorization" header. No "Bearer " prefix.
              A Bearer prefix is tolerated. On GET you may use ?api_key=<key>.
KEY           read it from an environment variable. Never commit it.

Use only the endpoints named in this prompt. Do not infer others, and do not
guess at parameters — if something you need is not here, say so rather than
inventing it.

ENDPOINT
--------
      POST /v2/isochrones/driving-car

TASK
----
Add a function that returns the area reachable from a point within a given
travel time, as a polygon you can test other points against.

1. Send {"locations": [[lon, lat]], "range": [1800], "range_type": "time"}.
   Range is in SECONDS when range_type is time, and metres when it is
   distance. 1800 is thirty minutes.
2. Several ranges in one call return nested polygons — ask for [900, 1800]
   rather than making two calls, which costs the same and is one round trip.
3. The result is GeoJSON. Use a point-in-polygon test against it rather than
   re-querying the API per candidate point.

Use this instead of a matrix when the question is "what is within reach"
rather than "how far apart are these". It is one call instead of hundreds.

You are integrating WayMatrix, an HTTP routing API.

BASE URL      https://api.waymatrix.io
AUTH          the API key raw in the "Authorization" header. No "Bearer " prefix.
              A Bearer prefix is tolerated. On GET you may use ?api_key=<key>.
KEY           read it from an environment variable. Never commit it.

Use only the endpoints named in this prompt. Do not infer others, and do not
guess at parameters — if something you need is not here, say so rather than
inventing it.

TASK
----
This codebase calls Google's Routes API computeRouteMatrix. Move it here.
This is a real rewrite, not a base URL change. Map it field by field:

  origins[].waypoint.location.latLng  ->  locations[], as [lon, lat]
  destinations[]...                   ->  "destinations": indices into locations
  travelMode: "DRIVE"                 ->  the profile in the path
  routingPreference                   ->  NO EQUIVALENT. There is no traffic.
  X-Goog-Api-Key header               ->  the "Authorization" header
  X-Goog-FieldMask header             ->  no equivalent; the whole matrix returns
  element.duration ("123s")           ->  durations[i][j], a number of seconds
  element.distanceMeters              ->  distances[i][j], in metres
  element.originIndex/destinationIndex->  not needed; see below

THE TWO THAT WILL BITE:

1. THE COORDINATE ORDER FLIPS. Google names its numbers in an object.
   This API takes [longitude, latitude] as an array. A pair the wrong way
   round is usually still a valid coordinate, so nothing errors — you get
   durations for the wrong place. Check one result against a road you know.

2. GOOGLE'S RESPONSE IS UNORDERED and yours is not. Their documentation
   says elements are not guaranteed to arrive in any order, which is why
   each carries originIndex and destinationIndex. This API returns arrays
   of arrays in the order you sent. DELETE the reindexing code rather than
   porting it, and delete the parser that strips the trailing "s" from
   their duration strings.

Also remove any per-element status handling: a failed pair is null in the
matrix, and a failed request is an HTTP error.

You are integrating WayMatrix, an HTTP routing API.

BASE URL      https://api.waymatrix.io
AUTH          the API key raw in the "Authorization" header. No "Bearer " prefix.
              A Bearer prefix is tolerated. On GET you may use ?api_key=<key>.
KEY           read it from an environment variable. Never commit it.

Use only the endpoints named in this prompt. Do not infer others, and do not
guess at parameters — if something you need is not here, say so rather than
inventing it.

THE BILLING MODEL
-----------------
The billed unit is the element: one origin paired with one destination.
A 200 x 150 matrix costs 30,000 of them whether you send it as one request
or as thirty. Requests that fail are not billed.

The free tier includes 250,000 elements a month and stops rather than billing.

TASK
----
Work out what this project will actually spend.
1. Find every call this codebase makes to a routing or distance API.
2. For each, work out the element count per call: origins x destinations
   for a matrix; a directions call has a flat cost. An isochrone costs more
   the further it reaches — flat at short range, climbing with the square of
   the range — so price those from the ranges this code actually requests.
3. Multiply by how often each runs. Be honest about retries and about
   anything inside a loop — that is where the surprise usually is.
4. Report the monthly total, then say which tier it lands in.
Two things worth checking while you are in there. If the same matrix is
computed repeatedly from unchanged inputs, cache it — results may be stored
indefinitely here, which is not true of every provider. And if a loop calls
the API once per candidate point, one isochrone call may replace all of it.