@vercel/build-utils 14.3.0 → 14.5.0

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # @vercel/build-utils
 
+## 14.5.0
+
+### Minor Changes
+
+- 90afd71: Expose the resolved rewrite destination as the request path observed by Node backend framework applications (express, hono, h3, koa, nestjs, fastify, elysia) and the unified backends builder, and warn affected backend projects about the behavior change.
+
+## 14.4.1
+
+### Patch Changes
+
+- e5b0363: Add `Span.reportChildEvents()` so a tree of trace events produced in another process (e.g. a forked build worker) can be reported under an existing span. Its root events are reparented to that span while links internal to the set are preserved, keeping trace nesting intact.
+
+## 14.4.0
+
+### Minor Changes
+
+- f8add0a: Replace `prerenderClassification` on `Prerender` with `initialMetadata`.
+
+  The platform consumes only the request-time compute mode and the HTML shell
+  size, so the flattened four-field taxonomy (`routeType`, `response`,
+  `compute`, `htmlSize`) is reduced to a single grouped field:
+
+  ```ts
+  initialMetadata?: {
+    compute: 'blocking' | 'resuming' | 'static';
+    htmlSize?: number;
+  }
+  ```
+
+  The group is named `initialMetadata` because the values describe the
+  deployment as it was built: revalidation can regenerate a route's output over
+  the deployment's lifetime, so readers must treat them as initial values, not
+  live state. `@vercel/next` reads `compute` and `htmlSize` off the v4
+  prerender-manifest taxonomy and deliberately ignores `routeType` and
+  `response`; the values are still carried unvalidated so a compute mode added
+  by a future framework release cannot hard-fail a deploy, and they are still
+  set only on the primary output of each prerender group. `htmlSize: 0` is a
+  real size (a shell that postponed everything); `htmlSize` is absent when
+  there is no HTML shell to measure (route handlers, Pages Router). Absence of
+  the whole group remains legitimate (`notFoundRoutes`, Pages Router
+  `fallback: false`, older frameworks).
+
 ## 14.3.0
 
 ### Minor Changes

package/dist/generate-node-builder-functions.js

@@ -76,6 +76,22 @@ function generateNodeBuilderFunctions(frameworkName, regex, validFilenames, vali
       slug: frameworkName,
       version
     };
+    if (!res.routes) {
+      res.routes = [
+        { handle: "filesystem" },
+        {
+          src: "/(.*)",
+          dest: "/",
+          transforms: [
+            {
+              type: "request.path",
+              op: "set",
+              args: "/$1"
+            }
+          ]
+        }
+      ];
+    }
     return res;
   };
   const entrypointCallback = async (args) => {

package/dist/index.d.ts

@@ -3,7 +3,7 @@ import FileFsRef from './file-fs-ref';
 import FileRef from './file-ref';
 import { Lambda, createLambda, getLambdaOptionsFromFunction, sanitizeConsumerName } from './lambda';
 import { NodejsLambda, type NodejsLambdaOptions } from './nodejs-lambda';
-import { Prerender, type PrerenderClassification } from './prerender';
+import { Prerender, type PrerenderInitialMetadata } from './prerender';
 import download, { downloadFile, DownloadedFiles, isSymbolicLink, isDirectory, isExternalSymlink, isExternalSymlinkTarget, getSymlinkTarget } from './fs/download';
 import getWriteableDirectory from './fs/get-writable-directory';
 import glob, { GlobOptions } from './fs/glob';
@@ -20,7 +20,7 @@ import { getServiceUrlEnvVars, getExperimentalServiceUrlEnvVars } from './get-se
 import { cloneEnv } from './clone-env';
 import { hardLinkDir } from './hard-link-dir';
 import { validateNpmrc } from './validate-npmrc';
-export type { NodejsLambdaOptions, PrerenderClassification };
+export type { NodejsLambdaOptions, PrerenderInitialMetadata };
 export { FileBlob, FileFsRef, FileRef, Lambda, NodejsLambda, createLambda, Prerender, download, downloadFile, DownloadedFiles, getWriteableDirectory, glob, GlobOptions, rename, spawnAsync, getScriptName, installDependencies, runPackageJsonScript, execCommand, spawnCommand, walkParentDirs, getNodeBinPath, getNodeBinPaths, getSupportedNodeVersion, isBunVersion, getSupportedBunVersion, getOrCreateBunBinary, detectPackageManager, runNpmInstall, NpmInstallOutput, runBundleInstall, runPipInstall, PipInstallResult, runShellScript, runCustomInstallCommand, resetCustomInstallCommandSet, getEnvForPackageManager, getNodeVersion, getPathForPackageManager, getLatestNodeVersion, getDiscontinuedNodeVersions, getSpawnOptions, getPlatformEnv, getPrefixedEnvVars, getServiceUrlEnvVars, getExperimentalServiceUrlEnvVars, streamToBuffer, streamToBufferChunks, debug, isSymbolicLink, isDirectory, isExternalSymlink, isExternalSymlinkTarget, getSymlinkTarget, getLambdaOptionsFromFunction, sanitizeConsumerName, scanParentDirs, findPackageJson, getIgnoreFilter, cloneEnv, hardLinkDir, traverseUpDirectories, validateNpmrc, type CliType, };
 export { EdgeFunction } from './edge-function';
 export { ContainerImage } from './container-image';

package/dist/index.js

@@ -35406,13 +35406,13 @@ var Prerender = class {
     chain,
     exposeErrBody,
     partialFallback,
-    prerenderClassification
+    initialMetadata
   }) {
     this.type = "Prerender";
     this.expiration = expiration;
     this.staleExpiration = staleExpiration;
     this.sourcePath = sourcePath;
-    this.prerenderClassification = prerenderClassification;
+    this.initialMetadata = initialMetadata;
     this.lambda = lambda;
     if (this.lambda) {
       this.lambda.operationType = this.lambda.operationType || "ISR";
@@ -39344,6 +39344,22 @@ var Span = class _Span {
       reporter: this._reporter
     });
   }
