netlify 27.8.1 → 27.10.0

package/dist/commands/blobs/blobs-delete.js

@@ -10,6 +10,7 @@ export const blobsDelete = async (storeName, key, _options, command) => {
     const store = getStore({
         apiURL: `${api.scheme}://${api.host}`,
         name: storeName,
+        region: _options.region,
         siteID: siteInfo.id ?? '',
         token: api.accessToken ?? '',
     });

package/dist/commands/blobs/blobs-get.d.ts

@@ -1,7 +1,9 @@
+import { type GetStoreOptions } from '@netlify/blobs';
 import { OptionValues } from 'commander';
 import BaseCommand from '../base-command.js';
 interface Options extends OptionValues {
     output?: string;
+    region?: GetStoreOptions['region'];
 }
 export declare const blobsGet: (storeName: string, key: string, options: Options, command: BaseCommand) => Promise<undefined>;
 export {};

package/dist/commands/blobs/blobs-get.js

@@ -8,6 +8,7 @@ export const blobsGet = async (storeName, key, options, command) => {
     const store = getStore({
         apiURL: `${api.scheme}://${api.host}`,
         name: storeName,
+        region: options.region,
         siteID: siteInfo?.id ?? '',
         token: api.accessToken ?? '',
     });

package/dist/commands/blobs/blobs-list.d.ts

@@ -1,9 +1,11 @@
+import { type GetStoreOptions } from '@netlify/blobs';
 import { OptionValues } from 'commander';
 import BaseCommand from '../base-command.js';
 interface Options extends OptionValues {
     directories?: boolean;
     json?: boolean;
     prefix?: string;
+    region?: GetStoreOptions['region'];
 }
 export declare const blobsList: (storeName: string, options: Options, command: BaseCommand) => Promise<undefined>;
 export {};

package/dist/commands/blobs/blobs-list.js

@@ -6,6 +6,7 @@ export const blobsList = async (storeName, options, command) => {
     const store = getStore({
         apiURL: `${api.scheme}://${api.host}`,
         name: storeName,
+        region: options.region,
         siteID: siteInfo.id,
         token: api.accessToken ?? '',
     });

package/dist/commands/blobs/blobs-set.d.ts

@@ -1,8 +1,10 @@
+import { type GetStoreOptions } from '@netlify/blobs';
 import { OptionValues } from 'commander';
 import BaseCommand from '../base-command.js';
 interface Options extends OptionValues {
     input?: string;
     force?: string | boolean;
+    region?: GetStoreOptions['region'];
 }
 export declare const blobsSet: (storeName: string, key: string, valueParts: string[], options: Options, command: BaseCommand) => Promise<undefined>;
 export {};

package/dist/commands/blobs/blobs-set.js

@@ -9,6 +9,7 @@ export const blobsSet = async (storeName, key, valueParts, options, command) =>
     const store = getStore({
         apiURL: `${api.scheme}://${api.host}`,
         name: storeName,
+        region: options.region,
         siteID: siteInfo.id,
         token: api.accessToken ?? '',
     });

package/dist/commands/blobs/blobs.js

@@ -15,6 +15,7 @@ export const createBlobsCommand = (program) => {
         .description(`Deletes an object with a given key, if it exists, from a Netlify Blobs store`)
         .argument('<store>', 'Name of the store')
         .argument('<key>', 'Object key')
+        .option('--region <region>', "The region where the store data is held, such as 'eu-central-1'; when omitted, the default region is used")
         .alias('blob:delete')
         .hook('preAction', requiresSiteInfo)
         .action(async (storeName, key, _options, command) => {
@@ -27,6 +28,7 @@ export const createBlobsCommand = (program) => {
         .argument('<store>', 'Name of the store')
         .argument('<key>', 'Object key')
         .option('-O, --output <path>', 'Defines the filesystem path where the blob data should be persisted')
+        .option('--region <region>', "The region where the store data is held, such as 'eu-central-1'; when omitted, the default region is used")
         .alias('blob:get')
         .hook('preAction', requiresSiteInfo)
         .action(async (storeName, key, options, command) => {
@@ -40,6 +42,7 @@ export const createBlobsCommand = (program) => {
         .option('-d, --directories', `Indicates that keys with the '/' character should be treated as directories, returning a list of sub-directories at a given level rather than all the keys inside them`)
         .option('-p, --prefix <prefix>', `A string for filtering down the entries; when specified, only the entries whose key starts with that prefix are returned`)
         .option('--json', 'Output list contents as JSON')
+        .option('--region <region>', "The region where the store data is held, such as 'eu-central-1'; when omitted, the default region is used")
         .alias('blob:list')
         .hook('preAction', requiresSiteInfo)
         .action(async (storeName, options, command) => {
@@ -53,6 +56,7 @@ export const createBlobsCommand = (program) => {
         .argument('<key>', 'Object key')
         .argument('[value...]', 'Object value')
         .option('-i, --input <path>', 'Defines the filesystem path where the blob data should be read from')
+        .option('--region <region>', "The region where the store data is held, such as 'eu-central-1'; when omitted, the default region is used")
         .alias('blob:set')
         .hook('preAction', requiresSiteInfo)
         .action(async (storeName, key, valueParts, options, command) => {
@@ -76,6 +80,7 @@ For more information about Netlify Blobs, see ${terminalLink(docsUrl, docsUrl, {
         'netlify blobs:delete my-store my-key',
         'netlify blobs:list my-store',
         'netlify blobs:list my-store --json',
+        'netlify blobs:list my-store --region eu-central-1',
     ])
         .action(blobs);
 };

package/dist/commands/deploy/deploy.js

@@ -22,7 +22,7 @@ import { getDeploySourceFields } from '../../utils/deploy/deploy-source.js';
 import { uploadSourceZip } from '../../utils/deploy/upload-source-zip.js';
 import { getEnvelopeEnv } from '../../utils/env/index.js';
 import { mergeDeployEnvVars } from '../../utils/env/deploy-env-vars.js';
-import { getFunctionsManifestPath, getInternalFunctionsDir } from '../../utils/functions/index.js';
+import { getFunctionsManifestPath, getInternalFunctionsDir, getServerManifestPath, } from '../../utils/functions/index.js';
 import { isEmpty } from '../../utils/object-utilities.js';
 import openBrowser from '../../utils/open-browser.js';
 import { isInteractive } from '../../utils/scripted-commands.js';
@@ -458,6 +458,7 @@ title, deployId: existingDeployId, }) => {
             functionsFolder,
         ].filter((folder) => Boolean(folder));
         const manifestPath = skipFunctionsCache ? null : await getFunctionsManifestPath({ base: site.root, packagePath });
+        const serverManifestPath = await getServerManifestPath({ base: site.root, packagePath });
         const redirectsPath = `${deployFolder}/_redirects`;
         const headersPath = `${deployFolder}/_headers`;
         const { redirects } = await parseAllRedirects({
@@ -493,6 +494,9 @@ title, deployId: existingDeployId, }) => {
             filter: getDeployFilesFilter({ site, deployFolder }),
             workingDir: command.workingDir,
             manifestPath,
+            packagePath,
+            serverEnabled: Boolean(siteData?.feature_flags?.netlify_build_server_standalone),
+            serverManifestPath: serverManifestPath ?? undefined,
             skipFunctionsCache,
             siteRoot: site.root,
             environment: mergeDeployEnvVars(options.env, options.secretEnv),

package/dist/utils/deploy/deploy-site.d.ts

@@ -3,13 +3,16 @@ import { type $TSFixMe } from '../../commands/types.js';
 import type { DeployEvent } from './status-cb.js';
 import type { DeployEnvironmentVariable } from '../env/deploy-env-vars.js';
 export type { DeployEvent };
-export declare const deploySite: (command: BaseCommand, api: $TSFixMe, siteId: any, dir: any, { assetType, branch, concurrentHash, concurrentUpload, config, deployId, deployTimeout, draft, environment, filter, fnDir, functionsConfig, hashAlgorithm, manifestPath, maxRetry, siteRoot, skipFunctionsCache, statusCb, syncFileLimit, tmpDir, workingDir, }: {
+export declare const deploySite: (command: BaseCommand, api: $TSFixMe, siteId: any, dir: any, { assetType, branch, concurrentHash, concurrentUpload, config, deployId, deployTimeout, draft, environment, filter, fnDir, functionsConfig, hashAlgorithm, manifestPath, maxRetry, packagePath, serverEnabled, serverManifestPath, siteRoot, skipFunctionsCache, statusCb, syncFileLimit, tmpDir, workingDir, }: {
     concurrentHash?: number;
     concurrentUpload?: number;
     deployTimeout?: number;
     draft?: boolean;
     environment?: DeployEnvironmentVariable[];
     maxRetry?: number;
+    packagePath?: string;
+    serverEnabled?: boolean;
+    serverManifestPath?: string;
     statusCb?: (status: DeployEvent) => void;
     syncFileLimit?: number;
     tmpDir?: string;

package/dist/utils/deploy/deploy-site.js

@@ -36,7 +36,7 @@ functionsConfig,
 // @ts-expect-error TS(2525) FIXME: Initializer provides no value for this binding ele... Remove this comment to see the full error message
 hashAlgorithm, 
 // @ts-expect-error TS(2525) FIXME: Initializer provides no value for this binding ele... Remove this comment to see the full error message
-manifestPath, maxRetry = DEFAULT_MAX_RETRY, 
+manifestPath, maxRetry = DEFAULT_MAX_RETRY, packagePath, serverEnabled, serverManifestPath, 
 // @ts-expect-error TS(2525) FIXME: Initializer provides no value for this binding ele... Remove this comment to see the full error message
 siteRoot, 
 // @ts-expect-error TS(2525) FIXME: Initializer provides no value for this binding ele... Remove this comment to see the full error message
@@ -51,7 +51,7 @@ skipFunctionsCache, statusCb = () => {
     const edgeFunctionsDistPath = await getEdgeFunctionsDistPathIfExists(workingDir);
     const deployConfigPath = await getDeployConfigPathIfExists(workingDir);
     const dbMigrationsDistPath = await getDbMigrationsDistPathIfExists(workingDir);
-    const [{ files: staticFiles, filesShaMap: staticShaMap }, { fnConfig, fnShaMap, functionSchedules, functions, functionsWithNativeModules }, configFile, { edgeFunctions, edgeFnShaMap },] = await Promise.all([
+    const [{ files: staticFiles, filesShaMap: staticShaMap }, { fnConfig, fnShaMap, functionSchedules, functions, functionsWithNativeModules, server, serverShaMap }, configFile, { edgeFunctions, edgeFnShaMap },] = await Promise.all([
         hashFiles({
             assetType,
             concurrentHash,
@@ -68,6 +68,9 @@ skipFunctionsCache, statusCb = () => {
             hashAlgorithm,
             statusCb,
             manifestPath,
+            packagePath,
+            serverEnabled,
+            serverManifestPath,
             skipFunctionsCache,
             rootDir: siteRoot,
         }),
@@ -122,6 +125,7 @@ For more information, visit https://ntl.fyi/cli-native-modules.`);
             files,
             functions,
             edge_functions: edgeFunctions,
+            server,
             function_schedules: functionSchedules,
             functions_config: fnConfig,
             async: Object.keys(files).length > syncFileLimit,
@@ -141,7 +145,7 @@ For more information, visit https://ntl.fyi/cli-native-modules.`);
     let deploy = await api.updateSiteDeploy(deployParams);
     if (deployParams.body.async)
         deploy = await waitForDiff(api, deploy.id, siteId, deployTimeout);
-    const { required: requiredFiles, required_functions: requiredFns, required_edge_functions: requiredEdgeFns } = deploy;
+    const { required: requiredFiles, required_functions: requiredFns, required_edge_functions: requiredEdgeFns, required_server: requiredServer, } = deploy;
     statusCb({
         type: 'create-deploy',
         msg: `CDN requesting ${requiredFiles.length} files${Array.isArray(requiredFns) ? ` and ${requiredFns.length} functions` : ''}${Array.isArray(requiredEdgeFns) ? ` and ${requiredEdgeFns.length} edge functions` : ''}`,
@@ -150,7 +154,8 @@ For more information, visit https://ntl.fyi/cli-native-modules.`);
     const filesUploadList = getUploadList(requiredFiles, filesShaMap);
     const functionsUploadList = getUploadList(requiredFns, fnShaMap);
     const edgeFunctionsUploadList = getUploadList(requiredEdgeFns, edgeFnShaMap);
-    const uploadList = [...filesUploadList, ...functionsUploadList, ...edgeFunctionsUploadList];
+    const serverUploadList = getUploadList(requiredServer, serverShaMap);
+    const uploadList = [...filesUploadList, ...functionsUploadList, ...edgeFunctionsUploadList, ...serverUploadList];
     await uploadFiles(api, deployId, uploadList, { concurrentUpload, statusCb, maxRetry });
     statusCb({
         type: 'wait-for-deploy',

package/dist/utils/deploy/hash-fns.d.ts

@@ -1,11 +1,15 @@
 import BaseCommand from '../../commands/base-command.js';
 import { $TSFixMe } from '../../commands/types.js';
-declare const hashFns: (command: BaseCommand, directories: string[], { concurrentHash, functionsConfig, hashAlgorithm, manifestPath, rootDir, skipFunctionsCache, statusCb, tmpDir, }: {
+import type { ServerUploadFile } from './upload-files.js';
+declare const hashFns: (command: BaseCommand, directories: string[], { concurrentHash, functionsConfig, hashAlgorithm, manifestPath, packagePath, rootDir, serverEnabled, serverManifestPath, skipFunctionsCache, statusCb, tmpDir, }: {
     concurrentHash?: number;
     functionsConfig?: $TSFixMe;
     hashAlgorithm?: string | undefined;
     manifestPath?: string | undefined;
+    packagePath?: string | undefined;
     rootDir?: string | undefined;
+    serverEnabled?: boolean | undefined;
+    serverManifestPath?: string | undefined;
     skipFunctionsCache?: boolean | undefined;
     statusCb: $TSFixMe;
     tmpDir: $TSFixMe;
@@ -19,6 +23,11 @@ declare const hashFns: (command: BaseCommand, directories: string[], { concurren
     shaMap?: Record<string, $TSFixMe> | undefined;
     fnShaMap?: Record<string, $TSFixMe[]> | undefined;
     fnConfig?: Record<string, $TSFixMe> | undefined;
+    server?: {
+        sha: string;
+        region?: string;
+    } | undefined;
+    serverShaMap?: Record<string, ServerUploadFile[]> | undefined;
 }>;
 export default hashFns;
 //# sourceMappingURL=hash-fns.d.ts.map

package/dist/utils/deploy/hash-fns.js

@@ -1,8 +1,9 @@
 import { readFile } from 'fs/promises';
-import path from 'path';
+import path, { join } from 'path';
 import { pipeline } from 'stream/promises';
 import { Readable } from 'stream';
-import { zipFunctions } from '@netlify/zip-it-and-ship-it';
+import { SERVER_DIRECTORY } from '@netlify/build';
+import { findServerEntry, zipFunctions, zipServer, } from '@netlify/zip-it-and-ship-it';
 import { INTERNAL_FUNCTIONS_FOLDER } from '../functions/functions.js';
 import { hasherCtor, manifestCollectorCtor } from './hasher-segments.js';
 // Maximum age of functions manifest (2 minutes).
@@ -15,9 +16,7 @@ const getFunctionZips = async ({ command, directories, functionsConfig, manifest
     });
     if (manifestPath) {
         try {
-            // read manifest.json file
-            // @ts-expect-error TS(2345) FIXME: Argument of type 'Buffer' is not assignable to par... Remove this comment to see the full error message
-            const { functions, timestamp } = JSON.parse(await readFile(manifestPath));
+            const { functions, timestamp } = JSON.parse(await readFile(manifestPath, 'utf-8'));
             const manifestAge = Date.now() - timestamp;
             if (manifestAge > MANIFEST_FILE_TTL) {
                 throw new Error('Manifest expired');
@@ -53,6 +52,28 @@ const getFunctionZips = async ({ command, directories, functionsConfig, manifest
         config: functionsConfig,
     });
 };
+const getServerBundle = async ({ packagePath, rootDir, serverEnabled, serverManifestPath, tmpDir, }) => {
+    if (!serverEnabled) {
+        return undefined;
+    }
+    if (serverManifestPath) {
+        try {
+            const { server, timestamp } = JSON.parse(await readFile(serverManifestPath, 'utf-8'));
+            if (server && Date.now() - timestamp <= MANIFEST_FILE_TTL) {
+                return server;
+            }
+        }
+        catch {
+            // An unusable manifest is no different from not having one: the server is
+            // rebuilt below.
+        }
+    }
+    const entryPath = rootDir ? await findServerEntry(join(rootDir, packagePath ?? '', SERVER_DIRECTORY)) : undefined;
+    if (entryPath === undefined) {
+        return undefined;
+    }
+    return await zipServer(entryPath, join(tmpDir, 'server'), { basePath: rootDir });
+};
 const trafficRulesConfig = (trafficRules) => {
     if (!trafficRules) {
         return;
@@ -72,24 +93,30 @@ const trafficRulesConfig = (trafficRules) => {
         },
     };
 };
-const hashFns = async (command, directories, { concurrentHash, functionsConfig, hashAlgorithm = 'sha256', manifestPath, rootDir, skipFunctionsCache, statusCb, tmpDir, }) => {
-    // Exit early if no functions directories are configured.
-    if (directories.length === 0) {
+const hashFns = async (command, directories, { concurrentHash, functionsConfig, hashAlgorithm = 'sha256', manifestPath, packagePath, rootDir, serverEnabled, serverManifestPath, skipFunctionsCache, statusCb, tmpDir, }) => {
+    // Exit early if there is nothing to bundle. A site can have a server without
+    // any functions directory.
+    if (directories.length === 0 && !serverEnabled) {
         return { functions: {}, functionsWithNativeModules: [], shaMap: {} };
     }
     if (!tmpDir) {
         throw new Error('Missing tmpDir directory for zipping files');
     }
-    const functionZips = await getFunctionZips({
-        command,
-        directories,
-        functionsConfig,
-        manifestPath,
-        rootDir,
-        skipFunctionsCache,
-        statusCb,
-        tmpDir,
-    });
+    const [functionZips, serverBundle] = await Promise.all([
+        directories.length === 0
+            ? []
+            : getFunctionZips({
+                command,
+                directories,
+                functionsConfig,
+                manifestPath,
+                rootDir,
+                skipFunctionsCache,
+                statusCb,
+                tmpDir,
+            }),
+        getServerBundle({ packagePath, rootDir, serverEnabled, serverManifestPath, tmpDir }),
+    ]);
     // ZISI's in-memory FunctionResult only nests bootstrap/runtime version into
     // buildData when writing the manifest cache. Reconstruct it for direct-zip paths.
     for (const func of functionZips) {
@@ -156,7 +183,34 @@ const hashFns = async (command, directories, { concurrentHash, functionsConfig,
     const fnShaMap = {};
     const manifestCollector = manifestCollectorCtor(functions, fnShaMap, { statusCb });
     await pipeline([functionStream, hasher, manifestCollector]);
-    return { functionSchedules, functions, functionsWithNativeModules, fnShaMap, fnConfig };
+    const { server, serverShaMap } = await hashServer(serverBundle, { concurrentHash, hashAlgorithm, statusCb, tmpDir });
+    return { functionSchedules, functions, functionsWithNativeModules, fnShaMap, fnConfig, server, serverShaMap };
+};
+// A deploy has at most one server, so it is declared on its own rather than in a
+// map keyed by name. It still goes through the same hashing pipeline, so the
+// upload flow can treat it like any other artifact.
+const hashServer = async (serverBundle, { concurrentHash, hashAlgorithm, statusCb, tmpDir, }) => {
+    if (!serverBundle) {
+        return {};
+    }
+    const fileObj = {
+        filepath: serverBundle.path,
+        root: tmpDir,
+        relname: path.relative(tmpDir, serverBundle.path),
+        basename: path.basename(serverBundle.path),
+        extname: path.extname(serverBundle.path),
+        type: 'file',
+        assetType: 'server',
+        normalizedPath: path.basename(serverBundle.path, path.extname(serverBundle.path)),
+    };
+    const servers = {};
+    const serverShaMap = {};
+    await pipeline([
+        Readable.from([fileObj]),
+        hasherCtor({ concurrentHash, hashAlgorithm }),
+        manifestCollectorCtor(servers, serverShaMap, { statusCb }),
+    ]);
+    return { server: { sha: Object.values(servers)[0], region: serverBundle.region }, serverShaMap };
 };
 export default hashFns;
 //# sourceMappingURL=hash-fns.js.map

package/dist/utils/deploy/upload-files.d.ts

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import type { NetlifyAPI } from '@netlify/api';
 import type { StatusCallback } from './status-cb.js';
-export type UploadApi = Pick<NetlifyAPI, 'uploadDeployFile' | 'uploadDeployFunction' | 'uploadDeployEdgeFunction'>;
+export type UploadApi = Pick<NetlifyAPI, 'uploadDeployFile' | 'uploadDeployFunction' | 'uploadDeployEdgeFunction' | 'uploadDeployServer'>;
 interface UploadFileBase {
     filepath: string;
     normalizedPath: string;
@@ -20,7 +20,11 @@ export interface EdgeFunctionUploadFile extends UploadFileBase {
     assetType: 'edge-function';
     hash: string;
 }
-export type UploadFile = StaticUploadFile | FunctionUploadFile | EdgeFunctionUploadFile;
+export interface ServerUploadFile extends UploadFileBase {
+    assetType: 'server';
+    hash: string;
+}
+export type UploadFile = StaticUploadFile | FunctionUploadFile | EdgeFunctionUploadFile | ServerUploadFile;
 interface UploadFilesOptions {
     concurrentUpload: number;
     maxRetry: number;

package/dist/utils/deploy/upload-files.js

@@ -63,6 +63,19 @@ const uploadFiles = async (api, deployId, uploadList, { concurrentUpload, maxRet
                     return api.uploadDeployEdgeFunction(params);
                 }, maxRetry);
             }
+            case 'server': {
+                return await retryUpload((retryCount) => {
+                    const params = {
+                        body: readStreamCtor,
+                        deployId,
+                        codeSha: fileObj.hash,
+                    };
+                    if (retryCount > 0) {
+                        params.xNfRetryCount = retryCount;
+                    }
+                    return api.uploadDeployServer(params);
+                }, maxRetry);
+            }
             default: {
                 throw new MissingAssetTypeError(fileObj);
             }

package/dist/utils/functions/functions.d.ts

@@ -13,6 +13,10 @@ export declare const getFunctionsManifestPath: ({ base, packagePath }: {
     base: string;
     packagePath?: string;
 }) => Promise<string | null>;
+export declare const getServerManifestPath: ({ base, packagePath }: {
+    base: string;
+    packagePath?: string;
+}) => Promise<string | null>;
 export declare const getFunctionsDistPath: ({ base, packagePath, }: {
     base?: undefined | string;
     packagePath?: string;

package/dist/utils/functions/functions.js

@@ -17,6 +17,11 @@ export const getFunctionsManifestPath = async ({ base, packagePath = '' }) => {
     const isFile = await isFileAsync(path);
     return isFile ? path : null;
 };
+export const getServerManifestPath = async ({ base, packagePath = '' }) => {
+    const path = resolve(base, packagePath, getPathInProject(['server', 'manifest.json']));
+    const isFile = await isFileAsync(path);
+    return isFile ? path : null;
+};
 export const getFunctionsDistPath = async ({ base, packagePath = '', }) => {
     const path = resolve(base ?? '', packagePath, getPathInProject(['functions']));
     const isDirectory = await isDirectoryAsync(path);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "netlify",
-  "version": "27.8.1",
+  "version": "27.10.0",
   "description": "Netlify command line tool",
   "keywords": [
     "api",
@@ -55,12 +55,12 @@
     "@netlify/ai": "^1.0.1",
     "@netlify/api": "^15.1.2",
     "@netlify/blobs": "^11.1.0",
-    "@netlify/build": "^37.0.0",
+    "@netlify/build": "^37.3.0",
     "@netlify/build-info": "^11.3.0",
     "@netlify/config": "^25.2.5",
     "@netlify/dev": "^5.1.2",
     "@netlify/dev-utils": "^6.0.1",
-    "@netlify/edge-bundler": "^16.0.4",
+    "@netlify/edge-bundler": "^16.1.0",
     "@netlify/edge-functions": "^4.0.0",
     "@netlify/edge-functions-bootstrap": "^3.2.0",
     "@netlify/headers-parser": "^10.1.1",
@@ -68,7 +68,7 @@
     "@netlify/local-functions-proxy": "^2.0.3",
     "@netlify/redirect-parser": "^16.1.1",
     "@netlify/server-dev": "^0.1.1",
-    "@netlify/zip-it-and-ship-it": "^16.0.0",
+    "@netlify/zip-it-and-ship-it": "^16.2.0",
     "@octokit/rest": "^22.0.0",
     "@opentelemetry/api": "~1.9.0",
     "@pnpm/tabtab": "^0.5.4",