@nifrajs/web 4.0.2 → 5.1.0

package/src/server-components/runtime.ts

@@ -0,0 +1,376 @@
+import type { CapabilityDefinition } from "@nifrajs/core/capabilities"
+import { isResponseResult, isStatusSignal, STATUS_SIGNAL } from "../internal/render-document.ts"
+import {
+  authorizeServerComponent,
+  isServerComponent,
+  prepareAuthorizedServerComponent,
+  serverComponentCapabilities,
+  validateServerComponentInput,
+} from "./definition.ts"
+import { ServerComponentError } from "./error.ts"
+import { componentFrames } from "./frames.ts"
+import { componentRangeHTML } from "./html.ts"
+import {
+  COMPONENT_LIMITS,
+  COMPONENT_RESPONSE_HEADERS,
+  componentFailure,
+  componentKey,
+  readComponentRequest,
+} from "./protocol.ts"
+import { BoundedComponentTasks, componentAbort } from "./scheduler.ts"
+import { componentValue } from "./schema.ts"
+import type {
+  ComponentInstance,
+  ComponentOwner,
+  ComponentRecord,
+  ServerComponent,
+  ServerComponentContext,
+  ServerComponentHandle,
+  ServerComponentRenderAdapter,
+  ServerComponentRuntime,
+} from "./types.ts"
+import { componentInputKey } from "./value.ts"
+
+const admission = new BoundedComponentTasks(
+  COMPONENT_LIMITS.activeLoads,
+  COMPONENT_LIMITS.queuedLoads,
+)
+const encoder = new TextEncoder()
+const token = /^[A-Za-z0-9_-]{1,128}$/
+
+export interface ServerComponentsOptions {
+  readonly build: string
+  readonly adapter: ServerComponentRenderAdapter
+  readonly owners: Readonly<Record<string, ComponentOwner>>
+  readonly capabilities?: readonly CapabilityDefinition[]
+  readonly assets?: readonly string[]
+}
+
+export function serverComponentInstance<Input, Props, View>(
+  component: ServerComponent<Input, Props, View>,
+  key: string | number,
+  input: Input,
+  parent?: string,
+): ComponentInstance {
+  const instance: ComponentInstance = { component, key, input }
+  if (parent !== undefined) Object.assign(instance, { parent })
+  return instance
+}
+
+export function defineComponentOwner<const Owner extends ComponentOwner>(owner: Owner): Owner {
+  return owner
+}
+
+async function identity(value: unknown): Promise<string> {
+  const digest = await crypto.subtle.digest("SHA-256", encoder.encode(JSON.stringify(value)))
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("")
+}
+export function serverComponentIdentity(
+  owner: string,
+  component: ServerComponentHandle,
+  key: string | number,
+  parent: string | null = null,
+): Promise<string> {
+  if (
+    component.reference === undefined ||
+    !componentKey(key) ||
+    (parent !== null && !token.test(parent))
+  )
+    throw new ServerComponentError("component_contract")
+  return identity([owner, component.reference, parent, key])
+}
+
+export function createServerComponents(options: ServerComponentsOptions): ServerComponentRuntime {
+  if (
+    !token.test(options.build) ||
+    options.adapter.version !== 1 ||
+    !["react", "vue", "svelte", "solid", "preact"].includes(options.adapter.name)
+  )
+    throw new ServerComponentError("component_contract")
+  const owners = new Map<
+    string,
+    { owner: ComponentOwner; components: ReadonlyMap<string, ServerComponentHandle> }
+  >()
+  const assets = new Set(options.assets ?? [])
+  if (
+    [...assets].some(
+      (path) => !/^\/assets\/[A-Za-z0-9_./-]+$/.test(path) || path.split("/").includes(".."),
+    )
+  )
+    throw new ServerComponentError("component_contract")
+  const capabilities = new Map(
+    (options.capabilities ?? []).map((capability) => [capability.id, capability]),
+  )
+  if (capabilities.size !== (options.capabilities?.length ?? 0))
+    throw new ServerComponentError("component_contract")
+  for (const [routeId, owner] of Object.entries(options.owners)) {
+    if (
+      typeof owner.instances !== "function" ||
+      (owner.scope !== "anonymous" && typeof owner.scope !== "function")
+    )
+      throw new ServerComponentError("component_contract")
+    const components = new Map<string, ServerComponentHandle>()
+    const allowed = new Set(owner.capabilities ?? [])
+    for (const capability of allowed) {
+      const declared = capabilities.get(capability)
+      if (declared === undefined || (declared.zone === "domain" && declared.access !== "read"))
+        throw new ServerComponentError("component_contract")
+    }
+    for (const component of owner.components) {
+      if (
+        !isServerComponent(component) ||
+        component.reference === undefined ||
+        !token.test(component.reference) ||
+        components.has(component.reference)
+      )
+        throw new ServerComponentError("component_contract")
+      components.set(component.reference, component)
+      if (serverComponentCapabilities(component).some((capability) => !allowed.has(capability)))
+        throw new ServerComponentError("component_contract")
+    }
+    owners.set(routeId, { owner, components })
+  }
+  return {
+    owns: (routeId) => owners.has(routeId),
+    capabilities: (routeId) => owners.get(routeId)?.owner.capabilities ?? [],
+    classify(request, routeId) {
+      const selection = readComponentRequest(request)
+      if (selection === undefined) return undefined
+      if (selection.build !== options.build)
+        throw new ServerComponentError("component_version", 409)
+      if (!owners.get(routeId)?.components.has(selection.reference))
+        throw new ServerComponentError("component_unavailable", 404)
+      return selection
+    },
+    async execute(routeId, context, selection, nonce) {
+      const entry = owners.get(routeId)
+      if (entry === undefined) throw new ServerComponentError("component_unavailable", 404)
+      const signal = AbortSignal.any([
+        context.signal,
+        AbortSignal.timeout(COMPONENT_LIMITS.executionMs),
+      ])
+      const ctx: ServerComponentContext = Object.create(context, {
+        signal: { value: signal, enumerable: true },
+      })
+      const { scope, instances } = await admission.run(signal, async () => ({
+        scope: entry.owner.scope === "anonymous" ? "anonymous" : await entry.owner.scope(ctx),
+        instances: await entry.owner.instances(ctx),
+      }))
+      if (typeof scope !== "string" || !token.test(scope))
+        throw new ServerComponentError("component_contract")
+      if (!Array.isArray(instances) || instances.length > COMPONENT_LIMITS.instances)
+        throw new ServerComponentError("component_limit", 413)
+      const candidates = await Promise.all(
+        instances.map(async (instance) => {
+          const reference = instance.component.reference
+          if (
+            reference === undefined ||
+            entry.components.get(reference) !== instance.component ||
+            !componentKey(instance.key) ||
+            (instance.parent !== undefined && !token.test(instance.parent))
+          )
+            throw new ServerComponentError("component_contract")
+          return {
+            ...instance,
+            reference,
+            id: await serverComponentIdentity(
+              routeId,
+              instance.component,
+              instance.key,
+              instance.parent ?? null,
+            ),
+            input: componentValue(instance.input, COMPONENT_LIMITS.inputBytes),
+          }
+        }),
+      )
+      const byId = new Map(candidates.map((instance) => [instance.id, instance]))
+      if (byId.size !== candidates.length) throw new ServerComponentError("component_contract")
+      await admission.run(signal, () =>
+        Promise.all(
+          candidates.map((instance) =>
+            // biome-ignore lint/plugin/requireSafetyCommentForTypeAssertion: The owner allowlist and private definition registry identify this handle; input validation precedes callback execution.
+            validateServerComponentInput(instance.component as ServerComponent, instance.input),
+          ),
+        ),
+      )
+      for (const instance of candidates) {
+        const chain = new Set([instance.id])
+        let parent = instance.parent
+        while (parent !== undefined) {
+          const ancestor = byId.get(parent)
+          if (ancestor === undefined || chain.has(parent) || chain.size >= 16)
+            throw new ServerComponentError("component_contract")
+          chain.add(parent)
+          parent = ancestor.parent
+        }
+      }
+      const roots =
+        selection === undefined
+          ? candidates
+          : candidates.filter(
+              (item) =>
+                item.reference === selection.reference &&
+                item.key === selection.key &&
+                (item.parent ?? null) === selection.parent &&
+                componentInputKey(item.input) === componentInputKey(selection.input),
+            )
+      if (selection !== undefined && roots.length !== 1)
+        throw new ServerComponentError("component_unavailable", 404)
+      const selected = new Set(roots.map((item) => item.id))
+      if (selection !== undefined)
+        for (let depth = 0; depth < 16; depth++)
+          for (const item of candidates)
+            if (item.parent !== undefined && selected.has(item.parent)) selected.add(item.id)
+      const picked =
+        selection === undefined
+          ? candidates
+          : [
+              ...roots,
+              ...candidates.filter((item) => selected.has(item.id) && item.id !== roots[0]?.id),
+            ]
+      const authorized = new Map<string, object>()
+      await admission.run(signal, async () => {
+        for (const instance of picked)
+          authorized.set(
+            instance.id,
+            await authorizeServerComponent(
+              // biome-ignore lint/plugin/requireSafetyCommentForTypeAssertion: The owner allowlist and private definition registry identify this handle; input validation precedes callback execution.
+              instance.component as ServerComponent,
+              instance.input,
+              ctx,
+            ),
+          )
+      })
+      const requestTasks = new BoundedComponentTasks(
+        COMPONENT_LIMITS.requestLoads,
+        COMPONENT_LIMITS.instances,
+      )
+      let bytes = 0
+      let count = candidates.length
+      const pending = new Map<string, Promise<ComponentRecord>>()
+      const render = (instance: (typeof candidates)[number]): Promise<ComponentRecord> => {
+        const prior = pending.get(instance.id)
+        if (prior !== undefined) return prior
+        const task = (async () => {
+          const children = await Promise.all(
+            picked.filter((child) => child.parent === instance.id).map(render),
+          )
+          return requestTasks.run(signal, () =>
+            admission.run(signal, async () => {
+              const id = instance.id
+              // The runtime allowlist verified the handle; prepare still validates the schema-derived input and output.
+              const prepared = await prepareAuthorizedServerComponent(authorized.get(id)!)
+              const renderContext: import("./types.ts").ComponentRenderContext = {
+                reference: instance.reference,
+                instance: id,
+                signal,
+                children,
+              }
+              if (nonce !== undefined) Object.assign(renderContext, { nonce })
+              const rendered = await options.adapter.render(
+                prepared.view,
+                prepared.props,
+                renderContext,
+              )
+              if (signal.aborted) throw componentAbort(signal)
+              if (typeof rendered.html !== "string")
+                throw new ServerComponentError("component_contract")
+              const html = componentRangeHTML(rendered.html, assets)
+              count += rendered.islands?.length ?? 0
+              if (count > COMPONENT_LIMITS.instances)
+                throw new ServerComponentError("component_limit", 413)
+              const record: ComponentRecord = {
+                instance: id,
+                reference: instance.reference,
+                key: instance.key,
+                parent: instance.parent ?? null,
+                input: instance.input,
+                html,
+              }
+              if (rendered.payload !== undefined)
+                Object.assign(record, {
+                  payload: componentValue(rendered.payload, COMPONENT_LIMITS.outputBytes),
+                })
+              if (rendered.islands !== undefined)
+                Object.assign(record, {
+                  islands: rendered.islands.map((island) => ({
+                    ...island,
+                    props: componentValue(island.props),
+                  })),
+                })
+              const size = encoder.encode(JSON.stringify(record)).length
+              bytes += size
+              if (
+                size > COMPONENT_LIMITS.outputBytes ||
+                bytes >
+                  (selection === undefined
+                    ? COMPONENT_LIMITS.documentBytes
+                    : COMPONENT_LIMITS.outputBytes)
+              )
+                throw new ServerComponentError("component_limit", 413)
+              return record
+            }),
+          )
+        })()
+        pending.set(instance.id, task)
+        return task
+      }
+      const records = await Promise.all(picked.map(render))
+      if (signal.aborted) throw componentAbort(signal)
+      return {
+        v: 1,
+        build: options.build,
+        adapter: options.adapter.name,
+        owner: await identity(routeId),
+        scope,
+        records,
+      }
+    },
+    response(state, selection) {
+      return new Response(
+        componentFrames(
+          {
+            ...selection,
+            input: undefined,
+            adapter: state.adapter,
+            owner: state.owner,
+            scope: state.scope,
+            instance: state.records[0]?.instance,
+          },
+          state,
+        ),
+        { headers: COMPONENT_RESPONSE_HEADERS },
+      )
+    },
+    failure(error) {
+      if (isResponseResult(error)) return this.failure(error.toResponse())
+      if (isStatusSignal(error)) {
+        const status = error[STATUS_SIGNAL]
+        const init: ResponseInit = { status: status.status }
+        if (status.headers !== undefined) init.headers = status.headers
+        return this.failure(new Response(null, init))
+      }
+      if (error instanceof Response) {
+        const headers = new Headers(error.headers)
+        headers.set("cache-control", "private, no-store")
+        headers.delete("content-length")
+        if (error.status >= 300 && error.status < 400)
+          return new Response(null, { status: error.status, headers })
+        if (error.status < 300) {
+          headers.set("x-nifra-component-control", String(error.status))
+          return Response.json({ v: 1, control: { status: error.status } }, { headers })
+        }
+        const code = [401, 403, 404].includes(error.status)
+          ? "component_denied"
+          : "component_failed"
+        const response = componentFailure(
+          new ServerComponentError(code, error.status >= 400 ? error.status : 500),
+        )
+        headers.set("content-type", "application/json")
+        headers.set("x-content-type-options", "nosniff")
+        return new Response(response.body, { status: response.status, headers })
+      }
+      return componentFailure(error)
+    },
+  }
+}

