@unitninety/site-kit 0.0.0-stage → 1.6.2

package/src/features/server/gateway.ts

@@ -0,0 +1,318 @@
+import { verifyWithDeadline } from './verification'
+import { z } from 'zod'
+import {
+  AskAiInputSchema,
+  AiRatingInputSchema,
+  AiConversationPageSchema,
+  AI_RECOVERY_MAX_BYTES,
+  FeedbackSubmissionSchema,
+  FeedbackVerificationSchema,
+  parseSearchQuery,
+  SearchResponseSchema,
+  SEARCH_RESPONSE_BYTES,
+  FeedbackWidgetSettingsSchema,
+  AskAiWidgetSettingsSchema,
+  PublicFeatureBaseSchema,
+  FeatureErrorCodeSchema,
+} from '../contracts'
+import {
+  failure,
+  FeatureFailure,
+  FEATURE_PREFIX,
+  readBoundedJSON,
+  upstreamFetch,
+  matchAskAiRoute,
+} from './http'
+import { SessionInputSchema, sessionCookie, visitorCookie, TOKEN_PATTERN } from './session'
+export type FeatureEnvironment = { PLATFORM_URL: string; PAYLOAD_API_KEY: string; SITE_URL: string }
+export type VerifyVisitor = (
+  request: Request,
+) => Promise<{ ok: true } | { ok: false; retryable: boolean }>
+export type SiteFeaturesOptions = {
+  env: FeatureEnvironment
+  /** Set only for server-verified test traffic, never from browser input. */
+  testPreview?: boolean
+  /** Server-verified environment namespace; never derived from browser input. */
+  visitorCookieName?: string
+  fetch?: typeof fetch
+  verifyVisitor?: VerifyVisitor
+  resolveClientIdentity?: (request: Request) => Promise<string | undefined>
+}
+export function createSiteFeatures(options: SiteFeaturesOptions) {
+  const { env } = options
+  const handle = async (request: Request): Promise<Response> => {
+    let requestId: string | undefined
+    try {
+      const url = new URL(request.url)
+      const aiRoute = matchAskAiRoute(request.method, url)
+      const operation = aiRoute
+        ? 'ask-ai'
+        : url.pathname === FEATURE_PREFIX + '/verify' && request.method === 'POST'
+          ? 'verify'
+          : url.pathname === FEATURE_PREFIX + '/config' && request.method === 'GET'
+            ? 'config'
+            : url.pathname === FEATURE_PREFIX + '/session' && request.method === 'POST'
+              ? 'session'
+              : url.pathname === FEATURE_PREFIX + '/feedback' && request.method === 'POST'
+                ? 'feedback'
+                : url.pathname === FEATURE_PREFIX + '/search' && request.method === 'GET'
+                  ? 'search'
+                  : undefined
+      if (!operation || (operation !== 'search' && operation !== 'ask-ai' && url.search))
+        return failure('not_found')
+      const query = operation === 'search' ? parseSearchQuery(url.searchParams) : null
+      if (operation === 'search' && !query) return failure('invalid_request')
+      const origin = new URL(env.SITE_URL).origin
+      const platform = new URL(env.PLATFORM_URL)
+      if (
+        !['http:', 'https:'].includes(platform.protocol) ||
+        platform.username ||
+        platform.password ||
+        !env.PAYLOAD_API_KEY
+      )
+        throw new FeatureFailure('unavailable')
+      if (
+        operation !== 'config' &&
+        operation !== 'search' &&
+        !(aiRoute?.operation === 'conversation' && !request.headers.has('origin')) &&
+        request.headers.get('origin') !== origin
+      )
+        return failure('forbidden')
+      const headers = new Headers({
+        authorization: `Bearer ${env.PAYLOAD_API_KEY}`,
+        'x-u90-feature-audience': origin,
+      })
+      if (aiRoute) {
+        const cookie = visitorCookie(request, options.visitorCookieName)
+        if (!cookie) throw new FeatureFailure('unauthorized')
+        headers.set('x-u90-feature-session', cookie)
+        let body: unknown
+        if (aiRoute.operation !== 'conversation') {
+          if (request.headers.get('content-type')?.split(';')[0].trim() !== 'application/json')
+            throw new FeatureFailure('invalid_request')
+          const raw = await readBoundedJSON(request)
+          const parsed =
+            aiRoute.operation === 'message'
+              ? AskAiInputSchema.safeParse(raw)
+              : AiRatingInputSchema.safeParse(raw)
+          if (!parsed.success) throw new FeatureFailure('invalid_request')
+          body = parsed.data
+          requestId = parsed.data.requestId.toLowerCase()
+          headers.set('content-type', 'application/json')
+        }
+        const response = await upstreamFetch(
+          options.fetch ?? fetch,
+          new URL(url.pathname + url.search, platform).href,
+          {
+            method: request.method,
+            headers,
+            ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+          },
+          AbortSignal.any([request.signal, AbortSignal.timeout(95000)]),
+        )
+        if (!response.ok) {
+          const data = await readBoundedJSON(response)
+          const error = (data as { error?: { code?: unknown; retryAfter?: number } })?.error
+          const parsed = FeatureErrorCodeSchema.safeParse(error?.code)
+          throw new FeatureFailure(parsed.success ? parsed.data : 'unavailable', error?.retryAfter)
+        }
+        if (aiRoute.operation === 'message') {
+          if (
+            response.status !== 200 ||
+            response.headers.get('content-type')?.split(';')[0].trim() !== 'text/event-stream' ||
+            !response.body
+          ) {
+            await response.body?.cancel()
+            throw new FeatureFailure('unavailable')
+          }
+          return new Response(response.body, {
+            headers: {
+              'content-type': 'text/event-stream; charset=utf-8',
+              'cache-control': 'no-store',
+              'x-accel-buffering': 'no',
+            },
+          })
+        }
+        let raw: unknown
+        try {
+          raw = await readBoundedJSON(
+            response,
+            aiRoute.operation === 'conversation' ? AI_RECOVERY_MAX_BYTES : undefined,
+          )
+        } catch {
+          throw new FeatureFailure('unavailable')
+        }
+        const parsed =
+          aiRoute.operation === 'conversation'
+            ? AiConversationPageSchema.safeParse(raw)
+            : z.strictObject({ version: z.literal(1), ok: z.literal(true) }).safeParse(raw)
+        if (!parsed.success || response.status !== 200) throw new FeatureFailure('unavailable')
+        return Response.json(parsed.data, { headers: { 'cache-control': 'no-store' } })
+      }
+      let upstreamStatus = 200
+      const exchange = async (body?: unknown) => {
+        const response = await upstreamFetch(
+          options.fetch ?? fetch,
+          new URL(
+            FEATURE_PREFIX + '/' + operation + (query ? '?' + new URLSearchParams(query) : ''),
+            platform,
+          ).href,
+          {
+            method: request.method,
+            headers,
+            body: body === undefined ? undefined : JSON.stringify(body),
+          },
+          request.signal,
+        )
+        upstreamStatus = response.status
+        let data: unknown
+        try {
+          data = await readBoundedJSON(
+            response,
+            operation === 'search' ? SEARCH_RESPONSE_BYTES : undefined,
+          )
+        } catch {
+          throw new FeatureFailure('unavailable')
+        }
+        if (!response.ok) {
+          const error = (data as { error?: { code?: unknown; retryAfter?: number } })?.error
+          const parsed = FeatureErrorCodeSchema.safeParse(error?.code)
+          const code = parsed.success ? parsed.data : 'unavailable'
+          throw new FeatureFailure(code, error?.retryAfter)
+        }
+        return data
+      }
+      if (operation === 'config') {
+        const parsed = PublicFeatureBaseSchema.safeParse(await exchange())
+        if (!parsed.success) throw new FeatureFailure('unavailable')
+        const { version, revision, enabled, feedback, consent, askAi, verification } = parsed.data
+        return Response.json(
+          {
+            version,
+            revision,
+            ...(verification ? { verification } : {}),
+            ...(consent ? { consent } : {}),
+            feedback: FeedbackWidgetSettingsSchema.parse(feedback ?? {}),
+            askAi: AskAiWidgetSettingsSchema.parse(askAi ?? {}),
+            enabled: {
+              search: enabled.search,
+              askAi: enabled.askAi,
+              feedback: enabled.feedback,
+              consent: enabled.consent,
+            },
+          },
+          { headers: { 'cache-control': 'no-store' } },
+        )
+      }
+      if (operation === 'search') {
+        const identity = await options.resolveClientIdentity?.(request)
+        if (identity !== undefined) {
+          if (!identity || new TextEncoder().encode(identity).length > 512)
+            throw new FeatureFailure('unavailable')
+          headers.set('x-u90-feature-client', encodeURIComponent(identity))
+        }
+        const parsed = SearchResponseSchema.safeParse(await exchange())
+        if (!parsed.success || upstreamStatus !== 200) throw new FeatureFailure('unavailable')
+        return Response.json(parsed.data, { headers: { 'cache-control': 'no-store' } })
+      }
+      if (request.headers.get('content-type')?.split(';')[0].trim() !== 'application/json')
+        throw new FeatureFailure('invalid_request')
+      if (operation === 'feedback' || operation === 'verify') {
+        const input = (
+          operation === 'feedback' ? FeedbackSubmissionSchema : FeedbackVerificationSchema
+        ).safeParse(await readBoundedJSON(request))
+        if (!input.success) throw new FeatureFailure('invalid_request')
+        requestId = input.data.body.requestId
+        const cookie = visitorCookie(request, options.visitorCookieName)
+        if (!cookie) throw new FeatureFailure('unauthorized')
+        headers.set('content-type', 'application/json')
+        headers.set('x-u90-feature-session', cookie)
+        if (operation === 'verify') {
+          const result = z
+            .strictObject({ grant: z.string().min(1).max(4096) })
+            .safeParse(await exchange(input.data))
+          if (!result.success) throw new FeatureFailure('unavailable')
+          return Response.json(result.data, { headers: { 'cache-control': 'no-store' } })
+        }
+        const receipt = z
+          .object({ submissionId: z.string().min(1).max(128), receivedAt: z.iso.datetime() })
+          .safeParse(await exchange(input.data))
+        if (!receipt.success || ![200, 201].includes(upstreamStatus))
+          throw new FeatureFailure('unavailable')
+        return Response.json(receipt.data, {
+          status: upstreamStatus,
+          headers: { 'cache-control': 'no-store' },
+        })
+      }
+      const input = SessionInputSchema.safeParse(await readBoundedJSON(request))
+      if (!input.success) throw new FeatureFailure('invalid_request')
+      requestId = input.data.requestId
+      headers.set('content-type', 'application/json')
+      const cookie = visitorCookie(request, options.visitorCookieName)
+      if (cookie) {
+        headers.set('x-u90-feature-session', cookie)
+        try {
+          const resumed = await exchange({
+            requestId,
+            mode: input.data.mode === 'identity' ? 'identity' : 'resume',
+          })
+          if ((resumed as { ok?: unknown })?.ok !== true) throw new FeatureFailure('unavailable')
+          const token = (resumed as { token?: unknown }).token
+          return Response.json(
+            { version: 1, ok: true },
+            {
+              headers: {
+                'cache-control': 'no-store',
+                ...(typeof token === 'string' && TOKEN_PATTERN.test(token)
+                  ? { 'set-cookie': sessionCookie(token, origin, options.visitorCookieName, options.testPreview) }
+                  : {}),
+              },
+            },
+          )
+        } catch (error) {
+          if (!(error instanceof FeatureFailure) || error.code !== 'unauthorized') throw error
+        }
+      }
+      if (input.data.proof === undefined && input.data.mode !== 'identity')
+        throw new FeatureFailure('verification_required')
+      if (options.verifyVisitor && input.data.proof) {
+        const result = await verifyWithDeadline(
+          options.verifyVisitor,
+          request.url,
+          input.data.proof,
+          request.signal,
+        )
+        if (!result.ok)
+          throw new FeatureFailure(result.retryable ? 'unavailable' : 'verification_required')
+      }
+      const issued = (await exchange({
+        requestId,
+        mode: input.data.mode === 'identity' ? 'identity' : 'issue',
+        proof: input.data.proof,
+      })) as {
+        ok?: unknown
+        token?: unknown
+      }
+      if (
+        issued?.ok !== true ||
+        typeof issued.token !== 'string' ||
+        !TOKEN_PATTERN.test(issued.token)
+      )
+        throw new FeatureFailure('unavailable')
+      return Response.json(
+        { version: 1, ok: true },
+        {
+          headers: {
+            'cache-control': 'no-store',
+            'set-cookie': sessionCookie(issued.token, origin, options.visitorCookieName, options.testPreview),
+          },
+        },
+      )
+    } catch (error) {
+      return error instanceof FeatureFailure
+        ? failure(error.code, requestId, error.retryAfter)
+        : failure('unavailable', requestId)
+    }
+  }
+  return { GET: handle, POST: handle }
+}