+  /**
+   * Report already-finalized trace events (e.g. collected in a child process) to this span's
+   * reporter so they appear nested under this span. Any event that is a root of the passed set —
+   * i.e. whose `parentId` refers to a span not present in `events` — is reparented to this span;
+   * links internal to the set are preserved. Safe to call with events from any process: the
+   * caller does not need to know or set this span's id.
+   */
+  reportChildEvents(events) {
+    if (!this._reporter)
+      return;
+    const ids = new Set(events.map((event) => event.id));
+    for (const event of events) {
+      const isRoot = event.parentId === void 0 || !ids.has(event.parentId);
+      this._reporter.report(isRoot ? { ...event, parentId: this.id } : event);
+    }
+  }
   async trace(fn) {
     try {
       return await fn(this);
@@ -39440,6 +39456,22 @@ function generateNodeBuilderFunctions(frameworkName, regex, validFilenames, vali
       slug: frameworkName,
       version
     };
+    if (!res.routes) {
+      res.routes = [
+        { handle: "filesystem" },
+        {
+          src: "/(.*)",
+          dest: "/",
+          transforms: [
+            {
+              type: "request.path",
+              op: "set",
+              args: "/$1"
+            }
+          ]
+        }
+      ];
+    }
     return res;
   };
   const entrypointCallback = async (args) => {

package/dist/prerender.d.ts

@@ -1,17 +1,25 @@
 import type { File, HasField, Chain } from './types';
 import { Lambda } from './lambda';
 /**
- * The framework's own description of what it prerendered, mirroring the
- * Next.js prerender taxonomy rather than re-deriving it from build artifacts.
+ * The framework's own description of what it prerendered at build time,
+ * rather than re-deriving it from build artifacts. These are *initial*
+ * values: revalidation can regenerate a route's output over the lifetime of
+ * a deployment, so readers must treat them as the state as of the build,
+ * not as live state.
  */
-export interface PrerenderClassification {
-    /** What kind of entry this is within its route group. */
-    routeType: 'route' | 'page' | 'shell' | 'fallback';
-    /** How much of the response the prerender contains. */
-    response: 'empty' | 'initial' | 'complete';
-    /** What has to happen at request time to finish the response. */
+export interface PrerenderInitialMetadata {
+    /**
+     * What has to happen at request time to finish the response, as of build
+     * time: `static` needs no server compute, `resuming` streams the static
+     * response while the server resumes postponed work, and `blocking` cannot
+     * start the response until request-time compute starts.
+     */
     compute: 'blocking' | 'resuming' | 'static';
-    /** Byte size of the prerendered HTML shell, when the entry has one. */
+    /**
+     * Byte size of the prerendered HTML shell, when the entry has one. `0` is
+     * a real size — a shell that postponed everything — and `undefined` means
+     * there is no HTML shell to measure (route handlers, Pages Router).
+     */
     htmlSize?: number;
 }
 interface PrerenderOptions {
@@ -32,7 +40,7 @@ interface PrerenderOptions {
     chain?: Chain;
     exposeErrBody?: boolean;
     partialFallback?: boolean;
-    prerenderClassification?: PrerenderClassification;
+    initialMetadata?: PrerenderInitialMetadata;
 }
 export declare class Prerender {
     type: 'Prerender';
@@ -63,11 +71,12 @@ export declare class Prerender {
     exposeErrBody?: boolean;
     partialFallback?: boolean;
     /**
-     * The framework's classification of this prerender. `undefined` when the
-     * framework did not provide one, which is legitimate: not-found routes and
-     * Pages Router `fallback: false` templates have no classification.
+     * The framework's build-time serving metadata for this prerender.
+     * `undefined` when the framework did not provide it, which is legitimate:
+     * not-found routes, Pages Router `fallback: false` templates, and builds
+     * from frameworks that predate the field carry none.
      */
-    prerenderClassification?: PrerenderClassification;
-    constructor({ expiration, staleExpiration, lambda, fallback, group, bypassToken, allowQuery, allowHeader, initialHeaders, initialStatus, passQuery, sourcePath, experimentalBypassFor, experimentalStreamingLambdaPath, chain, exposeErrBody, partialFallback, prerenderClassification, }: PrerenderOptions);
+    initialMetadata?: PrerenderInitialMetadata;
+    constructor({ expiration, staleExpiration, lambda, fallback, group, bypassToken, allowQuery, allowHeader, initialHeaders, initialStatus, passQuery, sourcePath, experimentalBypassFor, experimentalStreamingLambdaPath, chain, exposeErrBody, partialFallback, initialMetadata, }: PrerenderOptions);
 }
 export {};

package/dist/prerender.js

@@ -40,13 +40,13 @@ class Prerender {
     chain,
     exposeErrBody,
     partialFallback,
-    prerenderClassification
+    initialMetadata
   }) {
     this.type = "Prerender";
     this.expiration = expiration;
     this.staleExpiration = staleExpiration;
     this.sourcePath = sourcePath;
-    this.prerenderClassification = prerenderClassification;
+    this.initialMetadata = initialMetadata;
     this.lambda = lambda;
     if (this.lambda) {
       this.lambda.operationType = this.lambda.operationType || "ISR";

package/dist/trace/trace.d.ts

@@ -32,6 +32,14 @@ export declare class Span {
     stop(): void;
     setAttributes(attrs: Attributes): void;
     child(name: string, attrs?: Attributes): Span;
+    /**
+     * Report already-finalized trace events (e.g. collected in a child process) to this span's
+     * reporter so they appear nested under this span. Any event that is a root of the passed set —
+     * i.e. whose `parentId` refers to a span not present in `events` — is reparented to this span;
+     * links internal to the set are preserved. Safe to call with events from any process: the
+     * caller does not need to know or set this span's id.
+     */
+    reportChildEvents(events: TraceEvent[]): void;
     trace<T>(fn: (span: Span) => T | Promise<T>): Promise<T>;
 }
 export {};

package/dist/trace/trace.js

@@ -78,6 +78,22 @@ class Span {
       reporter: this._reporter
     });
   }
+  /**
+   * Report already-finalized trace events (e.g. collected in a child process) to this span's
+   * reporter so they appear nested under this span. Any event that is a root of the passed set —
+   * i.e. whose `parentId` refers to a span not present in `events` — is reparented to this span;
+   * links internal to the set are preserved. Safe to call with events from any process: the
+   * caller does not need to know or set this span's id.
+   */
+  reportChildEvents(events) {
+    if (!this._reporter)
+      return;
+    const ids = new Set(events.map((event) => event.id));
+    for (const event of events) {
+      const isRoot = event.parentId === void 0 || !ids.has(event.parentId);
+      this._reporter.report(isRoot ? { ...event, parentId: this.id } : event);
+    }
+  }
   async trace(fn) {
     try {
       return await fn(this);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/build-utils",
-  "version": "14.3.0",
+  "version": "14.5.0",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",