@vercel/build-utils 13.11.0 → 13.12.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @vercel/build-utils
 
+## 13.12.0
+
+### Minor Changes
+
+- Add hash utilities (`streamToDigestAsync`, `sha256`, `md5`) and build result helpers (`getBuildResultMetadata`, `getLambdaByOutputPath`, `isRouteMiddleware`, `getPrerenderChain`, `streamWithExtendedPayload`) for shared use. ([#15726](https://github.com/vercel/vercel/pull/15726))
+
 ## 13.11.0
 
 ### Minor Changes

package/dist/collect-build-result/get-build-result-metadata.d.ts

@@ -0,0 +1,33 @@
+import type { Route } from '@vercel/routing-utils';
+import type { EdgeFunction } from '../edge-function';
+import type { File } from '../types';
+import type { Lambda } from '../lambda';
+import type { Prerender } from '../prerender';
+export interface BuildResultMetadata {
+    middleware: Map<string, MiddlewareMeta>;
+    ppr: Map<string, boolean>;
+}
+/**
+ * Extract metadata about the build result that depend on the relationship
+ * between components in the build output. This data is later used to map to
+ * the infrastructure that we need to create.
+ */
+export declare function getBuildResultMetadata(params: {
+    buildOutputMap: Record<string, EdgeFunction | Lambda | Prerender | File>;
+    routes: Route[];
+}): BuildResultMetadata;
+type MiddlewareMeta = {
+    type: 'middleware';
+    middlewarePath: string;
+    outputPath: string;
+    match: Set<string>;
+    edgeFunction: EdgeFunction;
+    index: number;
+} | {
+    type: 'middleware-lambda';
+    middlewarePath: string;
+    outputPath: string;
+    match: Set<string>;
+    index: number;
+};
+export {};

package/dist/collect-build-result/get-build-result-metadata.js

@@ -0,0 +1,99 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var get_build_result_metadata_exports = {};
+__export(get_build_result_metadata_exports, {
+  getBuildResultMetadata: () => getBuildResultMetadata
+});
+module.exports = __toCommonJS(get_build_result_metadata_exports);
+var import_errors = require("../errors");
+var import_get_lambda_by_output_path = require("./get-lambda-by-output-path");
+var import_get_prerender_chain = require("./get-prerender-chain");
+var import_is_route_middleware = require("./is-route-middleware");
+function getBuildResultMetadata(params) {
+  return {
+    middleware: getMiddlewareMetadata(params),
+    ppr: new Map(
+      Object.entries(params.buildOutputMap).flatMap(([_outputPath, output]) => {
+        if (output.type === "Prerender") {
+          const chain = (0, import_get_prerender_chain.getPrerenderChain)(output);
+          if (chain) {
+            const maybeLambda = (0, import_get_lambda_by_output_path.getLambdaByOutputPath)({
+              buildOutputMap: params.buildOutputMap,
+              outputPath: chain.outputPath
+            });
+            if (maybeLambda) {
+              return [[chain.outputPath, true]];
+            }
+          }
+        }
+        return [];
+      })
+    )
+  };
+}
+function getMiddlewareMetadata(params) {
+  const deduped = new Map(
+    params.routes.filter(import_is_route_middleware.isRouteMiddleware).map(
+      (route) => toMiddlewareTuple({
+        buildOutputMap: params.buildOutputMap,
+        middlewarePath: route.middlewarePath
+      })
+    )
+  );
+  return new Map(
+    Array.from(deduped, ([outputPath, metadata], index) => [
+      outputPath,
+      { ...metadata, index }
+    ])
+  );
+}
+function toMiddlewareTuple(params) {
+  const keys = [
+    params.middlewarePath,
+    params.middlewarePath.replace(/^\//, "")
+  ];
+  const [outputPath, output] = Object.entries(params.buildOutputMap).find(
+    (entry) => keys.includes(entry[0]) && (entry[1].type === "EdgeFunction" || entry[1].type === "Lambda")
+  ) ?? [];
+  if (!outputPath || !output) {
+    throw new import_errors.NowBuildError({
+      message: `Mapping ${params.middlewarePath} not found. Maybe you provided a wrong middlewarePath?`,
+      code: "middleware_path_not_found"
+    });
+  }
+  return [
+    outputPath,
+    output.type === "EdgeFunction" ? {
+      edgeFunction: output,
+      match: new Set(keys),
+      middlewarePath: params.middlewarePath,
+      outputPath,
+      type: "middleware"
+    } : {
+      match: new Set(keys),
+      middlewarePath: params.middlewarePath,
+      outputPath,
+      type: "middleware-lambda"
+    }
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getBuildResultMetadata
+});

package/dist/collect-build-result/get-lambda-by-output-path.d.ts

@@ -0,0 +1,13 @@
+import type { EdgeFunction } from '../edge-function';
+import type { File } from '../types';
+import type { Lambda } from '../lambda';
+import type { Prerender } from '../prerender';
+/**
+ * A Prerender can hold references to a Lambda or another Prerender when
+ * using PPR. This function retrieves the Lambda or Prerender from the
+ * build output map ensuring its type.
+ */
+export declare function getLambdaByOutputPath(params: {
+    buildOutputMap: Record<string, EdgeFunction | Lambda | Prerender | File>;
+    outputPath: string;
+}): Lambda | undefined;

package/dist/collect-build-result/get-lambda-by-output-path.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var get_lambda_by_output_path_exports = {};
+__export(get_lambda_by_output_path_exports, {
+  getLambdaByOutputPath: () => getLambdaByOutputPath
+});
+module.exports = __toCommonJS(get_lambda_by_output_path_exports);
+function getLambdaByOutputPath(params) {
+  const output = params.buildOutputMap[params.outputPath];
+  return output?.type === "Lambda" ? output : output?.type === "Prerender" ? output.lambda : void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getLambdaByOutputPath
+});

package/dist/collect-build-result/get-prerender-chain.d.ts

@@ -0,0 +1,8 @@
+import type { Chain } from '../types';
+import type { Prerender } from '../prerender';
+/**
+ * The Prerender chain can be defined as a `chain` property or as a flag
+ * `experimentalStreamingLambdaPath`. This function normalizes the chain
+ * to a single structure.
+ */
+export declare function getPrerenderChain(prerender: Prerender): Chain | undefined;

package/dist/collect-build-result/get-prerender-chain.js

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var get_prerender_chain_exports = {};
+__export(get_prerender_chain_exports, {
+  getPrerenderChain: () => getPrerenderChain
+});
+module.exports = __toCommonJS(get_prerender_chain_exports);
+function getPrerenderChain(prerender) {
+  if (prerender.chain) {
+    return {
+      outputPath: prerender.chain.outputPath,
+      headers: prerender.chain.headers
+    };
+  }
+  if (prerender.experimentalStreamingLambdaPath) {
+    return {
+      outputPath: prerender.experimentalStreamingLambdaPath,
+      headers: {
+        "x-matched-path": prerender.experimentalStreamingLambdaPath
+      }
+    };
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPrerenderChain
+});

package/dist/collect-build-result/is-route-middleware.d.ts

@@ -0,0 +1,4 @@
+import type { Route } from '@vercel/routing-utils';
+export declare function isRouteMiddleware(route: Route): route is Route & {
+    middlewarePath: string;
+};

package/dist/collect-build-result/is-route-middleware.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var is_route_middleware_exports = {};
+__export(is_route_middleware_exports, {
+  isRouteMiddleware: () => isRouteMiddleware
+});
+module.exports = __toCommonJS(is_route_middleware_exports);
+function isRouteMiddleware(route) {
+  return "middlewarePath" in route && typeof route.middlewarePath === "string";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isRouteMiddleware
+});

package/dist/collect-build-result/stream-with-extended-payload.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+export interface ExtendedBodyData {
+    prefix: string;
+    suffix: string;
+}
+export declare function streamWithExtendedPayload(stream: NodeJS.ReadableStream, data?: ExtendedBodyData): NodeJS.ReadableStream;

package/dist/collect-build-result/stream-with-extended-payload.js

@@ -0,0 +1,49 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stream_with_extended_payload_exports = {};
+__export(stream_with_extended_payload_exports, {
+  streamWithExtendedPayload: () => streamWithExtendedPayload
+});
+module.exports = __toCommonJS(stream_with_extended_payload_exports);
+var import_stream = require("stream");
+function streamWithExtendedPayload(stream, data) {
+  return data ? new MultipartContentStream(stream, data) : stream;
+}
+class MultipartContentStream extends import_stream.Readable {
+  constructor(stream, data) {
+    super();
+    stream.on("error", (err) => {
+      this.emit("error", err);
+    });
+    stream.on("end", () => {
+      this.push(data.suffix);
+      this.push(null);
+    });
+    this.push(data.prefix);
+    stream.on("data", (chunk) => {
+      this.push(chunk);
+    });
+  }
+  _read() {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  streamWithExtendedPayload
+});

package/dist/fs/stream-to-digest-async.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export interface FileDigest {
+    md5: string;
+    sha256: string;
+    size: number;
+}
+export declare function streamToDigestAsync(stream: NodeJS.ReadableStream): Promise<FileDigest>;
+export declare function sha256(value: any): string;
+export declare function md5(value: Buffer): string;

package/dist/fs/stream-to-digest-async.js

@@ -0,0 +1,62 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stream_to_digest_async_exports = {};
+__export(stream_to_digest_async_exports, {
+  md5: () => md5,
+  sha256: () => sha256,
+  streamToDigestAsync: () => streamToDigestAsync
+});
+module.exports = __toCommonJS(stream_to_digest_async_exports);
+var import_crypto = require("crypto");
+async function streamToDigestAsync(stream) {
+  return await new Promise((resolve, reject) => {
+    stream.once("error", reject);
+    let count = 0;
+    const sha2562 = (0, import_crypto.createHash)("sha256");
+    const md52 = (0, import_crypto.createHash)("md5");
+    stream.on("end", () => {
+      const res = {
+        sha256: sha2562.digest("hex"),
+        md5: md52.digest("hex"),
+        size: count
+      };
+      resolve(res);
+    });
+    stream.on("readable", () => {
+      let chunk;
+      while (null !== (chunk = stream.read())) {
+        md52.update(chunk);
+        sha2562.update(chunk);
+        count += chunk.length;
+      }
+    });
+  });
+}
+function sha256(value) {
+  return (0, import_crypto.createHash)("sha256").update(value).digest("hex");
+}
+function md5(value) {
+  return (0, import_crypto.createHash)("md5").update(value).digest("hex");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  md5,
+  sha256,
+  streamToDigestAsync
+});