package/src/features/server/http.ts

@@ -0,0 +1,179 @@
+import { randomUUID } from 'node:crypto'
+import type { FeatureErrorCode } from '../contracts'
+export const FEATURE_PREFIX = '/api/u90/features/v1'
+export const STATUS: Record<FeatureErrorCode, number> = {
+  invalid_request: 400,
+  unauthorized: 401,
+  verification_required: 403,
+  forbidden: 403,
+  not_found: 404,
+  conflict: 409,
+  too_large: 413,
+  rate_limited: 429,
+  budget_exceeded: 429,
+  unavailable: 503,
+  incompatible_version: 426,
+}
+export class FeatureFailure extends Error {
+  constructor(
+    public code: FeatureErrorCode,
+    public retryAfter?: number,
+  ) {
+    super(code)
+  }
+}
+export function failure(
+  code: FeatureErrorCode,
+  requestId: string = randomUUID(),
+  retryAfter?: number,
+): Response {
+  const retry =
+    Number.isSafeInteger(retryAfter) && retryAfter! >= 0 && retryAfter! <= 86400
+      ? retryAfter
+      : undefined
+  return Response.json(
+    {
+      version: 1,
+      error: {
+        code,
+        message: code.replaceAll('_', ' '),
+        requestId,
+        ...(retry === undefined ? {} : { retryAfter: retry }),
+      },
+    },
+    {
+      status: STATUS[code],
+      headers: {
+        'cache-control': 'no-store',
+        ...(retry === undefined ? {} : { 'retry-after': String(retry) }),
+      },
+    },
+  )
+}
+/** Count actual bytes; a missing or dishonest Content-Length cannot bypass the cap. */
+export async function readBoundedJSON(input: Request | Response, cap = 16384, signal?: AbortSignal): Promise<unknown> {
+  const reader = input.body?.getReader()
+  if (!reader) throw new FeatureFailure('invalid_request')
+  const abort = () => { void reader.cancel().catch(() => {}) }
+  signal?.addEventListener('abort', abort, { once: true })
+  if (signal?.aborted) abort()
+  let size = 0
+  const chunks: Uint8Array[] = []
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+      if (signal?.aborted) throw new FeatureFailure('unavailable')
+      if (done) break
+      size += value.byteLength
+      if (size > cap) throw new FeatureFailure('too_large')
+      chunks.push(value)
+    }
+  } catch (error) {
+    await reader.cancel().catch(() => {})
+    throw error
+  } finally {
+    signal?.removeEventListener('abort', abort)
+    reader.releaseLock()
+  }
+  const bytes = new Uint8Array(size)
+  let offset = 0
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset)
+    offset += chunk.byteLength
+  }
+  try {
+    return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes))
+  } catch {
+    throw new FeatureFailure('invalid_request')
+  }
+}
+/** First-response deadline only. Cancellation stays attached until the returned body finishes. */
+export async function upstreamFetch(
+  fetcher: typeof fetch,
+  url: string,
+  init: RequestInit,
+  signal: AbortSignal,
+): Promise<Response> {
+  const controller = new AbortController()
+  let reader: ReadableStreamDefaultReader<Uint8Array> | undefined
+  const abort = () => {
+    controller.abort()
+    void reader?.cancel().catch(() => {})
+  }
+  signal.addEventListener('abort', abort, { once: true })
+  if (signal.aborted) abort()
+  const timer = setTimeout(() => controller.abort(), 30000)
+  const cleanup = () => {
+    clearTimeout(timer)
+    signal.removeEventListener('abort', abort)
+  }
+  try {
+    if (controller.signal.aborted) throw new FeatureFailure('unavailable')
+    const response = await fetcher(url, {
+      ...init,
+      signal: controller.signal,
+      redirect: 'error',
+      cache: 'no-store',
+    })
+    clearTimeout(timer)
+    if (response.status >= 300 && response.status < 400) throw new FeatureFailure('unavailable')
+    if (!response.body) {
+      cleanup()
+      return response
+    }
+    reader = response.body.getReader()
+    const stream = new ReadableStream<Uint8Array>({
+      async pull(out) {
+        try {
+          const next = await reader!.read()
+          if (controller.signal.aborted) throw new FeatureFailure('unavailable')
+          if (next.done) {
+            cleanup()
+            out.close()
+          } else out.enqueue(next.value)
+        } catch {
+          cleanup()
+          out.error(new FeatureFailure('unavailable'))
+        }
+      },
+      async cancel() {
+        controller.abort()
+        try {
+          await reader!.cancel()
+        } finally {
+          cleanup()
+        }
+      },
+    })
+    return new Response(stream, { status: response.status, headers: response.headers })
+  } catch {
+    cleanup()
+    controller.abort()
+    throw new FeatureFailure('unavailable')
+  }
+}
+
+export type AskAiRoute =
+  { operation: 'message' } | { operation: 'conversation' | 'rating'; id: string }
+/** Shared approved allowlist only. A3/A5 wire authentication and unbuffered SSE separately. */
+export function matchAskAiRoute(method: string, url: URL): AskAiRoute | null {
+  if (url.hash) return null
+  const path = url.pathname.slice(FEATURE_PREFIX.length)
+  if (!url.pathname.startsWith(FEATURE_PREFIX + '/')) return null
+  if (method === 'POST' && !url.search && path === '/ask-ai/messages')
+    return { operation: 'message' }
+  const conversation = /^\/ask-ai\/conversations\/([a-zA-Z0-9_-]{1,128})$/.exec(path)
+  if (method === 'GET' && conversation) {
+    const query = [...url.searchParams.entries()]
+    if (
+      query.length &&
+      (query.length !== 1 ||
+        query[0][0] !== 'cursor' ||
+        !/^[A-Za-z0-9_-]{1,1024}$/.test(query[0][1]))
+    )
+      return null
+    return { operation: 'conversation', id: conversation[1] }
+  }
+  const rating = /^\/ask-ai\/messages\/([a-zA-Z0-9_-]{1,128})\/rating$/.exec(path)
+  return method === 'POST' && !url.search && rating ? { operation: 'rating', id: rating[1] } : null
+}

