@netlify/zip-it-and-ship-it 15.3.2 → 15.3.4

package/dist/config.d.ts

@@ -1,15 +1,14 @@
-import type { FunctionRegion } from '@netlify/types';
 import { z } from 'zod';
 import { FunctionSource } from './function.js';
 export declare const functionConfigShape: z.ZodObject<{
     background: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
-    externalNodeModules: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    externalNodeModules: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;
     generator: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-    includedFiles: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    includedFiles: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;
     includedFilesBasePath: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-    ignoredNodeModules: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    ignoredNodeModules: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;
     name: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-    nodeBundler: z.ZodCatch<z.ZodOptional<z.ZodNativeEnum<{
+    nodeBundler: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
         readonly ESBUILD: "esbuild";
         readonly ESBUILD_ZISI: "esbuild_zisi";
         readonly NFT: "nft";
@@ -18,161 +17,31 @@ export declare const functionConfigShape: z.ZodObject<{
     }>>>;
     nodeSourcemap: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
     nodeVersion: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-    memory: z.ZodOptional<z.ZodEffects<z.ZodNumber, number, unknown>>;
-    region: z.ZodOptional<z.ZodEffects<z.ZodEnum<[FunctionRegion, ...FunctionRegion[]]>, FunctionRegion, unknown>>;
-    rustTargetDirectory: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-    schedule: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-    timeout: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
-    vcpu: z.ZodOptional<z.ZodNumber>;
-    zipGo: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
-    nodeModuleFormat: z.ZodCatch<z.ZodOptional<z.ZodNativeEnum<{
-        readonly COMMONJS: "cjs";
-        readonly ESM: "esm";
+    memory: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
+    region: z.ZodOptional<z.ZodPreprocess<z.ZodEnum<{
+        cmh: "cmh";
+        dub: "dub";
+        fra: "fra";
+        gru: "gru";
+        iad: "iad";
+        lhr: "lhr";
+        nrt: "nrt";
+        pdx: "pdx";
+        sfo: "sfo";
+        sin: "sin";
+        syd: "syd";
+        yul: "yul";
     }>>>;
-}, "strip", z.ZodTypeAny, {
-    name?: string | undefined;
-    background?: boolean | undefined;
-    externalNodeModules?: string[] | undefined;
-    generator?: string | undefined;
-    includedFiles?: string[] | undefined;
-    includedFilesBasePath?: string | undefined;
-    ignoredNodeModules?: string[] | undefined;
-    nodeBundler?: "none" | "esbuild" | "esbuild_zisi" | "nft" | "zisi" | undefined;
-    nodeSourcemap?: boolean | undefined;
-    nodeVersion?: string | undefined;
-    memory?: number | undefined;
-    region?: FunctionRegion | undefined;
-    rustTargetDirectory?: string | undefined;
-    schedule?: string | undefined;
-    timeout?: number | undefined;
-    vcpu?: number | undefined;
-    zipGo?: boolean | undefined;
-    nodeModuleFormat?: "cjs" | "esm" | undefined;
-}, {
-    name?: unknown;
-    background?: unknown;
-    externalNodeModules?: unknown;
-    generator?: unknown;
-    includedFiles?: unknown;
-    includedFilesBasePath?: unknown;
-    ignoredNodeModules?: unknown;
-    nodeBundler?: unknown;
-    nodeSourcemap?: unknown;
-    nodeVersion?: unknown;
-    memory?: unknown;
-    region?: unknown;
-    rustTargetDirectory?: unknown;
-    schedule?: unknown;
-    timeout?: unknown;
-    vcpu?: number | undefined;
-    zipGo?: unknown;
-    nodeModuleFormat?: unknown;
-}>;
-export declare const functionConfig: z.ZodEffects<z.ZodObject<{
-    background: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
-    externalNodeModules: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
-    generator: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-    includedFiles: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
-    includedFilesBasePath: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-    ignoredNodeModules: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
-    name: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-    nodeBundler: z.ZodCatch<z.ZodOptional<z.ZodNativeEnum<{
-        readonly ESBUILD: "esbuild";
-        readonly ESBUILD_ZISI: "esbuild_zisi";
-        readonly NFT: "nft";
-        readonly ZISI: "zisi";
-        readonly NONE: "none";
-    }>>>;
-    nodeSourcemap: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
-    nodeVersion: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-    memory: z.ZodOptional<z.ZodEffects<z.ZodNumber, number, unknown>>;
-    region: z.ZodOptional<z.ZodEffects<z.ZodEnum<[FunctionRegion, ...FunctionRegion[]]>, FunctionRegion, unknown>>;
     rustTargetDirectory: z.ZodCatch<z.ZodOptional<z.ZodString>>;
     schedule: z.ZodCatch<z.ZodOptional<z.ZodString>>;
     timeout: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
     vcpu: z.ZodOptional<z.ZodNumber>;
     zipGo: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
-    nodeModuleFormat: z.ZodCatch<z.ZodOptional<z.ZodNativeEnum<{
+    nodeModuleFormat: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
         readonly COMMONJS: "cjs";
         readonly ESM: "esm";
     }>>>;
-}, "strip", z.ZodTypeAny, {
-    name?: string | undefined;
-    background?: boolean | undefined;
-    externalNodeModules?: string[] | undefined;
-    generator?: string | undefined;
-    includedFiles?: string[] | undefined;
-    includedFilesBasePath?: string | undefined;
-    ignoredNodeModules?: string[] | undefined;
-    nodeBundler?: "none" | "esbuild" | "esbuild_zisi" | "nft" | "zisi" | undefined;
-    nodeSourcemap?: boolean | undefined;
-    nodeVersion?: string | undefined;
-    memory?: number | undefined;
-    region?: FunctionRegion | undefined;
-    rustTargetDirectory?: string | undefined;
-    schedule?: string | undefined;
-    timeout?: number | undefined;
-    vcpu?: number | undefined;
-    zipGo?: boolean | undefined;
-    nodeModuleFormat?: "cjs" | "esm" | undefined;
-}, {
-    name?: unknown;
-    background?: unknown;
-    externalNodeModules?: unknown;
-    generator?: unknown;
-    includedFiles?: unknown;
-    includedFilesBasePath?: unknown;
-    ignoredNodeModules?: unknown;
-    nodeBundler?: unknown;
-    nodeSourcemap?: unknown;
-    nodeVersion?: unknown;
-    memory?: unknown;
-    region?: unknown;
-    rustTargetDirectory?: unknown;
-    schedule?: unknown;
-    timeout?: unknown;
-    vcpu?: number | undefined;
-    zipGo?: unknown;
-    nodeModuleFormat?: unknown;
-}>, {
-    name?: string | undefined;
-    background?: boolean | undefined;
-    externalNodeModules?: string[] | undefined;
-    generator?: string | undefined;
-    includedFiles?: string[] | undefined;
-    includedFilesBasePath?: string | undefined;
-    ignoredNodeModules?: string[] | undefined;
-    nodeBundler?: "none" | "esbuild" | "esbuild_zisi" | "nft" | "zisi" | undefined;
-    nodeSourcemap?: boolean | undefined;
-    nodeVersion?: string | undefined;
-    memory?: number | undefined;
-    region?: FunctionRegion | undefined;
-    rustTargetDirectory?: string | undefined;
-    schedule?: string | undefined;
-    timeout?: number | undefined;
-    vcpu?: number | undefined;
-    zipGo?: boolean | undefined;
-    nodeModuleFormat?: "cjs" | "esm" | undefined;
-}, {
-    name?: unknown;
-    background?: unknown;
-    externalNodeModules?: unknown;
-    generator?: unknown;
-    includedFiles?: unknown;
-    includedFilesBasePath?: unknown;
-    ignoredNodeModules?: unknown;
-    nodeBundler?: unknown;
-    nodeSourcemap?: unknown;
-    nodeVersion?: unknown;
-    memory?: unknown;
-    region?: unknown;
-    rustTargetDirectory?: unknown;
-    schedule?: unknown;
-    timeout?: unknown;
-    vcpu?: number | undefined;
-    zipGo?: unknown;
-    nodeModuleFormat?: unknown;
-}>;
+}, z.core.$strip>;
 type FunctionConfig = z.infer<typeof functionConfigShape>;
 type GlobPattern = string;
 type Config = Record<GlobPattern, FunctionConfig>;

package/dist/config.js

@@ -66,11 +66,6 @@ export const functionConfigShape = z.object({
     // we can remove this.
     nodeModuleFormat: moduleFormat.optional().catch(undefined),
 });
-const refuseMemoryAndVcpu = (cfg) => !(cfg.memory !== undefined && cfg.vcpu !== undefined);
-export const functionConfig = functionConfigShape.refine(refuseMemoryAndVcpu, {
-    message: '`memory` and `vcpu` cannot both be set.',
-    path: ['vcpu'],
-});
 const getConfigForFunction = async ({ config, configFileDirectories, func, }) => {
     const fromConfig = getFromMainConfig({ config, func });
     // We try to read from a function config file if the function directory is

package/dist/feature_flags.d.ts

@@ -1,6 +1,5 @@
 export declare const defaultFlags: {
     readonly buildRustSource: boolean;
-    readonly parseWithEsbuild: false;
     readonly traceWithNft: false;
     readonly zisi_pure_esm: false;
     readonly zisi_pure_esm_mjs: false;
@@ -12,7 +11,6 @@ export declare const defaultFlags: {
 export type FeatureFlags = Partial<Record<keyof typeof defaultFlags, boolean>>;
 export declare const getFlags: (input?: Record<string, boolean>, flags?: {
     readonly buildRustSource: boolean;
-    readonly parseWithEsbuild: false;
     readonly traceWithNft: false;
     readonly zisi_pure_esm: false;
     readonly zisi_pure_esm_mjs: false;

package/dist/feature_flags.js

@@ -2,8 +2,6 @@ import { env } from 'process';
 export const defaultFlags = {
     // Build Rust functions from source.
     buildRustSource: Boolean(env.NETLIFY_EXPERIMENTAL_BUILD_RUST_SOURCE),
-    // Use esbuild to trace dependencies in the legacy bundler.
-    parseWithEsbuild: false,
     // Use NFT as the default bundler.
     traceWithNft: false,
     // Output pure (i.e. untranspiled) ESM files when the function file has ESM

package/dist/rate_limit.d.ts

@@ -18,29 +18,24 @@ export interface TrafficRules {
     };
 }
 export declare const rateLimit: z.ZodObject<{
-    action: z.ZodOptional<z.ZodEnum<["rate_limit", "rewrite"]>>;
-    aggregateBy: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["domain", "ip"]>, z.ZodArray<z.ZodEnum<["domain", "ip"]>, "many">]>>;
-    algorithm: z.ZodOptional<z.ZodEnum<["sliding_window"]>>;
-} & {
+    action: z.ZodOptional<z.ZodEnum<{
+        rate_limit: "rate_limit";
+        rewrite: "rewrite";
+    }>>;
+    aggregateBy: z.ZodOptional<z.ZodUnion<[z.ZodEnum<{
+        domain: "domain";
+        ip: "ip";
+    }>, z.ZodArray<z.ZodEnum<{
+        domain: "domain";
+        ip: "ip";
+    }>>]>>;
+    algorithm: z.ZodOptional<z.ZodEnum<{
+        sliding_window: "sliding_window";
+    }>>;
     windowLimit: z.ZodNumber;
     windowSize: z.ZodNumber;
-} & {
     to: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    windowLimit: number;
-    windowSize: number;
-    to?: string | undefined;
-    action?: "rate_limit" | "rewrite" | undefined;
-    aggregateBy?: "domain" | "ip" | ("domain" | "ip")[] | undefined;
-    algorithm?: "sliding_window" | undefined;
-}, {
-    windowLimit: number;
-    windowSize: number;
-    to?: string | undefined;
-    action?: "rate_limit" | "rewrite" | undefined;
-    aggregateBy?: "domain" | "ip" | ("domain" | "ip")[] | undefined;
-    algorithm?: "sliding_window" | undefined;
-}>;
+}, z.core.$strip>;
 type RateLimit = z.infer<typeof rateLimit>;
 /**
  * Takes a rate limiting configuration object and returns a traffic rules

package/dist/rate_limit.js

@@ -15,25 +15,25 @@ export const rateLimit = z
     aggregateBy: rateLimitAggregator.or(z.array(rateLimitAggregator)).optional(),
     algorithm: rateLimitAlgorithm.optional(),
 })
-    .merge(slidingWindow)
-    .merge(rewriteActionConfig.partial());
+    .extend(slidingWindow.shape)
+    .extend(rewriteActionConfig.partial().shape);
 /**
  * Takes a rate limiting configuration object and returns a traffic rules
  * object that is added to the manifest.
  */
 export const getTrafficRulesConfig = (input) => {
     const { windowSize, windowLimit, algorithm, aggregateBy, action, to } = input;
-    const rateLimitAgg = Array.isArray(aggregateBy) ? aggregateBy : [rateLimitAggregator.Enum.domain];
+    const rateLimitAgg = Array.isArray(aggregateBy) ? aggregateBy : [rateLimitAggregator.enum.domain];
     const rewriteConfig = to ? { to: input.to } : undefined;
     return {
         action: {
-            type: action || rateLimitAction.Enum.rate_limit,
+            type: action || rateLimitAction.enum.rate_limit,
             config: {
                 ...rewriteConfig,
                 rateLimitConfig: {
                     windowLimit,
                     windowSize,
-                    algorithm: algorithm || rateLimitAlgorithm.Enum.sliding_window,
+                    algorithm: algorithm || rateLimitAlgorithm.enum.sliding_window,
                 },
                 aggregate: {
                     keys: rateLimitAgg.map((agg) => ({ type: agg })),

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

@@ -14,7 +14,7 @@ export declare const NODE_BUNDLER: {
     readonly ZISI: "zisi";
     readonly NONE: "none";
 };
-export declare const nodeBundler: z.ZodNativeEnum<{
+export declare const nodeBundler: z.ZodEnum<{
     readonly ESBUILD: "esbuild";
     readonly ESBUILD_ZISI: "esbuild_zisi";
     readonly NFT: "nft";

package/dist/runtimes/node/bundlers/types.js

@@ -6,7 +6,7 @@ export const NODE_BUNDLER = {
     ZISI: 'zisi',
     NONE: 'none',
 };
-export const nodeBundler = z.nativeEnum(NODE_BUNDLER);
+export const nodeBundler = z.enum(NODE_BUNDLER);
 /* Why a bundler was used to bundle a given function */
 export const BUNDLER_REASON = {
     ConfigOverride: 'config-override', // explicit `config.nodeBundler`

package/dist/runtimes/node/bundlers/zisi/list_imports.js

@@ -1,64 +1,7 @@
-import * as esbuild from 'esbuild';
-import { isBuiltin } from 'node:module';
 import precinct from 'precinct';
-import { tmpName } from 'tmp-promise';
 import { FunctionBundlingUserError } from '../../../../utils/error.js';
-import { safeUnlink } from '../../../../utils/fs.js';
 import { RUNTIME } from '../../../runtime.js';
 import { NODE_BUNDLER } from '../types.js';
-// Maximum number of log messages that an esbuild instance will produce. This
-// limit is important to avoid out-of-memory errors due to too much data being
-// sent in the Go<>Node IPC channel.
-const ESBUILD_LOG_LIMIT = 10;
-const getListImportsPlugin = ({ imports, path }) => ({
-    name: 'list-imports',
-    setup(build) {
-        build.onResolve({ filter: /.*/ }, (args) => {
-            const isEntryPoint = args.path === path;
-            const isImport = !isEntryPoint && !isBuiltin(args.path);
-            if (isImport) {
-                imports.add(args.path);
-            }
-            return {
-                namespace: 'list-imports',
-                external: isImport,
-            };
-        });
-    },
-});
-const listImportsWithESBuild = async ({ functionName, path, }) => {
-    // We're not interested in the output that esbuild generates, we're just
-    // using it for its parsing capabilities in order to find import/require
-    // statements. However, if we don't give esbuild a path in `outfile`, it
-    // will pipe the output to stdout, which we also don't want. So we create
-    // a temporary file to serve as the esbuild output and then get rid of it
-    // when we're done.
-    const targetPath = await tmpName();
-    const imports = new Set();
-    try {
-        await esbuild.build({
-            bundle: true,
-            entryPoints: [path],
-            logLevel: 'error',
-            logLimit: ESBUILD_LOG_LIMIT,
-            outfile: targetPath,
-            platform: 'node',
-            plugins: [getListImportsPlugin({ imports, path })],
-            target: 'esnext',
-        });
-    }
-    catch (error) {
-        throw FunctionBundlingUserError.addCustomErrorInfo(error, {
-            functionName,
-            runtime: RUNTIME.JAVASCRIPT,
-            bundler: NODE_BUNDLER.ZISI,
-        });
-    }
-    finally {
-        await safeUnlink(targetPath);
-    }
-    return [...imports];
-};
 const listImportsWithPrecinct = async ({ functionName, path }) => {
     try {
         return await precinct.paperwork(path, { includeCore: false });
@@ -75,4 +18,4 @@ const listImportsWithPrecinct = async ({ functionName, path }) => {
         throw error;
     }
 };
-export const listImports = async ({ featureFlags, ...args }) => (featureFlags.parseWithEsbuild ? await listImportsWithESBuild(args) : await listImportsWithPrecinct(args));
+export const listImports = async ({ featureFlags, ...args }) => await listImportsWithPrecinct(args);

package/dist/runtimes/node/in_source_config/index.d.ts

@@ -17,158 +17,79 @@ export interface StaticAnalysisResult {
 interface FindISCDeclarationsOptions {
     functionName: string;
 }
-declare const httpMethod: z.ZodEnum<["GET", "POST", "PUT", "PATCH", "OPTIONS", "DELETE", "HEAD"]>;
-declare const httpMethods: z.ZodEffects<z.ZodEnum<["GET", "POST", "PUT", "PATCH", "OPTIONS", "DELETE", "HEAD"]>, "GET" | "POST" | "PUT" | "PATCH" | "OPTIONS" | "DELETE" | "HEAD", unknown>;
-export type HttpMethod = z.infer<typeof httpMethod>;
-export type HttpMethods = z.infer<typeof httpMethods>;
-export declare const inSourceConfig: z.ZodEffects<z.ZodObject<Pick<{
+export declare const inSourceConfig: z.ZodObject<{
+    name: z.ZodCatch<z.ZodOptional<z.ZodString>>;
     background: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
-    externalNodeModules: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    externalNodeModules: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;
     generator: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-    includedFiles: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
-    includedFilesBasePath: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-    ignoredNodeModules: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
-    name: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-    nodeBundler: z.ZodCatch<z.ZodOptional<z.ZodNativeEnum<{
+    includedFiles: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    ignoredNodeModules: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    nodeBundler: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
         readonly ESBUILD: "esbuild";
         readonly ESBUILD_ZISI: "esbuild_zisi";
         readonly NFT: "nft";
         readonly ZISI: "zisi";
         readonly NONE: "none";
     }>>>;
-    nodeSourcemap: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
     nodeVersion: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-    memory: z.ZodOptional<z.ZodEffects<z.ZodNumber, number, unknown>>;
-    region: z.ZodOptional<z.ZodEffects<z.ZodEnum<[import("@netlify/types").FunctionRegion, ...import("@netlify/types").FunctionRegion[]]>, import("@netlify/types").FunctionRegion, unknown>>;
-    rustTargetDirectory: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    memory: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
+    region: z.ZodOptional<z.ZodPreprocess<z.ZodEnum<{
+        cmh: "cmh";
+        dub: "dub";
+        fra: "fra";
+        gru: "gru";
+        iad: "iad";
+        lhr: "lhr";
+        nrt: "nrt";
+        pdx: "pdx";
+        sfo: "sfo";
+        sin: "sin";
+        syd: "syd";
+        yul: "yul";
+    }>>>;
     schedule: z.ZodCatch<z.ZodOptional<z.ZodString>>;
     timeout: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
     vcpu: z.ZodOptional<z.ZodNumber>;
-    zipGo: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
-    nodeModuleFormat: z.ZodCatch<z.ZodOptional<z.ZodNativeEnum<{
-        readonly COMMONJS: "cjs";
-        readonly ESM: "esm";
-    }>>>;
-}, "name" | "background" | "externalNodeModules" | "generator" | "includedFiles" | "ignoredNodeModules" | "nodeBundler" | "nodeVersion" | "memory" | "region" | "schedule" | "timeout" | "vcpu"> & {
-    method: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodEffects<z.ZodEnum<["GET", "POST", "PUT", "PATCH", "OPTIONS", "DELETE", "HEAD"]>, "GET" | "POST" | "PUT" | "PATCH" | "OPTIONS" | "DELETE" | "HEAD", unknown>, z.ZodArray<z.ZodEffects<z.ZodEnum<["GET", "POST", "PUT", "PATCH", "OPTIONS", "DELETE", "HEAD"]>, "GET" | "POST" | "PUT" | "PATCH" | "OPTIONS" | "DELETE" | "HEAD", unknown>, "many">]>, ("GET" | "POST" | "PUT" | "PATCH" | "OPTIONS" | "DELETE" | "HEAD")[], unknown>>;
-    path: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, string[], string | string[]>>;
-    excludedPath: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, string[], string | string[]>>;
+    method: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodPreprocess<z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+        OPTIONS: "OPTIONS";
+        DELETE: "DELETE";
+        HEAD: "HEAD";
+    }>>, z.ZodArray<z.ZodPreprocess<z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+        OPTIONS: "OPTIONS";
+        DELETE: "DELETE";
+        HEAD: "HEAD";
+    }>>>]>, z.ZodTransform<("GET" | "POST" | "PUT" | "PATCH" | "OPTIONS" | "DELETE" | "HEAD")[], "GET" | "POST" | "PUT" | "PATCH" | "OPTIONS" | "DELETE" | "HEAD" | ("GET" | "POST" | "PUT" | "PATCH" | "OPTIONS" | "DELETE" | "HEAD")[]>>>;
+    path: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>>;
+    excludedPath: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>>;
     preferStatic: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
     rateLimit: z.ZodCatch<z.ZodOptional<z.ZodObject<{
-        action: z.ZodOptional<z.ZodEnum<["rate_limit", "rewrite"]>>;
-        aggregateBy: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["domain", "ip"]>, z.ZodArray<z.ZodEnum<["domain", "ip"]>, "many">]>>;
-        algorithm: z.ZodOptional<z.ZodEnum<["sliding_window"]>>;
-    } & {
+        action: z.ZodOptional<z.ZodEnum<{
+            rate_limit: "rate_limit";
+            rewrite: "rewrite";
+        }>>;
+        aggregateBy: z.ZodOptional<z.ZodUnion<[z.ZodEnum<{
+            domain: "domain";
+            ip: "ip";
+        }>, z.ZodArray<z.ZodEnum<{
+            domain: "domain";
+            ip: "ip";
+        }>>]>>;
+        algorithm: z.ZodOptional<z.ZodEnum<{
+            sliding_window: "sliding_window";
+        }>>;
         windowLimit: z.ZodNumber;
         windowSize: z.ZodNumber;
-    } & {
         to: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        windowLimit: number;
-        windowSize: number;
-        to?: string | undefined;
-        action?: "rate_limit" | "rewrite" | undefined;
-        aggregateBy?: "domain" | "ip" | ("domain" | "ip")[] | undefined;
-        algorithm?: "sliding_window" | undefined;
-    }, {
-        windowLimit: number;
-        windowSize: number;
-        to?: string | undefined;
-        action?: "rate_limit" | "rewrite" | undefined;
-        aggregateBy?: "domain" | "ip" | ("domain" | "ip")[] | undefined;
-        algorithm?: "sliding_window" | undefined;
-    }>>>;
-}, "strip", z.ZodTypeAny, {
-    name?: string | undefined;
-    path?: string[] | undefined;
-    background?: boolean | undefined;
-    externalNodeModules?: string[] | undefined;
-    generator?: string | undefined;
-    includedFiles?: string[] | undefined;
-    ignoredNodeModules?: string[] | undefined;
-    nodeBundler?: "none" | "esbuild" | "esbuild_zisi" | "nft" | "zisi" | undefined;
-    nodeVersion?: string | undefined;
-    memory?: number | undefined;
-    region?: import("@netlify/types").FunctionRegion | undefined;
-    schedule?: string | undefined;
-    timeout?: number | undefined;
-    vcpu?: number | undefined;
-    method?: ("GET" | "POST" | "PUT" | "PATCH" | "OPTIONS" | "DELETE" | "HEAD")[] | undefined;
-    excludedPath?: string[] | undefined;
-    preferStatic?: boolean | undefined;
-    rateLimit?: {
-        windowLimit: number;
-        windowSize: number;
-        to?: string | undefined;
-        action?: "rate_limit" | "rewrite" | undefined;
-        aggregateBy?: "domain" | "ip" | ("domain" | "ip")[] | undefined;
-        algorithm?: "sliding_window" | undefined;
-    } | undefined;
-}, {
-    name?: unknown;
-    path?: string | string[] | undefined;
-    background?: unknown;
-    externalNodeModules?: unknown;
-    generator?: unknown;
-    includedFiles?: unknown;
-    ignoredNodeModules?: unknown;
-    nodeBundler?: unknown;
-    nodeVersion?: unknown;
-    memory?: unknown;
-    region?: unknown;
-    schedule?: unknown;
-    timeout?: unknown;
-    vcpu?: number | undefined;
-    method?: unknown;
-    excludedPath?: string | string[] | undefined;
-    preferStatic?: unknown;
-    rateLimit?: unknown;
-}>, {
-    name?: string | undefined;
-    path?: string[] | undefined;
-    background?: boolean | undefined;
-    externalNodeModules?: string[] | undefined;
-    generator?: string | undefined;
-    includedFiles?: string[] | undefined;
-    ignoredNodeModules?: string[] | undefined;
-    nodeBundler?: "none" | "esbuild" | "esbuild_zisi" | "nft" | "zisi" | undefined;
-    nodeVersion?: string | undefined;
-    memory?: number | undefined;
-    region?: import("@netlify/types").FunctionRegion | undefined;
-    schedule?: string | undefined;
-    timeout?: number | undefined;
-    vcpu?: number | undefined;
-    method?: ("GET" | "POST" | "PUT" | "PATCH" | "OPTIONS" | "DELETE" | "HEAD")[] | undefined;
-    excludedPath?: string[] | undefined;
-    preferStatic?: boolean | undefined;
-    rateLimit?: {
-        windowLimit: number;
-        windowSize: number;
-        to?: string | undefined;
-        action?: "rate_limit" | "rewrite" | undefined;
-        aggregateBy?: "domain" | "ip" | ("domain" | "ip")[] | undefined;
-        algorithm?: "sliding_window" | undefined;
-    } | undefined;
-}, {
-    name?: unknown;
-    path?: string | string[] | undefined;
-    background?: unknown;
-    externalNodeModules?: unknown;
-    generator?: unknown;
-    includedFiles?: unknown;
-    ignoredNodeModules?: unknown;
-    nodeBundler?: unknown;
-    nodeVersion?: unknown;
-    memory?: unknown;
-    region?: unknown;
-    schedule?: unknown;
-    timeout?: unknown;
-    vcpu?: number | undefined;
-    method?: unknown;
-    excludedPath?: string | string[] | undefined;
-    preferStatic?: unknown;
-    rateLimit?: unknown;
-}>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
 export type InSourceConfig = z.infer<typeof inSourceConfig>;
 /**
  * Loads a file at a given path, parses it into an AST, and returns a series of
@@ -182,18 +103,18 @@ export declare const parseFile: (sourcePath: string, { functionName }: FindISCDe
  */
 export declare const parseSource: (source: string, { functionName }: FindISCDeclarationsOptions) => StaticAnalysisResult;
 export declare const augmentFunctionConfig: (mainFile: string, tomlConfig: FunctionConfig, inSourceConfig?: InSourceConfig) => {
-    name?: string | undefined;
     background?: boolean | undefined;
     externalNodeModules?: string[] | undefined;
     generator?: string | undefined;
     includedFiles?: string[] | undefined;
     includedFilesBasePath?: string | undefined;
     ignoredNodeModules?: string[] | undefined;
+    name?: string | undefined;
     nodeBundler?: "none" | "esbuild" | "esbuild_zisi" | "nft" | "zisi" | undefined;
     nodeSourcemap?: boolean | undefined;
     nodeVersion?: string | undefined;
     memory?: number | undefined;
-    region?: import("@netlify/types").FunctionRegion | undefined;
+    region?: "cmh" | "dub" | "fra" | "gru" | "iad" | "lhr" | "nrt" | "pdx" | "sfo" | "sin" | "syd" | "yul" | undefined;
     rustTargetDirectory?: string | undefined;
     schedule?: string | undefined;
     timeout?: number | undefined;
@@ -202,7 +123,6 @@ export declare const augmentFunctionConfig: (mainFile: string, tomlConfig: Funct
     nodeModuleFormat?: "cjs" | "esm" | undefined;
 } & {
     name?: string | undefined;
-    path?: string[] | undefined;
     background?: boolean | undefined;
     externalNodeModules?: string[] | undefined;
     generator?: string | undefined;
@@ -211,20 +131,21 @@ export declare const augmentFunctionConfig: (mainFile: string, tomlConfig: Funct
     nodeBundler?: "none" | "esbuild" | "esbuild_zisi" | "nft" | "zisi" | undefined;
     nodeVersion?: string | undefined;
     memory?: number | undefined;
-    region?: import("@netlify/types").FunctionRegion | undefined;
+    region?: "cmh" | "dub" | "fra" | "gru" | "iad" | "lhr" | "nrt" | "pdx" | "sfo" | "sin" | "syd" | "yul" | undefined;
     schedule?: string | undefined;
     timeout?: number | undefined;
     vcpu?: number | undefined;
     method?: ("GET" | "POST" | "PUT" | "PATCH" | "OPTIONS" | "DELETE" | "HEAD")[] | undefined;
+    path?: string[] | undefined;
     excludedPath?: string[] | undefined;
     preferStatic?: boolean | undefined;
     rateLimit?: {
         windowLimit: number;
         windowSize: number;
-        to?: string | undefined;
         action?: "rate_limit" | "rewrite" | undefined;
         aggregateBy?: "domain" | "ip" | ("domain" | "ip")[] | undefined;
         algorithm?: "sliding_window" | undefined;
+        to?: string | undefined;
     } | undefined;
 };
 export type ISCHandlerArg = ArgumentPlaceholder | Expression | SpreadElement | JSXNamespacedName;

package/dist/runtimes/node/in_source_config/index.js

@@ -39,16 +39,16 @@ export const inSourceConfig = functionConfigShape
     .extend({
     method: z
         .union([httpMethods, z.array(httpMethods)], {
-        errorMap: () => ({ message: 'Must be a string or array of strings' }),
+        error: () => ({ message: 'Must be a string or array of strings' }),
     })
         .transform(ensureArray)
         .optional(),
     path: z
-        .union([path, z.array(path)], { errorMap: () => ({ message: 'Must be a string or array of strings' }) })
+        .union([path, z.array(path)], { error: () => ({ message: 'Must be a string or array of strings' }) })
         .transform(ensureArray)
         .optional(),
     excludedPath: z
-        .union([path, z.array(path)], { errorMap: () => ({ message: 'Must be a string or array of strings' }) })
+        .union([path, z.array(path)], { error: () => ({ message: 'Must be a string or array of strings' }) })
         .transform(ensureArray)
         .optional(),
     preferStatic: z.boolean().optional().catch(undefined),

package/dist/runtimes/node/parser/index.d.ts

@@ -1,11 +1,3 @@
 import type { Program } from '@babel/types';
-export declare const parseExpression: ({ basePath, expression: rawExpression, resolveDir, }: {
-    basePath: string;
-    expression: string;
-    resolveDir: string;
-}) => {
-    includedPathsGlob: string | null | undefined;
-    type: string;
-} | undefined;
 export declare const safelyParseSource: (source: string) => Program | null;
 export declare const safelyReadSource: (path: string) => Promise<string | null>;

package/dist/runtimes/node/parser/index.js

@@ -1,76 +1,5 @@
 import { promises as fs } from 'fs';
-import { join, relative, resolve } from 'path';
 import { parse } from '@babel/parser';
-import { nonNullable } from '../../../utils/non_nullable.js';
-const GLOB_WILDCARD = '**';
-// Transforms an array of glob nodes into a glob string including an absolute
-// path.
-//
-// Example: ["./files/", "*", ".json"] => "/home/ntl/files/*.json"
-const getAbsoluteGlob = ({ basePath, globNodes, resolveDir, }) => {
-    if (!validateGlobNodes(globNodes)) {
-        return null;
-    }
-    const globStarIndex = globNodes.indexOf(GLOB_WILDCARD);
-    const [staticPath, dynamicPath] = globStarIndex === -1
-        ? [globNodes.join(''), '']
-        : [globNodes.slice(0, globStarIndex).join(''), globNodes.slice(globStarIndex).join('')];
-    const absoluteStaticPath = resolve(resolveDir, staticPath);
-    const relativeStaticPath = relative(basePath, absoluteStaticPath);
-    const absoluteGlob = join(relativeStaticPath, dynamicPath);
-    return absoluteGlob;
-};
-// Returns GLOB_WILDCARD for AST nodes that are accepted as part of a dynamic
-// expression and convertable to a wildcard character. This determines whether
-// we convert an expression or leave it alone. For example:
-//
-// - `./files/${someVariable}`: Convert `someVariable` to GLOB_WILDCARD
-// - `./files/${[some, array]}`: Don't convert expression
-//
-// The following AST nodes are converted to a wildcard:
-//
-// - CallExpression: `someFunction()`
-// - ConditionalExpression: `someCond ? someValue : otherValue`
-// - Identifier: `someVariable`
-// - MemberExpression: `someArray[index]` or `someObject.property`
-const getWildcardFromASTNode = (node) => {
-    switch (node.type) {
-        case 'CallExpression':
-        case 'ConditionalExpression':
-        case 'Identifier':
-        case 'MemberExpression':
-            return GLOB_WILDCARD;
-        default:
-            throw new Error('Expression member not supported');
-    }
-};
-// Tries to parse an expression, returning an object with:
-// - `includedPathsGlob`: A glob with the files to be included in the bundle
-// - `type`: The expression type (e.g. "require", "import")
-export const parseExpression = ({ basePath, expression: rawExpression, resolveDir, }) => {
-    const { program } = parse(rawExpression, {
-        sourceType: 'module',
-    });
-    const [statement] = program.body;
-    if (statement.type !== 'ExpressionStatement') {
-        return;
-    }
-    const { expression } = statement;
-    if (expression.type === 'CallExpression' &&
-        expression.callee.type === 'Identifier' &&
-        expression.callee.name === 'require') {
-        try {
-            const includedPathsGlob = parseRequire({ basePath, expression, resolveDir });
-            return {
-                includedPathsGlob,
-                type: expression.callee.name,
-            };
-        }
-        catch {
-            // no-op
-        }
-    }
-};
 // Parses a JS/TS source and returns the resulting AST.
 const parseSource = (source) => {
     const ast = parse(source, {
@@ -107,74 +36,3 @@ export const safelyReadSource = async (path) => {
         return null;
     }
 };
-// Parses a `require()` and returns a glob string with an absolute path.
-const parseRequire = ({ basePath, expression, resolveDir, }) => {
-    const { arguments: args = [] } = expression;
-    const [firstArg] = args;
-    if (firstArg === undefined) {
-        return;
-    }
-    if (firstArg.type === 'BinaryExpression') {
-        try {
-            const globNodes = parseBinaryExpression(firstArg);
-            return getAbsoluteGlob({ basePath, globNodes, resolveDir });
-        }
-        catch {
-            // no-op
-        }
-    }
-    if (firstArg.type === 'TemplateLiteral') {
-        const globNodes = parseTemplateLiteral(firstArg);
-        return getAbsoluteGlob({ basePath, globNodes, resolveDir });
-    }
-};
-// Transforms a binary expression AST node into an array of glob nodes, where
-// static parts will be left untouched and identifiers will be replaced by
-// `GLOB_WILDCARD`.
-//
-// Example: './files/' + lang + '.json' => ["./files/", "**", ".json"]
-const parseBinaryExpression = (expression) => {
-    const { left, operator, right } = expression;
-    if (operator !== '+') {
-        throw new Error('Expression operator not supported');
-    }
-    const operands = [left, right].flatMap((operand) => {
-        switch (operand.type) {
-            case 'BinaryExpression':
-                return parseBinaryExpression(operand);
-            case 'StringLiteral':
-                return operand.value;
-            default:
-                return getWildcardFromASTNode(operand);
-        }
-    });
-    return operands;
-};
-// Transforms a template literal AST node into an array of glob nodes, where
-// static parts will be left untouched and identifiers will be replaced by
-// `GLOB_WILDCARD`.
-//
-// Example: `./files/${lang}.json` => ["./files/", "**", ".json"]
-const parseTemplateLiteral = (expression) => {
-    const { expressions, quasis } = expression;
-    const parts = [...expressions, ...quasis].sort((partA, partB) => (partA.start ?? 0) - (partB.start ?? 0));
-    const globNodes = parts.map((part) => {
-        switch (part.type) {
-            case 'TemplateElement':
-                return part.value.cooked === '' ? null : part.value.cooked;
-            default:
-                return getWildcardFromASTNode(part);
-        }
-    });
-    return globNodes.filter(nonNullable);
-};
-// For our purposes, we consider a glob to be valid if all the nodes are
-// strings and the first node is static (i.e. not a wildcard character).
-const validateGlobNodes = (globNodes) => {
-    if (!globNodes) {
-        return false;
-    }
-    const hasStrings = globNodes.every((node) => typeof node === 'string');
-    const hasStaticHead = globNodes[0] !== GLOB_WILDCARD;
-    return hasStrings && hasStaticHead;
-};

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

@@ -2,7 +2,6 @@ import type { FeatureFlags } from '../../../feature_flags.js';
 import { ModuleFormat } from './module_format.js';
 export declare const ENTRY_FILE_NAME = "___netlify-entry-point";
 export declare const BOOTSTRAP_FILE_NAME = "___netlify-bootstrap.mjs";
-export declare const BOOTSTRAP_VERSION_FILE_NAME = "___netlify-bootstrap-version";
 export declare const METADATA_FILE_NAME = "___netlify-metadata.json";
 export declare const TELEMETRY_FILE_NAME = "___netlify-telemetry.mjs";
 export interface EntryFile {

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

@@ -7,7 +7,6 @@ import { getFileExtensionForFormat, MODULE_FILE_EXTENSION, MODULE_FORMAT, } from
 import { normalizeFilePath } from './normalize_path.js';
 export const ENTRY_FILE_NAME = '___netlify-entry-point';
 export const BOOTSTRAP_FILE_NAME = '___netlify-bootstrap.mjs';
-export const BOOTSTRAP_VERSION_FILE_NAME = '___netlify-bootstrap-version';
 export const METADATA_FILE_NAME = '___netlify-metadata.json';
 export const TELEMETRY_FILE_NAME = '___netlify-telemetry.mjs';
 const require = createRequire(import.meta.url);

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

@@ -6,7 +6,7 @@ export declare const MODULE_FORMAT: {
     readonly COMMONJS: "cjs";
     readonly ESM: "esm";
 };
-export declare const moduleFormat: z.ZodNativeEnum<{
+export declare const moduleFormat: z.ZodEnum<{
     readonly COMMONJS: "cjs";
     readonly ESM: "esm";
 }>;

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

@@ -4,7 +4,7 @@ export const MODULE_FORMAT = {
     COMMONJS: 'cjs',
     ESM: 'esm',
 };
-export const moduleFormat = z.nativeEnum(MODULE_FORMAT);
+export const moduleFormat = z.enum(MODULE_FORMAT);
 export const MODULE_FILE_EXTENSION = {
     CJS: '.cjs',
     CTS: '.cts',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "15.3.2",
+  "version": "15.3.4",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",
@@ -73,13 +73,12 @@
     "unixify": "^1.0.0",
     "urlpattern-polyfill": "8.0.2",
     "yargs": "^17.0.0",
-    "zod": "^3.23.8"
+    "zod": "^4.0.5"
   },
   "devDependencies": {
     "@netlify/types": "2.7.0",
     "@opentelemetry/sdk-trace-base": "~1.24.0",
     "@types/archiver": "8.0.0",
-    "@types/is-ci": "3.0.4",
     "@types/node": "^22.12.0",
     "@types/normalize-path": "3.0.2",
     "@types/resolve": "1.20.6",
@@ -96,11 +95,10 @@
     "is-ci": "4.1.0",
     "lambda-local": "2.2.0",
     "source-map-support": "0.5.21",
-    "typescript": "5.9.3",
     "vitest": "^3.0.0"
   },
   "engines": {
     "node": ">=22.12.0"
   },
-  "gitHead": "f34dd81fc3bc8925aabe5cf9c1cdce4e8eebc4e0"
+  "gitHead": "584d4952868504a07a5741b8c37fbef6b10b61b2"
 }

package/dist/utils/timer.d.ts

@@ -1,2 +0,0 @@
-export declare const startTimer: () => [number, number];
-export declare const endTimer: ([startSecs, startNsecs]: [number, number]) => number;

package/dist/utils/timer.js

@@ -1,11 +0,0 @@
-import { hrtime } from 'process';
-const NANOSECS_TO_SECS = 1e9;
-export const startTimer = function () {
-    return hrtime();
-};
-// returns the time in nanoseconds
-export const endTimer = function ([startSecs, startNsecs]) {
-    const [endSecs, endNsecs] = hrtime();
-    const durationNs = (endSecs - startSecs) * NANOSECS_TO_SECS + endNsecs - startNsecs;
-    return durationNs;
-};