package/dist/index.d.ts

@@ -40,3 +40,9 @@ export { getEncryptedEnv, type EncryptedEnvFile, } from './process-serverless/ge
 export { getLambdaEnvironment } from './process-serverless/get-lambda-environment';
 export { getLambdaPreloadScripts, type BytecodeCachingOptions, } from './process-serverless/get-lambda-preload-scripts';
 export { getLambdaSupportsStreaming, type SupportsStreamingResult, } from './process-serverless/get-lambda-supports-streaming';
+export { streamToDigestAsync, sha256, md5, type FileDigest, } from './fs/stream-to-digest-async';
+export { getBuildResultMetadata, type BuildResultMetadata, } from './collect-build-result/get-build-result-metadata';
+export { getLambdaByOutputPath } from './collect-build-result/get-lambda-by-output-path';
+export { isRouteMiddleware } from './collect-build-result/is-route-middleware';
+export { getPrerenderChain } from './collect-build-result/get-prerender-chain';
+export { streamWithExtendedPayload, type ExtendedBodyData, } from './collect-build-result/stream-with-extended-payload';

package/dist/index.js

@@ -911,9 +911,9 @@ var require_stream_duplex = __commonJS({
     module2.exports = Duplex;
     var util = Object.create(require_util());
     util.inherits = require_inherits();
-    var Readable = require_stream_readable();
+    var Readable2 = require_stream_readable();
     var Writable = require_stream_writable();
-    util.inherits(Duplex, Readable);
+    util.inherits(Duplex, Readable2);
     {
       keys = objectKeys(Writable.prototype);
       for (v = 0; v < keys.length; v++) {
@@ -928,7 +928,7 @@ var require_stream_duplex = __commonJS({
     function Duplex(options) {
       if (!(this instanceof Duplex))
         return new Duplex(options);
-      Readable.call(this, options);
+      Readable2.call(this, options);
       Writable.call(this, options);
       if (options && options.readable === false)
         this.readable = false;
@@ -1244,10 +1244,10 @@ var require_stream_readable = __commonJS({
   "../../node_modules/.pnpm/readable-stream@2.3.8/node_modules/readable-stream/lib/_stream_readable.js"(exports2, module2) {
     "use strict";
     var pna = require_process_nextick_args();
-    module2.exports = Readable;
+    module2.exports = Readable2;
     var isArray = require_isarray();
     var Duplex;
-    Readable.ReadableState = ReadableState;
+    Readable2.ReadableState = ReadableState;
     var EE = require("events").EventEmitter;
     var EElistenerCount = function(emitter, type) {
       return emitter.listeners(type).length;
@@ -1275,7 +1275,7 @@ var require_stream_readable = __commonJS({
     var BufferList = require_BufferList();
     var destroyImpl = require_destroy();
     var StringDecoder;
-    util.inherits(Readable, Stream);
+    util.inherits(Readable2, Stream);
     var kProxyEvents = ["error", "close", "destroy", "pause", "resume"];
     function prependListener(emitter, event, fn) {
       if (typeof emitter.prependListener === "function")
@@ -1330,10 +1330,10 @@ var require_stream_readable = __commonJS({
         this.encoding = options.encoding;
       }
     }
-    function Readable(options) {
+    function Readable2(options) {
       Duplex = Duplex || require_stream_duplex();
-      if (!(this instanceof Readable))
-        return new Readable(options);
+      if (!(this instanceof Readable2))
+        return new Readable2(options);
       this._readableState = new ReadableState(options, this);
       this.readable = true;
       if (options) {
@@ -1344,7 +1344,7 @@ var require_stream_readable = __commonJS({
       }
       Stream.call(this);
     }
-    Object.defineProperty(Readable.prototype, "destroyed", {
+    Object.defineProperty(Readable2.prototype, "destroyed", {
       get: function() {
         if (this._readableState === void 0) {
           return false;
@@ -1358,13 +1358,13 @@ var require_stream_readable = __commonJS({
         this._readableState.destroyed = value;
       }
     });
-    Readable.prototype.destroy = destroyImpl.destroy;
-    Readable.prototype._undestroy = destroyImpl.undestroy;
-    Readable.prototype._destroy = function(err, cb) {
+    Readable2.prototype.destroy = destroyImpl.destroy;
+    Readable2.prototype._undestroy = destroyImpl.undestroy;
+    Readable2.prototype._destroy = function(err, cb) {
       this.push(null);
       cb(err);
     };
-    Readable.prototype.push = function(chunk, encoding) {
+    Readable2.prototype.push = function(chunk, encoding) {
       var state = this._readableState;
       var skipChunkCheck;
       if (!state.objectMode) {
@@ -1381,7 +1381,7 @@ var require_stream_readable = __commonJS({
       }
       return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
     };
-    Readable.prototype.unshift = function(chunk) {
+    Readable2.prototype.unshift = function(chunk) {
       return readableAddChunk(this, chunk, null, true, false);
     };
     function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
@@ -1449,10 +1449,10 @@ var require_stream_readable = __commonJS({
     function needMoreData(state) {
       return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
     }
-    Readable.prototype.isPaused = function() {
+    Readable2.prototype.isPaused = function() {
       return this._readableState.flowing === false;
     };
-    Readable.prototype.setEncoding = function(enc) {
+    Readable2.prototype.setEncoding = function(enc) {
       if (!StringDecoder)
         StringDecoder = require_string_decoder().StringDecoder;
       this._readableState.decoder = new StringDecoder(enc);
@@ -1495,7 +1495,7 @@ var require_stream_readable = __commonJS({
       }
       return state.length;
     }
-    Readable.prototype.read = function(n) {
+    Readable2.prototype.read = function(n) {
       debug2("read", n);
       n = parseInt(n, 10);
       var state = this._readableState;
@@ -1605,10 +1605,10 @@ var require_stream_readable = __commonJS({
       }
       state.readingMore = false;
     }
-    Readable.prototype._read = function(n) {
+    Readable2.prototype._read = function(n) {
       this.emit("error", new Error("_read() is not implemented"));
     };
-    Readable.prototype.pipe = function(dest, pipeOpts) {
+    Readable2.prototype.pipe = function(dest, pipeOpts) {
       var src = this;
       var state = this._readableState;
       switch (state.pipesCount) {
@@ -1718,7 +1718,7 @@ var require_stream_readable = __commonJS({
         }
       };
     }
-    Readable.prototype.unpipe = function(dest) {
+    Readable2.prototype.unpipe = function(dest) {
       var state = this._readableState;
       var unpipeInfo = { hasUnpiped: false };
       if (state.pipesCount === 0)
@@ -1756,7 +1756,7 @@ var require_stream_readable = __commonJS({
       dest.emit("unpipe", this, unpipeInfo);
       return this;
     };
-    Readable.prototype.on = function(ev, fn) {
+    Readable2.prototype.on = function(ev, fn) {
       var res = Stream.prototype.on.call(this, ev, fn);
       if (ev === "data") {
         if (this._readableState.flowing !== false)
@@ -1775,12 +1775,12 @@ var require_stream_readable = __commonJS({
       }
       return res;
     };
-    Readable.prototype.addListener = Readable.prototype.on;
+    Readable2.prototype.addListener = Readable2.prototype.on;
     function nReadingNextTick(self2) {
       debug2("readable nexttick read 0");
       self2.read(0);
     }
-    Readable.prototype.resume = function() {
+    Readable2.prototype.resume = function() {
       var state = this._readableState;
       if (!state.flowing) {
         debug2("resume");
@@ -1807,7 +1807,7 @@ var require_stream_readable = __commonJS({
       if (state.flowing && !state.reading)
         stream.read(0);
     }
-    Readable.prototype.pause = function() {
+    Readable2.prototype.pause = function() {
       debug2("call pause flowing=%j", this._readableState.flowing);
       if (false !== this._readableState.flowing) {
         debug2("pause");
@@ -1822,7 +1822,7 @@ var require_stream_readable = __commonJS({
       while (state.flowing && stream.read() !== null) {
       }
     }
-    Readable.prototype.wrap = function(stream) {
+    Readable2.prototype.wrap = function(stream) {
       var _this = this;
       var state = this._readableState;
       var paused = false;
@@ -1870,7 +1870,7 @@ var require_stream_readable = __commonJS({
       };
       return this;
     };
-    Object.defineProperty(Readable.prototype, "readableHighWaterMark", {
+    Object.defineProperty(Readable2.prototype, "readableHighWaterMark", {
       // making it explicit this property is not enumerable
       // because otherwise some prototype manipulation in
       // userland will fail
@@ -1879,7 +1879,7 @@ var require_stream_readable = __commonJS({
         return this._readableState.highWaterMark;
       }
     });
-    Readable._fromList = fromList;
+    Readable2._fromList = fromList;
     function fromList(n, state) {
       if (state.length === 0)
         return null;
@@ -2152,7 +2152,7 @@ var require_readable = __commonJS({
 // ../../node_modules/.pnpm/from2@2.3.0/node_modules/from2/index.js
 var require_from2 = __commonJS({
   "../../node_modules/.pnpm/from2@2.3.0/node_modules/from2/index.js"(exports2, module2) {
-    var Readable = require_readable().Readable;
+    var Readable2 = require_readable().Readable;
     var inherits = require_inherits();
     module2.exports = from2;
     from2.ctor = ctor;
@@ -2185,14 +2185,14 @@ var require_from2 = __commonJS({
         opts = {};
       }
       opts = defaults(opts);
-      inherits(Class, Readable);
+      inherits(Class, Readable2);
       function Class(override) {
         if (!(this instanceof Class))
           return new Class(override);
         this._reading = false;
         this._callback = check;
         this.destroyed = false;
-        Readable.call(this, override || opts);
+        Readable2.call(this, override || opts);
         var self2 = this;
         var hwm = this._readableState.highWaterMark;
         function check(err, data) {
@@ -7203,7 +7203,7 @@ var require_lib3 = __commonJS({
     var whatwgUrl = _interopDefault(require_public_api());
     var https = _interopDefault(require("https"));
     var zlib = _interopDefault(require("zlib"));
-    var Readable = Stream.Readable;
+    var Readable2 = Stream.Readable;
     var BUFFER = Symbol("buffer");
     var TYPE = Symbol("type");
     var Blob = class _Blob {
@@ -7255,7 +7255,7 @@ var require_lib3 = __commonJS({
         return Promise.resolve(ab);
       }
       stream() {
-        const readable = new Readable();
+        const readable = new Readable2();
         readable._read = function() {
         };
         readable.push(this[BUFFER]);
@@ -21848,11 +21848,13 @@ __export(src_exports, {
   findPackageJson: () => findPackageJson,
   functionsSchema: () => functionsSchema,
   generateNodeBuilderFunctions: () => generateNodeBuilderFunctions,
+  getBuildResultMetadata: () => getBuildResultMetadata,
   getDiscontinuedNodeVersions: () => getDiscontinuedNodeVersions,
   getEncryptedEnv: () => getEncryptedEnv,
   getEnvForPackageManager: () => getEnvForPackageManager,
   getIgnoreFilter: () => get_ignore_filter_default,
   getInstalledPackageVersion: () => getInstalledPackageVersion,
+  getLambdaByOutputPath: () => getLambdaByOutputPath,
   getLambdaEnvironment: () => getLambdaEnvironment,
   getLambdaOptionsFromFunction: () => getLambdaOptionsFromFunction,
   getLambdaPreloadScripts: () => getLambdaPreloadScripts,
@@ -21866,6 +21868,7 @@ __export(src_exports, {
   getPathForPackageManager: () => getPathForPackageManager,
   getPlatformEnv: () => getPlatformEnv,
   getPrefixedEnvVars: () => getPrefixedEnvVars,
+  getPrerenderChain: () => getPrerenderChain,
   getPrettyError: () => getPrettyError,
   getProvidedRuntime: () => getProvidedRuntime,
   getScriptName: () => getScriptName,
@@ -21887,7 +21890,9 @@ __export(src_exports, {
   isNodeBackendFramework: () => isNodeBackendFramework,
   isPythonEntrypoint: () => isPythonEntrypoint,
   isPythonFramework: () => isPythonFramework,
+  isRouteMiddleware: () => isRouteMiddleware,
   isSymbolicLink: () => isSymbolicLink,
+  md5: () => md5,
   normalizePath: () => normalizePath,
   packageManifestSchema: () => packageManifestSchema,
   readConfigFile: () => readConfigFile,
@@ -21901,12 +21906,15 @@ __export(src_exports, {
   runShellScript: () => runShellScript,
   sanitizeConsumerName: () => sanitizeConsumerName,
   scanParentDirs: () => scanParentDirs,
+  sha256: () => sha256,
   shouldServe: () => shouldServe,
   shouldUseExperimentalBackends: () => shouldUseExperimentalBackends,
   spawnAsync: () => spawnAsync,
   spawnCommand: () => spawnCommand,
   streamToBuffer: () => streamToBuffer,
   streamToBufferChunks: () => streamToBufferChunks,
+  streamToDigestAsync: () => streamToDigestAsync,
+  streamWithExtendedPayload: () => streamWithExtendedPayload,
   traverseUpDirectories: () => traverseUpDirectories,
   validateNpmrc: () => validateNpmrc,
   walkParentDirs: () => walkParentDirs
@@ -25479,6 +25487,163 @@ function streamToBuffer2(stream) {
     });
   });
 }
+
+// src/fs/stream-to-digest-async.ts
+var import_crypto = require("crypto");
+async function streamToDigestAsync(stream) {
+  return await new Promise((resolve, reject) => {
+    stream.once("error", reject);
+    let count = 0;
+    const sha2562 = (0, import_crypto.createHash)("sha256");
+    const md52 = (0, import_crypto.createHash)("md5");
+    stream.on("end", () => {
+      const res = {
+        sha256: sha2562.digest("hex"),
+        md5: md52.digest("hex"),
+        size: count
+      };
+      resolve(res);
+    });
+    stream.on("readable", () => {
+      let chunk;
+      while (null !== (chunk = stream.read())) {
+        md52.update(chunk);
+        sha2562.update(chunk);
+        count += chunk.length;
+      }
+    });
+  });
+}
+function sha256(value) {
+  return (0, import_crypto.createHash)("sha256").update(value).digest("hex");
+}
+function md5(value) {
+  return (0, import_crypto.createHash)("md5").update(value).digest("hex");
+}
+
+// src/collect-build-result/get-lambda-by-output-path.ts
+function getLambdaByOutputPath(params) {
+  const output = params.buildOutputMap[params.outputPath];
+  return output?.type === "Lambda" ? output : output?.type === "Prerender" ? output.lambda : void 0;
+}
+
+// src/collect-build-result/get-prerender-chain.ts
+function getPrerenderChain(prerender) {
+  if (prerender.chain) {
+    return {
+      outputPath: prerender.chain.outputPath,
+      headers: prerender.chain.headers
+    };
+  }
+  if (prerender.experimentalStreamingLambdaPath) {
+    return {
+      outputPath: prerender.experimentalStreamingLambdaPath,
+      headers: {
+        "x-matched-path": prerender.experimentalStreamingLambdaPath
+      }
+    };
+  }
+  return void 0;
+}
+
+// src/collect-build-result/is-route-middleware.ts
+function isRouteMiddleware(route) {
+  return "middlewarePath" in route && typeof route.middlewarePath === "string";
+}
+
+// src/collect-build-result/get-build-result-metadata.ts
+function getBuildResultMetadata(params) {
+  return {
+    middleware: getMiddlewareMetadata(params),
+    ppr: new Map(
+      Object.entries(params.buildOutputMap).flatMap(([_outputPath, output]) => {
+        if (output.type === "Prerender") {
+          const chain = getPrerenderChain(output);
+          if (chain) {
+            const maybeLambda = getLambdaByOutputPath({
+              buildOutputMap: params.buildOutputMap,
+              outputPath: chain.outputPath
+            });
+            if (maybeLambda) {
+              return [[chain.outputPath, true]];
+            }
+          }
+        }
+        return [];
+      })
+    )
+  };
+}
+function getMiddlewareMetadata(params) {
+  const deduped = new Map(
+    params.routes.filter(isRouteMiddleware).map(
+      (route) => toMiddlewareTuple({
+        buildOutputMap: params.buildOutputMap,
+        middlewarePath: route.middlewarePath
+      })
+    )
+  );
+  return new Map(
+    Array.from(deduped, ([outputPath, metadata], index) => [
+      outputPath,
+      { ...metadata, index }
+    ])
+  );
+}
+function toMiddlewareTuple(params) {
+  const keys = [
+    params.middlewarePath,
+    params.middlewarePath.replace(/^\//, "")
+  ];
+  const [outputPath, output] = Object.entries(params.buildOutputMap).find(
+    (entry) => keys.includes(entry[0]) && (entry[1].type === "EdgeFunction" || entry[1].type === "Lambda")
+  ) ?? [];
+  if (!outputPath || !output) {
+    throw new NowBuildError({
+      message: `Mapping ${params.middlewarePath} not found. Maybe you provided a wrong middlewarePath?`,
+      code: "middleware_path_not_found"
+    });
+  }
+  return [
+    outputPath,
+    output.type === "EdgeFunction" ? {
+      edgeFunction: output,
+      match: new Set(keys),
+      middlewarePath: params.middlewarePath,
+      outputPath,
+      type: "middleware"
+    } : {
+      match: new Set(keys),
+      middlewarePath: params.middlewarePath,
+      outputPath,
+      type: "middleware-lambda"
+    }
+  ];
+}
+
+// src/collect-build-result/stream-with-extended-payload.ts
+var import_stream = require("stream");
+function streamWithExtendedPayload(stream, data) {
+  return data ? new MultipartContentStream(stream, data) : stream;
+}
+var MultipartContentStream = class extends import_stream.Readable {
+  constructor(stream, data) {
+    super();
+    stream.on("error", (err) => {
+      this.emit("error", err);
+    });
+    stream.on("end", () => {
+      this.push(data.suffix);
+      this.push(null);
+    });
+    this.push(data.prefix);
+    stream.on("data", (chunk) => {
+      this.push(chunk);
+    });
+  }
+  _read() {
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BACKEND_BUILDERS,
@@ -25512,11 +25677,13 @@ function streamToBuffer2(stream) {
   findPackageJson,
   functionsSchema,
   generateNodeBuilderFunctions,
+  getBuildResultMetadata,
   getDiscontinuedNodeVersions,
   getEncryptedEnv,
   getEnvForPackageManager,
   getIgnoreFilter,
   getInstalledPackageVersion,
+  getLambdaByOutputPath,
   getLambdaEnvironment,
   getLambdaOptionsFromFunction,
   getLambdaPreloadScripts,
@@ -25530,6 +25697,7 @@ function streamToBuffer2(stream) {
   getPathForPackageManager,
   getPlatformEnv,
   getPrefixedEnvVars,
+  getPrerenderChain,
   getPrettyError,
   getProvidedRuntime,
   getScriptName,
@@ -25551,7 +25719,9 @@ function streamToBuffer2(stream) {
   isNodeBackendFramework,
   isPythonEntrypoint,
   isPythonFramework,
+  isRouteMiddleware,
   isSymbolicLink,
+  md5,
   normalizePath,
   packageManifestSchema,
   readConfigFile,
@@ -25565,12 +25735,15 @@ function streamToBuffer2(stream) {
   runShellScript,
   sanitizeConsumerName,
   scanParentDirs,
+  sha256,
   shouldServe,
   shouldUseExperimentalBackends,
   spawnAsync,
   spawnCommand,
   streamToBuffer,
   streamToBufferChunks,
+  streamToDigestAsync,
+  streamWithExtendedPayload,
   traverseUpDirectories,
   validateNpmrc,
   walkParentDirs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/build-utils",
-  "version": "13.11.0",
+  "version": "13.12.0",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",
@@ -52,8 +52,8 @@
     "yazl": "2.5.1",
     "vitest": "2.0.1",
     "json5": "2.2.3",
-    "@vercel/routing-utils": "6.1.1",
-    "@vercel/error-utils": "2.0.3"
+    "@vercel/error-utils": "2.0.3",
+    "@vercel/routing-utils": "6.1.1"
   },
   "scripts": {
     "build": "node build.mjs",