looks like the comment here needs to be updated to reflect that this function is collecting root params

(non-blocking nit)

this function is a pretty clever usage of loops but I worry that what it makes up for in performance it sacrifices in readability. I'm also not 100% sure that this is more performant than the more expressive version, eg:

 for (const params of routeParams) {
    const isDuplicate = unique.some((item) =>
      paramKeys.every((key) => areParamValuesEqual(item[key], params[key]))
    );

    if (!isDuplicate) {
      unique.push(params);
    }
  }

In the worst case, this is O(N * M * K), which I think matches the implementation here as well:

for each params in routeParams (N times):
  for each item in unique (M times):
    for each key in paramKeys (K times):
    // perform comparison

(I actually am curious if the built-in loops that power some/every might be slightly more efficient?)

The only downside to the .some.every version is that each loop of N, we create 2 functions, which is avoided with the looping. I'll defer to @gnoff if this seems alright 😅

I'm partial to the loop code b/c it should be faster both in internal implementation and b/c it creates fewer functions. Typlically for loops can be heavily optimized by JIT and the builtins are only optimized maybe in the newest runtimes and I suspect not likely nearly as much as raw loops. That said I think you can achieve better complexity by tracking the param 'key' becuase the routeParams are in order and spaces aren't allowed.

for /app/[foo]/[bar]/page.tsx
we'd encode
{} -> ''
{ foo: 'f0' } -> 'f0'
{ bar: 'b1', foo: 'f1' } -> 'f1 b1'
{ foo: 'f2', bar: 'b2' } -> 'f2 b2'
And so if you later encountered { bar: 'b2', foo: 'f2' } (same values, different object key order) you'd just recompute 'f2 b2' and see you already produced this result

It doesn't even have to be a string you could also have Maps of Maps but this has fewer objects created

The interesting question is what happens if you had just { bar: 'b3' }. This would really be treated like unknown params from the foo downwards so it should encode as '' since the bar can't be "reached" except if there was a known foo value.