@vercel/build-utils 2.13.1-canary.0 → 2.14.1-canary.0

package/dist/lambda.d.ts

@@ -3,17 +3,7 @@ import { Files, Config } from './types';
 interface Environment {
     [key: string]: string;
 }
-interface LambdaOptions {
-    zipBuffer: Buffer;
-    handler: string;
-    runtime: string;
-    memory?: number;
-    maxDuration?: number;
-    environment: Environment;
-    allowQuery?: string[];
-    regions?: string[];
-}
-interface CreateLambdaOptions {
+export interface LambdaOptions {
     files: Files;
     handler: string;
     runtime: string;
@@ -22,15 +12,18 @@ interface CreateLambdaOptions {
     environment?: Environment;
     allowQuery?: string[];
     regions?: string[];
+    /**
+     * @deprecated Use `files` property instead.
+     */
+    zipBuffer?: Buffer;
 }
 interface GetLambdaOptionsFromFunctionOptions {
     sourceFile: string;
     config?: Pick<Config, 'functions'>;
 }
-export declare const FILES_SYMBOL: unique symbol;
 export declare class Lambda {
     type: 'Lambda';
-    zipBuffer: Buffer;
+    files: Files;
     handler: string;
     runtime: string;
     memory?: number;
@@ -38,9 +31,17 @@ export declare class Lambda {
     environment: Environment;
     allowQuery?: string[];
     regions?: string[];
-    constructor({ zipBuffer, handler, runtime, maxDuration, memory, environment, allowQuery, regions, }: LambdaOptions);
+    /**
+     * @deprecated Use `await lambda.createZip()` instead.
+     */
+    zipBuffer?: Buffer;
+    constructor({ files, handler, runtime, maxDuration, memory, environment, allowQuery, regions, zipBuffer, }: LambdaOptions);
+    createZip(): Promise<Buffer>;
 }
-export declare function createLambda({ files, handler, runtime, memory, maxDuration, environment, allowQuery, regions, }: CreateLambdaOptions): Promise<Lambda>;
+/**
+ * @deprecated Use `new Lambda()` instead.
+ */
+export declare function createLambda(opts: LambdaOptions): Promise<Lambda>;
 export declare function createZip(files: Files): Promise<Buffer>;
 export declare function getLambdaOptionsFromFunction({ sourceFile, config, }: GetLambdaOptionsFromFunctionOptions): Promise<Pick<LambdaOptions, 'memory' | 'maxDuration'>>;
 export {};

package/dist/lambda.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLambdaOptionsFromFunction = exports.createZip = exports.createLambda = exports.Lambda = exports.FILES_SYMBOL = void 0;
+exports.getLambdaOptionsFromFunction = exports.createZip = exports.createLambda = exports.Lambda = void 0;
 const assert_1 = __importDefault(require("assert"));
 const async_sema_1 = __importDefault(require("async-sema"));
 const yazl_1 = require("yazl");
@@ -11,11 +11,30 @@ const minimatch_1 = __importDefault(require("minimatch"));
 const fs_extra_1 = require("fs-extra");
 const download_1 = require("./fs/download");
 const stream_to_buffer_1 = __importDefault(require("./fs/stream-to-buffer"));
-exports.FILES_SYMBOL = Symbol('files');
 class Lambda {
-    constructor({ zipBuffer, handler, runtime, maxDuration, memory, environment, allowQuery, regions, }) {
+    constructor({ files, handler, runtime, maxDuration, memory, environment = {}, allowQuery, regions, zipBuffer, }) {
+        if (!zipBuffer) {
+            assert_1.default(typeof files === 'object', '"files" must be an object');
+        }
+        assert_1.default(typeof handler === 'string', '"handler" is not a string');
+        assert_1.default(typeof runtime === 'string', '"runtime" is not a string');
+        assert_1.default(typeof environment === 'object', '"environment" is not an object');
+        if (memory !== undefined) {
+            assert_1.default(typeof memory === 'number', '"memory" is not a number');
+        }
+        if (maxDuration !== undefined) {
+            assert_1.default(typeof maxDuration === 'number', '"maxDuration" is not a number');
+        }
+        if (allowQuery !== undefined) {
+            assert_1.default(Array.isArray(allowQuery), '"allowQuery" is not an Array');
+            assert_1.default(allowQuery.every(q => typeof q === 'string'), '"allowQuery" is not a string Array');
+        }
+        if (regions !== undefined) {
+            assert_1.default(Array.isArray(regions), '"regions" is not an Array');
+            assert_1.default(regions.every(r => typeof r === 'string'), '"regions" is not a string Array');
+        }
         this.type = 'Lambda';
-        this.zipBuffer = zipBuffer;
+        this.files = files;
         this.handler = handler;
         this.runtime = runtime;
         this.memory = memory;
@@ -23,49 +42,33 @@ class Lambda {
         this.environment = environment;
         this.allowQuery = allowQuery;
         this.regions = regions;
+        this.zipBuffer = zipBuffer;
+    }
+    async createZip() {
+        let { zipBuffer } = this;
+        if (!zipBuffer) {
+            await sema.acquire();
+            try {
+                zipBuffer = await createZip(this.files);
+            }
+            finally {
+                sema.release();
+            }
+        }
+        return zipBuffer;
     }
 }
 exports.Lambda = Lambda;
 const sema = new async_sema_1.default(10);
 const mtime = new Date(1540000000000);
-async function createLambda({ files, handler, runtime, memory, maxDuration, environment = {}, allowQuery, regions, }) {
-    assert_1.default(typeof files === 'object', '"files" must be an object');
-    assert_1.default(typeof handler === 'string', '"handler" is not a string');
-    assert_1.default(typeof runtime === 'string', '"runtime" is not a string');
-    assert_1.default(typeof environment === 'object', '"environment" is not an object');
-    if (memory !== undefined) {
-        assert_1.default(typeof memory === 'number', '"memory" is not a number');
-    }
-    if (maxDuration !== undefined) {
-        assert_1.default(typeof maxDuration === 'number', '"maxDuration" is not a number');
-    }
-    if (allowQuery !== undefined) {
-        assert_1.default(Array.isArray(allowQuery), '"allowQuery" is not an Array');
-        assert_1.default(allowQuery.every(q => typeof q === 'string'), '"allowQuery" is not a string Array');
-    }
-    if (regions !== undefined) {
-        assert_1.default(Array.isArray(regions), '"regions" is not an Array');
-        assert_1.default(regions.every(r => typeof r === 'string'), '"regions" is not a string Array');
-    }
-    await sema.acquire();
-    try {
-        const zipBuffer = await createZip(files);
-        const lambda = new Lambda({
-            zipBuffer,
-            handler,
-            runtime,
-            memory,
-            maxDuration,
-            environment,
-            regions,
-        });
-        // @ts-ignore This symbol is a private API
-        lambda[exports.FILES_SYMBOL] = files;
-        return lambda;
-    }
-    finally {
-        sema.release();
-    }
+/**
+ * @deprecated Use `new Lambda()` instead.
+ */
+async function createLambda(opts) {
+    const lambda = new Lambda(opts);
+    // backwards compat
+    lambda.zipBuffer = await lambda.createZip();
+    return lambda;
 }
 exports.createLambda = createLambda;
 async function createZip(files) {
@@ -100,7 +103,7 @@ async function createZip(files) {
 }
 exports.createZip = createZip;
 async function getLambdaOptionsFromFunction({ sourceFile, config, }) {
-    if (config && config.functions) {
+    if (config === null || config === void 0 ? void 0 : config.functions) {
         for (const [pattern, fn] of Object.entries(config.functions)) {
             if (sourceFile === pattern || minimatch_1.default(sourceFile, pattern)) {
                 return {

package/dist/nodejs-lambda.d.ts

@@ -0,0 +1,14 @@
+import { Lambda, LambdaOptions } from './lambda';
+interface NodejsLambdaOptions extends LambdaOptions {
+    shouldAddHelpers: boolean;
+    shouldAddSourcemapSupport: boolean;
+    awsLambdaHandler?: string;
+}
+export declare class NodejsLambda extends Lambda {
+    launcherType: 'Nodejs';
+    shouldAddHelpers: boolean;
+    shouldAddSourcemapSupport: boolean;
+    awsLambdaHandler?: string;
+    constructor({ shouldAddHelpers, shouldAddSourcemapSupport, awsLambdaHandler, ...opts }: NodejsLambdaOptions);
+}
+export {};

package/dist/nodejs-lambda.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodejsLambda = void 0;
+const lambda_1 = require("./lambda");
+class NodejsLambda extends lambda_1.Lambda {
+    constructor({ shouldAddHelpers, shouldAddSourcemapSupport, awsLambdaHandler, ...opts }) {
+        super(opts);
+        this.launcherType = 'Nodejs';
+        this.shouldAddHelpers = shouldAddHelpers;
+        this.shouldAddSourcemapSupport = shouldAddSourcemapSupport;
+        this.awsLambdaHandler = awsLambdaHandler;
+    }
+}
+exports.NodejsLambda = NodejsLambda;

package/dist/types.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import FileRef from './file-ref';
 import FileFsRef from './file-fs-ref';
+import { Lambda } from './lambda';
 export interface Env {
     [name: string]: string | undefined;
 }
@@ -319,3 +320,40 @@ export interface ProjectSettings {
     directoryListing?: boolean;
     gitForkProtection?: boolean;
 }
+export interface BuilderV2 {
+    version: 2;
+    build: BuildV2;
+    prepareCache?: PrepareCache;
+}
+export interface BuilderV3 {
+    version: 3;
+    build: BuildV3;
+    prepareCache?: PrepareCache;
+    startDevServer?: StartDevServer;
+}
+declare type ImageFormat = 'image/avif' | 'image/webp';
+export interface Images {
+    domains: string[];
+    sizes: number[];
+    minimumCacheTTL?: number;
+    formats?: ImageFormat[];
+}
+export interface BuildResultV2 {
+    routes: any[];
+    images?: Images;
+    output: {
+        [key: string]: File | Lambda;
+    };
+    wildcard?: Array<{
+        domain: string;
+        value: string;
+    }>;
+}
+export interface BuildResultV3 {
+    output: Lambda;
+}
+export declare type BuildV2 = (options: BuildOptions) => Promise<BuildResultV2>;
+export declare type BuildV3 = (options: BuildOptions) => Promise<BuildResultV3>;
+export declare type PrepareCache = (options: PrepareCacheOptions) => Promise<Files>;
+export declare type StartDevServer = (options: StartDevServerOptions) => Promise<StartDevServerResult>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/build-utils",
-  "version": "2.13.1-canary.0",
+  "version": "2.14.1-canary.0",
   "license": "MIT",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",
@@ -30,7 +30,7 @@
     "@types/node-fetch": "^2.1.6",
     "@types/semver": "6.0.0",
     "@types/yazl": "^2.4.1",
-    "@vercel/frameworks": "0.5.1-canary.20",
+    "@vercel/frameworks": "0.6.1-canary.0",
     "@vercel/ncc": "0.24.0",
     "aggregate-error": "3.0.1",
     "async-retry": "1.2.3",
@@ -49,5 +49,5 @@
     "typescript": "4.3.4",
     "yazl": "2.4.3"
   },
-  "gitHead": "9bbb2cdcbd39846f4a7c97c3cf8838eee130eec4"
+  "gitHead": "04029013a60ed96c86ed369990cef6dd284d1724"
 }

package/dist/convert-runtime-to-plugin.d.ts

@@ -1,65 +0,0 @@
-import { Lambda } from './lambda';
-import type { BuildOptions } from './types';
-/**
- * Convert legacy Runtime to a Plugin.
- * @param buildRuntime - a legacy build() function from a Runtime
- * @param packageName - the name of the package, for example `vercel-plugin-python`
- * @param ext - the file extension, for example `.py`
- */
-export declare function _experimental_convertRuntimeToPlugin(buildRuntime: (options: BuildOptions) => Promise<{
-    output: Lambda;
-}>, packageName: string, ext: string): ({ workPath }: {
-    workPath: string;
-}) => Promise<void>;
-/**
- * If `.output/functions-manifest.json` exists, append to the pages
- * property. Otherwise write a new file.
- */
-export declare function _experimental_updateFunctionsManifest({ workPath, pages, }: {
-    workPath: string;
-    pages: {
-        [key: string]: any;
-    };
-}): Promise<void>;
-/**
- * Append routes to the `routes-manifest.json` file.
- * If the file does not exist, it will be created.
- */
-export declare function _experimental_updateRoutesManifest({ workPath, redirects, rewrites, headers, dynamicRoutes, staticRoutes, }: {
-    workPath: string;
-    redirects?: {
-        source: string;
-        destination: string;
-        statusCode: number;
-        regex: string;
-    }[];
-    rewrites?: {
-        source: string;
-        destination: string;
-        regex: string;
-    }[];
-    headers?: {
-        source: string;
-        headers: {
-            key: string;
-            value: string;
-        }[];
-        regex: string;
-    }[];
-    dynamicRoutes?: {
-        page: string;
-        regex: string;
-        namedRegex?: string;
-        routeKeys?: {
-            [named: string]: string;
-        };
-    }[];
-    staticRoutes?: {
-        page: string;
-        regex: string;
-        namedRegex?: string;
-        routeKeys?: {
-            [named: string]: string;
-        };
-    }[];
-}): Promise<void>;

package/dist/convert-runtime-to-plugin.js

@@ -1,298 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._experimental_updateRoutesManifest = exports._experimental_updateFunctionsManifest = exports._experimental_convertRuntimeToPlugin = void 0;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = require("path");
-const glob_1 = __importDefault(require("./fs/glob"));
-const normalize_path_1 = require("./fs/normalize-path");
-const lambda_1 = require("./lambda");
-const _1 = require(".");
-// `.output` was already created by the Build Command, so we have
-// to ensure its contents don't get bundled into the Lambda. Similarily,
-// we don't want to bundle anything from `.vercel` either. Lastly,
-// Builders/Runtimes didn't have `vercel.json` or `now.json`.
-const ignoredPaths = ['.output', '.vercel', 'vercel.json', 'now.json'];
-const shouldIgnorePath = (file, ignoreFilter, ignoreFile) => {
-    const isNative = ignoredPaths.some(item => {
-        return file.startsWith(item);
-    });
-    if (!ignoreFile) {
-        return isNative;
-    }
-    return isNative || ignoreFilter(file);
-};
-const getSourceFiles = async (workPath, ignoreFilter) => {
-    const list = await glob_1.default('**', {
-        cwd: workPath,
-    });
-    // We're not passing this as an `ignore` filter to the `glob` function above,
-    // so that we can re-use exactly the same `getIgnoreFilter` method that the
-    // Build Step uses (literally the same code). Note that this exclusion only applies
-    // when deploying. Locally, another exclusion is needed, which is handled
-    // further below in the `convertRuntimeToPlugin` function.
-    for (const file in list) {
-        if (shouldIgnorePath(file, ignoreFilter, true)) {
-            delete list[file];
-        }
-    }
-    return list;
-};
-/**
- * Convert legacy Runtime to a Plugin.
- * @param buildRuntime - a legacy build() function from a Runtime
- * @param packageName - the name of the package, for example `vercel-plugin-python`
- * @param ext - the file extension, for example `.py`
- */
-function _experimental_convertRuntimeToPlugin(buildRuntime, packageName, ext) {
-    // This `build()` signature should match `plugin.build()` signature in `vercel build`.
-    return async function build({ workPath }) {
-        // We also don't want to provide any files to Runtimes that were ignored
-        // through `.vercelignore` or `.nowignore`, because the Build Step does the same.
-        const ignoreFilter = await _1.getIgnoreFilter(workPath);
-        // Retrieve the files that are currently available on the File System,
-        // before the Legacy Runtime has even started to build.
-        const sourceFilesPreBuild = await getSourceFiles(workPath, ignoreFilter);
-        // Instead of doing another `glob` to get all the matching source files,
-        // we'll filter the list of existing files down to only the ones
-        // that are matching the entrypoint pattern, so we're first creating
-        // a clean new list to begin.
-        const entrypoints = Object.assign({}, sourceFilesPreBuild);
-        const entrypointMatch = new RegExp(`^api/.*${ext}$`);
-        // Up next, we'll strip out the files from the list of entrypoints
-        // that aren't actually considered entrypoints.
-        for (const file in entrypoints) {
-            if (!entrypointMatch.test(file)) {
-                delete entrypoints[file];
-            }
-        }
-        const pages = {};
-        const pluginName = packageName.replace('vercel-plugin-', '');
-        const outputPath = path_1.join(workPath, '.output');
-        const traceDir = path_1.join(outputPath, `inputs`, 
-        // Legacy Runtimes can only provide API Routes, so that's
-        // why we can use this prefix for all of them. Here, we have to
-        // make sure to not use a cryptic hash name, because people
-        // need to be able to easily inspect the output.
-        `api-routes-${pluginName}`);
-        await fs_extra_1.default.ensureDir(traceDir);
-        const entryRoot = path_1.join(outputPath, 'server', 'pages');
-        for (const entrypoint of Object.keys(entrypoints)) {
-            const { output } = await buildRuntime({
-                files: sourceFilesPreBuild,
-                entrypoint,
-                workPath,
-                config: {
-                    zeroConfig: true,
-                },
-                meta: {
-                    avoidTopLevelInstall: true,
-                    skipDownload: true,
-                },
-            });
-            // @ts-ignore This symbol is a private API
-            const lambdaFiles = output[lambda_1.FILES_SYMBOL];
-            // When deploying, the `files` that are passed to the Legacy Runtimes already
-            // have certain files that are ignored stripped, but locally, that list of
-            // files isn't used by the Legacy Runtimes, so we need to apply the filters
-            // to the outputs that they are returning instead.
-            for (const file in lambdaFiles) {
-                if (shouldIgnorePath(file, ignoreFilter, false)) {
-                    delete lambdaFiles[file];
-                }
-            }
-            let handlerFileBase = output.handler;
-            let handlerFile = lambdaFiles[handlerFileBase];
-            let handlerHasImport = false;
-            const { handler } = output;
-            const handlerMethod = handler.split('.').pop();
-            const handlerFileName = handler.replace(`.${handlerMethod}`, '');
-            // For compiled languages, the launcher file for the Lambda generated
-            // by the Legacy Runtime matches the `handler` defined for it, but for
-            // interpreted languages, the `handler` consists of the launcher file name
-            // without an extension, plus the name of the method inside of that file
-            // that should be invoked, so we have to construct the file path explicitly.
-            if (!handlerFile) {
-                handlerFileBase = handlerFileName + ext;
-                handlerFile = lambdaFiles[handlerFileBase];
-                handlerHasImport = true;
-            }
-            if (!handlerFile || !handlerFile.fsPath) {
-                throw new Error(`Could not find a handler file. Please ensure that \`files\` for the returned \`Lambda\` contains an \`FileFsRef\` named "${handlerFileBase}" with a valid \`fsPath\`.`);
-            }
-            const handlerExtName = path_1.extname(handlerFile.fsPath);
-            const entryBase = path_1.basename(entrypoint).replace(ext, handlerExtName);
-            const entryPath = path_1.join(path_1.dirname(entrypoint), entryBase);
-            const entry = path_1.join(entryRoot, entryPath);
-            // Create the parent directory of the API Route that will be created
-            // for the current entrypoint inside of `.output/server/pages/api`.
-            await fs_extra_1.default.ensureDir(path_1.dirname(entry));
-            // For compiled languages, the launcher file will be binary and therefore
-            // won't try to import a user-provided request handler (instead, it will
-            // contain it). But for interpreted languages, the launcher might try to
-            // load a user-provided request handler from the source file instead of bundling
-            // it, so we have to adjust the import statement inside the launcher to point
-            // to the respective source file. Previously, Legacy Runtimes simply expected
-            // the user-provided request-handler to be copied right next to the launcher,
-            // but with the new File System API, files won't be moved around unnecessarily.
-            if (handlerHasImport) {
-                const { fsPath } = handlerFile;
-                const encoding = 'utf-8';
-                // This is the true directory of the user-provided request handler in the
-                // source files, so that's what we will use as an import path in the launcher.
-                const locationPrefix = path_1.relative(entry, outputPath);
-                let handlerContent = await fs_extra_1.default.readFile(fsPath, encoding);
-                const importPaths = [
-                    // This is the full entrypoint path, like `./api/test.py`. In our tests
-                    // Python didn't support importing from a parent directory without using different
-                    // code in the launcher that registers it as a location for modules and then changing
-                    // the importing syntax, but continuing to import it like before seems to work. If
-                    // other languages need this, we should consider excluding Python explicitly.
-                    // `./${entrypoint}`,
-                    // This is the entrypoint path without extension, like `api/test`
-                    entrypoint.slice(0, -ext.length),
-                ];
-                // Generate a list of regular expressions that we can use for
-                // finding matches, but only allow matches if the import path is
-                // wrapped inside single (') or double quotes (").
-                const patterns = importPaths.map(path => {
-                    // eslint-disable-next-line no-useless-escape
-                    return new RegExp(`('|")(${path.replace(/\./g, '\\.')})('|")`, 'g');
-                });
-                let replacedMatch = null;
-                for (const pattern of patterns) {
-                    const newContent = handlerContent.replace(pattern, (_, p1, p2, p3) => {
-                        return `${p1}${path_1.join(locationPrefix, p2)}${p3}`;
-                    });
-                    if (newContent !== handlerContent) {
-                        _1.debug(`Replaced "${pattern}" inside "${entry}" to ensure correct import of user-provided request handler`);
-                        handlerContent = newContent;
-                        replacedMatch = true;
-                    }
-                }
-                if (!replacedMatch) {
-                    new Error(`No replacable matches for "${importPaths[0]}" or "${importPaths[1]}" found in "${fsPath}"`);
-                }
-                await fs_extra_1.default.writeFile(entry, handlerContent, encoding);
-            }
-            else {
-                await fs_extra_1.default.copy(handlerFile.fsPath, entry);
-            }
-            // Legacy Runtimes based on interpreted languages will create a new launcher file
-            // for every entrypoint, but they will create each one inside `workPath`, which means that
-            // the launcher for one entrypoint will overwrite the launcher provided for the previous
-            // entrypoint. That's why, above, we copy the file contents into the new destination (and
-            // optionally transform them along the way), instead of linking. We then also want to remove
-            // the copy origin right here, so that the `workPath` doesn't contain a useless launcher file
-            // once the build has finished running.
-            await fs_extra_1.default.remove(handlerFile.fsPath);
-            _1.debug(`Removed temporary file "${handlerFile.fsPath}"`);
-            const nft = `${entry}.nft.json`;
-            const json = JSON.stringify({
-                version: 2,
-                files: Object.keys(lambdaFiles)
-                    .map(file => {
-                    const { fsPath } = lambdaFiles[file];
-                    if (!fsPath) {
-                        throw new Error(`File "${file}" is missing valid \`fsPath\` property`);
-                    }
-                    // The handler was already moved into position above.
-                    if (file === handlerFileBase) {
-                        return;
-                    }
-                    return normalize_path_1.normalizePath(path_1.relative(path_1.dirname(nft), fsPath));
-                })
-                    .filter(Boolean),
-            });
-            await fs_extra_1.default.writeFile(nft, json);
-            // Add an entry that will later on be added to the `functions-manifest.json`
-            // file that is placed inside of the `.output` directory.
-            pages[normalize_path_1.normalizePath(entryPath)] = {
-                // Because the underlying file used as a handler was placed
-                // inside `.output/server/pages/api`, it no longer has the name it originally
-                // had and is now named after the API Route that it's responsible for,
-                // so we have to adjust the name of the Lambda handler accordingly.
-                handler: handler.replace(handlerFileName, path_1.parse(entry).name),
-                runtime: output.runtime,
-                memory: output.memory,
-                maxDuration: output.maxDuration,
-                environment: output.environment,
-                allowQuery: output.allowQuery,
-            };
-        }
-        // Add any Serverless Functions that were exposed by the Legacy Runtime
-        // to the `functions-manifest.json` file provided in `.output`.
-        await _experimental_updateFunctionsManifest({ workPath, pages });
-    };
-}
-exports._experimental_convertRuntimeToPlugin = _experimental_convertRuntimeToPlugin;
-async function readJson(filePath) {
-    try {
-        const str = await fs_extra_1.default.readFile(filePath, 'utf8');
-        return JSON.parse(str);
-    }
-    catch (err) {
-        if (err.code === 'ENOENT') {
-            return {};
-        }
-        throw err;
-    }
-}
-/**
- * If `.output/functions-manifest.json` exists, append to the pages
- * property. Otherwise write a new file.
- */
-async function _experimental_updateFunctionsManifest({ workPath, pages, }) {
-    const functionsManifestPath = path_1.join(workPath, '.output', 'functions-manifest.json');
-    const functionsManifest = await readJson(functionsManifestPath);
-    if (!functionsManifest.version)
-        functionsManifest.version = 2;
-    if (!functionsManifest.pages)
-        functionsManifest.pages = {};
-    for (const [pageKey, pageConfig] of Object.entries(pages)) {
-        functionsManifest.pages[pageKey] = { ...pageConfig };
-    }
-    await fs_extra_1.default.writeFile(functionsManifestPath, JSON.stringify(functionsManifest));
-}
-exports._experimental_updateFunctionsManifest = _experimental_updateFunctionsManifest;
-/**
- * Append routes to the `routes-manifest.json` file.
- * If the file does not exist, it will be created.
- */
-async function _experimental_updateRoutesManifest({ workPath, redirects, rewrites, headers, dynamicRoutes, staticRoutes, }) {
-    const routesManifestPath = path_1.join(workPath, '.output', 'routes-manifest.json');
-    const routesManifest = await readJson(routesManifestPath);
-    if (!routesManifest.version)
-        routesManifest.version = 3;
-    if (routesManifest.pages404 === undefined)
-        routesManifest.pages404 = true;
-    if (redirects) {
-        if (!routesManifest.redirects)
-            routesManifest.redirects = [];
-        routesManifest.redirects.push(...redirects);
-    }
-    if (rewrites) {
-        if (!routesManifest.rewrites)
-            routesManifest.rewrites = [];
-        routesManifest.rewrites.push(...rewrites);
-    }
-    if (headers) {
-        if (!routesManifest.headers)
-            routesManifest.headers = [];
-        routesManifest.headers.push(...headers);
-    }
-    if (dynamicRoutes) {
-        if (!routesManifest.dynamicRoutes)
-            routesManifest.dynamicRoutes = [];
-        routesManifest.dynamicRoutes.push(...dynamicRoutes);
-    }
-    if (staticRoutes) {
-        if (!routesManifest.staticRoutes)
-            routesManifest.staticRoutes = [];
-        routesManifest.staticRoutes.push(...staticRoutes);
-    }
-    await fs_extra_1.default.writeFile(routesManifestPath, JSON.stringify(routesManifest));
-}
-exports._experimental_updateRoutesManifest = _experimental_updateRoutesManifest;