@nifrajs/web 4.0.2 → 5.1.0

package/src/router.ts

@@ -9,6 +9,8 @@ import { Router as CoreRouter } from "@nifrajs/core/router"
 import type { StandardSchemaV1 } from "@nifrajs/core/server"
 import type { BoundaryDescriptor, BoundaryStates } from "./boundary.ts"
 import { parseNdjsonData } from "./deferred.ts"
+import { parsePageData } from "./internal/revive-dates.ts"
+import { appUrl, requestPattern } from "./internal/route-path.ts"
 import type { ClientActionResult, ClientRequestBody, ClientRouteHooks } from "./manifest.ts"
 import type { MatchChain } from "./render-seam.ts"
 import { isClientOnlySearchChange } from "./search.ts"
@@ -90,6 +92,7 @@ export const NAV_FROM_HEADER = "x-nifra-from"
  * structure rather than by assuming the deploy was atomic.
  */
 export interface RouteDataEnvelope {
+  readonly serverComponents?: import("./server-components/types.ts").ComponentState | undefined
   readonly v: 1
   readonly data: unknown
   readonly layoutData?: readonly unknown[]
@@ -129,6 +132,7 @@ export interface Submission {
 
 /** The router's observable state. A new object is published on every transition. */
 export interface RouterState {
+  readonly serverComponents?: import("./server-components/types.ts").ComponentState | undefined
   readonly routeId: string
   readonly params: Record<string, string>
   /** The current URL path (used to revalidate the active loader after an action). */
@@ -173,7 +177,7 @@ export function createMatcher(
   for (const pattern of patterns) {
     // Pass the literal to the public router seam: package type resolution may point the two core
     // subpaths at different source/dist declarations, while registration-time compilation is cheap.
-    routeIndex.add("GET", pattern.pattern, pattern.routeId)
+    routeIndex.add("GET", requestPattern(pattern.pattern), pattern.routeId)
   }
   return (path) => {
     // Strip the query without allocating a `split("?")` array - matcher runs per match.
@@ -258,8 +262,9 @@ export interface ClientRouter {
    * loader is revalidated so the mutation is reflected. Pass `{ revalidate: false }` to SKIP that
    * revalidation - keep the current `data` and just publish the action's `actionData` (useful when
    * the action already returned everything that changed, saving the extra round-trip). A redirect
-   * always loads its target regardless. Rejects on failure (caller falls back); once the action has
-   * run, the rejection's `redirectTo` names the page to load instead of posting again.
+   * always loads its target regardless. Rejects on failure (caller falls back); once the server has
+   * answered, at any status, the rejection's `redirectTo` names the page to load instead of posting
+   * again.
    */
   submit: (
     action: string,
@@ -310,6 +315,10 @@ export interface ClientRouterOptions {
   /** Terminal status → client route id. Generated entries populate this from `_404` and
    * `_<status>` files so soft navigation renders the same boundary as a hard request. */
   readonly statusRoutes?: Readonly<Record<number, string>>
+  /** Status route ids whose page renders inside layouts (all but `inLayouts = false`), filled in by the generated entry's
+   * `loadModule`. A soft navigation that ends on one loads the URL as a document, as one ending on a
+   * nested `_404` does: only the server runs those layouts' loaders. */
+  readonly layoutStatusRoutes?: Readonly<Record<string, true>>
   /** routeId → the route's client-only search keys (its `searchClientKeys` export). When a soft
    * navigation stays on the same route + pathname and changes ONLY these keys, `navigate` publishes the
    * new URL WITHOUT re-running the loader (re-render, not revalidate). Populated lazily by the generated
@@ -346,7 +355,7 @@ export interface MountRouterOptions {
 const readResponseData = (res: Response, signal?: AbortSignal): Promise<unknown> =>
   (res.headers.get("content-type") ?? "").includes("application/x-ndjson") && res.body !== null
     ? parseNdjsonData(res.body, signal)
-    : res.json()
+    : res.text().then(parsePageData)
 
 // Index scan, not `/\/+$/` - the unanchored-start trailing-run replace backtracks quadratically and
 // the pathname is caller-controlled.
@@ -404,8 +413,8 @@ const targetUrl = (to: string): URL | undefined => {
   }
 }
 
-const redirected = (to: string): Error =>
-  Object.assign(new Error(`[nifra/web] redirected to ${to}`), { redirectTo: to })
+const redirected = (to: string, cause?: unknown): Error =>
+  Object.assign(new Error(`[nifra/web] redirected to ${to}`, { cause }), { redirectTo: to })
 
 const defaultFetchData: FetchRouteData = async (path, _match, signal, navigation) => {
   // SSG fast path: if this path was prerendered, its loader data is a static file - fetch that (no
@@ -420,7 +429,7 @@ const defaultFetchData: FetchRouteData = async (path, _match, signal, navigation
     const cut = query === -1 ? hash : hash === -1 ? query : Math.min(query, hash)
     const pathname = cut === -1 ? path : path.slice(0, cut)
     if (prerenderedSetOf(prerendered).has(pathname)) {
-      const staticRes = await fetch(dataUrlFor(pathname), { signal: signal ?? null })
+      const staticRes = await fetch(appUrl(dataUrlFor(pathname)), { signal: signal ?? null })
       if (staticRes.ok) return readResponseData(staticRes, signal)
     }
   }
@@ -429,7 +438,7 @@ const defaultFetchData: FetchRouteData = async (path, _match, signal, navigation
     headers.set(RETAIN_HEADER, navigation.retain.join(","))
     headers.set(NAV_FROM_HEADER, navigation.from)
   }
-  const res = await fetch(path, { headers, signal: signal ?? null })
+  const res = await fetch(appUrl(path), { headers, signal: signal ?? null })
   const redirectTo = res.headers.get(REDIRECT_HEADER)
   if (redirectTo !== null) throw redirected(redirectTo)
   const status = Number(res.headers.get(STATUS_HEADER))
@@ -519,11 +528,18 @@ export function createClientRouter(options: ClientRouterOptions): ClientRouter {
    * an older build be read by newer client code.
    */
   type LoadedRouteData = {
+    readonly serverComponents?: import("./server-components/types.ts").ComponentState | undefined
     readonly data: unknown
     readonly layoutData?: readonly unknown[] | undefined
     readonly terminalRouteId?: string | undefined
     readonly boundaries?: BoundaryStates
   }
+  const dataFields = (value: LoadedRouteData) => ({
+    data: value.data,
+    layoutData: value.layoutData,
+    serverComponents: value.serverComponents,
+    ...(value.boundaries === undefined ? {} : { boundaries: value.boundaries }),
+  })
   const loadRouteData = async (
     path: string,
     match: { routeId: string; params: Record<string, string> },
@@ -551,24 +567,21 @@ export function createClientRouter(options: ClientRouterOptions): ClientRouter {
       }
       return { data: null, terminalRouteId }
     }
-    if (retainFrom === undefined || payload.retained === undefined) {
-      return {
-        data: payload.data,
-        layoutData: payload.layoutData,
-        ...(payload.boundaries !== undefined ? { boundaries: payload.boundaries } : {}),
-      }
+    let layoutData = payload.layoutData
+    if (retainFrom !== undefined && payload.retained !== undefined) {
+      const retained = new Set(
+        payload.retained.filter(
+          (index) => Number.isInteger(index) && index >= 0 && index < retainFrom.layoutData.length,
+        ),
+      )
+      layoutData = layoutData?.map((value, index) =>
+        retained.has(index) ? retainFrom.layoutData[index] : value,
+      )
     }
-    const retained = new Set(
-      payload.retained.filter(
-        (index) => Number.isInteger(index) && index >= 0 && index < retainFrom.layoutData.length,
-      ),
-    )
-    const layoutData = payload.layoutData?.map((value, index) =>
-      retained.has(index) ? retainFrom.layoutData[index] : value,
-    )
     return {
       data: payload.data,
       layoutData,
+      serverComponents: payload.serverComponents,
       ...(payload.boundaries !== undefined ? { boundaries: payload.boundaries } : {}),
     }
   }
@@ -644,11 +657,7 @@ export function createClientRouter(options: ClientRouterOptions): ClientRouter {
     navAbort?.abort()
     const ac = new AbortController()
     navAbort = ac
-    const initial = {
-      data: state.data,
-      layoutData: state.layoutData,
-      ...(state.boundaries !== undefined ? { boundaries: state.boundaries } : {}),
-    }
+    const initial = dataFields(state)
     const loaded = await applyClientLoader(
       state.path,
       route,
@@ -663,9 +672,7 @@ export function createClientRouter(options: ClientRouterOptions): ClientRouter {
     } else {
       state = {
         ...state,
-        data: loaded.data,
-        layoutData: loaded.layoutData,
-        ...(loaded.boundaries !== undefined ? { boundaries: loaded.boundaries } : {}),
+        ...dataFields(loaded),
       }
     }
     emit()
@@ -707,6 +714,10 @@ export function createClientRouter(options: ClientRouterOptions): ClientRouter {
     }
   >()
   const cachePut = (path: string, loaded: LoadedRouteData): void => {
+    if (loaded.serverComponents !== undefined) {
+      cache.delete(path)
+      return
+    }
     if (!cache.has(path) && cache.size >= MAX_CACHE) {
       const oldest = cache.keys().next().value
       if (oldest !== undefined) cache.delete(oldest)
@@ -789,7 +800,14 @@ export function createClientRouter(options: ClientRouterOptions): ClientRouter {
           () => loadRouteData(at, route, signal, keepLayouts),
           prefetchedData,
         )
-        if (loaded.terminalRouteId !== undefined) await loadModule?.(loaded.terminalRouteId)
+        if (loaded.terminalRouteId !== undefined) {
+          await loadModule?.(loaded.terminalRouteId)
+          if (options.layoutStatusRoutes?.[loaded.terminalRouteId] === true) {
+            throw new Error(
+              `[nifra/web] ${loaded.terminalRouteId} renders inside layouts; loading ${at} as a document`,
+            )
+          }
+        }
         return [at, route, loaded]
       } catch (error) {
         const next = hops < 20 ? appRedirect(redirectOf(error)) : undefined
@@ -817,9 +835,7 @@ export function createClientRouter(options: ClientRouterOptions): ClientRouter {
       cachePut(state.path, loaded)
       state = {
         ...state,
-        data: loaded.data,
-        layoutData: loaded.layoutData,
-        ...(loaded.boundaries !== undefined ? { boundaries: loaded.boundaries } : {}),
+        ...dataFields(loaded),
         pending: false,
       }
       emit()
@@ -927,7 +943,11 @@ export function createClientRouter(options: ClientRouterOptions): ClientRouter {
         }
         fEmit()
         try {
-          const res = await fetch(action, { method: "POST", body, headers: { [DATA_HEADER]: "1" } })
+          const res = await fetch(appUrl(action), {
+            method: "POST",
+            body,
+            headers: { [DATA_HEADER]: "1" },
+          })
           if (!res.ok)
             throw new Error(`[nifra/web] fetcher action failed (${res.status}): ${action}`)
           const actionData = res.status === 204 ? undefined : await readResponseData(res, ac.signal)
@@ -989,11 +1009,7 @@ export function createClientRouter(options: ClientRouterOptions): ClientRouter {
       ) {
         ++generation // supersede any in-flight navigation so its late result is dropped
         navAbort?.abort()
-        cachePut(path, {
-          data: state.data,
-          layoutData: state.layoutData,
-          ...(state.boundaries !== undefined ? { boundaries: state.boundaries } : {}),
-        })
+        cachePut(path, dataFields(state))
         state = { ...state, path, pending: false, pendingPath: undefined }
         emit()
         return
@@ -1041,9 +1057,7 @@ export function createClientRouter(options: ClientRouterOptions): ClientRouter {
           routeId: loaded.terminalRouteId ?? target.routeId,
           params: loaded.terminalRouteId === undefined ? target.params : {},
           path: to,
-          data: loaded.data,
-          layoutData: loaded.layoutData,
-          ...(loaded.boundaries !== undefined ? { boundaries: loaded.boundaries } : {}),
+          ...dataFields(loaded),
           actionData: undefined, // a fresh navigation has no action result
           pending: false,
         }
@@ -1084,13 +1098,14 @@ export function createClientRouter(options: ClientRouterOptions): ClientRouter {
           state = { ...state, actionData: prepared.optimisticData }
           emit()
         }
-        const res = await fetch(action, {
+        const res = await fetch(appUrl(action), {
           method: "POST",
           body: prepared.body,
           headers: { [DATA_HEADER]: "1" },
         })
-        if (!res.ok) throw new Error(`[nifra/web] action failed (${res.status}): ${action}`)
+        // Whatever the status, the server took the POST: the action may have run before it failed.
         posted = true
+        if (!res.ok) throw new Error(`[nifra/web] action failed (${res.status}): ${action}`)
         const redirectTo = res.headers.get(REDIRECT_HEADER)
         if (redirectTo !== null) {
           // The action redirected (Post/Redirect/Get) - treat it as a client navigation.
@@ -1114,9 +1129,7 @@ export function createClientRouter(options: ClientRouterOptions): ClientRouter {
             routeId: loaded.terminalRouteId ?? target.routeId,
             params: loaded.terminalRouteId === undefined ? target.params : {},
             path: to,
-            data: loaded.data,
-            layoutData: loaded.layoutData,
-            ...(loaded.boundaries !== undefined ? { boundaries: loaded.boundaries } : {}),
+            ...dataFields(loaded),
             actionData: undefined,
             pending: false,
           }
@@ -1137,9 +1150,7 @@ export function createClientRouter(options: ClientRouterOptions): ClientRouter {
         const active = { routeId: state.routeId, params: state.params }
         const loaded = skipActive
           ? {
-              data: state.data,
-              layoutData: state.layoutData,
-              ...(state.boundaries !== undefined ? { boundaries: state.boundaries } : {}),
+              ...dataFields(state),
             }
           : await applyClientLoader(state.path, active, ac.signal, () =>
               loadRouteData(state.path, active, ac.signal),
@@ -1154,9 +1165,7 @@ export function createClientRouter(options: ClientRouterOptions): ClientRouter {
           routeId: state.routeId,
           params: state.params,
           path: state.path,
-          data: loaded.data,
-          layoutData: loaded.layoutData,
-          ...(loaded.boundaries !== undefined ? { boundaries: loaded.boundaries } : {}),
+          ...dataFields(loaded),
           actionData,
           pending: false,
         }
@@ -1172,9 +1181,7 @@ export function createClientRouter(options: ClientRouterOptions): ClientRouter {
             routeId: state.routeId,
             params: state.params,
             path: state.path,
-            data: state.data,
-            layoutData: state.layoutData,
-            ...(state.boundaries !== undefined ? { boundaries: state.boundaries } : {}),
+            ...dataFields(state),
             actionData: previousActionData,
             pending: false,
           }
@@ -1182,7 +1189,7 @@ export function createClientRouter(options: ClientRouterOptions): ClientRouter {
         }
         if (!posted) throw err
         if (mine !== generation) return // a newer navigation or submit owns the page
-        throw redirectOf(err) === undefined ? redirected(landing ?? state.path) : err
+        throw redirectOf(err) === undefined ? redirected(landing ?? state.path, err) : err
       }
     },
     hydrate,
@@ -1216,7 +1223,7 @@ export function createClientRouter(options: ClientRouterOptions): ClientRouter {
           const oldest = prefetched.keys().next().value
           if (oldest !== undefined) prefetched.delete(oldest)
         }
-        prefetched.set(path, [loaded, Date.now()])
+        if (loaded.serverComponents === undefined) prefetched.set(path, [loaded, Date.now()])
       } catch {
         // Best-effort: a failed prefetch just means the eventual navigate fetches normally.
       } finally {

package/src/seo.ts

@@ -0,0 +1,68 @@
+/**
+ * Head helpers for a route's `meta`: `canonical()`, `openGraph()` and `jsonLd()`. `meta()` runs on the
+ * server and in the browser, and this entry imports nothing at runtime, so browser code can take the
+ * helpers from here without bundling the server modules the package root also exports.
+ */
+import type { LinkDescriptor, MetaDescriptor, ScriptDescriptor } from "./manifest.ts"
+
+/**
+ * A `<link rel="canonical">` descriptor for a route's `meta.link`. The canonical URL tells search
+ * engines which URL is authoritative for a page (deduping query-string / tracking variants).
+ *
+ * ```ts
+ * export const meta = (a) => ({ link: [canonical(`https://site.com/posts/${a.params.slug}`)] })
+ * ```
+ */
+export function canonical(href: string): LinkDescriptor {
+  return { rel: "canonical", href }
+}
+
+/** Inputs for {@link openGraph} - the common Open Graph properties. All optional; only the provided
+ * ones become tags. `type` defaults to `"website"`. */
+export interface OpenGraphInput {
+  readonly title?: string
+  readonly description?: string
+  /** Absolute URL of the share image (`og:image`). */
+  readonly image?: string
+  /** Canonical URL of the page (`og:url`). */
+  readonly url?: string
+  /** Object type (`og:type`) - `"website"`, `"article"`, … Default `"website"`. */
+  readonly type?: string
+}
+
+/**
+ * Build the Open Graph `<meta property="og:*">` entries for a route's `meta.meta`. Returns only the
+ * properties you supplied (plus `og:type`, defaulting to `"website"`), so it composes with other meta.
+ *
+ * ```ts
+ * export const meta = { meta: [...openGraph({ title: "Nifra", image: "https://site.com/og.png" })] }
+ * ```
+ */
+export function openGraph(input: OpenGraphInput): MetaDescriptor[] {
+  const tags: MetaDescriptor[] = []
+  const add = (property: string, content: string | undefined): void => {
+    if (content !== undefined) tags.push({ property, content })
+  }
+  add("og:title", input.title)
+  add("og:description", input.description)
+  add("og:image", input.image)
+  add("og:url", input.url)
+  // `og:type` always present (the spec's required property) - default "website" when unset.
+  tags.push({ property: "og:type", content: input.type ?? "website" })
+  return tags
+}
+
+/**
+ * Build a JSON-LD `<script type="application/ld+json">` entry for a route's `meta.script` from a plain
+ * object. `JSON.stringify` produces the body; the head renderer breakout-escapes it (see
+ * `escapeScriptContent`), so a string field containing `</script>` is embedded safely.
+ *
+ * ```ts
+ * export const meta = {
+ *   script: [jsonLd({ "@context": "https://schema.org", "@type": "Article", headline: "Hi" })],
+ * }
+ * ```
+ */
+export function jsonLd(data: Record<string, unknown>): ScriptDescriptor {
+  return { type: "application/ld+json", content: JSON.stringify(data) }
+}

package/src/server-components/build-info.ts

@@ -0,0 +1,11 @@
+declare const __NIFRA_COMPONENT_BUILD__: string
+
+/** The coordinated compiler replaces this value in every environment. */
+export const componentBuild: string =
+  typeof __NIFRA_COMPONENT_BUILD__ === "string"
+    ? __NIFRA_COMPONENT_BUILD__
+    : (() => {
+        throw new Error(
+          "[nifra/components] build-info requires serverComponentsConfig or nifra build",
+        )
+      })()

package/src/server-components/build-target.ts

@@ -0,0 +1,194 @@
+import { createHash } from "node:crypto"
+import { cp, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises"
+import { relative, resolve } from "node:path"
+import { build } from "vite"
+import { unsupportedBuiltin } from "../internal/target-compat.ts"
+import type { ComponentPipelineOptions } from "./build.ts"
+import { componentBundleImports } from "./bundle-proof.ts"
+import { componentServerEntry } from "./server-entry.ts"
+
+export interface ComponentBuildResult {
+  readonly outDir: string
+  readonly build: string
+  readonly target: NonNullable<ComponentPipelineOptions["target"]>
+  readonly entry: string
+  readonly styles: readonly string[]
+  readonly assets: readonly string[]
+}
+
+interface Asset {
+  readonly file: string
+  readonly isEntry?: boolean
+  readonly css?: readonly string[]
+}
+const assetPath = /^assets\/[A-Za-z0-9_./-]+$/
+function readAssets(value: unknown): readonly Asset[] {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    throw new Error("[nifra/components] Missing client build manifest")
+  return Object.values(value).map((item: unknown) => {
+    if (typeof item !== "object" || item === null || Array.isArray(item))
+      throw new Error("[nifra/components] Invalid client manifest")
+    // biome-ignore lint/plugin/requireSafetyCommentForTypeAssertion: Manifest object shape, asset paths and optional field types are checked before constructing the target manifest.
+    const record = item as Record<string, unknown>
+    if (
+      typeof record.file !== "string" ||
+      !assetPath.test(record.file) ||
+      record.file.split("/").includes("..") ||
+      (record.isEntry !== undefined && typeof record.isEntry !== "boolean") ||
+      (record.css !== undefined &&
+        (!Array.isArray(record.css) ||
+          record.css.some(
+            (css) =>
+              typeof css !== "string" || !assetPath.test(css) || css.split("/").includes(".."),
+          )))
+    )
+      throw new Error("[nifra/components] Invalid build asset URL")
+    const asset: Asset = { file: record.file }
+    if (record.isEntry !== undefined) Object.assign(asset, { isEntry: record.isEntry })
+    if (record.css !== undefined) Object.assign(asset, { css: record.css })
+    return asset
+  })
+}
+
+async function files(directory: string): Promise<string[]> {
+  const result: string[] = []
+  for (const item of await readdir(directory, { withFileTypes: true })) {
+    if (item.isSymbolicLink())
+      throw new Error("[nifra/components] Build artifacts cannot be symbolic links")
+    const path = resolve(directory, item.name)
+    if (item.isDirectory()) result.push(...(await files(path)))
+    else if (item.isFile()) result.push(path)
+  }
+  return result.sort()
+}
+const digest = (value: string | Uint8Array): string =>
+  createHash("sha256").update(value).digest("hex")
+
+/** Assemble one complete generation before the build orchestrator publishes its directory. */
+export async function assembleComponentTarget(
+  options: ComponentPipelineOptions,
+  generation: string,
+): Promise<ComponentBuildResult> {
+  const out = resolve(options.root, options.outDir ?? "dist")
+  const target = options.target ?? "bun"
+  const records = readAssets(
+    JSON.parse(await readFile(resolve(out, "client/.vite/manifest.json"), "utf8")),
+  )
+  const entries = records.filter((record) => record.isEntry)
+  if (entries.length !== 1)
+    throw new Error("[nifra/components] Exactly one client entry is required")
+  const assets = (await files(resolve(out, "client/assets"))).map(
+    (file) => `/${relative(resolve(out, "client"), file).replaceAll("\\", "/")}`,
+  )
+  const entry = `/${entries[0]!.file}`
+  const styles = [...new Set(records.flatMap((record) => record.css ?? []))]
+    .map((file) => `/${file}`)
+    .sort()
+  if (!assets.includes(entry) || styles.some((file) => !assets.includes(file)))
+    throw new Error("[nifra/components] Missing client generation artifacts")
+  const serverDirectory = options.adapter === "react" ? "ssr" : "server"
+  const serverEntry = `${serverDirectory}/index.js`
+  const staticRoot = target === "vercel" ? resolve(out, "static") : out
+  await cp(resolve(out, "client/assets"), resolve(staticRoot, "assets"), { recursive: true })
+  await rm(resolve(out, "client"), { recursive: true })
+  const metadata = {
+    v: 1,
+    build: generation,
+    adapter: options.adapter,
+    target,
+    entry,
+    styles,
+    assets,
+  }
+  if (target === "cloudflare") {
+    const source = componentServerEntry({ ...metadata, serverEntry, platform: "cloudflare" })
+    const input = resolve(out, ".nifra-entry.backend.js")
+    await writeFile(input, source)
+    await build({
+      root: out,
+      configFile: false,
+      publicDir: false,
+      ssr: { noExternal: true },
+      define: { "process.env.NODE_ENV": '"production"' },
+      build: {
+        ssr: input,
+        outDir: resolve(out, ".nifra-worker"),
+        emptyOutDir: true,
+        minify: true,
+        rollupOptions: { output: { inlineDynamicImports: true, entryFileNames: "index.js" } },
+      },
+    })
+    await cp(resolve(out, ".nifra-worker/index.js"), resolve(out, "_worker.js"))
+    const worker = await readFile(resolve(out, "_worker.js"), "utf8")
+    if (
+      componentBundleImports(worker).some((specifier) => unsupportedBuiltin(specifier, "browser"))
+    )
+      throw new Error("[nifra/components] Unsupported built-in in the assembled edge worker")
+    await rm(input)
+    await rm(resolve(out, ".nifra-worker"), { recursive: true })
+    await rm(resolve(out, serverDirectory), { recursive: true })
+    if (options.adapter === "react") await rm(resolve(out, "rsc"), { recursive: true })
+    await writeFile(
+      resolve(out, "_routes.json"),
+      `${JSON.stringify({ version: 1, include: ["/*"], exclude: ["/assets/*"] })}\n`,
+    )
+    await writeFile(resolve(out, ".assetsignore"), "*\n!assets/\n!assets/**\n")
+  } else {
+    const runtimeRoot = target === "vercel" ? resolve(out, "functions/index.func") : out
+    await mkdir(runtimeRoot, { recursive: true })
+    if (runtimeRoot !== out) {
+      await cp(resolve(out, serverDirectory), resolve(runtimeRoot, serverDirectory), {
+        recursive: true,
+      })
+      await rm(resolve(out, serverDirectory), { recursive: true })
+      if (options.adapter === "react") {
+        await cp(resolve(out, "rsc"), resolve(runtimeRoot, "rsc"), { recursive: true })
+        await rm(resolve(out, "rsc"), { recursive: true })
+      }
+    }
+    const privateFiles = await files(resolve(runtimeRoot, serverDirectory))
+    if (options.adapter === "react")
+      privateFiles.push(...(await files(resolve(runtimeRoot, "rsc"))))
+    if (target !== "vercel") privateFiles.push(...(await files(resolve(runtimeRoot, "assets"))))
+    const hashes = Object.fromEntries(
+      await Promise.all(
+        privateFiles.map(async (file) => [
+          relative(runtimeRoot, file).replaceAll("\\", "/"),
+          digest(await readFile(file)),
+        ]),
+      ),
+    )
+    const manifest = `${JSON.stringify({ ...metadata, files: hashes })}\n`
+    await writeFile(resolve(runtimeRoot, "component-manifest.json"), manifest)
+    await writeFile(
+      resolve(runtimeRoot, target === "vercel" ? "index.js" : "server.js"),
+      componentServerEntry({
+        ...metadata,
+        serverEntry,
+        platform: target,
+        manifestDigest: digest(manifest),
+      }),
+    )
+    await writeFile(resolve(runtimeRoot, "package.json"), '{"type":"module"}\n')
+    if (target === "vercel") {
+      await writeFile(
+        resolve(runtimeRoot, ".vc-config.json"),
+        `${JSON.stringify({
+          runtime: "nodejs22.x",
+          handler: "index.js",
+          launcherType: "Nodejs",
+          shouldAddHelpers: false,
+        })}\n`,
+      )
+      await writeFile(
+        resolve(out, "config.json"),
+        `${JSON.stringify({
+          version: 3,
+          routes: [{ handle: "filesystem" }, { src: "/(.*)", dest: "/index" }],
+        })}\n`,
+      )
+    }
+  }
+  await writeFile(resolve(out, "component-build.json"), `${JSON.stringify(metadata)}\n`)
+  return { outDir: out, build: generation, target, entry, styles, assets }
+}