package/src/server-components/scheduler.ts

@@ -0,0 +1,84 @@
+import { ServerComponentError } from "./error.ts"
+
+interface PendingTask {
+  readonly signal: AbortSignal
+  readonly start: () => void
+  readonly reject: (reason: unknown) => void
+  readonly cancel: () => void
+}
+
+export function componentAbort(signal: AbortSignal): ServerComponentError {
+  return new ServerComponentError(
+    signal.reason instanceof DOMException && signal.reason.name === "TimeoutError"
+      ? "component_timeout"
+      : "component_cancelled",
+    504,
+  )
+}
+
+export class BoundedComponentTasks {
+  #active = 0
+  readonly #queue: PendingTask[] = []
+  constructor(
+    readonly concurrency: number,
+    readonly capacity: number,
+  ) {
+    if (
+      !Number.isSafeInteger(concurrency) ||
+      concurrency < 1 ||
+      !Number.isSafeInteger(capacity) ||
+      capacity < 0
+    )
+      throw new ServerComponentError("component_contract")
+  }
+  get counts(): { active: number; queued: number } {
+    return { active: this.#active, queued: this.#queue.length }
+  }
+
+  run<T>(signal: AbortSignal, work: () => T | Promise<T>): Promise<T> {
+    if (signal.aborted) return Promise.reject(componentAbort(signal))
+    if (this.#active >= this.concurrency && this.#queue.length >= this.capacity)
+      return Promise.reject(new ServerComponentError("component_busy", 429))
+    return new Promise<T>((resolve, reject) => {
+      let began = false
+      const cancel = (): void => {
+        if (!began) {
+          const index = this.#queue.indexOf(pending)
+          if (index !== -1) this.#queue.splice(index, 1)
+          signal.removeEventListener("abort", cancel)
+        }
+        reject(componentAbort(signal))
+      }
+      const start = (): void => {
+        began = true
+        this.#active++
+        const complete = (): void => {
+          signal.removeEventListener("abort", cancel)
+          this.#active--
+          const next = this.#queue.shift()
+          if (next !== undefined) next.start()
+        }
+        // Admission is released by actual completion, never by the public promise's abort.
+        void Promise.resolve()
+          .then(() => {
+            if (signal.aborted) throw componentAbort(signal)
+            return work()
+          })
+          .then(
+            (value) => {
+              complete()
+              resolve(value)
+            },
+            (error: unknown) => {
+              complete()
+              reject(error)
+            },
+          )
+      }
+      const pending: PendingTask = { signal, start, reject, cancel }
+      signal.addEventListener("abort", cancel, { once: true })
+      if (this.#active < this.concurrency) start()
+      else this.#queue.push(pending)
+    })
+  }
+}

package/src/server-components/schema.ts

@@ -0,0 +1,69 @@
+import type { StandardSchemaV1 } from "@nifrajs/core/server"
+import { jsonSchemaOf } from "../internal/output-guard.ts"
+import { ServerComponentError } from "./error.ts"
+
+export { componentValue } from "./value.ts"
+
+const forbidden = new Set(["__proto__", "prototype", "constructor"])
+const scalar = new Set(["string", "number", "integer", "boolean", "null"])
+
+export function assertComponentSchema(schema: StandardSchemaV1): void {
+  const root = jsonSchemaOf(schema)
+  if (root === undefined) throw new ServerComponentError("component_contract")
+  const visiting = new Set<object>()
+  const checked = new Set<object>()
+  const visit = (value: unknown, depth: number): void => {
+    if (typeof value !== "object" || value === null || Array.isArray(value) || depth > 32) {
+      throw new ServerComponentError("component_contract")
+    }
+    if (visiting.has(value)) throw new ServerComponentError("component_contract")
+    if (checked.has(value)) return
+    visiting.add(value)
+    // biome-ignore lint/plugin/requireSafetyCommentForTypeAssertion: Schema traversal verifies object shape and local references before inspecting schema members.
+    const node = value as Record<string, unknown>
+    if (node.$ref !== undefined) {
+      if (typeof node.$ref !== "string" || !node.$ref.startsWith("#/"))
+        throw new ServerComponentError("component_contract")
+      let target: unknown = root
+      for (const part of node.$ref.slice(2).split("/")) {
+        const name = part.replace(/~1/g, "/").replace(/~0/g, "~")
+        if (
+          forbidden.has(name) ||
+          typeof target !== "object" ||
+          target === null ||
+          !Object.hasOwn(target, name)
+        ) {
+          throw new ServerComponentError("component_contract")
+        }
+        // biome-ignore lint/plugin/requireSafetyCommentForTypeAssertion: Schema traversal verifies object shape and local references before inspecting schema members.
+        target = (target as Record<string, unknown>)[name]
+      }
+      visit(target, depth + 1)
+    } else if (node.anyOf !== undefined || node.oneOf !== undefined || node.allOf !== undefined) {
+      for (const name of ["anyOf", "oneOf", "allOf"]) {
+        if (node[name] === undefined) continue
+        if (!Array.isArray(node[name]) || node[name].length === 0)
+          throw new ServerComponentError("component_contract")
+        for (const child of node[name]) visit(child, depth + 1)
+      }
+    } else if (node.type === "object") {
+      if (node.additionalProperties !== false || node.patternProperties !== undefined)
+        throw new ServerComponentError("component_contract")
+      const properties = node.properties
+      if (typeof properties !== "object" || properties === null || Array.isArray(properties))
+        throw new ServerComponentError("component_contract")
+      for (const [name, child] of Object.entries(properties)) {
+        if (forbidden.has(name)) throw new ServerComponentError("component_contract")
+        visit(child, depth + 1)
+      }
+    } else if (node.type === "array") {
+      if (Array.isArray(node.items)) for (const child of node.items) visit(child, depth + 1)
+      else visit(node.items, depth + 1)
+    } else if (typeof node.type !== "string" || !scalar.has(node.type)) {
+      throw new ServerComponentError("component_contract")
+    }
+    visiting.delete(value)
+    checked.add(value)
+  }
+  visit(root, 0)
+}

package/src/server-components/server-entry.ts

@@ -0,0 +1,98 @@
+export interface ComponentEntryOptions {
+  readonly build: string
+  readonly entry: string
+  readonly styles: readonly string[]
+  readonly assets: readonly string[]
+  readonly serverEntry: string
+  readonly platform: "bun" | "node" | "deno" | "cloudflare" | "vercel"
+  readonly manifestDigest?: string
+}
+
+/** Only validated, build-owned paths and tokens become generated source. */
+export function componentServerEntry(options: ComponentEntryOptions): string {
+  const local = options.platform !== "cloudflare"
+  const setup = local
+    ? [
+        'import { readFile } from "node:fs/promises"',
+        'import { createHash } from "node:crypto"',
+        'const manifestBytes = await readFile(new URL("./component-manifest.json", import.meta.url))',
+        `if (createHash("sha256").update(manifestBytes).digest("hex") !== ${JSON.stringify(options.manifestDigest)}) throw new Error("component_version")`,
+        'const manifest = JSON.parse(manifestBytes.toString("utf8"))',
+        "for (const [file, hash] of Object.entries(manifest.files)) {",
+        '  if (!["server", "ssr", "rsc", "assets"].includes(file.split("/")[0]) || file.split("/").some((part) => !/^[A-Za-z0-9_.-]+$/.test(part) || part === "..") || createHash("sha256").update(await readFile(new URL(file, import.meta.url))).digest("hex") !== hash) throw new Error("component_version")',
+        "}",
+        `const module = await import(${JSON.stringify(`./${options.serverEntry}`)})`,
+      ]
+    : [`import * as module from ${JSON.stringify(`./${options.serverEntry}`)}`]
+  const factory = [
+    `if (module.__nifraComponentBuild !== ${JSON.stringify(options.build)} || typeof module.createApp !== "function") throw new Error("component_version")`,
+    `const app = await module.createApp(${JSON.stringify(options.entry)}, ${JSON.stringify({ styles: options.styles, assets: options.assets, build: options.build })})`,
+    'if (typeof app?.fetch !== "function") throw new Error("component_contract")',
+    "export const fetch = (request, env, context) => app.fetch(request, { env, ...(context?.waitUntil ? { waitUntil: context.waitUntil.bind(context) } : {}) })",
+  ]
+  if (!local) return `${[...setup, ...factory, "export default { fetch }"].join("\n")}\n`
+  const assets = options.platform === "vercel" ? [] : options.assets
+  const serving = [
+    `const assets = new Set(${JSON.stringify(assets)})`,
+    "const serve = async (request) => {",
+    "  const path = new URL(request.url).pathname",
+    '  if (assets.has(path) && ["GET", "HEAD"].includes(request.method)) {',
+    '    const bytes = await readFile(new URL("." + path, import.meta.url))',
+    '    const type = path.endsWith(".css") ? "text/css" : path.endsWith(".js") ? "text/javascript" : path.endsWith(".svg") ? "image/svg+xml" : "application/octet-stream"',
+    '    return new Response(request.method === "HEAD" ? null : bytes, { headers: { "content-type": type, "cache-control": "public, max-age=31536000, immutable", "x-content-type-options": "nosniff" } })',
+    "  }",
+    "  return fetch(request)",
+    "}",
+  ]
+  if (options.platform === "bun")
+    return `${[
+      ...setup,
+      ...factory,
+      ...serving,
+      "Bun.serve({ port: Number(process.env.PORT ?? 3000), fetch: serve })",
+    ].join("\n")}\n`
+  if (options.platform === "deno")
+    return `${[
+      ...setup,
+      ...factory,
+      ...serving,
+      'Deno.serve({ port: Number(Deno.env.get("PORT") ?? 3000) }, serve)',
+    ].join("\n")}\n`
+  const http = [
+    'import { createServer } from "node:http"',
+    'import { Readable } from "node:stream"',
+    'import { pipeline } from "node:stream/promises"',
+    "const handle = async (req, res) => {",
+    "  const abort = new AbortController()",
+    "  const close = () => { if (!res.writableEnded) abort.abort() }",
+    '  res.on("close", close)',
+    "  try {",
+    "    const headers = new Headers()",
+    "    for (let i = 0; i < req.rawHeaders.length; i += 2) headers.append(req.rawHeaders[i], req.rawHeaders[i + 1])",
+    // Resolving the target against a base reads `//evil.example/admin` as a host; the origin comes
+    // from a validated Host header, and an absolute-form target is routed by its path.
+    '    const host = req.headers.host ?? "localhost"',
+    "    if (!/^[\\w.:[\\]-]+$/.test(host)) { res.writeHead(400); res.end(); return }",
+    '    const target = req.url.startsWith("/") ? req.url : ((url) => url.pathname + url.search)(new URL(req.url))',
+    '    const request = new Request("http://" + host + target, { method: req.method, headers, signal: abort.signal, ...(["GET", "HEAD"].includes(req.method) ? {} : { body: Readable.toWeb(req), duplex: "half" }) })',
+    "    const response = await serve(request)",
+    "    res.statusCode = response.status",
+    '    for (const [name, value] of response.headers) if (name !== "set-cookie") res.setHeader(name, value)',
+    "    const cookies = response.headers.getSetCookie()",
+    '    if (cookies.length) res.setHeader("set-cookie", cookies)',
+    '    if (response.body && req.method !== "HEAD") await pipeline(Readable.fromWeb(response.body), res)',
+    "    else res.end()",
+    '  } catch { if (!res.headersSent) res.writeHead(500); res.end("component_failed") }',
+    '  finally { res.off("close", close) }',
+    "}",
+  ]
+  return `${[
+    ...setup,
+    ...factory,
+    ...serving,
+    ...http,
+    options.platform === "vercel"
+      ? "export default handle"
+      : 'createServer(handle).listen(Number(process.env.PORT ?? 3000), "0.0.0.0")',
+  ].join("\n")}\n`
+}