@netlify/zip-it-and-ship-it 8.0.0 → 8.2.0

package/README.md

@@ -137,6 +137,7 @@ The following properties are accepted:
   - `12.x` (or `nodejs12.x`)
   - `14.x` (or `nodejs14.x`)
   - `16.x` (or `nodejs16.x`)
+  - `18.x` (or `nodejs18.x`)
 
 - `rustTargetDirectory`
 

package/dist/archive.d.ts

@@ -3,7 +3,7 @@ import { Stats } from 'fs';
 import { Writable } from 'stream';
 import { Archiver } from 'archiver';
 export { Archiver as ZipArchive } from 'archiver';
-export declare type ArchiveFormat = 'none' | 'zip';
+export type ArchiveFormat = 'none' | 'zip';
 export declare const startZip: (destPath: string) => {
     archive: Archiver;
     output: Writable;

package/dist/config.d.ts

@@ -17,9 +17,9 @@ interface FunctionConfig {
     zipGo?: boolean;
     nodeModuleFormat?: ModuleFormat;
 }
-declare type GlobPattern = string;
-declare type Config = Record<GlobPattern, FunctionConfig>;
-declare type FunctionWithoutConfig = Omit<FunctionSource, 'config'>;
+type GlobPattern = string;
+type Config = Record<GlobPattern, FunctionConfig>;
+type FunctionWithoutConfig = Omit<FunctionSource, 'config'>;
 declare const getConfigForFunction: ({ config, configFileDirectories, func, featureFlags, }: {
     config?: Config | undefined;
     configFileDirectories?: string[] | undefined;

package/dist/feature_flags.d.ts

@@ -1,4 +1,4 @@
 export declare const defaultFlags: Record<string, boolean>;
-export declare type FeatureFlag = keyof typeof defaultFlags;
-export declare type FeatureFlags = Record<FeatureFlag, boolean>;
+export type FeatureFlag = keyof typeof defaultFlags;
+export type FeatureFlags = Record<FeatureFlag, boolean>;
 export declare const getFlags: (input?: Record<string, boolean>, flags?: Record<string, boolean>) => FeatureFlags;

package/dist/feature_flags.js

@@ -14,6 +14,12 @@ export const defaultFlags = {
     zisi_pure_esm_mjs: false,
     // Load configuration from per-function JSON files.
     project_deploy_configuration_api_use_per_function_configuration_files: false,
+    // Enable runtime cache for NFT
+    zisi_nft_use_cache: false,
+    // Raise file IO limit for NFT
+    zisi_nft_higher_fileio_limit: false,
+    // Provide banner to esbuild which allows requires in ESM output
+    zisi_esbuild_require_banner: false,
 };
 // List of supported flags and their default value.
 export const getFlags = (input = {}, flags = defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({

package/dist/function.d.ts

@@ -2,7 +2,7 @@
 import { Stats } from 'fs';
 import type { FunctionConfig } from './config.js';
 import type { Runtime, ZipFunctionResult } from './runtimes/runtime.js';
-export declare type FunctionArchive = ZipFunctionResult & {
+export type FunctionArchive = ZipFunctionResult & {
     mainFile: string;
     name: string;
     runtime: Runtime;
@@ -17,7 +17,7 @@ export interface SourceFile {
     srcPath: string;
     stat: Stats;
 }
-export declare type FunctionSource = SourceFile & {
+export type FunctionSource = SourceFile & {
     config: FunctionConfig;
     runtime: Runtime;
 };

package/dist/main.d.ts

@@ -12,7 +12,7 @@ export interface ListedFunction {
     extension: string;
     schedule?: string;
 }
-declare type ListedFunctionFile = ListedFunction & {
+type ListedFunctionFile = ListedFunction & {
     srcFile: string;
 };
 interface ListFunctionsOptions {

package/dist/main.js

@@ -2,6 +2,7 @@ import { extname } from 'path';
 import { getFlags } from './feature_flags.js';
 import { getFunctionFromPath, getFunctionsFromPaths } from './runtimes/index.js';
 import { findISCDeclarationsInPath } from './runtimes/node/in_source_config/index.js';
+import { RuntimeCache } from './utils/cache.js';
 import { listFunctionsDirectories, resolveFunctionsDirectories } from './utils/fs.js';
 export { zipFunction, zipFunctions } from './zip.js';
 const augmentWithISC = async (func) => {
@@ -17,7 +18,8 @@ export const listFunctions = async function (relativeSrcFolders, { featureFlags:
     const featureFlags = getFlags(inputFeatureFlags);
     const srcFolders = resolveFunctionsDirectories(relativeSrcFolders);
     const paths = await listFunctionsDirectories(srcFolders);
-    const functionsMap = await getFunctionsFromPaths(paths, { featureFlags, config });
+    const cache = new RuntimeCache();
+    const functionsMap = await getFunctionsFromPaths(paths, { cache, config, featureFlags });
     const functions = [...functionsMap.values()];
     const augmentedFunctions = parseISC ? await Promise.all(functions.map(augmentWithISC)) : functions;
     return augmentedFunctions.map(getListedFunction);
@@ -25,7 +27,8 @@ export const listFunctions = async function (relativeSrcFolders, { featureFlags:
 // Finds a function at a specific path.
 export const listFunction = async function (path, { featureFlags: inputFeatureFlags, config, parseISC = false, } = {}) {
     const featureFlags = getFlags(inputFeatureFlags);
-    const func = await getFunctionFromPath(path, { featureFlags, config });
+    const cache = new RuntimeCache();
+    const func = await getFunctionFromPath(path, { cache, config, featureFlags });
     if (!func) {
         return;
     }
@@ -37,7 +40,8 @@ export const listFunctionsFiles = async function (relativeSrcFolders, { basePath
     const featureFlags = getFlags(inputFeatureFlags);
     const srcFolders = resolveFunctionsDirectories(relativeSrcFolders);
     const paths = await listFunctionsDirectories(srcFolders);
-    const functionsMap = await getFunctionsFromPaths(paths, { config, featureFlags });
+    const cache = new RuntimeCache();
+    const functionsMap = await getFunctionsFromPaths(paths, { cache, config, featureFlags });
     const functions = [...functionsMap.values()];
     const augmentedFunctions = parseISC ? await Promise.all(functions.map(augmentWithISC)) : functions;
     const listedFunctionsFiles = await Promise.all(augmentedFunctions.map((func) => getListedFunctionFiles(func, { basePath, featureFlags })));

package/dist/runtimes/detect_runtime.d.ts

@@ -1,6 +1,4 @@
-import { FsCache } from '../utils/fs.js';
 import { RuntimeType } from './runtime.js';
-export declare const detectBinaryRuntime: ({ fsCache, path, }: {
-    fsCache: FsCache;
+export declare const detectBinaryRuntime: ({ path }: {
     path: string;
 }) => Promise<RuntimeType | undefined>;

package/dist/runtimes/detect_runtime.js

@@ -1,5 +1,5 @@
+import { readFile } from 'fs/promises';
 import { detect, Runtime as BinaryRuntime, Arch, Platform } from '@netlify/binary-info';
-import { cachedReadFile } from '../utils/fs.js';
 const isValidFunctionBinary = (info) => info.arch === Arch.Amd64 && info.platform === Platform.Linux;
 const warnIncompatibleBinary = function (path, binaryInfo) {
     if (!global.ZISI_CLI) {
@@ -10,13 +10,10 @@ The binary needs to be built for Linux/Amd64, but it was built for ${Platform[bi
     return undefined;
 };
 // Try to guess the runtime by inspecting the binary file.
-export const detectBinaryRuntime = async function ({ fsCache, path, }) {
+export const detectBinaryRuntime = async function ({ path }) {
     try {
-        const buffer = await cachedReadFile(fsCache, path);
-        // We're using the Type Assertion because the `cachedReadFile` abstraction
-        // loses part of the return type information. We can safely say it's a
-        // Buffer in this case because we're not specifying an encoding.
-        const binaryInfo = detect(buffer);
+        const fileContents = await readFile(path);
+        const binaryInfo = detect(fileContents);
         if (!isValidFunctionBinary(binaryInfo)) {
             return warnIncompatibleBinary(path, binaryInfo);
         }

package/dist/runtimes/go/index.js

@@ -5,37 +5,35 @@ import { nonNullable } from '../../utils/non_nullable.js';
 import { zipBinary } from '../../zip_binary.js';
 import { detectBinaryRuntime } from '../detect_runtime.js';
 import { build } from './builder.js';
-const detectGoFunction = async ({ fsCache, path }) => {
-    const stat = await cachedLstat(fsCache, path);
+const detectGoFunction = async ({ cache, path }) => {
+    const stat = await cachedLstat(cache.lstatCache, path);
     if (!stat.isDirectory()) {
         return;
     }
     const directoryName = basename(path);
-    // @ts-expect-error TODO: The `makeCachedFunction` abstraction is causing the
-    // return value of `readdir` to be incorrectly typed.
-    const files = (await cachedReaddir(fsCache, path));
+    const files = await cachedReaddir(cache.readdirCache, path);
     const mainFileName = [`${directoryName}.go`, 'main.go'].find((name) => files.includes(name));
     if (mainFileName === undefined) {
         return;
     }
     return mainFileName;
 };
-const findFunctionsInPaths = async function ({ featureFlags, fsCache, paths }) {
-    const functions = await Promise.all(paths.map((path) => findFunctionInPath({ featureFlags, fsCache, path })));
+const findFunctionsInPaths = async function ({ cache, featureFlags, paths }) {
+    const functions = await Promise.all(paths.map((path) => findFunctionInPath({ cache, featureFlags, path })));
     return functions.filter(nonNullable);
 };
-const findFunctionInPath = async function ({ fsCache, path }) {
-    const runtime = await detectBinaryRuntime({ fsCache, path });
+const findFunctionInPath = async function ({ cache, path }) {
+    const runtime = await detectBinaryRuntime({ path });
     if (runtime === "go" /* RuntimeType.GO */) {
-        return processBinary({ fsCache, path });
+        return processBinary({ cache, path });
     }
-    const goSourceFile = await detectGoFunction({ fsCache, path });
+    const goSourceFile = await detectGoFunction({ cache, path });
     if (goSourceFile) {
-        return processSource({ fsCache, mainFile: goSourceFile, path });
+        return processSource({ cache, mainFile: goSourceFile, path });
     }
 };
-const processBinary = async ({ fsCache, path }) => {
-    const stat = (await cachedLstat(fsCache, path));
+const processBinary = async ({ cache, path }) => {
+    const stat = await cachedLstat(cache.lstatCache, path);
     const extension = extname(path);
     const filename = basename(path);
     const name = basename(path, extname(path));
@@ -49,12 +47,12 @@ const processBinary = async ({ fsCache, path }) => {
         stat,
     };
 };
-const processSource = async ({ fsCache, mainFile, path, }) => {
+const processSource = async ({ cache, mainFile, path, }) => {
     // TODO: This `stat` value is not going to be used, but we need it to satisfy
     // the `FunctionSource` interface. We should revisit whether `stat` should be
     // part of that interface in the first place, or whether we could compute it
     // downstream when needed (maybe using the FS cache as an optimisation).
-    const stat = (await cachedLstat(fsCache, path));
+    const stat = (await cachedLstat(cache.lstatCache, path));
     const filename = basename(path);
     const extension = extname(mainFile);
     const name = basename(path, extname(path));

package/dist/runtimes/index.d.ts

@@ -1,11 +1,13 @@
 import { Config } from '../config.js';
 import { FeatureFlags } from '../feature_flags.js';
 import { FunctionSource } from '../function.js';
-declare type FunctionMap = Map<string, FunctionSource>;
+import type { RuntimeCache } from '../utils/cache.js';
+type FunctionMap = Map<string, FunctionSource>;
 /**
  * Gets a list of functions found in a list of paths.
  */
-export declare const getFunctionsFromPaths: (paths: string[], { config, configFileDirectories, dedupe, featureFlags, }?: {
+export declare const getFunctionsFromPaths: (paths: string[], { cache, config, configFileDirectories, dedupe, featureFlags, }: {
+    cache: RuntimeCache;
     config?: Config | undefined;
     configFileDirectories?: string[] | undefined;
     dedupe?: boolean | undefined;
@@ -14,7 +16,8 @@ export declare const getFunctionsFromPaths: (paths: string[], { config, configFi
 /**
  * Gets a list of functions found in a list of paths.
  */
-export declare const getFunctionFromPath: (path: string, { config, featureFlags }?: {
+export declare const getFunctionFromPath: (path: string, { cache, config, featureFlags }: {
+    cache: RuntimeCache;
     config?: Config | undefined;
     featureFlags?: FeatureFlags | undefined;
 }) => Promise<FunctionSource | undefined>;

package/dist/runtimes/index.js

@@ -10,8 +10,8 @@ import rustRuntime from './rust/index.js';
  * and an array with the paths that haven't been recognized by the runtime
  * (`remainingPaths`).
  */
-const findFunctionsInRuntime = async function ({ dedupe = false, featureFlags, fsCache, paths, runtime, }) {
-    const functions = await runtime.findFunctionsInPaths({ featureFlags, fsCache, paths });
+const findFunctionsInRuntime = async function ({ cache, dedupe = false, featureFlags, paths, runtime, }) {
+    const functions = await runtime.findFunctionsInPaths({ cache, featureFlags, paths });
     // If `dedupe` is true, we use the function name (`filename`) as the map key,
     // so that `function-1.js` will overwrite `function-1.go`. Otherwise, we use
     // `srcPath`, so that both functions are returned.
@@ -30,10 +30,6 @@ const findFunctionsInRuntime = async function ({ dedupe = false, featureFlags, f
     const remainingPaths = paths.filter((path) => !usedPaths.has(path));
     return { functions: augmentedFunctions, remainingPaths };
 };
-// An object to cache filesystem operations. This allows different functions
-// to perform IO operations on the same file (i.e. getting its stats or its
-// contents) without duplicating work.
-const makeFsCache = () => ({});
 // The order of this array determines the priority of the runtimes. If a path
 // is used by the first time, it won't be made available to the subsequent
 // runtimes.
@@ -41,8 +37,7 @@ const RUNTIMES = [jsRuntime, goRuntime, rustRuntime];
 /**
  * Gets a list of functions found in a list of paths.
  */
-export const getFunctionsFromPaths = async (paths, { config, configFileDirectories = [], dedupe = false, featureFlags = defaultFlags, } = {}) => {
-    const fsCache = makeFsCache();
+export const getFunctionsFromPaths = async (paths, { cache, config, configFileDirectories = [], dedupe = false, featureFlags = defaultFlags, }) => {
     // We cycle through the ordered array of runtimes, passing each one of them
     // through `findFunctionsInRuntime`. For each iteration, we collect all the
     // functions found plus the list of paths that still need to be evaluated,
@@ -50,9 +45,9 @@ export const getFunctionsFromPaths = async (paths, { config, configFileDirectori
     const { functions } = await RUNTIMES.reduce(async (aggregate, runtime) => {
         const { functions: aggregateFunctions, remainingPaths: aggregatePaths } = await aggregate;
         const { functions: runtimeFunctions, remainingPaths: runtimePaths } = await findFunctionsInRuntime({
+            cache,
             dedupe,
             featureFlags,
-            fsCache,
             paths: aggregatePaths,
             runtime,
         });
@@ -71,10 +66,9 @@ export const getFunctionsFromPaths = async (paths, { config, configFileDirectori
 /**
  * Gets a list of functions found in a list of paths.
  */
-export const getFunctionFromPath = async (path, { config, featureFlags = defaultFlags } = {}) => {
-    const fsCache = makeFsCache();
+export const getFunctionFromPath = async (path, { cache, config, featureFlags = defaultFlags }) => {
     for (const runtime of RUNTIMES) {
-        const func = await runtime.findFunctionInPath({ path, fsCache, featureFlags });
+        const func = await runtime.findFunctionInPath({ path, cache, featureFlags });
         if (func) {
             const functionConfig = await getConfigForFunction({ config, func: { ...func, runtime }, featureFlags });
             return {

package/dist/runtimes/node/bundlers/esbuild/bundler.js

@@ -59,8 +59,19 @@ export const bundleJsFile = async function ({ additionalModulePaths, basePath, c
     const extension = getFileExtensionForFormat(moduleFormat, featureFlags);
     // When outputting an ESM file, configure esbuild to produce a `.mjs` file.
     const outExtension = moduleFormat === "esm" /* ModuleFormat.ESM */ ? { [".js" /* ModuleFileExtension.JS */]: ".mjs" /* ModuleFileExtension.MJS */ } : undefined;
+    // We add this banner so that calls to require() still work in ESM modules, especially when importing node built-ins
+    // We have to do this until this is fixed in esbuild: https://github.com/evanw/esbuild/pull/2067
+    const esmJSBanner = `
+    import {createRequire as ___nfyCreateRequire} from "module";
+    import {fileURLToPath as ___nfyFileURLToPath} from "url";
+    import {dirname as ___nfyPathDirname} from "path";
+    let __filename=___nfyFileURLToPath(import.meta.url);
+    let __dirname=___nfyPathDirname(___nfyFileURLToPath(import.meta.url));
+    let require=___nfyCreateRequire(import.meta.url);
+  `;
     try {
         const { metafile = { inputs: {}, outputs: {} }, warnings } = await build({
+            banner: moduleFormat === "esm" /* ModuleFormat.ESM */ && featureFlags.zisi_esbuild_require_banner ? { js: esmJSBanner } : undefined,
             bundle: true,
             entryPoints: [srcFile],
             external,

package/dist/runtimes/node/bundlers/esbuild/bundler_target.d.ts

@@ -7,8 +7,9 @@ declare const versionMap: {
     readonly '12.x': "node12";
     readonly '14.x': "node14";
     readonly '16.x': "node16";
+    readonly '18.x': "node18";
 };
-declare type VersionValues = typeof versionMap[keyof typeof versionMap];
+type VersionValues = typeof versionMap[keyof typeof versionMap];
 declare const getBundlerTarget: (suppliedVersion?: NodeVersionString) => VersionValues;
 declare const getModuleFormat: (srcDir: string, featureFlags: FeatureFlags, extension: string, configVersion?: string) => Promise<{
     includedFiles: string[];

package/dist/runtimes/node/bundlers/esbuild/bundler_target.js

@@ -6,6 +6,7 @@ const versionMap = {
     '12.x': 'node12',
     '14.x': 'node14',
     '16.x': 'node16',
+    '18.x': 'node18',
 };
 const getBundlerTarget = (suppliedVersion) => {
     const version = normalizeVersion(suppliedVersion);

package/dist/runtimes/node/bundlers/esbuild/plugin_dynamic_imports.js

@@ -1,8 +1,8 @@
 import { basename, join, relative } from 'path';
-import findUp from 'find-up';
+import { findUp, findUpStop, pathExists } from 'find-up';
 import normalizePath from 'normalize-path';
-import readPackageJson from 'read-package-json-fast';
 import { parseExpression } from '../../parser/index.js';
+import { readPackageJson } from '../../utils/package_json.js';
 // This plugin intercepts module imports using dynamic expressions and does a
 // couple of things with them. First of all, it figures out whether the call
 // is being made from within a Node module, and if so it adds the name of the
@@ -49,10 +49,10 @@ const getPackageName = async ({ resolveDir, srcDir }) => {
         // We stop traversing if we're about to leave the boundaries of the
         // function directory or any node_modules directory.
         if (directory === srcDir || basename(directory) === 'node_modules') {
-            return findUp.stop;
+            return findUpStop;
         }
         const path = join(directory, 'package.json');
-        const hasPackageJson = await findUp.exists(path);
+        const hasPackageJson = await pathExists(path);
         return hasPackageJson ? path : undefined;
     }, { cwd: resolveDir });
     if (packageJsonPath !== undefined) {
@@ -61,10 +61,12 @@ const getPackageName = async ({ resolveDir, srcDir }) => {
     }
 };
 const getPackageNameCached = ({ cache, resolveDir, srcDir, }) => {
-    if (!cache.has(resolveDir)) {
-        cache.set(resolveDir, getPackageName({ resolveDir, srcDir }));
+    let result = cache.get(resolveDir);
+    if (result === undefined) {
+        result = getPackageName({ resolveDir, srcDir });
+        cache.set(resolveDir, result);
     }
-    return cache.get(resolveDir);
+    return result;
 };
 const getShimContents = ({ expressionType, resolveDir, srcDir, }) => {
     // The shim needs to modify the path of the import, since originally it was

package/dist/runtimes/node/bundlers/esbuild/plugin_native_modules.js

@@ -1,6 +1,6 @@
 import path from 'path';
-import readPackageJson from 'read-package-json-fast';
 import { isNativeModule } from '../../utils/detect_native_module.js';
+import { readPackageJson } from '../../utils/package_json.js';
 // Filters out relative or absolute file paths.
 const packageFilter = /^([^./]*)$/;
 // Filters valid package names and extracts the base directory.

package/dist/runtimes/node/bundlers/esbuild/src_files.js

@@ -6,8 +6,8 @@ export const getSrcFiles = async ({ config, mainFile, pluginsModulesPath, srcDir
     const { externalNodeModules = [], includedFiles = [], includedFilesBasePath } = config;
     const { excludePatterns, paths: includedFilePaths } = await getPathsOfIncludedFiles(includedFiles, includedFilesBasePath);
     const dependencyPaths = await getSrcFilesForDependencies({
-        dependencies: externalNodeModules,
         basedir: srcDir,
+        dependencies: externalNodeModules,
         pluginsModulesPath,
     });
     const srcFiles = filterExcludedPaths(dependencyPaths, excludePatterns);
@@ -17,7 +17,7 @@ export const getSrcFiles = async ({ config, mainFile, pluginsModulesPath, srcDir
         includedFiles: includedPaths,
     };
 };
-const getSrcFilesForDependencies = async function ({ dependencies: dependencyNames, basedir, state = getNewCache(), pluginsModulesPath, }) {
+const getSrcFilesForDependencies = async function ({ basedir, dependencies: dependencyNames, state = getNewCache(), pluginsModulesPath, }) {
     if (dependencyNames.length === 0) {
         return [];
     }

package/dist/runtimes/node/bundlers/nft/es_modules.d.ts

@@ -1,14 +1,14 @@
 import { NodeFileTraceReasons } from '@vercel/nft';
 import type { FunctionConfig } from '../../../../config.js';
 import { FeatureFlags } from '../../../../feature_flags.js';
-import { FsCache } from '../../../../utils/fs.js';
+import type { RuntimeCache } from '../../../../utils/cache.js';
 import { ModuleFormat } from '../../utils/module_format.js';
-export declare const processESM: ({ basePath, config, esmPaths, featureFlags, fsCache, mainFile, reasons, name, }: {
+export declare const processESM: ({ basePath, cache, config, esmPaths, featureFlags, mainFile, reasons, name, }: {
     basePath: string | undefined;
+    cache: RuntimeCache;
     config: FunctionConfig;
     esmPaths: Set<string>;
     featureFlags: FeatureFlags;
-    fsCache: FsCache;
     mainFile: string;
     reasons: NodeFileTraceReasons;
     name: string;

package/dist/runtimes/node/bundlers/nft/es_modules.js

@@ -3,8 +3,8 @@ import { cachedReadFile } from '../../../../utils/fs.js';
 import { getNodeSupportMatrix } from '../../utils/node_version.js';
 import { getPackageJsonIfAvailable } from '../../utils/package_json.js';
 import { transpile } from './transpile.js';
-const getPatchedESMPackages = async (packages, fsCache) => {
-    const patchedPackages = await Promise.all(packages.map((path) => patchESMPackage(path, fsCache)));
+const getPatchedESMPackages = async (packages, cache) => {
+    const patchedPackages = await Promise.all(packages.map((path) => patchESMPackage(path, cache)));
     const patchedPackagesMap = new Map();
     packages.forEach((packagePath, index) => {
         patchedPackagesMap.set(packagePath, patchedPackages[index]);
@@ -16,8 +16,8 @@ const isEntrypointESM = ({ basePath, esmPaths, mainFile, }) => {
     const entrypointIsESM = absoluteESMPaths.has(mainFile);
     return entrypointIsESM;
 };
-const patchESMPackage = async (path, fsCache) => {
-    const file = (await cachedReadFile(fsCache, path, 'utf8'));
+const patchESMPackage = async (path, cache) => {
+    const file = await cachedReadFile(cache.fileCache, path);
     const packageJson = JSON.parse(file);
     const patchedPackageJson = {
         ...packageJson,
@@ -25,7 +25,7 @@ const patchESMPackage = async (path, fsCache) => {
     };
     return JSON.stringify(patchedPackageJson);
 };
-export const processESM = async ({ basePath, config, esmPaths, featureFlags, fsCache, mainFile, reasons, name, }) => {
+export const processESM = async ({ basePath, cache, config, esmPaths, featureFlags, mainFile, reasons, name, }) => {
     const extension = extname(mainFile);
     // If this is a .mjs file and we want to output pure ESM files, we don't need
     // to transpile anything.
@@ -47,7 +47,7 @@ export const processESM = async ({ basePath, config, esmPaths, featureFlags, fsC
             moduleFormat: "esm" /* ModuleFormat.ESM */,
         };
     }
-    const rewrites = await transpileESM({ basePath, config, esmPaths, fsCache, reasons, name });
+    const rewrites = await transpileESM({ basePath, cache, config, esmPaths, reasons, name });
     return {
         moduleFormat: "cjs" /* ModuleFormat.COMMONJS */,
         rewrites,
@@ -79,9 +79,10 @@ const shouldTranspile = (path, cache, esmPaths, reasons) => {
     cache.set(path, shouldTranspilePath);
     return shouldTranspilePath;
 };
-const transpileESM = async ({ basePath, config, esmPaths, fsCache, reasons, name, }) => {
-    const cache = new Map();
-    const pathsToTranspile = [...esmPaths].filter((path) => shouldTranspile(path, cache, esmPaths, reasons));
+const transpileESM = async ({ basePath, cache, config, esmPaths, reasons, name, }) => {
+    // Used for memoizing the check for whether a path should be transpiled.
+    const shouldCompileCache = new Map();
+    const pathsToTranspile = [...esmPaths].filter((path) => shouldTranspile(path, shouldCompileCache, esmPaths, reasons));
     const pathsToTranspileSet = new Set(pathsToTranspile);
     const packageJsonPaths = [...reasons.entries()]
         .filter(([path, reason]) => {
@@ -92,7 +93,7 @@ const transpileESM = async ({ basePath, config, esmPaths, fsCache, reasons, name
         return needsPatch;
     })
         .map(([path]) => (basePath ? resolve(basePath, path) : resolve(path)));
-    const rewrites = await getPatchedESMPackages(packageJsonPaths, fsCache);
+    const rewrites = await getPatchedESMPackages(packageJsonPaths, cache);
     await Promise.all(pathsToTranspile.map(async (path) => {
         const absolutePath = resolvePath(path, basePath);
         const transpiled = await transpile(absolutePath, config, name);

package/dist/runtimes/node/bundlers/nft/index.js

@@ -1,23 +1,20 @@
 import { basename, dirname, join, normalize, resolve } from 'path';
 import { nodeFileTrace } from '@vercel/nft';
-import nftResolveDependency from '@vercel/nft/out/resolve-dependency.js';
+import resolveDependency from '@vercel/nft/out/resolve-dependency.js';
 import { cachedReadFile } from '../../../../utils/fs.js';
 import { minimatch } from '../../../../utils/matching.js';
 import { getBasePath } from '../../utils/base_path.js';
 import { filterExcludedPaths, getPathsOfIncludedFiles } from '../../utils/included_files.js';
 import { processESM } from './es_modules.js';
-// @ts-expect-error vitest with esbuild already resolves the default export, whereas Node.js does not
-const resolveDependency = nftResolveDependency.default
-    ? nftResolveDependency.default
-    : nftResolveDependency;
 // Paths that will be excluded from the tracing process.
 const ignore = ['node_modules/aws-sdk/**'];
 const appearsToBeModuleName = (name) => !name.startsWith('.');
-const bundle = async ({ basePath, config, featureFlags, mainFile, name, pluginsModulesPath, repositoryRoot = basePath, }) => {
+const bundle = async ({ basePath, cache, config, featureFlags, mainFile, name, pluginsModulesPath, repositoryRoot = basePath, }) => {
     const { includedFiles = [], includedFilesBasePath } = config;
     const { excludePatterns, paths: includedFilePaths } = await getPathsOfIncludedFiles(includedFiles, includedFilesBasePath || basePath);
     const { moduleFormat, paths: dependencyPaths, rewrites, } = await traceFilesAndTranspile({
         basePath: repositoryRoot,
+        cache,
         config,
         featureFlags,
         mainFile,
@@ -43,14 +40,16 @@ const ignoreFunction = (path) => {
     const shouldIgnore = ignore.some((expression) => minimatch(path, expression));
     return shouldIgnore;
 };
-const traceFilesAndTranspile = async function ({ basePath, config, featureFlags, mainFile, pluginsModulesPath, name, }) {
-    const fsCache = {};
+const traceFilesAndTranspile = async function ({ basePath, cache, config, featureFlags, mainFile, pluginsModulesPath, name, }) {
     const { fileList: dependencyPaths, esmFileList, reasons, } = await nodeFileTrace([mainFile], {
+        // Default is 1024. Allowing double the fileIO in parallel makes nft faster, but uses a little more memory.
+        fileIOConcurrency: featureFlags.zisi_nft_higher_fileio_limit ? 2048 : 1024,
         base: basePath,
+        cache: featureFlags.zisi_nft_use_cache ? cache.nftCache : undefined,
         ignore: ignoreFunction,
         readFile: async (path) => {
             try {
-                const source = (await cachedReadFile(fsCache, path, 'utf8'));
+                const source = await cachedReadFile(cache.fileCache, path);
                 return source;
             }
             catch (error) {
@@ -62,7 +61,7 @@ const traceFilesAndTranspile = async function ({ basePath, config, featureFlags,
         },
         resolve: async (specifier, parent, ...args) => {
             try {
-                return await resolveDependency(specifier, parent, ...args);
+                return await resolveDependency.default(specifier, parent, ...args);
             }
             catch (error) {
                 // If we get a `MODULE_NOT_FOUND` error for what appears to be a module
@@ -70,7 +69,7 @@ const traceFilesAndTranspile = async function ({ basePath, config, featureFlags,
                 // as the base directory.
                 if (error.code === 'MODULE_NOT_FOUND' && pluginsModulesPath && appearsToBeModuleName(specifier)) {
                     const newParent = join(pluginsModulesPath, basename(parent));
-                    return await resolveDependency(specifier, newParent, ...args);
+                    return await resolveDependency.default(specifier, newParent, ...args);
                 }
                 throw error;
             }
@@ -79,10 +78,10 @@ const traceFilesAndTranspile = async function ({ basePath, config, featureFlags,
     const normalizedDependencyPaths = [...dependencyPaths].map((path) => basePath ? resolve(basePath, path) : resolve(path));
     const { moduleFormat, rewrites } = await processESM({
         basePath,
+        cache,
         config,
         esmPaths: esmFileList,
         featureFlags,
-        fsCache,
         mainFile,
         reasons,
         name,

package/dist/runtimes/node/bundlers/types.d.ts

@@ -2,6 +2,7 @@ import type { Message } from '@netlify/esbuild';
 import type { FunctionConfig } from '../../../config.js';
 import type { FeatureFlag, FeatureFlags } from '../../../feature_flags.js';
 import type { FunctionSource } from '../../../function.js';
+import type { RuntimeCache } from '../../../utils/cache.js';
 import type { ModuleFormat } from '../utils/module_format.js';
 export declare const enum NodeBundlerType {
     ESBUILD = "esbuild",
@@ -10,11 +11,12 @@ export declare const enum NodeBundlerType {
     ZISI = "zisi",
     NONE = "none"
 }
-declare type BundlerWarning = Message;
-declare type CleanupFunction = () => Promise<void>;
-export declare type NativeNodeModules = Record<string, Record<string, string | undefined>>;
-export declare type BundleFunction = (args: {
+type BundlerWarning = Message;
+type CleanupFunction = () => Promise<void>;
+export type NativeNodeModules = Record<string, Record<string, string | undefined>>;
+export type BundleFunction = (args: {
     basePath?: string;
+    cache: RuntimeCache;
     config: FunctionConfig;
     featureFlags: Record<FeatureFlag, boolean>;
     pluginsModulesPath?: string;
@@ -33,7 +35,7 @@ export declare type BundleFunction = (args: {
     nodeModulesWithDynamicImports?: string[];
     srcFiles: string[];
 }>;
-export declare type GetSrcFilesFunction = (args: {
+export type GetSrcFilesFunction = (args: {
     basePath?: string;
     config: FunctionConfig;
     featureFlags: FeatureFlags;

package/dist/runtimes/node/bundlers/zisi/list_imports.d.ts

@@ -1,4 +1,6 @@
-export declare const listImports: ({ functionName, path, }: {
+import { FeatureFlags } from '../../../../feature_flags.js';
+export declare const listImports: ({ featureFlags, ...args }: {
+    featureFlags: FeatureFlags;
     functionName: string;
     path: string;
 }) => Promise<string[]>;