package/src/features/server/index.ts

@@ -0,0 +1,6 @@
+import 'server-only'
+export { createSiteFeatures } from './gateway'
+export type { FeatureEnvironment, VerifyVisitor, SiteFeaturesOptions } from './gateway'
+export { createRecaptchaVerifier } from './verifyVisitor'
+
+export { ConsentDefaults } from './ConsentDefaults'

package/src/features/server/session.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod'
+import { ActionProofSchema } from '../contracts'
+import { FEATURE_PREFIX } from './http'
+export const SESSION_COOKIE = 'u90_feature_session'
+export const SessionInputSchema = z.strictObject({
+  requestId: z.uuid(),
+  mode: z.enum(['identity', 'verified']).optional(),
+  proof: ActionProofSchema.optional(),
+})
+export const TOKEN_PATTERN = /^[A-Za-z0-9_.-]{1,2048}$/
+export function visitorCookie(request: Request, cookieName = SESSION_COOKIE): string | undefined {
+  const values = (request.headers.get('cookie') ?? '')
+    .split(';')
+    .map((v) => v.trim())
+    .filter((v) => v.startsWith(cookieName + '='))
+  if (values.length !== 1) return undefined
+  const token = values[0].slice(cookieName.length + 1)
+  return TOKEN_PATTERN.test(token) ? token : undefined
+}
+export function sessionCookie(token: string, origin: string, cookieName = SESSION_COOKIE, testPreview = false): string {
+  if (!TOKEN_PATTERN.test(token)) throw Error('Invalid credential')
+  return `${cookieName}=${token}; HttpOnly; SameSite=${testPreview ? 'None' : 'Lax'}; Path=${FEATURE_PREFIX}${testPreview || new URL(origin).protocol === 'https:' ? '; Secure' : ''}`
+}

