optimize ApiFromModules type performance

[ssalbdivad]

This pull request optimizes ApiFromModules and adds type-level benchmarks using @ark/attest so that they can be tested and added to CI if desired.

A large portion of the diff will consist of fake_chef files copied from a generated Convex project as a realistic benchmark and can generally be ignored. All meaningful optimizations occurred in src/server/api.ts.

The biggest improvements come from avoiding the creation of intermediate object types, additional intersections, and adding a fast path for modules with no segmented (i.e. A/B) paths.

This lead to a ~27% improvement in type performance on the fast path and ~14% for segmented modules. Similar strategies could be applied to other types in the repo for further improvements, but generally I found the types I reviewed to be relatively efficient and well-written, so props to the team 👏

As mentioned to @thomasballinger, another promising avenue for followup type optimization would be deduplicating object literals defined in _generated/api.d.ts. Here's an example of how that could be achieved:

// current
export declare const components: {
    rateLimiter: {
        lib: {
            checkRateLimit: FunctionReference<
                "query",
                "internal",
                {
                    config:
                        | {
                              capacity?: number
                              kind: "token bucket"
                              maxReserved?: number
                              period: number
                              rate: number
                              shards?: number
                          }
                        | {
                              capacity?: number
                              kind: "fixed window"
                              maxReserved?: number
                              period: number
                              rate: number
                              shards?: number
                              start?: number
                          }
                    count?: number
                    key?: string
                    name: string
                    reserve?: boolean
                    throws?: boolean
                },
                | { ok: true; retryAfter?: number }
                | { ok: false; retryAfter: number }
            >
        }
    }
}

// example optimization (should be reused for other components as well)
interface BaseConfig {
    capacity?: number
    maxReserved?: number
    period: number
    rate: number
    shards?: number
}

interface FixedWindowConfig extends BaseConfig {
    kind: "fixed window"
    start?: number
}

interface TokenBucketConfig extends BaseConfig {
    kind: "token bucket"
}

interface CommonArgs {
    config: FixedWindowConfig | TokenBucketConfig
    count?: number
    key?: string
    name: string
    reserve?: boolean
    throws?: boolean
}

type ReturnType =
    | { ok: true; retryAfter?: number }
    | { ok: false; retryAfter: number }

export declare const components: {
    rateLimiter: {
        lib: {
            checkRateLimit: FunctionReference<
                "query",
                "internal",
                CommonArgs,
                ReturnType
            >
        }
    }
}

Applying a similar approach to a large number of object literals in Prisma's generated types led to a ~50% performance improvement, so this could be very impactful for large projects with many such components.

---

By submitting this pull request, I confirm that you can use, modify, copy, and redistribute this contribution, under the terms of your choice.