@netlify/zip-it-and-ship-it 16.1.0 → 16.2.1

package/dist/main.d.ts

@@ -5,8 +5,9 @@ import { ModuleFormat } from './runtimes/node/utils/module_format.js';
 import { RuntimeName } from './runtimes/runtime.js';
 import type { ExtendedRoute, Route } from './utils/routes.js';
 export { Config, FunctionConfig } from './config.js';
-export { bundle, zipFunction, zipFunctions, ZipFunctionOptions, ZipFunctionsOptions } from './zip.js';
-export type { BundleOptions, BundleResult, FunctionsOptions, ServerOptions, ServerResult } from './zip.js';
+export { zipFunction, zipFunctions, zipServer, ZipFunctionOptions, ZipFunctionsOptions } from './zip.js';
+export type { ServerOptions, ServerResult, ZipServerOptions } from './zip.js';
+export { findServerEntry } from './server.js';
 export type { FunctionsBag, MixedPaths } from './paths.js';
 export { ArchiveFormat, ARCHIVE_FORMAT } from './archive.js';
 export type { TrafficRules } from './rate_limit.js';
@@ -14,7 +15,7 @@ export type { ExtendedRoute, Route } from './utils/routes.js';
 export { NodeBundlerName, NODE_BUNDLER } from './runtimes/node/bundlers/types.js';
 export { RuntimeName, RUNTIME } from './runtimes/runtime.js';
 export { ModuleFormat, MODULE_FORMAT } from './runtimes/node/utils/module_format.js';