package/src/features/server/verification.ts

@@ -0,0 +1,39 @@
+import type { VerifyVisitor } from './gateway'
+/** Bound custom adapters as well as network adapters. Proof stays in this server-only request. */
+export async function verifyWithDeadline(
+  verifyVisitor: VerifyVisitor,
+  url: string,
+  proof: string,
+  signal?: AbortSignal,
+): Promise<Awaited<ReturnType<VerifyVisitor>>> {
+  const controller = new AbortController()
+  const abort = () => controller.abort()
+  signal?.addEventListener('abort', abort, { once: true })
+  if (signal?.aborted) abort()
+  let timer: ReturnType<typeof setTimeout> | undefined
+  try {
+    return await Promise.race([
+      new Promise<never>((_resolve, reject) => {
+        const fail = () => reject(new Error('Verification unavailable.'))
+        controller.signal.addEventListener('abort', fail, { once: true })
+        if (controller.signal.aborted) fail()
+        timer = setTimeout(() => controller.abort(), 10000)
+      }),
+      Promise.resolve().then(() => {
+        controller.signal.throwIfAborted()
+        return verifyVisitor(
+          new Request(url, {
+            method: 'POST',
+            body: JSON.stringify({ proof }),
+            headers: { 'content-type': 'application/json' },
+            signal: controller.signal,
+          }),
+        )
+      }),
+    ])
+  } finally {
+    clearTimeout(timer)
+    controller.abort()
+    signal?.removeEventListener('abort', abort)
+  }
+}

