Function createStartHandler

packages/start-server-core/src/createStartHandler.ts:353–650

(
  cbOrOptions: HandlerCallback<AnyRouter> | CreateStartHandlerOptions,
)

 * ```
 */
export function createStartHandler<TRegister = Register>(
  cbOrOptions: HandlerCallback<AnyRouter> | CreateStartHandlerOptions,
): RequestHandler<TRegister> {
  // Normalize the overloaded argument
  const cb: HandlerCallback<AnyRouter> =
    typeof cbOrOptions === 'function' ? cbOrOptions : cbOrOptions.handler
  const transformAssetUrlsOption: TransformAssetUrls | undefined =
    typeof cbOrOptions === 'function'
      ? undefined
      : cbOrOptions.transformAssetUrls

  const warmupTransformManifest =
    !!transformAssetUrlsOption &&
    typeof transformAssetUrlsOption === 'object' &&
    transformAssetUrlsOption.warmup === true

  // Pre-resolve the transform function and cache flag
  const resolvedTransformConfig = transformAssetUrlsOption
    ? resolveTransformConfig(transformAssetUrlsOption)
    : undefined
  const cache = resolvedTransformConfig ? resolvedTransformConfig.cache : true

  // Memoize a single createTransform() result when caching is enabled.
  let cachedCreateTransformPromise: Promise<TransformAssetUrlsFn> | undefined

  const getTransformFn = async (
    opts: { warmup: true } | { warmup: false; request: Request },
  ): Promise<TransformAssetUrlsFn | undefined> => {
    if (!resolvedTransformConfig) return undefined
    if (resolvedTransformConfig.type === 'createTransform') {
      if (cache) {
        if (!cachedCreateTransformPromise) {
          cachedCreateTransformPromise = Promise.resolve(
            resolvedTransformConfig.createTransform(opts),
          )
        }
        return cachedCreateTransformPromise
      }
      return resolvedTransformConfig.createTransform(opts)
    }
    return resolvedTransformConfig.transformFn
  }

  // Background warmup for cached transforms (production only)
  if (
    warmupTransformManifest &&
    cache &&
    process.env.TSS_DEV_SERVER !== 'true' &&
    !cachedFinalManifestPromise
  ) {
    // NOTE: Do not call resolveManifest() here.
    // resolveManifest() reads from cachedFinalManifestPromise, and since we set
    // cachedFinalManifestPromise to this warmup promise, that would create a
    // self-referential promise and hang forever.
    const warmupPromise = (async () => {
      const base = await getBaseManifest(undefined)
      const transformFn = await getTransformFn({ warmup: true })
      return transformFn