-export { Manifest } from './manifest.js';
+export type { FunctionsManifest, Manifest, ServerManifest } from './manifest.js';
 export { FunctionResult } from './utils/format_result.js';
 export interface ListedFunction {
     name: string;

package/dist/main.js

@@ -6,7 +6,8 @@ import { parseFile } from './runtimes/node/in_source_config/index.js';
 import { RUNTIME } from './runtimes/runtime.js';
 import { RuntimeCache } from './utils/cache.js';
 import { listFunctionsDirectories, resolveFunctionsDirectories } from './utils/fs.js';
-export { bundle, zipFunction, zipFunctions } from './zip.js';
+export { zipFunction, zipFunctions, zipServer } from './zip.js';
+export { findServerEntry } from './server.js';
 export { ARCHIVE_FORMAT } from './archive.js';
 export { NODE_BUNDLER } from './runtimes/node/bundlers/types.js';
 export { RUNTIME } from './runtimes/runtime.js';

package/dist/manifest.d.ts

@@ -37,9 +37,7 @@ interface ManifestServer {
     runtimeVersion?: string;
     vcpu?: number;
 }
-export interface Manifest {
-    functions: ManifestFunction[];
-    server?: ManifestServer;
+interface ManifestBase {
     system: {
         arch: string;
         platform: string;
@@ -47,9 +45,29 @@ export interface Manifest {
     timestamp: number;
     version: number;
 }
-export declare const createManifest: ({ functions, path, server, }: {
+export interface FunctionsManifest extends ManifestBase {
+    functions: ManifestFunction[];
+    /**
+     * A server is described by its own manifest now. Nothing writes this any
+     * more; it is kept so that readers of manifests written before the split
+     * still compile.
+     */
+    server?: ManifestServer;
+}
+export interface ServerManifest extends ManifestBase {
+    server: ManifestServer;
+}
+/**
+ * The functions manifest, under the name it had before the server manifest was
+ * introduced, for backwards compatibility.
+ */
+export type Manifest = FunctionsManifest;
+export declare const createFunctionsManifest: ({ functions, path }: {
     functions: FunctionResult[];
     path: string;
-    server?: ServerResult;
+}) => Promise<void>;
+export declare const createServerManifest: ({ path, server }: {
+    path: string;
+    server: ServerResult;
 }) => Promise<void>;
 export {};

package/dist/manifest.js

@@ -2,10 +2,19 @@ import { promises as fs } from 'fs';
 import { resolve } from 'path';
 import { arch, platform } from 'process';
 const MANIFEST_VERSION = 1;
-export const createManifest = async ({ functions, path, server, }) => {
+export const createFunctionsManifest = async ({ functions, path }) => {
+    const formattedFunctions = functions.map((func) => formatFunctionForManifest(func));
     const payload = {
-        functions: functions.map((func) => formatFunctionForManifest(func)),
-        server: server && formatServerForManifest(server),
+        functions: formattedFunctions,
+        system: { arch, platform },
+        timestamp: Date.now(),
+        version: MANIFEST_VERSION,
+    };
+    await fs.writeFile(path, JSON.stringify(payload));
+};
+export const createServerManifest = async ({ path, server }) => {
+    const payload = {
+        server: formatServerForManifest(server),
         system: { arch, platform },
         timestamp: Date.now(),
         version: MANIFEST_VERSION,

package/dist/runtimes/node/utils/zip.d.ts

@@ -1,3 +1,4 @@
+import { Stats } from 'fs';
 import { ArchiveFormat } from '../../../archive.js';
 import type { FeatureFlags } from '../../../feature_flags.js';
 import type { RuntimeCache } from '../../../utils/cache.js';
@@ -29,4 +30,13 @@ interface ZipNodeJsResult {
 export declare const zipNodeJs: ({ archiveFormat, ...options }: ZipNodeParameters & {
     archiveFormat: ArchiveFormat;
 }) => Promise<ZipNodeJsResult>;
+interface ArchiveEntry {
+    destPath: string;
+    srcFile: string;
+    stat: Stats;
+}
+export declare const resolveSymlinkedDestPaths: <T extends ArchiveEntry>(files: T[], { readTarget, rewrites, }?: {
+    readTarget?: (srcFile: string) => Promise<string>;
+    rewrites?: Map<string, string>;
+}) => Promise<T[]>;
 export {};

package/dist/runtimes/node/utils/zip.js

@@ -1,7 +1,7 @@
 import { Buffer } from 'buffer';
 import { mkdir, readlink as readLink, rm, symlink, writeFile } from 'fs/promises';
 import os from 'os';
-import { basename, dirname, extname, join } from 'path';
+import { basename, dirname, extname, isAbsolute, join, posix } from 'path';
 import { getPath as getV2APIPath } from '@netlify/serverless-functions-api';
 import { copyFile } from 'copy-file';
 import pMap from 'p-map';
@@ -66,19 +66,17 @@ const createDirectory = async function ({ aliases = new Map(), basePath, cache,
         addBootstrapFile(srcFiles, aliases);
     }
     const symlinks = new Map();
+    const statted = await Promise.all([...new Set(srcFiles)].map(async (srcFile) => ({
+        srcFile,
+        stat: await cachedLstat(cache.lstatCache, srcFile),
+        destPath: normalizeFilePath({ commonPrefix: basePath, path: aliases.get(srcFile) || srcFile, userNamespace }),
+    })));
     // Copying source files.
-    await pMap(srcFiles, async (srcFile) => {
-        const destPath = aliases.get(srcFile) || srcFile;
-        const normalizedDestPath = normalizeFilePath({
-            commonPrefix: basePath,
-            path: destPath,
-            userNamespace,
-        });
-        const absoluteDestPath = join(functionFolder, normalizedDestPath);
+    await pMap(await resolveSymlinkedDestPaths(statted, { rewrites }), async ({ srcFile, stat, destPath }) => {
+        const absoluteDestPath = join(functionFolder, destPath);
         if (rewrites.has(srcFile)) {
             return mkdirAndWriteFile(absoluteDestPath, rewrites.get(srcFile));
         }
-        const stat = await cachedLstat(cache.lstatCache, srcFile);
         // If the path is a symlink, find the link target and add the link to a
         // `symlinks` map, which we'll later use to create the symlinks in the
         // target directory. We can't do that right now because the target path
@@ -157,18 +155,15 @@ const createZipArchive = async function ({ aliases = new Map(), basePath, branch
     }
     const deduplicatedSrcFiles = [...new Set(srcFiles)];
     const srcFilesInfos = await Promise.all(deduplicatedSrcFiles.map((file) => addStat(cache, file)));
+    const entries = await resolveSymlinkedDestPaths(srcFilesInfos.map(({ srcFile, stat }) => ({
+        srcFile,
+        stat,
+        destPath: normalizeFilePath({ commonPrefix: basePath, path: aliases.get(srcFile) || srcFile, userNamespace }),
+    })), { rewrites });
     // We ensure this is not async, so that the archive's checksum is
     // deterministic. Otherwise it depends on the order the files were added.
-    srcFilesInfos.forEach(({ srcFile, stat }) => {
-        zipJsFile({
-            aliases,
-            archive,
-            commonPrefix: basePath,
-            rewrites,
-            srcFile,
-            stat,
-            userNamespace,
-        });
+    entries.forEach(({ srcFile, stat, destPath }) => {
+        zipJsFile({ archive, destPath, rewrites, srcFile, stat });
     });
     await endZip(archive, output);
     return { path: destPath, entryFilename, bootstrapVersion };
@@ -183,17 +178,85 @@ const addEntryFileToZip = function (archive, { contents, filename }) {
     const contentBuffer = Buffer.from(contents);
     addZipContent(archive, contentBuffer, filename);
 };
+// A tracer that resolves a module through a symlinked directory reports the path
+// it walked, not where the files really live. The archive then holds a link at
+// `node_modules/<pkg>` *and* files under that same path, which cannot both exist
+// once extracted — AWS Lambda rejects the whole bundle for it.
+//
+// Put those entries back on the path the link points at, which is the layout the
+// package manager produced in the first place: files in the store, `node_modules
+// /<pkg>` a link to them. Resolution then works the way it does locally.
+//
+// A link the archive cannot contain — absolute, or reaching above the bundle
+// root — is left alone; rewriting onto it would move entries out of the bundle.
+export const resolveSymlinkedDestPaths = async function (files, { readTarget = readLink, rewrites = new Map(), } = {}) {
+    const links = files.filter(({ stat }) => stat.isSymbolicLink());
+    if (links.length === 0) {
+        return files;
+    }
+    // Resolve in parallel, but record in `links` order: keying off whichever
+    // readlink finished first would make the output depend on IO timing, and the
+    // archive checksum has to be reproducible.
+    const targets = await Promise.all(links.map(({ srcFile }) => readTarget(srcFile)));
+    const realPaths = new Map();
+    links.forEach(({ destPath }, index) => {
+        const target = targets[index];
+        if (isAbsolute(target)) {
+            return;
+        }
+        const realPath = posix.normalize(posix.join(posix.dirname(destPath), target));
+        if (realPath.startsWith('..')) {
+            return;
+        }
+        realPaths.set(destPath, realPath);
+    });
+    if (realPaths.size === 0) {
+        return files;
+    }
+    // Longest first, so a link nested inside another wins over its parent.
+    const candidates = [...realPaths.entries()].sort(([a], [b]) => b.length - a.length);
+    // One rewrite can land under another link, so keep going until the path sits
+    // below none of them. Links that point at each other would otherwise spin
+    // here, so stop as soon as a path repeats.
+    const resolveDestPath = (destPath) => {
+        const visited = new Set([destPath]);
+        let current = destPath;
+        for (;;) {
+            const match = candidates.find(([link]) => current.startsWith(`${link}/`));
+            if (match === undefined) {
+                return current;
+            }
+            const next = match[1] + current.slice(match[0].length);
+            if (visited.has(next)) {
+                return current;
+            }
+            visited.add(next);
+            current = next;
+        }
+    };
+    const byDestPath = new Map();
+    for (const file of files) {
+        const destPath = resolveDestPath(file.destPath);
+        const resolved = destPath === file.destPath ? file : { ...file, destPath };
+        const existing = byDestPath.get(resolved.destPath);
+        // Two spellings of one package can now collapse onto a single path. Keep
+        // the entry whose contents were rewritten — nft patches package.json files
+        // into `rewrites`, and the unpatched twin would ship the wrong manifest.
+        if (existing === undefined || (!rewrites.has(existing.srcFile) && rewrites.has(resolved.srcFile))) {
+            byDestPath.set(resolved.destPath, resolved);
+        }
+    }
+    return [...byDestPath.values()];
+};
 const addStat = async function (cache, srcFile) {
     const stat = await cachedLstat(cache.lstatCache, srcFile);
     return { srcFile, stat };
 };
-const zipJsFile = function ({ aliases = new Map(), archive, commonPrefix, rewrites = new Map(), stat, srcFile, userNamespace, }) {
-    const destPath = aliases.get(srcFile) || srcFile;
-    const normalizedDestPath = normalizeFilePath({ commonPrefix, path: destPath, userNamespace });
+const zipJsFile = function ({ archive, destPath, rewrites = new Map(), stat, srcFile, }) {
     if (rewrites.has(srcFile)) {
-        addZipContent(archive, rewrites.get(srcFile), normalizedDestPath);
+        addZipContent(archive, rewrites.get(srcFile), destPath);
     }
     else {
-        addZipFile(archive, srcFile, normalizedDestPath, stat);
+        addZipFile(archive, srcFile, destPath, stat);
     }
 };

package/dist/server.d.ts

@@ -1,13 +1,13 @@
 import type { FeatureFlags } from './feature_flags.js';
-import type { RuntimeName } from './runtimes/runtime.js';
+import { type RuntimeName } from './runtimes/runtime.js';
 import type { RuntimeCache } from './utils/cache.js';
 import type { getLogger } from './utils/logger.js';
 import type { ExtendedRoute, Route } from './utils/routes.js';
 /**
- * A bundled Netlify Server. It is built like a function, but it is described on
- * its own terms: it carries no schedule, event subscriptions, invocation mode,
- * priority or timeout, because it is not invoked per request.
+ * Resolves the server entrypoint inside `directory`, or undefined when there is
+ * none.
  */
+export declare const findServerEntry: (directory: string) => Promise<string | undefined>;
 export type ServerResult = {
     bundler?: string;
     excludedRoutes?: Route[];
@@ -22,8 +22,7 @@ export type ServerResult = {
     vcpu?: number;
 };
 /**
- * The deploy's Netlify Server, and how to bundle it. Set by whatever generates
- * the server, not by the user.
+ * The deploy's Netlify Server, and how to bundle it.
  */
 export interface ServerOptions {
     /**

package/dist/server.js

@@ -1,42 +1,72 @@
 import { promises as fs } from 'fs';
 import { extname, join, resolve } from 'path';
 import { ARCHIVE_FORMAT } from './archive.js';
+import { NODE_BUNDLER } from './runtimes/node/bundlers/types.js';
 import { getFunctionFromPath } from './runtimes/index.js';
+import { RUNTIME } from './runtimes/runtime.js';
+import { FunctionBundlingUserError } from './utils/error.js';
 import { formatZipResult } from './utils/format_result.js';
 import { removeUndefined } from './utils/remove_undefined.js';
 import { getRoutes } from './utils/routes.js';
 // A server claims every path the rest of the deploy does not.
 const SERVER_ROUTE = '/*';
-// Names the server's output folder and its archive.
+// Names the server's archive. Everywhere else it is only a label, identifying
+// the server in bundling errors, since a server has no name of its own.
 const SERVER_NAME = 'server';
-// A server that cannot be read leaves the deploy with no backend at all, so it
-// fails the build rather than coming up empty.
+const SERVER_ENTRY_BASENAMES = new Set(['index.js', 'index.mjs', 'index.ts', 'index.mts']);
+/**
+ * Resolves the server entrypoint inside `directory`, or undefined when there is
+ * none.
+ */
+export const findServerEntry = async (directory) => {
+    let entries;
+    try {
+        entries = await fs.readdir(directory);
+    }
+    catch (error) {
+        const { code } = error;
+        if (code === 'ENOENT' || code === 'ENOTDIR') {
+            return undefined;
+        }
+        throw error;
+    }
+    const candidates = entries.filter((name) => SERVER_ENTRY_BASENAMES.has(name)).sort();
+    if (candidates.length === 0) {
+        return undefined;
+    }
+    if (candidates.length > 1) {
+        throw new Error(`Found multiple server entrypoints in ${directory} (${candidates.join(', ')}). A site can have one server only.`);
+    }
+    return join(directory, candidates[0]);
+};
 const readServerSource = async (srcPath, { cache, featureFlags }) => {
     let source;
+    // A server that cannot be read is the user's file being wrong, so it is
+    // reported as a bundling failure rather than an internal error.
+    const unreadable = (detail) => new FunctionBundlingUserError(`Could not read the Netlify Server at ${srcPath}${detail ? `: ${detail}` : ''}`, {
+        functionName: SERVER_NAME,
+        runtime: RUNTIME.JAVASCRIPT,
+    });
     try {
         source = await getFunctionFromPath(srcPath, { cache, featureFlags });
     }
     catch (error) {
-        throw new Error(`Could not read the Netlify Server at ${srcPath}: ${error.message}`);
+        throw unreadable(error.message);
     }
     if (source === undefined) {
-        throw new Error(`Could not read the Netlify Server at ${srcPath}`);
+        throw unreadable();
     }
     return source;
 };
-// Bundles a Netlify Server through the same runtime as a function, into its own
-// folder so its archive does not land among theirs.
 export const bundleServer = async (server, destFolder, { basePath, cache, featureFlags, logger, repositoryRoot, }) => {
     const srcPath = resolve(server.path);
     const source = await readServerSource(srcPath, { cache, featureFlags });
-    const serverFolder = join(destFolder, SERVER_NAME);
-    await fs.mkdir(serverFolder, { recursive: true });
     const zipResult = await source.runtime.zipFunction({
         archiveFormat: ARCHIVE_FORMAT.ZIP,
         basePath,
         cache,
-        config: source.config,
-        destFolder: serverFolder,
+        config: { ...source.config, nodeBundler: NODE_BUNDLER.NFT },
+        destFolder,
         extension: source.extension,
         featureFlags,
         filename: source.filename,
@@ -51,7 +81,7 @@ export const bundleServer = async (server, destFolder, { basePath, cache, featur
         srcPath,
         stat: source.stat,
     });
-    const path = join(serverFolder, `${SERVER_NAME}${extname(zipResult.path)}`);
+    const path = join(destFolder, `${SERVER_NAME}${extname(zipResult.path)}`);
     await fs.rename(zipResult.path, path);
     const result = formatZipResult({
         ...zipResult,

package/dist/zip.d.ts

@@ -17,53 +17,23 @@ export interface ZipFunctionOptions {
     debug?: boolean;
     internalSrcFolder?: string;
 }
-export interface BundleResult {
-    /**
-     * The bundled functions. A server is never among them.
-     */
-    functions: FunctionResult[];
-    /**
-     * The bundled Netlify Server, when one was given.
-     */
-    server?: ServerResult;
-}
 export type ZipFunctionsOptions = ZipFunctionOptions & {
     configFileDirectories?: string[];
     manifest?: string;
     parallelLimit?: number;
 };
-/**
- * The deploy's functions, and how to bundle them.
- */
-export interface FunctionsOptions {
-    /**
-     * Directories to search, specific function paths, or both.
-     */
-    paths: MixedPaths;
-    archiveFormat?: ArchiveFormat;
-    config?: Config;
-    configFileDirectories?: string[];
-    parallelLimit?: number;
-}
-export type { ServerOptions, ServerResult };
-export interface BundleOptions {
-    /**
-     * Where the archives and the manifest are written.
-     */
-    destFolder: string;
-    functions?: FunctionsOptions;
-    server?: ServerOptions;
+export interface ZipServerOptions {
+    basePath?: string;
+    debug?: boolean;
+    featureFlags?: FeatureFlags;
     /**
      * Path of the manifest file. Defaults to `manifest.json` inside `destFolder`.
      */
     manifest?: string;
-    basePath?: string;
-    branch?: string;
-    debug?: boolean;
-    featureFlags?: FeatureFlags;
     repositoryRoot?: string;
     systemLog?: LogFunction;
 }
-export declare const zipFunctions: (input: MixedPaths, destFolder: string, { archiveFormat, basePath, branch, config, configFileDirectories, debug, featureFlags, manifest, parallelLimit, repositoryRoot, systemLog, }?: ZipFunctionsOptions) => Promise<FunctionResult[]>;
-export declare const bundle: ({ basePath, branch, debug, destFolder, featureFlags: inputFeatureFlags, functions: functionsOptions, manifest, repositoryRoot, server, systemLog, }: BundleOptions) => Promise<BundleResult>;
+export type { ServerOptions, ServerResult };
+export declare const zipFunctions: (input: MixedPaths, destFolder: string, { archiveFormat, basePath, branch, config, configFileDirectories, featureFlags: inputFeatureFlags, manifest, parallelLimit, repositoryRoot, systemLog, debug, }?: ZipFunctionsOptions) => Promise<FunctionResult[]>;
+export declare const zipServer: (srcPath: string, destFolder: string, { basePath, debug, featureFlags: inputFeatureFlags, manifest, repositoryRoot, systemLog, }?: ZipServerOptions) => Promise<ServerResult>;
 export declare const zipFunction: (relativeSrcPath: string, destFolder: string, { archiveFormat, basePath, config: inputConfig, featureFlags: inputFeatureFlags, repositoryRoot, systemLog, debug, internalSrcFolder, }?: ZipFunctionOptions) => Promise<FunctionResult | undefined>;

package/dist/zip.js

@@ -4,7 +4,7 @@ import isPathInside from 'is-path-inside';
 import pMap from 'p-map';
 import { ARCHIVE_FORMAT } from './archive.js';
 import { getFlags } from './feature_flags.js';
-import { createManifest } from './manifest.js';
+import { createFunctionsManifest, createServerManifest } from './manifest.js';
 import { bundleServer } from './server.js';
 import { getFunctionsFromPaths } from './runtimes/index.js';
 import { MODULE_FORMAT } from './runtimes/node/utils/module_format.js';
@@ -23,41 +23,15 @@ const validateArchiveFormat = (archiveFormat) => {
 };
 // Zip `srcFolder/*` (Node.js or Go files) to `destFolder/*.zip` so it can be
 // used by AWS Lambda
-export const zipFunctions = async function (input, destFolder, { archiveFormat, basePath, branch, config, configFileDirectories, debug, featureFlags, manifest, parallelLimit, repositoryRoot, systemLog, } = {}) {
-    const { functions } = await bundle({
-        basePath,
-        branch,
-        debug,
-        destFolder,
-        featureFlags,
-        functions: {
-            archiveFormat,
-            config,
-            configFileDirectories,
-            parallelLimit,
-            paths: input,
-        },
-        manifest,
-        repositoryRoot,
-        systemLog,
-    });
-    return functions;
-};
-// Bundles a deploy's functions and its Netlify Server, writing the one manifest
-// that describes both.
-export const bundle = async function ({ basePath, branch, debug, destFolder, featureFlags: inputFeatureFlags, functions: functionsOptions, manifest, repositoryRoot = basePath, server, systemLog, }) {
-    const { archiveFormat = ARCHIVE_FORMAT.ZIP, config = {}, configFileDirectories, parallelLimit = DEFAULT_PARALLEL_LIMIT, paths, } = functionsOptions ?? { paths: [] };
+export const zipFunctions = async function (input, destFolder, { archiveFormat = ARCHIVE_FORMAT.ZIP, basePath, branch, config = {}, configFileDirectories, featureFlags: inputFeatureFlags, manifest, parallelLimit = DEFAULT_PARALLEL_LIMIT, repositoryRoot = basePath, systemLog, debug, } = {}) {
     validateArchiveFormat(archiveFormat);
     const logger = getLogger(systemLog, debug);
     const cache = new RuntimeCache();
     const featureFlags = getFlags(inputFeatureFlags);
-    const bag = getFunctionsBag(paths);
+    const bag = getFunctionsBag(input);
     const srcFolders = resolveFunctionsDirectories([...bag.generated.directories, ...bag.user.directories]);
-    const [foundPaths] = await Promise.all([
-        listFunctionsDirectories(srcFolders),
-        fs.mkdir(destFolder, { recursive: true }),
-    ]);
-    const functions = await getFunctionsFromPaths([...foundPaths, ...bag.generated.functions, ...bag.user.functions], {
+    const [paths] = await Promise.all([listFunctionsDirectories(srcFolders), fs.mkdir(destFolder, { recursive: true })]);
+    const functions = await getFunctionsFromPaths([...paths, ...bag.generated.functions, ...bag.user.functions], {
         cache,
         config,
         configFileDirectories,
@@ -101,21 +75,26 @@ export const bundle = async function ({ basePath, branch, debug, destFolder, fea
         const resultWithSize = await addArchiveSize(result);
         return formatZipResult(resultWithSize);
     }));
-    const serverResult = server === undefined
-        ? undefined
-        : await bundleServer(server, destFolder, {
-            basePath,
-            cache,
-            featureFlags,
-            logger,
-            repositoryRoot,
-        });
-    await createManifest({
+    await createFunctionsManifest({
         functions: formattedResults,
         path: resolve(manifest || join(destFolder, 'manifest.json')),
-        server: serverResult,
     });
-    return { functions: formattedResults, server: serverResult };
+    return formattedResults;
+};
+export const zipServer = async function (srcPath, destFolder, { basePath, debug, featureFlags: inputFeatureFlags, manifest, repositoryRoot = basePath, systemLog, } = {}) {
+    const logger = getLogger(systemLog, debug);
+    const cache = new RuntimeCache();
+    const featureFlags = getFlags(inputFeatureFlags);
+    await fs.mkdir(destFolder, { recursive: true });
+    const result = await bundleServer({ path: srcPath }, destFolder, {
+        basePath,
+        cache,
+        featureFlags,
+        logger,
+        repositoryRoot,
+    });
+    await createServerManifest({ path: resolve(manifest || join(destFolder, 'manifest.json')), server: result });
+    return result;
 };
 export const zipFunction = async function (relativeSrcPath, destFolder, { archiveFormat = ARCHIVE_FORMAT.ZIP, basePath, config: inputConfig = {}, featureFlags: inputFeatureFlags, repositoryRoot = basePath, systemLog, debug, internalSrcFolder, } = {}) {
     validateArchiveFormat(archiveFormat);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "16.1.0",
+  "version": "16.2.1",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",
@@ -100,5 +100,5 @@
   "engines": {
     "node": ">=22.12.0"
   },
-  "gitHead": "22902a5992a5909a97bb366c88c96f6d95c18b33"
+  "gitHead": "d99b17e8a25b18687ce7b7657621dd22827304b7"
 }