package/src/features/server/verifyVisitor.ts

@@ -0,0 +1,69 @@
+import type { VerifyVisitor } from './gateway'
+import { readBoundedJSON } from './http'
+/** Server-only reCAPTCHA v3 adapter. Never resolve client identity from browser forwarding headers. */
+export function createRecaptchaVerifier(options: {
+  secret: string
+  hostname: string
+  action: string
+  minimumScore?: number
+  fetch?: typeof fetch
+}): VerifyVisitor {
+  return async (request) => {
+    const minimum = options.minimumScore ?? 0.5
+    if (
+      !options.secret ||
+      !options.hostname ||
+      !options.action ||
+      !Number.isFinite(minimum) ||
+      minimum < 0 ||
+      minimum > 1
+    )
+      return { ok: false, retryable: true }
+    try {
+      const body = (await readBoundedJSON(request)) as { proof?: unknown }
+      if (
+        typeof body.proof !== 'string' ||
+        !body.proof ||
+        new TextEncoder().encode(body.proof).length > 4096
+      )
+        return { ok: false, retryable: false }
+      const response = await (options.fetch ?? fetch)(
+        'https://www.google.com/recaptcha/api/siteverify',
+        {
+          method: 'POST',
+          redirect: 'error',
+          cache: 'no-store',
+          signal: AbortSignal.any([request.signal, AbortSignal.timeout(10000)]),
+          headers: { 'content-type': 'application/x-www-form-urlencoded' },
+          body: new URLSearchParams({ secret: options.secret, response: body.proof }).toString(),
+        },
+      )
+      if (!response.ok) return { ok: false, retryable: true }
+      const result = (await readBoundedJSON(response)) as {
+        success?: unknown
+        hostname?: unknown
+        action?: unknown
+        score?: unknown
+        'error-codes'?: unknown
+      }
+      if (
+        Array.isArray(result['error-codes']) &&
+        result['error-codes'].some((e) =>
+          ['missing-input-secret', 'invalid-input-secret', 'bad-request'].includes(e),
+        )
+      )
+        return { ok: false, retryable: true }
+      return result.success === true &&
+        result.hostname === options.hostname &&
+        result.action === options.action &&
+        typeof result.score === 'number' &&
+        Number.isFinite(result.score) &&
+        result.score >= minimum &&
+        result.score <= 1
+        ? { ok: true }
+        : { ok: false, retryable: false }
+    } catch {
+      return { ok: false, retryable: true }
+    }
+  }
+}

package/src/languages/config.d.mts

@@ -0,0 +1,5 @@
+/** Adds `env.U90_LANGUAGES_SNAPSHOT` to a Next config: the site's languages as `/site` answered them at build time. */
+export function withLanguagesSnapshot<C extends { env?: Record<string, string | undefined> }>(
+  config: C,
+  options?: { env?: NodeJS.ProcessEnv; fetch?: typeof fetch },
+): Promise<C>